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"
174 #include "libiberty.h"
175 #include "safe-ctype.h"
176 #include "filenames.h"
179 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
182 typedef struct elf_section_list
184 Elf_Internal_Shdr
* hdr
;
185 struct elf_section_list
* next
;
188 /* Flag bits indicating particular types of dump. */
189 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
190 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
191 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
192 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
193 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
194 #define CTF_DUMP (1 << 5) /* The --ctf command line switch. */
195 #define SFRAME_DUMP (1 << 6) /* The --sframe command line switch. */
197 typedef unsigned char dump_type
;
199 /* A linked list of the section names for which dumps were requested. */
200 struct dump_list_entry
204 struct dump_list_entry
* next
;
207 /* A dynamic array of flags indicating for which sections a dump
208 has been requested via command line switches. */
211 dump_type
* dump_sects
;
212 unsigned int num_dump_sects
;
215 static struct dump_data cmdline
;
217 static struct dump_list_entry
* dump_sects_byname
;
219 char * program_name
= "readelf";
221 static bool show_name
= false;
222 static bool do_dynamic
= false;
223 static bool do_syms
= false;
224 static bool do_dyn_syms
= false;
225 static bool do_lto_syms
= false;
226 static bool do_reloc
= false;
227 static bool do_sections
= false;
228 static bool do_section_groups
= false;
229 static bool do_section_details
= false;
230 static bool do_segments
= false;
231 static bool do_unwind
= false;
232 static bool do_using_dynamic
= false;
233 static bool do_header
= false;
234 static bool do_dump
= false;
235 static bool do_version
= false;
236 static bool do_histogram
= false;
237 static bool do_debugging
= false;
238 static bool do_ctf
= false;
239 static bool do_sframe
= false;
240 static bool do_arch
= false;
241 static bool do_notes
= false;
242 static bool do_archive_index
= false;
243 static bool check_all
= false;
244 static bool is_32bit_elf
= false;
245 static bool decompress_dumps
= false;
246 static bool do_not_show_symbol_truncation
= false;
247 static bool do_demangle
= false; /* Pretty print C++ symbol names. */
248 static bool process_links
= false;
249 static bool dump_any_debugging
= false;
250 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
251 static int sym_base
= 0;
253 static char *dump_ctf_parent_name
;
254 static char *dump_ctf_symtab_name
;
255 static char *dump_ctf_strtab_name
;
259 struct group_list
* next
;
260 unsigned int section_index
;
265 struct group_list
* root
;
266 unsigned int group_index
;
269 typedef struct filedata
271 const char * file_name
;
275 Elf_Internal_Ehdr file_header
;
276 uint64_t archive_file_offset
;
277 uint64_t archive_file_size
;
278 /* Everything below this point is cleared out by free_filedata. */
279 Elf_Internal_Shdr
* section_headers
;
280 Elf_Internal_Phdr
* program_headers
;
282 uint64_t string_table_length
;
283 uint64_t dynamic_addr
;
284 uint64_t dynamic_size
;
285 uint64_t dynamic_nent
;
286 Elf_Internal_Dyn
* dynamic_section
;
287 Elf_Internal_Shdr
* dynamic_strtab_section
;
288 char * dynamic_strings
;
289 uint64_t dynamic_strings_length
;
290 Elf_Internal_Shdr
* dynamic_symtab_section
;
291 uint64_t num_dynamic_syms
;
292 Elf_Internal_Sym
* dynamic_symbols
;
293 uint64_t version_info
[16];
294 unsigned int dynamic_syminfo_nent
;
295 Elf_Internal_Syminfo
* dynamic_syminfo
;
296 uint64_t dynamic_syminfo_offset
;
301 uint64_t ngnubuckets
;
303 uint64_t * gnubuckets
;
304 uint64_t * gnuchains
;
307 char * program_interpreter
;
308 uint64_t dynamic_info
[DT_RELRENT
+ 1];
309 uint64_t dynamic_info_DT_GNU_HASH
;
310 uint64_t dynamic_info_DT_MIPS_XHASH
;
311 elf_section_list
* symtab_shndx_list
;
313 struct group
* section_groups
;
314 struct group
** section_headers_groups
;
315 /* A dynamic array of flags indicating for which sections a dump of
316 some kind has been requested. It is reset on a per-object file
317 basis and then initialised from the cmdline_dump_sects array,
318 the results of interpreting the -w switch, and the
319 dump_sects_byname list. */
320 struct dump_data dump
;
323 /* How to print a vma value. */
324 typedef enum print_mode
341 typedef enum unicode_display_type
349 } unicode_display_type
;
351 static unicode_display_type unicode_display
= unicode_default
;
361 /* Versioned symbol info. */
362 enum versioned_symbol_info
370 fseek64 (FILE *stream
, int64_t offset
, int whence
)
372 #if defined (HAVE_FSEEKO64)
379 return fseeko64 (stream
, o
, whence
);
380 #elif defined (HAVE_FSEEKO)
387 return fseeko (stream
, o
, whence
);
395 return fseek (stream
, o
, whence
);
399 static const char * get_symbol_version_string
400 (Filedata
*, bool, const char *, size_t, unsigned,
401 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
405 static inline const char *
406 section_name (const Filedata
*filedata
, const Elf_Internal_Shdr
*hdr
)
408 return filedata
->string_table
+ hdr
->sh_name
;
412 section_name_valid (const Filedata
*filedata
, const Elf_Internal_Shdr
*hdr
)
415 && filedata
->string_table
!= NULL
416 && hdr
->sh_name
< filedata
->string_table_length
);
419 static inline const char *
420 section_name_print (const Filedata
*filedata
, const Elf_Internal_Shdr
*hdr
)
424 if (filedata
->string_table
== NULL
)
425 return _("<no-strings>");
426 if (hdr
->sh_name
>= filedata
->string_table_length
)
427 return _("<corrupt>");
428 return section_name (filedata
, hdr
);
431 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
434 valid_symbol_name (const char *strtab
, size_t strtab_size
, uint64_t offset
)
436 return strtab
!= NULL
&& offset
< strtab_size
;
440 valid_dynamic_name (const Filedata
*filedata
, uint64_t offset
)
442 return valid_symbol_name (filedata
->dynamic_strings
,
443 filedata
->dynamic_strings_length
, offset
);
446 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
447 already been called and verified that the string exists. */
448 static inline const char *
449 get_dynamic_name (const Filedata
*filedata
, size_t offset
)
451 return filedata
->dynamic_strings
+ offset
;
454 #define REMOVE_ARCH_BITS(ADDR) \
457 if (filedata->file_header.e_machine == EM_ARM) \
462 /* Get the correct GNU hash section name. */
463 #define GNU_HASH_SECTION_NAME(filedata) \
464 filedata->dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
466 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
467 OFFSET + the offset of the current archive member, if we are examining an
468 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
469 allocate a buffer using malloc and fill that. In either case return the
470 pointer to the start of the retrieved data or NULL if something went wrong.
471 If something does go wrong and REASON is not NULL then emit an error
472 message using REASON as part of the context. */
483 uint64_t amt
= size
* nmemb
;
485 if (size
== 0 || nmemb
== 0)
488 /* If size_t is smaller than uint64_t, eg because you are building
489 on a 32-bit host, then make sure that when the sizes are cast to
490 size_t no information is lost. */
491 if ((size_t) size
!= size
492 || (size_t) nmemb
!= nmemb
493 || (size_t) amt
!= amt
494 || amt
/ size
!= nmemb
495 || (size_t) amt
+ 1 == 0)
498 error (_("Size overflow prevents reading %" PRIu64
499 " elements of size %" PRIu64
" for %s\n"),
500 nmemb
, size
, reason
);
504 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
505 attempting to allocate memory when the read is bound to fail. */
506 if (filedata
->archive_file_offset
> filedata
->file_size
507 || offset
> filedata
->file_size
- filedata
->archive_file_offset
508 || amt
> filedata
->file_size
- filedata
->archive_file_offset
- offset
)
511 error (_("Reading %" PRIu64
" bytes extends past end of file for %s\n"),
516 if (fseek64 (filedata
->handle
, filedata
->archive_file_offset
+ offset
,
520 error (_("Unable to seek to %#" PRIx64
" for %s\n"),
521 filedata
->archive_file_offset
+ offset
, reason
);
528 /* + 1 so that we can '\0' terminate invalid string table sections. */
529 mvar
= malloc ((size_t) amt
+ 1);
534 error (_("Out of memory allocating %" PRIu64
" bytes for %s\n"),
539 ((char *) mvar
)[amt
] = '\0';
542 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
545 error (_("Unable to read in %" PRIu64
" bytes of %s\n"),
555 /* Print a VMA value in the MODE specified.
556 Returns the number of characters displayed. */
559 print_vma (uint64_t vma
, print_mode mode
)
570 return nc
+ printf ("%16.16" PRIx64
, vma
);
571 return nc
+ printf ("%8.8" PRIx64
, vma
);
575 return printf ("%5" PRId64
, vma
);
581 return nc
+ printf ("%" PRIx64
, vma
);
587 return nc
+ printf ("%05" PRIx64
, vma
);
590 return printf ("%" PRId64
, vma
);
593 return printf ("%" PRIu64
, vma
);
596 return printf ("%5" PRIu64
, vma
);
599 return printf ("%" PRIo64
, vma
);
602 return printf ("%5" PRIo64
, vma
);
605 /* FIXME: Report unrecognised mode ? */
611 /* Display a symbol on stdout. Handles the display of control characters and
612 multibye characters (assuming the host environment supports them).
614 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
616 If truncation will happen and do_not_show_symbol_truncation is FALSE then display
617 abs(WIDTH) - 5 characters followed by "[...]".
619 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
620 padding as necessary.
622 Returns the number of emitted characters. */
625 print_symbol (signed int width
, const char * symbol
)
627 bool extra_padding
= false;
628 bool do_dots
= false;
629 signed int num_printed
= 0;
630 #ifdef HAVE_MBSTATE_T
633 unsigned int width_remaining
;
634 const void * alloced_symbol
= NULL
;
638 /* Keep the width positive. This helps the code below. */
640 extra_padding
= true;
646 /* Set the remaining width to a very large value.
647 This simplifies the code below. */
648 width_remaining
= INT_MAX
;
651 width_remaining
= width
;
652 if (! do_not_show_symbol_truncation
653 && (int) strlen (symbol
) > width
)
655 width_remaining
-= 5;
656 if ((int) width_remaining
< 0)
662 #ifdef HAVE_MBSTATE_T
663 /* Initialise the multibyte conversion state. */
664 memset (& state
, 0, sizeof (state
));
667 if (do_demangle
&& *symbol
)
669 const char * res
= cplus_demangle (symbol
, demangle_flags
);
672 alloced_symbol
= symbol
= res
;
675 while (width_remaining
)
678 const char c
= *symbol
++;
689 else if (ISCNTRL (c
))
691 /* Do not print control characters directly as they can affect terminal
692 settings. Such characters usually appear in the names generated
693 by the assembler for local labels. */
695 if (width_remaining
< 2)
698 printf ("^%c", c
+ 0x40);
699 width_remaining
-= 2;
704 if (width_remaining
< 5)
707 width_remaining
-= 5;
710 else if (unicode_display
!= unicode_locale
711 && unicode_display
!= unicode_default
)
713 /* Display unicode characters as something else. */
714 unsigned char bytes
[4];
727 bytes
[1] = *symbol
++;
729 if ((bytes
[1] & 0xc0) != 0x80)
732 /* Do not consume this character. It may only
733 be the first byte in the sequence that was
738 else if ((bytes
[0] & 0x20) == 0)
745 bytes
[2] = *symbol
++;
747 if ((bytes
[2] & 0xc0) != 0x80)
753 else if ((bytes
[0] & 0x10) == 0)
760 bytes
[3] = *symbol
++;
764 if ((bytes
[3] & 0xc0) != 0x80)
776 if (unicode_display
== unicode_invalid
)
779 if (unicode_display
== unicode_hex
|| ! is_utf8
)
783 if (width_remaining
< (nbytes
* 2) + 2)
786 putchar (is_utf8
? '<' : '{');
788 for (i
= 0; i
< nbytes
; i
++)
789 printf ("%02x", bytes
[i
]);
790 putchar (is_utf8
? '>' : '}');
794 if (unicode_display
== unicode_highlight
&& isatty (1))
795 printf ("\x1B[31;47m"); /* Red. */
800 if (width_remaining
< 6)
802 printf ("\\u%02x%02x",
803 (bytes
[0] & 0x1c) >> 2,
804 ((bytes
[0] & 0x03) << 6) | (bytes
[1] & 0x3f));
807 if (width_remaining
< 6)
809 printf ("\\u%02x%02x",
810 ((bytes
[0] & 0x0f) << 4) | ((bytes
[1] & 0x3c) >> 2),
811 ((bytes
[1] & 0x03) << 6) | (bytes
[2] & 0x3f));
814 if (width_remaining
< 8)
816 printf ("\\u%02x%02x%02x",
817 ((bytes
[0] & 0x07) << 6) | ((bytes
[1] & 0x3c) >> 2),
818 ((bytes
[1] & 0x03) << 6) | ((bytes
[2] & 0x3c) >> 2),
819 ((bytes
[2] & 0x03) << 6) | (bytes
[3] & 0x3f));
827 if (unicode_display
== unicode_highlight
&& isatty (1))
828 printf ("\033[0m"); /* Default colour. */
831 if (bytes
[nbytes
- 1] == 0)
836 #ifdef HAVE_MBSTATE_T
839 /* Let printf do the hard work of displaying multibyte characters. */
840 printf ("%.1s", symbol
- 1);
844 #ifdef HAVE_MBSTATE_T
845 /* Try to find out how many bytes made up the character that was
846 just printed. Advance the symbol pointer past the bytes that
848 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
852 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
858 num_printed
+= printf ("[...]");
860 if (extra_padding
&& num_printed
< width
)
862 /* Fill in the remaining spaces. */
863 printf ("%-*s", width
- num_printed
, " ");
867 free ((void *) alloced_symbol
);
871 /* Returns a pointer to a static buffer containing a printable version of
872 the given section's name. Like print_symbol, except that it does not try
873 to print multibyte characters, it just interprets them as hex values. */
876 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
878 #define MAX_PRINT_SEC_NAME_LEN 256
879 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
880 const char * name
= section_name_print (filedata
, sec
);
881 char * buf
= sec_name_buf
;
883 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
885 while ((c
= * name
++) != 0)
896 else if (ISPRINT (c
))
903 static char hex
[17] = "0123456789ABCDEF";
908 * buf
++ = hex
[(c
& 0xf0) >> 4];
909 * buf
++ = hex
[c
& 0x0f];
923 printable_section_name_from_index (Filedata
*filedata
, size_t ndx
)
925 if (ndx
>= filedata
->file_header
.e_shnum
)
926 return _("<corrupt>");
928 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
931 /* Return a pointer to section NAME, or NULL if no such section exists. */
933 static Elf_Internal_Shdr
*
934 find_section (Filedata
* filedata
, const char * name
)
938 if (filedata
->section_headers
== NULL
)
941 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
942 if (section_name_valid (filedata
, filedata
->section_headers
+ i
)
943 && streq (section_name (filedata
, filedata
->section_headers
+ i
),
945 return filedata
->section_headers
+ i
;
950 /* Return a pointer to a section containing ADDR, or NULL if no such
953 static Elf_Internal_Shdr
*
954 find_section_by_address (Filedata
* filedata
, uint64_t addr
)
958 if (filedata
->section_headers
== NULL
)
961 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
963 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
965 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
972 static Elf_Internal_Shdr
*
973 find_section_by_type (Filedata
* filedata
, unsigned int type
)
977 if (filedata
->section_headers
== NULL
)
980 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
982 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
984 if (sec
->sh_type
== type
)
991 /* Return a pointer to section NAME, or NULL if no such section exists,
992 restricted to the list of sections given in SET. */
994 static Elf_Internal_Shdr
*
995 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
999 if (filedata
->section_headers
== NULL
)
1004 while ((i
= *set
++) > 0)
1006 /* See PR 21156 for a reproducer. */
1007 if (i
>= filedata
->file_header
.e_shnum
)
1008 continue; /* FIXME: Should we issue an error message ? */
1010 if (section_name_valid (filedata
, filedata
->section_headers
+ i
)
1011 && streq (section_name (filedata
, filedata
->section_headers
+ i
),
1013 return filedata
->section_headers
+ i
;
1017 return find_section (filedata
, name
);
1020 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
1021 This OS has so many departures from the ELF standard that we test it at
1025 is_ia64_vms (Filedata
* filedata
)
1027 return filedata
->file_header
.e_machine
== EM_IA_64
1028 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
1031 /* Guess the relocation size commonly used by the specific machines. */
1034 guess_is_rela (unsigned int e_machine
)
1038 /* Targets that use REL relocations. */
1044 case EM_CYGNUS_D10V
:
1047 case EM_MIPS_RS3_LE
:
1048 case EM_CYGNUS_M32R
:
1055 /* Targets that use RELA relocations. */
1059 case EM_ADAPTEVA_EPIPHANY
:
1061 case EM_ALTERA_NIOS2
:
1063 case EM_ARC_COMPACT
:
1064 case EM_ARC_COMPACT2
:
1065 case EM_ARC_COMPACT3
:
1066 case EM_ARC_COMPACT3_64
:
1075 case EM_CYGNUS_D30V
:
1078 case EM_CYGNUS_FR30
:
1087 case EM_LATTICEMICO32
:
1096 case EM_CYGNUS_MN10200
:
1098 case EM_CYGNUS_MN10300
:
1116 case EM_SPARC32PLUS
:
1124 case EM_CYGNUS_V850
:
1134 case EM_MICROBLAZE_OLD
:
1135 case EM_WEBASSEMBLY
:
1156 warn (_("Don't know about relocations on this machine architecture\n"));
1161 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1162 Returns TRUE upon success, FALSE otherwise. If successful then a
1163 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
1164 and the number of relocs loaded is placed in *NRELASP. It is the caller's
1165 responsibility to free the allocated buffer. */
1168 slurp_rela_relocs (Filedata
*filedata
,
1169 uint64_t rel_offset
,
1171 Elf_Internal_Rela
**relasp
,
1174 Elf_Internal_Rela
* relas
;
1180 Elf32_External_Rela
* erelas
;
1182 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
1183 rel_size
, _("32-bit relocation data"));
1187 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
1189 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
1190 sizeof (Elf_Internal_Rela
));
1195 error (_("out of memory parsing relocs\n"));
1199 for (i
= 0; i
< nrelas
; i
++)
1201 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
1202 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
1203 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
1210 Elf64_External_Rela
* erelas
;
1212 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
1213 rel_size
, _("64-bit relocation data"));
1217 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
1219 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
1220 sizeof (Elf_Internal_Rela
));
1225 error (_("out of memory parsing relocs\n"));
1229 for (i
= 0; i
< nrelas
; i
++)
1231 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
1232 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
1233 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
1235 if (filedata
->file_header
.e_machine
== EM_MIPS
1236 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1238 /* In little-endian objects, r_info isn't really a
1239 64-bit little-endian value: it has a 32-bit
1240 little-endian symbol index followed by four
1241 individual byte fields. Reorder INFO
1243 uint64_t inf
= relas
[i
].r_info
;
1244 inf
= (((inf
& 0xffffffff) << 32)
1245 | ((inf
>> 56) & 0xff)
1246 | ((inf
>> 40) & 0xff00)
1247 | ((inf
>> 24) & 0xff0000)
1248 | ((inf
>> 8) & 0xff000000));
1249 relas
[i
].r_info
= inf
;
1261 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1262 Returns TRUE upon success, FALSE otherwise. If successful then a
1263 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1264 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1265 responsibility to free the allocated buffer. */
1268 slurp_rel_relocs (Filedata
*filedata
,
1269 uint64_t rel_offset
,
1271 Elf_Internal_Rela
**relsp
,
1274 Elf_Internal_Rela
* rels
;
1280 Elf32_External_Rel
* erels
;
1282 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1283 rel_size
, _("32-bit relocation data"));
1287 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1289 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1294 error (_("out of memory parsing relocs\n"));
1298 for (i
= 0; i
< nrels
; i
++)
1300 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1301 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1302 rels
[i
].r_addend
= 0;
1309 Elf64_External_Rel
* erels
;
1311 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1312 rel_size
, _("64-bit relocation data"));
1316 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1318 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1323 error (_("out of memory parsing relocs\n"));
1327 for (i
= 0; i
< nrels
; i
++)
1329 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1330 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1331 rels
[i
].r_addend
= 0;
1333 if (filedata
->file_header
.e_machine
== EM_MIPS
1334 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1336 /* In little-endian objects, r_info isn't really a
1337 64-bit little-endian value: it has a 32-bit
1338 little-endian symbol index followed by four
1339 individual byte fields. Reorder INFO
1341 uint64_t inf
= rels
[i
].r_info
;
1342 inf
= (((inf
& 0xffffffff) << 32)
1343 | ((inf
>> 56) & 0xff)
1344 | ((inf
>> 40) & 0xff00)
1345 | ((inf
>> 24) & 0xff0000)
1346 | ((inf
>> 8) & 0xff000000));
1347 rels
[i
].r_info
= inf
;
1360 slurp_relr_relocs (Filedata
*filedata
,
1361 uint64_t relr_offset
,
1367 size_t size
= 0, nentries
, i
;
1368 uint64_t base
= 0, addr
, entry
;
1370 relrs
= get_data (NULL
, filedata
, relr_offset
, 1, relr_size
,
1371 _("RELR relocation data"));
1376 nentries
= relr_size
/ sizeof (Elf32_External_Relr
);
1378 nentries
= relr_size
/ sizeof (Elf64_External_Relr
);
1379 for (i
= 0; i
< nentries
; i
++)
1382 entry
= BYTE_GET (((Elf32_External_Relr
*)relrs
)[i
].r_data
);
1384 entry
= BYTE_GET (((Elf64_External_Relr
*)relrs
)[i
].r_data
);
1385 if ((entry
& 1) == 0)
1388 while ((entry
>>= 1) != 0)
1389 if ((entry
& 1) == 1)
1393 *relrsp
= malloc (size
* sizeof (**relrsp
));
1394 if (*relrsp
== NULL
)
1397 error (_("out of memory parsing relocs\n"));
1402 for (i
= 0; i
< nentries
; i
++)
1404 const uint64_t entry_bytes
= is_32bit_elf
? 4 : 8;
1407 entry
= BYTE_GET (((Elf32_External_Relr
*)relrs
)[i
].r_data
);
1409 entry
= BYTE_GET (((Elf64_External_Relr
*)relrs
)[i
].r_data
);
1410 if ((entry
& 1) == 0)
1412 (*relrsp
)[size
++] = entry
;
1413 base
= entry
+ entry_bytes
;
1417 for (addr
= base
; (entry
>>= 1) != 0; addr
+= entry_bytes
)
1418 if ((entry
& 1) != 0)
1419 (*relrsp
)[size
++] = addr
;
1420 base
+= entry_bytes
* (entry_bytes
* CHAR_BIT
- 1);
1429 /* Returns the reloc type extracted from the reloc info field. */
1432 get_reloc_type (Filedata
* filedata
, uint64_t reloc_info
)
1435 return ELF32_R_TYPE (reloc_info
);
1437 switch (filedata
->file_header
.e_machine
)
1440 /* Note: We assume that reloc_info has already been adjusted for us. */
1441 return ELF64_MIPS_R_TYPE (reloc_info
);
1444 return ELF64_R_TYPE_ID (reloc_info
);
1447 return ELF64_R_TYPE (reloc_info
);
1451 /* Return the symbol index extracted from the reloc info field. */
1454 get_reloc_symindex (uint64_t reloc_info
)
1456 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1460 uses_msp430x_relocs (Filedata
* filedata
)
1463 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1464 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1465 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1466 /* TI compiler uses ELFOSABI_NONE. */
1467 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1470 /* Display the contents of the relocation data found at the specified
1474 dump_relocations (Filedata
*filedata
,
1475 uint64_t rel_offset
,
1477 Elf_Internal_Sym
*symtab
,
1481 relocation_type rel_type
,
1485 Elf_Internal_Rela
* rels
;
1488 if (rel_type
== reltype_unknown
)
1489 rel_type
= guess_is_rela (filedata
->file_header
.e_machine
) ? reltype_rela
: reltype_rel
;
1491 if (rel_type
== reltype_rela
)
1493 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1496 else if (rel_type
== reltype_rel
)
1498 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1501 else if (rel_type
== reltype_relr
)
1505 = is_32bit_elf
? "%08" PRIx64
"\n" : "%016" PRIx64
"\n";
1507 if (!slurp_relr_relocs (filedata
, rel_offset
, rel_size
, &relrs
,
1511 printf (ngettext (" %" PRIu64
" offset\n",
1512 " %" PRIu64
" offsets\n", rel_size
),
1514 for (i
= 0; i
< rel_size
; i
++)
1515 printf (format
, relrs
[i
]);
1522 if (rel_type
== reltype_rela
)
1525 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1527 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1532 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1534 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1539 if (rel_type
== reltype_rela
)
1542 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1544 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1549 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1551 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1555 for (i
= 0; i
< rel_size
; i
++)
1560 uint64_t symtab_index
;
1563 offset
= rels
[i
].r_offset
;
1564 inf
= rels
[i
].r_info
;
1566 type
= get_reloc_type (filedata
, inf
);
1567 symtab_index
= get_reloc_symindex (inf
);
1571 printf ("%8.8lx %8.8lx ",
1572 (unsigned long) offset
& 0xffffffff,
1573 (unsigned long) inf
& 0xffffffff);
1578 ? "%16.16" PRIx64
" %16.16" PRIx64
" "
1579 : "%12.12" PRIx64
" %12.12" PRIx64
" ",
1583 switch (filedata
->file_header
.e_machine
)
1590 rtype
= elf_aarch64_reloc_type (type
);
1594 case EM_CYGNUS_M32R
:
1595 rtype
= elf_m32r_reloc_type (type
);
1600 rtype
= elf_i386_reloc_type (type
);
1605 rtype
= elf_m68hc11_reloc_type (type
);
1609 rtype
= elf_s12z_reloc_type (type
);
1613 rtype
= elf_m68k_reloc_type (type
);
1617 rtype
= elf_i960_reloc_type (type
);
1622 rtype
= elf_avr_reloc_type (type
);
1625 case EM_OLD_SPARCV9
:
1626 case EM_SPARC32PLUS
:
1629 rtype
= elf_sparc_reloc_type (type
);
1633 rtype
= elf_spu_reloc_type (type
);
1637 rtype
= v800_reloc_type (type
);
1640 case EM_CYGNUS_V850
:
1641 rtype
= v850_reloc_type (type
);
1645 case EM_CYGNUS_D10V
:
1646 rtype
= elf_d10v_reloc_type (type
);
1650 case EM_CYGNUS_D30V
:
1651 rtype
= elf_d30v_reloc_type (type
);
1655 rtype
= elf_dlx_reloc_type (type
);
1659 rtype
= elf_sh_reloc_type (type
);
1663 case EM_CYGNUS_MN10300
:
1664 rtype
= elf_mn10300_reloc_type (type
);
1668 case EM_CYGNUS_MN10200
:
1669 rtype
= elf_mn10200_reloc_type (type
);
1673 case EM_CYGNUS_FR30
:
1674 rtype
= elf_fr30_reloc_type (type
);
1678 rtype
= elf_frv_reloc_type (type
);
1682 rtype
= elf_csky_reloc_type (type
);
1686 rtype
= elf_ft32_reloc_type (type
);
1690 rtype
= elf_mcore_reloc_type (type
);
1694 rtype
= elf_mmix_reloc_type (type
);
1698 rtype
= elf_moxie_reloc_type (type
);
1702 if (uses_msp430x_relocs (filedata
))
1704 rtype
= elf_msp430x_reloc_type (type
);
1709 rtype
= elf_msp430_reloc_type (type
);
1713 rtype
= elf_nds32_reloc_type (type
);
1717 rtype
= elf_ppc_reloc_type (type
);
1721 rtype
= elf_ppc64_reloc_type (type
);
1725 case EM_MIPS_RS3_LE
:
1726 rtype
= elf_mips_reloc_type (type
);
1730 rtype
= elf_riscv_reloc_type (type
);
1734 rtype
= elf_alpha_reloc_type (type
);
1738 rtype
= elf_arm_reloc_type (type
);
1742 case EM_ARC_COMPACT
:
1743 case EM_ARC_COMPACT2
:
1744 case EM_ARC_COMPACT3
:
1745 case EM_ARC_COMPACT3_64
:
1746 rtype
= elf_arc_reloc_type (type
);
1750 rtype
= elf_hppa_reloc_type (type
);
1756 rtype
= elf_h8_reloc_type (type
);
1760 rtype
= elf_or1k_reloc_type (type
);
1765 rtype
= elf_pj_reloc_type (type
);
1768 rtype
= elf_ia64_reloc_type (type
);
1772 rtype
= elf_cris_reloc_type (type
);
1776 rtype
= elf_i860_reloc_type (type
);
1782 rtype
= elf_x86_64_reloc_type (type
);
1786 rtype
= i370_reloc_type (type
);
1791 rtype
= elf_s390_reloc_type (type
);
1795 rtype
= elf_score_reloc_type (type
);
1799 rtype
= elf_xstormy16_reloc_type (type
);
1803 rtype
= elf_crx_reloc_type (type
);
1807 rtype
= elf_vax_reloc_type (type
);
1811 rtype
= elf_visium_reloc_type (type
);
1815 rtype
= elf_bpf_reloc_type (type
);
1818 case EM_ADAPTEVA_EPIPHANY
:
1819 rtype
= elf_epiphany_reloc_type (type
);
1824 rtype
= elf_ip2k_reloc_type (type
);
1828 rtype
= elf_iq2000_reloc_type (type
);
1833 rtype
= elf_xtensa_reloc_type (type
);
1836 case EM_LATTICEMICO32
:
1837 rtype
= elf_lm32_reloc_type (type
);
1842 rtype
= elf_m32c_reloc_type (type
);
1846 rtype
= elf_mt_reloc_type (type
);
1850 rtype
= elf_bfin_reloc_type (type
);
1854 rtype
= elf_mep_reloc_type (type
);
1858 rtype
= elf_cr16_reloc_type (type
);
1862 case EM_MICROBLAZE_OLD
:
1863 rtype
= elf_microblaze_reloc_type (type
);
1867 rtype
= elf_rl78_reloc_type (type
);
1871 rtype
= elf_rx_reloc_type (type
);
1875 rtype
= elf_metag_reloc_type (type
);
1879 rtype
= elf_tic6x_reloc_type (type
);
1883 rtype
= elf_tilegx_reloc_type (type
);
1887 rtype
= elf_tilepro_reloc_type (type
);
1890 case EM_WEBASSEMBLY
:
1891 rtype
= elf_wasm32_reloc_type (type
);
1895 rtype
= elf_xgate_reloc_type (type
);
1898 case EM_ALTERA_NIOS2
:
1899 rtype
= elf_nios2_reloc_type (type
);
1903 rtype
= elf_pru_reloc_type (type
);
1907 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
1908 rtype
= elf_nfp3200_reloc_type (type
);
1910 rtype
= elf_nfp_reloc_type (type
);
1914 rtype
= elf_z80_reloc_type (type
);
1918 rtype
= elf_loongarch_reloc_type (type
);
1922 rtype
= elf_amdgpu_reloc_type (type
);
1927 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1929 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1931 if (filedata
->file_header
.e_machine
== EM_ALPHA
1933 && streq (rtype
, "R_ALPHA_LITUSE")
1934 && rel_type
== reltype_rela
)
1936 switch (rels
[i
].r_addend
)
1938 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1939 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1940 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1941 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1942 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1943 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1944 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1945 default: rtype
= NULL
;
1949 printf (" (%s)", rtype
);
1953 printf (_("<unknown addend: %" PRIx64
">"),
1958 else if (symtab_index
)
1960 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1962 error (_(" bad symbol index: %08lx in reloc\n"),
1963 (unsigned long) symtab_index
);
1968 Elf_Internal_Sym
* psym
;
1969 const char * version_string
;
1970 enum versioned_symbol_info sym_info
;
1971 unsigned short vna_other
;
1973 psym
= symtab
+ symtab_index
;
1976 = get_symbol_version_string (filedata
, is_dynsym
,
1985 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1989 unsigned int width
= is_32bit_elf
? 8 : 14;
1991 /* Relocations against GNU_IFUNC symbols do not use the value
1992 of the symbol as the address to relocate against. Instead
1993 they invoke the function named by the symbol and use its
1994 result as the address for relocation.
1996 To indicate this to the user, do not display the value of
1997 the symbol in the "Symbols's Value" field. Instead show
1998 its name followed by () as a hint that the symbol is
2002 || psym
->st_name
== 0
2003 || psym
->st_name
>= strtablen
)
2006 name
= strtab
+ psym
->st_name
;
2008 len
= print_symbol (width
, name
);
2010 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
2012 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
2016 print_vma (psym
->st_value
, LONG_HEX
);
2018 printf (is_32bit_elf
? " " : " ");
2021 if (psym
->st_name
== 0)
2023 const char * sec_name
= "<null>";
2026 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
2028 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
2029 && filedata
->section_headers
!= NULL
)
2030 sec_name
= section_name_print (filedata
,
2031 filedata
->section_headers
2033 else if (psym
->st_shndx
== SHN_ABS
)
2035 else if (psym
->st_shndx
== SHN_COMMON
)
2036 sec_name
= "COMMON";
2037 else if ((filedata
->file_header
.e_machine
== EM_MIPS
2038 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
2039 || (filedata
->file_header
.e_machine
== EM_TI_C6000
2040 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
2041 sec_name
= "SCOMMON";
2042 else if (filedata
->file_header
.e_machine
== EM_MIPS
2043 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
2044 sec_name
= "SUNDEF";
2045 else if ((filedata
->file_header
.e_machine
== EM_X86_64
2046 || filedata
->file_header
.e_machine
== EM_L1OM
2047 || filedata
->file_header
.e_machine
== EM_K1OM
)
2048 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
2049 sec_name
= "LARGE_COMMON";
2050 else if (filedata
->file_header
.e_machine
== EM_IA_64
2051 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
2052 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
2053 sec_name
= "ANSI_COM";
2054 else if (is_ia64_vms (filedata
)
2055 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
2056 sec_name
= "VMS_SYMVEC";
2059 sprintf (name_buf
, "<section 0x%x>",
2060 (unsigned int) psym
->st_shndx
);
2061 sec_name
= name_buf
;
2064 print_symbol (22, sec_name
);
2066 else if (strtab
== NULL
)
2067 printf (_("<string table index: %3ld>"), psym
->st_name
);
2068 else if (psym
->st_name
>= strtablen
)
2070 error (_("<corrupt string table index: %3ld>\n"),
2076 print_symbol (22, strtab
+ psym
->st_name
);
2078 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
2082 if (rel_type
== reltype_rela
)
2084 uint64_t off
= rels
[i
].r_addend
;
2086 if ((int64_t) off
< 0)
2087 printf (" - %" PRIx64
, -off
);
2089 printf (" + %" PRIx64
, off
);
2093 else if (rel_type
== reltype_rela
)
2095 uint64_t off
= rels
[i
].r_addend
;
2097 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
2098 if ((int64_t) off
< 0)
2099 printf ("-%" PRIx64
, -off
);
2101 printf ("%" PRIx64
, off
);
2104 if (filedata
->file_header
.e_machine
== EM_SPARCV9
2106 && streq (rtype
, "R_SPARC_OLO10"))
2107 printf (" + %" PRIx64
, ELF64_R_TYPE_DATA (inf
));
2111 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
2113 uint64_t type2
= ELF64_MIPS_R_TYPE2 (inf
);
2114 uint64_t type3
= ELF64_MIPS_R_TYPE3 (inf
);
2115 const char * rtype2
= elf_mips_reloc_type (type2
);
2116 const char * rtype3
= elf_mips_reloc_type (type3
);
2118 printf (" Type2: ");
2121 printf (_("unrecognized: %-7lx"),
2122 (unsigned long) type2
& 0xffffffff);
2124 printf ("%-17.17s", rtype2
);
2126 printf ("\n Type3: ");
2129 printf (_("unrecognized: %-7lx"),
2130 (unsigned long) type3
& 0xffffffff);
2132 printf ("%-17.17s", rtype3
);
2144 get_aarch64_dynamic_type (unsigned long type
)
2148 case DT_AARCH64_BTI_PLT
: return "AARCH64_BTI_PLT";
2149 case DT_AARCH64_PAC_PLT
: return "AARCH64_PAC_PLT";
2150 case DT_AARCH64_VARIANT_PCS
: return "AARCH64_VARIANT_PCS";
2157 get_mips_dynamic_type (unsigned long type
)
2161 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
2162 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
2163 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
2164 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
2165 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
2166 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
2167 case DT_MIPS_MSYM
: return "MIPS_MSYM";
2168 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2169 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2170 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
2171 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
2172 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
2173 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
2174 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
2175 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
2176 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
2177 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
2178 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
2179 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
2180 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
2181 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
2182 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
2183 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
2184 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
2185 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
2186 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
2187 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
2188 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
2189 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
2190 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
2191 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2192 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
2193 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
2194 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
2195 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
2196 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2197 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
2198 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
2199 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
2200 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
2201 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
2202 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
2203 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
2204 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
2205 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
2206 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
2207 case DT_MIPS_XHASH
: return "MIPS_XHASH";
2214 get_sparc64_dynamic_type (unsigned long type
)
2218 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
2225 get_ppc_dynamic_type (unsigned long type
)
2229 case DT_PPC_GOT
: return "PPC_GOT";
2230 case DT_PPC_OPT
: return "PPC_OPT";
2237 get_ppc64_dynamic_type (unsigned long type
)
2241 case DT_PPC64_GLINK
: return "PPC64_GLINK";
2242 case DT_PPC64_OPD
: return "PPC64_OPD";
2243 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
2244 case DT_PPC64_OPT
: return "PPC64_OPT";
2251 get_parisc_dynamic_type (unsigned long type
)
2255 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
2256 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
2257 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
2258 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
2259 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
2260 case DT_HP_PREINIT
: return "HP_PREINIT";
2261 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
2262 case DT_HP_NEEDED
: return "HP_NEEDED";
2263 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
2264 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
2265 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
2266 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
2267 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
2268 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
2269 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
2270 case DT_HP_FILTERED
: return "HP_FILTERED";
2271 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
2272 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
2273 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
2274 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
2275 case DT_PLT
: return "PLT";
2276 case DT_PLT_SIZE
: return "PLT_SIZE";
2277 case DT_DLT
: return "DLT";
2278 case DT_DLT_SIZE
: return "DLT_SIZE";
2285 get_ia64_dynamic_type (unsigned long type
)
2289 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
2290 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
2291 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
2292 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
2293 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
2294 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
2295 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
2296 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
2297 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
2298 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
2299 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
2300 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
2301 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
2302 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
2303 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
2304 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
2305 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
2306 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
2307 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
2308 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
2309 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
2310 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
2311 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
2312 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
2313 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
2314 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
2315 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
2316 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
2317 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
2318 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
2319 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
2326 get_solaris_section_type (unsigned long type
)
2330 case 0x6fffffee: return "SUNW_ancillary";
2331 case 0x6fffffef: return "SUNW_capchain";
2332 case 0x6ffffff0: return "SUNW_capinfo";
2333 case 0x6ffffff1: return "SUNW_symsort";
2334 case 0x6ffffff2: return "SUNW_tlssort";
2335 case 0x6ffffff3: return "SUNW_LDYNSYM";
2336 case 0x6ffffff4: return "SUNW_dof";
2337 case 0x6ffffff5: return "SUNW_cap";
2338 case 0x6ffffff6: return "SUNW_SIGNATURE";
2339 case 0x6ffffff7: return "SUNW_ANNOTATE";
2340 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2341 case 0x6ffffff9: return "SUNW_DEBUG";
2342 case 0x6ffffffa: return "SUNW_move";
2343 case 0x6ffffffb: return "SUNW_COMDAT";
2344 case 0x6ffffffc: return "SUNW_syminfo";
2345 case 0x6ffffffd: return "SUNW_verdef";
2346 case 0x6ffffffe: return "SUNW_verneed";
2347 case 0x6fffffff: return "SUNW_versym";
2348 case 0x70000000: return "SPARC_GOTDATA";
2349 default: return NULL
;
2354 get_alpha_dynamic_type (unsigned long type
)
2358 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2359 default: return NULL
;
2364 get_score_dynamic_type (unsigned long type
)
2368 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2369 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2370 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2371 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2372 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2373 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2374 default: return NULL
;
2379 get_tic6x_dynamic_type (unsigned long type
)
2383 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2384 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2385 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2386 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2387 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2388 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2389 default: return NULL
;
2394 get_nios2_dynamic_type (unsigned long type
)
2398 case DT_NIOS2_GP
: return "NIOS2_GP";
2399 default: return NULL
;
2404 get_solaris_dynamic_type (unsigned long type
)
2408 case 0x6000000d: return "SUNW_AUXILIARY";
2409 case 0x6000000e: return "SUNW_RTLDINF";
2410 case 0x6000000f: return "SUNW_FILTER";
2411 case 0x60000010: return "SUNW_CAP";
2412 case 0x60000011: return "SUNW_SYMTAB";
2413 case 0x60000012: return "SUNW_SYMSZ";
2414 case 0x60000013: return "SUNW_SORTENT";
2415 case 0x60000014: return "SUNW_SYMSORT";
2416 case 0x60000015: return "SUNW_SYMSORTSZ";
2417 case 0x60000016: return "SUNW_TLSSORT";
2418 case 0x60000017: return "SUNW_TLSSORTSZ";
2419 case 0x60000018: return "SUNW_CAPINFO";
2420 case 0x60000019: return "SUNW_STRPAD";
2421 case 0x6000001a: return "SUNW_CAPCHAIN";
2422 case 0x6000001b: return "SUNW_LDMACH";
2423 case 0x6000001d: return "SUNW_CAPCHAINENT";
2424 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2425 case 0x60000021: return "SUNW_PARENT";
2426 case 0x60000023: return "SUNW_ASLR";
2427 case 0x60000025: return "SUNW_RELAX";
2428 case 0x60000029: return "SUNW_NXHEAP";
2429 case 0x6000002b: return "SUNW_NXSTACK";
2431 case 0x70000001: return "SPARC_REGISTER";
2432 case 0x7ffffffd: return "AUXILIARY";
2433 case 0x7ffffffe: return "USED";
2434 case 0x7fffffff: return "FILTER";
2436 default: return NULL
;
2441 get_riscv_dynamic_type (unsigned long type
)
2445 case DT_RISCV_VARIANT_CC
: return "RISCV_VARIANT_CC";
2452 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2454 static char buff
[64];
2458 case DT_NULL
: return "NULL";
2459 case DT_NEEDED
: return "NEEDED";
2460 case DT_PLTRELSZ
: return "PLTRELSZ";
2461 case DT_PLTGOT
: return "PLTGOT";
2462 case DT_HASH
: return "HASH";
2463 case DT_STRTAB
: return "STRTAB";
2464 case DT_SYMTAB
: return "SYMTAB";
2465 case DT_RELA
: return "RELA";
2466 case DT_RELASZ
: return "RELASZ";
2467 case DT_RELAENT
: return "RELAENT";
2468 case DT_STRSZ
: return "STRSZ";
2469 case DT_SYMENT
: return "SYMENT";
2470 case DT_INIT
: return "INIT";
2471 case DT_FINI
: return "FINI";
2472 case DT_SONAME
: return "SONAME";
2473 case DT_RPATH
: return "RPATH";
2474 case DT_SYMBOLIC
: return "SYMBOLIC";
2475 case DT_REL
: return "REL";
2476 case DT_RELSZ
: return "RELSZ";
2477 case DT_RELENT
: return "RELENT";
2478 case DT_RELR
: return "RELR";
2479 case DT_RELRSZ
: return "RELRSZ";
2480 case DT_RELRENT
: return "RELRENT";
2481 case DT_PLTREL
: return "PLTREL";
2482 case DT_DEBUG
: return "DEBUG";
2483 case DT_TEXTREL
: return "TEXTREL";
2484 case DT_JMPREL
: return "JMPREL";
2485 case DT_BIND_NOW
: return "BIND_NOW";
2486 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2487 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2488 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2489 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2490 case DT_RUNPATH
: return "RUNPATH";
2491 case DT_FLAGS
: return "FLAGS";
2493 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2494 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2495 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2497 case DT_CHECKSUM
: return "CHECKSUM";
2498 case DT_PLTPADSZ
: return "PLTPADSZ";
2499 case DT_MOVEENT
: return "MOVEENT";
2500 case DT_MOVESZ
: return "MOVESZ";
2501 case DT_FEATURE
: return "FEATURE";
2502 case DT_POSFLAG_1
: return "POSFLAG_1";
2503 case DT_SYMINSZ
: return "SYMINSZ";
2504 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2506 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2507 case DT_CONFIG
: return "CONFIG";
2508 case DT_DEPAUDIT
: return "DEPAUDIT";
2509 case DT_AUDIT
: return "AUDIT";
2510 case DT_PLTPAD
: return "PLTPAD";
2511 case DT_MOVETAB
: return "MOVETAB";
2512 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2514 case DT_VERSYM
: return "VERSYM";
2516 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2517 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2518 case DT_RELACOUNT
: return "RELACOUNT";
2519 case DT_RELCOUNT
: return "RELCOUNT";
2520 case DT_FLAGS_1
: return "FLAGS_1";
2521 case DT_VERDEF
: return "VERDEF";
2522 case DT_VERDEFNUM
: return "VERDEFNUM";
2523 case DT_VERNEED
: return "VERNEED";
2524 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2526 case DT_AUXILIARY
: return "AUXILIARY";
2527 case DT_USED
: return "USED";
2528 case DT_FILTER
: return "FILTER";
2530 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2531 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2532 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2533 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2534 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2535 case DT_GNU_HASH
: return "GNU_HASH";
2536 case DT_GNU_FLAGS_1
: return "GNU_FLAGS_1";
2539 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2541 const char * result
;
2543 switch (filedata
->file_header
.e_machine
)
2546 result
= get_aarch64_dynamic_type (type
);
2549 case EM_MIPS_RS3_LE
:
2550 result
= get_mips_dynamic_type (type
);
2553 result
= get_sparc64_dynamic_type (type
);
2556 result
= get_ppc_dynamic_type (type
);
2559 result
= get_ppc64_dynamic_type (type
);
2562 result
= get_ia64_dynamic_type (type
);
2565 result
= get_alpha_dynamic_type (type
);
2568 result
= get_score_dynamic_type (type
);
2571 result
= get_tic6x_dynamic_type (type
);
2573 case EM_ALTERA_NIOS2
:
2574 result
= get_nios2_dynamic_type (type
);
2577 result
= get_riscv_dynamic_type (type
);
2580 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2581 result
= get_solaris_dynamic_type (type
);
2590 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2592 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2593 || (filedata
->file_header
.e_machine
== EM_PARISC
2594 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2596 const char * result
;
2598 switch (filedata
->file_header
.e_machine
)
2601 result
= get_parisc_dynamic_type (type
);
2604 result
= get_ia64_dynamic_type (type
);
2607 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2608 result
= get_solaris_dynamic_type (type
);
2617 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2621 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2627 static bool get_program_headers (Filedata
*);
2628 static bool get_dynamic_section (Filedata
*);
2631 locate_dynamic_section (Filedata
*filedata
)
2633 uint64_t dynamic_addr
= 0;
2634 uint64_t dynamic_size
= 0;
2636 if (filedata
->file_header
.e_phnum
!= 0
2637 && get_program_headers (filedata
))
2639 Elf_Internal_Phdr
*segment
;
2642 for (i
= 0, segment
= filedata
->program_headers
;
2643 i
< filedata
->file_header
.e_phnum
;
2646 if (segment
->p_type
== PT_DYNAMIC
)
2648 dynamic_addr
= segment
->p_offset
;
2649 dynamic_size
= segment
->p_filesz
;
2651 if (filedata
->section_headers
!= NULL
)
2653 Elf_Internal_Shdr
*sec
;
2655 sec
= find_section (filedata
, ".dynamic");
2658 if (sec
->sh_size
== 0
2659 || sec
->sh_type
== SHT_NOBITS
)
2666 dynamic_addr
= sec
->sh_offset
;
2667 dynamic_size
= sec
->sh_size
;
2672 if (dynamic_addr
> filedata
->file_size
2673 || (dynamic_size
> filedata
->file_size
- dynamic_addr
))
2682 filedata
->dynamic_addr
= dynamic_addr
;
2683 filedata
->dynamic_size
= dynamic_size
? dynamic_size
: 1;
2687 is_pie (Filedata
*filedata
)
2689 Elf_Internal_Dyn
*entry
;
2691 if (filedata
->dynamic_size
== 0)
2692 locate_dynamic_section (filedata
);
2693 if (filedata
->dynamic_size
<= 1)
2696 if (!get_dynamic_section (filedata
))
2699 for (entry
= filedata
->dynamic_section
;
2700 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
2703 if (entry
->d_tag
== DT_FLAGS_1
)
2705 if ((entry
->d_un
.d_val
& DF_1_PIE
) != 0)
2714 get_file_type (Filedata
*filedata
)
2716 unsigned e_type
= filedata
->file_header
.e_type
;
2717 static char buff
[64];
2721 case ET_NONE
: return _("NONE (None)");
2722 case ET_REL
: return _("REL (Relocatable file)");
2723 case ET_EXEC
: return _("EXEC (Executable file)");
2725 if (is_pie (filedata
))
2726 return _("DYN (Position-Independent Executable file)");
2728 return _("DYN (Shared object file)");
2729 case ET_CORE
: return _("CORE (Core file)");
2732 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2733 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2734 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2735 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2737 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2743 get_machine_name (unsigned e_machine
)
2745 static char buff
[64]; /* XXX */
2749 /* Please keep this switch table sorted by increasing EM_ value. */
2751 case EM_NONE
: return _("None");
2752 case EM_M32
: return "WE32100";
2753 case EM_SPARC
: return "Sparc";
2754 case EM_386
: return "Intel 80386";
2755 case EM_68K
: return "MC68000";
2756 case EM_88K
: return "MC88000";
2757 case EM_IAMCU
: return "Intel MCU";
2758 case EM_860
: return "Intel 80860";
2759 case EM_MIPS
: return "MIPS R3000";
2760 case EM_S370
: return "IBM System/370";
2762 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2763 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2764 case EM_PARISC
: return "HPPA";
2765 case EM_VPP550
: return "Fujitsu VPP500";
2766 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2767 case EM_960
: return "Intel 80960";
2768 case EM_PPC
: return "PowerPC";
2770 case EM_PPC64
: return "PowerPC64";
2772 case EM_S390
: return "IBM S/390";
2773 case EM_SPU
: return "SPU";
2775 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2776 case EM_FR20
: return "Fujitsu FR20";
2777 case EM_RH32
: return "TRW RH32";
2778 case EM_MCORE
: return "MCORE";
2780 case EM_ARM
: return "ARM";
2781 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2782 case EM_SH
: return "Renesas / SuperH SH";
2783 case EM_SPARCV9
: return "Sparc v9";
2784 case EM_TRICORE
: return "Siemens Tricore";
2785 case EM_ARC
: return "ARC";
2786 case EM_H8_300
: return "Renesas H8/300";
2787 case EM_H8_300H
: return "Renesas H8/300H";
2788 case EM_H8S
: return "Renesas H8S";
2789 case EM_H8_500
: return "Renesas H8/500";
2791 case EM_IA_64
: return "Intel IA-64";
2792 case EM_MIPS_X
: return "Stanford MIPS-X";
2793 case EM_COLDFIRE
: return "Motorola Coldfire";
2794 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2795 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2796 case EM_PCP
: return "Siemens PCP";
2797 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2798 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2799 case EM_STARCORE
: return "Motorola Star*Core processor";
2800 case EM_ME16
: return "Toyota ME16 processor";
2802 case EM_ST100
: return "STMicroelectronics ST100 processor";
2803 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2804 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2805 case EM_PDSP
: return "Sony DSP processor";
2806 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2807 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2808 case EM_FX66
: return "Siemens FX66 microcontroller";
2809 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2810 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2811 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2813 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2814 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2815 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2816 case EM_SVX
: return "Silicon Graphics SVx";
2817 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2818 case EM_VAX
: return "Digital VAX";
2819 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2820 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2821 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2822 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2824 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2825 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2826 case EM_PRISM
: return "Vitesse Prism";
2828 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2829 case EM_CYGNUS_FR30
:
2830 case EM_FR30
: return "Fujitsu FR30";
2831 case EM_CYGNUS_D10V
:
2832 case EM_D10V
: return "d10v";
2833 case EM_CYGNUS_D30V
:
2834 case EM_D30V
: return "d30v";
2835 case EM_CYGNUS_V850
:
2836 case EM_V850
: return "Renesas V850";
2837 case EM_CYGNUS_M32R
:
2838 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2839 case EM_CYGNUS_MN10300
:
2840 case EM_MN10300
: return "mn10300";
2842 case EM_CYGNUS_MN10200
:
2843 case EM_MN10200
: return "mn10200";
2844 case EM_PJ
: return "picoJava";
2845 case EM_OR1K
: return "OpenRISC 1000";
2846 case EM_ARC_COMPACT
: return "ARCompact";
2848 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2849 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2850 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2851 case EM_NS32K
: return "National Semiconductor 32000 series";
2852 case EM_TPC
: return "Tenor Network TPC processor";
2853 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2855 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2857 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2858 case EM_MAX
: return "MAX Processor";
2859 case EM_CR
: return "National Semiconductor CompactRISC";
2860 case EM_F2MC16
: return "Fujitsu F2MC16";
2861 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2862 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2863 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2864 case EM_SEP
: return "Sharp embedded microprocessor";
2865 case EM_ARCA
: return "Arca RISC microprocessor";
2867 case EM_UNICORE
: return "Unicore";
2868 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2869 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2870 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2871 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2872 case EM_XGATE
: return "Motorola XGATE embedded processor";
2874 case EM_XC16X
: return "Infineon Technologies xc16x";
2875 case EM_M16C
: return "Renesas M16C series microprocessors";
2876 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2877 case EM_CE
: return "Freescale Communication Engine RISC core";
2879 case EM_M32C
: return "Renesas M32c";
2881 case EM_TSK3000
: return "Altium TSK3000 core";
2882 case EM_RS08
: return "Freescale RS08 embedded processor";
2883 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2884 case EM_SCORE
: return "SUNPLUS S+Core";
2885 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2886 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2887 case EM_LATTICEMICO32
: return "Lattice Mico32";
2888 case EM_SE_C17
: return "Seiko Epson C17 family";
2890 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2891 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2892 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2893 case EM_TI_PRU
: return "TI PRU I/O processor";
2895 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2896 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2897 case EM_R32C
: return "Renesas R32C series microprocessors";
2898 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2899 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2900 case EM_8051
: return "Intel 8051 and variants";
2901 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2902 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2903 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2904 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2906 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2907 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2908 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2909 case EM_RX
: return "Renesas RX";
2910 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2911 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2912 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2915 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2916 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2917 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2919 case EM_L1OM
: return "Intel L1OM";
2920 case EM_K1OM
: return "Intel K1OM";
2921 case EM_INTEL182
: return "Intel (reserved)";
2922 case EM_AARCH64
: return "AArch64";
2923 case EM_ARM184
: return "ARM (reserved)";
2924 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2925 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2926 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2927 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2929 case EM_CUDA
: return "NVIDIA CUDA architecture";
2930 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2931 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2932 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2933 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2934 case EM_ARC_COMPACT2
: return "ARCv2";
2935 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2936 case EM_RL78
: return "Renesas RL78";
2937 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2938 case EM_78K0R
: return "Renesas 78K0R";
2940 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2941 case EM_BA1
: return "Beyond BA1 CPU architecture";
2942 case EM_BA2
: return "Beyond BA2 CPU architecture";
2943 case EM_XCORE
: return "XMOS xCORE processor family";
2944 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2945 case EM_INTELGT
: return "Intel Graphics Technology";
2947 case EM_KM32
: return "KM211 KM32 32-bit processor";
2948 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2949 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2950 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2951 case EM_KVARC
: return "KM211 KVARC processor";
2952 case EM_CDP
: return "Paneve CDP architecture family";
2953 case EM_COGE
: return "Cognitive Smart Memory Processor";
2954 case EM_COOL
: return "Bluechip Systems CoolEngine";
2955 case EM_NORC
: return "Nanoradio Optimized RISC";
2956 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2958 case EM_Z80
: return "Zilog Z80";
2959 case EM_VISIUM
: return "CDS VISIUMcore processor";
2960 case EM_FT32
: return "FTDI Chip FT32";
2961 case EM_MOXIE
: return "Moxie";
2962 case EM_AMDGPU
: return "AMD GPU";
2963 /* 230 (all reserved) */
2965 case EM_RISCV
: return "RISC-V";
2966 case EM_LANAI
: return "Lanai 32-bit processor";
2967 case EM_CEVA
: return "CEVA Processor Architecture Family";
2968 case EM_CEVA_X2
: return "CEVA X2 Processor Family";
2969 case EM_BPF
: return "Linux BPF";
2970 case EM_GRAPHCORE_IPU
: return "Graphcore Intelligent Processing Unit";
2971 case EM_IMG1
: return "Imagination Technologies";
2973 case EM_NFP
: return "Netronome Flow Processor";
2974 case EM_VE
: return "NEC Vector Engine";
2975 case EM_CSKY
: return "C-SKY";
2976 case EM_ARC_COMPACT3_64
: return "Synopsys ARCv3 64-bit processor";
2977 case EM_MCS6502
: return "MOS Technology MCS 6502 processor";
2978 case EM_ARC_COMPACT3
: return "Synopsys ARCv3 32-bit processor";
2979 case EM_KVX
: return "Kalray VLIW core of the MPPA processor family";
2980 case EM_65816
: return "WDC 65816/65C816";
2981 case EM_LOONGARCH
: return "LoongArch";
2982 case EM_KF32
: return "ChipON KungFu32";
2984 /* Large numbers... */
2985 case EM_MT
: return "Morpho Techologies MT processor";
2986 case EM_ALPHA
: return "Alpha";
2987 case EM_WEBASSEMBLY
: return "Web Assembly";
2988 case EM_DLX
: return "OpenDLX";
2989 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2990 case EM_IQ2000
: return "Vitesse IQ2000";
2992 case EM_NIOS32
: return "Altera Nios";
2993 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2994 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2995 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2996 case EM_S12Z
: return "Freescale S12Z";
2999 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
3005 decode_ARC_machine_flags (char *out
, unsigned e_flags
, unsigned e_machine
)
3007 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
3008 other compilers don't specify an architecture type in the e_flags, and
3009 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
3010 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
3013 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
3014 but also sets a specific architecture type in the e_flags field.
3016 However, when decoding the flags we don't worry if we see an
3017 unexpected pairing, for example EM_ARC_COMPACT machine type, with
3018 ARCEM architecture type. */
3020 switch (e_flags
& EF_ARC_MACH_MSK
)
3022 /* We only expect these to occur for EM_ARC_COMPACT2. */
3023 case EF_ARC_CPU_ARCV2EM
:
3024 out
= stpcpy (out
, ", ARC EM");
3026 case EF_ARC_CPU_ARCV2HS
:
3027 out
= stpcpy (out
, ", ARC HS");
3030 /* We only expect these to occur for EM_ARC_COMPACT. */
3031 case E_ARC_MACH_ARC600
:
3032 out
= stpcpy (out
, ", ARC600");
3034 case E_ARC_MACH_ARC601
:
3035 out
= stpcpy (out
, ", ARC601");
3037 case E_ARC_MACH_ARC700
:
3038 out
= stpcpy (out
, ", ARC700");
3041 /* The only times we should end up here are (a) A corrupt ELF, (b) A
3042 new ELF with new architecture being read by an old version of
3043 readelf, or (c) An ELF built with non-GNU compiler that does not
3044 set the architecture in the e_flags. */
3046 if (e_machine
== EM_ARC_COMPACT
)
3047 out
= stpcpy (out
, ", Unknown ARCompact");
3049 out
= stpcpy (out
, ", Unknown ARC");
3053 switch (e_flags
& EF_ARC_OSABI_MSK
)
3055 case E_ARC_OSABI_ORIG
:
3056 out
= stpcpy (out
, ", (ABI:legacy)");
3058 case E_ARC_OSABI_V2
:
3059 out
= stpcpy (out
, ", (ABI:v2)");
3061 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
3062 case E_ARC_OSABI_V3
:
3063 out
= stpcpy (out
, ", v3 no-legacy-syscalls ABI");
3065 case E_ARC_OSABI_V4
:
3066 out
= stpcpy (out
, ", v4 ABI");
3069 out
= stpcpy (out
, ", unrecognised ARC OSABI flag");
3076 decode_ARM_machine_flags (char *out
, unsigned e_flags
)
3079 bool unknown
= false;
3081 eabi
= EF_ARM_EABI_VERSION (e_flags
);
3082 e_flags
&= ~ EF_ARM_EABIMASK
;
3084 /* Handle "generic" ARM flags. */
3085 if (e_flags
& EF_ARM_RELEXEC
)
3087 out
= stpcpy (out
, ", relocatable executable");
3088 e_flags
&= ~ EF_ARM_RELEXEC
;
3091 if (e_flags
& EF_ARM_PIC
)
3093 out
= stpcpy (out
, ", position independent");
3094 e_flags
&= ~ EF_ARM_PIC
;
3097 /* Now handle EABI specific flags. */
3101 out
= stpcpy (out
, ", <unrecognized EABI>");
3106 case EF_ARM_EABI_VER1
:
3107 out
= stpcpy (out
, ", Version1 EABI");
3112 /* Process flags one bit at a time. */
3113 flag
= e_flags
& - e_flags
;
3118 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
3119 out
= stpcpy (out
, ", sorted symbol tables");
3129 case EF_ARM_EABI_VER2
:
3130 out
= stpcpy (out
, ", Version2 EABI");
3135 /* Process flags one bit at a time. */
3136 flag
= e_flags
& - e_flags
;
3141 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
3142 out
= stpcpy (out
, ", sorted symbol tables");
3145 case EF_ARM_DYNSYMSUSESEGIDX
:
3146 out
= stpcpy (out
, ", dynamic symbols use segment index");
3149 case EF_ARM_MAPSYMSFIRST
:
3150 out
= stpcpy (out
, ", mapping symbols precede others");
3160 case EF_ARM_EABI_VER3
:
3161 out
= stpcpy (out
, ", Version3 EABI");
3164 case EF_ARM_EABI_VER4
:
3165 out
= stpcpy (out
, ", Version4 EABI");
3170 /* Process flags one bit at a time. */
3171 flag
= e_flags
& - e_flags
;
3177 out
= stpcpy (out
, ", BE8");
3181 out
= stpcpy (out
, ", LE8");
3191 case EF_ARM_EABI_VER5
:
3192 out
= stpcpy (out
, ", Version5 EABI");
3197 /* Process flags one bit at a time. */
3198 flag
= e_flags
& - e_flags
;
3204 out
= stpcpy (out
, ", BE8");
3208 out
= stpcpy (out
, ", LE8");
3211 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
3212 out
= stpcpy (out
, ", soft-float ABI");
3215 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
3216 out
= stpcpy (out
, ", hard-float ABI");
3226 case EF_ARM_EABI_UNKNOWN
:
3227 out
= stpcpy (out
, ", GNU EABI");
3232 /* Process flags one bit at a time. */
3233 flag
= e_flags
& - e_flags
;
3238 case EF_ARM_INTERWORK
:
3239 out
= stpcpy (out
, ", interworking enabled");
3242 case EF_ARM_APCS_26
:
3243 out
= stpcpy (out
, ", uses APCS/26");
3246 case EF_ARM_APCS_FLOAT
:
3247 out
= stpcpy (out
, ", uses APCS/float");
3251 out
= stpcpy (out
, ", position independent");
3255 out
= stpcpy (out
, ", 8 bit structure alignment");
3258 case EF_ARM_NEW_ABI
:
3259 out
= stpcpy (out
, ", uses new ABI");
3262 case EF_ARM_OLD_ABI
:
3263 out
= stpcpy (out
, ", uses old ABI");
3266 case EF_ARM_SOFT_FLOAT
:
3267 out
= stpcpy (out
, ", software FP");
3270 case EF_ARM_VFP_FLOAT
:
3271 out
= stpcpy (out
, ", VFP");
3274 case EF_ARM_MAVERICK_FLOAT
:
3275 out
= stpcpy (out
, ", Maverick FP");
3286 out
= stpcpy (out
,_(", <unknown>"));
3291 decode_AVR_machine_flags (char *out
, unsigned e_flags
)
3293 switch (e_flags
& EF_AVR_MACH
)
3295 case E_AVR_MACH_AVR1
:
3296 out
= stpcpy (out
, ", avr:1");
3298 case E_AVR_MACH_AVR2
:
3299 out
= stpcpy (out
, ", avr:2");
3301 case E_AVR_MACH_AVR25
:
3302 out
= stpcpy (out
, ", avr:25");
3304 case E_AVR_MACH_AVR3
:
3305 out
= stpcpy (out
, ", avr:3");
3307 case E_AVR_MACH_AVR31
:
3308 out
= stpcpy (out
, ", avr:31");
3310 case E_AVR_MACH_AVR35
:
3311 out
= stpcpy (out
, ", avr:35");
3313 case E_AVR_MACH_AVR4
:
3314 out
= stpcpy (out
, ", avr:4");
3316 case E_AVR_MACH_AVR5
:
3317 out
= stpcpy (out
, ", avr:5");
3319 case E_AVR_MACH_AVR51
:
3320 out
= stpcpy (out
, ", avr:51");
3322 case E_AVR_MACH_AVR6
:
3323 out
= stpcpy (out
, ", avr:6");
3325 case E_AVR_MACH_AVRTINY
:
3326 out
= stpcpy (out
, ", avr:100");
3328 case E_AVR_MACH_XMEGA1
:
3329 out
= stpcpy (out
, ", avr:101");
3331 case E_AVR_MACH_XMEGA2
:
3332 out
= stpcpy (out
, ", avr:102");
3334 case E_AVR_MACH_XMEGA3
:
3335 out
= stpcpy (out
, ", avr:103");
3337 case E_AVR_MACH_XMEGA4
:
3338 out
= stpcpy (out
, ", avr:104");
3340 case E_AVR_MACH_XMEGA5
:
3341 out
= stpcpy (out
, ", avr:105");
3343 case E_AVR_MACH_XMEGA6
:
3344 out
= stpcpy (out
, ", avr:106");
3346 case E_AVR_MACH_XMEGA7
:
3347 out
= stpcpy (out
, ", avr:107");
3350 out
= stpcpy (out
, ", avr:<unknown>");
3354 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
3355 out
= stpcpy (out
, ", link-relax");
3360 decode_BLACKFIN_machine_flags (char *out
, unsigned e_flags
)
3362 if (e_flags
& EF_BFIN_PIC
)
3363 out
= stpcpy (out
, ", PIC");
3365 if (e_flags
& EF_BFIN_FDPIC
)
3366 out
= stpcpy (out
, ", FDPIC");
3368 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3369 out
= stpcpy (out
, ", code in L1");
3371 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3372 out
= stpcpy (out
, ", data in L1");
3377 decode_FRV_machine_flags (char *out
, unsigned e_flags
)
3379 switch (e_flags
& EF_FRV_CPU_MASK
)
3381 case EF_FRV_CPU_GENERIC
:
3385 out
= stpcpy (out
, ", fr???");
3388 case EF_FRV_CPU_FR300
:
3389 out
= stpcpy (out
, ", fr300");
3392 case EF_FRV_CPU_FR400
:
3393 out
= stpcpy (out
, ", fr400");
3395 case EF_FRV_CPU_FR405
:
3396 out
= stpcpy (out
, ", fr405");
3399 case EF_FRV_CPU_FR450
:
3400 out
= stpcpy (out
, ", fr450");
3403 case EF_FRV_CPU_FR500
:
3404 out
= stpcpy (out
, ", fr500");
3406 case EF_FRV_CPU_FR550
:
3407 out
= stpcpy (out
, ", fr550");
3410 case EF_FRV_CPU_SIMPLE
:
3411 out
= stpcpy (out
, ", simple");
3413 case EF_FRV_CPU_TOMCAT
:
3414 out
= stpcpy (out
, ", tomcat");
3421 decode_IA64_machine_flags (char *out
, unsigned e_flags
, Filedata
*filedata
)
3423 if ((e_flags
& EF_IA_64_ABI64
))
3424 out
= stpcpy (out
, ", 64-bit");
3426 out
= stpcpy (out
, ", 32-bit");
3427 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3428 out
= stpcpy (out
, ", reduced fp model");
3429 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3430 out
= stpcpy (out
, ", no function descriptors, constant gp");
3431 else if ((e_flags
& EF_IA_64_CONS_GP
))
3432 out
= stpcpy (out
, ", constant gp");
3433 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3434 out
= stpcpy (out
, ", absolute");
3435 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3437 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3438 out
= stpcpy (out
, ", vms_linkages");
3439 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3441 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3443 case EF_IA_64_VMS_COMCOD_WARNING
:
3444 out
= stpcpy (out
, ", warning");
3446 case EF_IA_64_VMS_COMCOD_ERROR
:
3447 out
= stpcpy (out
, ", error");
3449 case EF_IA_64_VMS_COMCOD_ABORT
:
3450 out
= stpcpy (out
, ", abort");
3453 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3454 e_flags
& EF_IA_64_VMS_COMCOD
);
3455 out
= stpcpy (out
, ", <unknown>");
3462 decode_LOONGARCH_machine_flags (char *out
, unsigned int e_flags
)
3464 if (EF_LOONGARCH_IS_SOFT_FLOAT (e_flags
))
3465 out
= stpcpy (out
, ", SOFT-FLOAT");
3466 else if (EF_LOONGARCH_IS_SINGLE_FLOAT (e_flags
))
3467 out
= stpcpy (out
, ", SINGLE-FLOAT");
3468 else if (EF_LOONGARCH_IS_DOUBLE_FLOAT (e_flags
))
3469 out
= stpcpy (out
, ", DOUBLE-FLOAT");
3471 if (EF_LOONGARCH_IS_OBJ_V0 (e_flags
))
3472 out
= stpcpy (out
, ", OBJ-v0");
3473 else if (EF_LOONGARCH_IS_OBJ_V1 (e_flags
))
3474 out
= stpcpy (out
, ", OBJ-v1");
3479 decode_M68K_machine_flags (char *out
, unsigned int e_flags
)
3481 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3482 out
= stpcpy (out
, ", m68000");
3483 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3484 out
= stpcpy (out
, ", cpu32");
3485 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3486 out
= stpcpy (out
, ", fido_a");
3489 char const *isa
= _("unknown");
3490 char const *mac
= _("unknown mac");
3491 char const *additional
= NULL
;
3493 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3495 case EF_M68K_CF_ISA_A_NODIV
:
3497 additional
= ", nodiv";
3499 case EF_M68K_CF_ISA_A
:
3502 case EF_M68K_CF_ISA_A_PLUS
:
3505 case EF_M68K_CF_ISA_B_NOUSP
:
3507 additional
= ", nousp";
3509 case EF_M68K_CF_ISA_B
:
3512 case EF_M68K_CF_ISA_C
:
3515 case EF_M68K_CF_ISA_C_NODIV
:
3517 additional
= ", nodiv";
3520 out
= stpcpy (out
, ", cf, isa ");
3521 out
= stpcpy (out
, isa
);
3523 out
= stpcpy (out
, additional
);
3524 if (e_flags
& EF_M68K_CF_FLOAT
)
3525 out
= stpcpy (out
, ", float");
3526 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3531 case EF_M68K_CF_MAC
:
3534 case EF_M68K_CF_EMAC
:
3537 case EF_M68K_CF_EMAC_B
:
3543 out
= stpcpy (out
, ", ");
3544 out
= stpcpy (out
, mac
);
3551 decode_MeP_machine_flags (char *out
, unsigned int e_flags
)
3553 switch (e_flags
& EF_MEP_CPU_MASK
)
3555 case EF_MEP_CPU_MEP
:
3556 out
= stpcpy (out
, ", generic MeP");
3559 out
= stpcpy (out
, ", MeP C2");
3562 out
= stpcpy (out
, ", MeP C3");
3565 out
= stpcpy (out
, ", MeP C4");
3568 out
= stpcpy (out
, ", MeP C5");
3571 out
= stpcpy (out
, ", MeP H1");
3574 out
= stpcpy (out
, _(", <unknown MeP cpu type>"));
3578 switch (e_flags
& EF_MEP_COP_MASK
)
3580 case EF_MEP_COP_NONE
:
3582 case EF_MEP_COP_AVC
:
3583 out
= stpcpy (out
, ", AVC coprocessor");
3585 case EF_MEP_COP_AVC2
:
3586 out
= stpcpy (out
, ", AVC2 coprocessor");
3588 case EF_MEP_COP_FMAX
:
3589 out
= stpcpy (out
, ", FMAX coprocessor");
3591 case EF_MEP_COP_IVC2
:
3592 out
= stpcpy (out
, ", IVC2 coprocessor");
3595 out
= stpcpy (out
, _("<unknown MeP copro type>"));
3599 if (e_flags
& EF_MEP_LIBRARY
)
3600 out
= stpcpy (out
, ", Built for Library");
3602 if (e_flags
& EF_MEP_INDEX_MASK
)
3603 out
+= sprintf (out
, ", Configuration Index: %#x",
3604 e_flags
& EF_MEP_INDEX_MASK
);
3606 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3607 out
+= sprintf (out
, _(", unknown flags bits: %#x"),
3608 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3613 decode_MIPS_machine_flags (char *out
, unsigned int e_flags
)
3615 if (e_flags
& EF_MIPS_NOREORDER
)
3616 out
= stpcpy (out
, ", noreorder");
3618 if (e_flags
& EF_MIPS_PIC
)
3619 out
= stpcpy (out
, ", pic");
3621 if (e_flags
& EF_MIPS_CPIC
)
3622 out
= stpcpy (out
, ", cpic");
3624 if (e_flags
& EF_MIPS_UCODE
)
3625 out
= stpcpy (out
, ", ugen_reserved");
3627 if (e_flags
& EF_MIPS_ABI2
)
3628 out
= stpcpy (out
, ", abi2");
3630 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3631 out
= stpcpy (out
, ", odk first");
3633 if (e_flags
& EF_MIPS_32BITMODE
)
3634 out
= stpcpy (out
, ", 32bitmode");
3636 if (e_flags
& EF_MIPS_NAN2008
)
3637 out
= stpcpy (out
, ", nan2008");
3639 if (e_flags
& EF_MIPS_FP64
)
3640 out
= stpcpy (out
, ", fp64");
3642 switch ((e_flags
& EF_MIPS_MACH
))
3644 case E_MIPS_MACH_3900
:
3645 out
= stpcpy (out
, ", 3900");
3647 case E_MIPS_MACH_4010
:
3648 out
= stpcpy (out
, ", 4010");
3650 case E_MIPS_MACH_4100
:
3651 out
= stpcpy (out
, ", 4100");
3653 case E_MIPS_MACH_4111
:
3654 out
= stpcpy (out
, ", 4111");
3656 case E_MIPS_MACH_4120
:
3657 out
= stpcpy (out
, ", 4120");
3659 case E_MIPS_MACH_4650
:
3660 out
= stpcpy (out
, ", 4650");
3662 case E_MIPS_MACH_5400
:
3663 out
= stpcpy (out
, ", 5400");
3665 case E_MIPS_MACH_5500
:
3666 out
= stpcpy (out
, ", 5500");
3668 case E_MIPS_MACH_5900
:
3669 out
= stpcpy (out
, ", 5900");
3671 case E_MIPS_MACH_SB1
:
3672 out
= stpcpy (out
, ", sb1");
3674 case E_MIPS_MACH_9000
:
3675 out
= stpcpy (out
, ", 9000");
3677 case E_MIPS_MACH_LS2E
:
3678 out
= stpcpy (out
, ", loongson-2e");
3680 case E_MIPS_MACH_LS2F
:
3681 out
= stpcpy (out
, ", loongson-2f");
3683 case E_MIPS_MACH_GS464
:
3684 out
= stpcpy (out
, ", gs464");
3686 case E_MIPS_MACH_GS464E
:
3687 out
= stpcpy (out
, ", gs464e");
3689 case E_MIPS_MACH_GS264E
:
3690 out
= stpcpy (out
, ", gs264e");
3692 case E_MIPS_MACH_OCTEON
:
3693 out
= stpcpy (out
, ", octeon");
3695 case E_MIPS_MACH_OCTEON2
:
3696 out
= stpcpy (out
, ", octeon2");
3698 case E_MIPS_MACH_OCTEON3
:
3699 out
= stpcpy (out
, ", octeon3");
3701 case E_MIPS_MACH_XLR
:
3702 out
= stpcpy (out
, ", xlr");
3704 case E_MIPS_MACH_IAMR2
:
3705 out
= stpcpy (out
, ", interaptiv-mr2");
3707 case E_MIPS_MACH_ALLEGREX
:
3708 out
= stpcpy (out
, ", allegrex");
3711 /* We simply ignore the field in this case to avoid confusion:
3712 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3716 out
= stpcpy (out
, _(", unknown CPU"));
3720 switch ((e_flags
& EF_MIPS_ABI
))
3722 case E_MIPS_ABI_O32
:
3723 out
= stpcpy (out
, ", o32");
3725 case E_MIPS_ABI_O64
:
3726 out
= stpcpy (out
, ", o64");
3728 case E_MIPS_ABI_EABI32
:
3729 out
= stpcpy (out
, ", eabi32");
3731 case E_MIPS_ABI_EABI64
:
3732 out
= stpcpy (out
, ", eabi64");
3735 /* We simply ignore the field in this case to avoid confusion:
3736 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3737 This means it is likely to be an o32 file, but not for
3741 out
= stpcpy (out
, _(", unknown ABI"));
3745 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3746 out
= stpcpy (out
, ", mdmx");
3748 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3749 out
= stpcpy (out
, ", mips16");
3751 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3752 out
= stpcpy (out
, ", micromips");
3754 switch ((e_flags
& EF_MIPS_ARCH
))
3757 out
= stpcpy (out
, ", mips1");
3760 out
= stpcpy (out
, ", mips2");
3763 out
= stpcpy (out
, ", mips3");
3766 out
= stpcpy (out
, ", mips4");
3769 out
= stpcpy (out
, ", mips5");
3771 case E_MIPS_ARCH_32
:
3772 out
= stpcpy (out
, ", mips32");
3774 case E_MIPS_ARCH_32R2
:
3775 out
= stpcpy (out
, ", mips32r2");
3777 case E_MIPS_ARCH_32R6
:
3778 out
= stpcpy (out
, ", mips32r6");
3780 case E_MIPS_ARCH_64
:
3781 out
= stpcpy (out
, ", mips64");
3783 case E_MIPS_ARCH_64R2
:
3784 out
= stpcpy (out
, ", mips64r2");
3786 case E_MIPS_ARCH_64R6
:
3787 out
= stpcpy (out
, ", mips64r6");
3790 out
= stpcpy (out
, _(", unknown ISA"));
3797 decode_MSP430_machine_flags (char *out
, unsigned e_flags
)
3799 out
= stpcpy (out
, _(": architecture variant: "));
3800 switch (e_flags
& EF_MSP430_MACH
)
3802 case E_MSP430_MACH_MSP430x11
:
3803 out
= stpcpy (out
, "MSP430x11");
3805 case E_MSP430_MACH_MSP430x11x1
:
3806 out
= stpcpy (out
, "MSP430x11x1 ");
3808 case E_MSP430_MACH_MSP430x12
:
3809 out
= stpcpy (out
, "MSP430x12");
3811 case E_MSP430_MACH_MSP430x13
:
3812 out
= stpcpy (out
, "MSP430x13");
3814 case E_MSP430_MACH_MSP430x14
:
3815 out
= stpcpy (out
, "MSP430x14");
3817 case E_MSP430_MACH_MSP430x15
:
3818 out
= stpcpy (out
, "MSP430x15");
3820 case E_MSP430_MACH_MSP430x16
:
3821 out
= stpcpy (out
, "MSP430x16");
3823 case E_MSP430_MACH_MSP430x31
:
3824 out
= stpcpy (out
, "MSP430x31");
3826 case E_MSP430_MACH_MSP430x32
:
3827 out
= stpcpy (out
, "MSP430x32");
3829 case E_MSP430_MACH_MSP430x33
:
3830 out
= stpcpy (out
, "MSP430x33");
3832 case E_MSP430_MACH_MSP430x41
:
3833 out
= stpcpy (out
, "MSP430x41");
3835 case E_MSP430_MACH_MSP430x42
:
3836 out
= stpcpy (out
, "MSP430x42");
3838 case E_MSP430_MACH_MSP430x43
:
3839 out
= stpcpy (out
, "MSP430x43");
3841 case E_MSP430_MACH_MSP430x44
:
3842 out
= stpcpy (out
, "MSP430x44");
3844 case E_MSP430_MACH_MSP430X
:
3845 out
= stpcpy (out
, "MSP430X");
3848 out
= stpcpy (out
, _(": unknown"));
3852 if (e_flags
& ~ EF_MSP430_MACH
)
3853 out
= stpcpy (out
, _(": unknown extra flag bits also present"));
3858 decode_NDS32_machine_flags (char *out
, unsigned e_flags
)
3864 bool has_fpu
= false;
3866 static const char *ABI_STRINGS
[] =
3868 "ABI v0", /* use r5 as return register; only used in N1213HC */
3869 "ABI v1", /* use r0 as return register */
3870 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
3871 "ABI v2fp", /* for FPU */
3875 static const char *VER_STRINGS
[] =
3877 "Andes ELF V1.3 or older",
3881 static const char *ARCH_STRINGS
[] =
3890 abi
= EF_NDS_ABI
& e_flags
;
3891 arch
= EF_NDS_ARCH
& e_flags
;
3892 config
= EF_NDS_INST
& e_flags
;
3893 version
= EF_NDS32_ELF_VERSION
& e_flags
;
3900 case E_NDS_ABI_V2FP
:
3901 case E_NDS_ABI_AABI
:
3902 case E_NDS_ABI_V2FP_PLUS
:
3903 /* In case there are holes in the array. */
3904 out
+= sprintf (out
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
3908 out
= stpcpy (out
, ", <unrecognized ABI>");
3914 case E_NDS32_ELF_VER_1_2
:
3915 case E_NDS32_ELF_VER_1_3
:
3916 case E_NDS32_ELF_VER_1_4
:
3917 out
+= sprintf (out
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
3921 out
= stpcpy (out
, ", <unrecognized ELF version number>");
3925 if (E_NDS_ABI_V0
== abi
)
3927 /* OLD ABI; only used in N1213HC, has performance extension 1. */
3928 out
= stpcpy (out
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
3929 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3930 out
= stpcpy (out
, ", 16b"); /* has 16-bit instructions */
3936 case E_NDS_ARCH_STAR_V1_0
:
3937 case E_NDS_ARCH_STAR_V2_0
:
3938 case E_NDS_ARCH_STAR_V3_0
:
3939 case E_NDS_ARCH_STAR_V3_M
:
3940 out
+= sprintf (out
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
3944 out
= stpcpy (out
, ", <unrecognized architecture>");
3945 /* ARCH version determines how the e_flags are interpreted.
3946 If it is unknown, we cannot proceed. */
3950 /* Newer ABI; Now handle architecture specific flags. */
3951 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3953 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3954 out
= stpcpy (out
, ", MFUSR_PC");
3956 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
3957 out
= stpcpy (out
, ", MAC");
3959 if (config
& E_NDS32_HAS_DIV_INST
)
3960 out
= stpcpy (out
, ", DIV");
3962 if (config
& E_NDS32_HAS_16BIT_INST
)
3963 out
= stpcpy (out
, ", 16b");
3967 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3969 if (version
<= E_NDS32_ELF_VER_1_3
)
3970 out
= stpcpy (out
, ", [B8]");
3972 out
= stpcpy (out
, ", EX9");
3975 if (config
& E_NDS32_HAS_MAC_DX_INST
)
3976 out
= stpcpy (out
, ", MAC_DX");
3978 if (config
& E_NDS32_HAS_DIV_DX_INST
)
3979 out
= stpcpy (out
, ", DIV_DX");
3981 if (config
& E_NDS32_HAS_16BIT_INST
)
3983 if (version
<= E_NDS32_ELF_VER_1_3
)
3984 out
= stpcpy (out
, ", 16b");
3986 out
= stpcpy (out
, ", IFC");
3990 if (config
& E_NDS32_HAS_EXT_INST
)
3991 out
= stpcpy (out
, ", PERF1");
3993 if (config
& E_NDS32_HAS_EXT2_INST
)
3994 out
= stpcpy (out
, ", PERF2");
3996 if (config
& E_NDS32_HAS_FPU_INST
)
3999 out
= stpcpy (out
, ", FPU_SP");
4002 if (config
& E_NDS32_HAS_FPU_DP_INST
)
4005 out
= stpcpy (out
, ", FPU_DP");
4008 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
4011 out
= stpcpy (out
, ", FPU_MAC");
4016 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
4018 case E_NDS32_FPU_REG_8SP_4DP
:
4019 out
= stpcpy (out
, ", FPU_REG:8/4");
4021 case E_NDS32_FPU_REG_16SP_8DP
:
4022 out
= stpcpy (out
, ", FPU_REG:16/8");
4024 case E_NDS32_FPU_REG_32SP_16DP
:
4025 out
= stpcpy (out
, ", FPU_REG:32/16");
4027 case E_NDS32_FPU_REG_32SP_32DP
:
4028 out
= stpcpy (out
, ", FPU_REG:32/32");
4033 if (config
& E_NDS32_HAS_AUDIO_INST
)
4034 out
= stpcpy (out
, ", AUDIO");
4036 if (config
& E_NDS32_HAS_STRING_INST
)
4037 out
= stpcpy (out
, ", STR");
4039 if (config
& E_NDS32_HAS_REDUCED_REGS
)
4040 out
= stpcpy (out
, ", 16REG");
4042 if (config
& E_NDS32_HAS_VIDEO_INST
)
4044 if (version
<= E_NDS32_ELF_VER_1_3
)
4045 out
= stpcpy (out
, ", VIDEO");
4047 out
= stpcpy (out
, ", SATURATION");
4050 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
4051 out
= stpcpy (out
, ", ENCRP");
4053 if (config
& E_NDS32_HAS_L2C_INST
)
4054 out
= stpcpy (out
, ", L2C");
4060 decode_PARISC_machine_flags (char *out
, unsigned e_flags
)
4062 switch (e_flags
& EF_PARISC_ARCH
)
4064 case EFA_PARISC_1_0
:
4065 out
= stpcpy (out
, ", PA-RISC 1.0");
4067 case EFA_PARISC_1_1
:
4068 out
= stpcpy (out
, ", PA-RISC 1.1");
4070 case EFA_PARISC_2_0
:
4071 out
= stpcpy (out
, ", PA-RISC 2.0");
4076 if (e_flags
& EF_PARISC_TRAPNIL
)
4077 out
= stpcpy (out
, ", trapnil");
4078 if (e_flags
& EF_PARISC_EXT
)
4079 out
= stpcpy (out
, ", ext");
4080 if (e_flags
& EF_PARISC_LSB
)
4081 out
= stpcpy (out
, ", lsb");
4082 if (e_flags
& EF_PARISC_WIDE
)
4083 out
= stpcpy (out
, ", wide");
4084 if (e_flags
& EF_PARISC_NO_KABP
)
4085 out
= stpcpy (out
, ", no kabp");
4086 if (e_flags
& EF_PARISC_LAZYSWAP
)
4087 out
= stpcpy (out
, ", lazyswap");
4092 decode_RISCV_machine_flags (char *out
, unsigned e_flags
)
4094 if (e_flags
& EF_RISCV_RVC
)
4095 out
= stpcpy (out
, ", RVC");
4097 if (e_flags
& EF_RISCV_RVE
)
4098 out
= stpcpy (out
, ", RVE");
4100 if (e_flags
& EF_RISCV_TSO
)
4101 out
= stpcpy (out
, ", TSO");
4103 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
4105 case EF_RISCV_FLOAT_ABI_SOFT
:
4106 out
= stpcpy (out
, ", soft-float ABI");
4109 case EF_RISCV_FLOAT_ABI_SINGLE
:
4110 out
= stpcpy (out
, ", single-float ABI");
4113 case EF_RISCV_FLOAT_ABI_DOUBLE
:
4114 out
= stpcpy (out
, ", double-float ABI");
4117 case EF_RISCV_FLOAT_ABI_QUAD
:
4118 out
= stpcpy (out
, ", quad-float ABI");
4125 decode_RL78_machine_flags (char *out
, unsigned e_flags
)
4127 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
4129 case E_FLAG_RL78_ANY_CPU
:
4131 case E_FLAG_RL78_G10
:
4132 out
= stpcpy (out
, ", G10");
4134 case E_FLAG_RL78_G13
:
4135 out
= stpcpy (out
, ", G13");
4137 case E_FLAG_RL78_G14
:
4138 out
= stpcpy (out
, ", G14");
4141 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
4142 out
= stpcpy (out
, ", 64-bit doubles");
4147 decode_RX_machine_flags (char *out
, unsigned e_flags
)
4149 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
4150 out
= stpcpy (out
, ", 64-bit doubles");
4151 if (e_flags
& E_FLAG_RX_DSP
)
4152 out
= stpcpy (out
, ", dsp");
4153 if (e_flags
& E_FLAG_RX_PID
)
4154 out
= stpcpy (out
, ", pid");
4155 if (e_flags
& E_FLAG_RX_ABI
)
4156 out
= stpcpy (out
, ", RX ABI");
4157 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
4158 out
= stpcpy (out
, (e_flags
& E_FLAG_RX_SINSNS_YES
4159 ? ", uses String instructions"
4160 : ", bans String instructions"));
4161 if (e_flags
& E_FLAG_RX_V2
)
4162 out
= stpcpy (out
, ", V2");
4163 if (e_flags
& E_FLAG_RX_V3
)
4164 out
= stpcpy (out
, ", V3");
4169 decode_SH_machine_flags (char *out
, unsigned e_flags
)
4171 switch ((e_flags
& EF_SH_MACH_MASK
))
4174 out
= stpcpy (out
, ", sh1");
4177 out
= stpcpy (out
, ", sh2");
4180 out
= stpcpy (out
, ", sh3");
4183 out
= stpcpy (out
, ", sh-dsp");
4186 out
= stpcpy (out
, ", sh3-dsp");
4189 out
= stpcpy (out
, ", sh4al-dsp");
4192 out
= stpcpy (out
, ", sh3e");
4195 out
= stpcpy (out
, ", sh4");
4198 out
= stpcpy (out
, ", sh5");
4201 out
= stpcpy (out
, ", sh2e");
4204 out
= stpcpy (out
, ", sh4a");
4207 out
= stpcpy (out
, ", sh2a");
4210 out
= stpcpy (out
, ", sh4-nofpu");
4213 out
= stpcpy (out
, ", sh4a-nofpu");
4216 out
= stpcpy (out
, ", sh2a-nofpu");
4219 out
= stpcpy (out
, ", sh3-nommu");
4221 case EF_SH4_NOMMU_NOFPU
:
4222 out
= stpcpy (out
, ", sh4-nommu-nofpu");
4224 case EF_SH2A_SH4_NOFPU
:
4225 out
= stpcpy (out
, ", sh2a-nofpu-or-sh4-nommu-nofpu");
4227 case EF_SH2A_SH3_NOFPU
:
4228 out
= stpcpy (out
, ", sh2a-nofpu-or-sh3-nommu");
4231 out
= stpcpy (out
, ", sh2a-or-sh4");
4234 out
= stpcpy (out
, ", sh2a-or-sh3e");
4237 out
= stpcpy (out
, _(", unknown ISA"));
4241 if (e_flags
& EF_SH_PIC
)
4242 out
= stpcpy (out
, ", pic");
4244 if (e_flags
& EF_SH_FDPIC
)
4245 out
= stpcpy (out
, ", fdpic");
4250 decode_SPARC_machine_flags (char *out
, unsigned e_flags
)
4252 if (e_flags
& EF_SPARC_32PLUS
)
4253 out
= stpcpy (out
, ", v8+");
4255 if (e_flags
& EF_SPARC_SUN_US1
)
4256 out
= stpcpy (out
, ", ultrasparcI");
4258 if (e_flags
& EF_SPARC_SUN_US3
)
4259 out
= stpcpy (out
, ", ultrasparcIII");
4261 if (e_flags
& EF_SPARC_HAL_R1
)
4262 out
= stpcpy (out
, ", halr1");
4264 if (e_flags
& EF_SPARC_LEDATA
)
4265 out
= stpcpy (out
, ", ledata");
4267 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
4268 out
= stpcpy (out
, ", tso");
4270 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
4271 out
= stpcpy (out
, ", pso");
4273 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
4274 out
= stpcpy (out
, ", rmo");
4279 decode_V800_machine_flags (char *out
, unsigned int e_flags
)
4281 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
4282 out
= stpcpy (out
, ", RH850 ABI");
4284 if (e_flags
& EF_V800_850E3
)
4285 out
= stpcpy (out
, ", V3 architecture");
4287 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
4288 out
= stpcpy (out
, ", FPU not used");
4290 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
4291 out
= stpcpy (out
, ", regmode: COMMON");
4293 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
4294 out
= stpcpy (out
, ", r4 not used");
4296 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
4297 out
= stpcpy (out
, ", r30 not used");
4299 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
4300 out
= stpcpy (out
, ", r5 not used");
4302 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
4303 out
= stpcpy (out
, ", r2 not used");
4305 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
4307 switch (e_flags
& - e_flags
)
4309 case EF_RH850_FPU_DOUBLE
:
4310 out
= stpcpy (out
, ", double precision FPU");
4312 case EF_RH850_FPU_SINGLE
:
4313 out
= stpcpy (out
, ", single precision FPU");
4315 case EF_RH850_REGMODE22
:
4316 out
= stpcpy (out
, ", regmode:22");
4318 case EF_RH850_REGMODE32
:
4319 out
= stpcpy (out
, ", regmode:23");
4321 case EF_RH850_GP_FIX
:
4322 out
= stpcpy (out
, ", r4 fixed");
4324 case EF_RH850_GP_NOFIX
:
4325 out
= stpcpy (out
, ", r4 free");
4327 case EF_RH850_EP_FIX
:
4328 out
= stpcpy (out
, ", r30 fixed");
4330 case EF_RH850_EP_NOFIX
:
4331 out
= stpcpy (out
, ", r30 free");
4333 case EF_RH850_TP_FIX
:
4334 out
= stpcpy (out
, ", r5 fixed");
4336 case EF_RH850_TP_NOFIX
:
4337 out
= stpcpy (out
, ", r5 free");
4339 case EF_RH850_REG2_RESERVE
:
4340 out
= stpcpy (out
, ", r2 fixed");
4342 case EF_RH850_REG2_NORESERVE
:
4343 out
= stpcpy (out
, ", r2 free");
4353 decode_V850_machine_flags (char *out
, unsigned int e_flags
)
4355 switch (e_flags
& EF_V850_ARCH
)
4357 case E_V850E3V5_ARCH
:
4358 out
= stpcpy (out
, ", v850e3v5");
4360 case E_V850E2V3_ARCH
:
4361 out
= stpcpy (out
, ", v850e2v3");
4364 out
= stpcpy (out
, ", v850e2");
4367 out
= stpcpy (out
, ", v850e1");
4370 out
= stpcpy (out
, ", v850e");
4373 out
= stpcpy (out
, ", v850");
4376 out
= stpcpy (out
, _(", unknown v850 architecture variant"));
4383 decode_Z80_machine_flags (char *out
, unsigned int e_flags
)
4385 switch (e_flags
& EF_Z80_MACH_MSK
)
4387 case EF_Z80_MACH_Z80
:
4388 out
= stpcpy (out
, ", Z80");
4390 case EF_Z80_MACH_Z180
:
4391 out
= stpcpy (out
, ", Z180");
4393 case EF_Z80_MACH_R800
:
4394 out
= stpcpy (out
, ", R800");
4396 case EF_Z80_MACH_EZ80_Z80
:
4397 out
= stpcpy (out
, ", EZ80");
4399 case EF_Z80_MACH_EZ80_ADL
:
4400 out
= stpcpy (out
, ", EZ80, ADL");
4402 case EF_Z80_MACH_GBZ80
:
4403 out
= stpcpy (out
, ", GBZ80");
4405 case EF_Z80_MACH_Z80N
:
4406 out
= stpcpy (out
, ", Z80N");
4409 out
= stpcpy (out
, _(", unknown"));
4416 decode_AMDGPU_machine_flags (char *out
, unsigned int e_flags
, Filedata
*filedata
)
4418 unsigned char *e_ident
= filedata
->file_header
.e_ident
;
4419 unsigned char osabi
= e_ident
[EI_OSABI
];
4420 unsigned char abiversion
= e_ident
[EI_ABIVERSION
];
4423 /* HSA OS ABI v2 used a different encoding, but we don't need to support it,
4424 it has been deprecated for a while.
4426 The PAL, MESA3D and NONE OS ABIs are not properly versioned, at the time
4427 of writing, they use the same flags as HSA v3, so the code below uses that
4429 if (osabi
== ELFOSABI_AMDGPU_HSA
&& abiversion
< ELFABIVERSION_AMDGPU_HSA_V3
)
4432 mach
= e_flags
& EF_AMDGPU_MACH
;
4435 #define AMDGPU_CASE(code, string) \
4436 case code: out = stpcpy (out, ", " string); break;
4437 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX600
, "gfx600")
4438 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX601
, "gfx601")
4439 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX700
, "gfx700")
4440 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX701
, "gfx701")
4441 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX702
, "gfx702")
4442 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX703
, "gfx703")
4443 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX704
, "gfx704")
4444 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX801
, "gfx801")
4445 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX802
, "gfx802")
4446 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX803
, "gfx803")
4447 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX810
, "gfx810")
4448 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX900
, "gfx900")
4449 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX902
, "gfx902")
4450 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX904
, "gfx904")
4451 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX906
, "gfx906")
4452 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX908
, "gfx908")
4453 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX909
, "gfx909")
4454 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX90C
, "gfx90c")
4455 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1010
, "gfx1010")
4456 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1011
, "gfx1011")
4457 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1012
, "gfx1012")
4458 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1030
, "gfx1030")
4459 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1031
, "gfx1031")
4460 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1032
, "gfx1032")
4461 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1033
, "gfx1033")
4462 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX602
, "gfx602")
4463 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX705
, "gfx705")
4464 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX805
, "gfx805")
4465 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1035
, "gfx1035")
4466 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1034
, "gfx1034")
4467 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX90A
, "gfx90a")
4468 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX940
, "gfx940")
4469 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1013
, "gfx1013")
4470 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1036
, "gfx1036")
4472 out
+= sprintf (out
, _(", <unknown AMDGPU GPU type: %#x>"), mach
);
4477 e_flags
&= ~EF_AMDGPU_MACH
;
4479 if ((osabi
== ELFOSABI_AMDGPU_HSA
4480 && abiversion
== ELFABIVERSION_AMDGPU_HSA_V3
)
4481 || osabi
!= ELFOSABI_AMDGPU_HSA
)
4483 /* For HSA v3 and other OS ABIs. */
4484 if (e_flags
& EF_AMDGPU_FEATURE_XNACK_V3
)
4486 out
= stpcpy (out
, ", xnack on");
4487 e_flags
&= ~EF_AMDGPU_FEATURE_XNACK_V3
;
4490 if (e_flags
& EF_AMDGPU_FEATURE_SRAMECC_V3
)
4492 out
= stpcpy (out
, ", sramecc on");
4493 e_flags
&= ~EF_AMDGPU_FEATURE_SRAMECC_V3
;
4501 xnack
= e_flags
& EF_AMDGPU_FEATURE_XNACK_V4
;
4504 case EF_AMDGPU_FEATURE_XNACK_UNSUPPORTED_V4
:
4507 case EF_AMDGPU_FEATURE_XNACK_ANY_V4
:
4508 out
= stpcpy (out
, ", xnack any");
4511 case EF_AMDGPU_FEATURE_XNACK_OFF_V4
:
4512 out
= stpcpy (out
, ", xnack off");
4515 case EF_AMDGPU_FEATURE_XNACK_ON_V4
:
4516 out
= stpcpy (out
, ", xnack on");
4520 out
+= sprintf (out
, _(", <unknown xnack value: %#x>"), xnack
);
4524 e_flags
&= ~EF_AMDGPU_FEATURE_XNACK_V4
;
4526 sramecc
= e_flags
& EF_AMDGPU_FEATURE_SRAMECC_V4
;
4529 case EF_AMDGPU_FEATURE_SRAMECC_UNSUPPORTED_V4
:
4532 case EF_AMDGPU_FEATURE_SRAMECC_ANY_V4
:
4533 out
= stpcpy (out
, ", sramecc any");
4536 case EF_AMDGPU_FEATURE_SRAMECC_OFF_V4
:
4537 out
= stpcpy (out
, ", sramecc off");
4540 case EF_AMDGPU_FEATURE_SRAMECC_ON_V4
:
4541 out
= stpcpy (out
, ", sramecc on");
4545 out
+= sprintf (out
, _(", <unknown sramecc value: %#x>"), sramecc
);
4549 e_flags
&= ~EF_AMDGPU_FEATURE_SRAMECC_V4
;
4553 out
+= sprintf (out
, _(", unknown flags bits: %#x"), e_flags
);
4558 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
4560 static char buf
[1024];
4572 case EM_ARC_COMPACT3
:
4573 out
= stpcpy (out
, ", HS5x");
4576 case EM_ARC_COMPACT3_64
:
4577 out
= stpcpy (out
, ", HS6x");
4580 case EM_ARC_COMPACT2
:
4581 case EM_ARC_COMPACT
:
4582 out
= decode_ARC_machine_flags (out
, e_flags
, e_machine
);
4586 out
= decode_ARM_machine_flags (out
, e_flags
);
4590 out
= decode_AVR_machine_flags (out
, e_flags
);
4594 out
= decode_BLACKFIN_machine_flags (out
, e_flags
);
4598 out
= decode_FRV_machine_flags (out
, e_flags
);
4602 out
= decode_M68K_machine_flags (out
, e_flags
);
4606 out
= decode_AMDGPU_machine_flags (out
, e_flags
, filedata
);
4610 out
= decode_MeP_machine_flags (out
, e_flags
);
4614 if (e_flags
& EF_PPC_EMB
)
4615 out
= stpcpy (out
, ", emb");
4617 if (e_flags
& EF_PPC_RELOCATABLE
)
4618 out
= stpcpy (out
, _(", relocatable"));
4620 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
4621 out
= stpcpy (out
, _(", relocatable-lib"));
4625 if (e_flags
& EF_PPC64_ABI
)
4626 out
+= sprintf (out
, ", abiv%d", e_flags
& EF_PPC64_ABI
);
4630 out
= decode_V800_machine_flags (out
, e_flags
);
4634 case EM_CYGNUS_V850
:
4635 out
= decode_V850_machine_flags (out
, e_flags
);
4639 case EM_CYGNUS_M32R
:
4640 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
4641 out
= stpcpy (out
, ", m32r");
4645 case EM_MIPS_RS3_LE
:
4646 out
= decode_MIPS_machine_flags (out
, e_flags
);
4650 out
= decode_NDS32_machine_flags (out
, e_flags
);
4654 switch (EF_NFP_MACH (e_flags
))
4656 case E_NFP_MACH_3200
:
4657 out
= stpcpy (out
, ", NFP-32xx");
4659 case E_NFP_MACH_6000
:
4660 out
= stpcpy (out
, ", NFP-6xxx");
4666 out
= decode_RISCV_machine_flags (out
, e_flags
);
4670 out
= decode_SH_machine_flags (out
, e_flags
);
4674 if (e_flags
& EF_OR1K_NODELAY
)
4675 out
= stpcpy (out
, ", no delay");
4679 out
+= sprintf (out
, ", CPU Version: %u", e_flags
& EF_BPF_CPUVER
);
4683 out
= decode_SPARC_machine_flags (out
, e_flags
);
4687 out
= decode_PARISC_machine_flags (out
, e_flags
);
4692 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
4693 out
= stpcpy (out
, ", new calling convention");
4695 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
4696 out
= stpcpy (out
, ", gnu calling convention");
4700 out
= decode_IA64_machine_flags (out
, e_flags
, filedata
);
4704 if ((e_flags
& EF_VAX_NONPIC
))
4705 out
= stpcpy (out
, ", non-PIC");
4706 if ((e_flags
& EF_VAX_DFLOAT
))
4707 out
= stpcpy (out
, ", D-Float");
4708 if ((e_flags
& EF_VAX_GFLOAT
))
4709 out
= stpcpy (out
, ", G-Float");
4713 if (e_flags
& EF_VISIUM_ARCH_MCM
)
4714 out
= stpcpy (out
, ", mcm");
4715 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
4716 out
= stpcpy (out
, ", mcm24");
4717 if (e_flags
& EF_VISIUM_ARCH_GR6
)
4718 out
= stpcpy (out
, ", gr6");
4722 out
= decode_RL78_machine_flags (out
, e_flags
);
4726 out
= decode_RX_machine_flags (out
, e_flags
);
4730 if (e_flags
& EF_S390_HIGH_GPRS
)
4731 out
= stpcpy (out
, ", highgprs");
4735 if ((e_flags
& EF_C6000_REL
))
4736 out
= stpcpy (out
, ", relocatable module");
4740 out
= decode_MSP430_machine_flags (out
, e_flags
);
4744 out
= decode_Z80_machine_flags (out
, e_flags
);
4748 out
= decode_LOONGARCH_machine_flags (out
, e_flags
);
4757 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
4759 static char buff
[32];
4763 case ELFOSABI_NONE
: return "UNIX - System V";
4764 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
4765 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
4766 case ELFOSABI_GNU
: return "UNIX - GNU";
4767 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
4768 case ELFOSABI_AIX
: return "UNIX - AIX";
4769 case ELFOSABI_IRIX
: return "UNIX - IRIX";
4770 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
4771 case ELFOSABI_TRU64
: return "UNIX - TRU64";
4772 case ELFOSABI_MODESTO
: return "Novell - Modesto";
4773 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
4774 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
4775 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
4776 case ELFOSABI_AROS
: return "AROS";
4777 case ELFOSABI_FENIXOS
: return "FenixOS";
4778 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
4779 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
4782 switch (filedata
->file_header
.e_machine
)
4787 case ELFOSABI_AMDGPU_HSA
: return "AMD HSA";
4788 case ELFOSABI_AMDGPU_PAL
: return "AMD PAL";
4789 case ELFOSABI_AMDGPU_MESA3D
: return "AMD Mesa3D";
4798 case ELFOSABI_ARM
: return "ARM";
4799 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
4810 case ELFOSABI_STANDALONE
: return _("Standalone App");
4819 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
4820 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
4829 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
4835 get_aarch64_segment_type (unsigned long type
)
4839 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
4840 case PT_AARCH64_MEMTAG_MTE
: return "AARCH64_MEMTAG_MTE";
4841 default: return NULL
;
4846 get_arm_segment_type (unsigned long type
)
4850 case PT_ARM_EXIDX
: return "EXIDX";
4851 default: return NULL
;
4856 get_s390_segment_type (unsigned long type
)
4860 case PT_S390_PGSTE
: return "S390_PGSTE";
4861 default: return NULL
;
4866 get_mips_segment_type (unsigned long type
)
4870 case PT_MIPS_REGINFO
: return "REGINFO";
4871 case PT_MIPS_RTPROC
: return "RTPROC";
4872 case PT_MIPS_OPTIONS
: return "OPTIONS";
4873 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
4874 default: return NULL
;
4879 get_parisc_segment_type (unsigned long type
)
4883 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
4884 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
4885 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
4886 default: return NULL
;
4891 get_ia64_segment_type (unsigned long type
)
4895 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
4896 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
4897 default: return NULL
;
4902 get_tic6x_segment_type (unsigned long type
)
4906 case PT_C6000_PHATTR
: return "C6000_PHATTR";
4907 default: return NULL
;
4912 get_riscv_segment_type (unsigned long type
)
4916 case PT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4917 default: return NULL
;
4922 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
4924 if (e_machine
== EM_PARISC
)
4927 case PT_HP_TLS
: return "HP_TLS";
4928 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
4929 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
4930 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
4931 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
4932 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
4933 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
4934 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
4935 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
4936 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
4937 case PT_HP_PARALLEL
: return "HP_PARALLEL";
4938 case PT_HP_FASTBIND
: return "HP_FASTBIND";
4939 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
4940 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
4941 case PT_HP_STACK
: return "HP_STACK";
4942 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
4943 default: return NULL
;
4946 if (e_machine
== EM_IA_64
)
4949 case PT_HP_TLS
: return "HP_TLS";
4950 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
4951 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
4952 case PT_IA_64_HP_STACK
: return "HP_STACK";
4953 default: return NULL
;
4960 get_solaris_segment_type (unsigned long type
)
4964 case 0x6464e550: return "PT_SUNW_UNWIND";
4965 case 0x6474e550: return "PT_SUNW_EH_FRAME";
4966 case 0x6ffffff7: return "PT_LOSUNW";
4967 case 0x6ffffffa: return "PT_SUNWBSS";
4968 case 0x6ffffffb: return "PT_SUNWSTACK";
4969 case 0x6ffffffc: return "PT_SUNWDTRACE";
4970 case 0x6ffffffd: return "PT_SUNWCAP";
4971 case 0x6fffffff: return "PT_HISUNW";
4972 default: return NULL
;
4977 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
4979 static char buff
[32];
4983 case PT_NULL
: return "NULL";
4984 case PT_LOAD
: return "LOAD";
4985 case PT_DYNAMIC
: return "DYNAMIC";
4986 case PT_INTERP
: return "INTERP";
4987 case PT_NOTE
: return "NOTE";
4988 case PT_SHLIB
: return "SHLIB";
4989 case PT_PHDR
: return "PHDR";
4990 case PT_TLS
: return "TLS";
4991 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
4992 case PT_GNU_STACK
: return "GNU_STACK";
4993 case PT_GNU_RELRO
: return "GNU_RELRO";
4994 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
4995 case PT_GNU_SFRAME
: return "GNU_SFRAME";
4997 case PT_OPENBSD_MUTABLE
: return "OPENBSD_MUTABLE";
4998 case PT_OPENBSD_RANDOMIZE
: return "OPENBSD_RANDOMIZE";
4999 case PT_OPENBSD_WXNEEDED
: return "OPENBSD_WXNEEDED";
5000 case PT_OPENBSD_BOOTDATA
: return "OPENBSD_BOOTDATA";
5003 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
5005 const char * result
;
5007 switch (filedata
->file_header
.e_machine
)
5010 result
= get_aarch64_segment_type (p_type
);
5013 result
= get_arm_segment_type (p_type
);
5016 case EM_MIPS_RS3_LE
:
5017 result
= get_mips_segment_type (p_type
);
5020 result
= get_parisc_segment_type (p_type
);
5023 result
= get_ia64_segment_type (p_type
);
5026 result
= get_tic6x_segment_type (p_type
);
5030 result
= get_s390_segment_type (p_type
);
5033 result
= get_riscv_segment_type (p_type
);
5043 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
5045 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
5047 const char * result
= NULL
;
5049 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
5052 case ELFOSABI_FREEBSD
:
5053 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
5055 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
5060 result
= get_hpux_segment_type (p_type
,
5061 filedata
->file_header
.e_machine
);
5063 case ELFOSABI_SOLARIS
:
5064 result
= get_solaris_segment_type (p_type
);
5072 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
5075 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
5082 get_arc_section_type_name (unsigned int sh_type
)
5086 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
5094 get_mips_section_type_name (unsigned int sh_type
)
5098 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
5099 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
5100 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
5101 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
5102 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
5103 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
5104 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
5105 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
5106 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
5107 case SHT_MIPS_RELD
: return "MIPS_RELD";
5108 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
5109 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
5110 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
5111 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
5112 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
5113 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
5114 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
5115 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
5116 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
5117 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
5118 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
5119 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
5120 case SHT_MIPS_LINE
: return "MIPS_LINE";
5121 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
5122 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
5123 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
5124 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
5125 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
5126 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
5127 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
5128 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
5129 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
5130 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
5131 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
5132 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
5133 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
5134 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
5135 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
5136 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
5137 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
5138 case SHT_MIPS_XHASH
: return "MIPS_XHASH";
5146 get_parisc_section_type_name (unsigned int sh_type
)
5150 case SHT_PARISC_EXT
: return "PARISC_EXT";
5151 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
5152 case SHT_PARISC_DOC
: return "PARISC_DOC";
5153 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
5154 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
5155 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
5156 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
5157 default: return NULL
;
5162 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
5164 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
5165 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
5166 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
5170 case SHT_IA_64_EXT
: return "IA_64_EXT";
5171 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
5172 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
5173 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
5174 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
5175 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
5176 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
5177 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
5178 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
5179 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
5187 get_x86_64_section_type_name (unsigned int sh_type
)
5191 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
5192 default: return NULL
;
5197 get_aarch64_section_type_name (unsigned int sh_type
)
5201 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
5202 default: return NULL
;
5207 get_arm_section_type_name (unsigned int sh_type
)
5211 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
5212 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
5213 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
5214 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
5215 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
5216 default: return NULL
;
5221 get_tic6x_section_type_name (unsigned int sh_type
)
5225 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
5226 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
5227 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
5228 case SHT_TI_ICODE
: return "TI_ICODE";
5229 case SHT_TI_XREF
: return "TI_XREF";
5230 case SHT_TI_HANDLER
: return "TI_HANDLER";
5231 case SHT_TI_INITINFO
: return "TI_INITINFO";
5232 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
5233 default: return NULL
;
5238 get_msp430_section_type_name (unsigned int sh_type
)
5242 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
5243 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
5244 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
5245 default: return NULL
;
5250 get_nfp_section_type_name (unsigned int sh_type
)
5254 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
5255 case SHT_NFP_INITREG
: return "NFP_INITREG";
5256 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
5257 default: return NULL
;
5262 get_v850_section_type_name (unsigned int sh_type
)
5266 case SHT_V850_SCOMMON
: return "V850 Small Common";
5267 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
5268 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
5269 case SHT_RENESAS_IOP
: return "RENESAS IOP";
5270 case SHT_RENESAS_INFO
: return "RENESAS INFO";
5271 default: return NULL
;
5276 get_riscv_section_type_name (unsigned int sh_type
)
5280 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
5281 default: return NULL
;
5286 get_csky_section_type_name (unsigned int sh_type
)
5290 case SHT_CSKY_ATTRIBUTES
: return "CSKY_ATTRIBUTES";
5291 default: return NULL
;
5296 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
5298 static char buff
[32];
5299 const char * result
;
5303 case SHT_NULL
: return "NULL";
5304 case SHT_PROGBITS
: return "PROGBITS";
5305 case SHT_SYMTAB
: return "SYMTAB";
5306 case SHT_STRTAB
: return "STRTAB";
5307 case SHT_RELA
: return "RELA";
5308 case SHT_RELR
: return "RELR";
5309 case SHT_HASH
: return "HASH";
5310 case SHT_DYNAMIC
: return "DYNAMIC";
5311 case SHT_NOTE
: return "NOTE";
5312 case SHT_NOBITS
: return "NOBITS";
5313 case SHT_REL
: return "REL";
5314 case SHT_SHLIB
: return "SHLIB";
5315 case SHT_DYNSYM
: return "DYNSYM";
5316 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
5317 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
5318 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
5319 case SHT_GNU_HASH
: return "GNU_HASH";
5320 case SHT_GROUP
: return "GROUP";
5321 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
5322 case SHT_GNU_verdef
: return "VERDEF";
5323 case SHT_GNU_verneed
: return "VERNEED";
5324 case SHT_GNU_versym
: return "VERSYM";
5325 case 0x6ffffff0: return "VERSYM";
5326 case 0x6ffffffc: return "VERDEF";
5327 case 0x7ffffffd: return "AUXILIARY";
5328 case 0x7fffffff: return "FILTER";
5329 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
5332 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
5334 switch (filedata
->file_header
.e_machine
)
5337 case EM_ARC_COMPACT
:
5338 case EM_ARC_COMPACT2
:
5339 case EM_ARC_COMPACT3
:
5340 case EM_ARC_COMPACT3_64
:
5341 result
= get_arc_section_type_name (sh_type
);
5344 case EM_MIPS_RS3_LE
:
5345 result
= get_mips_section_type_name (sh_type
);
5348 result
= get_parisc_section_type_name (sh_type
);
5351 result
= get_ia64_section_type_name (filedata
, sh_type
);
5356 result
= get_x86_64_section_type_name (sh_type
);
5359 result
= get_aarch64_section_type_name (sh_type
);
5362 result
= get_arm_section_type_name (sh_type
);
5365 result
= get_tic6x_section_type_name (sh_type
);
5368 result
= get_msp430_section_type_name (sh_type
);
5371 result
= get_nfp_section_type_name (sh_type
);
5375 case EM_CYGNUS_V850
:
5376 result
= get_v850_section_type_name (sh_type
);
5379 result
= get_riscv_section_type_name (sh_type
);
5382 result
= get_csky_section_type_name (sh_type
);
5392 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
5394 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
5396 switch (filedata
->file_header
.e_machine
)
5399 result
= get_ia64_section_type_name (filedata
, sh_type
);
5402 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
5403 result
= get_solaris_section_type (sh_type
);
5408 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
5409 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
5410 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
5411 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
5423 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
5425 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
5427 switch (filedata
->file_header
.e_machine
)
5431 case EM_CYGNUS_V850
:
5432 result
= get_v850_section_type_name (sh_type
);
5442 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
5445 /* This message is probably going to be displayed in a 15
5446 character wide field, so put the hex value first. */
5447 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
5453 enum long_option_values
5455 OPTION_DEBUG_DUMP
= 512,
5466 OPTION_WITH_SYMBOL_VERSIONS
,
5467 OPTION_RECURSE_LIMIT
,
5468 OPTION_NO_RECURSE_LIMIT
,
5469 OPTION_NO_DEMANGLING
,
5473 static struct option options
[] =
5475 /* Note - This table is alpha-sorted on the 'val'
5476 field in order to make adding new options easier. */
5477 {"arch-specific", no_argument
, 0, 'A'},
5478 {"all", no_argument
, 0, 'a'},
5479 {"demangle", optional_argument
, 0, 'C'},
5480 {"archive-index", no_argument
, 0, 'c'},
5481 {"use-dynamic", no_argument
, 0, 'D'},
5482 {"dynamic", no_argument
, 0, 'd'},
5483 {"headers", no_argument
, 0, 'e'},
5484 {"section-groups", no_argument
, 0, 'g'},
5485 {"help", no_argument
, 0, 'H'},
5486 {"file-header", no_argument
, 0, 'h'},
5487 {"histogram", no_argument
, 0, 'I'},
5488 {"lint", no_argument
, 0, 'L'},
5489 {"enable-checks", no_argument
, 0, 'L'},
5490 {"program-headers", no_argument
, 0, 'l'},
5491 {"segments", no_argument
, 0, 'l'},
5492 {"full-section-name",no_argument
, 0, 'N'},
5493 {"notes", no_argument
, 0, 'n'},
5494 {"process-links", no_argument
, 0, 'P'},
5495 {"string-dump", required_argument
, 0, 'p'},
5496 {"relocated-dump", required_argument
, 0, 'R'},
5497 {"relocs", no_argument
, 0, 'r'},
5498 {"section-headers", no_argument
, 0, 'S'},
5499 {"sections", no_argument
, 0, 'S'},
5500 {"symbols", no_argument
, 0, 's'},
5501 {"syms", no_argument
, 0, 's'},
5502 {"silent-truncation",no_argument
, 0, 'T'},
5503 {"section-details", no_argument
, 0, 't'},
5504 {"unicode", required_argument
, NULL
, 'U'},
5505 {"unwind", no_argument
, 0, 'u'},
5506 {"version-info", no_argument
, 0, 'V'},
5507 {"version", no_argument
, 0, 'v'},
5508 {"wide", no_argument
, 0, 'W'},
5509 {"hex-dump", required_argument
, 0, 'x'},
5510 {"decompress", no_argument
, 0, 'z'},
5512 {"no-demangle", no_argument
, 0, OPTION_NO_DEMANGLING
},
5513 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
5514 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
5515 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
5516 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
5517 {"lto-syms", no_argument
, 0, OPTION_LTO_SYMS
},
5518 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
5519 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
5520 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
5521 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
5522 #ifdef ENABLE_LIBCTF
5523 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
5524 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
5525 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
5526 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
5528 {"sframe", optional_argument
, 0, OPTION_SFRAME_DUMP
},
5529 {"sym-base", optional_argument
, 0, OPTION_SYM_BASE
},
5531 {0, no_argument
, 0, 0}
5535 usage (FILE * stream
)
5537 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
5538 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
5539 fprintf (stream
, _(" Options are:\n"));
5540 fprintf (stream
, _("\
5541 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
5542 fprintf (stream
, _("\
5543 -h --file-header Display the ELF file header\n"));
5544 fprintf (stream
, _("\
5545 -l --program-headers Display the program headers\n"));
5546 fprintf (stream
, _("\
5547 --segments An alias for --program-headers\n"));
5548 fprintf (stream
, _("\
5549 -S --section-headers Display the sections' header\n"));
5550 fprintf (stream
, _("\
5551 --sections An alias for --section-headers\n"));
5552 fprintf (stream
, _("\
5553 -g --section-groups Display the section groups\n"));
5554 fprintf (stream
, _("\
5555 -t --section-details Display the section details\n"));
5556 fprintf (stream
, _("\
5557 -e --headers Equivalent to: -h -l -S\n"));
5558 fprintf (stream
, _("\
5559 -s --syms Display the symbol table\n"));
5560 fprintf (stream
, _("\
5561 --symbols An alias for --syms\n"));
5562 fprintf (stream
, _("\
5563 --dyn-syms Display the dynamic symbol table\n"));
5564 fprintf (stream
, _("\
5565 --lto-syms Display LTO symbol tables\n"));
5566 fprintf (stream
, _("\
5567 --sym-base=[0|8|10|16] \n\
5568 Force base for symbol sizes. The options are \n\
5569 mixed (the default), octal, decimal, hexadecimal.\n"));
5570 fprintf (stream
, _("\
5571 -C --demangle[=STYLE] Decode mangled/processed symbol names\n"));
5572 display_demangler_styles (stream
, _("\
5574 fprintf (stream
, _("\
5575 --no-demangle Do not demangle low-level symbol names. (default)\n"));
5576 fprintf (stream
, _("\
5577 --recurse-limit Enable a demangling recursion limit. (default)\n"));
5578 fprintf (stream
, _("\
5579 --no-recurse-limit Disable a demangling recursion limit\n"));
5580 fprintf (stream
, _("\
5581 -U[dlexhi] --unicode=[default|locale|escape|hex|highlight|invalid]\n\
5582 Display unicode characters as determined by the current locale\n\
5583 (default), escape sequences, \"<hex sequences>\", highlighted\n\
5584 escape sequences, or treat them as invalid and display as\n\
5585 \"{hex sequences}\"\n"));
5586 fprintf (stream
, _("\
5587 -n --notes Display the core notes (if present)\n"));
5588 fprintf (stream
, _("\
5589 -r --relocs Display the relocations (if present)\n"));
5590 fprintf (stream
, _("\
5591 -u --unwind Display the unwind info (if present)\n"));
5592 fprintf (stream
, _("\
5593 -d --dynamic Display the dynamic section (if present)\n"));
5594 fprintf (stream
, _("\
5595 -V --version-info Display the version sections (if present)\n"));
5596 fprintf (stream
, _("\
5597 -A --arch-specific Display architecture specific information (if any)\n"));
5598 fprintf (stream
, _("\
5599 -c --archive-index Display the symbol/file index in an archive\n"));
5600 fprintf (stream
, _("\
5601 -D --use-dynamic Use the dynamic section info when displaying symbols\n"));
5602 fprintf (stream
, _("\
5603 -L --lint|--enable-checks\n\
5604 Display warning messages for possible problems\n"));
5605 fprintf (stream
, _("\
5606 -x --hex-dump=<number|name>\n\
5607 Dump the contents of section <number|name> as bytes\n"));
5608 fprintf (stream
, _("\
5609 -p --string-dump=<number|name>\n\
5610 Dump the contents of section <number|name> as strings\n"));
5611 fprintf (stream
, _("\
5612 -R --relocated-dump=<number|name>\n\
5613 Dump the relocated contents of section <number|name>\n"));
5614 fprintf (stream
, _("\
5615 -z --decompress Decompress section before dumping it\n"));
5616 fprintf (stream
, _("\
5617 -w --debug-dump[a/=abbrev, A/=addr, r/=aranges, c/=cu_index, L/=decodedline,\n\
5618 f/=frames, F/=frames-interp, g/=gdb_index, i/=info, o/=loc,\n\
5619 m/=macro, p/=pubnames, t/=pubtypes, R/=Ranges, l/=rawline,\n\
5620 s/=str, O/=str-offsets, u/=trace_abbrev, T/=trace_aranges,\n\
5622 Display the contents of DWARF debug sections\n"));
5623 fprintf (stream
, _("\
5624 -wk --debug-dump=links Display the contents of sections that link to separate\n\
5625 debuginfo files\n"));
5626 fprintf (stream
, _("\
5627 -P --process-links Display the contents of non-debug sections in separate\n\
5628 debuginfo files. (Implies -wK)\n"));
5629 #if DEFAULT_FOR_FOLLOW_LINKS
5630 fprintf (stream
, _("\
5631 -wK --debug-dump=follow-links\n\
5632 Follow links to separate debug info files (default)\n"));
5633 fprintf (stream
, _("\
5634 -wN --debug-dump=no-follow-links\n\
5635 Do not follow links to separate debug info files\n"));
5637 fprintf (stream
, _("\
5638 -wK --debug-dump=follow-links\n\
5639 Follow links to separate debug info files\n"));
5640 fprintf (stream
, _("\
5641 -wN --debug-dump=no-follow-links\n\
5642 Do not follow links to separate debug info files\n\
5645 #if HAVE_LIBDEBUGINFOD
5646 fprintf (stream
, _("\
5647 -wD --debug-dump=use-debuginfod\n\
5648 When following links, also query debuginfod servers (default)\n"));
5649 fprintf (stream
, _("\
5650 -wE --debug-dump=do-not-use-debuginfod\n\
5651 When following links, do not query debuginfod servers\n"));
5653 fprintf (stream
, _("\
5654 --dwarf-depth=N Do not display DIEs at depth N or greater\n"));
5655 fprintf (stream
, _("\
5656 --dwarf-start=N Display DIEs starting at offset N\n"));
5657 #ifdef ENABLE_LIBCTF
5658 fprintf (stream
, _("\
5659 --ctf=<number|name> Display CTF info from section <number|name>\n"));
5660 fprintf (stream
, _("\
5661 --ctf-parent=<name> Use CTF archive member <name> as the CTF parent\n"));
5662 fprintf (stream
, _("\
5663 --ctf-symbols=<number|name>\n\
5664 Use section <number|name> as the CTF external symtab\n"));
5665 fprintf (stream
, _("\
5666 --ctf-strings=<number|name>\n\
5667 Use section <number|name> as the CTF external strtab\n"));
5669 fprintf (stream
, _("\
5670 --sframe[=NAME] Display SFrame info from section NAME, (default '.sframe')\n"));
5672 #ifdef SUPPORT_DISASSEMBLY
5673 fprintf (stream
, _("\
5674 -i --instruction-dump=<number|name>\n\
5675 Disassemble the contents of section <number|name>\n"));
5677 fprintf (stream
, _("\
5678 -I --histogram Display histogram of bucket list lengths\n"));
5679 fprintf (stream
, _("\
5680 -W --wide Allow output width to exceed 80 characters\n"));
5681 fprintf (stream
, _("\
5682 -T --silent-truncation If a symbol name is truncated, do not add [...] suffix\n"));
5683 fprintf (stream
, _("\
5684 @<file> Read options from <file>\n"));
5685 fprintf (stream
, _("\
5686 -H --help Display this information\n"));
5687 fprintf (stream
, _("\
5688 -v --version Display the version number of readelf\n"));
5690 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
5691 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
5693 exit (stream
== stdout
? 0 : 1);
5696 /* Record the fact that the user wants the contents of section number
5697 SECTION to be displayed using the method(s) encoded as flags bits
5698 in TYPE. Note, TYPE can be zero if we are creating the array for
5702 request_dump_bynumber (struct dump_data
*dumpdata
,
5703 unsigned int section
, dump_type type
)
5705 if (section
>= dumpdata
->num_dump_sects
)
5707 dump_type
* new_dump_sects
;
5709 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
5710 sizeof (* new_dump_sects
));
5712 if (new_dump_sects
== NULL
)
5713 error (_("Out of memory allocating dump request table.\n"));
5716 if (dumpdata
->dump_sects
)
5718 /* Copy current flag settings. */
5719 memcpy (new_dump_sects
, dumpdata
->dump_sects
,
5720 dumpdata
->num_dump_sects
* sizeof (* new_dump_sects
));
5722 free (dumpdata
->dump_sects
);
5725 dumpdata
->dump_sects
= new_dump_sects
;
5726 dumpdata
->num_dump_sects
= section
+ 1;
5730 if (dumpdata
->dump_sects
)
5731 dumpdata
->dump_sects
[section
] |= type
;
5734 /* Request a dump by section name. */
5737 request_dump_byname (const char * section
, dump_type type
)
5739 struct dump_list_entry
* new_request
;
5741 new_request
= (struct dump_list_entry
*)
5742 malloc (sizeof (struct dump_list_entry
));
5744 error (_("Out of memory allocating dump request table.\n"));
5746 new_request
->name
= strdup (section
);
5747 if (!new_request
->name
)
5748 error (_("Out of memory allocating dump request table.\n"));
5750 new_request
->type
= type
;
5752 new_request
->next
= dump_sects_byname
;
5753 dump_sects_byname
= new_request
;
5757 request_dump (struct dump_data
*dumpdata
, dump_type type
)
5763 section
= strtoul (optarg
, & cp
, 0);
5765 if (! *cp
&& section
>= 0)
5766 request_dump_bynumber (dumpdata
, section
, type
);
5768 request_dump_byname (optarg
, type
);
5772 parse_args (struct dump_data
*dumpdata
, int argc
, char ** argv
)
5779 while ((c
= getopt_long
5780 (argc
, argv
, "ACDHILNPR:STU:VWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
5798 do_section_groups
= true;
5801 do_histogram
= true;
5807 do_section_groups
= true;
5812 do_section_details
= true;
5823 do_using_dynamic
= true;
5847 do_histogram
= true;
5853 do_archive_index
= true;
5859 process_links
= true;
5860 do_follow_links
= true;
5861 dump_any_debugging
= true;
5864 request_dump (dumpdata
, HEX_DUMP
);
5867 request_dump (dumpdata
, STRING_DUMP
);
5870 request_dump (dumpdata
, RELOC_DUMP
);
5873 decompress_dumps
= true;
5878 do_debugging
= true;
5880 dump_any_debugging
= true;
5881 dwarf_select_sections_all ();
5885 do_debugging
= false;
5886 if (dwarf_select_sections_by_letters (optarg
))
5889 dump_any_debugging
= true;
5893 case OPTION_DEBUG_DUMP
:
5897 do_debugging
= true;
5898 dump_any_debugging
= true;
5899 dwarf_select_sections_all ();
5903 do_debugging
= false;
5904 if (dwarf_select_sections_by_names (optarg
))
5907 dump_any_debugging
= true;
5911 case OPTION_DWARF_DEPTH
:
5915 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
5918 case OPTION_DWARF_START
:
5922 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
5925 case OPTION_DWARF_CHECK
:
5928 case OPTION_CTF_DUMP
:
5930 request_dump (dumpdata
, CTF_DUMP
);
5932 case OPTION_CTF_SYMBOLS
:
5933 free (dump_ctf_symtab_name
);
5934 dump_ctf_symtab_name
= strdup (optarg
);
5936 case OPTION_CTF_STRINGS
:
5937 free (dump_ctf_strtab_name
);
5938 dump_ctf_strtab_name
= strdup (optarg
);
5940 case OPTION_CTF_PARENT
:
5941 free (dump_ctf_parent_name
);
5942 dump_ctf_parent_name
= strdup (optarg
);
5944 case OPTION_SFRAME_DUMP
:
5946 /* Providing section name is optional. request_dump (), however,
5947 thrives on non NULL optarg. Handle it explicitly here. */
5949 request_dump (dumpdata
, SFRAME_DUMP
);
5953 const char *sframe_sec_name
= strdup (".sframe");
5954 request_dump_byname (sframe_sec_name
, SFRAME_DUMP
);
5957 case OPTION_DYN_SYMS
:
5960 case OPTION_LTO_SYMS
:
5963 #ifdef SUPPORT_DISASSEMBLY
5965 request_dump (dumpdata
, DISASS_DUMP
);
5969 print_version (program_name
);
5978 do_not_show_symbol_truncation
= true;
5984 enum demangling_styles style
;
5986 style
= cplus_demangle_name_to_style (optarg
);
5987 if (style
== unknown_demangling
)
5988 error (_("unknown demangling style `%s'"), optarg
);
5990 cplus_demangle_set_style (style
);
5993 case OPTION_NO_DEMANGLING
:
5994 do_demangle
= false;
5996 case OPTION_RECURSE_LIMIT
:
5997 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
5999 case OPTION_NO_RECURSE_LIMIT
:
6000 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
6002 case OPTION_WITH_SYMBOL_VERSIONS
:
6003 /* Ignored for backward compatibility. */
6008 error (_("Missing arg to -U/--unicode")); /* Can this happen ? */
6009 else if (streq (optarg
, "default") || streq (optarg
, "d"))
6010 unicode_display
= unicode_default
;
6011 else if (streq (optarg
, "locale") || streq (optarg
, "l"))
6012 unicode_display
= unicode_locale
;
6013 else if (streq (optarg
, "escape") || streq (optarg
, "e"))
6014 unicode_display
= unicode_escape
;
6015 else if (streq (optarg
, "invalid") || streq (optarg
, "i"))
6016 unicode_display
= unicode_invalid
;
6017 else if (streq (optarg
, "hex") || streq (optarg
, "x"))
6018 unicode_display
= unicode_hex
;
6019 else if (streq (optarg
, "highlight") || streq (optarg
, "h"))
6020 unicode_display
= unicode_highlight
;
6022 error (_("invalid argument to -U/--unicode: %s"), optarg
);
6025 case OPTION_SYM_BASE
:
6029 sym_base
= strtoul (optarg
, NULL
, 0);
6046 /* xgettext:c-format */
6047 error (_("Invalid option '-%c'\n"), c
);
6054 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
6055 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
6056 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
6057 && !do_section_groups
&& !do_archive_index
6058 && !do_dyn_syms
&& !do_lto_syms
)
6063 do_dynamic
= do_syms
= do_reloc
= do_unwind
= do_sections
= true;
6064 do_segments
= do_header
= do_dump
= do_version
= true;
6065 do_histogram
= do_debugging
= do_arch
= do_notes
= true;
6066 do_section_groups
= do_archive_index
= do_dyn_syms
= true;
6075 get_elf_class (unsigned int elf_class
)
6077 static char buff
[32];
6081 case ELFCLASSNONE
: return _("none");
6082 case ELFCLASS32
: return "ELF32";
6083 case ELFCLASS64
: return "ELF64";
6085 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
6091 get_data_encoding (unsigned int encoding
)
6093 static char buff
[32];
6097 case ELFDATANONE
: return _("none");
6098 case ELFDATA2LSB
: return _("2's complement, little endian");
6099 case ELFDATA2MSB
: return _("2's complement, big endian");
6101 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
6107 check_magic_number (Filedata
* filedata
, Elf_Internal_Ehdr
* header
)
6109 if (header
->e_ident
[EI_MAG0
] == ELFMAG0
6110 && header
->e_ident
[EI_MAG1
] == ELFMAG1
6111 && header
->e_ident
[EI_MAG2
] == ELFMAG2
6112 && header
->e_ident
[EI_MAG3
] == ELFMAG3
)
6115 /* Some compilers produce object files that are not in the ELF file format.
6116 As an aid to users of readelf, try to identify these cases and suggest
6119 FIXME: It is not clear if all four bytes are used as constant magic
6120 valus by all compilers. It may be necessary to recode this function if
6121 different tools use different length sequences. */
6125 unsigned char magic
[4];
6126 const char * obj_message
;
6127 const char * ar_message
;
6131 { { 'B', 'C', 0xc0, 0xde },
6132 N_("This is a LLVM bitcode file - try using llvm-bcanalyzer\n"),
6133 N_("This is a LLVM bitcode file - try extracing and then using llvm-bcanalyzer\n")
6135 { { 'g', 'o', ' ', 'o' },
6136 N_("This is a GO binary file - try using 'go tool objdump' or 'go tool nm'\n"),
6142 for (i
= ARRAY_SIZE (known_magic
); i
--;)
6144 if (header
->e_ident
[EI_MAG0
] == known_magic
[i
].magic
[0]
6145 && header
->e_ident
[EI_MAG1
] == known_magic
[i
].magic
[1]
6146 && header
->e_ident
[EI_MAG2
] == known_magic
[i
].magic
[2]
6147 && header
->e_ident
[EI_MAG3
] == known_magic
[i
].magic
[3])
6149 /* Some compiler's analyzer tools do not handle archives,
6150 so we provide two different kinds of error message. */
6151 if (filedata
->archive_file_size
> 0
6152 && known_magic
[i
].ar_message
!= NULL
)
6153 error ("%s", known_magic
[i
].ar_message
);
6155 error ("%s", known_magic
[i
].obj_message
);
6160 error (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
6164 /* Decode the data held in 'filedata->file_header'. */
6167 process_file_header (Filedata
* filedata
)
6169 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
6171 if (! check_magic_number (filedata
, header
))
6174 if (! filedata
->is_separate
)
6175 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
6181 if (filedata
->is_separate
)
6182 printf (_("ELF Header in linked file '%s':\n"), filedata
->file_name
);
6184 printf (_("ELF Header:\n"));
6185 printf (_(" Magic: "));
6186 for (i
= 0; i
< EI_NIDENT
; i
++)
6187 printf ("%2.2x ", header
->e_ident
[i
]);
6189 printf (_(" Class: %s\n"),
6190 get_elf_class (header
->e_ident
[EI_CLASS
]));
6191 printf (_(" Data: %s\n"),
6192 get_data_encoding (header
->e_ident
[EI_DATA
]));
6193 printf (_(" Version: %d%s\n"),
6194 header
->e_ident
[EI_VERSION
],
6195 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
6197 : (header
->e_ident
[EI_VERSION
] != EV_NONE
6200 printf (_(" OS/ABI: %s\n"),
6201 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
6202 printf (_(" ABI Version: %d\n"),
6203 header
->e_ident
[EI_ABIVERSION
]);
6204 printf (_(" Type: %s\n"),
6205 get_file_type (filedata
));
6206 printf (_(" Machine: %s\n"),
6207 get_machine_name (header
->e_machine
));
6208 printf (_(" Version: 0x%lx\n"),
6211 printf (_(" Entry point address: "));
6212 print_vma (header
->e_entry
, PREFIX_HEX
);
6213 printf (_("\n Start of program headers: "));
6214 print_vma (header
->e_phoff
, DEC
);
6215 printf (_(" (bytes into file)\n Start of section headers: "));
6216 print_vma (header
->e_shoff
, DEC
);
6217 printf (_(" (bytes into file)\n"));
6219 printf (_(" Flags: 0x%lx%s\n"),
6221 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
6222 printf (_(" Size of this header: %u (bytes)\n"),
6224 printf (_(" Size of program headers: %u (bytes)\n"),
6225 header
->e_phentsize
);
6226 printf (_(" Number of program headers: %u"),
6228 if (filedata
->section_headers
!= NULL
6229 && header
->e_phnum
== PN_XNUM
6230 && filedata
->section_headers
[0].sh_info
!= 0)
6231 printf (" (%u)", filedata
->section_headers
[0].sh_info
);
6232 putc ('\n', stdout
);
6233 printf (_(" Size of section headers: %u (bytes)\n"),
6234 header
->e_shentsize
);
6235 printf (_(" Number of section headers: %u"),
6237 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
6239 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
6240 printf (" (%u)", header
->e_shnum
);
6242 putc ('\n', stdout
);
6243 printf (_(" Section header string table index: %u"),
6244 header
->e_shstrndx
);
6245 if (filedata
->section_headers
!= NULL
6246 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
6248 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
6249 printf (" (%u)", header
->e_shstrndx
);
6251 if (header
->e_shstrndx
!= SHN_UNDEF
6252 && header
->e_shstrndx
>= header
->e_shnum
)
6254 header
->e_shstrndx
= SHN_UNDEF
;
6255 printf (_(" <corrupt: out of range>"));
6257 putc ('\n', stdout
);
6260 if (filedata
->section_headers
!= NULL
)
6262 if (header
->e_phnum
== PN_XNUM
6263 && filedata
->section_headers
[0].sh_info
!= 0)
6265 /* Throw away any cached read of PN_XNUM headers. */
6266 free (filedata
->program_headers
);
6267 filedata
->program_headers
= NULL
;
6268 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
6270 if (header
->e_shnum
== SHN_UNDEF
)
6271 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
6272 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
6273 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
6274 if (header
->e_shstrndx
>= header
->e_shnum
)
6275 header
->e_shstrndx
= SHN_UNDEF
;
6281 /* Read in the program headers from FILEDATA and store them in PHEADERS.
6282 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
6285 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
6287 Elf32_External_Phdr
* phdrs
;
6288 Elf32_External_Phdr
* external
;
6289 Elf_Internal_Phdr
* internal
;
6291 unsigned int size
= filedata
->file_header
.e_phentsize
;
6292 unsigned int num
= filedata
->file_header
.e_phnum
;
6294 /* PR binutils/17531: Cope with unexpected section header sizes. */
6295 if (size
== 0 || num
== 0)
6297 if (size
< sizeof * phdrs
)
6299 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
6302 if (size
> sizeof * phdrs
)
6303 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
6305 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
6306 size
, num
, _("program headers"));
6310 for (i
= 0, internal
= pheaders
, external
= phdrs
;
6311 i
< filedata
->file_header
.e_phnum
;
6312 i
++, internal
++, external
++)
6314 internal
->p_type
= BYTE_GET (external
->p_type
);
6315 internal
->p_offset
= BYTE_GET (external
->p_offset
);
6316 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
6317 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
6318 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
6319 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
6320 internal
->p_flags
= BYTE_GET (external
->p_flags
);
6321 internal
->p_align
= BYTE_GET (external
->p_align
);
6328 /* Read in the program headers from FILEDATA and store them in PHEADERS.
6329 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
6332 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
6334 Elf64_External_Phdr
* phdrs
;
6335 Elf64_External_Phdr
* external
;
6336 Elf_Internal_Phdr
* internal
;
6338 unsigned int size
= filedata
->file_header
.e_phentsize
;
6339 unsigned int num
= filedata
->file_header
.e_phnum
;
6341 /* PR binutils/17531: Cope with unexpected section header sizes. */
6342 if (size
== 0 || num
== 0)
6344 if (size
< sizeof * phdrs
)
6346 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
6349 if (size
> sizeof * phdrs
)
6350 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
6352 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
6353 size
, num
, _("program headers"));
6357 for (i
= 0, internal
= pheaders
, external
= phdrs
;
6358 i
< filedata
->file_header
.e_phnum
;
6359 i
++, internal
++, external
++)
6361 internal
->p_type
= BYTE_GET (external
->p_type
);
6362 internal
->p_flags
= BYTE_GET (external
->p_flags
);
6363 internal
->p_offset
= BYTE_GET (external
->p_offset
);
6364 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
6365 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
6366 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
6367 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
6368 internal
->p_align
= BYTE_GET (external
->p_align
);
6375 /* Returns TRUE if the program headers were read into `program_headers'. */
6378 get_program_headers (Filedata
* filedata
)
6380 Elf_Internal_Phdr
* phdrs
;
6382 /* Check cache of prior read. */
6383 if (filedata
->program_headers
!= NULL
)
6386 /* Be kind to memory checkers by looking for
6387 e_phnum values which we know must be invalid. */
6388 if (filedata
->file_header
.e_phnum
6389 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
6390 >= filedata
->file_size
)
6392 error (_("Too many program headers - %#x - the file is not that big\n"),
6393 filedata
->file_header
.e_phnum
);
6397 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
6398 sizeof (Elf_Internal_Phdr
));
6401 error (_("Out of memory reading %u program headers\n"),
6402 filedata
->file_header
.e_phnum
);
6407 ? get_32bit_program_headers (filedata
, phdrs
)
6408 : get_64bit_program_headers (filedata
, phdrs
))
6410 filedata
->program_headers
= phdrs
;
6418 /* Print program header info and locate dynamic section. */
6421 process_program_headers (Filedata
* filedata
)
6423 Elf_Internal_Phdr
* segment
;
6425 Elf_Internal_Phdr
* previous_load
= NULL
;
6427 if (filedata
->file_header
.e_phnum
== 0)
6429 /* PR binutils/12467. */
6430 if (filedata
->file_header
.e_phoff
!= 0)
6431 warn (_("possibly corrupt ELF header - it has a non-zero program"
6432 " header offset, but no program headers\n"));
6433 else if (do_segments
)
6435 if (filedata
->is_separate
)
6436 printf (_("\nThere are no program headers in linked file '%s'.\n"),
6437 filedata
->file_name
);
6439 printf (_("\nThere are no program headers in this file.\n"));
6444 if (do_segments
&& !do_header
)
6446 if (filedata
->is_separate
)
6447 printf ("\nIn linked file '%s' the ELF file type is %s\n",
6448 filedata
->file_name
, get_file_type (filedata
));
6450 printf (_("\nElf file type is %s\n"), get_file_type (filedata
));
6451 printf (_("Entry point 0x%" PRIx64
"\n"),
6452 filedata
->file_header
.e_entry
);
6453 printf (ngettext ("There is %d program header,"
6454 " starting at offset %" PRIu64
"\n",
6455 "There are %d program headers,"
6456 " starting at offset %" PRIu64
"\n",
6457 filedata
->file_header
.e_phnum
),
6458 filedata
->file_header
.e_phnum
,
6459 filedata
->file_header
.e_phoff
);
6462 if (! get_program_headers (filedata
))
6467 if (filedata
->file_header
.e_phnum
> 1)
6468 printf (_("\nProgram Headers:\n"));
6470 printf (_("\nProgram Headers:\n"));
6474 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
6477 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
6481 (_(" Type Offset VirtAddr PhysAddr\n"));
6483 (_(" FileSiz MemSiz Flags Align\n"));
6487 uint64_t dynamic_addr
= 0;
6488 uint64_t dynamic_size
= 0;
6489 for (i
= 0, segment
= filedata
->program_headers
;
6490 i
< filedata
->file_header
.e_phnum
;
6495 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
6499 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
6500 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
6501 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
6502 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
6503 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
6505 (segment
->p_flags
& PF_R
? 'R' : ' '),
6506 (segment
->p_flags
& PF_W
? 'W' : ' '),
6507 (segment
->p_flags
& PF_X
? 'E' : ' '));
6508 printf ("%#lx", (unsigned long) segment
->p_align
);
6512 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
6513 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
6516 print_vma (segment
->p_offset
, FULL_HEX
);
6520 print_vma (segment
->p_vaddr
, FULL_HEX
);
6522 print_vma (segment
->p_paddr
, FULL_HEX
);
6525 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
6526 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
6529 print_vma (segment
->p_filesz
, FULL_HEX
);
6533 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
6534 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
6537 print_vma (segment
->p_memsz
, FULL_HEX
);
6541 (segment
->p_flags
& PF_R
? 'R' : ' '),
6542 (segment
->p_flags
& PF_W
? 'W' : ' '),
6543 (segment
->p_flags
& PF_X
? 'E' : ' '));
6545 if ((unsigned long) segment
->p_align
== segment
->p_align
)
6546 printf ("%#lx", (unsigned long) segment
->p_align
);
6549 print_vma (segment
->p_align
, PREFIX_HEX
);
6554 print_vma (segment
->p_offset
, FULL_HEX
);
6556 print_vma (segment
->p_vaddr
, FULL_HEX
);
6558 print_vma (segment
->p_paddr
, FULL_HEX
);
6560 print_vma (segment
->p_filesz
, FULL_HEX
);
6562 print_vma (segment
->p_memsz
, FULL_HEX
);
6564 (segment
->p_flags
& PF_R
? 'R' : ' '),
6565 (segment
->p_flags
& PF_W
? 'W' : ' '),
6566 (segment
->p_flags
& PF_X
? 'E' : ' '));
6567 print_vma (segment
->p_align
, PREFIX_HEX
);
6570 putc ('\n', stdout
);
6573 switch (segment
->p_type
)
6576 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
6577 required by the ELF standard, several programs, including the Linux
6578 kernel, make use of non-ordered segments. */
6580 && previous_load
->p_vaddr
> segment
->p_vaddr
)
6581 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
6583 if (segment
->p_memsz
< segment
->p_filesz
)
6584 error (_("the segment's file size is larger than its memory size\n"));
6585 previous_load
= segment
;
6589 /* PR 20815 - Verify that the program header is loaded into memory. */
6590 if (i
> 0 && previous_load
!= NULL
)
6591 error (_("the PHDR segment must occur before any LOAD segment\n"));
6592 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
6596 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
6598 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
6599 if (load
->p_type
== PT_LOAD
6600 && load
->p_offset
<= segment
->p_offset
6601 && (load
->p_offset
+ load
->p_filesz
6602 >= segment
->p_offset
+ segment
->p_filesz
)
6603 && load
->p_vaddr
<= segment
->p_vaddr
6604 && (load
->p_vaddr
+ load
->p_filesz
6605 >= segment
->p_vaddr
+ segment
->p_filesz
))
6608 if (j
== filedata
->file_header
.e_phnum
)
6609 error (_("the PHDR segment is not covered by a LOAD segment\n"));
6615 error (_("more than one dynamic segment\n"));
6617 /* By default, assume that the .dynamic section is the first
6618 section in the DYNAMIC segment. */
6619 dynamic_addr
= segment
->p_offset
;
6620 dynamic_size
= segment
->p_filesz
;
6622 /* Try to locate the .dynamic section. If there is
6623 a section header table, we can easily locate it. */
6624 if (filedata
->section_headers
!= NULL
)
6626 Elf_Internal_Shdr
* sec
;
6628 sec
= find_section (filedata
, ".dynamic");
6629 if (sec
== NULL
|| sec
->sh_size
== 0)
6631 /* A corresponding .dynamic section is expected, but on
6632 IA-64/OpenVMS it is OK for it to be missing. */
6633 if (!is_ia64_vms (filedata
))
6634 error (_("no .dynamic section in the dynamic segment\n"));
6638 if (sec
->sh_type
== SHT_NOBITS
)
6645 dynamic_addr
= sec
->sh_offset
;
6646 dynamic_size
= sec
->sh_size
;
6648 /* The PT_DYNAMIC segment, which is used by the run-time
6649 loader, should exactly match the .dynamic section. */
6651 && (dynamic_addr
!= segment
->p_offset
6652 || dynamic_size
!= segment
->p_filesz
))
6654 the .dynamic section is not the same as the dynamic segment\n"));
6657 /* PR binutils/17512: Avoid corrupt dynamic section info in the
6658 segment. Check this after matching against the section headers
6659 so we don't warn on debuginfo file (which have NOBITS .dynamic
6661 if (dynamic_addr
> filedata
->file_size
6662 || (dynamic_size
> filedata
->file_size
- dynamic_addr
))
6664 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
6671 if (segment
->p_offset
>= filedata
->file_size
6672 || segment
->p_filesz
> filedata
->file_size
- segment
->p_offset
6673 || segment
->p_filesz
- 1 >= (size_t) -2
6674 || fseek64 (filedata
->handle
,
6675 filedata
->archive_file_offset
+ segment
->p_offset
,
6677 error (_("Unable to find program interpreter name\n"));
6680 size_t len
= segment
->p_filesz
;
6681 free (filedata
->program_interpreter
);
6682 filedata
->program_interpreter
= xmalloc (len
+ 1);
6683 len
= fread (filedata
->program_interpreter
, 1, len
,
6685 filedata
->program_interpreter
[len
] = 0;
6688 printf (_(" [Requesting program interpreter: %s]\n"),
6689 filedata
->program_interpreter
);
6696 && filedata
->section_headers
!= NULL
6697 && filedata
->string_table
!= NULL
)
6699 printf (_("\n Section to Segment mapping:\n"));
6700 printf (_(" Segment Sections...\n"));
6702 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
6705 Elf_Internal_Shdr
* section
;
6707 segment
= filedata
->program_headers
+ i
;
6708 section
= filedata
->section_headers
+ 1;
6710 printf (" %2.2d ", i
);
6712 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
6714 if (!ELF_TBSS_SPECIAL (section
, segment
)
6715 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
6716 printf ("%s ", printable_section_name (filedata
, section
));
6723 filedata
->dynamic_addr
= dynamic_addr
;
6724 filedata
->dynamic_size
= dynamic_size
? dynamic_size
: 1;
6728 filedata
->dynamic_addr
= 0;
6729 filedata
->dynamic_size
= 1;
6733 /* Find the file offset corresponding to VMA by using the program headers. */
6736 offset_from_vma (Filedata
* filedata
, uint64_t vma
, uint64_t size
)
6738 Elf_Internal_Phdr
* seg
;
6740 if (! get_program_headers (filedata
))
6742 warn (_("Cannot interpret virtual addresses without program headers.\n"));
6746 for (seg
= filedata
->program_headers
;
6747 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
6750 if (seg
->p_type
!= PT_LOAD
)
6753 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
6754 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
6755 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
6758 warn (_("Virtual address %#" PRIx64
6759 " not located in any PT_LOAD segment.\n"), vma
);
6764 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
6765 If PROBE is true, this is just a probe and we do not generate any error
6766 messages if the load fails. */
6769 get_32bit_section_headers (Filedata
* filedata
, bool probe
)
6771 Elf32_External_Shdr
* shdrs
;
6772 Elf_Internal_Shdr
* internal
;
6774 unsigned int size
= filedata
->file_header
.e_shentsize
;
6775 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
6777 /* PR binutils/17531: Cope with unexpected section header sizes. */
6778 if (size
== 0 || num
== 0)
6781 /* The section header cannot be at the start of the file - that is
6782 where the ELF file header is located. A file with absolutely no
6783 sections in it will use a shoff of 0. */
6784 if (filedata
->file_header
.e_shoff
== 0)
6787 if (size
< sizeof * shdrs
)
6790 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
6793 if (!probe
&& size
> sizeof * shdrs
)
6794 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
6796 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
6798 probe
? NULL
: _("section headers"));
6802 filedata
->section_headers
= (Elf_Internal_Shdr
*)
6803 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
6804 if (filedata
->section_headers
== NULL
)
6807 error (_("Out of memory reading %u section headers\n"), num
);
6812 for (i
= 0, internal
= filedata
->section_headers
;
6816 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
6817 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
6818 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
6819 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
6820 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
6821 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
6822 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
6823 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
6824 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
6825 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
6826 if (!probe
&& internal
->sh_link
> num
)
6827 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
6828 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
6829 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
6836 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
6839 get_64bit_section_headers (Filedata
* filedata
, bool probe
)
6841 Elf64_External_Shdr
* shdrs
;
6842 Elf_Internal_Shdr
* internal
;
6844 unsigned int size
= filedata
->file_header
.e_shentsize
;
6845 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
6847 /* PR binutils/17531: Cope with unexpected section header sizes. */
6848 if (size
== 0 || num
== 0)
6851 /* The section header cannot be at the start of the file - that is
6852 where the ELF file header is located. A file with absolutely no
6853 sections in it will use a shoff of 0. */
6854 if (filedata
->file_header
.e_shoff
== 0)
6857 if (size
< sizeof * shdrs
)
6860 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
6864 if (! probe
&& size
> sizeof * shdrs
)
6865 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
6867 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
6868 filedata
->file_header
.e_shoff
,
6870 probe
? NULL
: _("section headers"));
6874 filedata
->section_headers
= (Elf_Internal_Shdr
*)
6875 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
6876 if (filedata
->section_headers
== NULL
)
6879 error (_("Out of memory reading %u section headers\n"), num
);
6884 for (i
= 0, internal
= filedata
->section_headers
;
6888 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
6889 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
6890 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
6891 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
6892 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
6893 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
6894 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
6895 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
6896 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
6897 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
6898 if (!probe
&& internal
->sh_link
> num
)
6899 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
6900 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
6901 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
6909 get_section_headers (Filedata
*filedata
, bool probe
)
6911 if (filedata
->section_headers
!= NULL
)
6915 return get_32bit_section_headers (filedata
, probe
);
6917 return get_64bit_section_headers (filedata
, probe
);
6920 static Elf_Internal_Sym
*
6921 get_32bit_elf_symbols (Filedata
*filedata
,
6922 Elf_Internal_Shdr
*section
,
6923 uint64_t *num_syms_return
)
6925 uint64_t number
= 0;
6926 Elf32_External_Sym
* esyms
= NULL
;
6927 Elf_External_Sym_Shndx
* shndx
= NULL
;
6928 Elf_Internal_Sym
* isyms
= NULL
;
6929 Elf_Internal_Sym
* psym
;
6931 elf_section_list
* entry
;
6933 if (section
->sh_size
== 0)
6935 if (num_syms_return
!= NULL
)
6936 * num_syms_return
= 0;
6940 /* Run some sanity checks first. */
6941 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
6943 error (_("Section %s has an invalid sh_entsize of %#" PRIx64
"\n"),
6944 printable_section_name (filedata
, section
),
6945 section
->sh_entsize
);
6949 if (section
->sh_size
> filedata
->file_size
)
6951 error (_("Section %s has an invalid sh_size of %#" PRIx64
"\n"),
6952 printable_section_name (filedata
, section
),
6957 number
= section
->sh_size
/ section
->sh_entsize
;
6959 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
6961 error (_("Size (%#" PRIx64
") of section %s "
6962 "is not a multiple of its sh_entsize (%#" PRIx64
")\n"),
6964 printable_section_name (filedata
, section
),
6965 section
->sh_entsize
);
6969 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
6970 section
->sh_size
, _("symbols"));
6975 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
6977 if (entry
->hdr
->sh_link
!= (size_t) (section
- filedata
->section_headers
))
6982 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
6986 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
6987 entry
->hdr
->sh_offset
,
6988 1, entry
->hdr
->sh_size
,
6989 _("symbol table section indices"));
6993 /* PR17531: file: heap-buffer-overflow */
6994 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
6996 error (_("Index section %s has an sh_size of %#" PRIx64
" - expected %#" PRIx64
"\n"),
6997 printable_section_name (filedata
, entry
->hdr
),
6998 entry
->hdr
->sh_size
,
7004 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
7008 error (_("Out of memory reading %" PRIu64
" symbols\n"), number
);
7012 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
7014 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
7015 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
7016 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
7017 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
7018 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
7020 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
7021 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
7022 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
7023 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
7024 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
7031 if (num_syms_return
!= NULL
)
7032 * num_syms_return
= isyms
== NULL
? 0 : number
;
7037 static Elf_Internal_Sym
*
7038 get_64bit_elf_symbols (Filedata
*filedata
,
7039 Elf_Internal_Shdr
*section
,
7040 uint64_t *num_syms_return
)
7042 uint64_t number
= 0;
7043 Elf64_External_Sym
* esyms
= NULL
;
7044 Elf_External_Sym_Shndx
* shndx
= NULL
;
7045 Elf_Internal_Sym
* isyms
= NULL
;
7046 Elf_Internal_Sym
* psym
;
7048 elf_section_list
* entry
;
7050 if (section
->sh_size
== 0)
7052 if (num_syms_return
!= NULL
)
7053 * num_syms_return
= 0;
7057 /* Run some sanity checks first. */
7058 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
7060 error (_("Section %s has an invalid sh_entsize of %#" PRIx64
"\n"),
7061 printable_section_name (filedata
, section
),
7062 section
->sh_entsize
);
7066 if (section
->sh_size
> filedata
->file_size
)
7068 error (_("Section %s has an invalid sh_size of %#" PRIx64
"\n"),
7069 printable_section_name (filedata
, section
),
7074 number
= section
->sh_size
/ section
->sh_entsize
;
7076 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
7078 error (_("Size (%#" PRIx64
") of section %s "
7079 "is not a multiple of its sh_entsize (%#" PRIx64
")\n"),
7081 printable_section_name (filedata
, section
),
7082 section
->sh_entsize
);
7086 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
7087 section
->sh_size
, _("symbols"));
7092 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
7094 if (entry
->hdr
->sh_link
!= (size_t) (section
- filedata
->section_headers
))
7099 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
7103 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
7104 entry
->hdr
->sh_offset
,
7105 1, entry
->hdr
->sh_size
,
7106 _("symbol table section indices"));
7110 /* PR17531: file: heap-buffer-overflow */
7111 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
7113 error (_("Index section %s has an sh_size of %#" PRIx64
" - expected %#" PRIx64
"\n"),
7114 printable_section_name (filedata
, entry
->hdr
),
7115 entry
->hdr
->sh_size
,
7121 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
7125 error (_("Out of memory reading %" PRIu64
" symbols\n"), number
);
7129 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
7131 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
7132 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
7133 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
7134 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
7136 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
7138 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
7139 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
7140 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
7142 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
7143 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
7150 if (num_syms_return
!= NULL
)
7151 * num_syms_return
= isyms
== NULL
? 0 : number
;
7156 static Elf_Internal_Sym
*
7157 get_elf_symbols (Filedata
*filedata
,
7158 Elf_Internal_Shdr
*section
,
7159 uint64_t *num_syms_return
)
7162 return get_32bit_elf_symbols (filedata
, section
, num_syms_return
);
7164 return get_64bit_elf_symbols (filedata
, section
, num_syms_return
);
7168 get_elf_section_flags (Filedata
* filedata
, uint64_t sh_flags
)
7170 static char buff
[1024];
7172 unsigned int field_size
= is_32bit_elf
? 8 : 16;
7174 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
7175 uint64_t os_flags
= 0;
7176 uint64_t proc_flags
= 0;
7177 uint64_t unknown_flags
= 0;
7185 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
7186 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
7187 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
7188 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
7189 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
7190 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
7191 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
7192 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
7193 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
7194 /* 9 */ { STRING_COMMA_LEN ("TLS") },
7195 /* IA-64 specific. */
7196 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
7197 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
7198 /* IA-64 OpenVMS specific. */
7199 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
7200 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
7201 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
7202 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
7203 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
7204 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
7206 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
7207 /* SPARC specific. */
7208 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
7209 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
7211 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
7212 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
7213 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
7215 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
7217 /* 25 */ { STRING_COMMA_LEN ("VLE") },
7219 /* 26 */ { STRING_COMMA_LEN ("GNU_RETAIN") },
7222 if (do_section_details
)
7223 p
+= sprintf (p
, "[%*.*lx]: ",
7224 field_size
, field_size
, (unsigned long) sh_flags
);
7230 flag
= sh_flags
& - sh_flags
;
7233 if (do_section_details
)
7237 case SHF_WRITE
: sindex
= 0; break;
7238 case SHF_ALLOC
: sindex
= 1; break;
7239 case SHF_EXECINSTR
: sindex
= 2; break;
7240 case SHF_MERGE
: sindex
= 3; break;
7241 case SHF_STRINGS
: sindex
= 4; break;
7242 case SHF_INFO_LINK
: sindex
= 5; break;
7243 case SHF_LINK_ORDER
: sindex
= 6; break;
7244 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
7245 case SHF_GROUP
: sindex
= 8; break;
7246 case SHF_TLS
: sindex
= 9; break;
7247 case SHF_EXCLUDE
: sindex
= 18; break;
7248 case SHF_COMPRESSED
: sindex
= 20; break;
7252 switch (filedata
->file_header
.e_machine
)
7255 if (flag
== SHF_IA_64_SHORT
)
7257 else if (flag
== SHF_IA_64_NORECOV
)
7259 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
7262 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
7263 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
7264 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
7265 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
7266 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
7267 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
7277 case EM_OLD_SPARCV9
:
7278 case EM_SPARC32PLUS
:
7281 if (flag
== SHF_ORDERED
)
7288 case SHF_ENTRYSECT
: sindex
= 21; break;
7289 case SHF_ARM_PURECODE
: sindex
= 22; break;
7290 case SHF_COMDEF
: sindex
= 23; break;
7295 if (flag
== SHF_PPC_VLE
)
7302 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
7305 case ELFOSABI_FREEBSD
:
7306 if (flag
== SHF_GNU_RETAIN
)
7310 if (flag
== SHF_GNU_MBIND
)
7311 /* We should not recognize SHF_GNU_MBIND for
7312 ELFOSABI_NONE, but binutils as of 2019-07-23 did
7313 not set the EI_OSABI header byte. */
7324 if (p
!= buff
+ field_size
+ 4)
7326 if (size
< (10 + 2))
7328 warn (_("Internal error: not enough buffer room for section flag info"));
7329 return _("<unknown>");
7336 size
-= flags
[sindex
].len
;
7337 p
= stpcpy (p
, flags
[sindex
].str
);
7339 else if (flag
& SHF_MASKOS
)
7341 else if (flag
& SHF_MASKPROC
)
7344 unknown_flags
|= flag
;
7350 case SHF_WRITE
: *p
= 'W'; break;
7351 case SHF_ALLOC
: *p
= 'A'; break;
7352 case SHF_EXECINSTR
: *p
= 'X'; break;
7353 case SHF_MERGE
: *p
= 'M'; break;
7354 case SHF_STRINGS
: *p
= 'S'; break;
7355 case SHF_INFO_LINK
: *p
= 'I'; break;
7356 case SHF_LINK_ORDER
: *p
= 'L'; break;
7357 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
7358 case SHF_GROUP
: *p
= 'G'; break;
7359 case SHF_TLS
: *p
= 'T'; break;
7360 case SHF_EXCLUDE
: *p
= 'E'; break;
7361 case SHF_COMPRESSED
: *p
= 'C'; break;
7364 if ((filedata
->file_header
.e_machine
== EM_X86_64
7365 || filedata
->file_header
.e_machine
== EM_L1OM
7366 || filedata
->file_header
.e_machine
== EM_K1OM
)
7367 && flag
== SHF_X86_64_LARGE
)
7369 else if (filedata
->file_header
.e_machine
== EM_ARM
7370 && flag
== SHF_ARM_PURECODE
)
7372 else if (filedata
->file_header
.e_machine
== EM_PPC
7373 && flag
== SHF_PPC_VLE
)
7375 else if (flag
& SHF_MASKOS
)
7377 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
7380 case ELFOSABI_FREEBSD
:
7381 if (flag
== SHF_GNU_RETAIN
)
7388 if (flag
== SHF_GNU_MBIND
)
7390 /* We should not recognize SHF_GNU_MBIND for
7391 ELFOSABI_NONE, but binutils as of 2019-07-23 did
7392 not set the EI_OSABI header byte. */
7399 sh_flags
&= ~SHF_MASKOS
;
7403 else if (flag
& SHF_MASKPROC
)
7406 sh_flags
&= ~ SHF_MASKPROC
;
7416 if (do_section_details
)
7420 if (p
!= buff
+ field_size
+ 4)
7422 if (size
< 2 + 5 + field_size
+ 1)
7424 warn (_("Internal error: not enough buffer room for section flag info"));
7425 return _("<unknown>");
7431 size
-= 5 + field_size
;
7432 p
+= sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
7433 (unsigned long) os_flags
);
7437 if (p
!= buff
+ field_size
+ 4)
7439 if (size
< 2 + 7 + field_size
+ 1)
7441 warn (_("Internal error: not enough buffer room for section flag info"));
7442 return _("<unknown>");
7448 size
-= 7 + field_size
;
7449 p
+= sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
7450 (unsigned long) proc_flags
);
7454 if (p
!= buff
+ field_size
+ 4)
7456 if (size
< 2 + 10 + field_size
+ 1)
7458 warn (_("Internal error: not enough buffer room for section flag info"));
7459 return _("<unknown>");
7465 size
-= 10 + field_size
;
7466 p
+= sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
7467 (unsigned long) unknown_flags
);
7475 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
7476 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
,
7481 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
7483 if (size
< sizeof (* echdr
))
7485 error (_("Compressed section is too small even for a compression header\n"));
7489 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
7490 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
7491 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
7492 return sizeof (*echdr
);
7496 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
7498 if (size
< sizeof (* echdr
))
7500 error (_("Compressed section is too small even for a compression header\n"));
7504 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
7505 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
7506 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
7507 return sizeof (*echdr
);
7512 process_section_headers (Filedata
* filedata
)
7514 Elf_Internal_Shdr
* section
;
7517 if (filedata
->file_header
.e_shnum
== 0)
7519 /* PR binutils/12467. */
7520 if (filedata
->file_header
.e_shoff
!= 0)
7522 warn (_("possibly corrupt ELF file header - it has a non-zero"
7523 " section header offset, but no section headers\n"));
7526 else if (do_sections
)
7527 printf (_("\nThere are no sections in this file.\n"));
7532 if (do_sections
&& !do_header
)
7534 if (filedata
->is_separate
&& process_links
)
7535 printf (_("In linked file '%s': "), filedata
->file_name
);
7536 if (! filedata
->is_separate
|| process_links
)
7537 printf (ngettext ("There is %d section header, "
7538 "starting at offset %#" PRIx64
":\n",
7539 "There are %d section headers, "
7540 "starting at offset %#" PRIx64
":\n",
7541 filedata
->file_header
.e_shnum
),
7542 filedata
->file_header
.e_shnum
,
7543 filedata
->file_header
.e_shoff
);
7546 if (!get_section_headers (filedata
, false))
7549 /* Read in the string table, so that we have names to display. */
7550 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
7551 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
7553 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
7555 if (section
->sh_size
!= 0)
7557 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
7558 1, section
->sh_size
,
7561 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
7565 /* Scan the sections for the dynamic symbol table
7566 and dynamic string table and debug sections. */
7567 eh_addr_size
= is_32bit_elf
? 4 : 8;
7568 switch (filedata
->file_header
.e_machine
)
7571 case EM_MIPS_RS3_LE
:
7572 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
7573 FDE addresses. However, the ABI also has a semi-official ILP32
7574 variant for which the normal FDE address size rules apply.
7576 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
7577 section, where XX is the size of longs in bits. Unfortunately,
7578 earlier compilers provided no way of distinguishing ILP32 objects
7579 from LP64 objects, so if there's any doubt, we should assume that
7580 the official LP64 form is being used. */
7581 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
7582 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
7588 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
7590 case E_H8_MACH_H8300
:
7591 case E_H8_MACH_H8300HN
:
7592 case E_H8_MACH_H8300SN
:
7593 case E_H8_MACH_H8300SXN
:
7596 case E_H8_MACH_H8300H
:
7597 case E_H8_MACH_H8300S
:
7598 case E_H8_MACH_H8300SX
:
7606 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
7608 case EF_M32C_CPU_M16C
:
7615 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
7618 uint64_t expected_entsize = is_32bit_elf ? size32 : size64; \
7619 if (section->sh_entsize != expected_entsize) \
7621 error (_("Section %d has invalid sh_entsize of %" PRIx64 "\n"), \
7622 i, section->sh_entsize); \
7623 error (_("(Using the expected size of %" PRIx64 " for the rest of this dump)\n"), \
7624 expected_entsize); \
7625 section->sh_entsize = expected_entsize; \
7630 #define CHECK_ENTSIZE(section, i, type) \
7631 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
7632 sizeof (Elf64_External_##type))
7634 for (i
= 0, section
= filedata
->section_headers
;
7635 i
< filedata
->file_header
.e_shnum
;
7638 const char *name
= section_name_print (filedata
, section
);
7640 /* Run some sanity checks on the headers and
7641 possibly fill in some file data as well. */
7642 switch (section
->sh_type
)
7645 if (filedata
->dynamic_symbols
!= NULL
)
7647 error (_("File contains multiple dynamic symbol tables\n"));
7651 CHECK_ENTSIZE (section
, i
, Sym
);
7652 filedata
->dynamic_symbols
7653 = get_elf_symbols (filedata
, section
, &filedata
->num_dynamic_syms
);
7654 filedata
->dynamic_symtab_section
= section
;
7658 if (streq (name
, ".dynstr"))
7660 if (filedata
->dynamic_strings
!= NULL
)
7662 error (_("File contains multiple dynamic string tables\n"));
7666 filedata
->dynamic_strings
7667 = (char *) get_data (NULL
, filedata
, section
->sh_offset
,
7668 1, section
->sh_size
, _("dynamic strings"));
7669 filedata
->dynamic_strings_length
7670 = filedata
->dynamic_strings
== NULL
? 0 : section
->sh_size
;
7671 filedata
->dynamic_strtab_section
= section
;
7675 case SHT_SYMTAB_SHNDX
:
7677 elf_section_list
* entry
= xmalloc (sizeof * entry
);
7679 entry
->hdr
= section
;
7680 entry
->next
= filedata
->symtab_shndx_list
;
7681 filedata
->symtab_shndx_list
= entry
;
7686 CHECK_ENTSIZE (section
, i
, Sym
);
7690 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
7694 CHECK_ENTSIZE (section
, i
, Rel
);
7695 if (do_checks
&& section
->sh_size
== 0)
7696 warn (_("Section '%s': zero-sized relocation section\n"), name
);
7700 CHECK_ENTSIZE (section
, i
, Rela
);
7701 if (do_checks
&& section
->sh_size
== 0)
7702 warn (_("Section '%s': zero-sized relocation section\n"), name
);
7706 CHECK_ENTSIZE (section
, i
, Relr
);
7711 /* Having a zero sized section is not illegal according to the
7712 ELF standard, but it might be an indication that something
7713 is wrong. So issue a warning if we are running in lint mode. */
7714 if (do_checks
&& section
->sh_size
== 0)
7715 warn (_("Section '%s': has a size of zero - is this intended ?\n"), name
);
7722 if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
7723 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
7724 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
7725 || do_debug_str
|| do_debug_str_offsets
|| do_debug_loc
7727 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
7728 && (startswith (name
, ".debug_")
7729 || startswith (name
, ".zdebug_")))
7732 name
+= sizeof (".zdebug_") - 1;
7734 name
+= sizeof (".debug_") - 1;
7737 || (do_debug_info
&& startswith (name
, "info"))
7738 || (do_debug_info
&& startswith (name
, "types"))
7739 || (do_debug_abbrevs
&& startswith (name
, "abbrev"))
7740 || (do_debug_lines
&& strcmp (name
, "line") == 0)
7741 || (do_debug_lines
&& startswith (name
, "line."))
7742 || (do_debug_pubnames
&& startswith (name
, "pubnames"))
7743 || (do_debug_pubtypes
&& startswith (name
, "pubtypes"))
7744 || (do_debug_pubnames
&& startswith (name
, "gnu_pubnames"))
7745 || (do_debug_pubtypes
&& startswith (name
, "gnu_pubtypes"))
7746 || (do_debug_aranges
&& startswith (name
, "aranges"))
7747 || (do_debug_ranges
&& startswith (name
, "ranges"))
7748 || (do_debug_ranges
&& startswith (name
, "rnglists"))
7749 || (do_debug_frames
&& startswith (name
, "frame"))
7750 || (do_debug_macinfo
&& startswith (name
, "macinfo"))
7751 || (do_debug_macinfo
&& startswith (name
, "macro"))
7752 || (do_debug_str
&& startswith (name
, "str"))
7753 || (do_debug_links
&& startswith (name
, "sup"))
7754 || (do_debug_str_offsets
&& startswith (name
, "str_offsets"))
7755 || (do_debug_loc
&& startswith (name
, "loc"))
7756 || (do_debug_loc
&& startswith (name
, "loclists"))
7757 || (do_debug_addr
&& startswith (name
, "addr"))
7758 || (do_debug_cu_index
&& startswith (name
, "cu_index"))
7759 || (do_debug_cu_index
&& startswith (name
, "tu_index"))
7761 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7763 /* Linkonce section to be combined with .debug_info at link time. */
7764 else if ((do_debugging
|| do_debug_info
)
7765 && startswith (name
, ".gnu.linkonce.wi."))
7766 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7767 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
7768 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7769 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
7770 || streq (name
, ".debug_names")))
7771 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7772 /* Trace sections for Itanium VMS. */
7773 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
7774 || do_trace_aranges
)
7775 && startswith (name
, ".trace_"))
7777 name
+= sizeof (".trace_") - 1;
7780 || (do_trace_info
&& streq (name
, "info"))
7781 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
7782 || (do_trace_aranges
&& streq (name
, "aranges"))
7784 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7786 else if ((do_debugging
|| do_debug_links
)
7787 && (startswith (name
, ".gnu_debuglink")
7788 || startswith (name
, ".gnu_debugaltlink")))
7789 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7795 if (filedata
->is_separate
&& ! process_links
)
7798 if (filedata
->is_separate
)
7799 printf (_("\nSection Headers in linked file '%s':\n"), filedata
->file_name
);
7800 else if (filedata
->file_header
.e_shnum
> 1)
7801 printf (_("\nSection Headers:\n"));
7803 printf (_("\nSection Header:\n"));
7807 if (do_section_details
)
7809 printf (_(" [Nr] Name\n"));
7810 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
7814 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
7818 if (do_section_details
)
7820 printf (_(" [Nr] Name\n"));
7821 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
7825 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
7829 if (do_section_details
)
7831 printf (_(" [Nr] Name\n"));
7832 printf (_(" Type Address Offset Link\n"));
7833 printf (_(" Size EntSize Info Align\n"));
7837 printf (_(" [Nr] Name Type Address Offset\n"));
7838 printf (_(" Size EntSize Flags Link Info Align\n"));
7842 if (do_section_details
)
7843 printf (_(" Flags\n"));
7845 for (i
= 0, section
= filedata
->section_headers
;
7846 i
< filedata
->file_header
.e_shnum
;
7849 /* Run some sanity checks on the section header. */
7851 /* Check the sh_link field. */
7852 switch (section
->sh_type
)
7856 if (section
->sh_link
== 0
7857 && (filedata
->file_header
.e_type
== ET_EXEC
7858 || filedata
->file_header
.e_type
== ET_DYN
))
7859 /* A dynamic relocation section where all entries use a
7860 zero symbol index need not specify a symtab section. */
7863 case SHT_SYMTAB_SHNDX
:
7867 case SHT_GNU_versym
:
7868 if (section
->sh_link
== 0
7869 || section
->sh_link
>= filedata
->file_header
.e_shnum
7870 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
7871 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
7872 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
7873 i
, section
->sh_link
);
7879 case SHT_GNU_verneed
:
7880 case SHT_GNU_verdef
:
7881 case SHT_GNU_LIBLIST
:
7882 if (section
->sh_link
== 0
7883 || section
->sh_link
>= filedata
->file_header
.e_shnum
7884 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
7885 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
7886 i
, section
->sh_link
);
7889 case SHT_INIT_ARRAY
:
7890 case SHT_FINI_ARRAY
:
7891 case SHT_PREINIT_ARRAY
:
7892 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
7893 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
7894 i
, section
->sh_link
);
7898 /* FIXME: Add support for target specific section types. */
7899 #if 0 /* Currently we do not check other section types as there are too
7900 many special cases. Stab sections for example have a type
7901 of SHT_PROGBITS but an sh_link field that links to the .stabstr
7903 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
7904 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
7905 i
, section
->sh_link
);
7910 /* Check the sh_info field. */
7911 switch (section
->sh_type
)
7915 if (section
->sh_info
== 0
7916 && (filedata
->file_header
.e_type
== ET_EXEC
7917 || filedata
->file_header
.e_type
== ET_DYN
))
7918 /* Dynamic relocations apply to segments, so they do not
7919 need to specify the section they relocate. */
7921 if (section
->sh_info
== 0
7922 || section
->sh_info
>= filedata
->file_header
.e_shnum
7923 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
7924 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
7925 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
7926 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
7927 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
7928 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
7929 /* FIXME: Are other section types valid ? */
7930 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
7931 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
7932 i
, section
->sh_info
);
7937 case SHT_SYMTAB_SHNDX
:
7938 case SHT_INIT_ARRAY
:
7939 case SHT_FINI_ARRAY
:
7940 case SHT_PREINIT_ARRAY
:
7941 if (section
->sh_info
!= 0)
7942 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
7943 i
, section
->sh_info
);
7949 /* A symbol index - we assume that it is valid. */
7953 /* FIXME: Add support for target specific section types. */
7954 if (section
->sh_type
== SHT_NOBITS
)
7955 /* NOBITS section headers with non-zero sh_info fields can be
7956 created when a binary is stripped of everything but its debug
7957 information. The stripped sections have their headers
7958 preserved but their types set to SHT_NOBITS. So do not check
7959 this type of section. */
7961 else if (section
->sh_flags
& SHF_INFO_LINK
)
7963 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
7964 warn (_("[%2u]: Expected link to another section in info field"), i
);
7966 else if (section
->sh_type
< SHT_LOOS
7967 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
7968 && section
->sh_info
!= 0)
7969 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
7970 i
, section
->sh_info
);
7974 /* Check the sh_size field. */
7975 if (section
->sh_size
> filedata
->file_size
7976 && section
->sh_type
!= SHT_NOBITS
7977 && section
->sh_type
!= SHT_NULL
7978 && section
->sh_type
< SHT_LOOS
)
7979 warn (_("Size of section %u is larger than the entire file!\n"), i
);
7981 printf (" [%2u] ", i
);
7982 if (do_section_details
)
7983 printf ("%s\n ", printable_section_name (filedata
, section
));
7985 print_symbol (-17, section_name_print (filedata
, section
));
7987 printf (do_wide
? " %-15s " : " %-15.15s ",
7988 get_section_type_name (filedata
, section
->sh_type
));
7992 const char * link_too_big
= NULL
;
7994 print_vma (section
->sh_addr
, LONG_HEX
);
7996 printf ( " %6.6lx %6.6lx %2.2lx",
7997 (unsigned long) section
->sh_offset
,
7998 (unsigned long) section
->sh_size
,
7999 (unsigned long) section
->sh_entsize
);
8001 if (do_section_details
)
8002 fputs (" ", stdout
);
8004 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
8006 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
8009 /* The sh_link value is out of range. Normally this indicates
8010 an error but it can have special values in Solaris binaries. */
8011 switch (filedata
->file_header
.e_machine
)
8018 case EM_OLD_SPARCV9
:
8019 case EM_SPARC32PLUS
:
8022 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
8023 link_too_big
= "BEFORE";
8024 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
8025 link_too_big
= "AFTER";
8032 if (do_section_details
)
8034 if (link_too_big
!= NULL
&& * link_too_big
)
8035 printf ("<%s> ", link_too_big
);
8037 printf ("%2u ", section
->sh_link
);
8038 printf ("%3u %2lu\n", section
->sh_info
,
8039 (unsigned long) section
->sh_addralign
);
8042 printf ("%2u %3u %2lu\n",
8045 (unsigned long) section
->sh_addralign
);
8047 if (link_too_big
&& ! * link_too_big
)
8048 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
8049 i
, section
->sh_link
);
8053 print_vma (section
->sh_addr
, LONG_HEX
);
8055 if ((long) section
->sh_offset
== section
->sh_offset
)
8056 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
8060 print_vma (section
->sh_offset
, LONG_HEX
);
8063 if ((unsigned long) section
->sh_size
== section
->sh_size
)
8064 printf (" %6.6lx", (unsigned long) section
->sh_size
);
8068 print_vma (section
->sh_size
, LONG_HEX
);
8071 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
8072 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
8076 print_vma (section
->sh_entsize
, LONG_HEX
);
8079 if (do_section_details
)
8080 fputs (" ", stdout
);
8082 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
8084 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
8086 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
8087 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
8090 print_vma (section
->sh_addralign
, DEC
);
8094 else if (do_section_details
)
8097 print_vma (section
->sh_addr
, LONG_HEX
);
8098 if ((long) section
->sh_offset
== section
->sh_offset
)
8099 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
8103 print_vma (section
->sh_offset
, LONG_HEX
);
8105 printf (" %u\n ", section
->sh_link
);
8106 print_vma (section
->sh_size
, LONG_HEX
);
8108 print_vma (section
->sh_entsize
, LONG_HEX
);
8110 printf (" %-16u %lu\n",
8112 (unsigned long) section
->sh_addralign
);
8117 print_vma (section
->sh_addr
, LONG_HEX
);
8118 if ((long) section
->sh_offset
== section
->sh_offset
)
8119 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
8123 print_vma (section
->sh_offset
, LONG_HEX
);
8126 print_vma (section
->sh_size
, LONG_HEX
);
8128 print_vma (section
->sh_entsize
, LONG_HEX
);
8130 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
8132 printf (" %2u %3u %lu\n",
8135 (unsigned long) section
->sh_addralign
);
8138 if (do_section_details
)
8140 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
8141 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
8143 /* Minimum section size is 12 bytes for 32-bit compression
8144 header + 12 bytes for compressed data header. */
8145 unsigned char buf
[24];
8147 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
8148 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
8149 sizeof (buf
), _("compression header")))
8151 Elf_Internal_Chdr chdr
;
8153 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
8154 printf (_(" [<corrupt>]\n"));
8157 if (chdr
.ch_type
== ch_compress_zlib
)
8159 else if (chdr
.ch_type
== ch_compress_zstd
)
8162 printf (_(" [<unknown>: 0x%x], "),
8164 print_vma (chdr
.ch_size
, LONG_HEX
);
8165 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
8172 if (!do_section_details
)
8174 /* The ordering of the letters shown here matches the ordering of the
8175 corresponding SHF_xxx values, and hence the order in which these
8176 letters will be displayed to the user. */
8177 printf (_("Key to Flags:\n\
8178 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
8179 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
8180 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
8181 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
8184 case ELFOSABI_FREEBSD
:
8185 printf (_("R (retain), "));
8188 printf (_("D (mbind), "));
8193 if (filedata
->file_header
.e_machine
== EM_X86_64
8194 || filedata
->file_header
.e_machine
== EM_L1OM
8195 || filedata
->file_header
.e_machine
== EM_K1OM
)
8196 printf (_("l (large), "));
8197 else if (filedata
->file_header
.e_machine
== EM_ARM
)
8198 printf (_("y (purecode), "));
8199 else if (filedata
->file_header
.e_machine
== EM_PPC
)
8200 printf (_("v (VLE), "));
8201 printf ("p (processor specific)\n");
8208 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
8209 Elf_Internal_Sym
**symtab
, uint64_t *nsyms
,
8210 char **strtab
, uint64_t *strtablen
)
8214 *symtab
= get_elf_symbols (filedata
, symsec
, nsyms
);
8216 if (*symtab
== NULL
)
8219 if (symsec
->sh_link
!= 0)
8221 Elf_Internal_Shdr
*strsec
;
8223 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
8225 error (_("Bad sh_link in symbol table section\n"));
8232 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
8234 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
8235 1, strsec
->sh_size
, _("string table"));
8236 if (*strtab
== NULL
)
8243 *strtablen
= strsec
->sh_size
;
8249 get_group_flags (unsigned int flags
)
8251 static char buff
[128];
8255 else if (flags
== GRP_COMDAT
)
8258 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
8260 flags
& GRP_MASKOS
? _("<OS specific>") : "",
8261 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
8262 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
8263 ? _("<unknown>") : ""));
8269 process_section_groups (Filedata
* filedata
)
8271 Elf_Internal_Shdr
* section
;
8273 struct group
* group
;
8274 Elf_Internal_Shdr
* symtab_sec
;
8275 Elf_Internal_Shdr
* strtab_sec
;
8276 Elf_Internal_Sym
* symtab
;
8281 /* Don't process section groups unless needed. */
8282 if (!do_unwind
&& !do_section_groups
)
8285 if (filedata
->file_header
.e_shnum
== 0)
8287 if (do_section_groups
)
8289 if (filedata
->is_separate
)
8290 printf (_("\nThere are no sections group in linked file '%s'.\n"),
8291 filedata
->file_name
);
8293 printf (_("\nThere are no section groups in this file.\n"));
8298 if (filedata
->section_headers
== NULL
)
8300 error (_("Section headers are not available!\n"));
8301 /* PR 13622: This can happen with a corrupt ELF header. */
8305 filedata
->section_headers_groups
8306 = (struct group
**) calloc (filedata
->file_header
.e_shnum
,
8307 sizeof (struct group
*));
8309 if (filedata
->section_headers_groups
== NULL
)
8311 error (_("Out of memory reading %u section group headers\n"),
8312 filedata
->file_header
.e_shnum
);
8316 /* Scan the sections for the group section. */
8317 filedata
->group_count
= 0;
8318 for (i
= 0, section
= filedata
->section_headers
;
8319 i
< filedata
->file_header
.e_shnum
;
8321 if (section
->sh_type
== SHT_GROUP
)
8322 filedata
->group_count
++;
8324 if (filedata
->group_count
== 0)
8326 if (do_section_groups
)
8328 if (filedata
->is_separate
)
8329 printf (_("\nThere are no section groups in linked file '%s'.\n"),
8330 filedata
->file_name
);
8332 printf (_("\nThere are no section groups in this file.\n"));
8338 filedata
->section_groups
= (struct group
*) calloc (filedata
->group_count
,
8339 sizeof (struct group
));
8341 if (filedata
->section_groups
== NULL
)
8343 error (_("Out of memory reading %zu groups\n"), filedata
->group_count
);
8354 if (filedata
->is_separate
)
8355 printf (_("Section groups in linked file '%s'\n"), filedata
->file_name
);
8357 for (i
= 0, section
= filedata
->section_headers
, group
= filedata
->section_groups
;
8358 i
< filedata
->file_header
.e_shnum
;
8361 if (section
->sh_type
== SHT_GROUP
)
8363 const char * name
= printable_section_name (filedata
, section
);
8364 const char * group_name
;
8365 unsigned char * start
;
8366 unsigned char * indices
;
8367 unsigned int entry
, j
, size
;
8368 Elf_Internal_Shdr
* sec
;
8369 Elf_Internal_Sym
* sym
;
8371 /* Get the symbol table. */
8372 if (section
->sh_link
>= filedata
->file_header
.e_shnum
8373 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
8376 error (_("Bad sh_link in group section `%s'\n"), name
);
8380 if (symtab_sec
!= sec
)
8384 symtab
= get_elf_symbols (filedata
, symtab_sec
, & num_syms
);
8389 error (_("Corrupt header in group section `%s'\n"), name
);
8393 if (section
->sh_info
>= num_syms
)
8395 error (_("Bad sh_info in group section `%s'\n"), name
);
8399 sym
= symtab
+ section
->sh_info
;
8401 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
8403 if (sym
->st_shndx
== 0
8404 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
8406 error (_("Bad sh_info in group section `%s'\n"), name
);
8410 group_name
= section_name_print (filedata
,
8411 filedata
->section_headers
8420 /* Get the string table. */
8421 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
8429 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
8434 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
8435 1, strtab_sec
->sh_size
,
8437 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
8439 group_name
= sym
->st_name
< strtab_size
8440 ? strtab
+ sym
->st_name
: _("<corrupt>");
8443 /* PR 17531: file: loop. */
8444 if (section
->sh_entsize
> section
->sh_size
)
8446 error (_("Section %s has sh_entsize (%#" PRIx64
")"
8447 " which is larger than its size (%#" PRIx64
")\n"),
8448 printable_section_name (filedata
, section
),
8449 section
->sh_entsize
,
8454 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
8455 1, section
->sh_size
,
8461 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
8462 entry
= byte_get (indices
, 4);
8465 if (do_section_groups
)
8467 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
8468 get_group_flags (entry
), i
, name
, group_name
, size
);
8470 printf (_(" [Index] Name\n"));
8473 group
->group_index
= i
;
8475 for (j
= 0; j
< size
; j
++)
8477 struct group_list
* g
;
8479 entry
= byte_get (indices
, 4);
8482 if (entry
>= filedata
->file_header
.e_shnum
)
8484 static unsigned num_group_errors
= 0;
8486 if (num_group_errors
++ < 10)
8488 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
8489 entry
, i
, filedata
->file_header
.e_shnum
- 1);
8490 if (num_group_errors
== 10)
8491 warn (_("Further error messages about overlarge group section indices suppressed\n"));
8496 if (filedata
->section_headers_groups
[entry
] != NULL
)
8500 static unsigned num_errs
= 0;
8502 if (num_errs
++ < 10)
8504 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
8506 filedata
->section_headers_groups
[entry
]->group_index
);
8508 warn (_("Further error messages about already contained group sections suppressed\n"));
8514 /* Intel C/C++ compiler may put section 0 in a
8515 section group. We just warn it the first time
8516 and ignore it afterwards. */
8517 static bool warned
= false;
8520 error (_("section 0 in group section [%5u]\n"),
8521 filedata
->section_headers_groups
[entry
]->group_index
);
8527 filedata
->section_headers_groups
[entry
] = group
;
8529 if (do_section_groups
)
8531 sec
= filedata
->section_headers
+ entry
;
8532 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
8535 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
8536 g
->section_index
= entry
;
8537 g
->next
= group
->root
;
8552 /* Data used to display dynamic fixups. */
8554 struct ia64_vms_dynfixup
8556 uint64_t needed_ident
; /* Library ident number. */
8557 uint64_t needed
; /* Index in the dstrtab of the library name. */
8558 uint64_t fixup_needed
; /* Index of the library. */
8559 uint64_t fixup_rela_cnt
; /* Number of fixups. */
8560 uint64_t fixup_rela_off
; /* Fixups offset in the dynamic segment. */
8563 /* Data used to display dynamic relocations. */
8565 struct ia64_vms_dynimgrela
8567 uint64_t img_rela_cnt
; /* Number of relocations. */
8568 uint64_t img_rela_off
; /* Reloc offset in the dynamic segment. */
8571 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
8575 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
8576 struct ia64_vms_dynfixup
* fixup
,
8577 const char * strtab
,
8578 unsigned int strtab_sz
)
8580 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
8582 const char * lib_name
;
8584 imfs
= get_data (NULL
, filedata
,
8585 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
8586 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
8587 _("dynamic section image fixups"));
8591 if (fixup
->needed
< strtab_sz
)
8592 lib_name
= strtab
+ fixup
->needed
;
8595 warn (_("corrupt library name index of %#" PRIx64
8596 " found in dynamic entry"), fixup
->needed
);
8600 printf (_("\nImage fixups for needed library #%" PRId64
8601 ": %s - ident: %" PRIx64
"\n"),
8602 fixup
->fixup_needed
, lib_name
, fixup
->needed_ident
);
8604 (_("Seg Offset Type SymVec DataType\n"));
8606 for (i
= 0; i
< (size_t) fixup
->fixup_rela_cnt
; i
++)
8611 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
8612 printf ("%016" PRIx64
" ", BYTE_GET (imfs
[i
].fixup_offset
));
8613 type
= BYTE_GET (imfs
[i
].type
);
8614 rtype
= elf_ia64_reloc_type (type
);
8616 printf ("0x%08x ", type
);
8618 printf ("%-32s ", rtype
);
8619 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
8620 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
8627 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
8630 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
8632 Elf64_External_VMS_IMAGE_RELA
*imrs
;
8635 imrs
= get_data (NULL
, filedata
,
8636 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
8637 sizeof (*imrs
), imgrela
->img_rela_cnt
,
8638 _("dynamic section image relocations"));
8642 printf (_("\nImage relocs\n"));
8644 (_("Seg Offset Type Addend Seg Sym Off\n"));
8646 for (i
= 0; i
< (size_t) imgrela
->img_rela_cnt
; i
++)
8651 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
8652 printf ("%08" PRIx64
" ", BYTE_GET (imrs
[i
].rela_offset
));
8653 type
= BYTE_GET (imrs
[i
].type
);
8654 rtype
= elf_ia64_reloc_type (type
);
8656 printf ("0x%08x ", type
);
8658 printf ("%-31s ", rtype
);
8659 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
8660 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
8661 printf ("%08" PRIx64
"\n", BYTE_GET (imrs
[i
].sym_offset
));
8668 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
8671 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
8673 struct ia64_vms_dynfixup fixup
;
8674 struct ia64_vms_dynimgrela imgrela
;
8675 Elf_Internal_Dyn
*entry
;
8676 uint64_t strtab_off
= 0;
8677 uint64_t strtab_sz
= 0;
8678 char *strtab
= NULL
;
8681 memset (&fixup
, 0, sizeof (fixup
));
8682 memset (&imgrela
, 0, sizeof (imgrela
));
8684 /* Note: the order of the entries is specified by the OpenVMS specs. */
8685 for (entry
= filedata
->dynamic_section
;
8686 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
8689 switch (entry
->d_tag
)
8691 case DT_IA_64_VMS_STRTAB_OFFSET
:
8692 strtab_off
= entry
->d_un
.d_val
;
8695 strtab_sz
= entry
->d_un
.d_val
;
8697 strtab
= get_data (NULL
, filedata
,
8698 filedata
->dynamic_addr
+ strtab_off
,
8699 1, strtab_sz
, _("dynamic string section"));
8704 case DT_IA_64_VMS_NEEDED_IDENT
:
8705 fixup
.needed_ident
= entry
->d_un
.d_val
;
8708 fixup
.needed
= entry
->d_un
.d_val
;
8710 case DT_IA_64_VMS_FIXUP_NEEDED
:
8711 fixup
.fixup_needed
= entry
->d_un
.d_val
;
8713 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
8714 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
8716 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
8717 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
8718 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
8721 case DT_IA_64_VMS_IMG_RELA_CNT
:
8722 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
8724 case DT_IA_64_VMS_IMG_RELA_OFF
:
8725 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
8726 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
8745 relocation_type rel_type
;
8747 dynamic_relocations
[] =
8749 { "REL", DT_REL
, DT_RELSZ
, reltype_rel
},
8750 { "RELA", DT_RELA
, DT_RELASZ
, reltype_rela
},
8751 { "RELR", DT_RELR
, DT_RELRSZ
, reltype_relr
},
8752 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, reltype_unknown
}
8755 /* Process the reloc section. */
8758 process_relocs (Filedata
* filedata
)
8761 uint64_t rel_offset
;
8766 if (do_using_dynamic
)
8768 relocation_type rel_type
;
8770 bool has_dynamic_reloc
;
8773 has_dynamic_reloc
= false;
8775 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
8777 rel_type
= dynamic_relocations
[i
].rel_type
;
8778 name
= dynamic_relocations
[i
].name
;
8779 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
8780 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
8783 has_dynamic_reloc
= true;
8785 if (rel_type
== reltype_unknown
)
8787 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
8788 switch (filedata
->dynamic_info
[DT_PLTREL
])
8791 rel_type
= reltype_rel
;
8794 rel_type
= reltype_rela
;
8801 if (filedata
->is_separate
)
8803 (_("\nIn linked file '%s' section '%s' at offset %#" PRIx64
8804 " contains %" PRId64
" bytes:\n"),
8805 filedata
->file_name
, name
, rel_offset
, rel_size
);
8808 (_("\n'%s' relocation section at offset %#" PRIx64
8809 " contains %" PRId64
" bytes:\n"),
8810 name
, rel_offset
, rel_size
);
8812 dump_relocations (filedata
,
8813 offset_from_vma (filedata
, rel_offset
, rel_size
),
8815 filedata
->dynamic_symbols
,
8816 filedata
->num_dynamic_syms
,
8817 filedata
->dynamic_strings
,
8818 filedata
->dynamic_strings_length
,
8819 rel_type
, true /* is_dynamic */);
8823 if (is_ia64_vms (filedata
))
8824 if (process_ia64_vms_dynamic_relocs (filedata
))
8825 has_dynamic_reloc
= true;
8827 if (! has_dynamic_reloc
)
8829 if (filedata
->is_separate
)
8830 printf (_("\nThere are no dynamic relocations in linked file '%s'.\n"),
8831 filedata
->file_name
);
8833 printf (_("\nThere are no dynamic relocations in this file.\n"));
8838 Elf_Internal_Shdr
* section
;
8842 for (i
= 0, section
= filedata
->section_headers
;
8843 i
< filedata
->file_header
.e_shnum
;
8846 if ( section
->sh_type
!= SHT_RELA
8847 && section
->sh_type
!= SHT_REL
8848 && section
->sh_type
!= SHT_RELR
)
8851 rel_offset
= section
->sh_offset
;
8852 rel_size
= section
->sh_size
;
8856 relocation_type rel_type
;
8859 if (filedata
->is_separate
)
8860 printf (_("\nIn linked file '%s' relocation section "),
8861 filedata
->file_name
);
8863 printf (_("\nRelocation section "));
8865 if (filedata
->string_table
== NULL
)
8866 printf ("%d", section
->sh_name
);
8868 printf ("'%s'", printable_section_name (filedata
, section
));
8870 num_rela
= rel_size
/ section
->sh_entsize
;
8871 printf (ngettext (" at offset %#" PRIx64
8872 " contains %" PRIu64
" entry:\n",
8873 " at offset %#" PRIx64
8874 " contains %" PRId64
" entries:\n",
8876 rel_offset
, num_rela
);
8878 rel_type
= section
->sh_type
== SHT_RELA
? reltype_rela
:
8879 section
->sh_type
== SHT_REL
? reltype_rel
: reltype_relr
;
8881 if (section
->sh_link
!= 0
8882 && section
->sh_link
< filedata
->file_header
.e_shnum
)
8884 Elf_Internal_Shdr
*symsec
;
8885 Elf_Internal_Sym
*symtab
;
8887 uint64_t strtablen
= 0;
8888 char *strtab
= NULL
;
8890 symsec
= filedata
->section_headers
+ section
->sh_link
;
8891 if (symsec
->sh_type
!= SHT_SYMTAB
8892 && symsec
->sh_type
!= SHT_DYNSYM
)
8895 if (!get_symtab (filedata
, symsec
,
8896 &symtab
, &nsyms
, &strtab
, &strtablen
))
8899 dump_relocations (filedata
, rel_offset
, rel_size
,
8900 symtab
, nsyms
, strtab
, strtablen
,
8902 symsec
->sh_type
== SHT_DYNSYM
);
8907 dump_relocations (filedata
, rel_offset
, rel_size
,
8908 NULL
, 0, NULL
, 0, rel_type
, false /* is_dynamic */);
8916 /* Users sometimes forget the -D option, so try to be helpful. */
8917 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
8919 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
8921 if (filedata
->is_separate
)
8922 printf (_("\nThere are no static relocations in linked file '%s'."),
8923 filedata
->file_name
);
8925 printf (_("\nThere are no static relocations in this file."));
8926 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
8931 if (i
== ARRAY_SIZE (dynamic_relocations
))
8933 if (filedata
->is_separate
)
8934 printf (_("\nThere are no relocations in linked file '%s'.\n"),
8935 filedata
->file_name
);
8937 printf (_("\nThere are no relocations in this file.\n"));
8945 /* An absolute address consists of a section and an offset. If the
8946 section is NULL, the offset itself is the address, otherwise, the
8947 address equals to LOAD_ADDRESS(section) + offset. */
8951 unsigned short section
;
8955 /* Find the nearest symbol at or below ADDR. Returns the symbol
8956 name, if found, and the offset from the symbol to ADDR. */
8959 find_symbol_for_address (Filedata
*filedata
,
8960 Elf_Internal_Sym
*symtab
,
8963 uint64_t strtab_size
,
8964 struct absaddr addr
,
8965 const char **symname
,
8968 uint64_t dist
= 0x100000;
8969 Elf_Internal_Sym
* sym
;
8970 Elf_Internal_Sym
* beg
;
8971 Elf_Internal_Sym
* end
;
8972 Elf_Internal_Sym
* best
= NULL
;
8974 REMOVE_ARCH_BITS (addr
.offset
);
8976 end
= symtab
+ nsyms
;
8982 sym
= beg
+ (end
- beg
) / 2;
8984 value
= sym
->st_value
;
8985 REMOVE_ARCH_BITS (value
);
8987 if (sym
->st_name
!= 0
8988 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
8989 && addr
.offset
>= value
8990 && addr
.offset
- value
< dist
)
8993 dist
= addr
.offset
- value
;
8998 if (addr
.offset
< value
)
9006 *symname
= (best
->st_name
>= strtab_size
9007 ? _("<corrupt>") : strtab
+ best
->st_name
);
9013 *offset
= addr
.offset
;
9016 static /* signed */ int
9017 symcmp (const void *p
, const void *q
)
9019 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
9020 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
9022 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
9025 /* Process the unwind section. */
9027 #include "unwind-ia64.h"
9029 struct ia64_unw_table_entry
9031 struct absaddr start
;
9033 struct absaddr info
;
9036 struct ia64_unw_aux_info
9038 struct ia64_unw_table_entry
* table
; /* Unwind table. */
9039 uint64_t table_len
; /* Length of unwind table. */
9040 unsigned char * info
; /* Unwind info. */
9041 uint64_t info_size
; /* Size of unwind info. */
9042 uint64_t info_addr
; /* Starting address of unwind info. */
9043 uint64_t seg_base
; /* Starting address of segment. */
9044 Elf_Internal_Sym
* symtab
; /* The symbol table. */
9045 uint64_t nsyms
; /* Number of symbols. */
9046 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
9047 uint64_t nfuns
; /* Number of entries in funtab. */
9048 char * strtab
; /* The string table. */
9049 uint64_t strtab_size
; /* Size of string table. */
9053 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
9055 struct ia64_unw_table_entry
* tp
;
9060 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9061 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9062 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9063 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9065 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9067 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
9071 const unsigned char * dp
;
9072 const unsigned char * head
;
9073 const unsigned char * end
;
9074 const char * procname
;
9076 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
9077 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
9079 fputs ("\n<", stdout
);
9083 fputs (procname
, stdout
);
9086 printf ("+%" PRIx64
, offset
);
9089 fputs (">: [", stdout
);
9090 print_vma (tp
->start
.offset
, PREFIX_HEX
);
9091 fputc ('-', stdout
);
9092 print_vma (tp
->end
.offset
, PREFIX_HEX
);
9093 printf ("], info at +0x%" PRIx64
"\n",
9094 tp
->info
.offset
- aux
->seg_base
);
9096 /* PR 17531: file: 86232b32. */
9097 if (aux
->info
== NULL
)
9100 offset
= tp
->info
.offset
;
9101 if (tp
->info
.section
)
9103 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
9105 warn (_("Invalid section %u in table entry %td\n"),
9106 tp
->info
.section
, tp
- aux
->table
);
9110 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
9112 offset
-= aux
->info_addr
;
9113 /* PR 17531: file: 0997b4d1. */
9114 if (offset
>= aux
->info_size
9115 || aux
->info_size
- offset
< 8)
9117 warn (_("Invalid offset %" PRIx64
" in table entry %td\n"),
9118 tp
->info
.offset
, tp
- aux
->table
);
9123 head
= aux
->info
+ offset
;
9124 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
9126 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
9127 (unsigned) UNW_VER (stamp
),
9128 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
9129 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
9130 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
9131 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
9133 if (UNW_VER (stamp
) != 1)
9135 printf (_("\tUnknown version.\n"));
9140 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
9141 /* PR 17531: file: 16ceda89. */
9142 if (end
> aux
->info
+ aux
->info_size
)
9143 end
= aux
->info
+ aux
->info_size
;
9144 for (dp
= head
+ 8; dp
< end
;)
9145 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
9154 slurp_ia64_unwind_table (Filedata
* filedata
,
9155 struct ia64_unw_aux_info
* aux
,
9156 Elf_Internal_Shdr
* sec
)
9158 uint64_t size
, nrelas
, i
;
9159 Elf_Internal_Phdr
* seg
;
9160 struct ia64_unw_table_entry
* tep
;
9161 Elf_Internal_Shdr
* relsec
;
9162 Elf_Internal_Rela
* rela
;
9163 Elf_Internal_Rela
* rp
;
9164 unsigned char * table
;
9166 Elf_Internal_Sym
* sym
;
9167 const char * relname
;
9171 /* First, find the starting address of the segment that includes
9174 if (filedata
->file_header
.e_phnum
)
9176 if (! get_program_headers (filedata
))
9179 for (seg
= filedata
->program_headers
;
9180 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
9183 if (seg
->p_type
!= PT_LOAD
)
9186 if (sec
->sh_addr
>= seg
->p_vaddr
9187 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
9189 aux
->seg_base
= seg
->p_vaddr
;
9195 /* Second, build the unwind table from the contents of the unwind section: */
9196 size
= sec
->sh_size
;
9197 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
9202 aux
->table_len
= size
/ (3 * eh_addr_size
);
9203 aux
->table
= (struct ia64_unw_table_entry
*)
9204 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
9207 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
9209 tep
->start
.section
= SHN_UNDEF
;
9210 tep
->end
.section
= SHN_UNDEF
;
9211 tep
->info
.section
= SHN_UNDEF
;
9212 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
9213 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
9214 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
9215 tep
->start
.offset
+= aux
->seg_base
;
9216 tep
->end
.offset
+= aux
->seg_base
;
9217 tep
->info
.offset
+= aux
->seg_base
;
9221 /* Third, apply any relocations to the unwind table: */
9222 for (relsec
= filedata
->section_headers
;
9223 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
9226 if (relsec
->sh_type
!= SHT_RELA
9227 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
9228 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
9231 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
9240 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
9242 unsigned int sym_ndx
;
9243 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
9244 relname
= elf_ia64_reloc_type (r_type
);
9246 /* PR 17531: file: 9fa67536. */
9247 if (relname
== NULL
)
9249 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
9253 if (! startswith (relname
, "R_IA64_SEGREL"))
9255 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
9259 i
= rp
->r_offset
/ (3 * eh_addr_size
);
9261 /* PR 17531: file: 5bc8d9bf. */
9262 if (i
>= aux
->table_len
)
9264 warn (_("Skipping reloc with overlarge offset: %#" PRIx64
"\n"),
9269 sym_ndx
= get_reloc_symindex (rp
->r_info
);
9270 if (sym_ndx
>= aux
->nsyms
)
9272 warn (_("Skipping reloc with invalid symbol index: %u\n"),
9276 sym
= aux
->symtab
+ sym_ndx
;
9278 switch (rp
->r_offset
/ eh_addr_size
% 3)
9281 aux
->table
[i
].start
.section
= sym
->st_shndx
;
9282 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
9285 aux
->table
[i
].end
.section
= sym
->st_shndx
;
9286 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
9289 aux
->table
[i
].info
.section
= sym
->st_shndx
;
9290 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
9304 ia64_process_unwind (Filedata
* filedata
)
9306 Elf_Internal_Shdr
* sec
;
9307 Elf_Internal_Shdr
* unwsec
= NULL
;
9308 uint64_t i
, unwcount
= 0, unwstart
= 0;
9309 struct ia64_unw_aux_info aux
;
9312 memset (& aux
, 0, sizeof (aux
));
9314 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9316 if (sec
->sh_type
== SHT_SYMTAB
)
9320 error (_("Multiple symbol tables encountered\n"));
9326 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9327 &aux
.strtab
, &aux
.strtab_size
))
9330 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
9335 printf (_("\nThere are no unwind sections in this file.\n"));
9337 while (unwcount
-- > 0)
9342 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
9343 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9344 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
9349 /* We have already counted the number of SHT_IA64_UNWIND
9350 sections so the loop above should never fail. */
9351 assert (unwsec
!= NULL
);
9354 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
9356 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
9358 /* We need to find which section group it is in. */
9359 struct group_list
* g
;
9361 if (filedata
->section_headers_groups
== NULL
9362 || filedata
->section_headers_groups
[i
] == NULL
)
9363 i
= filedata
->file_header
.e_shnum
;
9366 g
= filedata
->section_headers_groups
[i
]->root
;
9368 for (; g
!= NULL
; g
= g
->next
)
9370 sec
= filedata
->section_headers
+ g
->section_index
;
9372 if (section_name_valid (filedata
, sec
)
9373 && streq (section_name (filedata
, sec
),
9374 ELF_STRING_ia64_unwind_info
))
9379 i
= filedata
->file_header
.e_shnum
;
9382 else if (section_name_valid (filedata
, unwsec
)
9383 && startswith (section_name (filedata
, unwsec
),
9384 ELF_STRING_ia64_unwind_once
))
9386 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
9387 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
9388 suffix
= section_name (filedata
, unwsec
) + len
;
9389 for (i
= 0, sec
= filedata
->section_headers
;
9390 i
< filedata
->file_header
.e_shnum
;
9392 if (section_name_valid (filedata
, sec
)
9393 && startswith (section_name (filedata
, sec
),
9394 ELF_STRING_ia64_unwind_info_once
)
9395 && streq (section_name (filedata
, sec
) + len2
, suffix
))
9400 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
9401 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
9402 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
9403 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
9405 if (section_name_valid (filedata
, unwsec
)
9406 && startswith (section_name (filedata
, unwsec
),
9407 ELF_STRING_ia64_unwind
))
9408 suffix
= section_name (filedata
, unwsec
) + len
;
9409 for (i
= 0, sec
= filedata
->section_headers
;
9410 i
< filedata
->file_header
.e_shnum
;
9412 if (section_name_valid (filedata
, sec
)
9413 && startswith (section_name (filedata
, sec
),
9414 ELF_STRING_ia64_unwind_info
)
9415 && streq (section_name (filedata
, sec
) + len2
, suffix
))
9419 if (i
== filedata
->file_header
.e_shnum
)
9421 printf (_("\nCould not find unwind info section for "));
9423 if (filedata
->string_table
== NULL
)
9424 printf ("%d", unwsec
->sh_name
);
9426 printf ("'%s'", printable_section_name (filedata
, unwsec
));
9430 aux
.info_addr
= sec
->sh_addr
;
9431 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
9434 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
9436 printf (_("\nUnwind section "));
9438 if (filedata
->string_table
== NULL
)
9439 printf ("%d", unwsec
->sh_name
);
9441 printf ("'%s'", printable_section_name (filedata
, unwsec
));
9443 printf (_(" at offset %#" PRIx64
" contains %" PRIu64
" entries:\n"),
9445 unwsec
->sh_size
/ (3 * eh_addr_size
));
9447 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
9448 && aux
.table_len
> 0)
9449 dump_ia64_unwind (filedata
, & aux
);
9451 free ((char *) aux
.table
);
9452 free ((char *) aux
.info
);
9459 free ((char *) aux
.strtab
);
9464 struct hppa_unw_table_entry
9466 struct absaddr start
;
9468 unsigned int Cannot_unwind
:1; /* 0 */
9469 unsigned int Millicode
:1; /* 1 */
9470 unsigned int Millicode_save_sr0
:1; /* 2 */
9471 unsigned int Region_description
:2; /* 3..4 */
9472 unsigned int reserved1
:1; /* 5 */
9473 unsigned int Entry_SR
:1; /* 6 */
9474 unsigned int Entry_FR
:4; /* Number saved 7..10 */
9475 unsigned int Entry_GR
:5; /* Number saved 11..15 */
9476 unsigned int Args_stored
:1; /* 16 */
9477 unsigned int Variable_Frame
:1; /* 17 */
9478 unsigned int Separate_Package_Body
:1; /* 18 */
9479 unsigned int Frame_Extension_Millicode
:1; /* 19 */
9480 unsigned int Stack_Overflow_Check
:1; /* 20 */
9481 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
9482 unsigned int Ada_Region
:1; /* 22 */
9483 unsigned int cxx_info
:1; /* 23 */
9484 unsigned int cxx_try_catch
:1; /* 24 */
9485 unsigned int sched_entry_seq
:1; /* 25 */
9486 unsigned int reserved2
:1; /* 26 */
9487 unsigned int Save_SP
:1; /* 27 */
9488 unsigned int Save_RP
:1; /* 28 */
9489 unsigned int Save_MRP_in_frame
:1; /* 29 */
9490 unsigned int extn_ptr_defined
:1; /* 30 */
9491 unsigned int Cleanup_defined
:1; /* 31 */
9493 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
9494 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
9495 unsigned int Large_frame
:1; /* 2 */
9496 unsigned int Pseudo_SP_Set
:1; /* 3 */
9497 unsigned int reserved4
:1; /* 4 */
9498 unsigned int Total_frame_size
:27; /* 5..31 */
9501 struct hppa_unw_aux_info
9503 struct hppa_unw_table_entry
* table
; /* Unwind table. */
9504 uint64_t table_len
; /* Length of unwind table. */
9505 uint64_t seg_base
; /* Starting address of segment. */
9506 Elf_Internal_Sym
* symtab
; /* The 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 entries in funtab. */
9510 char * strtab
; /* The string table. */
9511 uint64_t strtab_size
; /* Size of string table. */
9515 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
9517 struct hppa_unw_table_entry
* tp
;
9521 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9522 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9523 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9524 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9526 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9528 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
9531 const char * procname
;
9533 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
9534 aux
->strtab_size
, tp
->start
, &procname
,
9537 fputs ("\n<", stdout
);
9541 fputs (procname
, stdout
);
9544 printf ("+%" PRIx64
, offset
);
9547 fputs (">: [", stdout
);
9548 print_vma (tp
->start
.offset
, PREFIX_HEX
);
9549 fputc ('-', stdout
);
9550 print_vma (tp
->end
.offset
, PREFIX_HEX
);
9553 #define PF(_m) if (tp->_m) printf (#_m " ");
9554 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
9557 PF(Millicode_save_sr0
);
9558 /* PV(Region_description); */
9564 PF(Separate_Package_Body
);
9565 PF(Frame_Extension_Millicode
);
9566 PF(Stack_Overflow_Check
);
9567 PF(Two_Instruction_SP_Increment
);
9571 PF(sched_entry_seq
);
9574 PF(Save_MRP_in_frame
);
9575 PF(extn_ptr_defined
);
9576 PF(Cleanup_defined
);
9577 PF(MPE_XL_interrupt_marker
);
9578 PF(HP_UX_interrupt_marker
);
9581 PV(Total_frame_size
);
9594 slurp_hppa_unwind_table (Filedata
* filedata
,
9595 struct hppa_unw_aux_info
* aux
,
9596 Elf_Internal_Shdr
* sec
)
9598 uint64_t size
, unw_ent_size
, nentries
, nrelas
, i
;
9599 Elf_Internal_Phdr
* seg
;
9600 struct hppa_unw_table_entry
* tep
;
9601 Elf_Internal_Shdr
* relsec
;
9602 Elf_Internal_Rela
* rela
;
9603 Elf_Internal_Rela
* rp
;
9604 unsigned char * table
;
9606 Elf_Internal_Sym
* sym
;
9607 const char * relname
;
9609 /* First, find the starting address of the segment that includes
9611 if (filedata
->file_header
.e_phnum
)
9613 if (! get_program_headers (filedata
))
9616 for (seg
= filedata
->program_headers
;
9617 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
9620 if (seg
->p_type
!= PT_LOAD
)
9623 if (sec
->sh_addr
>= seg
->p_vaddr
9624 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
9626 aux
->seg_base
= seg
->p_vaddr
;
9632 /* Second, build the unwind table from the contents of the unwind
9634 size
= sec
->sh_size
;
9635 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
9641 nentries
= size
/ unw_ent_size
;
9642 size
= unw_ent_size
* nentries
;
9644 aux
->table_len
= nentries
;
9645 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
9646 xcmalloc (nentries
, sizeof (aux
->table
[0]));
9648 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
9650 unsigned int tmp1
, tmp2
;
9652 tep
->start
.section
= SHN_UNDEF
;
9653 tep
->end
.section
= SHN_UNDEF
;
9655 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
9656 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
9657 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
9658 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
9660 tep
->start
.offset
+= aux
->seg_base
;
9661 tep
->end
.offset
+= aux
->seg_base
;
9663 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
9664 tep
->Millicode
= (tmp1
>> 30) & 0x1;
9665 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
9666 tep
->Region_description
= (tmp1
>> 27) & 0x3;
9667 tep
->reserved1
= (tmp1
>> 26) & 0x1;
9668 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
9669 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
9670 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
9671 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
9672 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
9673 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
9674 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
9675 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
9676 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
9677 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
9678 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
9679 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
9680 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
9681 tep
->reserved2
= (tmp1
>> 5) & 0x1;
9682 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
9683 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
9684 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
9685 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
9686 tep
->Cleanup_defined
= tmp1
& 0x1;
9688 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
9689 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
9690 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
9691 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
9692 tep
->reserved4
= (tmp2
>> 27) & 0x1;
9693 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
9697 /* Third, apply any relocations to the unwind table. */
9698 for (relsec
= filedata
->section_headers
;
9699 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
9702 if (relsec
->sh_type
!= SHT_RELA
9703 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
9704 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
9707 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
9711 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
9713 unsigned int sym_ndx
;
9714 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
9715 relname
= elf_hppa_reloc_type (r_type
);
9717 if (relname
== NULL
)
9719 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
9723 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
9724 if (! startswith (relname
, "R_PARISC_SEGREL"))
9726 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
9730 i
= rp
->r_offset
/ unw_ent_size
;
9731 if (i
>= aux
->table_len
)
9733 warn (_("Skipping reloc with overlarge offset: %#" PRIx64
"\n"),
9738 sym_ndx
= get_reloc_symindex (rp
->r_info
);
9739 if (sym_ndx
>= aux
->nsyms
)
9741 warn (_("Skipping reloc with invalid symbol index: %u\n"),
9745 sym
= aux
->symtab
+ sym_ndx
;
9747 switch ((rp
->r_offset
% unw_ent_size
) / 4)
9750 aux
->table
[i
].start
.section
= sym
->st_shndx
;
9751 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
9754 aux
->table
[i
].end
.section
= sym
->st_shndx
;
9755 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
9769 hppa_process_unwind (Filedata
* filedata
)
9771 struct hppa_unw_aux_info aux
;
9772 Elf_Internal_Shdr
* unwsec
= NULL
;
9773 Elf_Internal_Shdr
* sec
;
9777 if (filedata
->string_table
== NULL
)
9780 memset (& aux
, 0, sizeof (aux
));
9782 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9784 if (sec
->sh_type
== SHT_SYMTAB
)
9788 error (_("Multiple symbol tables encountered\n"));
9794 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9795 &aux
.strtab
, &aux
.strtab_size
))
9798 else if (section_name_valid (filedata
, sec
)
9799 && streq (section_name (filedata
, sec
), ".PARISC.unwind"))
9804 printf (_("\nThere are no unwind sections in this file.\n"));
9806 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9808 if (section_name_valid (filedata
, sec
)
9809 && streq (section_name (filedata
, sec
), ".PARISC.unwind"))
9811 uint64_t num_unwind
= sec
->sh_size
/ 16;
9813 printf (ngettext ("\nUnwind section '%s' at offset %#" PRIx64
" "
9814 "contains %" PRIu64
" entry:\n",
9815 "\nUnwind section '%s' at offset %#" PRIx64
" "
9816 "contains %" PRIu64
" entries:\n",
9818 printable_section_name (filedata
, sec
),
9822 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
9825 if (res
&& aux
.table_len
> 0)
9827 if (! dump_hppa_unwind (filedata
, &aux
))
9831 free ((char *) aux
.table
);
9837 free ((char *) aux
.strtab
);
9844 unsigned char * data
; /* The unwind data. */
9845 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
9846 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
9847 uint64_t nrelas
; /* The number of relocations. */
9848 unsigned int rel_type
; /* REL or RELA ? */
9849 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
9852 struct arm_unw_aux_info
9854 Filedata
* filedata
; /* The file containing the unwind sections. */
9855 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
9856 uint64_t nsyms
; /* Number of symbols. */
9857 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
9858 uint64_t nfuns
; /* Number of these symbols. */
9859 char * strtab
; /* The file's string table. */
9860 uint64_t strtab_size
; /* Size of string table. */
9864 arm_print_vma_and_name (Filedata
* filedata
,
9865 struct arm_unw_aux_info
* aux
,
9867 struct absaddr addr
)
9869 const char *procname
;
9870 uint64_t sym_offset
;
9872 if (addr
.section
== SHN_UNDEF
)
9875 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
9876 aux
->strtab_size
, addr
, &procname
,
9879 print_vma (fn
, PREFIX_HEX
);
9883 fputs (" <", stdout
);
9884 fputs (procname
, stdout
);
9887 printf ("+0x%" PRIx64
, sym_offset
);
9888 fputc ('>', stdout
);
9895 arm_free_section (struct arm_section
*arm_sec
)
9897 free (arm_sec
->data
);
9898 free (arm_sec
->rela
);
9901 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
9902 cached section and install SEC instead.
9903 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
9904 and return its valued in * WORDP, relocating if necessary.
9905 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
9906 relocation's offset in ADDR.
9907 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
9908 into the string table of the symbol associated with the reloc. If no
9909 reloc was applied store -1 there.
9910 5) Return TRUE upon success, FALSE otherwise. */
9913 get_unwind_section_word (Filedata
* filedata
,
9914 struct arm_unw_aux_info
* aux
,
9915 struct arm_section
* arm_sec
,
9916 Elf_Internal_Shdr
* sec
,
9917 uint64_t word_offset
,
9918 unsigned int * wordp
,
9919 struct absaddr
* addr
,
9920 uint64_t * sym_name
)
9922 Elf_Internal_Rela
*rp
;
9923 Elf_Internal_Sym
*sym
;
9924 const char * relname
;
9928 if (sec
== NULL
|| arm_sec
== NULL
)
9931 addr
->section
= SHN_UNDEF
;
9934 if (sym_name
!= NULL
)
9935 *sym_name
= (uint64_t) -1;
9937 /* If necessary, update the section cache. */
9938 if (sec
!= arm_sec
->sec
)
9940 Elf_Internal_Shdr
*relsec
;
9942 arm_free_section (arm_sec
);
9945 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
9946 sec
->sh_size
, _("unwind data"));
9947 arm_sec
->rela
= NULL
;
9948 arm_sec
->nrelas
= 0;
9950 for (relsec
= filedata
->section_headers
;
9951 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
9954 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
9955 || filedata
->section_headers
+ relsec
->sh_info
!= sec
9956 /* PR 15745: Check the section type as well. */
9957 || (relsec
->sh_type
!= SHT_REL
9958 && relsec
->sh_type
!= SHT_RELA
))
9961 arm_sec
->rel_type
= relsec
->sh_type
;
9962 if (relsec
->sh_type
== SHT_REL
)
9964 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
9966 & arm_sec
->rela
, & arm_sec
->nrelas
))
9969 else /* relsec->sh_type == SHT_RELA */
9971 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
9973 & arm_sec
->rela
, & arm_sec
->nrelas
))
9979 arm_sec
->next_rela
= arm_sec
->rela
;
9982 /* If there is no unwind data we can do nothing. */
9983 if (arm_sec
->data
== NULL
)
9986 /* If the offset is invalid then fail. */
9987 if (/* PR 21343 *//* PR 18879 */
9989 || word_offset
> sec
->sh_size
- 4)
9992 /* Get the word at the required offset. */
9993 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
9995 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
9996 if (arm_sec
->rela
== NULL
)
10002 /* Look through the relocs to find the one that applies to the provided offset. */
10004 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
10006 uint64_t prelval
, offset
;
10008 if (rp
->r_offset
> word_offset
&& !wrapped
)
10010 rp
= arm_sec
->rela
;
10013 if (rp
->r_offset
> word_offset
)
10016 if (rp
->r_offset
& 3)
10018 warn (_("Skipping unexpected relocation at offset %#" PRIx64
"\n"),
10023 if (rp
->r_offset
< word_offset
)
10026 /* PR 17531: file: 027-161405-0.004 */
10027 if (aux
->symtab
== NULL
)
10030 if (arm_sec
->rel_type
== SHT_REL
)
10032 offset
= word
& 0x7fffffff;
10033 if (offset
& 0x40000000)
10034 offset
|= ~ (uint64_t) 0x7fffffff;
10036 else if (arm_sec
->rel_type
== SHT_RELA
)
10037 offset
= rp
->r_addend
;
10040 error (_("Unknown section relocation type %d encountered\n"),
10041 arm_sec
->rel_type
);
10045 /* PR 17531 file: 027-1241568-0.004. */
10046 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
10048 error (_("Bad symbol index in unwind relocation "
10049 "(%" PRIu64
" > %" PRIu64
")\n"),
10050 ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
10054 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
10055 offset
+= sym
->st_value
;
10056 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
10058 /* Check that we are processing the expected reloc type. */
10059 if (filedata
->file_header
.e_machine
== EM_ARM
)
10061 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
10062 if (relname
== NULL
)
10064 warn (_("Skipping unknown ARM relocation type: %d\n"),
10065 (int) ELF32_R_TYPE (rp
->r_info
));
10069 if (streq (relname
, "R_ARM_NONE"))
10072 if (! streq (relname
, "R_ARM_PREL31"))
10074 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
10078 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
10080 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
10081 if (relname
== NULL
)
10083 warn (_("Skipping unknown C6000 relocation type: %d\n"),
10084 (int) ELF32_R_TYPE (rp
->r_info
));
10088 if (streq (relname
, "R_C6000_NONE"))
10091 if (! streq (relname
, "R_C6000_PREL31"))
10093 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
10101 /* This function currently only supports ARM and TI unwinders. */
10102 warn (_("Only TI and ARM unwinders are currently supported\n"));
10106 word
= (word
& ~ (uint64_t) 0x7fffffff) | (prelval
& 0x7fffffff);
10107 addr
->section
= sym
->st_shndx
;
10108 addr
->offset
= offset
;
10111 * sym_name
= sym
->st_name
;
10116 arm_sec
->next_rela
= rp
;
10121 static const char *tic6x_unwind_regnames
[16] =
10123 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
10124 "A14", "A13", "A12", "A11", "A10",
10125 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
10129 decode_tic6x_unwind_regmask (unsigned int mask
)
10133 for (i
= 12; mask
; mask
>>= 1, i
--)
10137 fputs (tic6x_unwind_regnames
[i
], stdout
);
10139 fputs (", ", stdout
);
10145 if (remaining == 0 && more_words) \
10147 data_offset += 4; \
10148 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
10149 data_offset, & word, & addr, NULL)) \
10155 #define GET_OP(OP) \
10160 (OP) = word >> 24; \
10165 printf (_("[Truncated opcode]\n")); \
10168 printf ("0x%02x ", OP)
10171 decode_arm_unwind_bytecode (Filedata
* filedata
,
10172 struct arm_unw_aux_info
* aux
,
10174 unsigned int remaining
,
10175 unsigned int more_words
,
10176 uint64_t data_offset
,
10177 Elf_Internal_Shdr
* data_sec
,
10178 struct arm_section
* data_arm_sec
)
10180 struct absaddr addr
;
10183 /* Decode the unwinding instructions. */
10186 unsigned int op
, op2
;
10189 if (remaining
== 0)
10195 printf (" 0x%02x ", op
);
10197 if ((op
& 0xc0) == 0x00)
10199 int offset
= ((op
& 0x3f) << 2) + 4;
10201 printf (" vsp = vsp + %d", offset
);
10203 else if ((op
& 0xc0) == 0x40)
10205 int offset
= ((op
& 0x3f) << 2) + 4;
10207 printf (" vsp = vsp - %d", offset
);
10209 else if ((op
& 0xf0) == 0x80)
10212 if (op
== 0x80 && op2
== 0)
10213 printf (_("Refuse to unwind"));
10216 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
10221 for (i
= 0; i
< 12; i
++)
10222 if (mask
& (1 << i
))
10228 printf ("r%d", 4 + i
);
10233 else if ((op
& 0xf0) == 0x90)
10235 if (op
== 0x9d || op
== 0x9f)
10236 printf (_(" [Reserved]"));
10238 printf (" vsp = r%d", op
& 0x0f);
10240 else if ((op
& 0xf0) == 0xa0)
10242 int end
= 4 + (op
& 0x07);
10247 for (i
= 4; i
<= end
; i
++)
10263 else if (op
== 0xb0)
10264 printf (_(" finish"));
10265 else if (op
== 0xb1)
10268 if (op2
== 0 || (op2
& 0xf0) != 0)
10269 printf (_("[Spare]"));
10272 unsigned int mask
= op2
& 0x0f;
10277 for (i
= 0; i
< 12; i
++)
10278 if (mask
& (1 << i
))
10289 else if (op
== 0xb2)
10291 unsigned char buf
[9];
10292 unsigned int i
, len
;
10295 for (i
= 0; i
< sizeof (buf
); i
++)
10298 if ((buf
[i
] & 0x80) == 0)
10301 if (i
== sizeof (buf
))
10303 error (_("corrupt change to vsp\n"));
10308 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
10309 assert (len
== i
+ 1);
10310 offset
= offset
* 4 + 0x204;
10311 printf ("vsp = vsp + %" PRId64
, offset
);
10314 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
10316 unsigned int first
, last
;
10322 first
= first
+ 16;
10323 printf ("pop {D%d", first
);
10325 printf ("-D%d", first
+ last
);
10328 else if (op
== 0xb4)
10329 printf (_(" pop {ra_auth_code}"));
10330 else if (op
== 0xb5)
10331 printf (_(" vsp as modifier for PAC validation"));
10332 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
10334 unsigned int count
= op
& 0x07;
10336 printf ("pop {D8");
10338 printf ("-D%d", 8 + count
);
10341 else if (op
>= 0xc0 && op
<= 0xc5)
10343 unsigned int count
= op
& 0x07;
10345 printf (" pop {wR10");
10347 printf ("-wR%d", 10 + count
);
10350 else if (op
== 0xc6)
10352 unsigned int first
, last
;
10357 printf ("pop {wR%d", first
);
10359 printf ("-wR%d", first
+ last
);
10362 else if (op
== 0xc7)
10365 if (op2
== 0 || (op2
& 0xf0) != 0)
10366 printf (_("[Spare]"));
10369 unsigned int mask
= op2
& 0x0f;
10374 for (i
= 0; i
< 4; i
++)
10375 if (mask
& (1 << i
))
10381 printf ("wCGR%d", i
);
10388 printf (_(" [unsupported opcode]"));
10399 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
10400 struct arm_unw_aux_info
* aux
,
10402 unsigned int remaining
,
10403 unsigned int more_words
,
10404 uint64_t data_offset
,
10405 Elf_Internal_Shdr
* data_sec
,
10406 struct arm_section
* data_arm_sec
)
10408 struct absaddr addr
;
10410 /* Decode the unwinding instructions. */
10413 unsigned int op
, op2
;
10416 if (remaining
== 0)
10422 printf (" 0x%02x ", op
);
10424 if ((op
& 0xc0) == 0x00)
10426 int offset
= ((op
& 0x3f) << 3) + 8;
10427 printf (" sp = sp + %d", offset
);
10429 else if ((op
& 0xc0) == 0x80)
10432 if (op
== 0x80 && op2
== 0)
10433 printf (_("Refuse to unwind"));
10436 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
10438 printf ("pop compact {");
10442 decode_tic6x_unwind_regmask (mask
);
10446 else if ((op
& 0xf0) == 0xc0)
10449 unsigned int nregs
;
10454 unsigned int offset
;
10458 /* Scan entire instruction first so that GET_OP output is not
10459 interleaved with disassembly. */
10461 for (i
= 0; nregs
< (op
& 0xf); i
++)
10467 regpos
[nregs
].offset
= i
* 2;
10468 regpos
[nregs
].reg
= reg
;
10475 regpos
[nregs
].offset
= i
* 2 + 1;
10476 regpos
[nregs
].reg
= reg
;
10481 printf (_("pop frame {"));
10484 printf (_("*corrupt* - no registers specified"));
10489 for (i
= i
* 2; i
> 0; i
--)
10491 if (regpos
[reg
].offset
== i
- 1)
10493 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
10500 fputs (name
, stdout
);
10508 else if (op
== 0xd0)
10509 printf (" MOV FP, SP");
10510 else if (op
== 0xd1)
10511 printf (" __c6xabi_pop_rts");
10512 else if (op
== 0xd2)
10514 unsigned char buf
[9];
10515 unsigned int i
, len
;
10518 for (i
= 0; i
< sizeof (buf
); i
++)
10521 if ((buf
[i
] & 0x80) == 0)
10524 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
10525 if (i
== sizeof (buf
))
10527 warn (_("Corrupt stack pointer adjustment detected\n"));
10531 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
10532 assert (len
== i
+ 1);
10533 offset
= offset
* 8 + 0x408;
10534 printf (_("sp = sp + %" PRId64
), offset
);
10536 else if ((op
& 0xf0) == 0xe0)
10538 if ((op
& 0x0f) == 7)
10539 printf (" RETURN");
10541 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
10545 printf (_(" [unsupported opcode]"));
10554 arm_expand_prel31 (Filedata
* filedata
, uint64_t word
, uint64_t where
)
10558 offset
= word
& 0x7fffffff;
10559 if (offset
& 0x40000000)
10560 offset
|= ~ (uint64_t) 0x7fffffff;
10562 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
10565 return offset
+ where
;
10569 decode_arm_unwind (Filedata
* filedata
,
10570 struct arm_unw_aux_info
* aux
,
10572 unsigned int remaining
,
10573 uint64_t data_offset
,
10574 Elf_Internal_Shdr
* data_sec
,
10575 struct arm_section
* data_arm_sec
)
10578 unsigned int more_words
= 0;
10579 struct absaddr addr
;
10580 uint64_t sym_name
= (uint64_t) -1;
10583 if (remaining
== 0)
10585 /* Fetch the first word.
10586 Note - when decoding an object file the address extracted
10587 here will always be 0. So we also pass in the sym_name
10588 parameter so that we can find the symbol associated with
10589 the personality routine. */
10590 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
10591 & word
, & addr
, & sym_name
))
10598 addr
.section
= SHN_UNDEF
;
10602 if ((word
& 0x80000000) == 0)
10604 /* Expand prel31 for personality routine. */
10606 const char *procname
;
10608 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
10609 printf (_(" Personality routine: "));
10611 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
10612 && sym_name
!= (uint64_t) -1 && sym_name
< aux
->strtab_size
)
10614 procname
= aux
->strtab
+ sym_name
;
10615 print_vma (fn
, PREFIX_HEX
);
10618 fputs (" <", stdout
);
10619 fputs (procname
, stdout
);
10620 fputc ('>', stdout
);
10624 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
10625 fputc ('\n', stdout
);
10627 /* The GCC personality routines use the standard compact
10628 encoding, starting with one byte giving the number of
10630 if (procname
!= NULL
10631 && (startswith (procname
, "__gcc_personality_v0")
10632 || startswith (procname
, "__gxx_personality_v0")
10633 || startswith (procname
, "__gcj_personality_v0")
10634 || startswith (procname
, "__gnu_objc_personality_v0")))
10641 printf (_(" [Truncated data]\n"));
10644 more_words
= word
>> 24;
10654 /* ARM EHABI Section 6.3:
10656 An exception-handling table entry for the compact model looks like:
10658 31 30-28 27-24 23-0
10659 -- ----- ----- ----
10660 1 0 index Data for personalityRoutine[index] */
10662 if (filedata
->file_header
.e_machine
== EM_ARM
10663 && (word
& 0x70000000))
10665 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
10669 per_index
= (word
>> 24) & 0x7f;
10670 printf (_(" Compact model index: %d\n"), per_index
);
10671 if (per_index
== 0)
10677 else if (per_index
< 3)
10679 more_words
= (word
>> 16) & 0xff;
10685 switch (filedata
->file_header
.e_machine
)
10690 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
10691 data_offset
, data_sec
, data_arm_sec
))
10696 warn (_("Unknown ARM compact model index encountered\n"));
10697 printf (_(" [reserved]\n"));
10705 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
10706 data_offset
, data_sec
, data_arm_sec
))
10709 else if (per_index
< 5)
10711 if (((word
>> 17) & 0x7f) == 0x7f)
10712 printf (_(" Restore stack from frame pointer\n"));
10714 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
10715 printf (_(" Registers restored: "));
10716 if (per_index
== 4)
10717 printf (" (compact) ");
10718 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
10720 printf (_(" Return register: %s\n"),
10721 tic6x_unwind_regnames
[word
& 0xf]);
10724 printf (_(" [reserved (%d)]\n"), per_index
);
10728 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
10729 filedata
->file_header
.e_machine
);
10733 /* Decode the descriptors. Not implemented. */
10739 dump_arm_unwind (Filedata
* filedata
,
10740 struct arm_unw_aux_info
* aux
,
10741 Elf_Internal_Shdr
* exidx_sec
)
10743 struct arm_section exidx_arm_sec
, extab_arm_sec
;
10744 unsigned int i
, exidx_len
;
10748 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
10749 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
10750 exidx_len
= exidx_sec
->sh_size
/ 8;
10752 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
10753 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
10754 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
10755 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
10756 aux
->nfuns
= nfuns
;
10757 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
10759 for (i
= 0; i
< exidx_len
; i
++)
10761 unsigned int exidx_fn
, exidx_entry
;
10762 struct absaddr fn_addr
, entry_addr
;
10765 fputc ('\n', stdout
);
10767 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
10768 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
10769 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
10770 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
10772 free (aux
->funtab
);
10773 arm_free_section (& exidx_arm_sec
);
10774 arm_free_section (& extab_arm_sec
);
10778 /* ARM EHABI, Section 5:
10779 An index table entry consists of 2 words.
10780 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
10781 if (exidx_fn
& 0x80000000)
10783 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
10787 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
10789 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
10790 fputs (": ", stdout
);
10792 if (exidx_entry
== 1)
10794 print_vma (exidx_entry
, PREFIX_HEX
);
10795 fputs (" [cantunwind]\n", stdout
);
10797 else if (exidx_entry
& 0x80000000)
10799 print_vma (exidx_entry
, PREFIX_HEX
);
10800 fputc ('\n', stdout
);
10801 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
10805 uint64_t table
, table_offset
= 0;
10806 Elf_Internal_Shdr
*table_sec
;
10808 fputs ("@", stdout
);
10809 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
10810 print_vma (table
, PREFIX_HEX
);
10813 /* Locate the matching .ARM.extab. */
10814 if (entry_addr
.section
!= SHN_UNDEF
10815 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
10817 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
10818 table_offset
= entry_addr
.offset
;
10820 if (table_offset
> table_sec
->sh_size
)
10822 warn (_("Unwind entry contains corrupt offset (%#" PRIx64
") into section %s\n"),
10824 printable_section_name (filedata
, table_sec
));
10831 table_sec
= find_section_by_address (filedata
, table
);
10832 if (table_sec
!= NULL
)
10833 table_offset
= table
- table_sec
->sh_addr
;
10836 if (table_sec
== NULL
)
10838 warn (_("Could not locate .ARM.extab section containing %#" PRIx64
".\n"),
10844 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
10852 free (aux
->funtab
);
10853 arm_free_section (&exidx_arm_sec
);
10854 arm_free_section (&extab_arm_sec
);
10859 /* Used for both ARM and C6X unwinding tables. */
10862 arm_process_unwind (Filedata
* filedata
)
10864 struct arm_unw_aux_info aux
;
10865 Elf_Internal_Shdr
*unwsec
= NULL
;
10866 Elf_Internal_Shdr
*sec
;
10868 unsigned int sec_type
;
10871 switch (filedata
->file_header
.e_machine
)
10874 sec_type
= SHT_ARM_EXIDX
;
10878 sec_type
= SHT_C6000_UNWIND
;
10882 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
10883 filedata
->file_header
.e_machine
);
10887 if (filedata
->string_table
== NULL
)
10890 memset (& aux
, 0, sizeof (aux
));
10891 aux
.filedata
= filedata
;
10893 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
10895 if (sec
->sh_type
== SHT_SYMTAB
)
10899 error (_("Multiple symbol tables encountered\n"));
10905 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
10906 &aux
.strtab
, &aux
.strtab_size
))
10909 else if (sec
->sh_type
== sec_type
)
10913 if (unwsec
== NULL
)
10914 printf (_("\nThere are no unwind sections in this file.\n"));
10916 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
10918 if (sec
->sh_type
== sec_type
)
10920 uint64_t num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
10921 printf (ngettext ("\nUnwind section '%s' at offset %#" PRIx64
" "
10922 "contains %" PRIu64
" entry:\n",
10923 "\nUnwind section '%s' at offset %#" PRIx64
" "
10924 "contains %" PRIu64
" entries:\n",
10926 printable_section_name (filedata
, sec
),
10930 if (! dump_arm_unwind (filedata
, &aux
, sec
))
10936 free ((char *) aux
.strtab
);
10942 no_processor_specific_unwind (Filedata
* filedata ATTRIBUTE_UNUSED
)
10944 printf (_("No processor specific unwind information to decode\n"));
10949 process_unwind (Filedata
* filedata
)
10951 struct unwind_handler
10953 unsigned int machtype
;
10954 bool (* handler
)(Filedata
*);
10957 { EM_ARM
, arm_process_unwind
},
10958 { EM_IA_64
, ia64_process_unwind
},
10959 { EM_PARISC
, hppa_process_unwind
},
10960 { EM_TI_C6000
, arm_process_unwind
},
10961 { EM_386
, no_processor_specific_unwind
},
10962 { EM_X86_64
, no_processor_specific_unwind
},
10970 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
10971 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
10972 return handlers
[i
].handler (filedata
);
10974 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
10975 get_machine_name (filedata
->file_header
.e_machine
));
10980 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
10982 switch (entry
->d_tag
)
10984 case DT_AARCH64_BTI_PLT
:
10985 case DT_AARCH64_PAC_PLT
:
10988 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10995 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
10997 switch (entry
->d_tag
)
10999 case DT_MIPS_FLAGS
:
11000 if (entry
->d_un
.d_val
== 0)
11001 printf (_("NONE"));
11004 static const char * opts
[] =
11006 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
11007 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
11008 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
11009 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
11015 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
11016 if (entry
->d_un
.d_val
& (1 << cnt
))
11018 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
11024 case DT_MIPS_IVERSION
:
11025 if (valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
11026 printf (_("Interface Version: %s"),
11027 get_dynamic_name (filedata
, entry
->d_un
.d_val
));
11029 printf (_("Interface Version: <corrupt: %" PRIx64
">"),
11030 entry
->d_un
.d_ptr
);
11033 case DT_MIPS_TIME_STAMP
:
11037 time_t atime
= entry
->d_un
.d_val
;
11039 tmp
= gmtime (&atime
);
11040 /* PR 17531: file: 6accc532. */
11042 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
11044 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
11045 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11046 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11047 printf (_("Time Stamp: %s"), timebuf
);
11051 case DT_MIPS_RLD_VERSION
:
11052 case DT_MIPS_LOCAL_GOTNO
:
11053 case DT_MIPS_CONFLICTNO
:
11054 case DT_MIPS_LIBLISTNO
:
11055 case DT_MIPS_SYMTABNO
:
11056 case DT_MIPS_UNREFEXTNO
:
11057 case DT_MIPS_HIPAGENO
:
11058 case DT_MIPS_DELTA_CLASS_NO
:
11059 case DT_MIPS_DELTA_INSTANCE_NO
:
11060 case DT_MIPS_DELTA_RELOC_NO
:
11061 case DT_MIPS_DELTA_SYM_NO
:
11062 case DT_MIPS_DELTA_CLASSSYM_NO
:
11063 case DT_MIPS_COMPACT_SIZE
:
11064 print_vma (entry
->d_un
.d_val
, DEC
);
11067 case DT_MIPS_XHASH
:
11068 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
11069 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11070 /* Falls through. */
11073 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
11079 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
11081 switch (entry
->d_tag
)
11083 case DT_HP_DLD_FLAGS
:
11092 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
11093 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
11094 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
11095 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
11096 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
11097 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
11098 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
11099 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
11100 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
11101 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
11102 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
11103 { DT_HP_GST
, "HP_GST" },
11104 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
11105 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
11106 { DT_HP_NODELETE
, "HP_NODELETE" },
11107 { DT_HP_GROUP
, "HP_GROUP" },
11108 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
11112 uint64_t val
= entry
->d_un
.d_val
;
11114 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
11115 if (val
& flags
[cnt
].bit
)
11119 fputs (flags
[cnt
].str
, stdout
);
11121 val
^= flags
[cnt
].bit
;
11124 if (val
!= 0 || first
)
11128 print_vma (val
, HEX
);
11134 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
11140 /* VMS vs Unix time offset and factor. */
11142 #define VMS_EPOCH_OFFSET 35067168000000000LL
11143 #define VMS_GRANULARITY_FACTOR 10000000
11145 #define INT64_MIN (-9223372036854775807LL - 1)
11148 /* Display a VMS time in a human readable format. */
11151 print_vms_time (int64_t vmstime
)
11153 struct tm
*tm
= NULL
;
11156 if (vmstime
>= INT64_MIN
+ VMS_EPOCH_OFFSET
)
11158 vmstime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
11160 if (unxtime
== vmstime
)
11161 tm
= gmtime (&unxtime
);
11164 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
11165 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
11166 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
11170 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
11172 switch (entry
->d_tag
)
11174 case DT_IA_64_PLT_RESERVE
:
11175 /* First 3 slots reserved. */
11176 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
11178 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
11181 case DT_IA_64_VMS_LINKTIME
:
11182 print_vms_time (entry
->d_un
.d_val
);
11185 case DT_IA_64_VMS_LNKFLAGS
:
11186 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
11187 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
11188 printf (" CALL_DEBUG");
11189 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
11190 printf (" NOP0BUFS");
11191 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
11192 printf (" P0IMAGE");
11193 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
11194 printf (" MKTHREADS");
11195 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
11196 printf (" UPCALLS");
11197 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
11198 printf (" IMGSTA");
11199 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
11200 printf (" INITIALIZE");
11201 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
11203 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
11204 printf (" EXE_INIT");
11205 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
11206 printf (" TBK_IN_IMG");
11207 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
11208 printf (" DBG_IN_IMG");
11209 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
11210 printf (" TBK_IN_DSF");
11211 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
11212 printf (" DBG_IN_DSF");
11213 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
11214 printf (" SIGNATURES");
11215 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
11216 printf (" REL_SEG_OFF");
11220 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
11227 get_32bit_dynamic_section (Filedata
* filedata
)
11229 Elf32_External_Dyn
* edyn
;
11230 Elf32_External_Dyn
* ext
;
11231 Elf_Internal_Dyn
* entry
;
11233 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
11234 filedata
->dynamic_addr
, 1,
11235 filedata
->dynamic_size
,
11236 _("dynamic section"));
11240 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
11241 might not have the luxury of section headers. Look for the DT_NULL
11242 terminator to determine the number of entries. */
11243 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
11244 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
11247 filedata
->dynamic_nent
++;
11248 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
11252 filedata
->dynamic_section
11253 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
11254 if (filedata
->dynamic_section
== NULL
)
11256 error (_("Out of memory allocating space for %" PRIu64
" dynamic entries\n"),
11257 filedata
->dynamic_nent
);
11262 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
11263 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11266 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
11267 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
11276 get_64bit_dynamic_section (Filedata
* filedata
)
11278 Elf64_External_Dyn
* edyn
;
11279 Elf64_External_Dyn
* ext
;
11280 Elf_Internal_Dyn
* entry
;
11282 /* Read in the data. */
11283 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
11284 filedata
->dynamic_addr
, 1,
11285 filedata
->dynamic_size
,
11286 _("dynamic section"));
11290 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
11291 might not have the luxury of section headers. Look for the DT_NULL
11292 terminator to determine the number of entries. */
11293 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
11294 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
11295 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
11298 filedata
->dynamic_nent
++;
11299 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
11303 filedata
->dynamic_section
11304 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
11305 if (filedata
->dynamic_section
== NULL
)
11307 error (_("Out of memory allocating space for %" PRIu64
" dynamic entries\n"),
11308 filedata
->dynamic_nent
);
11313 /* Convert from external to internal formats. */
11314 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
11315 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11318 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
11319 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
11328 get_dynamic_section (Filedata
*filedata
)
11330 if (filedata
->dynamic_section
)
11334 return get_32bit_dynamic_section (filedata
);
11336 return get_64bit_dynamic_section (filedata
);
11340 print_dynamic_flags (uint64_t flags
)
11348 flag
= flags
& - flags
;
11354 putc (' ', stdout
);
11358 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
11359 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
11360 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
11361 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
11362 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
11363 default: fputs (_("unknown"), stdout
); break;
11370 get_dynamic_data (Filedata
* filedata
, uint64_t number
, unsigned int ent_size
)
11372 unsigned char * e_data
;
11375 /* If size_t is smaller than uint64_t, eg because you are building
11376 on a 32-bit host, then make sure that when number is cast to
11377 size_t no information is lost. */
11378 if ((size_t) number
!= number
11379 || ent_size
* number
/ ent_size
!= number
)
11381 error (_("Size overflow prevents reading %" PRIu64
11382 " elements of size %u\n"),
11387 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
11388 attempting to allocate memory when the read is bound to fail. */
11389 if (ent_size
* number
> filedata
->file_size
)
11391 error (_("Invalid number of dynamic entries: %" PRIu64
"\n"),
11396 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11397 if (e_data
== NULL
)
11399 error (_("Out of memory reading %" PRIu64
" dynamic entries\n"),
11404 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11406 error (_("Unable to read in %" PRIu64
" bytes of dynamic data\n"),
11407 number
* ent_size
);
11412 i_data
= (uint64_t *) cmalloc ((size_t) number
, sizeof (*i_data
));
11413 if (i_data
== NULL
)
11415 error (_("Out of memory allocating space for %" PRIu64
" dynamic entries\n"),
11422 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11430 get_num_dynamic_syms (Filedata
* filedata
)
11432 uint64_t num_of_syms
= 0;
11434 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
11435 return num_of_syms
;
11437 if (filedata
->dynamic_info
[DT_HASH
])
11439 unsigned char nb
[8];
11440 unsigned char nc
[8];
11441 unsigned int hash_ent_size
= 4;
11443 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11444 || filedata
->file_header
.e_machine
== EM_S390
11445 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11446 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11449 if (fseek64 (filedata
->handle
,
11450 (filedata
->archive_file_offset
11451 + offset_from_vma (filedata
,
11452 filedata
->dynamic_info
[DT_HASH
],
11453 sizeof nb
+ sizeof nc
)),
11456 error (_("Unable to seek to start of dynamic information\n"));
11460 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11462 error (_("Failed to read in number of buckets\n"));
11466 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11468 error (_("Failed to read in number of chains\n"));
11472 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
11473 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
11475 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
11477 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
11479 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
11482 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
11483 num_of_syms
= filedata
->nchains
;
11486 if (num_of_syms
== 0)
11488 free (filedata
->buckets
);
11489 filedata
->buckets
= NULL
;
11490 free (filedata
->chains
);
11491 filedata
->chains
= NULL
;
11492 filedata
->nbuckets
= 0;
11496 if (filedata
->dynamic_info_DT_GNU_HASH
)
11498 unsigned char nb
[16];
11499 uint64_t i
, maxchain
= 0xffffffff, bitmaskwords
;
11500 uint64_t buckets_vma
;
11503 if (fseek64 (filedata
->handle
,
11504 (filedata
->archive_file_offset
11505 + offset_from_vma (filedata
,
11506 filedata
->dynamic_info_DT_GNU_HASH
,
11510 error (_("Unable to seek to start of dynamic information\n"));
11514 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11516 error (_("Failed to read in number of buckets\n"));
11520 filedata
->ngnubuckets
= byte_get (nb
, 4);
11521 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
11522 bitmaskwords
= byte_get (nb
+ 8, 4);
11523 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
11525 buckets_vma
+= bitmaskwords
* 4;
11527 buckets_vma
+= bitmaskwords
* 8;
11529 if (fseek64 (filedata
->handle
,
11530 (filedata
->archive_file_offset
11531 + offset_from_vma (filedata
, buckets_vma
, 4)),
11534 error (_("Unable to seek to start of dynamic information\n"));
11538 filedata
->gnubuckets
11539 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
11541 if (filedata
->gnubuckets
== NULL
)
11544 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
11545 if (filedata
->gnubuckets
[i
] != 0)
11547 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
11550 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
11551 maxchain
= filedata
->gnubuckets
[i
];
11554 if (maxchain
== 0xffffffff)
11557 maxchain
-= filedata
->gnusymidx
;
11559 if (fseek64 (filedata
->handle
,
11560 (filedata
->archive_file_offset
11561 + offset_from_vma (filedata
,
11562 buckets_vma
+ 4 * (filedata
->ngnubuckets
11567 error (_("Unable to seek to start of dynamic information\n"));
11573 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11575 error (_("Failed to determine last chain length\n"));
11579 if (maxchain
+ 1 == 0)
11584 while ((byte_get (nb
, 4) & 1) == 0);
11586 if (fseek64 (filedata
->handle
,
11587 (filedata
->archive_file_offset
11588 + offset_from_vma (filedata
, (buckets_vma
11589 + 4 * filedata
->ngnubuckets
),
11593 error (_("Unable to seek to start of dynamic information\n"));
11597 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11598 filedata
->ngnuchains
= maxchain
;
11600 if (filedata
->gnuchains
== NULL
)
11603 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
11605 if (fseek64 (filedata
->handle
,
11606 (filedata
->archive_file_offset
11607 + offset_from_vma (filedata
, (buckets_vma
11608 + 4 * (filedata
->ngnubuckets
11612 error (_("Unable to seek to start of dynamic information\n"));
11616 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
11617 if (filedata
->mipsxlat
== NULL
)
11621 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
11622 if (filedata
->gnubuckets
[hn
] != 0)
11624 uint64_t si
= filedata
->gnubuckets
[hn
];
11625 uint64_t off
= si
- filedata
->gnusymidx
;
11629 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
11631 if (off
< filedata
->ngnuchains
11632 && filedata
->mipsxlat
[off
] >= num_of_syms
)
11633 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
11637 if (si
>= num_of_syms
)
11638 num_of_syms
= si
+ 1;
11642 while (off
< filedata
->ngnuchains
11643 && (filedata
->gnuchains
[off
++] & 1) == 0);
11646 if (num_of_syms
== 0)
11649 free (filedata
->mipsxlat
);
11650 filedata
->mipsxlat
= NULL
;
11651 free (filedata
->gnuchains
);
11652 filedata
->gnuchains
= NULL
;
11653 free (filedata
->gnubuckets
);
11654 filedata
->gnubuckets
= NULL
;
11655 filedata
->ngnubuckets
= 0;
11656 filedata
->ngnuchains
= 0;
11660 return num_of_syms
;
11663 /* Parse and display the contents of the dynamic section. */
11666 process_dynamic_section (Filedata
* filedata
)
11668 Elf_Internal_Dyn
* entry
;
11670 if (filedata
->dynamic_size
<= 1)
11674 if (filedata
->is_separate
)
11675 printf (_("\nThere is no dynamic section in linked file '%s'.\n"),
11676 filedata
->file_name
);
11678 printf (_("\nThere is no dynamic section in this file.\n"));
11684 if (!get_dynamic_section (filedata
))
11687 /* Find the appropriate symbol table. */
11688 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
11690 uint64_t num_of_syms
;
11692 for (entry
= filedata
->dynamic_section
;
11693 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11695 if (entry
->d_tag
== DT_SYMTAB
)
11696 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
11697 else if (entry
->d_tag
== DT_SYMENT
)
11698 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
11699 else if (entry
->d_tag
== DT_HASH
)
11700 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
11701 else if (entry
->d_tag
== DT_GNU_HASH
)
11702 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11703 else if ((filedata
->file_header
.e_machine
== EM_MIPS
11704 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
11705 && entry
->d_tag
== DT_MIPS_XHASH
)
11707 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
11708 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11711 num_of_syms
= get_num_dynamic_syms (filedata
);
11713 if (num_of_syms
!= 0
11714 && filedata
->dynamic_symbols
== NULL
11715 && filedata
->dynamic_info
[DT_SYMTAB
]
11716 && filedata
->dynamic_info
[DT_SYMENT
])
11718 Elf_Internal_Phdr
*seg
;
11719 uint64_t vma
= filedata
->dynamic_info
[DT_SYMTAB
];
11721 if (! get_program_headers (filedata
))
11723 error (_("Cannot interpret virtual addresses "
11724 "without program headers.\n"));
11728 for (seg
= filedata
->program_headers
;
11729 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
11732 if (seg
->p_type
!= PT_LOAD
)
11735 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
11737 /* See PR 21379 for a reproducer. */
11738 error (_("Invalid PT_LOAD entry\n"));
11742 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
11743 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
11745 /* Since we do not know how big the symbol table is,
11746 we default to reading in up to the end of PT_LOAD
11747 segment and processing that. This is overkill, I
11748 know, but it should work. */
11749 Elf_Internal_Shdr section
;
11750 section
.sh_offset
= (vma
- seg
->p_vaddr
11752 section
.sh_size
= (num_of_syms
11753 * filedata
->dynamic_info
[DT_SYMENT
]);
11754 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
11757 && filedata
->dynamic_symtab_section
!= NULL
11758 && ((filedata
->dynamic_symtab_section
->sh_offset
11759 != section
.sh_offset
)
11760 || (filedata
->dynamic_symtab_section
->sh_size
11761 != section
.sh_size
)
11762 || (filedata
->dynamic_symtab_section
->sh_entsize
11763 != section
.sh_entsize
)))
11765 the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
11767 section
.sh_name
= filedata
->string_table_length
;
11768 filedata
->dynamic_symbols
11769 = get_elf_symbols (filedata
, §ion
,
11770 &filedata
->num_dynamic_syms
);
11771 if (filedata
->dynamic_symbols
== NULL
11772 || filedata
->num_dynamic_syms
!= num_of_syms
)
11774 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
11783 /* Similarly find a string table. */
11784 if (filedata
->dynamic_strings
== NULL
)
11785 for (entry
= filedata
->dynamic_section
;
11786 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11789 if (entry
->d_tag
== DT_STRTAB
)
11790 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
11792 if (entry
->d_tag
== DT_STRSZ
)
11793 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
11795 if (filedata
->dynamic_info
[DT_STRTAB
]
11796 && filedata
->dynamic_info
[DT_STRSZ
])
11799 uint64_t str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
11801 offset
= offset_from_vma (filedata
,
11802 filedata
->dynamic_info
[DT_STRTAB
],
11805 && filedata
->dynamic_strtab_section
11806 && ((filedata
->dynamic_strtab_section
->sh_offset
11807 != (file_ptr
) offset
)
11808 || (filedata
->dynamic_strtab_section
->sh_size
11811 the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
11813 filedata
->dynamic_strings
11814 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
11815 _("dynamic string table"));
11816 if (filedata
->dynamic_strings
== NULL
)
11818 error (_("Corrupt DT_STRTAB dynamic entry\n"));
11822 filedata
->dynamic_strings_length
= str_tab_len
;
11827 /* And find the syminfo section if available. */
11828 if (filedata
->dynamic_syminfo
== NULL
)
11830 uint64_t syminsz
= 0;
11832 for (entry
= filedata
->dynamic_section
;
11833 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11836 if (entry
->d_tag
== DT_SYMINENT
)
11838 /* Note: these braces are necessary to avoid a syntax
11839 error from the SunOS4 C compiler. */
11840 /* PR binutils/17531: A corrupt file can trigger this test.
11841 So do not use an assert, instead generate an error message. */
11842 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
11843 error (_("Bad value (%d) for SYMINENT entry\n"),
11844 (int) entry
->d_un
.d_val
);
11846 else if (entry
->d_tag
== DT_SYMINSZ
)
11847 syminsz
= entry
->d_un
.d_val
;
11848 else if (entry
->d_tag
== DT_SYMINFO
)
11849 filedata
->dynamic_syminfo_offset
11850 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
11853 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
11855 Elf_External_Syminfo
* extsyminfo
;
11856 Elf_External_Syminfo
* extsym
;
11857 Elf_Internal_Syminfo
* syminfo
;
11859 /* There is a syminfo section. Read the data. */
11860 extsyminfo
= (Elf_External_Syminfo
*)
11861 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
11862 1, syminsz
, _("symbol information"));
11866 if (filedata
->dynamic_syminfo
!= NULL
)
11868 error (_("Multiple dynamic symbol information sections found\n"));
11869 free (filedata
->dynamic_syminfo
);
11871 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
11872 if (filedata
->dynamic_syminfo
== NULL
)
11874 error (_("Out of memory allocating %" PRIu64
11875 " bytes for dynamic symbol info\n"),
11880 filedata
->dynamic_syminfo_nent
11881 = syminsz
/ sizeof (Elf_External_Syminfo
);
11882 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
11883 syminfo
< (filedata
->dynamic_syminfo
11884 + filedata
->dynamic_syminfo_nent
);
11885 ++syminfo
, ++extsym
)
11887 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
11888 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
11895 if (do_dynamic
&& filedata
->dynamic_addr
)
11897 if (filedata
->is_separate
)
11898 printf (ngettext ("\nIn linked file '%s' the dynamic section at offset %#" PRIx64
" contains %" PRIu64
" entry:\n",
11899 "\nIn linked file '%s' the dynamic section at offset %#" PRIx64
" contains %" PRIu64
" entries:\n",
11900 filedata
->dynamic_nent
),
11901 filedata
->file_name
,
11902 filedata
->dynamic_addr
,
11903 filedata
->dynamic_nent
);
11905 printf (ngettext ("\nDynamic section at offset %#" PRIx64
" contains %" PRIu64
" entry:\n",
11906 "\nDynamic section at offset %#" PRIx64
" contains %" PRIu64
" entries:\n",
11907 filedata
->dynamic_nent
),
11908 filedata
->dynamic_addr
,
11909 filedata
->dynamic_nent
);
11912 printf (_(" Tag Type Name/Value\n"));
11914 for (entry
= filedata
->dynamic_section
;
11915 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11920 const char * dtype
;
11923 print_vma (entry
->d_tag
, FULL_HEX
);
11924 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
11925 printf (" (%s)%*s", dtype
,
11926 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
11929 switch (entry
->d_tag
)
11933 print_dynamic_flags (entry
->d_un
.d_val
);
11943 switch (entry
->d_tag
)
11946 printf (_("Auxiliary library"));
11950 printf (_("Filter library"));
11954 printf (_("Configuration file"));
11958 printf (_("Dependency audit library"));
11962 printf (_("Audit library"));
11966 if (valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
11967 printf (": [%s]\n",
11968 get_dynamic_name (filedata
, entry
->d_un
.d_val
));
11972 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11981 printf (_("Flags:"));
11983 if (entry
->d_un
.d_val
== 0)
11984 printf (_(" None\n"));
11987 uint64_t val
= entry
->d_un
.d_val
;
11989 if (val
& DTF_1_PARINIT
)
11991 printf (" PARINIT");
11992 val
^= DTF_1_PARINIT
;
11994 if (val
& DTF_1_CONFEXP
)
11996 printf (" CONFEXP");
11997 val
^= DTF_1_CONFEXP
;
12000 printf (" %" PRIx64
, val
);
12009 printf (_("Flags:"));
12011 if (entry
->d_un
.d_val
== 0)
12012 printf (_(" None\n"));
12015 uint64_t val
= entry
->d_un
.d_val
;
12017 if (val
& DF_P1_LAZYLOAD
)
12019 printf (" LAZYLOAD");
12020 val
^= DF_P1_LAZYLOAD
;
12022 if (val
& DF_P1_GROUPPERM
)
12024 printf (" GROUPPERM");
12025 val
^= DF_P1_GROUPPERM
;
12028 printf (" %" PRIx64
, val
);
12037 printf (_("Flags:"));
12038 if (entry
->d_un
.d_val
== 0)
12039 printf (_(" None\n"));
12042 uint64_t val
= entry
->d_un
.d_val
;
12044 if (val
& DF_1_NOW
)
12049 if (val
& DF_1_GLOBAL
)
12051 printf (" GLOBAL");
12052 val
^= DF_1_GLOBAL
;
12054 if (val
& DF_1_GROUP
)
12059 if (val
& DF_1_NODELETE
)
12061 printf (" NODELETE");
12062 val
^= DF_1_NODELETE
;
12064 if (val
& DF_1_LOADFLTR
)
12066 printf (" LOADFLTR");
12067 val
^= DF_1_LOADFLTR
;
12069 if (val
& DF_1_INITFIRST
)
12071 printf (" INITFIRST");
12072 val
^= DF_1_INITFIRST
;
12074 if (val
& DF_1_NOOPEN
)
12076 printf (" NOOPEN");
12077 val
^= DF_1_NOOPEN
;
12079 if (val
& DF_1_ORIGIN
)
12081 printf (" ORIGIN");
12082 val
^= DF_1_ORIGIN
;
12084 if (val
& DF_1_DIRECT
)
12086 printf (" DIRECT");
12087 val
^= DF_1_DIRECT
;
12089 if (val
& DF_1_TRANS
)
12094 if (val
& DF_1_INTERPOSE
)
12096 printf (" INTERPOSE");
12097 val
^= DF_1_INTERPOSE
;
12099 if (val
& DF_1_NODEFLIB
)
12101 printf (" NODEFLIB");
12102 val
^= DF_1_NODEFLIB
;
12104 if (val
& DF_1_NODUMP
)
12106 printf (" NODUMP");
12107 val
^= DF_1_NODUMP
;
12109 if (val
& DF_1_CONFALT
)
12111 printf (" CONFALT");
12112 val
^= DF_1_CONFALT
;
12114 if (val
& DF_1_ENDFILTEE
)
12116 printf (" ENDFILTEE");
12117 val
^= DF_1_ENDFILTEE
;
12119 if (val
& DF_1_DISPRELDNE
)
12121 printf (" DISPRELDNE");
12122 val
^= DF_1_DISPRELDNE
;
12124 if (val
& DF_1_DISPRELPND
)
12126 printf (" DISPRELPND");
12127 val
^= DF_1_DISPRELPND
;
12129 if (val
& DF_1_NODIRECT
)
12131 printf (" NODIRECT");
12132 val
^= DF_1_NODIRECT
;
12134 if (val
& DF_1_IGNMULDEF
)
12136 printf (" IGNMULDEF");
12137 val
^= DF_1_IGNMULDEF
;
12139 if (val
& DF_1_NOKSYMS
)
12141 printf (" NOKSYMS");
12142 val
^= DF_1_NOKSYMS
;
12144 if (val
& DF_1_NOHDR
)
12149 if (val
& DF_1_EDITED
)
12151 printf (" EDITED");
12152 val
^= DF_1_EDITED
;
12154 if (val
& DF_1_NORELOC
)
12156 printf (" NORELOC");
12157 val
^= DF_1_NORELOC
;
12159 if (val
& DF_1_SYMINTPOSE
)
12161 printf (" SYMINTPOSE");
12162 val
^= DF_1_SYMINTPOSE
;
12164 if (val
& DF_1_GLOBAUDIT
)
12166 printf (" GLOBAUDIT");
12167 val
^= DF_1_GLOBAUDIT
;
12169 if (val
& DF_1_SINGLETON
)
12171 printf (" SINGLETON");
12172 val
^= DF_1_SINGLETON
;
12174 if (val
& DF_1_STUB
)
12179 if (val
& DF_1_PIE
)
12184 if (val
& DF_1_KMOD
)
12189 if (val
& DF_1_WEAKFILTER
)
12191 printf (" WEAKFILTER");
12192 val
^= DF_1_WEAKFILTER
;
12194 if (val
& DF_1_NOCOMMON
)
12196 printf (" NOCOMMON");
12197 val
^= DF_1_NOCOMMON
;
12200 printf (" %" PRIx64
, val
);
12207 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
12209 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
12230 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
12236 if (valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
12237 name
= get_dynamic_name (filedata
, entry
->d_un
.d_val
);
12243 switch (entry
->d_tag
)
12246 printf (_("Shared library: [%s]"), name
);
12248 if (filedata
->program_interpreter
12249 && streq (name
, filedata
->program_interpreter
))
12250 printf (_(" program interpreter"));
12254 printf (_("Library soname: [%s]"), name
);
12258 printf (_("Library rpath: [%s]"), name
);
12262 printf (_("Library runpath: [%s]"), name
);
12266 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12271 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12286 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
12287 /* Fall through. */
12291 case DT_PREINIT_ARRAYSZ
:
12292 case DT_INIT_ARRAYSZ
:
12293 case DT_FINI_ARRAYSZ
:
12294 case DT_GNU_CONFLICTSZ
:
12295 case DT_GNU_LIBLISTSZ
:
12298 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
12299 printf (_(" (bytes)\n"));
12304 case DT_VERNEEDNUM
:
12309 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
12318 case DT_INIT_ARRAY
:
12319 case DT_FINI_ARRAY
:
12322 if (entry
->d_tag
== DT_USED
12323 && valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
12326 = get_dynamic_name (filedata
, entry
->d_un
.d_val
);
12330 printf (_("Not needed object: [%s]\n"), name
);
12335 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12341 /* The value of this entry is ignored. */
12346 case DT_GNU_PRELINKED
:
12350 time_t atime
= entry
->d_un
.d_val
;
12352 tmp
= gmtime (&atime
);
12353 /* PR 17533 file: 041-1244816-0.004. */
12355 printf (_("<corrupt time val: %" PRIx64
),
12358 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
12359 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
12360 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
12366 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
12369 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12374 case DT_GNU_FLAGS_1
:
12377 printf (_("Flags:"));
12378 if (entry
->d_un
.d_val
== 0)
12379 printf (_(" None\n"));
12382 uint64_t val
= entry
->d_un
.d_val
;
12384 if (val
& DF_GNU_1_UNIQUE
)
12386 printf (" UNIQUE");
12387 val
^= DF_GNU_1_UNIQUE
;
12390 printf (" %" PRIx64
, val
);
12397 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
12398 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
12399 = entry
->d_un
.d_val
;
12403 switch (filedata
->file_header
.e_machine
)
12406 dynamic_section_aarch64_val (entry
);
12409 case EM_MIPS_RS3_LE
:
12410 dynamic_section_mips_val (filedata
, entry
);
12413 dynamic_section_parisc_val (entry
);
12416 dynamic_section_ia64_val (entry
);
12419 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12431 get_ver_flags (unsigned int flags
)
12433 static char buff
[128];
12440 if (flags
& VER_FLG_BASE
)
12441 strcat (buff
, "BASE");
12443 if (flags
& VER_FLG_WEAK
)
12445 if (flags
& VER_FLG_BASE
)
12446 strcat (buff
, " | ");
12448 strcat (buff
, "WEAK");
12451 if (flags
& VER_FLG_INFO
)
12453 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
12454 strcat (buff
, " | ");
12456 strcat (buff
, "INFO");
12459 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
12461 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
12462 strcat (buff
, " | ");
12464 strcat (buff
, _("<unknown>"));
12470 /* Display the contents of the version sections. */
12473 process_version_sections (Filedata
* filedata
)
12475 Elf_Internal_Shdr
* section
;
12477 bool found
= false;
12482 for (i
= 0, section
= filedata
->section_headers
;
12483 i
< filedata
->file_header
.e_shnum
;
12486 switch (section
->sh_type
)
12488 case SHT_GNU_verdef
:
12490 Elf_External_Verdef
* edefs
;
12497 if (filedata
->is_separate
)
12498 printf (ngettext ("\nIn linked file '%s' the version definition section '%s' contains %u entry:\n",
12499 "\nIn linked file '%s' the version definition section '%s' contains %u entries:\n",
12501 filedata
->file_name
,
12502 printable_section_name (filedata
, section
),
12505 printf (ngettext ("\nVersion definition section '%s' "
12506 "contains %u entry:\n",
12507 "\nVersion definition section '%s' "
12508 "contains %u entries:\n",
12510 printable_section_name (filedata
, section
),
12513 printf (_(" Addr: 0x%016" PRIx64
), section
->sh_addr
);
12514 printf (_(" Offset: 0x%08" PRIx64
" Link: %u (%s)\n"),
12515 section
->sh_offset
, section
->sh_link
,
12516 printable_section_name_from_index (filedata
, section
->sh_link
));
12518 edefs
= (Elf_External_Verdef
*)
12519 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
12520 _("version definition section"));
12523 endbuf
= (char *) edefs
+ section
->sh_size
;
12525 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
12528 Elf_External_Verdef
* edef
;
12529 Elf_Internal_Verdef ent
;
12530 Elf_External_Verdaux
* eaux
;
12531 Elf_Internal_Verdaux aux
;
12535 vstart
= ((char *) edefs
) + idx
;
12536 if (vstart
+ sizeof (*edef
) > endbuf
)
12539 edef
= (Elf_External_Verdef
*) vstart
;
12541 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
12542 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
12543 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
12544 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
12545 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
12546 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
12547 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
12549 printf (_(" %#06zx: Rev: %d Flags: %s"),
12550 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
12552 printf (_(" Index: %d Cnt: %d "),
12553 ent
.vd_ndx
, ent
.vd_cnt
);
12555 /* Check for overflow. */
12556 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
12559 vstart
+= ent
.vd_aux
;
12561 if (vstart
+ sizeof (*eaux
) > endbuf
)
12563 eaux
= (Elf_External_Verdaux
*) vstart
;
12565 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
12566 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
12568 if (valid_dynamic_name (filedata
, aux
.vda_name
))
12569 printf (_("Name: %s\n"),
12570 get_dynamic_name (filedata
, aux
.vda_name
));
12572 printf (_("Name index: %ld\n"), aux
.vda_name
);
12574 isum
= idx
+ ent
.vd_aux
;
12576 for (j
= 1; j
< ent
.vd_cnt
; j
++)
12578 if (aux
.vda_next
< sizeof (*eaux
)
12579 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
12581 warn (_("Invalid vda_next field of %lx\n"),
12586 /* Check for overflow. */
12587 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
12590 isum
+= aux
.vda_next
;
12591 vstart
+= aux
.vda_next
;
12593 if (vstart
+ sizeof (*eaux
) > endbuf
)
12595 eaux
= (Elf_External_Verdaux
*) vstart
;
12597 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
12598 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
12600 if (valid_dynamic_name (filedata
, aux
.vda_name
))
12601 printf (_(" %#06zx: Parent %d: %s\n"),
12603 get_dynamic_name (filedata
, aux
.vda_name
));
12605 printf (_(" %#06zx: Parent %d, name index: %ld\n"),
12606 isum
, j
, aux
.vda_name
);
12609 if (j
< ent
.vd_cnt
)
12610 printf (_(" Version def aux past end of section\n"));
12613 file: id:000001,src:000172+005151,op:splice,rep:2. */
12614 if (ent
.vd_next
< sizeof (*edef
)
12615 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
12617 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
12618 cnt
= section
->sh_info
;
12621 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
12624 idx
+= ent
.vd_next
;
12627 if (cnt
< section
->sh_info
)
12628 printf (_(" Version definition past end of section\n"));
12634 case SHT_GNU_verneed
:
12636 Elf_External_Verneed
* eneed
;
12643 if (filedata
->is_separate
)
12644 printf (ngettext ("\nIn linked file '%s' the version needs section '%s' contains %u entry:\n",
12645 "\nIn linked file '%s' the version needs section '%s' contains %u entries:\n",
12647 filedata
->file_name
,
12648 printable_section_name (filedata
, section
),
12651 printf (ngettext ("\nVersion needs section '%s' "
12652 "contains %u entry:\n",
12653 "\nVersion needs section '%s' "
12654 "contains %u entries:\n",
12656 printable_section_name (filedata
, section
),
12659 printf (_(" Addr: 0x%016" PRIx64
), section
->sh_addr
);
12660 printf (_(" Offset: 0x%08" PRIx64
" Link: %u (%s)\n"),
12661 section
->sh_offset
, section
->sh_link
,
12662 printable_section_name_from_index (filedata
, section
->sh_link
));
12664 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
12665 section
->sh_offset
, 1,
12667 _("Version Needs section"));
12670 endbuf
= (char *) eneed
+ section
->sh_size
;
12672 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
12674 Elf_External_Verneed
* entry
;
12675 Elf_Internal_Verneed ent
;
12680 vstart
= ((char *) eneed
) + idx
;
12681 if (vstart
+ sizeof (*entry
) > endbuf
)
12684 entry
= (Elf_External_Verneed
*) vstart
;
12686 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
12687 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
12688 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
12689 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
12690 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
12692 printf (_(" %#06zx: Version: %d"), idx
, ent
.vn_version
);
12694 if (valid_dynamic_name (filedata
, ent
.vn_file
))
12695 printf (_(" File: %s"),
12696 get_dynamic_name (filedata
, ent
.vn_file
));
12698 printf (_(" File: %lx"), ent
.vn_file
);
12700 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
12702 /* Check for overflow. */
12703 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
12705 vstart
+= ent
.vn_aux
;
12707 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
12709 Elf_External_Vernaux
* eaux
;
12710 Elf_Internal_Vernaux aux
;
12712 if (vstart
+ sizeof (*eaux
) > endbuf
)
12714 eaux
= (Elf_External_Vernaux
*) vstart
;
12716 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
12717 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
12718 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
12719 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
12720 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
12722 if (valid_dynamic_name (filedata
, aux
.vna_name
))
12723 printf (_(" %#06zx: Name: %s"),
12724 isum
, get_dynamic_name (filedata
, aux
.vna_name
));
12726 printf (_(" %#06zx: Name index: %lx"),
12727 isum
, aux
.vna_name
);
12729 printf (_(" Flags: %s Version: %d\n"),
12730 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
12732 if (aux
.vna_next
< sizeof (*eaux
)
12733 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
12735 warn (_("Invalid vna_next field of %lx\n"),
12740 /* Check for overflow. */
12741 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
12743 isum
+= aux
.vna_next
;
12744 vstart
+= aux
.vna_next
;
12747 if (j
< ent
.vn_cnt
)
12748 warn (_("Missing Version Needs auxiliary information\n"));
12750 if (ent
.vn_next
< sizeof (*entry
)
12751 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
12753 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
12754 cnt
= section
->sh_info
;
12757 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
12759 idx
+= ent
.vn_next
;
12762 if (cnt
< section
->sh_info
)
12763 warn (_("Missing Version Needs information\n"));
12769 case SHT_GNU_versym
:
12771 Elf_Internal_Shdr
* link_section
;
12774 unsigned char * edata
;
12775 unsigned short * data
;
12777 Elf_Internal_Sym
* symbols
;
12778 Elf_Internal_Shdr
* string_sec
;
12782 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
12785 link_section
= filedata
->section_headers
+ section
->sh_link
;
12786 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
12788 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
12793 symbols
= get_elf_symbols (filedata
, link_section
, & num_syms
);
12794 if (symbols
== NULL
)
12797 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
12799 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
12800 string_sec
->sh_size
,
12801 _("version string table"));
12808 if (filedata
->is_separate
)
12809 printf (ngettext ("\nIn linked file '%s' the version symbols section '%s' contains %" PRIu64
" entry:\n",
12810 "\nIn linked file '%s' the version symbols section '%s' contains %" PRIu64
" entries:\n",
12812 filedata
->file_name
,
12813 printable_section_name (filedata
, section
),
12816 printf (ngettext ("\nVersion symbols section '%s' "
12817 "contains %" PRIu64
" entry:\n",
12818 "\nVersion symbols section '%s' "
12819 "contains %" PRIu64
" entries:\n",
12821 printable_section_name (filedata
, section
),
12824 printf (_(" Addr: 0x%016" PRIx64
), section
->sh_addr
);
12825 printf (_(" Offset: 0x%08" PRIx64
" Link: %u (%s)\n"),
12826 section
->sh_offset
, section
->sh_link
,
12827 printable_section_name (filedata
, link_section
));
12829 off
= offset_from_vma (filedata
,
12830 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
12831 total
* sizeof (short));
12832 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
12833 sizeof (short), total
,
12834 _("version symbol data"));
12842 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
12844 for (cnt
= total
; cnt
--;)
12845 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
12850 for (cnt
= 0; cnt
< total
; cnt
+= 4)
12854 char *invalid
= _("*invalid*");
12856 printf (" %03x:", cnt
);
12858 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
12859 switch (data
[cnt
+ j
])
12862 fputs (_(" 0 (*local*) "), stdout
);
12866 fputs (_(" 1 (*global*) "), stdout
);
12870 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
12871 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
12873 /* If this index value is greater than the size of the symbols
12874 array, break to avoid an out-of-bounds read. */
12875 if (cnt
+ j
>= num_syms
)
12877 warn (_("invalid index into symbol array\n"));
12882 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
12884 Elf_Internal_Verneed ivn
;
12887 offset
= offset_from_vma
12889 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
12890 sizeof (Elf_External_Verneed
));
12894 Elf_Internal_Vernaux ivna
;
12895 Elf_External_Verneed evn
;
12896 Elf_External_Vernaux evna
;
12899 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
12900 _("version need")) == NULL
)
12903 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
12904 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
12906 a_off
= offset
+ ivn
.vn_aux
;
12910 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
12911 1, _("version need aux (2)")) == NULL
)
12914 ivna
.vna_other
= 0;
12918 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
12919 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
12922 a_off
+= ivna
.vna_next
;
12924 while (ivna
.vna_other
!= data
[cnt
+ j
]
12925 && ivna
.vna_next
!= 0);
12927 if (ivna
.vna_other
== data
[cnt
+ j
])
12929 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
12931 if (ivna
.vna_name
>= string_sec
->sh_size
)
12934 name
= strtab
+ ivna
.vna_name
;
12938 offset
+= ivn
.vn_next
;
12940 while (ivn
.vn_next
);
12943 if (data
[cnt
+ j
] != 0x8001
12944 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
12946 Elf_Internal_Verdef ivd
;
12947 Elf_External_Verdef evd
;
12950 offset
= offset_from_vma
12952 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
12957 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
12958 _("version def")) == NULL
)
12961 /* PR 17531: file: 046-1082287-0.004. */
12962 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
12967 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
12968 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
12971 offset
+= ivd
.vd_next
;
12973 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
12974 && ivd
.vd_next
!= 0);
12976 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
12978 Elf_External_Verdaux evda
;
12979 Elf_Internal_Verdaux ivda
;
12981 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
12983 if (get_data (&evda
, filedata
,
12984 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
12986 _("version def aux")) == NULL
)
12989 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
12991 if (ivda
.vda_name
>= string_sec
->sh_size
)
12993 else if (name
!= NULL
&& name
!= invalid
)
12994 name
= _("*both*");
12996 name
= strtab
+ ivda
.vda_name
;
13000 nn
+= printf ("(%s%-*s",
13002 12 - (int) strlen (name
),
13006 printf ("%*c", 18 - nn
, ' ');
13025 if (filedata
->is_separate
)
13026 printf (_("\nNo version information found in linked file '%s'.\n"),
13027 filedata
->file_name
);
13029 printf (_("\nNo version information found in this file.\n"));
13035 static const char *
13036 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
13038 static char buff
[64];
13042 case STB_LOCAL
: return "LOCAL";
13043 case STB_GLOBAL
: return "GLOBAL";
13044 case STB_WEAK
: return "WEAK";
13046 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
13047 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
13049 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
13051 if (binding
== STB_GNU_UNIQUE
13052 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
13054 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
13057 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
13062 static const char *
13063 get_symbol_type (Filedata
* filedata
, unsigned int type
)
13065 static char buff
[64];
13069 case STT_NOTYPE
: return "NOTYPE";
13070 case STT_OBJECT
: return "OBJECT";
13071 case STT_FUNC
: return "FUNC";
13072 case STT_SECTION
: return "SECTION";
13073 case STT_FILE
: return "FILE";
13074 case STT_COMMON
: return "COMMON";
13075 case STT_TLS
: return "TLS";
13076 case STT_RELC
: return "RELC";
13077 case STT_SRELC
: return "SRELC";
13079 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
13081 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
13082 return "THUMB_FUNC";
13084 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
13087 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
13088 return "PARISC_MILLI";
13090 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
13092 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
13094 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13096 if (type
== STT_HP_OPAQUE
)
13097 return "HP_OPAQUE";
13098 if (type
== STT_HP_STUB
)
13102 if (type
== STT_GNU_IFUNC
13103 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
13104 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
13107 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
13110 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
13115 static const char *
13116 get_symbol_visibility (unsigned int visibility
)
13118 switch (visibility
)
13120 case STV_DEFAULT
: return "DEFAULT";
13121 case STV_INTERNAL
: return "INTERNAL";
13122 case STV_HIDDEN
: return "HIDDEN";
13123 case STV_PROTECTED
: return "PROTECTED";
13125 error (_("Unrecognized visibility value: %u\n"), visibility
);
13126 return _("<unknown>");
13130 static const char *
13131 get_alpha_symbol_other (unsigned int other
)
13135 case STO_ALPHA_NOPV
: return "NOPV";
13136 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
13138 error (_("Unrecognized alpha specific other value: %u\n"), other
);
13139 return _("<unknown>");
13143 static const char *
13144 get_solaris_symbol_visibility (unsigned int visibility
)
13146 switch (visibility
)
13148 case 4: return "EXPORTED";
13149 case 5: return "SINGLETON";
13150 case 6: return "ELIMINATE";
13151 default: return get_symbol_visibility (visibility
);
13155 static const char *
13156 get_aarch64_symbol_other (unsigned int other
)
13158 static char buf
[32];
13160 if (other
& STO_AARCH64_VARIANT_PCS
)
13162 other
&= ~STO_AARCH64_VARIANT_PCS
;
13164 return "VARIANT_PCS";
13165 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
13171 static const char *
13172 get_mips_symbol_other (unsigned int other
)
13176 case STO_OPTIONAL
: return "OPTIONAL";
13177 case STO_MIPS_PLT
: return "MIPS PLT";
13178 case STO_MIPS_PIC
: return "MIPS PIC";
13179 case STO_MICROMIPS
: return "MICROMIPS";
13180 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
13181 case STO_MIPS16
: return "MIPS16";
13182 default: return NULL
;
13186 static const char *
13187 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
13189 if (is_ia64_vms (filedata
))
13191 static char res
[32];
13195 /* Function types is for images and .STB files only. */
13196 switch (filedata
->file_header
.e_type
)
13200 switch (VMS_ST_FUNC_TYPE (other
))
13202 case VMS_SFT_CODE_ADDR
:
13203 strcat (res
, " CA");
13205 case VMS_SFT_SYMV_IDX
:
13206 strcat (res
, " VEC");
13209 strcat (res
, " FD");
13211 case VMS_SFT_RESERVE
:
13212 strcat (res
, " RSV");
13215 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
13216 VMS_ST_FUNC_TYPE (other
));
13217 strcat (res
, " <unknown>");
13224 switch (VMS_ST_LINKAGE (other
))
13226 case VMS_STL_IGNORE
:
13227 strcat (res
, " IGN");
13229 case VMS_STL_RESERVE
:
13230 strcat (res
, " RSV");
13233 strcat (res
, " STD");
13236 strcat (res
, " LNK");
13239 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
13240 VMS_ST_LINKAGE (other
));
13241 strcat (res
, " <unknown>");
13253 static const char *
13254 get_ppc64_symbol_other (unsigned int other
)
13256 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
13259 other
>>= STO_PPC64_LOCAL_BIT
;
13262 static char buf
[64];
13264 other
= ppc64_decode_local_entry (other
);
13265 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
13271 static const char *
13272 get_riscv_symbol_other (unsigned int other
)
13274 static char buf
[32];
13277 if (other
& STO_RISCV_VARIANT_CC
)
13279 strcat (buf
, _(" VARIANT_CC"));
13280 other
&= ~STO_RISCV_VARIANT_CC
;
13284 snprintf (buf
, sizeof buf
, " %x", other
);
13293 static const char *
13294 get_symbol_other (Filedata
* filedata
, unsigned int other
)
13296 const char * result
= NULL
;
13297 static char buff
[64];
13302 switch (filedata
->file_header
.e_machine
)
13305 result
= get_alpha_symbol_other (other
);
13308 result
= get_aarch64_symbol_other (other
);
13311 result
= get_mips_symbol_other (other
);
13314 result
= get_ia64_symbol_other (filedata
, other
);
13317 result
= get_ppc64_symbol_other (other
);
13320 result
= get_riscv_symbol_other (other
);
13330 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
13334 static const char *
13335 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
13337 static char buff
[32];
13341 case SHN_UNDEF
: return "UND";
13342 case SHN_ABS
: return "ABS";
13343 case SHN_COMMON
: return "COM";
13345 if (type
== SHN_IA_64_ANSI_COMMON
13346 && filedata
->file_header
.e_machine
== EM_IA_64
13347 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
13349 else if ((filedata
->file_header
.e_machine
== EM_X86_64
13350 || filedata
->file_header
.e_machine
== EM_L1OM
13351 || filedata
->file_header
.e_machine
== EM_K1OM
)
13352 && type
== SHN_X86_64_LCOMMON
)
13353 return "LARGE_COM";
13354 else if ((type
== SHN_MIPS_SCOMMON
13355 && filedata
->file_header
.e_machine
== EM_MIPS
)
13356 || (type
== SHN_TIC6X_SCOMMON
13357 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
13359 else if (type
== SHN_MIPS_SUNDEFINED
13360 && filedata
->file_header
.e_machine
== EM_MIPS
)
13362 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
13363 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
13364 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
13365 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
13366 else if (type
>= SHN_LORESERVE
)
13367 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
13368 else if (filedata
->file_header
.e_shnum
!= 0
13369 && type
>= filedata
->file_header
.e_shnum
)
13370 sprintf (buff
, _("bad section index[%3d]"), type
);
13372 sprintf (buff
, "%3d", type
);
13379 static const char *
13380 get_symbol_version_string (Filedata
*filedata
,
13382 const char *strtab
,
13383 size_t strtab_size
,
13385 Elf_Internal_Sym
*psym
,
13386 enum versioned_symbol_info
*sym_info
,
13387 unsigned short *vna_other
)
13389 unsigned char data
[2];
13390 unsigned short vers_data
;
13392 unsigned short max_vd_ndx
;
13395 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
13398 offset
= offset_from_vma (filedata
,
13399 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
13400 sizeof data
+ si
* sizeof (vers_data
));
13402 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
13403 sizeof (data
), 1, _("version data")) == NULL
)
13406 vers_data
= byte_get (data
, 2);
13408 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
13411 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
13414 /* Usually we'd only see verdef for defined symbols, and verneed for
13415 undefined symbols. However, symbols defined by the linker in
13416 .dynbss for variables copied from a shared library in order to
13417 avoid text relocations are defined yet have verneed. We could
13418 use a heuristic to detect the special case, for example, check
13419 for verneed first on symbols defined in SHT_NOBITS sections, but
13420 it is simpler and more reliable to just look for both verdef and
13421 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
13423 if (psym
->st_shndx
!= SHN_UNDEF
13424 && vers_data
!= 0x8001
13425 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
13427 Elf_Internal_Verdef ivd
;
13428 Elf_Internal_Verdaux ivda
;
13429 Elf_External_Verdaux evda
;
13432 off
= offset_from_vma (filedata
,
13433 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
13434 sizeof (Elf_External_Verdef
));
13438 Elf_External_Verdef evd
;
13440 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
13441 _("version def")) == NULL
)
13450 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
13451 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
13452 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
13453 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
13456 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
13457 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
13459 off
+= ivd
.vd_next
;
13461 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
13463 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
13465 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
13468 off
-= ivd
.vd_next
;
13471 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
13472 _("version def aux")) != NULL
)
13474 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
13476 if (psym
->st_name
!= ivda
.vda_name
)
13477 return (ivda
.vda_name
< strtab_size
13478 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
13483 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
13485 Elf_External_Verneed evn
;
13486 Elf_Internal_Verneed ivn
;
13487 Elf_Internal_Vernaux ivna
;
13489 offset
= offset_from_vma (filedata
,
13490 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
13496 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
13497 _("version need")) == NULL
)
13500 ivna
.vna_other
= 0;
13505 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
13506 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
13508 vna_off
= offset
+ ivn
.vn_aux
;
13512 Elf_External_Vernaux evna
;
13514 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
13515 _("version need aux (3)")) == NULL
)
13518 ivna
.vna_other
= 0;
13523 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
13524 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
13525 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
13528 vna_off
+= ivna
.vna_next
;
13530 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
13532 if (ivna
.vna_other
== vers_data
)
13535 offset
+= ivn
.vn_next
;
13537 while (ivn
.vn_next
!= 0);
13539 if (ivna
.vna_other
== vers_data
)
13541 *sym_info
= symbol_undefined
;
13542 *vna_other
= ivna
.vna_other
;
13543 return (ivna
.vna_name
< strtab_size
13544 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
13546 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
13547 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
13548 return _("<corrupt>");
13553 /* Display a symbol size on stdout. Format is based on --sym-base setting. */
13555 static unsigned int
13556 print_dynamic_symbol_size (uint64_t vma
, int base
)
13561 return print_vma (vma
, OCTAL_5
);
13564 return print_vma (vma
, UNSIGNED_5
);
13567 return print_vma (vma
, PREFIX_HEX_5
);
13571 return print_vma (vma
, DEC_5
);
13576 print_dynamic_symbol (Filedata
*filedata
, uint64_t si
,
13577 Elf_Internal_Sym
*symtab
,
13578 Elf_Internal_Shdr
*section
,
13579 char *strtab
, size_t strtab_size
)
13581 const char *version_string
;
13582 enum versioned_symbol_info sym_info
;
13583 unsigned short vna_other
;
13586 Elf_Internal_Sym
*psym
= symtab
+ si
;
13588 printf ("%6" PRId64
": ", si
);
13589 print_vma (psym
->st_value
, LONG_HEX
);
13591 print_dynamic_symbol_size (psym
->st_size
, sym_base
);
13592 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
13593 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
13594 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
13595 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
13598 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
13600 printf (" %-7s", get_symbol_visibility (vis
));
13601 /* Check to see if any other bits in the st_other field are set.
13602 Note - displaying this information disrupts the layout of the
13603 table being generated, but for the moment this case is very rare. */
13604 if (psym
->st_other
^ vis
)
13605 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
13607 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
13609 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
13610 && psym
->st_shndx
< filedata
->file_header
.e_shnum
13611 && filedata
->section_headers
!= NULL
13612 && psym
->st_name
== 0)
13615 = section_name_valid (filedata
,
13616 filedata
->section_headers
+ psym
->st_shndx
);
13618 section_name_print (filedata
,
13619 filedata
->section_headers
+ psym
->st_shndx
)
13624 is_valid
= valid_symbol_name (strtab
, strtab_size
, psym
->st_name
);
13625 sstr
= is_valid
? strtab
+ psym
->st_name
: _("<corrupt>");
13629 = get_symbol_version_string (filedata
,
13631 || section
->sh_type
== SHT_DYNSYM
),
13632 strtab
, strtab_size
, si
,
13633 psym
, &sym_info
, &vna_other
);
13635 int len_avail
= 21;
13636 if (! do_wide
&& version_string
!= NULL
)
13640 len_avail
-= 1 + strlen (version_string
);
13642 if (sym_info
== symbol_undefined
)
13643 len_avail
-= sprintf (buffer
," (%d)", vna_other
);
13644 else if (sym_info
!= symbol_hidden
)
13648 print_symbol (len_avail
, sstr
);
13650 if (version_string
)
13652 if (sym_info
== symbol_undefined
)
13653 printf ("@%s (%d)", version_string
, vna_other
);
13655 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
13661 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
13663 && si
>= section
->sh_info
13664 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
13665 && filedata
->file_header
.e_machine
!= EM_MIPS
13666 /* Solaris binaries have been found to violate this requirement as
13667 well. Not sure if this is a bug or an ABI requirement. */
13668 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
13669 warn (_("local symbol %" PRIu64
" found at index >= %s's sh_info value of %u\n"),
13670 si
, printable_section_name (filedata
, section
), section
->sh_info
);
13673 static const char *
13674 get_lto_kind (unsigned int kind
)
13678 case 0: return "DEF";
13679 case 1: return "WEAKDEF";
13680 case 2: return "UNDEF";
13681 case 3: return "WEAKUNDEF";
13682 case 4: return "COMMON";
13687 static char buffer
[30];
13688 error (_("Unknown LTO symbol definition encountered: %u\n"), kind
);
13689 sprintf (buffer
, "<unknown: %u>", kind
);
13693 static const char *
13694 get_lto_visibility (unsigned int visibility
)
13696 switch (visibility
)
13698 case 0: return "DEFAULT";
13699 case 1: return "PROTECTED";
13700 case 2: return "INTERNAL";
13701 case 3: return "HIDDEN";
13706 static char buffer
[30];
13707 error (_("Unknown LTO symbol visibility encountered: %u\n"), visibility
);
13708 sprintf (buffer
, "<unknown: %u>", visibility
);
13712 static const char *
13713 get_lto_sym_type (unsigned int sym_type
)
13717 case 0: return "UNKNOWN";
13718 case 1: return "FUNCTION";
13719 case 2: return "VARIABLE";
13724 static char buffer
[30];
13725 error (_("Unknown LTO symbol type encountered: %u\n"), sym_type
);
13726 sprintf (buffer
, "<unknown: %u>", sym_type
);
13730 /* Display an LTO format symbol table.
13731 FIXME: The format of LTO symbol tables is not formalized.
13732 So this code could need changing in the future. */
13735 display_lto_symtab (Filedata
* filedata
,
13736 Elf_Internal_Shdr
* section
)
13738 if (section
->sh_size
== 0)
13740 if (filedata
->is_separate
)
13741 printf (_("\nThe LTO Symbol table section '%s' in linked file '%s' is empty!\n"),
13742 printable_section_name (filedata
, section
),
13743 filedata
->file_name
);
13745 printf (_("\nLTO Symbol table '%s' is empty!\n"),
13746 printable_section_name (filedata
, section
));
13751 if (section
->sh_size
> filedata
->file_size
)
13753 error (_("Section %s has an invalid sh_size of %#" PRIx64
"\n"),
13754 printable_section_name (filedata
, section
),
13759 void * alloced_data
= get_data (NULL
, filedata
, section
->sh_offset
,
13760 section
->sh_size
, 1, _("LTO symbols"));
13761 if (alloced_data
== NULL
)
13764 /* Look for extended data for the symbol table. */
13765 Elf_Internal_Shdr
* ext
;
13766 void * ext_data_orig
= NULL
;
13767 char * ext_data
= NULL
;
13768 char * ext_data_end
= NULL
;
13769 char * ext_name
= NULL
;
13771 if (asprintf (& ext_name
, ".gnu.lto_.ext_symtab.%s",
13772 (section_name (filedata
, section
)
13773 + sizeof (".gnu.lto_.symtab.") - 1)) > 0
13774 && ext_name
!= NULL
/* Paranoia. */
13775 && (ext
= find_section (filedata
, ext_name
)) != NULL
)
13777 if (ext
->sh_size
< 3)
13778 error (_("LTO Symbol extension table '%s' is empty!\n"),
13779 printable_section_name (filedata
, ext
));
13782 ext_data_orig
= ext_data
= get_data (NULL
, filedata
, ext
->sh_offset
,
13784 _("LTO ext symbol data"));
13785 if (ext_data
!= NULL
)
13787 ext_data_end
= ext_data
+ ext
->sh_size
;
13788 if (* ext_data
++ != 1)
13789 error (_("Unexpected version number in symbol extension table\n"));
13794 const unsigned char * data
= (const unsigned char *) alloced_data
;
13795 const unsigned char * end
= data
+ section
->sh_size
;
13797 if (filedata
->is_separate
)
13798 printf (_("\nIn linked file '%s': "), filedata
->file_name
);
13802 if (ext_data_orig
!= NULL
)
13805 printf (_("LTO Symbol table '%s' and extension table '%s' contain:\n"),
13806 printable_section_name (filedata
, section
),
13807 printable_section_name (filedata
, ext
));
13810 printf (_("LTO Symbol table '%s'\n"),
13811 printable_section_name (filedata
, section
));
13812 printf (_(" and extension table '%s' contain:\n"),
13813 printable_section_name (filedata
, ext
));
13817 printf (_("LTO Symbol table '%s' contains:\n"),
13818 printable_section_name (filedata
, section
));
13820 /* FIXME: Add a wide version. */
13821 if (ext_data_orig
!= NULL
)
13822 printf (_(" Comdat_Key Kind Visibility Size Slot Type Section Name\n"));
13824 printf (_(" Comdat_Key Kind Visibility Size Slot Name\n"));
13826 /* FIXME: We do not handle style prefixes. */
13830 const unsigned char * sym_name
= data
;
13831 data
+= strnlen ((const char *) sym_name
, end
- data
) + 1;
13835 const unsigned char * comdat_key
= data
;
13836 data
+= strnlen ((const char *) comdat_key
, end
- data
) + 1;
13840 if (data
+ 2 + 8 + 4 > end
)
13843 unsigned int kind
= *data
++;
13844 unsigned int visibility
= *data
++;
13846 uint64_t size
= byte_get (data
, 8);
13849 uint64_t slot
= byte_get (data
, 4);
13852 if (ext_data
!= NULL
)
13854 if (ext_data
< (ext_data_end
- 1))
13856 unsigned int sym_type
= * ext_data
++;
13857 unsigned int sec_kind
= * ext_data
++;
13859 printf (" %10s %10s %11s %08" PRIx64
" %08" PRIx64
" %9s %08x _",
13860 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
13861 get_lto_kind (kind
),
13862 get_lto_visibility (visibility
),
13865 get_lto_sym_type (sym_type
),
13867 print_symbol (6, (const char *) sym_name
);
13871 error (_("Ran out of LTO symbol extension data\n"));
13873 /* FIXME: return FAIL result ? */
13878 printf (" %10s %10s %11s %08" PRIx64
" %08" PRIx64
" _",
13879 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
13880 get_lto_kind (kind
),
13881 get_lto_visibility (visibility
),
13884 print_symbol (21, (const char *) sym_name
);
13889 if (ext_data
!= NULL
&& ext_data
< ext_data_end
)
13891 error (_("Data remains in the LTO symbol extension table\n"));
13895 free (alloced_data
);
13896 free (ext_data_orig
);
13901 error (_("Buffer overrun encountered whilst decoding LTO symbol table\n"));
13902 free (alloced_data
);
13903 free (ext_data_orig
);
13908 /* Display LTO symbol tables. */
13911 process_lto_symbol_tables (Filedata
* filedata
)
13913 Elf_Internal_Shdr
* section
;
13920 if (filedata
->section_headers
== NULL
)
13923 for (i
= 0, section
= filedata
->section_headers
;
13924 i
< filedata
->file_header
.e_shnum
;
13926 if (section_name_valid (filedata
, section
)
13927 && startswith (section_name (filedata
, section
), ".gnu.lto_.symtab."))
13928 res
&= display_lto_symtab (filedata
, section
);
13933 /* Dump the symbol table. */
13936 process_symbol_table (Filedata
* filedata
)
13938 Elf_Internal_Shdr
* section
;
13940 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
13943 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
13945 && do_using_dynamic
13946 && filedata
->dynamic_strings
!= NULL
13947 && filedata
->dynamic_symbols
!= NULL
)
13951 if (filedata
->is_separate
)
13953 printf (ngettext ("\nIn linked file '%s' the dynamic symbol table"
13954 " contains %" PRIu64
" entry:\n",
13955 "\nIn linked file '%s' the dynamic symbol table"
13956 " contains %" PRIu64
" entries:\n",
13957 filedata
->num_dynamic_syms
),
13958 filedata
->file_name
,
13959 filedata
->num_dynamic_syms
);
13963 printf (ngettext ("\nSymbol table for image contains %" PRIu64
13965 "\nSymbol table for image contains %" PRIu64
13967 filedata
->num_dynamic_syms
),
13968 filedata
->num_dynamic_syms
);
13971 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
13973 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
13975 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
13976 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
13977 filedata
->dynamic_strings
,
13978 filedata
->dynamic_strings_length
);
13980 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
13981 && filedata
->section_headers
!= NULL
)
13985 for (i
= 0, section
= filedata
->section_headers
;
13986 i
< filedata
->file_header
.e_shnum
;
13989 char * strtab
= NULL
;
13990 uint64_t strtab_size
= 0;
13991 Elf_Internal_Sym
* symtab
;
13992 uint64_t si
, num_syms
;
13994 if ((section
->sh_type
!= SHT_SYMTAB
13995 && section
->sh_type
!= SHT_DYNSYM
)
13997 && section
->sh_type
== SHT_SYMTAB
))
14000 if (section
->sh_entsize
== 0)
14002 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
14003 printable_section_name (filedata
, section
));
14007 num_syms
= section
->sh_size
/ section
->sh_entsize
;
14009 if (filedata
->is_separate
)
14010 printf (ngettext ("\nIn linked file '%s' symbol section '%s'"
14011 " contains %" PRIu64
" entry:\n",
14012 "\nIn linked file '%s' symbol section '%s'"
14013 " contains %" PRIu64
" entries:\n",
14015 filedata
->file_name
,
14016 printable_section_name (filedata
, section
),
14019 printf (ngettext ("\nSymbol table '%s' contains %" PRIu64
14021 "\nSymbol table '%s' contains %" PRIu64
14024 printable_section_name (filedata
, section
),
14028 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
14030 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
14032 symtab
= get_elf_symbols (filedata
, section
, & num_syms
);
14033 if (symtab
== NULL
)
14036 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
14038 strtab
= filedata
->string_table
;
14039 strtab_size
= filedata
->string_table_length
;
14041 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
14043 Elf_Internal_Shdr
* string_sec
;
14045 string_sec
= filedata
->section_headers
+ section
->sh_link
;
14047 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
14048 1, string_sec
->sh_size
,
14049 _("string table"));
14050 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
14053 for (si
= 0; si
< num_syms
; si
++)
14054 print_dynamic_symbol (filedata
, si
, symtab
, section
,
14055 strtab
, strtab_size
);
14058 if (strtab
!= filedata
->string_table
)
14064 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
14066 if (do_histogram
&& filedata
->buckets
!= NULL
)
14072 uint64_t maxlength
= 0;
14073 uint64_t nzero_counts
= 0;
14074 uint64_t nsyms
= 0;
14077 printf (ngettext ("\nHistogram for bucket list length "
14078 "(total of %" PRIu64
" bucket):\n",
14079 "\nHistogram for bucket list length "
14080 "(total of %" PRIu64
" buckets):\n",
14081 filedata
->nbuckets
),
14082 filedata
->nbuckets
);
14084 lengths
= calloc (filedata
->nbuckets
, sizeof (*lengths
));
14085 if (lengths
== NULL
)
14087 error (_("Out of memory allocating space for histogram buckets\n"));
14090 visited
= xcmalloc (filedata
->nchains
, 1);
14091 memset (visited
, 0, filedata
->nchains
);
14093 printf (_(" Length Number %% of total Coverage\n"));
14094 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
14096 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
14099 if (maxlength
< ++lengths
[hn
])
14101 if (si
>= filedata
->nchains
|| visited
[si
])
14103 error (_("histogram chain is corrupt\n"));
14111 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
14112 if (counts
== NULL
)
14115 error (_("Out of memory allocating space for histogram counts\n"));
14119 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
14120 ++counts
[lengths
[hn
]];
14122 if (filedata
->nbuckets
> 0)
14125 printf (" 0 %-10" PRIu64
" (%5.1f%%)\n",
14126 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
14127 for (i
= 1; i
<= maxlength
; ++i
)
14129 nzero_counts
+= counts
[i
] * i
;
14130 printf ("%7" PRIu64
" %-10" PRIu64
" (%5.1f%%) %5.1f%%\n",
14131 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
14132 (nzero_counts
* 100.0) / nsyms
);
14140 free (filedata
->buckets
);
14141 filedata
->buckets
= NULL
;
14142 filedata
->nbuckets
= 0;
14143 free (filedata
->chains
);
14144 filedata
->chains
= NULL
;
14146 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
14151 uint64_t maxlength
= 0;
14152 uint64_t nzero_counts
= 0;
14153 uint64_t nsyms
= 0;
14155 printf (ngettext ("\nHistogram for `%s' bucket list length "
14156 "(total of %" PRIu64
" bucket):\n",
14157 "\nHistogram for `%s' bucket list length "
14158 "(total of %" PRIu64
" buckets):\n",
14159 filedata
->ngnubuckets
),
14160 GNU_HASH_SECTION_NAME (filedata
),
14161 filedata
->ngnubuckets
);
14163 lengths
= calloc (filedata
->ngnubuckets
, sizeof (*lengths
));
14164 if (lengths
== NULL
)
14166 error (_("Out of memory allocating space for gnu histogram buckets\n"));
14170 printf (_(" Length Number %% of total Coverage\n"));
14172 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
14173 if (filedata
->gnubuckets
[hn
] != 0)
14175 uint64_t off
, length
= 1;
14177 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
14178 /* PR 17531 file: 010-77222-0.004. */
14179 off
< filedata
->ngnuchains
14180 && (filedata
->gnuchains
[off
] & 1) == 0;
14183 lengths
[hn
] = length
;
14184 if (length
> maxlength
)
14185 maxlength
= length
;
14189 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
14190 if (counts
== NULL
)
14193 error (_("Out of memory allocating space for gnu histogram counts\n"));
14197 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
14198 ++counts
[lengths
[hn
]];
14200 if (filedata
->ngnubuckets
> 0)
14203 printf (" 0 %-10" PRIu64
" (%5.1f%%)\n",
14204 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
14205 for (j
= 1; j
<= maxlength
; ++j
)
14207 nzero_counts
+= counts
[j
] * j
;
14208 printf ("%7" PRIu64
" %-10" PRIu64
" (%5.1f%%) %5.1f%%\n",
14209 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
14210 (nzero_counts
* 100.0) / nsyms
);
14217 free (filedata
->gnubuckets
);
14218 filedata
->gnubuckets
= NULL
;
14219 filedata
->ngnubuckets
= 0;
14220 free (filedata
->gnuchains
);
14221 filedata
->gnuchains
= NULL
;
14222 filedata
->ngnuchains
= 0;
14223 free (filedata
->mipsxlat
);
14224 filedata
->mipsxlat
= NULL
;
14228 free (filedata
->gnubuckets
);
14229 filedata
->gnubuckets
= NULL
;
14230 filedata
->ngnubuckets
= 0;
14231 free (filedata
->gnuchains
);
14232 filedata
->gnuchains
= NULL
;
14233 filedata
->ngnuchains
= 0;
14234 free (filedata
->mipsxlat
);
14235 filedata
->mipsxlat
= NULL
;
14236 free (filedata
->buckets
);
14237 filedata
->buckets
= NULL
;
14238 filedata
->nbuckets
= 0;
14239 free (filedata
->chains
);
14240 filedata
->chains
= NULL
;
14245 process_syminfo (Filedata
* filedata
)
14249 if (filedata
->dynamic_syminfo
== NULL
14251 /* No syminfo, this is ok. */
14254 /* There better should be a dynamic symbol section. */
14255 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
14258 if (filedata
->is_separate
)
14259 printf (ngettext ("\nIn linked file '%s: the dynamic info segment at offset %#" PRIx64
" contains %d entry:\n",
14260 "\nIn linked file '%s: the dynamic info segment at offset %#" PRIx64
" contains %d entries:\n",
14261 filedata
->dynamic_syminfo_nent
),
14262 filedata
->file_name
,
14263 filedata
->dynamic_syminfo_offset
,
14264 filedata
->dynamic_syminfo_nent
);
14266 printf (ngettext ("\nDynamic info segment at offset %#" PRIx64
14267 " contains %d entry:\n",
14268 "\nDynamic info segment at offset %#" PRIx64
14269 " contains %d entries:\n",
14270 filedata
->dynamic_syminfo_nent
),
14271 filedata
->dynamic_syminfo_offset
,
14272 filedata
->dynamic_syminfo_nent
);
14274 printf (_(" Num: Name BoundTo Flags\n"));
14275 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
14277 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
14279 printf ("%4d: ", i
);
14280 if (i
>= filedata
->num_dynamic_syms
)
14281 printf (_("<corrupt index>"));
14282 else if (valid_dynamic_name (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
14283 print_symbol (30, get_dynamic_name (filedata
,
14284 filedata
->dynamic_symbols
[i
].st_name
));
14286 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
14289 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
14291 case SYMINFO_BT_SELF
:
14292 fputs ("SELF ", stdout
);
14294 case SYMINFO_BT_PARENT
:
14295 fputs ("PARENT ", stdout
);
14298 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
14299 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
14300 && valid_dynamic_name (filedata
,
14301 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
14303 print_symbol (10, get_dynamic_name (filedata
,
14304 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
14308 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
14312 if (flags
& SYMINFO_FLG_DIRECT
)
14313 printf (" DIRECT");
14314 if (flags
& SYMINFO_FLG_PASSTHRU
)
14315 printf (" PASSTHRU");
14316 if (flags
& SYMINFO_FLG_COPY
)
14318 if (flags
& SYMINFO_FLG_LAZYLOAD
)
14319 printf (" LAZYLOAD");
14327 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
14328 is contained by the region START .. END. The types of ADDR, START
14329 and END should all be the same. Note both ADDR + NELEM and END
14330 point to just beyond the end of the regions that are being tested. */
14331 #define IN_RANGE(START,END,ADDR,NELEM) \
14332 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
14334 /* Check to see if the given reloc needs to be handled in a target specific
14335 manner. If so then process the reloc and return TRUE otherwise return
14338 If called with reloc == NULL, then this is a signal that reloc processing
14339 for the current section has finished, and any saved state should be
14343 target_specific_reloc_handling (Filedata
*filedata
,
14344 Elf_Internal_Rela
*reloc
,
14345 unsigned char *start
,
14346 unsigned char *end
,
14347 Elf_Internal_Sym
*symtab
,
14350 unsigned int reloc_type
= 0;
14351 uint64_t sym_index
= 0;
14355 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
14356 sym_index
= get_reloc_symindex (reloc
->r_info
);
14359 switch (filedata
->file_header
.e_machine
)
14363 switch (reloc_type
)
14365 /* For .uleb128 .LFE1-.LFB1, loongarch write 0 to object file
14366 at assembly time. */
14367 case 107: /* R_LARCH_ADD_ULEB128. */
14368 case 108: /* R_LARCH_SUB_ULEB128. */
14370 uint64_t value
= 0;
14371 unsigned int reloc_size
= 0;
14374 if (reloc
->r_offset
< (size_t) (end
- start
))
14375 value
= read_leb128 (start
+ reloc
->r_offset
, end
, false,
14376 &reloc_size
, &leb_ret
);
14377 if (leb_ret
!= 0 || reloc_size
== 0 || reloc_size
> 8)
14378 error (_("LoongArch ULEB128 field at 0x%lx contains invalid "
14379 "ULEB128 value\n"),
14380 (long) reloc
->r_offset
);
14382 else if (sym_index
>= num_syms
)
14383 error (_("%s reloc contains invalid symbol index "
14386 ? "R_LARCH_ADD_ULEB128"
14387 : "R_LARCH_SUB_ULEB128"),
14391 if (reloc_type
== 107)
14392 value
+= reloc
->r_addend
+ symtab
[sym_index
].st_value
;
14394 value
-= reloc
->r_addend
+ symtab
[sym_index
].st_value
;
14396 /* Write uleb128 value to p. */
14397 bfd_byte
*p
= start
+ reloc
->r_offset
;
14400 bfd_byte c
= value
& 0x7f;
14402 if (--reloc_size
!= 0)
14406 while (reloc_size
);
14416 case EM_MSP430_OLD
:
14418 static Elf_Internal_Sym
* saved_sym
= NULL
;
14426 switch (reloc_type
)
14428 case 10: /* R_MSP430_SYM_DIFF */
14429 case 12: /* R_MSP430_GNU_SUB_ULEB128 */
14430 if (uses_msp430x_relocs (filedata
))
14432 /* Fall through. */
14433 case 21: /* R_MSP430X_SYM_DIFF */
14434 case 23: /* R_MSP430X_GNU_SUB_ULEB128 */
14436 if (sym_index
>= num_syms
)
14437 error (_("%s reloc contains invalid symbol index "
14438 "%" PRIu64
"\n"), "MSP430 SYM_DIFF", sym_index
);
14440 saved_sym
= symtab
+ sym_index
;
14443 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
14444 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
14445 goto handle_sym_diff
;
14447 case 5: /* R_MSP430_16_BYTE */
14448 case 9: /* R_MSP430_8 */
14449 case 11: /* R_MSP430_GNU_SET_ULEB128 */
14450 if (uses_msp430x_relocs (filedata
))
14452 goto handle_sym_diff
;
14454 case 2: /* R_MSP430_ABS16 */
14455 case 15: /* R_MSP430X_ABS16 */
14456 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
14457 if (! uses_msp430x_relocs (filedata
))
14459 goto handle_sym_diff
;
14462 if (saved_sym
!= NULL
)
14465 unsigned int reloc_size
= 0;
14467 switch (reloc_type
)
14469 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
14472 case 11: /* R_MSP430_GNU_SET_ULEB128 */
14473 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
14474 if (reloc
->r_offset
< (size_t) (end
- start
))
14475 read_leb128 (start
+ reloc
->r_offset
, end
, false,
14476 &reloc_size
, &leb_ret
);
14483 if (leb_ret
!= 0 || reloc_size
== 0 || reloc_size
> 8)
14484 error (_("MSP430 ULEB128 field at %#" PRIx64
14485 " contains invalid ULEB128 value\n"),
14487 else if (sym_index
>= num_syms
)
14488 error (_("%s reloc contains invalid symbol index "
14489 "%" PRIu64
"\n"), "MSP430", sym_index
);
14492 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
14493 - saved_sym
->st_value
);
14495 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
14496 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
14499 error (_("MSP430 sym diff reloc contains invalid offset: "
14510 if (saved_sym
!= NULL
)
14511 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
14518 case EM_CYGNUS_MN10300
:
14520 static Elf_Internal_Sym
* saved_sym
= NULL
;
14528 switch (reloc_type
)
14530 case 34: /* R_MN10300_ALIGN */
14532 case 33: /* R_MN10300_SYM_DIFF */
14533 if (sym_index
>= num_syms
)
14534 error (_("%s reloc contains invalid symbol index "
14535 "%" PRIu64
"\n"), "MN10300_SYM_DIFF", sym_index
);
14537 saved_sym
= symtab
+ sym_index
;
14540 case 1: /* R_MN10300_32 */
14541 case 2: /* R_MN10300_16 */
14542 if (saved_sym
!= NULL
)
14544 int reloc_size
= reloc_type
== 1 ? 4 : 2;
14547 if (sym_index
>= num_syms
)
14548 error (_("%s reloc contains invalid symbol index "
14549 "%" PRIu64
"\n"), "MN10300", sym_index
);
14552 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
14553 - saved_sym
->st_value
);
14555 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
14556 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
14558 error (_("MN10300 sym diff reloc contains invalid offset:"
14559 " %#" PRIx64
"\n"),
14568 if (saved_sym
!= NULL
)
14569 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
14577 static uint64_t saved_sym1
= 0;
14578 static uint64_t saved_sym2
= 0;
14579 static uint64_t value
;
14583 saved_sym1
= saved_sym2
= 0;
14587 switch (reloc_type
)
14589 case 0x80: /* R_RL78_SYM. */
14590 saved_sym1
= saved_sym2
;
14591 if (sym_index
>= num_syms
)
14592 error (_("%s reloc contains invalid symbol index "
14593 "%" PRIu64
"\n"), "RL78_SYM", sym_index
);
14596 saved_sym2
= symtab
[sym_index
].st_value
;
14597 saved_sym2
+= reloc
->r_addend
;
14601 case 0x83: /* R_RL78_OPsub. */
14602 value
= saved_sym1
- saved_sym2
;
14603 saved_sym2
= saved_sym1
= 0;
14607 case 0x41: /* R_RL78_ABS32. */
14608 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
14609 byte_put (start
+ reloc
->r_offset
, value
, 4);
14611 error (_("RL78 sym diff reloc contains invalid offset: "
14617 case 0x43: /* R_RL78_ABS16. */
14618 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
14619 byte_put (start
+ reloc
->r_offset
, value
, 2);
14621 error (_("RL78 sym diff reloc contains invalid offset: "
14637 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
14638 DWARF debug sections. This is a target specific test. Note - we do not
14639 go through the whole including-target-headers-multiple-times route, (as
14640 we have already done with <elf/h8.h>) because this would become very
14641 messy and even then this function would have to contain target specific
14642 information (the names of the relocs instead of their numeric values).
14643 FIXME: This is not the correct way to solve this problem. The proper way
14644 is to have target specific reloc sizing and typing functions created by
14645 the reloc-macros.h header, in the same way that it already creates the
14646 reloc naming functions. */
14649 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14651 /* Please keep this table alpha-sorted for ease of visual lookup. */
14652 switch (filedata
->file_header
.e_machine
)
14656 return reloc_type
== 1; /* R_386_32. */
14658 return reloc_type
== 1; /* R_68K_32. */
14660 return reloc_type
== 1; /* R_860_32. */
14662 return reloc_type
== 2; /* R_960_32. */
14664 return (reloc_type
== 258
14665 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
14667 return reloc_type
== 11; /* R_BPF_DATA_32 */
14668 case EM_ADAPTEVA_EPIPHANY
:
14669 return reloc_type
== 3;
14671 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
14673 return reloc_type
== 1; /* R_ARC_32. */
14674 case EM_ARC_COMPACT
:
14675 case EM_ARC_COMPACT2
:
14676 case EM_ARC_COMPACT3
:
14677 case EM_ARC_COMPACT3_64
:
14678 return reloc_type
== 4; /* R_ARC_32. */
14680 return reloc_type
== 2; /* R_ARM_ABS32 */
14683 return reloc_type
== 1;
14685 return reloc_type
== 0x12; /* R_byte4_data. */
14687 return reloc_type
== 3; /* R_CRIS_32. */
14689 return reloc_type
== 3; /* R_CR16_NUM32. */
14691 return reloc_type
== 15; /* R_CRX_NUM32. */
14693 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
14694 case EM_CYGNUS_FRV
:
14695 return reloc_type
== 1;
14696 case EM_CYGNUS_D10V
:
14698 return reloc_type
== 6; /* R_D10V_32. */
14699 case EM_CYGNUS_D30V
:
14701 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
14703 return reloc_type
== 3; /* R_DLX_RELOC_32. */
14704 case EM_CYGNUS_FR30
:
14706 return reloc_type
== 3; /* R_FR30_32. */
14708 return reloc_type
== 1; /* R_FT32_32. */
14712 return reloc_type
== 1; /* R_H8_DIR32. */
14714 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
14715 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
14716 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
14717 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
14720 return reloc_type
== 2; /* R_IP2K_32. */
14722 return reloc_type
== 2; /* R_IQ2000_32. */
14723 case EM_LATTICEMICO32
:
14724 return reloc_type
== 3; /* R_LM32_32. */
14726 return reloc_type
== 1; /* R_LARCH_32. */
14729 return reloc_type
== 3; /* R_M32C_32. */
14731 return reloc_type
== 34; /* R_M32R_32_RELA. */
14734 return reloc_type
== 6; /* R_M68HC11_32. */
14736 return reloc_type
== 7 || /* R_S12Z_EXT32 */
14737 reloc_type
== 6; /* R_S12Z_CW32. */
14739 return reloc_type
== 1; /* R_MCORE_ADDR32. */
14740 case EM_CYGNUS_MEP
:
14741 return reloc_type
== 4; /* R_MEP_32. */
14743 return reloc_type
== 2; /* R_METAG_ADDR32. */
14744 case EM_MICROBLAZE
:
14745 return reloc_type
== 1; /* R_MICROBLAZE_32. */
14747 return reloc_type
== 2; /* R_MIPS_32. */
14749 return reloc_type
== 4; /* R_MMIX_32. */
14750 case EM_CYGNUS_MN10200
:
14752 return reloc_type
== 1; /* R_MN10200_32. */
14753 case EM_CYGNUS_MN10300
:
14755 return reloc_type
== 1; /* R_MN10300_32. */
14757 return reloc_type
== 1; /* R_MOXIE_32. */
14758 case EM_MSP430_OLD
:
14760 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
14762 return reloc_type
== 2; /* R_MT_32. */
14764 return reloc_type
== 20; /* R_NDS32_32_RELA. */
14765 case EM_ALTERA_NIOS2
:
14766 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
14768 return reloc_type
== 1; /* R_NIOS_32. */
14770 return reloc_type
== 1; /* R_OR1K_32. */
14772 return (reloc_type
== 1 /* R_PARISC_DIR32. */
14773 || reloc_type
== 2 /* R_PARISC_DIR21L. */
14774 || reloc_type
== 41); /* R_PARISC_SECREL32. */
14777 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
14779 return reloc_type
== 1; /* R_PPC64_ADDR32. */
14781 return reloc_type
== 1; /* R_PPC_ADDR32. */
14783 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
14785 return reloc_type
== 1; /* R_RISCV_32. */
14787 return reloc_type
== 1; /* R_RL78_DIR32. */
14789 return reloc_type
== 1; /* R_RX_DIR32. */
14791 return reloc_type
== 1; /* R_I370_ADDR31. */
14794 return reloc_type
== 4; /* R_S390_32. */
14796 return reloc_type
== 8; /* R_SCORE_ABS32. */
14798 return reloc_type
== 1; /* R_SH_DIR32. */
14799 case EM_SPARC32PLUS
:
14802 return reloc_type
== 3 /* R_SPARC_32. */
14803 || reloc_type
== 23; /* R_SPARC_UA32. */
14805 return reloc_type
== 6; /* R_SPU_ADDR32 */
14807 return reloc_type
== 1; /* R_C6000_ABS32. */
14809 return reloc_type
== 2; /* R_TILEGX_32. */
14811 return reloc_type
== 1; /* R_TILEPRO_32. */
14812 case EM_CYGNUS_V850
:
14814 return reloc_type
== 6; /* R_V850_ABS32. */
14816 return reloc_type
== 0x33; /* R_V810_WORD. */
14818 return reloc_type
== 1; /* R_VAX_32. */
14820 return reloc_type
== 3; /* R_VISIUM_32. */
14821 case EM_WEBASSEMBLY
:
14822 return reloc_type
== 1; /* R_WASM32_32. */
14826 return reloc_type
== 10; /* R_X86_64_32. */
14828 return reloc_type
== 4; /* R_XGATE_32. */
14830 return reloc_type
== 1; /* R_XSTROMY16_32. */
14831 case EM_XTENSA_OLD
:
14833 return reloc_type
== 1; /* R_XTENSA_32. */
14835 return reloc_type
== 6; /* R_Z80_32. */
14838 static unsigned int prev_warn
= 0;
14840 /* Avoid repeating the same warning multiple times. */
14841 if (prev_warn
!= filedata
->file_header
.e_machine
)
14842 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
14843 filedata
->file_header
.e_machine
);
14844 prev_warn
= filedata
->file_header
.e_machine
;
14850 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14851 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
14854 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14856 switch (filedata
->file_header
.e_machine
)
14857 /* Please keep this table alpha-sorted for ease of visual lookup. */
14861 return reloc_type
== 2; /* R_386_PC32. */
14863 return reloc_type
== 4; /* R_68K_PC32. */
14865 return reloc_type
== 261; /* R_AARCH64_PREL32 */
14866 case EM_ADAPTEVA_EPIPHANY
:
14867 return reloc_type
== 6;
14869 return reloc_type
== 10; /* R_ALPHA_SREL32. */
14870 case EM_ARC_COMPACT
:
14871 case EM_ARC_COMPACT2
:
14872 case EM_ARC_COMPACT3
:
14873 case EM_ARC_COMPACT3_64
:
14874 return reloc_type
== 49; /* R_ARC_32_PCREL. */
14876 return reloc_type
== 3; /* R_ARM_REL32 */
14879 return reloc_type
== 36; /* R_AVR_32_PCREL. */
14881 return reloc_type
== 99; /* R_LARCH_32_PCREL. */
14882 case EM_MICROBLAZE
:
14883 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
14885 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
14887 return reloc_type
== 9; /* R_PARISC_PCREL32. */
14889 return reloc_type
== 26; /* R_PPC_REL32. */
14891 return reloc_type
== 26; /* R_PPC64_REL32. */
14893 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
14896 return reloc_type
== 5; /* R_390_PC32. */
14898 return reloc_type
== 2; /* R_SH_REL32. */
14899 case EM_SPARC32PLUS
:
14902 return reloc_type
== 6; /* R_SPARC_DISP32. */
14904 return reloc_type
== 13; /* R_SPU_REL32. */
14906 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
14908 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
14910 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
14914 return reloc_type
== 2; /* R_X86_64_PC32. */
14916 return reloc_type
== 4; /* R_VAX_PCREL32. */
14917 case EM_XTENSA_OLD
:
14919 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
14921 /* Do not abort or issue an error message here. Not all targets use
14922 pc-relative 32-bit relocs in their DWARF debug information and we
14923 have already tested for target coverage in is_32bit_abs_reloc. A
14924 more helpful warning message will be generated by apply_relocations
14925 anyway, so just return. */
14930 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14931 a 64-bit absolute RELA relocation used in DWARF debug sections. */
14934 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14936 switch (filedata
->file_header
.e_machine
)
14939 return reloc_type
== 257; /* R_AARCH64_ABS64. */
14940 case EM_ARC_COMPACT3_64
:
14941 return reloc_type
== 5; /* R_ARC_64. */
14943 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
14945 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
14946 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
14948 return reloc_type
== 2; /* R_LARCH_64 */
14950 return reloc_type
== 80; /* R_PARISC_DIR64. */
14952 return reloc_type
== 38; /* R_PPC64_ADDR64. */
14954 return reloc_type
== 2; /* R_RISCV_64. */
14955 case EM_SPARC32PLUS
:
14958 return reloc_type
== 32 /* R_SPARC_64. */
14959 || reloc_type
== 54; /* R_SPARC_UA64. */
14963 return reloc_type
== 1; /* R_X86_64_64. */
14966 return reloc_type
== 22; /* R_S390_64. */
14968 return reloc_type
== 1; /* R_TILEGX_64. */
14970 return reloc_type
== 18; /* R_MIPS_64. */
14976 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
14977 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
14980 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14982 switch (filedata
->file_header
.e_machine
)
14985 return reloc_type
== 260; /* R_AARCH64_PREL64. */
14987 return reloc_type
== 11; /* R_ALPHA_SREL64. */
14989 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
14990 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
14992 return reloc_type
== 72; /* R_PARISC_PCREL64. */
14994 return reloc_type
== 44; /* R_PPC64_REL64. */
14995 case EM_SPARC32PLUS
:
14998 return reloc_type
== 46; /* R_SPARC_DISP64. */
15002 return reloc_type
== 24; /* R_X86_64_PC64. */
15005 return reloc_type
== 23; /* R_S390_PC64. */
15007 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
15013 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15014 a 24-bit absolute RELA relocation used in DWARF debug sections. */
15017 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15019 switch (filedata
->file_header
.e_machine
)
15021 case EM_CYGNUS_MN10200
:
15023 return reloc_type
== 4; /* R_MN10200_24. */
15025 return reloc_type
== 5; /* R_FT32_20. */
15027 return reloc_type
== 5; /* R_Z80_24. */
15033 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15034 a 16-bit absolute RELA relocation used in DWARF debug sections. */
15037 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15039 /* Please keep this table alpha-sorted for ease of visual lookup. */
15040 switch (filedata
->file_header
.e_machine
)
15043 case EM_ARC_COMPACT
:
15044 case EM_ARC_COMPACT2
:
15045 case EM_ARC_COMPACT3
:
15046 case EM_ARC_COMPACT3_64
:
15047 return reloc_type
== 2; /* R_ARC_16. */
15048 case EM_ADAPTEVA_EPIPHANY
:
15049 return reloc_type
== 5;
15052 return reloc_type
== 4; /* R_AVR_16. */
15053 case EM_CYGNUS_D10V
:
15055 return reloc_type
== 3; /* R_D10V_16. */
15057 return reloc_type
== 2; /* R_FT32_16. */
15061 return reloc_type
== R_H8_DIR16
;
15064 return reloc_type
== 1; /* R_IP2K_16. */
15067 return reloc_type
== 1; /* R_M32C_16 */
15068 case EM_CYGNUS_MN10200
:
15070 return reloc_type
== 2; /* R_MN10200_16. */
15071 case EM_CYGNUS_MN10300
:
15073 return reloc_type
== 2; /* R_MN10300_16. */
15075 if (uses_msp430x_relocs (filedata
))
15076 return reloc_type
== 2; /* R_MSP430_ABS16. */
15077 /* Fall through. */
15078 case EM_MSP430_OLD
:
15079 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
15081 return reloc_type
== 19; /* R_NDS32_16_RELA. */
15082 case EM_ALTERA_NIOS2
:
15083 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
15085 return reloc_type
== 9; /* R_NIOS_16. */
15087 return reloc_type
== 2; /* R_OR1K_16. */
15089 return reloc_type
== 55; /* R_RISCV_SET16. */
15091 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
15093 return reloc_type
== 2; /* R_C6000_ABS16. */
15095 return reloc_type
== 2; /* R_VISIUM_16. */
15097 return reloc_type
== 3; /* R_XGATE_16. */
15099 return reloc_type
== 4; /* R_Z80_16. */
15105 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15106 a 8-bit absolute RELA relocation used in DWARF debug sections. */
15109 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15111 switch (filedata
->file_header
.e_machine
)
15114 return reloc_type
== 54; /* R_RISCV_SET8. */
15116 return reloc_type
== 1; /* R_Z80_8. */
15122 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15123 a 6-bit absolute RELA relocation used in DWARF debug sections. */
15126 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15128 switch (filedata
->file_header
.e_machine
)
15131 return reloc_type
== 53; /* R_RISCV_SET6. */
15137 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15138 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
15141 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15143 /* Please keep this table alpha-sorted for ease of visual lookup. */
15144 switch (filedata
->file_header
.e_machine
)
15147 return reloc_type
== 50; /* R_LARCH_ADD32. */
15149 return reloc_type
== 35; /* R_RISCV_ADD32. */
15155 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15156 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
15159 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15161 /* Please keep this table alpha-sorted for ease of visual lookup. */
15162 switch (filedata
->file_header
.e_machine
)
15165 return reloc_type
== 55; /* R_LARCH_SUB32. */
15167 return reloc_type
== 39; /* R_RISCV_SUB32. */
15173 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15174 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
15177 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15179 /* Please keep this table alpha-sorted for ease of visual lookup. */
15180 switch (filedata
->file_header
.e_machine
)
15183 return reloc_type
== 51; /* R_LARCH_ADD64. */
15185 return reloc_type
== 36; /* R_RISCV_ADD64. */
15191 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15192 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
15195 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15197 /* Please keep this table alpha-sorted for ease of visual lookup. */
15198 switch (filedata
->file_header
.e_machine
)
15201 return reloc_type
== 56; /* R_LARCH_SUB64. */
15203 return reloc_type
== 40; /* R_RISCV_SUB64. */
15209 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15210 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
15213 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15215 /* Please keep this table alpha-sorted for ease of visual lookup. */
15216 switch (filedata
->file_header
.e_machine
)
15219 return reloc_type
== 48; /* R_LARCH_ADD16. */
15221 return reloc_type
== 34; /* R_RISCV_ADD16. */
15227 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15228 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
15231 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15233 /* Please keep this table alpha-sorted for ease of visual lookup. */
15234 switch (filedata
->file_header
.e_machine
)
15237 return reloc_type
== 53; /* R_LARCH_SUB16. */
15239 return reloc_type
== 38; /* R_RISCV_SUB16. */
15245 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15246 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
15249 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15251 /* Please keep this table alpha-sorted for ease of visual lookup. */
15252 switch (filedata
->file_header
.e_machine
)
15255 return reloc_type
== 47; /* R_LARCH_ADD8. */
15257 return reloc_type
== 33; /* R_RISCV_ADD8. */
15263 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15264 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
15267 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15269 /* Please keep this table alpha-sorted for ease of visual lookup. */
15270 switch (filedata
->file_header
.e_machine
)
15273 return reloc_type
== 52; /* R_LARCH_SUB8. */
15275 return reloc_type
== 37; /* R_RISCV_SUB8. */
15281 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15282 a 6-bit inplace add RELA relocation used in DWARF debug sections. */
15285 is_6bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15287 switch (filedata
->file_header
.e_machine
)
15290 return reloc_type
== 105; /* R_LARCH_ADD6. */
15296 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15297 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
15300 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15302 switch (filedata
->file_header
.e_machine
)
15305 return reloc_type
== 106; /* R_LARCH_SUB6. */
15307 return reloc_type
== 52; /* R_RISCV_SUB6. */
15313 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
15314 relocation entries (possibly formerly used for SHT_GROUP sections). */
15317 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15319 switch (filedata
->file_header
.e_machine
)
15321 case EM_386
: /* R_386_NONE. */
15322 case EM_68K
: /* R_68K_NONE. */
15323 case EM_ADAPTEVA_EPIPHANY
:
15324 case EM_ALPHA
: /* R_ALPHA_NONE. */
15325 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
15326 case EM_ARC
: /* R_ARC_NONE. */
15327 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
15328 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
15329 case EM_ARC_COMPACT3
: /* R_ARC_NONE. */
15330 case EM_ARC_COMPACT3_64
: /* R_ARC_NONE. */
15331 case EM_ARM
: /* R_ARM_NONE. */
15332 case EM_CRIS
: /* R_CRIS_NONE. */
15333 case EM_FT32
: /* R_FT32_NONE. */
15334 case EM_IA_64
: /* R_IA64_NONE. */
15335 case EM_K1OM
: /* R_X86_64_NONE. */
15336 case EM_L1OM
: /* R_X86_64_NONE. */
15337 case EM_M32R
: /* R_M32R_NONE. */
15338 case EM_MIPS
: /* R_MIPS_NONE. */
15339 case EM_MN10300
: /* R_MN10300_NONE. */
15340 case EM_MOXIE
: /* R_MOXIE_NONE. */
15341 case EM_NIOS32
: /* R_NIOS_NONE. */
15342 case EM_OR1K
: /* R_OR1K_NONE. */
15343 case EM_PARISC
: /* R_PARISC_NONE. */
15344 case EM_PPC64
: /* R_PPC64_NONE. */
15345 case EM_PPC
: /* R_PPC_NONE. */
15346 case EM_RISCV
: /* R_RISCV_NONE. */
15347 case EM_S390
: /* R_390_NONE. */
15349 case EM_SH
: /* R_SH_NONE. */
15350 case EM_SPARC32PLUS
:
15351 case EM_SPARC
: /* R_SPARC_NONE. */
15353 case EM_TILEGX
: /* R_TILEGX_NONE. */
15354 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
15355 case EM_TI_C6000
:/* R_C6000_NONE. */
15356 case EM_X86_64
: /* R_X86_64_NONE. */
15357 case EM_Z80
: /* R_Z80_NONE. */
15358 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
15359 return reloc_type
== 0;
15362 return reloc_type
== 0 || reloc_type
== 256;
15365 return (reloc_type
== 0 /* R_AVR_NONE. */
15366 || reloc_type
== 30 /* R_AVR_DIFF8. */
15367 || reloc_type
== 31 /* R_AVR_DIFF16. */
15368 || reloc_type
== 32 /* R_AVR_DIFF32. */);
15370 return reloc_type
== 3; /* R_METAG_NONE. */
15372 return (reloc_type
== 0 /* R_NDS32_NONE. */
15373 || reloc_type
== 205 /* R_NDS32_DIFF8. */
15374 || reloc_type
== 206 /* R_NDS32_DIFF16. */
15375 || reloc_type
== 207 /* R_NDS32_DIFF32. */
15376 || reloc_type
== 208 /* R_NDS32_DIFF_ULEB128. */);
15378 return (reloc_type
== 0 /* R_PRU_NONE. */
15379 || reloc_type
== 65 /* R_PRU_DIFF8. */
15380 || reloc_type
== 66 /* R_PRU_DIFF16. */
15381 || reloc_type
== 67 /* R_PRU_DIFF32. */);
15382 case EM_XTENSA_OLD
:
15384 return (reloc_type
== 0 /* R_XTENSA_NONE. */
15385 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
15386 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
15387 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
15388 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
15389 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
15390 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
15391 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
15392 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
15393 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
15398 /* Returns TRUE if there is a relocation against
15399 section NAME at OFFSET bytes. */
15402 reloc_at (struct dwarf_section
* dsec
, uint64_t offset
)
15404 Elf_Internal_Rela
* relocs
;
15405 Elf_Internal_Rela
* rp
;
15407 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
15410 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
15412 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
15413 if (rp
->r_offset
== offset
)
15419 /* Apply relocations to a section.
15420 Returns TRUE upon success, FALSE otherwise.
15421 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
15422 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
15423 will be set to the number of relocs loaded.
15425 Note: So far support has been added only for those relocations
15426 which can be found in debug sections. FIXME: Add support for
15427 more relocations ? */
15430 apply_relocations (Filedata
*filedata
,
15431 const Elf_Internal_Shdr
*section
,
15432 unsigned char *start
,
15434 void **relocs_return
,
15435 uint64_t *num_relocs_return
)
15437 Elf_Internal_Shdr
* relsec
;
15438 unsigned char * end
= start
+ size
;
15440 if (relocs_return
!= NULL
)
15442 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
15443 * num_relocs_return
= 0;
15446 if (filedata
->file_header
.e_type
!= ET_REL
)
15447 /* No relocs to apply. */
15450 /* Find the reloc section associated with the section. */
15451 for (relsec
= filedata
->section_headers
;
15452 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
15456 uint64_t num_relocs
;
15457 Elf_Internal_Rela
* relocs
;
15458 Elf_Internal_Rela
* rp
;
15459 Elf_Internal_Shdr
* symsec
;
15460 Elf_Internal_Sym
* symtab
;
15462 Elf_Internal_Sym
* sym
;
15464 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
15465 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
15466 || filedata
->section_headers
+ relsec
->sh_info
!= section
15467 || relsec
->sh_size
== 0
15468 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
15471 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
15472 if (symsec
->sh_type
!= SHT_SYMTAB
15473 && symsec
->sh_type
!= SHT_DYNSYM
)
15476 is_rela
= relsec
->sh_type
== SHT_RELA
;
15480 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
15481 relsec
->sh_size
, & relocs
, & num_relocs
))
15486 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
15487 relsec
->sh_size
, & relocs
, & num_relocs
))
15491 /* SH uses RELA but uses in place value instead of the addend field. */
15492 if (filedata
->file_header
.e_machine
== EM_SH
)
15495 symtab
= get_elf_symbols (filedata
, symsec
, & num_syms
);
15497 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
15500 unsigned int reloc_type
;
15501 unsigned int reloc_size
;
15502 bool reloc_inplace
= false;
15503 bool reloc_subtract
= false;
15504 unsigned char *rloc
;
15505 uint64_t sym_index
;
15507 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
15509 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
15511 else if (is_none_reloc (filedata
, reloc_type
))
15513 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
15514 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
15516 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
15517 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
15519 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
15521 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
15523 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
15524 || is_6bit_abs_reloc (filedata
, reloc_type
))
15526 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
15528 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
15531 reloc_inplace
= true;
15533 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
15535 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
15538 reloc_inplace
= true;
15540 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
15542 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
15545 reloc_inplace
= true;
15547 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
15549 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
15552 reloc_inplace
= true;
15554 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
15556 || is_6bit_inplace_add_reloc (filedata
, reloc_type
))
15559 reloc_inplace
= true;
15563 static unsigned int prev_reloc
= 0;
15565 if (reloc_type
!= prev_reloc
)
15566 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
15567 reloc_type
, printable_section_name (filedata
, section
));
15568 prev_reloc
= reloc_type
;
15572 rloc
= start
+ rp
->r_offset
;
15573 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
15575 warn (_("skipping invalid relocation offset %#" PRIx64
15576 " in section %s\n"),
15578 printable_section_name (filedata
, section
));
15582 sym_index
= get_reloc_symindex (rp
->r_info
);
15583 if (sym_index
>= num_syms
)
15585 warn (_("skipping invalid relocation symbol index %#" PRIx64
15586 " in section %s\n"),
15587 sym_index
, printable_section_name (filedata
, section
));
15590 sym
= symtab
+ sym_index
;
15592 /* If the reloc has a symbol associated with it,
15593 make sure that it is of an appropriate type.
15595 Relocations against symbols without type can happen.
15596 Gcc -feliminate-dwarf2-dups may generate symbols
15597 without type for debug info.
15599 Icc generates relocations against function symbols
15600 instead of local labels.
15602 Relocations against object symbols can happen, eg when
15603 referencing a global array. For an example of this see
15604 the _clz.o binary in libgcc.a. */
15606 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
15607 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
15609 warn (_("skipping unexpected symbol type %s in section %s relocation %tu\n"),
15610 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
15611 printable_section_name (filedata
, relsec
),
15618 addend
+= rp
->r_addend
;
15619 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
15620 partial_inplace. */
15622 || (filedata
->file_header
.e_machine
== EM_XTENSA
15623 && reloc_type
== 1)
15624 || ((filedata
->file_header
.e_machine
== EM_PJ
15625 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
15626 && reloc_type
== 1)
15627 || ((filedata
->file_header
.e_machine
== EM_D30V
15628 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
15629 && reloc_type
== 12)
15632 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
15633 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
15635 addend
+= byte_get (rloc
, reloc_size
);
15638 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
15639 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
15641 /* On HPPA, all pc-relative relocations are biased by 8. */
15642 if (filedata
->file_header
.e_machine
== EM_PARISC
)
15644 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
15647 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
15648 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
)
15649 || is_6bit_inplace_add_reloc (filedata
, reloc_type
))
15651 if (reloc_subtract
)
15652 addend
-= sym
->st_value
;
15654 addend
+= sym
->st_value
;
15655 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
15656 byte_put (rloc
, addend
, reloc_size
);
15658 else if (reloc_subtract
)
15659 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
15661 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
15665 /* Let the target specific reloc processing code know that
15666 we have finished with these relocs. */
15667 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
15671 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
15672 * num_relocs_return
= num_relocs
;
15683 #ifdef SUPPORT_DISASSEMBLY
15685 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15687 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
15689 /* FIXME: XXX -- to be done --- XXX */
15695 /* Reads in the contents of SECTION from FILE, returning a pointer
15696 to a malloc'ed buffer or NULL if something went wrong. */
15699 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15701 uint64_t num_bytes
= section
->sh_size
;
15703 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
15705 printf (_("Section '%s' has no data to dump.\n"),
15706 printable_section_name (filedata
, section
));
15710 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
15711 _("section contents"));
15714 /* Uncompresses a section that was compressed using zlib/zstd, in place. */
15717 uncompress_section_contents (bool is_zstd
,
15718 unsigned char ** buffer
,
15719 uint64_t uncompressed_size
,
15721 uint64_t file_size
)
15723 uint64_t compressed_size
= *size
;
15724 unsigned char *compressed_buffer
= *buffer
;
15725 unsigned char *uncompressed_buffer
= NULL
;
15729 /* Similar to _bfd_section_size_insane() in the BFD library we expect an
15730 upper limit of ~10x compression. Any compression larger than that is
15731 thought to be due to fuzzing of the compression header. */
15732 if (uncompressed_size
> file_size
* 10)
15734 error (_("Uncompressed section size is suspiciously large: 0x%" PRIu64
"\n"),
15735 uncompressed_size
);
15739 uncompressed_buffer
= xmalloc (uncompressed_size
);
15744 size_t ret
= ZSTD_decompress (uncompressed_buffer
, uncompressed_size
,
15745 compressed_buffer
, compressed_size
);
15746 if (ZSTD_isError (ret
))
15752 /* It is possible the section consists of several compressed
15753 buffers concatenated together, so we uncompress in a loop. */
15754 /* PR 18313: The state field in the z_stream structure is supposed
15755 to be invisible to the user (ie us), but some compilers will
15756 still complain about it being used without initialisation. So
15757 we first zero the entire z_stream structure and then set the fields
15759 memset (&strm
, 0, sizeof strm
);
15760 strm
.avail_in
= compressed_size
;
15761 strm
.next_in
= (Bytef
*)compressed_buffer
;
15762 strm
.avail_out
= uncompressed_size
;
15764 rc
= inflateInit (&strm
);
15765 while (strm
.avail_in
> 0)
15769 strm
.next_out
= ((Bytef
*)uncompressed_buffer
15770 + (uncompressed_size
- strm
.avail_out
));
15771 rc
= inflate (&strm
, Z_FINISH
);
15772 if (rc
!= Z_STREAM_END
)
15774 rc
= inflateReset (&strm
);
15776 if (inflateEnd (&strm
) != Z_OK
|| rc
!= Z_OK
|| strm
.avail_out
!= 0)
15780 *buffer
= uncompressed_buffer
;
15781 *size
= uncompressed_size
;
15785 free (uncompressed_buffer
);
15786 /* Indicate decompression failure. */
15792 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15794 Elf_Internal_Shdr
*relsec
;
15795 uint64_t num_bytes
;
15796 unsigned char *data
;
15797 unsigned char *end
;
15798 unsigned char *real_start
;
15799 unsigned char *start
;
15800 bool some_strings_shown
;
15802 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
15804 /* PR 21820: Do not fail if the section was empty. */
15805 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
15807 num_bytes
= section
->sh_size
;
15809 if (filedata
->is_separate
)
15810 printf (_("\nString dump of section '%s' in linked file %s:\n"),
15811 printable_section_name (filedata
, section
),
15812 filedata
->file_name
);
15814 printf (_("\nString dump of section '%s':\n"),
15815 printable_section_name (filedata
, section
));
15817 if (decompress_dumps
)
15819 uint64_t new_size
= num_bytes
;
15820 uint64_t uncompressed_size
= 0;
15821 bool is_zstd
= false;
15823 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
15825 Elf_Internal_Chdr chdr
;
15826 unsigned int compression_header_size
15827 = get_compression_header (& chdr
, (unsigned char *) start
,
15829 if (compression_header_size
== 0)
15830 /* An error message will have already been generated
15831 by get_compression_header. */
15834 if (chdr
.ch_type
== ch_compress_zlib
)
15837 else if (chdr
.ch_type
== ch_compress_zstd
)
15842 warn (_("section '%s' has unsupported compress type: %d\n"),
15843 printable_section_name (filedata
, section
), chdr
.ch_type
);
15846 uncompressed_size
= chdr
.ch_size
;
15847 start
+= compression_header_size
;
15848 new_size
-= compression_header_size
;
15850 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
15852 /* Read the zlib header. In this case, it should be "ZLIB"
15853 followed by the uncompressed section size, 8 bytes in
15854 big-endian order. */
15855 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
15856 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
15857 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
15858 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
15859 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
15860 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
15861 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
15862 uncompressed_size
+= start
[11];
15867 if (uncompressed_size
)
15869 if (uncompress_section_contents (is_zstd
, &start
, uncompressed_size
,
15870 &new_size
, filedata
->file_size
))
15871 num_bytes
= new_size
;
15874 error (_("Unable to decompress section %s\n"),
15875 printable_section_name (filedata
, section
));
15880 start
= real_start
;
15883 /* If the section being dumped has relocations against it the user might
15884 be expecting these relocations to have been applied. Check for this
15885 case and issue a warning message in order to avoid confusion.
15886 FIXME: Maybe we ought to have an option that dumps a section with
15887 relocs applied ? */
15888 for (relsec
= filedata
->section_headers
;
15889 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
15892 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
15893 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
15894 || filedata
->section_headers
+ relsec
->sh_info
!= section
15895 || relsec
->sh_size
== 0
15896 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
15899 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
15904 end
= start
+ num_bytes
;
15905 some_strings_shown
= false;
15907 #ifdef HAVE_MBSTATE_T
15909 /* Initialise the multibyte conversion state. */
15910 memset (& state
, 0, sizeof (state
));
15913 bool continuing
= false;
15917 while (!ISPRINT (* data
))
15918 if (++ data
>= end
)
15923 size_t maxlen
= end
- data
;
15928 continuing
= false;
15932 printf (" [%6tx] ", data
- start
);
15946 /* PR 25543: Treat new-lines as string-ending characters. */
15955 /* Do not print control characters directly as they can affect terminal
15956 settings. Such characters usually appear in the names generated
15957 by the assembler for local labels. */
15960 printf ("^%c", c
+ 0x40);
15962 else if (ISPRINT (c
))
15969 #ifdef HAVE_MBSTATE_T
15972 /* Let printf do the hard work of displaying multibyte characters. */
15973 printf ("%.1s", data
- 1);
15974 #ifdef HAVE_MBSTATE_T
15975 /* Try to find out how many bytes made up the character that was
15976 just printed. Advance the symbol pointer past the bytes that
15978 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
15982 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
15992 printf (_("<corrupt>\n"));
15995 some_strings_shown
= true;
15999 if (! some_strings_shown
)
16000 printf (_(" No strings found in this section."));
16013 dump_section_as_bytes (Elf_Internal_Shdr
*section
,
16014 Filedata
*filedata
,
16017 Elf_Internal_Shdr
*relsec
;
16019 uint64_t section_size
;
16021 unsigned char *data
;
16022 unsigned char *real_start
;
16023 unsigned char *start
;
16025 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
16027 /* PR 21820: Do not fail if the section was empty. */
16028 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
16030 section_size
= section
->sh_size
;
16032 if (filedata
->is_separate
)
16033 printf (_("\nHex dump of section '%s' in linked file %s:\n"),
16034 printable_section_name (filedata
, section
),
16035 filedata
->file_name
);
16037 printf (_("\nHex dump of section '%s':\n"),
16038 printable_section_name (filedata
, section
));
16040 if (decompress_dumps
)
16042 uint64_t new_size
= section_size
;
16043 uint64_t uncompressed_size
= 0;
16044 bool is_zstd
= false;
16046 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
16048 Elf_Internal_Chdr chdr
;
16049 unsigned int compression_header_size
16050 = get_compression_header (& chdr
, start
, section_size
);
16052 if (compression_header_size
== 0)
16053 /* An error message will have already been generated
16054 by get_compression_header. */
16057 if (chdr
.ch_type
== ch_compress_zlib
)
16060 else if (chdr
.ch_type
== ch_compress_zstd
)
16065 warn (_("section '%s' has unsupported compress type: %d\n"),
16066 printable_section_name (filedata
, section
), chdr
.ch_type
);
16069 uncompressed_size
= chdr
.ch_size
;
16070 start
+= compression_header_size
;
16071 new_size
-= compression_header_size
;
16073 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
16075 /* Read the zlib header. In this case, it should be "ZLIB"
16076 followed by the uncompressed section size, 8 bytes in
16077 big-endian order. */
16078 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
16079 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
16080 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
16081 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
16082 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
16083 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
16084 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
16085 uncompressed_size
+= start
[11];
16090 if (uncompressed_size
)
16092 if (uncompress_section_contents (is_zstd
, &start
, uncompressed_size
,
16093 &new_size
, filedata
->file_size
))
16095 section_size
= new_size
;
16099 error (_("Unable to decompress section %s\n"),
16100 printable_section_name (filedata
, section
));
16101 /* FIXME: Print the section anyway ? */
16106 start
= real_start
;
16111 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
16116 /* If the section being dumped has relocations against it the user might
16117 be expecting these relocations to have been applied. Check for this
16118 case and issue a warning message in order to avoid confusion.
16119 FIXME: Maybe we ought to have an option that dumps a section with
16120 relocs applied ? */
16121 for (relsec
= filedata
->section_headers
;
16122 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
16125 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
16126 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
16127 || filedata
->section_headers
+ relsec
->sh_info
!= section
16128 || relsec
->sh_size
== 0
16129 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
16132 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
16137 addr
= section
->sh_addr
;
16138 bytes
= section_size
;
16147 lbytes
= (bytes
> 16 ? 16 : bytes
);
16149 printf (" 0x%8.8" PRIx64
" ", addr
);
16151 for (j
= 0; j
< 16; j
++)
16154 printf ("%2.2x", data
[j
]);
16162 for (j
= 0; j
< lbytes
; j
++)
16165 if (k
>= ' ' && k
< 0x7f)
16188 #ifdef ENABLE_LIBCTF
16189 static ctf_sect_t
*
16190 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
16192 buf
->cts_name
= section_name_print (filedata
, shdr
);
16193 buf
->cts_size
= shdr
->sh_size
;
16194 buf
->cts_entsize
= shdr
->sh_entsize
;
16199 /* Formatting callback function passed to ctf_dump. Returns either the pointer
16200 it is passed, or a pointer to newly-allocated storage, in which case
16201 dump_ctf() will free it when it no longer needs it. */
16204 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
16205 char *s
, void *arg
)
16207 const char *blanks
= arg
;
16210 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
16215 /* Dump CTF errors/warnings. */
16217 dump_ctf_errs (ctf_dict_t
*fp
)
16219 ctf_next_t
*it
= NULL
;
16224 /* Dump accumulated errors and warnings. */
16225 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
16227 error (_("%s: %s"), is_warning
? _("warning"): _("error"),
16231 if (err
!= ECTF_NEXT_END
)
16232 error (_("CTF error: cannot get CTF errors: `%s'"), ctf_errmsg (err
));
16235 /* Dump one CTF archive member. */
16238 dump_ctf_archive_member (ctf_dict_t
*ctf
, const char *name
, ctf_dict_t
*parent
,
16241 const char *things
[] = {"Header", "Labels", "Data objects",
16242 "Function objects", "Variables", "Types", "Strings",
16244 const char **thing
;
16247 /* Don't print out the name of the default-named archive member if it appears
16248 first in the list. The name .ctf appears everywhere, even for things that
16249 aren't really archives, so printing it out is liable to be confusing; also,
16250 the common case by far is for only one archive member to exist, and hiding
16251 it in that case seems worthwhile. */
16253 if (strcmp (name
, ".ctf") != 0 || member
!= 0)
16254 printf (_("\nCTF archive member: %s:\n"), name
);
16256 if (ctf_parent_name (ctf
) != NULL
)
16257 ctf_import (ctf
, parent
);
16259 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
16261 ctf_dump_state_t
*s
= NULL
;
16264 printf ("\n %s:\n", *thing
);
16265 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
16266 (void *) " ")) != NULL
)
16268 printf ("%s\n", item
);
16272 if (ctf_errno (ctf
))
16274 error (_("Iteration failed: %s, %s\n"), *thing
,
16275 ctf_errmsg (ctf_errno (ctf
)));
16280 dump_ctf_errs (ctf
);
16284 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
16286 Elf_Internal_Shdr
* symtab_sec
= NULL
;
16287 Elf_Internal_Shdr
* strtab_sec
= NULL
;
16288 void * data
= NULL
;
16289 void * symdata
= NULL
;
16290 void * strdata
= NULL
;
16291 ctf_sect_t ctfsect
, symsect
, strsect
;
16292 ctf_sect_t
* symsectp
= NULL
;
16293 ctf_sect_t
* strsectp
= NULL
;
16294 ctf_archive_t
* ctfa
= NULL
;
16295 ctf_dict_t
* parent
= NULL
;
16298 ctf_next_t
*i
= NULL
;
16304 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
16305 data
= get_section_contents (section
, filedata
);
16306 ctfsect
.cts_data
= data
;
16308 if (!dump_ctf_symtab_name
)
16309 dump_ctf_symtab_name
= strdup (".dynsym");
16311 if (!dump_ctf_strtab_name
)
16312 dump_ctf_strtab_name
= strdup (".dynstr");
16314 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
16316 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
16318 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
16321 if ((symdata
= (void *) get_data (NULL
, filedata
,
16322 symtab_sec
->sh_offset
, 1,
16323 symtab_sec
->sh_size
,
16324 _("symbols"))) == NULL
)
16326 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
16327 symsect
.cts_data
= symdata
;
16330 if (dump_ctf_strtab_name
&& dump_ctf_strtab_name
[0] != 0)
16332 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
16334 error (_("No string table section named %s\n"),
16335 dump_ctf_strtab_name
);
16338 if ((strdata
= (void *) get_data (NULL
, filedata
,
16339 strtab_sec
->sh_offset
, 1,
16340 strtab_sec
->sh_size
,
16341 _("strings"))) == NULL
)
16343 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
16344 strsect
.cts_data
= strdata
;
16347 /* Load the CTF file and dump it. It may be a raw CTF section, or an archive:
16348 libctf papers over the difference, so we can pretend it is always an
16351 if ((ctfa
= ctf_arc_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
16353 dump_ctf_errs (NULL
);
16354 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
16358 ctf_arc_symsect_endianness (ctfa
, filedata
->file_header
.e_ident
[EI_DATA
]
16361 /* Preload the parent dict, since it will need to be imported into every
16363 if ((parent
= ctf_dict_open (ctfa
, dump_ctf_parent_name
, &err
)) == NULL
)
16365 dump_ctf_errs (NULL
);
16366 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
16372 if (filedata
->is_separate
)
16373 printf (_("\nDump of CTF section '%s' in linked file %s:\n"),
16374 printable_section_name (filedata
, section
),
16375 filedata
->file_name
);
16377 printf (_("\nDump of CTF section '%s':\n"),
16378 printable_section_name (filedata
, section
));
16380 while ((fp
= ctf_archive_next (ctfa
, &i
, &name
, 0, &err
)) != NULL
)
16381 dump_ctf_archive_member (fp
, name
, parent
, member
++);
16382 if (err
!= ECTF_NEXT_END
)
16384 dump_ctf_errs (NULL
);
16385 error (_("CTF member open failure: %s\n"), ctf_errmsg (err
));
16390 ctf_dict_close (parent
);
16400 dump_section_as_sframe (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
16402 void * data
= NULL
;
16403 sframe_decoder_ctx
*sfd_ctx
= NULL
;
16404 const char *print_name
= printable_section_name (filedata
, section
);
16410 if (strcmp (print_name
, "") == 0)
16412 error (_("Section name must be provided \n"));
16417 data
= get_section_contents (section
, filedata
);
16418 sf_size
= section
->sh_size
;
16419 /* Decode the contents of the section. */
16420 sfd_ctx
= sframe_decode ((const char*)data
, sf_size
, &err
);
16424 error (_("SFrame decode failure: %s\n"), sframe_errmsg (err
));
16428 printf (_("Contents of the SFrame section %s:"), print_name
);
16429 /* Dump the contents as text. */
16430 dump_sframe (sfd_ctx
, section
->sh_addr
);
16438 load_specific_debug_section (enum dwarf_section_display_enum debug
,
16439 const Elf_Internal_Shdr
* sec
,
16442 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
16444 Filedata
* filedata
= (Filedata
*) data
;
16446 if (section
->start
!= NULL
)
16448 /* If it is already loaded, do nothing. */
16449 if (streq (section
->filename
, filedata
->file_name
))
16451 free (section
->start
);
16454 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
16455 section
->address
= sec
->sh_addr
;
16456 section
->filename
= filedata
->file_name
;
16457 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
16459 sec
->sh_size
, buf
);
16460 if (section
->start
== NULL
)
16464 unsigned char *start
= section
->start
;
16465 uint64_t size
= sec
->sh_size
;
16466 uint64_t uncompressed_size
= 0;
16467 bool is_zstd
= false;
16469 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
16471 Elf_Internal_Chdr chdr
;
16472 unsigned int compression_header_size
;
16474 if (size
< (is_32bit_elf
16475 ? sizeof (Elf32_External_Chdr
)
16476 : sizeof (Elf64_External_Chdr
)))
16478 warn (_("compressed section %s is too small to contain a compression header\n"),
16483 compression_header_size
= get_compression_header (&chdr
, start
, size
);
16484 if (compression_header_size
== 0)
16485 /* An error message will have already been generated
16486 by get_compression_header. */
16489 if (chdr
.ch_type
== ch_compress_zlib
)
16492 else if (chdr
.ch_type
== ch_compress_zstd
)
16497 warn (_("section '%s' has unsupported compress type: %d\n"),
16498 section
->name
, chdr
.ch_type
);
16501 uncompressed_size
= chdr
.ch_size
;
16502 start
+= compression_header_size
;
16503 size
-= compression_header_size
;
16505 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
16507 /* Read the zlib header. In this case, it should be "ZLIB"
16508 followed by the uncompressed section size, 8 bytes in
16509 big-endian order. */
16510 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
16511 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
16512 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
16513 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
16514 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
16515 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
16516 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
16517 uncompressed_size
+= start
[11];
16522 if (uncompressed_size
)
16524 if (uncompress_section_contents (is_zstd
, &start
, uncompressed_size
,
16525 &size
, filedata
->file_size
))
16527 /* Free the compressed buffer, update the section buffer
16528 and the section size if uncompress is successful. */
16529 free (section
->start
);
16530 section
->start
= start
;
16534 error (_("Unable to decompress section %s\n"),
16535 printable_section_name (filedata
, sec
));
16540 section
->size
= size
;
16543 if (section
->start
== NULL
)
16546 if (debug_displays
[debug
].relocate
)
16548 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
16549 & section
->reloc_info
, & section
->num_relocs
))
16554 section
->reloc_info
= NULL
;
16555 section
->num_relocs
= 0;
16561 #if HAVE_LIBDEBUGINFOD
16562 /* Return a hex string representation of the build-id. */
16564 get_build_id (void * data
)
16566 Filedata
* filedata
= (Filedata
*) data
;
16567 Elf_Internal_Shdr
* shdr
;
16570 /* Iterate through notes to find note.gnu.build-id.
16571 FIXME: Only the first note in any note section is examined. */
16572 for (i
= 0, shdr
= filedata
->section_headers
;
16573 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
16576 if (shdr
->sh_type
!= SHT_NOTE
)
16581 size_t data_remaining
;
16583 Elf_External_Note
* enote
;
16584 Elf_Internal_Note inote
;
16586 uint64_t offset
= shdr
->sh_offset
;
16587 uint64_t align
= shdr
->sh_addralign
;
16588 uint64_t length
= shdr
->sh_size
;
16590 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
16596 else if (align
!= 4 && align
!= 8)
16602 end
= (char *) enote
+ length
;
16603 data_remaining
= end
- (char *) enote
;
16605 if (!is_ia64_vms (filedata
))
16607 min_notesz
= offsetof (Elf_External_Note
, name
);
16608 if (data_remaining
< min_notesz
)
16611 malformed note encountered in section %s whilst scanning for build-id note\n"),
16612 printable_section_name (filedata
, shdr
));
16616 data_remaining
-= min_notesz
;
16618 inote
.type
= BYTE_GET (enote
->type
);
16619 inote
.namesz
= BYTE_GET (enote
->namesz
);
16620 inote
.namedata
= enote
->name
;
16621 inote
.descsz
= BYTE_GET (enote
->descsz
);
16622 inote
.descdata
= ((char *) enote
16623 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
16624 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
16625 next
= ((char *) enote
16626 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
16630 Elf64_External_VMS_Note
*vms_enote
;
16632 /* PR binutils/15191
16633 Make sure that there is enough data to read. */
16634 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
16635 if (data_remaining
< min_notesz
)
16638 malformed note encountered in section %s whilst scanning for build-id note\n"),
16639 printable_section_name (filedata
, shdr
));
16643 data_remaining
-= min_notesz
;
16645 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
16646 inote
.type
= BYTE_GET (vms_enote
->type
);
16647 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
16648 inote
.namedata
= vms_enote
->name
;
16649 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
16650 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
16651 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
16652 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
16655 /* Skip malformed notes. */
16656 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
16657 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
16658 || (size_t) (next
- inote
.descdata
) < inote
.descsz
16659 || ((size_t) (next
- inote
.descdata
)
16660 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
16663 malformed note encountered in section %s whilst scanning for build-id note\n"),
16664 printable_section_name (filedata
, shdr
));
16669 /* Check if this is the build-id note. If so then convert the build-id
16670 bytes to a hex string. */
16671 if (inote
.namesz
> 0
16672 && startswith (inote
.namedata
, "GNU")
16673 && inote
.type
== NT_GNU_BUILD_ID
)
16678 build_id
= malloc (inote
.descsz
* 2 + 1);
16679 if (build_id
== NULL
)
16685 for (j
= 0; j
< inote
.descsz
; ++j
)
16686 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
16687 build_id
[inote
.descsz
* 2] = '\0';
16690 return (unsigned char *) build_id
;
16697 #endif /* HAVE_LIBDEBUGINFOD */
16699 /* If this is not NULL, load_debug_section will only look for sections
16700 within the list of sections given here. */
16701 static unsigned int * section_subset
= NULL
;
16704 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
16706 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
16707 Elf_Internal_Shdr
* sec
;
16708 Filedata
* filedata
= (Filedata
*) data
;
16710 if (!dump_any_debugging
)
16713 /* Without section headers we cannot find any sections. */
16714 if (filedata
->section_headers
== NULL
)
16717 if (filedata
->string_table
== NULL
16718 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
16719 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
16721 Elf_Internal_Shdr
* strs
;
16723 /* Read in the string table, so that we have section names to scan. */
16724 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
16726 if (strs
!= NULL
&& strs
->sh_size
!= 0)
16728 filedata
->string_table
16729 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
16730 1, strs
->sh_size
, _("string table"));
16732 filedata
->string_table_length
16733 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
16737 /* Locate the debug section. */
16738 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
16740 section
->name
= section
->uncompressed_name
;
16743 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
16745 section
->name
= section
->compressed_name
;
16750 /* If we're loading from a subset of sections, and we've loaded
16751 a section matching this name before, it's likely that it's a
16753 if (section_subset
!= NULL
)
16754 free_debug_section (debug
);
16756 return load_specific_debug_section (debug
, sec
, data
);
16760 free_debug_section (enum dwarf_section_display_enum debug
)
16762 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
16764 if (section
->start
== NULL
)
16767 free ((char *) section
->start
);
16768 section
->start
= NULL
;
16769 section
->address
= 0;
16772 free (section
->reloc_info
);
16773 section
->reloc_info
= NULL
;
16774 section
->num_relocs
= 0;
16778 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
16780 const char *name
= (section_name_valid (filedata
, section
)
16781 ? section_name (filedata
, section
) : "");
16782 const char *print_name
= printable_section_name (filedata
, section
);
16784 bool result
= true;
16787 length
= section
->sh_size
;
16790 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
16793 if (section
->sh_type
== SHT_NOBITS
)
16795 /* There is no point in dumping the contents of a debugging section
16796 which has the NOBITS type - the bits in the file will be random.
16797 This can happen when a file containing a .eh_frame section is
16798 stripped with the --only-keep-debug command line option. */
16799 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
16804 if (startswith (name
, ".gnu.linkonce.wi."))
16805 name
= ".debug_info";
16807 /* See if we know how to display the contents of this section. */
16808 for (i
= 0; i
< max
; i
++)
16810 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
16811 struct dwarf_section_display
* display
= debug_displays
+ i
;
16812 struct dwarf_section
* sec
= & display
->section
;
16814 if (streq (sec
->uncompressed_name
, name
)
16815 || (id
== line
&& startswith (name
, ".debug_line."))
16816 || streq (sec
->compressed_name
, name
))
16818 bool secondary
= (section
!= find_section (filedata
, name
));
16821 free_debug_section (id
);
16823 if (i
== line
&& startswith (name
, ".debug_line."))
16825 else if (streq (sec
->uncompressed_name
, name
))
16826 sec
->name
= sec
->uncompressed_name
;
16828 sec
->name
= sec
->compressed_name
;
16830 if (load_specific_debug_section (id
, section
, filedata
))
16832 /* If this debug section is part of a CU/TU set in a .dwp file,
16833 restrict load_debug_section to the sections in that set. */
16834 section_subset
= find_cu_tu_set (filedata
, shndx
);
16836 result
&= display
->display (sec
, filedata
);
16838 section_subset
= NULL
;
16840 if (secondary
|| (id
!= info
&& id
!= abbrev
&& id
!= debug_addr
))
16841 free_debug_section (id
);
16849 printf (_("Unrecognized debug section: %s\n"), print_name
);
16856 /* Set DUMP_SECTS for all sections where dumps were requested
16857 based on section name. */
16860 initialise_dumps_byname (Filedata
* filedata
)
16862 struct dump_list_entry
* cur
;
16864 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
16869 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
16870 if (section_name_valid (filedata
, filedata
->section_headers
+ i
)
16871 && streq (section_name (filedata
, filedata
->section_headers
+ i
),
16874 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
16878 if (!any
&& !filedata
->is_separate
)
16879 warn (_("Section '%s' was not dumped because it does not exist\n"),
16885 process_section_contents (Filedata
* filedata
)
16887 Elf_Internal_Shdr
* section
;
16894 initialise_dumps_byname (filedata
);
16896 for (i
= 0, section
= filedata
->section_headers
;
16897 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
16900 dump_type dump
= filedata
->dump
.dump_sects
[i
];
16902 if (filedata
->is_separate
&& ! process_links
)
16903 dump
&= DEBUG_DUMP
;
16905 #ifdef SUPPORT_DISASSEMBLY
16906 if (dump
& DISASS_DUMP
)
16908 if (! disassemble_section (section
, filedata
))
16912 if (dump
& HEX_DUMP
)
16914 if (! dump_section_as_bytes (section
, filedata
, false))
16918 if (dump
& RELOC_DUMP
)
16920 if (! dump_section_as_bytes (section
, filedata
, true))
16924 if (dump
& STRING_DUMP
)
16926 if (! dump_section_as_strings (section
, filedata
))
16930 if (dump
& DEBUG_DUMP
)
16932 if (! display_debug_section (i
, section
, filedata
))
16936 #ifdef ENABLE_LIBCTF
16937 if (dump
& CTF_DUMP
)
16939 if (! dump_section_as_ctf (section
, filedata
))
16943 if (dump
& SFRAME_DUMP
)
16945 if (! dump_section_as_sframe (section
, filedata
))
16950 if (! filedata
->is_separate
)
16952 /* Check to see if the user requested a
16953 dump of a section that does not exist. */
16954 for (; i
< filedata
->dump
.num_dump_sects
; i
++)
16955 if (filedata
->dump
.dump_sects
[i
])
16957 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
16966 process_mips_fpe_exception (int mask
)
16972 if (mask
& OEX_FPU_INEX
)
16973 fputs ("INEX", stdout
), first
= false;
16974 if (mask
& OEX_FPU_UFLO
)
16975 printf ("%sUFLO", first
? "" : "|"), first
= false;
16976 if (mask
& OEX_FPU_OFLO
)
16977 printf ("%sOFLO", first
? "" : "|"), first
= false;
16978 if (mask
& OEX_FPU_DIV0
)
16979 printf ("%sDIV0", first
? "" : "|"), first
= false;
16980 if (mask
& OEX_FPU_INVAL
)
16981 printf ("%sINVAL", first
? "" : "|");
16984 fputs ("0", stdout
);
16987 /* Display's the value of TAG at location P. If TAG is
16988 greater than 0 it is assumed to be an unknown tag, and
16989 a message is printed to this effect. Otherwise it is
16990 assumed that a message has already been printed.
16992 If the bottom bit of TAG is set it assumed to have a
16993 string value, otherwise it is assumed to have an integer
16996 Returns an updated P pointing to the first unread byte
16997 beyond the end of TAG's value.
16999 Reads at or beyond END will not be made. */
17001 static unsigned char *
17002 display_tag_value (signed int tag
,
17004 const unsigned char * const end
)
17009 printf (" Tag_unknown_%d: ", tag
);
17013 warn (_("<corrupt tag>\n"));
17017 /* PR 17531 file: 027-19978-0.004. */
17018 size_t maxlen
= (end
- p
) - 1;
17023 print_symbol ((int) maxlen
, (const char *) p
);
17024 p
+= strnlen ((char *) p
, maxlen
) + 1;
17028 printf (_("<corrupt string tag>"));
17029 p
= (unsigned char *) end
;
17035 READ_ULEB (val
, p
, end
);
17036 printf ("%" PRId64
" (0x%" PRIx64
")\n", val
, val
);
17043 /* ARC ABI attributes section. */
17045 static unsigned char *
17046 display_arc_attribute (unsigned char * p
,
17047 const unsigned char * const end
)
17052 READ_ULEB (tag
, p
, end
);
17056 case Tag_ARC_PCS_config
:
17057 READ_ULEB (val
, p
, end
);
17058 printf (" Tag_ARC_PCS_config: ");
17062 printf (_("Absent/Non standard\n"));
17065 printf (_("Bare metal/mwdt\n"));
17068 printf (_("Bare metal/newlib\n"));
17071 printf (_("Linux/uclibc\n"));
17074 printf (_("Linux/glibc\n"));
17077 printf (_("Unknown\n"));
17082 case Tag_ARC_CPU_base
:
17083 READ_ULEB (val
, p
, end
);
17084 printf (" Tag_ARC_CPU_base: ");
17089 printf (_("Absent\n"));
17091 case TAG_CPU_ARC6xx
:
17092 printf ("ARC6xx\n");
17094 case TAG_CPU_ARC7xx
:
17095 printf ("ARC7xx\n");
17097 case TAG_CPU_ARCEM
:
17098 printf ("ARCEM\n");
17100 case TAG_CPU_ARCHS
:
17101 printf ("ARCHS\n");
17106 case Tag_ARC_CPU_variation
:
17107 READ_ULEB (val
, p
, end
);
17108 printf (" Tag_ARC_CPU_variation: ");
17112 if (val
> 0 && val
< 16)
17113 printf ("Core%d\n", val
);
17115 printf ("Unknown\n");
17119 printf (_("Absent\n"));
17124 case Tag_ARC_CPU_name
:
17125 printf (" Tag_ARC_CPU_name: ");
17126 p
= display_tag_value (-1, p
, end
);
17129 case Tag_ARC_ABI_rf16
:
17130 READ_ULEB (val
, p
, end
);
17131 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
17134 case Tag_ARC_ABI_osver
:
17135 READ_ULEB (val
, p
, end
);
17136 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
17139 case Tag_ARC_ABI_pic
:
17140 case Tag_ARC_ABI_sda
:
17141 READ_ULEB (val
, p
, end
);
17142 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
17143 : " Tag_ARC_ABI_pic: ");
17147 printf (_("Absent\n"));
17156 printf (_("Unknown\n"));
17161 case Tag_ARC_ABI_tls
:
17162 READ_ULEB (val
, p
, end
);
17163 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
17166 case Tag_ARC_ABI_enumsize
:
17167 READ_ULEB (val
, p
, end
);
17168 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
17172 case Tag_ARC_ABI_exceptions
:
17173 READ_ULEB (val
, p
, end
);
17174 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
17178 case Tag_ARC_ABI_double_size
:
17179 READ_ULEB (val
, p
, end
);
17180 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
17183 case Tag_ARC_ISA_config
:
17184 printf (" Tag_ARC_ISA_config: ");
17185 p
= display_tag_value (-1, p
, end
);
17188 case Tag_ARC_ISA_apex
:
17189 printf (" Tag_ARC_ISA_apex: ");
17190 p
= display_tag_value (-1, p
, end
);
17193 case Tag_ARC_ISA_mpy_option
:
17194 READ_ULEB (val
, p
, end
);
17195 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
17198 case Tag_ARC_ATR_version
:
17199 READ_ULEB (val
, p
, end
);
17200 printf (" Tag_ARC_ATR_version: %d\n", val
);
17204 return display_tag_value (tag
& 1, p
, end
);
17210 /* ARM EABI attributes section. */
17215 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
17217 const char *const *table
;
17218 } arm_attr_public_tag
;
17220 static const char *const arm_attr_tag_CPU_arch
[] =
17221 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
17222 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
17223 "v8-M.mainline", "v8.1-A", "v8.2-A", "v8.3-A",
17224 "v8.1-M.mainline", "v9"};
17225 static const char *const arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
17226 static const char *const arm_attr_tag_THUMB_ISA_use
[] =
17227 {"No", "Thumb-1", "Thumb-2", "Yes"};
17228 static const char *const arm_attr_tag_FP_arch
[] =
17229 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
17230 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
17231 static const char *const arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
17232 static const char *const arm_attr_tag_Advanced_SIMD_arch
[] =
17233 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
17234 "NEON for ARMv8.1"};
17235 static const char *const arm_attr_tag_PCS_config
[] =
17236 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
17237 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
17238 static const char *const arm_attr_tag_ABI_PCS_R9_use
[] =
17239 {"V6", "SB", "TLS", "Unused"};
17240 static const char *const arm_attr_tag_ABI_PCS_RW_data
[] =
17241 {"Absolute", "PC-relative", "SB-relative", "None"};
17242 static const char *const arm_attr_tag_ABI_PCS_RO_data
[] =
17243 {"Absolute", "PC-relative", "None"};
17244 static const char *const arm_attr_tag_ABI_PCS_GOT_use
[] =
17245 {"None", "direct", "GOT-indirect"};
17246 static const char *const arm_attr_tag_ABI_PCS_wchar_t
[] =
17247 {"None", "??? 1", "2", "??? 3", "4"};
17248 static const char *const arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
17249 static const char *const arm_attr_tag_ABI_FP_denormal
[] =
17250 {"Unused", "Needed", "Sign only"};
17251 static const char *const arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
17252 static const char *const arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
17253 static const char *const arm_attr_tag_ABI_FP_number_model
[] =
17254 {"Unused", "Finite", "RTABI", "IEEE 754"};
17255 static const char *const arm_attr_tag_ABI_enum_size
[] =
17256 {"Unused", "small", "int", "forced to int"};
17257 static const char *const arm_attr_tag_ABI_HardFP_use
[] =
17258 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
17259 static const char *const arm_attr_tag_ABI_VFP_args
[] =
17260 {"AAPCS", "VFP registers", "custom", "compatible"};
17261 static const char *const arm_attr_tag_ABI_WMMX_args
[] =
17262 {"AAPCS", "WMMX registers", "custom"};
17263 static const char *const arm_attr_tag_ABI_optimization_goals
[] =
17264 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
17265 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
17266 static const char *const arm_attr_tag_ABI_FP_optimization_goals
[] =
17267 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
17268 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
17269 static const char *const arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
17270 static const char *const arm_attr_tag_FP_HP_extension
[] =
17271 {"Not Allowed", "Allowed"};
17272 static const char *const arm_attr_tag_ABI_FP_16bit_format
[] =
17273 {"None", "IEEE 754", "Alternative Format"};
17274 static const char *const arm_attr_tag_DSP_extension
[] =
17275 {"Follow architecture", "Allowed"};
17276 static const char *const arm_attr_tag_MPextension_use
[] =
17277 {"Not Allowed", "Allowed"};
17278 static const char *const arm_attr_tag_DIV_use
[] =
17279 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
17280 "Allowed in v7-A with integer division extension"};
17281 static const char *const arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
17282 static const char *const arm_attr_tag_Virtualization_use
[] =
17283 {"Not Allowed", "TrustZone", "Virtualization Extensions",
17284 "TrustZone and Virtualization Extensions"};
17285 static const char *const arm_attr_tag_MPextension_use_legacy
[] =
17286 {"Not Allowed", "Allowed"};
17288 static const char *const arm_attr_tag_MVE_arch
[] =
17289 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
17291 static const char * arm_attr_tag_PAC_extension
[] =
17292 {"No PAC/AUT instructions",
17293 "PAC/AUT instructions permitted in the NOP space",
17294 "PAC/AUT instructions permitted in the NOP and in the non-NOP space"};
17296 static const char * arm_attr_tag_BTI_extension
[] =
17297 {"BTI instructions not permitted",
17298 "BTI instructions permitted in the NOP space",
17299 "BTI instructions permitted in the NOP and in the non-NOP space"};
17301 static const char * arm_attr_tag_BTI_use
[] =
17302 {"Compiled without branch target enforcement",
17303 "Compiled with branch target enforcement"};
17305 static const char * arm_attr_tag_PACRET_use
[] =
17306 {"Compiled without return address signing and authentication",
17307 "Compiled with return address signing and authentication"};
17309 #define LOOKUP(id, name) \
17310 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
17311 static arm_attr_public_tag arm_attr_public_tags
[] =
17313 {4, "CPU_raw_name", 1, NULL
},
17314 {5, "CPU_name", 1, NULL
},
17315 LOOKUP(6, CPU_arch
),
17316 {7, "CPU_arch_profile", 0, NULL
},
17317 LOOKUP(8, ARM_ISA_use
),
17318 LOOKUP(9, THUMB_ISA_use
),
17319 LOOKUP(10, FP_arch
),
17320 LOOKUP(11, WMMX_arch
),
17321 LOOKUP(12, Advanced_SIMD_arch
),
17322 LOOKUP(13, PCS_config
),
17323 LOOKUP(14, ABI_PCS_R9_use
),
17324 LOOKUP(15, ABI_PCS_RW_data
),
17325 LOOKUP(16, ABI_PCS_RO_data
),
17326 LOOKUP(17, ABI_PCS_GOT_use
),
17327 LOOKUP(18, ABI_PCS_wchar_t
),
17328 LOOKUP(19, ABI_FP_rounding
),
17329 LOOKUP(20, ABI_FP_denormal
),
17330 LOOKUP(21, ABI_FP_exceptions
),
17331 LOOKUP(22, ABI_FP_user_exceptions
),
17332 LOOKUP(23, ABI_FP_number_model
),
17333 {24, "ABI_align_needed", 0, NULL
},
17334 {25, "ABI_align_preserved", 0, NULL
},
17335 LOOKUP(26, ABI_enum_size
),
17336 LOOKUP(27, ABI_HardFP_use
),
17337 LOOKUP(28, ABI_VFP_args
),
17338 LOOKUP(29, ABI_WMMX_args
),
17339 LOOKUP(30, ABI_optimization_goals
),
17340 LOOKUP(31, ABI_FP_optimization_goals
),
17341 {32, "compatibility", 0, NULL
},
17342 LOOKUP(34, CPU_unaligned_access
),
17343 LOOKUP(36, FP_HP_extension
),
17344 LOOKUP(38, ABI_FP_16bit_format
),
17345 LOOKUP(42, MPextension_use
),
17346 LOOKUP(44, DIV_use
),
17347 LOOKUP(46, DSP_extension
),
17348 LOOKUP(48, MVE_arch
),
17349 LOOKUP(50, PAC_extension
),
17350 LOOKUP(52, BTI_extension
),
17351 LOOKUP(74, BTI_use
),
17352 LOOKUP(76, PACRET_use
),
17353 {64, "nodefaults", 0, NULL
},
17354 {65, "also_compatible_with", 0, NULL
},
17355 LOOKUP(66, T2EE_use
),
17356 {67, "conformance", 1, NULL
},
17357 LOOKUP(68, Virtualization_use
),
17358 LOOKUP(70, MPextension_use_legacy
)
17362 static unsigned char *
17363 display_arm_attribute (unsigned char * p
,
17364 const unsigned char * const end
)
17368 arm_attr_public_tag
* attr
;
17372 READ_ULEB (tag
, p
, end
);
17374 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
17376 if (arm_attr_public_tags
[i
].tag
== tag
)
17378 attr
= &arm_attr_public_tags
[i
];
17385 printf (" Tag_%s: ", attr
->name
);
17386 switch (attr
->type
)
17391 case 7: /* Tag_CPU_arch_profile. */
17392 READ_ULEB (val
, p
, end
);
17395 case 0: printf (_("None\n")); break;
17396 case 'A': printf (_("Application\n")); break;
17397 case 'R': printf (_("Realtime\n")); break;
17398 case 'M': printf (_("Microcontroller\n")); break;
17399 case 'S': printf (_("Application or Realtime\n")); break;
17400 default: printf ("??? (%d)\n", val
); break;
17404 case 24: /* Tag_align_needed. */
17405 READ_ULEB (val
, p
, end
);
17408 case 0: printf (_("None\n")); break;
17409 case 1: printf (_("8-byte\n")); break;
17410 case 2: printf (_("4-byte\n")); break;
17411 case 3: printf ("??? 3\n"); break;
17414 printf (_("8-byte and up to %d-byte extended\n"),
17417 printf ("??? (%d)\n", val
);
17422 case 25: /* Tag_align_preserved. */
17423 READ_ULEB (val
, p
, end
);
17426 case 0: printf (_("None\n")); break;
17427 case 1: printf (_("8-byte, except leaf SP\n")); break;
17428 case 2: printf (_("8-byte\n")); break;
17429 case 3: printf ("??? 3\n"); break;
17432 printf (_("8-byte and up to %d-byte extended\n"),
17435 printf ("??? (%d)\n", val
);
17440 case 32: /* Tag_compatibility. */
17442 READ_ULEB (val
, p
, end
);
17443 printf (_("flag = %d, vendor = "), val
);
17446 size_t maxlen
= (end
- p
) - 1;
17448 print_symbol ((int) maxlen
, (const char *) p
);
17449 p
+= strnlen ((char *) p
, maxlen
) + 1;
17453 printf (_("<corrupt>"));
17454 p
= (unsigned char *) end
;
17460 case 64: /* Tag_nodefaults. */
17461 /* PR 17531: file: 001-505008-0.01. */
17464 printf (_("True\n"));
17467 case 65: /* Tag_also_compatible_with. */
17468 READ_ULEB (val
, p
, end
);
17469 if (val
== 6 /* Tag_CPU_arch. */)
17471 READ_ULEB (val
, p
, end
);
17472 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
17473 printf ("??? (%d)\n", val
);
17475 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
17479 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
17484 printf (_("<unknown: %d>\n"), tag
);
17490 return display_tag_value (-1, p
, end
);
17492 return display_tag_value (0, p
, end
);
17495 assert (attr
->type
& 0x80);
17496 READ_ULEB (val
, p
, end
);
17497 type
= attr
->type
& 0x7f;
17499 printf ("??? (%d)\n", val
);
17501 printf ("%s\n", attr
->table
[val
]);
17506 return display_tag_value (tag
, p
, end
);
17509 static unsigned char *
17510 display_gnu_attribute (unsigned char * p
,
17511 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
17512 const unsigned char * const end
)
17517 READ_ULEB (tag
, p
, end
);
17519 /* Tag_compatibility is the only generic GNU attribute defined at
17523 READ_ULEB (val
, p
, end
);
17525 printf (_("flag = %d, vendor = "), val
);
17528 printf (_("<corrupt>\n"));
17529 warn (_("corrupt vendor attribute\n"));
17535 size_t maxlen
= (end
- p
) - 1;
17537 print_symbol ((int) maxlen
, (const char *) p
);
17538 p
+= strnlen ((char *) p
, maxlen
) + 1;
17542 printf (_("<corrupt>"));
17543 p
= (unsigned char *) end
;
17550 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
17551 return display_proc_gnu_attribute (p
, tag
, end
);
17553 return display_tag_value (tag
, p
, end
);
17556 static unsigned char *
17557 display_m68k_gnu_attribute (unsigned char * p
,
17559 const unsigned char * const end
)
17563 if (tag
== Tag_GNU_M68K_ABI_FP
)
17565 printf (" Tag_GNU_M68K_ABI_FP: ");
17568 printf (_("<corrupt>\n"));
17571 READ_ULEB (val
, p
, end
);
17574 printf ("(%#x), ", val
);
17579 printf (_("unspecified hard/soft float\n"));
17582 printf (_("hard float\n"));
17585 printf (_("soft float\n"));
17591 return display_tag_value (tag
& 1, p
, end
);
17594 static unsigned char *
17595 display_power_gnu_attribute (unsigned char * p
,
17597 const unsigned char * const end
)
17601 if (tag
== Tag_GNU_Power_ABI_FP
)
17603 printf (" Tag_GNU_Power_ABI_FP: ");
17606 printf (_("<corrupt>\n"));
17609 READ_ULEB (val
, p
, end
);
17612 printf ("(%#x), ", val
);
17617 printf (_("unspecified hard/soft float, "));
17620 printf (_("hard float, "));
17623 printf (_("soft float, "));
17626 printf (_("single-precision hard float, "));
17633 printf (_("unspecified long double\n"));
17636 printf (_("128-bit IBM long double\n"));
17639 printf (_("64-bit long double\n"));
17642 printf (_("128-bit IEEE long double\n"));
17648 if (tag
== Tag_GNU_Power_ABI_Vector
)
17650 printf (" Tag_GNU_Power_ABI_Vector: ");
17653 printf (_("<corrupt>\n"));
17656 READ_ULEB (val
, p
, end
);
17659 printf ("(%#x), ", val
);
17664 printf (_("unspecified\n"));
17667 printf (_("generic\n"));
17670 printf ("AltiVec\n");
17679 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
17681 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
17684 printf (_("<corrupt>\n"));
17687 READ_ULEB (val
, p
, end
);
17690 printf ("(%#x), ", val
);
17695 printf (_("unspecified\n"));
17698 printf ("r3/r4\n");
17701 printf (_("memory\n"));
17710 return display_tag_value (tag
& 1, p
, end
);
17713 static unsigned char *
17714 display_s390_gnu_attribute (unsigned char * p
,
17716 const unsigned char * const end
)
17720 if (tag
== Tag_GNU_S390_ABI_Vector
)
17722 printf (" Tag_GNU_S390_ABI_Vector: ");
17723 READ_ULEB (val
, p
, end
);
17728 printf (_("any\n"));
17731 printf (_("software\n"));
17734 printf (_("hardware\n"));
17737 printf ("??? (%d)\n", val
);
17743 return display_tag_value (tag
& 1, p
, end
);
17747 display_sparc_hwcaps (unsigned int mask
)
17753 if (mask
& ELF_SPARC_HWCAP_MUL32
)
17754 fputs ("mul32", stdout
), first
= false;
17755 if (mask
& ELF_SPARC_HWCAP_DIV32
)
17756 printf ("%sdiv32", first
? "" : "|"), first
= false;
17757 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
17758 printf ("%sfsmuld", first
? "" : "|"), first
= false;
17759 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
17760 printf ("%sv8plus", first
? "" : "|"), first
= false;
17761 if (mask
& ELF_SPARC_HWCAP_POPC
)
17762 printf ("%spopc", first
? "" : "|"), first
= false;
17763 if (mask
& ELF_SPARC_HWCAP_VIS
)
17764 printf ("%svis", first
? "" : "|"), first
= false;
17765 if (mask
& ELF_SPARC_HWCAP_VIS2
)
17766 printf ("%svis2", first
? "" : "|"), first
= false;
17767 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
17768 printf ("%sASIBlkInit", first
? "" : "|"), first
= false;
17769 if (mask
& ELF_SPARC_HWCAP_FMAF
)
17770 printf ("%sfmaf", first
? "" : "|"), first
= false;
17771 if (mask
& ELF_SPARC_HWCAP_VIS3
)
17772 printf ("%svis3", first
? "" : "|"), first
= false;
17773 if (mask
& ELF_SPARC_HWCAP_HPC
)
17774 printf ("%shpc", first
? "" : "|"), first
= false;
17775 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
17776 printf ("%srandom", first
? "" : "|"), first
= false;
17777 if (mask
& ELF_SPARC_HWCAP_TRANS
)
17778 printf ("%strans", first
? "" : "|"), first
= false;
17779 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
17780 printf ("%sfjfmau", first
? "" : "|"), first
= false;
17781 if (mask
& ELF_SPARC_HWCAP_IMA
)
17782 printf ("%sima", first
? "" : "|"), first
= false;
17783 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
17784 printf ("%scspare", first
? "" : "|"), first
= false;
17787 fputc ('0', stdout
);
17788 fputc ('\n', stdout
);
17792 display_sparc_hwcaps2 (unsigned int mask
)
17798 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
17799 fputs ("fjathplus", stdout
), first
= false;
17800 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
17801 printf ("%svis3b", first
? "" : "|"), first
= false;
17802 if (mask
& ELF_SPARC_HWCAP2_ADP
)
17803 printf ("%sadp", first
? "" : "|"), first
= false;
17804 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
17805 printf ("%ssparc5", first
? "" : "|"), first
= false;
17806 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
17807 printf ("%smwait", first
? "" : "|"), first
= false;
17808 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
17809 printf ("%sxmpmul", first
? "" : "|"), first
= false;
17810 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
17811 printf ("%sxmont2", first
? "" : "|"), first
= false;
17812 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
17813 printf ("%snsec", first
? "" : "|"), first
= false;
17814 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
17815 printf ("%sfjathhpc", first
? "" : "|"), first
= false;
17816 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
17817 printf ("%sfjdes", first
? "" : "|"), first
= false;
17818 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
17819 printf ("%sfjaes", first
? "" : "|"), first
= false;
17822 fputc ('0', stdout
);
17823 fputc ('\n', stdout
);
17826 static unsigned char *
17827 display_sparc_gnu_attribute (unsigned char * p
,
17829 const unsigned char * const end
)
17833 if (tag
== Tag_GNU_Sparc_HWCAPS
)
17835 READ_ULEB (val
, p
, end
);
17836 printf (" Tag_GNU_Sparc_HWCAPS: ");
17837 display_sparc_hwcaps (val
);
17840 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
17842 READ_ULEB (val
, p
, end
);
17843 printf (" Tag_GNU_Sparc_HWCAPS2: ");
17844 display_sparc_hwcaps2 (val
);
17848 return display_tag_value (tag
, p
, end
);
17852 print_mips_fp_abi_value (unsigned int val
)
17856 case Val_GNU_MIPS_ABI_FP_ANY
:
17857 printf (_("Hard or soft float\n"));
17859 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
17860 printf (_("Hard float (double precision)\n"));
17862 case Val_GNU_MIPS_ABI_FP_SINGLE
:
17863 printf (_("Hard float (single precision)\n"));
17865 case Val_GNU_MIPS_ABI_FP_SOFT
:
17866 printf (_("Soft float\n"));
17868 case Val_GNU_MIPS_ABI_FP_OLD_64
:
17869 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
17871 case Val_GNU_MIPS_ABI_FP_XX
:
17872 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
17874 case Val_GNU_MIPS_ABI_FP_64
:
17875 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
17877 case Val_GNU_MIPS_ABI_FP_64A
:
17878 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
17880 case Val_GNU_MIPS_ABI_FP_NAN2008
:
17881 printf (_("NaN 2008 compatibility\n"));
17884 printf ("??? (%d)\n", val
);
17889 static unsigned char *
17890 display_mips_gnu_attribute (unsigned char * p
,
17892 const unsigned char * const end
)
17894 if (tag
== Tag_GNU_MIPS_ABI_FP
)
17898 printf (" Tag_GNU_MIPS_ABI_FP: ");
17899 READ_ULEB (val
, p
, end
);
17900 print_mips_fp_abi_value (val
);
17904 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
17908 printf (" Tag_GNU_MIPS_ABI_MSA: ");
17909 READ_ULEB (val
, p
, end
);
17913 case Val_GNU_MIPS_ABI_MSA_ANY
:
17914 printf (_("Any MSA or not\n"));
17916 case Val_GNU_MIPS_ABI_MSA_128
:
17917 printf (_("128-bit MSA\n"));
17920 printf ("??? (%d)\n", val
);
17926 return display_tag_value (tag
& 1, p
, end
);
17929 static unsigned char *
17930 display_tic6x_attribute (unsigned char * p
,
17931 const unsigned char * const end
)
17936 READ_ULEB (tag
, p
, end
);
17941 printf (" Tag_ISA: ");
17942 READ_ULEB (val
, p
, end
);
17946 case C6XABI_Tag_ISA_none
:
17947 printf (_("None\n"));
17949 case C6XABI_Tag_ISA_C62X
:
17952 case C6XABI_Tag_ISA_C67X
:
17955 case C6XABI_Tag_ISA_C67XP
:
17956 printf ("C67x+\n");
17958 case C6XABI_Tag_ISA_C64X
:
17961 case C6XABI_Tag_ISA_C64XP
:
17962 printf ("C64x+\n");
17964 case C6XABI_Tag_ISA_C674X
:
17965 printf ("C674x\n");
17968 printf ("??? (%d)\n", val
);
17973 case Tag_ABI_wchar_t
:
17974 printf (" Tag_ABI_wchar_t: ");
17975 READ_ULEB (val
, p
, end
);
17979 printf (_("Not used\n"));
17982 printf (_("2 bytes\n"));
17985 printf (_("4 bytes\n"));
17988 printf ("??? (%d)\n", val
);
17993 case Tag_ABI_stack_align_needed
:
17994 printf (" Tag_ABI_stack_align_needed: ");
17995 READ_ULEB (val
, p
, end
);
17999 printf (_("8-byte\n"));
18002 printf (_("16-byte\n"));
18005 printf ("??? (%d)\n", val
);
18010 case Tag_ABI_stack_align_preserved
:
18011 READ_ULEB (val
, p
, end
);
18012 printf (" Tag_ABI_stack_align_preserved: ");
18016 printf (_("8-byte\n"));
18019 printf (_("16-byte\n"));
18022 printf ("??? (%d)\n", val
);
18028 READ_ULEB (val
, p
, end
);
18029 printf (" Tag_ABI_DSBT: ");
18033 printf (_("DSBT addressing not used\n"));
18036 printf (_("DSBT addressing used\n"));
18039 printf ("??? (%d)\n", val
);
18045 READ_ULEB (val
, p
, end
);
18046 printf (" Tag_ABI_PID: ");
18050 printf (_("Data addressing position-dependent\n"));
18053 printf (_("Data addressing position-independent, GOT near DP\n"));
18056 printf (_("Data addressing position-independent, GOT far from DP\n"));
18059 printf ("??? (%d)\n", val
);
18065 READ_ULEB (val
, p
, end
);
18066 printf (" Tag_ABI_PIC: ");
18070 printf (_("Code addressing position-dependent\n"));
18073 printf (_("Code addressing position-independent\n"));
18076 printf ("??? (%d)\n", val
);
18081 case Tag_ABI_array_object_alignment
:
18082 READ_ULEB (val
, p
, end
);
18083 printf (" Tag_ABI_array_object_alignment: ");
18087 printf (_("8-byte\n"));
18090 printf (_("4-byte\n"));
18093 printf (_("16-byte\n"));
18096 printf ("??? (%d)\n", val
);
18101 case Tag_ABI_array_object_align_expected
:
18102 READ_ULEB (val
, p
, end
);
18103 printf (" Tag_ABI_array_object_align_expected: ");
18107 printf (_("8-byte\n"));
18110 printf (_("4-byte\n"));
18113 printf (_("16-byte\n"));
18116 printf ("??? (%d)\n", val
);
18121 case Tag_ABI_compatibility
:
18123 READ_ULEB (val
, p
, end
);
18124 printf (" Tag_ABI_compatibility: ");
18125 printf (_("flag = %d, vendor = "), val
);
18128 size_t maxlen
= (end
- p
) - 1;
18130 print_symbol ((int) maxlen
, (const char *) p
);
18131 p
+= strnlen ((char *) p
, maxlen
) + 1;
18135 printf (_("<corrupt>"));
18136 p
= (unsigned char *) end
;
18142 case Tag_ABI_conformance
:
18144 printf (" Tag_ABI_conformance: \"");
18147 size_t maxlen
= (end
- p
) - 1;
18149 print_symbol ((int) maxlen
, (const char *) p
);
18150 p
+= strnlen ((char *) p
, maxlen
) + 1;
18154 printf (_("<corrupt>"));
18155 p
= (unsigned char *) end
;
18162 return display_tag_value (tag
, p
, end
);
18166 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
18169 size_t bytes
= end
- p
;
18176 int lbytes
= (bytes
> 16 ? 16 : bytes
);
18178 printf (" 0x%8.8" PRIx64
" ", addr
);
18180 for (j
= 0; j
< 16; j
++)
18183 printf ("%2.2x", p
[j
]);
18191 for (j
= 0; j
< lbytes
; j
++)
18194 if (k
>= ' ' && k
< 0x7f)
18210 static unsigned char *
18211 display_msp430_attribute (unsigned char * p
,
18212 const unsigned char * const end
)
18217 READ_ULEB (tag
, p
, end
);
18221 case OFBA_MSPABI_Tag_ISA
:
18222 printf (" Tag_ISA: ");
18223 READ_ULEB (val
, p
, end
);
18226 case 0: printf (_("None\n")); break;
18227 case 1: printf (_("MSP430\n")); break;
18228 case 2: printf (_("MSP430X\n")); break;
18229 default: printf ("??? (%" PRId64
")\n", val
); break;
18233 case OFBA_MSPABI_Tag_Code_Model
:
18234 printf (" Tag_Code_Model: ");
18235 READ_ULEB (val
, p
, end
);
18238 case 0: printf (_("None\n")); break;
18239 case 1: printf (_("Small\n")); break;
18240 case 2: printf (_("Large\n")); break;
18241 default: printf ("??? (%" PRId64
")\n", val
); break;
18245 case OFBA_MSPABI_Tag_Data_Model
:
18246 printf (" Tag_Data_Model: ");
18247 READ_ULEB (val
, p
, end
);
18250 case 0: printf (_("None\n")); break;
18251 case 1: printf (_("Small\n")); break;
18252 case 2: printf (_("Large\n")); break;
18253 case 3: printf (_("Restricted Large\n")); break;
18254 default: printf ("??? (%" PRId64
")\n", val
); break;
18259 printf (_(" <unknown tag %" PRId64
">: "), tag
);
18266 size_t maxlen
= (end
- p
) - 1;
18268 print_symbol ((int) maxlen
, (const char *) p
);
18269 p
+= strnlen ((char *) p
, maxlen
) + 1;
18273 printf (_("<corrupt>"));
18274 p
= (unsigned char *) end
;
18280 READ_ULEB (val
, p
, end
);
18281 printf ("%" PRId64
" (0x%" PRIx64
")\n", val
, val
);
18290 static unsigned char *
18291 display_msp430_gnu_attribute (unsigned char * p
,
18293 const unsigned char * const end
)
18295 if (tag
== Tag_GNU_MSP430_Data_Region
)
18299 printf (" Tag_GNU_MSP430_Data_Region: ");
18300 READ_ULEB (val
, p
, end
);
18304 case Val_GNU_MSP430_Data_Region_Any
:
18305 printf (_("Any Region\n"));
18307 case Val_GNU_MSP430_Data_Region_Lower
:
18308 printf (_("Lower Region Only\n"));
18311 printf ("??? (%" PRIu64
")\n", val
);
18315 return display_tag_value (tag
& 1, p
, end
);
18318 struct riscv_attr_tag_t
{
18323 static struct riscv_attr_tag_t riscv_attr_tag
[] =
18325 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
18328 T(priv_spec_minor
),
18329 T(priv_spec_revision
),
18330 T(unaligned_access
),
18335 static unsigned char *
18336 display_riscv_attribute (unsigned char *p
,
18337 const unsigned char * const end
)
18341 struct riscv_attr_tag_t
*attr
= NULL
;
18344 READ_ULEB (tag
, p
, end
);
18346 /* Find the name of attribute. */
18347 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
18349 if (riscv_attr_tag
[i
].tag
== tag
)
18351 attr
= &riscv_attr_tag
[i
];
18357 printf (" %s: ", attr
->name
);
18359 return display_tag_value (tag
, p
, end
);
18363 case Tag_RISCV_priv_spec
:
18364 case Tag_RISCV_priv_spec_minor
:
18365 case Tag_RISCV_priv_spec_revision
:
18366 READ_ULEB (val
, p
, end
);
18367 printf ("%" PRIu64
"\n", val
);
18369 case Tag_RISCV_unaligned_access
:
18370 READ_ULEB (val
, p
, end
);
18374 printf (_("No unaligned access\n"));
18377 printf (_("Unaligned access\n"));
18381 case Tag_RISCV_stack_align
:
18382 READ_ULEB (val
, p
, end
);
18383 printf (_("%" PRIu64
"-bytes\n"), val
);
18385 case Tag_RISCV_arch
:
18386 p
= display_tag_value (-1, p
, end
);
18389 return display_tag_value (tag
, p
, end
);
18395 static unsigned char *
18396 display_csky_attribute (unsigned char * p
,
18397 const unsigned char * const end
)
18401 READ_ULEB (tag
, p
, end
);
18403 if (tag
>= Tag_CSKY_MAX
)
18405 return display_tag_value (-1, p
, end
);
18410 case Tag_CSKY_ARCH_NAME
:
18411 printf (" Tag_CSKY_ARCH_NAME:\t\t");
18412 return display_tag_value (-1, p
, end
);
18413 case Tag_CSKY_CPU_NAME
:
18414 printf (" Tag_CSKY_CPU_NAME:\t\t");
18415 return display_tag_value (-1, p
, end
);
18417 case Tag_CSKY_ISA_FLAGS
:
18418 printf (" Tag_CSKY_ISA_FLAGS:\t\t");
18419 return display_tag_value (0, p
, end
);
18420 case Tag_CSKY_ISA_EXT_FLAGS
:
18421 printf (" Tag_CSKY_ISA_EXT_FLAGS:\t");
18422 return display_tag_value (0, p
, end
);
18424 case Tag_CSKY_DSP_VERSION
:
18425 printf (" Tag_CSKY_DSP_VERSION:\t\t");
18426 READ_ULEB (val
, p
, end
);
18427 if (val
== VAL_CSKY_DSP_VERSION_EXTENSION
)
18428 printf ("DSP Extension\n");
18429 else if (val
== VAL_CSKY_DSP_VERSION_2
)
18430 printf ("DSP 2.0\n");
18433 case Tag_CSKY_VDSP_VERSION
:
18434 printf (" Tag_CSKY_VDSP_VERSION:\t");
18435 READ_ULEB (val
, p
, end
);
18436 printf ("VDSP Version %" PRId64
"\n", val
);
18439 case Tag_CSKY_FPU_VERSION
:
18440 printf (" Tag_CSKY_FPU_VERSION:\t\t");
18441 READ_ULEB (val
, p
, end
);
18442 if (val
== VAL_CSKY_FPU_VERSION_1
)
18443 printf ("ABIV1 FPU Version 1\n");
18444 else if (val
== VAL_CSKY_FPU_VERSION_2
)
18445 printf ("FPU Version 2\n");
18448 case Tag_CSKY_FPU_ABI
:
18449 printf (" Tag_CSKY_FPU_ABI:\t\t");
18450 READ_ULEB (val
, p
, end
);
18451 if (val
== VAL_CSKY_FPU_ABI_HARD
)
18453 else if (val
== VAL_CSKY_FPU_ABI_SOFTFP
)
18454 printf ("SoftFP\n");
18455 else if (val
== VAL_CSKY_FPU_ABI_SOFT
)
18458 case Tag_CSKY_FPU_ROUNDING
:
18459 READ_ULEB (val
, p
, end
);
18462 printf (" Tag_CSKY_FPU_ROUNDING:\t");
18463 printf ("Needed\n");
18466 case Tag_CSKY_FPU_DENORMAL
:
18467 READ_ULEB (val
, p
, end
);
18470 printf (" Tag_CSKY_FPU_DENORMAL:\t");
18471 printf ("Needed\n");
18474 case Tag_CSKY_FPU_Exception
:
18475 READ_ULEB (val
, p
, end
);
18478 printf (" Tag_CSKY_FPU_Exception:\t");
18479 printf ("Needed\n");
18482 case Tag_CSKY_FPU_NUMBER_MODULE
:
18483 printf (" Tag_CSKY_FPU_NUMBER_MODULE:\t");
18484 return display_tag_value (-1, p
, end
);
18485 case Tag_CSKY_FPU_HARDFP
:
18486 printf (" Tag_CSKY_FPU_HARDFP:\t\t");
18487 READ_ULEB (val
, p
, end
);
18488 if (val
& VAL_CSKY_FPU_HARDFP_HALF
)
18490 if (val
& VAL_CSKY_FPU_HARDFP_SINGLE
)
18491 printf (" Single");
18492 if (val
& VAL_CSKY_FPU_HARDFP_DOUBLE
)
18493 printf (" Double");
18497 return display_tag_value (tag
, p
, end
);
18503 process_attributes (Filedata
* filedata
,
18504 const char * public_name
,
18505 unsigned int proc_type
,
18506 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
18507 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
18509 Elf_Internal_Shdr
* sect
;
18513 /* Find the section header so that we get the size. */
18514 for (i
= 0, sect
= filedata
->section_headers
;
18515 i
< filedata
->file_header
.e_shnum
;
18518 unsigned char * contents
;
18521 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
18524 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
18525 sect
->sh_size
, _("attributes"));
18526 if (contents
== NULL
)
18533 /* The first character is the version of the attributes.
18534 Currently only version 1, (aka 'A') is recognised here. */
18537 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
18542 uint64_t section_len
;
18544 section_len
= sect
->sh_size
- 1;
18547 while (section_len
> 0)
18550 unsigned int namelen
;
18551 bool public_section
;
18554 if (section_len
<= 4)
18556 error (_("Tag section ends prematurely\n"));
18560 attr_len
= byte_get (p
, 4);
18563 if (attr_len
> section_len
)
18565 error (_("Bad attribute length (%u > %u)\n"),
18566 (unsigned) attr_len
, (unsigned) section_len
);
18567 attr_len
= section_len
;
18570 /* PR 17531: file: 001-101425-0.004 */
18571 else if (attr_len
< 5)
18573 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
18578 section_len
-= attr_len
;
18581 namelen
= strnlen ((char *) p
, attr_len
) + 1;
18582 if (namelen
== 0 || namelen
>= attr_len
)
18584 error (_("Corrupt attribute section name\n"));
18589 printf (_("Attribute Section: "));
18590 print_symbol (INT_MAX
, (const char *) p
);
18593 if (public_name
&& streq ((char *) p
, public_name
))
18594 public_section
= true;
18596 public_section
= false;
18598 if (streq ((char *) p
, "gnu"))
18599 gnu_section
= true;
18601 gnu_section
= false;
18604 attr_len
-= namelen
;
18606 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
18611 unsigned char * end
;
18613 /* PR binutils/17531: Safe handling of corrupt files. */
18616 error (_("Unused bytes at end of section\n"));
18623 size
= byte_get (p
, 4);
18624 if (size
> attr_len
)
18626 error (_("Bad subsection length (%u > %u)\n"),
18627 (unsigned) size
, (unsigned) attr_len
);
18631 /* PR binutils/17531: Safe handling of corrupt files. */
18634 error (_("Bad subsection length (%u < 6)\n"),
18642 end
= p
+ size
- 1;
18643 assert (end
<= contents
+ sect
->sh_size
);
18649 printf (_("File Attributes\n"));
18652 printf (_("Section Attributes:"));
18655 printf (_("Symbol Attributes:"));
18656 /* Fall through. */
18660 READ_ULEB (val
, p
, end
);
18663 printf (" %d", val
);
18668 printf (_("Unknown tag: %d\n"), tag
);
18669 public_section
= false;
18673 if (public_section
&& display_pub_attribute
!= NULL
)
18676 p
= display_pub_attribute (p
, end
);
18679 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
18682 p
= display_gnu_attribute (p
,
18683 display_proc_gnu_attribute
,
18689 printf (_(" Unknown attribute:\n"));
18690 display_raw_attribute (p
, end
);
18705 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
18706 Print the Address, Access and Initial fields of an entry at VMA ADDR
18707 and return the VMA of the next entry, or -1 if there was a problem.
18708 Does not read from DATA_END or beyond. */
18711 print_mips_got_entry (unsigned char * data
, uint64_t pltgot
, uint64_t addr
,
18712 unsigned char * data_end
)
18715 print_vma (addr
, LONG_HEX
);
18717 if (addr
< pltgot
+ 0xfff0)
18718 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
18720 printf ("%10s", "");
18723 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
18727 unsigned char * from
= data
+ addr
- pltgot
;
18729 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
18731 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
18732 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
18733 return (uint64_t) -1;
18737 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
18738 print_vma (entry
, LONG_HEX
);
18741 return addr
+ (is_32bit_elf
? 4 : 8);
18744 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
18745 PLTGOT. Print the Address and Initial fields of an entry at VMA
18746 ADDR and return the VMA of the next entry. */
18749 print_mips_pltgot_entry (unsigned char * data
, uint64_t pltgot
, uint64_t addr
)
18752 print_vma (addr
, LONG_HEX
);
18755 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
18760 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
18761 print_vma (entry
, LONG_HEX
);
18763 return addr
+ (is_32bit_elf
? 4 : 8);
18767 print_mips_ases (unsigned int mask
)
18769 if (mask
& AFL_ASE_DSP
)
18770 fputs ("\n\tDSP ASE", stdout
);
18771 if (mask
& AFL_ASE_DSPR2
)
18772 fputs ("\n\tDSP R2 ASE", stdout
);
18773 if (mask
& AFL_ASE_DSPR3
)
18774 fputs ("\n\tDSP R3 ASE", stdout
);
18775 if (mask
& AFL_ASE_EVA
)
18776 fputs ("\n\tEnhanced VA Scheme", stdout
);
18777 if (mask
& AFL_ASE_MCU
)
18778 fputs ("\n\tMCU (MicroController) ASE", stdout
);
18779 if (mask
& AFL_ASE_MDMX
)
18780 fputs ("\n\tMDMX ASE", stdout
);
18781 if (mask
& AFL_ASE_MIPS3D
)
18782 fputs ("\n\tMIPS-3D ASE", stdout
);
18783 if (mask
& AFL_ASE_MT
)
18784 fputs ("\n\tMT ASE", stdout
);
18785 if (mask
& AFL_ASE_SMARTMIPS
)
18786 fputs ("\n\tSmartMIPS ASE", stdout
);
18787 if (mask
& AFL_ASE_VIRT
)
18788 fputs ("\n\tVZ ASE", stdout
);
18789 if (mask
& AFL_ASE_MSA
)
18790 fputs ("\n\tMSA ASE", stdout
);
18791 if (mask
& AFL_ASE_MIPS16
)
18792 fputs ("\n\tMIPS16 ASE", stdout
);
18793 if (mask
& AFL_ASE_MICROMIPS
)
18794 fputs ("\n\tMICROMIPS ASE", stdout
);
18795 if (mask
& AFL_ASE_XPA
)
18796 fputs ("\n\tXPA ASE", stdout
);
18797 if (mask
& AFL_ASE_MIPS16E2
)
18798 fputs ("\n\tMIPS16e2 ASE", stdout
);
18799 if (mask
& AFL_ASE_CRC
)
18800 fputs ("\n\tCRC ASE", stdout
);
18801 if (mask
& AFL_ASE_GINV
)
18802 fputs ("\n\tGINV ASE", stdout
);
18803 if (mask
& AFL_ASE_LOONGSON_MMI
)
18804 fputs ("\n\tLoongson MMI ASE", stdout
);
18805 if (mask
& AFL_ASE_LOONGSON_CAM
)
18806 fputs ("\n\tLoongson CAM ASE", stdout
);
18807 if (mask
& AFL_ASE_LOONGSON_EXT
)
18808 fputs ("\n\tLoongson EXT ASE", stdout
);
18809 if (mask
& AFL_ASE_LOONGSON_EXT2
)
18810 fputs ("\n\tLoongson EXT2 ASE", stdout
);
18812 fprintf (stdout
, "\n\t%s", _("None"));
18813 else if ((mask
& ~AFL_ASE_MASK
) != 0)
18814 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
18818 print_mips_isa_ext (unsigned int isa_ext
)
18823 fputs (_("None"), stdout
);
18826 fputs ("RMI XLR", stdout
);
18828 case AFL_EXT_OCTEON3
:
18829 fputs ("Cavium Networks Octeon3", stdout
);
18831 case AFL_EXT_OCTEON2
:
18832 fputs ("Cavium Networks Octeon2", stdout
);
18834 case AFL_EXT_OCTEONP
:
18835 fputs ("Cavium Networks OcteonP", stdout
);
18837 case AFL_EXT_OCTEON
:
18838 fputs ("Cavium Networks Octeon", stdout
);
18841 fputs ("Toshiba R5900", stdout
);
18844 fputs ("MIPS R4650", stdout
);
18847 fputs ("LSI R4010", stdout
);
18850 fputs ("NEC VR4100", stdout
);
18853 fputs ("Toshiba R3900", stdout
);
18855 case AFL_EXT_10000
:
18856 fputs ("MIPS R10000", stdout
);
18859 fputs ("Broadcom SB-1", stdout
);
18862 fputs ("NEC VR4111/VR4181", stdout
);
18865 fputs ("NEC VR4120", stdout
);
18868 fputs ("NEC VR5400", stdout
);
18871 fputs ("NEC VR5500", stdout
);
18873 case AFL_EXT_LOONGSON_2E
:
18874 fputs ("ST Microelectronics Loongson 2E", stdout
);
18876 case AFL_EXT_LOONGSON_2F
:
18877 fputs ("ST Microelectronics Loongson 2F", stdout
);
18879 case AFL_EXT_INTERAPTIV_MR2
:
18880 fputs ("Imagination interAptiv MR2", stdout
);
18883 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
18888 get_mips_reg_size (int reg_size
)
18890 return (reg_size
== AFL_REG_NONE
) ? 0
18891 : (reg_size
== AFL_REG_32
) ? 32
18892 : (reg_size
== AFL_REG_64
) ? 64
18893 : (reg_size
== AFL_REG_128
) ? 128
18898 process_mips_specific (Filedata
* filedata
)
18900 Elf_Internal_Dyn
* entry
;
18901 Elf_Internal_Shdr
*sect
= NULL
;
18902 size_t liblist_offset
= 0;
18903 size_t liblistno
= 0;
18904 size_t conflictsno
= 0;
18905 size_t options_offset
= 0;
18906 size_t conflicts_offset
= 0;
18907 size_t pltrelsz
= 0;
18909 uint64_t pltgot
= 0;
18910 uint64_t mips_pltgot
= 0;
18911 uint64_t jmprel
= 0;
18912 uint64_t local_gotno
= 0;
18913 uint64_t gotsym
= 0;
18914 uint64_t symtabno
= 0;
18917 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18918 display_mips_gnu_attribute
))
18921 sect
= find_section (filedata
, ".MIPS.abiflags");
18925 Elf_External_ABIFlags_v0
*abiflags_ext
;
18926 Elf_Internal_ABIFlags_v0 abiflags_in
;
18928 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
18930 error (_("Corrupt MIPS ABI Flags section.\n"));
18935 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
18936 sect
->sh_size
, _("MIPS ABI Flags section"));
18939 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
18940 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
18941 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
18942 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
18943 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
18944 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
18945 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
18946 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
18947 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
18948 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
18949 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
18951 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
18952 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
18953 if (abiflags_in
.isa_rev
> 1)
18954 printf ("r%d", abiflags_in
.isa_rev
);
18955 printf ("\nGPR size: %d",
18956 get_mips_reg_size (abiflags_in
.gpr_size
));
18957 printf ("\nCPR1 size: %d",
18958 get_mips_reg_size (abiflags_in
.cpr1_size
));
18959 printf ("\nCPR2 size: %d",
18960 get_mips_reg_size (abiflags_in
.cpr2_size
));
18961 fputs ("\nFP ABI: ", stdout
);
18962 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
18963 fputs ("ISA Extension: ", stdout
);
18964 print_mips_isa_ext (abiflags_in
.isa_ext
);
18965 fputs ("\nASEs:", stdout
);
18966 print_mips_ases (abiflags_in
.ases
);
18967 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
18968 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
18969 fputc ('\n', stdout
);
18970 free (abiflags_ext
);
18975 /* We have a lot of special sections. Thanks SGI! */
18976 if (filedata
->dynamic_section
== NULL
)
18978 /* No dynamic information available. See if there is static GOT. */
18979 sect
= find_section (filedata
, ".got");
18982 unsigned char *data_end
;
18983 unsigned char *data
;
18987 pltgot
= sect
->sh_addr
;
18990 addr_size
= (is_32bit_elf
? 4 : 8);
18991 end
= pltgot
+ sect
->sh_size
;
18993 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
18995 _("Global Offset Table data"));
18996 /* PR 12855: Null data is handled gracefully throughout. */
18997 data_end
= data
+ (end
- pltgot
);
18999 printf (_("\nStatic GOT:\n"));
19000 printf (_(" Canonical gp value: "));
19001 print_vma (ent
+ 0x7ff0, LONG_HEX
);
19004 /* In a dynamic binary GOT[0] is reserved for the dynamic
19005 loader to store the lazy resolver pointer, however in
19006 a static binary it may well have been omitted and GOT
19007 reduced to a table of addresses.
19008 PR 21344: Check for the entry being fully available
19009 before fetching it. */
19011 && data
+ ent
- pltgot
+ addr_size
<= data_end
19012 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
19014 printf (_(" Reserved entries:\n"));
19015 printf (_(" %*s %10s %*s\n"),
19016 addr_size
* 2, _("Address"), _("Access"),
19017 addr_size
* 2, _("Value"));
19018 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19020 if (ent
== (uint64_t) -1)
19021 goto sgot_print_fail
;
19023 /* Check for the MSB of GOT[1] being set, identifying a
19024 GNU object. This entry will be used by some runtime
19025 loaders, to store the module pointer. Otherwise this
19026 is an ordinary local entry.
19027 PR 21344: Check for the entry being fully available
19028 before fetching it. */
19030 && data
+ ent
- pltgot
+ addr_size
<= data_end
19031 && (byte_get (data
+ ent
- pltgot
, addr_size
)
19032 >> (addr_size
* 8 - 1)) != 0)
19034 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19036 if (ent
== (uint64_t) -1)
19037 goto sgot_print_fail
;
19042 if (data
!= NULL
&& ent
< end
)
19044 printf (_(" Local entries:\n"));
19045 printf (" %*s %10s %*s\n",
19046 addr_size
* 2, _("Address"), _("Access"),
19047 addr_size
* 2, _("Value"));
19050 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19052 if (ent
== (uint64_t) -1)
19053 goto sgot_print_fail
;
19064 for (entry
= filedata
->dynamic_section
;
19065 /* PR 17531 file: 012-50589-0.004. */
19066 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
19067 && entry
->d_tag
!= DT_NULL
);
19069 switch (entry
->d_tag
)
19071 case DT_MIPS_LIBLIST
:
19073 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
19074 liblistno
* sizeof (Elf32_External_Lib
));
19076 case DT_MIPS_LIBLISTNO
:
19077 liblistno
= entry
->d_un
.d_val
;
19079 case DT_MIPS_OPTIONS
:
19080 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
19082 case DT_MIPS_CONFLICT
:
19084 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
19085 conflictsno
* sizeof (Elf32_External_Conflict
));
19087 case DT_MIPS_CONFLICTNO
:
19088 conflictsno
= entry
->d_un
.d_val
;
19091 pltgot
= entry
->d_un
.d_ptr
;
19093 case DT_MIPS_LOCAL_GOTNO
:
19094 local_gotno
= entry
->d_un
.d_val
;
19096 case DT_MIPS_GOTSYM
:
19097 gotsym
= entry
->d_un
.d_val
;
19099 case DT_MIPS_SYMTABNO
:
19100 symtabno
= entry
->d_un
.d_val
;
19102 case DT_MIPS_PLTGOT
:
19103 mips_pltgot
= entry
->d_un
.d_ptr
;
19106 pltrel
= entry
->d_un
.d_val
;
19109 pltrelsz
= entry
->d_un
.d_val
;
19112 jmprel
= entry
->d_un
.d_ptr
;
19118 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
19120 Elf32_External_Lib
* elib
;
19123 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
19124 sizeof (Elf32_External_Lib
),
19126 _("liblist section data"));
19129 printf (ngettext ("\nSection '.liblist' contains %zu entry:\n",
19130 "\nSection '.liblist' contains %zu entries:\n",
19133 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
19136 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
19143 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
19144 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
19145 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
19146 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
19147 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
19149 tmp
= gmtime (&atime
);
19150 snprintf (timebuf
, sizeof (timebuf
),
19151 "%04u-%02u-%02uT%02u:%02u:%02u",
19152 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
19153 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
19155 printf ("%3zu: ", cnt
);
19156 if (valid_dynamic_name (filedata
, liblist
.l_name
))
19157 print_symbol (20, get_dynamic_name (filedata
, liblist
.l_name
));
19159 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
19160 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
19161 liblist
.l_version
);
19163 if (liblist
.l_flags
== 0)
19167 static const struct
19174 { " EXACT_MATCH", LL_EXACT_MATCH
},
19175 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
19176 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
19177 { " EXPORTS", LL_EXPORTS
},
19178 { " DELAY_LOAD", LL_DELAY_LOAD
},
19179 { " DELTA", LL_DELTA
}
19181 int flags
= liblist
.l_flags
;
19184 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
19185 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
19187 fputs (l_flags_vals
[fcnt
].name
, stdout
);
19188 flags
^= l_flags_vals
[fcnt
].bit
;
19191 printf (" %#x", (unsigned int) flags
);
19203 if (options_offset
!= 0)
19205 Elf_External_Options
* eopt
;
19209 /* Find the section header so that we get the size. */
19210 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
19211 /* PR 17533 file: 012-277276-0.004. */
19214 error (_("No MIPS_OPTIONS header found\n"));
19218 if (sect
->sh_size
< sizeof (* eopt
))
19220 error (_("The MIPS options section is too small.\n"));
19224 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
19225 sect
->sh_size
, _("options"));
19228 Elf_Internal_Options option
;
19231 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
19233 Elf_External_Options
* eoption
;
19234 unsigned int optsize
;
19236 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
19238 optsize
= BYTE_GET (eoption
->size
);
19240 /* PR 17531: file: ffa0fa3b. */
19241 if (optsize
< sizeof (* eopt
)
19242 || optsize
> sect
->sh_size
- offset
)
19244 error (_("Invalid size (%u) for MIPS option\n"),
19253 printf (ngettext ("\nSection '%s' contains %d entry:\n",
19254 "\nSection '%s' contains %d entries:\n",
19256 printable_section_name (filedata
, sect
), cnt
);
19262 Elf_External_Options
* eoption
;
19264 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
19266 option
.kind
= BYTE_GET (eoption
->kind
);
19267 option
.size
= BYTE_GET (eoption
->size
);
19268 option
.section
= BYTE_GET (eoption
->section
);
19269 option
.info
= BYTE_GET (eoption
->info
);
19271 switch (option
.kind
)
19274 /* This shouldn't happen. */
19275 printf (" NULL %" PRId16
" %" PRIx32
,
19276 option
.section
, option
.info
);
19280 printf (" REGINFO ");
19281 if (filedata
->file_header
.e_machine
== EM_MIPS
)
19283 Elf32_External_RegInfo
* ereg
;
19284 Elf32_RegInfo reginfo
;
19287 if (option
.size
< (sizeof (Elf_External_Options
)
19288 + sizeof (Elf32_External_RegInfo
)))
19290 printf (_("<corrupt>\n"));
19291 error (_("Truncated MIPS REGINFO option\n"));
19296 ereg
= (Elf32_External_RegInfo
*) (eoption
+ 1);
19298 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
19299 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
19300 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
19301 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
19302 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
19303 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
19305 printf ("GPR %08" PRIx32
" GP 0x%" PRIx32
"\n",
19306 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
19308 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
19309 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
19310 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
19311 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
19316 Elf64_External_RegInfo
* ereg
;
19317 Elf64_Internal_RegInfo reginfo
;
19319 if (option
.size
< (sizeof (Elf_External_Options
)
19320 + sizeof (Elf64_External_RegInfo
)))
19322 printf (_("<corrupt>\n"));
19323 error (_("Truncated MIPS REGINFO option\n"));
19328 ereg
= (Elf64_External_RegInfo
*) (eoption
+ 1);
19329 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
19330 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
19331 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
19332 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
19333 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
19334 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
19336 printf ("GPR %08" PRIx32
" GP 0x%" PRIx64
"\n",
19337 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
19339 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
19340 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
19341 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
19342 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
19344 offset
+= option
.size
;
19347 case ODK_EXCEPTIONS
:
19348 fputs (" EXCEPTIONS fpe_min(", stdout
);
19349 process_mips_fpe_exception (option
.info
& OEX_FPU_MIN
);
19350 fputs (") fpe_max(", stdout
);
19351 process_mips_fpe_exception ((option
.info
& OEX_FPU_MAX
) >> 8);
19352 fputs (")", stdout
);
19354 if (option
.info
& OEX_PAGE0
)
19355 fputs (" PAGE0", stdout
);
19356 if (option
.info
& OEX_SMM
)
19357 fputs (" SMM", stdout
);
19358 if (option
.info
& OEX_FPDBUG
)
19359 fputs (" FPDBUG", stdout
);
19360 if (option
.info
& OEX_DISMISS
)
19361 fputs (" DISMISS", stdout
);
19365 fputs (" PAD ", stdout
);
19366 if (option
.info
& OPAD_PREFIX
)
19367 fputs (" PREFIX", stdout
);
19368 if (option
.info
& OPAD_POSTFIX
)
19369 fputs (" POSTFIX", stdout
);
19370 if (option
.info
& OPAD_SYMBOL
)
19371 fputs (" SYMBOL", stdout
);
19375 fputs (" HWPATCH ", stdout
);
19376 if (option
.info
& OHW_R4KEOP
)
19377 fputs (" R4KEOP", stdout
);
19378 if (option
.info
& OHW_R8KPFETCH
)
19379 fputs (" R8KPFETCH", stdout
);
19380 if (option
.info
& OHW_R5KEOP
)
19381 fputs (" R5KEOP", stdout
);
19382 if (option
.info
& OHW_R5KCVTL
)
19383 fputs (" R5KCVTL", stdout
);
19387 fputs (" FILL ", stdout
);
19388 /* XXX Print content of info word? */
19392 fputs (" TAGS ", stdout
);
19393 /* XXX Print content of info word? */
19397 fputs (" HWAND ", stdout
);
19398 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
19399 fputs (" R4KEOP_CHECKED", stdout
);
19400 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
19401 fputs (" R4KEOP_CLEAN", stdout
);
19405 fputs (" HWOR ", stdout
);
19406 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
19407 fputs (" R4KEOP_CHECKED", stdout
);
19408 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
19409 fputs (" R4KEOP_CLEAN", stdout
);
19413 printf (" GP_GROUP %#06x self-contained %#06x",
19414 option
.info
& OGP_GROUP
,
19415 (option
.info
& OGP_SELF
) >> 16);
19419 printf (" IDENT %#06x self-contained %#06x",
19420 option
.info
& OGP_GROUP
,
19421 (option
.info
& OGP_SELF
) >> 16);
19425 /* This shouldn't happen. */
19426 printf (" %3d ??? %" PRId16
" %" PRIx32
,
19427 option
.kind
, option
.section
, option
.info
);
19431 len
= sizeof (* eopt
);
19432 while (len
< option
.size
)
19434 unsigned char datum
= *((unsigned char *) eoption
+ len
);
19436 if (ISPRINT (datum
))
19437 printf ("%c", datum
);
19439 printf ("\\%03o", datum
);
19442 fputs ("\n", stdout
);
19444 offset
+= option
.size
;
19452 if (conflicts_offset
!= 0 && conflictsno
!= 0)
19454 Elf32_Conflict
* iconf
;
19457 if (filedata
->dynamic_symbols
== NULL
)
19459 error (_("conflict list found without a dynamic symbol table\n"));
19463 /* PR 21345 - print a slightly more helpful error message
19464 if we are sure that the cmalloc will fail. */
19465 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
19467 error (_("Overlarge number of conflicts detected: %zx\n"),
19472 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
19475 error (_("Out of memory allocating space for dynamic conflicts\n"));
19481 Elf32_External_Conflict
* econf32
;
19483 econf32
= (Elf32_External_Conflict
*)
19484 get_data (NULL
, filedata
, conflicts_offset
,
19485 sizeof (*econf32
), conflictsno
, _("conflict"));
19492 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
19493 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
19499 Elf64_External_Conflict
* econf64
;
19501 econf64
= (Elf64_External_Conflict
*)
19502 get_data (NULL
, filedata
, conflicts_offset
,
19503 sizeof (*econf64
), conflictsno
, _("conflict"));
19510 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
19511 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
19516 printf (ngettext ("\nSection '.conflict' contains %zu entry:\n",
19517 "\nSection '.conflict' contains %zu entries:\n",
19520 puts (_(" Num: Index Value Name"));
19522 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
19524 printf ("%5zu: %8lu ", cnt
, iconf
[cnt
]);
19526 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
19527 printf (_("<corrupt symbol index>"));
19530 Elf_Internal_Sym
* psym
;
19532 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
19533 print_vma (psym
->st_value
, FULL_HEX
);
19535 if (valid_dynamic_name (filedata
, psym
->st_name
))
19536 print_symbol (25, get_dynamic_name (filedata
, psym
->st_name
));
19538 printf (_("<corrupt: %14ld>"), psym
->st_name
);
19546 if (pltgot
!= 0 && local_gotno
!= 0)
19548 uint64_t ent
, local_end
, global_end
;
19550 unsigned char * data
;
19551 unsigned char * data_end
;
19555 addr_size
= (is_32bit_elf
? 4 : 8);
19556 local_end
= pltgot
+ local_gotno
* addr_size
;
19558 /* PR binutils/17533 file: 012-111227-0.004 */
19559 if (symtabno
< gotsym
)
19561 error (_("The GOT symbol offset (%" PRIu64
19562 ") is greater than the symbol table size (%" PRIu64
")\n"),
19567 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
19568 /* PR 17531: file: 54c91a34. */
19569 if (global_end
< local_end
)
19571 error (_("Too many GOT symbols: %" PRIu64
"\n"), symtabno
);
19575 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
19576 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
19577 global_end
- pltgot
, 1,
19578 _("Global Offset Table data"));
19579 /* PR 12855: Null data is handled gracefully throughout. */
19580 data_end
= data
+ (global_end
- pltgot
);
19582 printf (_("\nPrimary GOT:\n"));
19583 printf (_(" Canonical gp value: "));
19584 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
19587 printf (_(" Reserved entries:\n"));
19588 printf (_(" %*s %10s %*s Purpose\n"),
19589 addr_size
* 2, _("Address"), _("Access"),
19590 addr_size
* 2, _("Initial"));
19591 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19592 printf (_(" Lazy resolver\n"));
19593 if (ent
== (uint64_t) -1)
19594 goto got_print_fail
;
19596 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
19597 This entry will be used by some runtime loaders, to store the
19598 module pointer. Otherwise this is an ordinary local entry.
19599 PR 21344: Check for the entry being fully available before
19602 && data
+ ent
- pltgot
+ addr_size
<= data_end
19603 && (byte_get (data
+ ent
- pltgot
, addr_size
)
19604 >> (addr_size
* 8 - 1)) != 0)
19606 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19607 printf (_(" Module pointer (GNU extension)\n"));
19608 if (ent
== (uint64_t) -1)
19609 goto got_print_fail
;
19613 if (data
!= NULL
&& ent
< local_end
)
19615 printf (_(" Local entries:\n"));
19616 printf (" %*s %10s %*s\n",
19617 addr_size
* 2, _("Address"), _("Access"),
19618 addr_size
* 2, _("Initial"));
19619 while (ent
< local_end
)
19621 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19623 if (ent
== (uint64_t) -1)
19624 goto got_print_fail
;
19629 if (data
!= NULL
&& gotsym
< symtabno
)
19633 printf (_(" Global entries:\n"));
19634 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
19635 addr_size
* 2, _("Address"),
19637 addr_size
* 2, _("Initial"),
19638 addr_size
* 2, _("Sym.Val."),
19640 /* Note for translators: "Ndx" = abbreviated form of "Index". */
19641 _("Ndx"), _("Name"));
19643 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
19645 for (i
= gotsym
; i
< symtabno
; i
++)
19647 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19650 if (filedata
->dynamic_symbols
== NULL
)
19651 printf (_("<no dynamic symbols>"));
19652 else if (i
< filedata
->num_dynamic_syms
)
19654 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
19656 print_vma (psym
->st_value
, LONG_HEX
);
19657 printf (" %-7s %3s ",
19658 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
19659 get_symbol_index_type (filedata
, psym
->st_shndx
));
19661 if (valid_dynamic_name (filedata
, psym
->st_name
))
19662 print_symbol (sym_width
,
19663 get_dynamic_name (filedata
, psym
->st_name
));
19665 printf (_("<corrupt: %14ld>"), psym
->st_name
);
19668 printf (_("<symbol index %zu exceeds number of dynamic symbols>"),
19672 if (ent
== (uint64_t) -1)
19682 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
19685 uint64_t offset
, rel_offset
;
19687 unsigned char * data
;
19688 int addr_size
, sym_width
;
19689 Elf_Internal_Rela
* rels
;
19691 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
19692 if (pltrel
== DT_RELA
)
19694 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
19699 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
19704 addr_size
= (is_32bit_elf
? 4 : 8);
19705 end
= mips_pltgot
+ (2 + count
) * addr_size
;
19707 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
19708 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
19709 1, _("Procedure Linkage Table data"));
19716 printf ("\nPLT GOT:\n\n");
19717 printf (_(" Reserved entries:\n"));
19718 printf (_(" %*s %*s Purpose\n"),
19719 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
19720 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
19721 printf (_(" PLT lazy resolver\n"));
19722 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
19723 printf (_(" Module pointer\n"));
19726 printf (_(" Entries:\n"));
19727 printf (" %*s %*s %*s %-7s %3s %s\n",
19728 addr_size
* 2, _("Address"),
19729 addr_size
* 2, _("Initial"),
19730 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
19731 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
19732 for (i
= 0; i
< count
; i
++)
19734 uint64_t idx
= get_reloc_symindex (rels
[i
].r_info
);
19736 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
19739 if (idx
>= filedata
->num_dynamic_syms
)
19740 printf (_("<corrupt symbol index: %" PRIu64
">"), idx
);
19743 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
19745 print_vma (psym
->st_value
, LONG_HEX
);
19746 printf (" %-7s %3s ",
19747 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
19748 get_symbol_index_type (filedata
, psym
->st_shndx
));
19749 if (valid_dynamic_name (filedata
, psym
->st_name
))
19750 print_symbol (sym_width
,
19751 get_dynamic_name (filedata
, psym
->st_name
));
19753 printf (_("<corrupt: %14ld>"), psym
->st_name
);
19767 process_nds32_specific (Filedata
* filedata
)
19769 Elf_Internal_Shdr
*sect
= NULL
;
19771 sect
= find_section (filedata
, ".nds32_e_flags");
19772 if (sect
!= NULL
&& sect
->sh_size
>= 4)
19774 unsigned char *buf
;
19777 printf ("\nNDS32 elf flags section:\n");
19778 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
19779 _("NDS32 elf flags section"));
19784 flag
= byte_get (buf
, 4);
19786 switch (flag
& 0x3)
19789 printf ("(VEC_SIZE):\tNo entry.\n");
19792 printf ("(VEC_SIZE):\t4 bytes\n");
19795 printf ("(VEC_SIZE):\t16 bytes\n");
19798 printf ("(VEC_SIZE):\treserved\n");
19807 process_gnu_liblist (Filedata
* filedata
)
19809 Elf_Internal_Shdr
* section
;
19810 Elf_Internal_Shdr
* string_sec
;
19811 Elf32_External_Lib
* elib
;
19813 size_t strtab_size
;
19815 uint64_t num_liblist
;
19822 for (i
= 0, section
= filedata
->section_headers
;
19823 i
< filedata
->file_header
.e_shnum
;
19826 switch (section
->sh_type
)
19828 case SHT_GNU_LIBLIST
:
19829 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
19832 elib
= (Elf32_External_Lib
*)
19833 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
19834 _("liblist section data"));
19842 string_sec
= filedata
->section_headers
+ section
->sh_link
;
19843 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
19844 string_sec
->sh_size
,
19845 _("liblist string table"));
19847 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
19854 strtab_size
= string_sec
->sh_size
;
19856 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
19857 printf (ngettext ("\nLibrary list section '%s' contains %" PRIu64
19859 "\nLibrary list section '%s' contains %" PRIu64
19862 printable_section_name (filedata
, section
),
19865 puts (_(" Library Time Stamp Checksum Version Flags"));
19867 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
19875 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
19876 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
19877 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
19878 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
19879 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
19881 tmp
= gmtime (&atime
);
19882 snprintf (timebuf
, sizeof (timebuf
),
19883 "%04u-%02u-%02uT%02u:%02u:%02u",
19884 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
19885 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
19887 printf ("%3zu: ", cnt
);
19889 printf ("%-20s", liblist
.l_name
< strtab_size
19890 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
19892 printf ("%-20.20s", liblist
.l_name
< strtab_size
19893 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
19894 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
19895 liblist
.l_version
, liblist
.l_flags
);
19906 static const char *
19907 get_note_type (Filedata
* filedata
, unsigned e_type
)
19909 static char buff
[64];
19911 if (filedata
->file_header
.e_type
== ET_CORE
)
19915 return _("NT_AUXV (auxiliary vector)");
19917 return _("NT_PRSTATUS (prstatus structure)");
19919 return _("NT_FPREGSET (floating point registers)");
19921 return _("NT_PRPSINFO (prpsinfo structure)");
19922 case NT_TASKSTRUCT
:
19923 return _("NT_TASKSTRUCT (task structure)");
19925 return _("NT_GDB_TDESC (GDB XML target description)");
19927 return _("NT_PRXFPREG (user_xfpregs structure)");
19929 return _("NT_PPC_VMX (ppc Altivec registers)");
19931 return _("NT_PPC_VSX (ppc VSX registers)");
19933 return _("NT_PPC_TAR (ppc TAR register)");
19935 return _("NT_PPC_PPR (ppc PPR register)");
19937 return _("NT_PPC_DSCR (ppc DSCR register)");
19939 return _("NT_PPC_EBB (ppc EBB registers)");
19941 return _("NT_PPC_PMU (ppc PMU registers)");
19942 case NT_PPC_TM_CGPR
:
19943 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
19944 case NT_PPC_TM_CFPR
:
19945 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
19946 case NT_PPC_TM_CVMX
:
19947 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
19948 case NT_PPC_TM_CVSX
:
19949 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
19950 case NT_PPC_TM_SPR
:
19951 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
19952 case NT_PPC_TM_CTAR
:
19953 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
19954 case NT_PPC_TM_CPPR
:
19955 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
19956 case NT_PPC_TM_CDSCR
:
19957 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
19959 return _("NT_386_TLS (x86 TLS information)");
19960 case NT_386_IOPERM
:
19961 return _("NT_386_IOPERM (x86 I/O permissions)");
19962 case NT_X86_XSTATE
:
19963 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
19965 return _("NT_X86_CET (x86 CET state)");
19966 case NT_S390_HIGH_GPRS
:
19967 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
19968 case NT_S390_TIMER
:
19969 return _("NT_S390_TIMER (s390 timer register)");
19970 case NT_S390_TODCMP
:
19971 return _("NT_S390_TODCMP (s390 TOD comparator register)");
19972 case NT_S390_TODPREG
:
19973 return _("NT_S390_TODPREG (s390 TOD programmable register)");
19975 return _("NT_S390_CTRS (s390 control registers)");
19976 case NT_S390_PREFIX
:
19977 return _("NT_S390_PREFIX (s390 prefix register)");
19978 case NT_S390_LAST_BREAK
:
19979 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
19980 case NT_S390_SYSTEM_CALL
:
19981 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
19983 return _("NT_S390_TDB (s390 transaction diagnostic block)");
19984 case NT_S390_VXRS_LOW
:
19985 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
19986 case NT_S390_VXRS_HIGH
:
19987 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
19988 case NT_S390_GS_CB
:
19989 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
19990 case NT_S390_GS_BC
:
19991 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
19993 return _("NT_ARM_VFP (arm VFP registers)");
19995 return _("NT_ARM_TLS (AArch TLS registers)");
19996 case NT_ARM_HW_BREAK
:
19997 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
19998 case NT_ARM_HW_WATCH
:
19999 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
20000 case NT_ARM_SYSTEM_CALL
:
20001 return _("NT_ARM_SYSTEM_CALL (AArch system call number)");
20003 return _("NT_ARM_SVE (AArch SVE registers)");
20004 case NT_ARM_PAC_MASK
:
20005 return _("NT_ARM_PAC_MASK (AArch pointer authentication code masks)");
20006 case NT_ARM_PACA_KEYS
:
20007 return _("NT_ARM_PACA_KEYS (ARM pointer authentication address keys)");
20008 case NT_ARM_PACG_KEYS
:
20009 return _("NT_ARM_PACG_KEYS (ARM pointer authentication generic keys)");
20010 case NT_ARM_TAGGED_ADDR_CTRL
:
20011 return _("NT_ARM_TAGGED_ADDR_CTRL (AArch tagged address control)");
20013 return _("NT_ARM_SSVE (AArch64 streaming SVE registers)");
20015 return _("NT_ARM_ZA (AArch64 SME ZA register)");
20016 case NT_ARM_PAC_ENABLED_KEYS
:
20017 return _("NT_ARM_PAC_ENABLED_KEYS (AArch64 pointer authentication enabled keys)");
20019 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
20021 return _("NT_RISCV_CSR (RISC-V control and status registers)");
20023 return _("NT_PSTATUS (pstatus structure)");
20025 return _("NT_FPREGS (floating point registers)");
20027 return _("NT_PSINFO (psinfo structure)");
20029 return _("NT_LWPSTATUS (lwpstatus_t structure)");
20031 return _("NT_LWPSINFO (lwpsinfo_t structure)");
20032 case NT_WIN32PSTATUS
:
20033 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
20035 return _("NT_SIGINFO (siginfo_t data)");
20037 return _("NT_FILE (mapped files)");
20045 return _("NT_VERSION (version)");
20047 return _("NT_ARCH (architecture)");
20048 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
20050 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
20052 case NT_GO_BUILDID
:
20053 return _("GO BUILDID");
20054 case FDO_PACKAGING_METADATA
:
20055 return _("FDO_PACKAGING_METADATA");
20060 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
20065 print_core_note (Elf_Internal_Note
*pnote
)
20067 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
20068 uint64_t count
, page_size
;
20069 unsigned char *descdata
, *filenames
, *descend
;
20071 if (pnote
->type
!= NT_FILE
)
20080 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
20081 /* Still "successful". */
20085 if (pnote
->descsz
< 2 * addr_size
)
20087 error (_(" Malformed note - too short for header\n"));
20091 descdata
= (unsigned char *) pnote
->descdata
;
20092 descend
= descdata
+ pnote
->descsz
;
20094 if (descdata
[pnote
->descsz
- 1] != '\0')
20096 error (_(" Malformed note - does not end with \\0\n"));
20100 count
= byte_get (descdata
, addr_size
);
20101 descdata
+= addr_size
;
20103 page_size
= byte_get (descdata
, addr_size
);
20104 descdata
+= addr_size
;
20106 if (count
> ((uint64_t) -1 - 2 * addr_size
) / (3 * addr_size
)
20107 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
20109 error (_(" Malformed note - too short for supplied file count\n"));
20113 printf (_(" Page size: "));
20114 print_vma (page_size
, DEC
);
20117 printf (_(" %*s%*s%*s\n"),
20118 (int) (2 + 2 * addr_size
), _("Start"),
20119 (int) (4 + 2 * addr_size
), _("End"),
20120 (int) (4 + 2 * addr_size
), _("Page Offset"));
20121 filenames
= descdata
+ count
* 3 * addr_size
;
20122 while (count
-- > 0)
20124 uint64_t start
, end
, file_ofs
;
20126 if (filenames
== descend
)
20128 error (_(" Malformed note - filenames end too early\n"));
20132 start
= byte_get (descdata
, addr_size
);
20133 descdata
+= addr_size
;
20134 end
= byte_get (descdata
, addr_size
);
20135 descdata
+= addr_size
;
20136 file_ofs
= byte_get (descdata
, addr_size
);
20137 descdata
+= addr_size
;
20140 print_vma (start
, FULL_HEX
);
20142 print_vma (end
, FULL_HEX
);
20144 print_vma (file_ofs
, FULL_HEX
);
20145 printf ("\n %s\n", filenames
);
20147 filenames
+= 1 + strlen ((char *) filenames
);
20153 static const char *
20154 get_gnu_elf_note_type (unsigned e_type
)
20156 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
20159 case NT_GNU_ABI_TAG
:
20160 return _("NT_GNU_ABI_TAG (ABI version tag)");
20162 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
20163 case NT_GNU_BUILD_ID
:
20164 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
20165 case NT_GNU_GOLD_VERSION
:
20166 return _("NT_GNU_GOLD_VERSION (gold version)");
20167 case NT_GNU_PROPERTY_TYPE_0
:
20168 return _("NT_GNU_PROPERTY_TYPE_0");
20169 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
20170 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
20171 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
20172 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
20175 static char buff
[64];
20177 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
20184 decode_x86_compat_isa (unsigned int bitmask
)
20188 unsigned int bit
= bitmask
& (- bitmask
);
20193 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
20196 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
20199 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
20202 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
20205 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
20208 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
20211 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
20214 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
20217 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
20220 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
20223 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
20226 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
20227 printf ("AVX512F");
20229 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
20230 printf ("AVX512CD");
20232 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
20233 printf ("AVX512ER");
20235 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
20236 printf ("AVX512PF");
20238 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
20239 printf ("AVX512VL");
20241 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
20242 printf ("AVX512DQ");
20244 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
20245 printf ("AVX512BW");
20248 printf (_("<unknown: %x>"), bit
);
20257 decode_x86_compat_2_isa (unsigned int bitmask
)
20261 printf (_("<None>"));
20267 unsigned int bit
= bitmask
& (- bitmask
);
20272 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_CMOV
:
20275 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE
:
20278 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE2
:
20281 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE3
:
20284 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSSE3
:
20287 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_1
:
20290 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_2
:
20293 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX
:
20296 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX2
:
20299 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_FMA
:
20302 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512F
:
20303 printf ("AVX512F");
20305 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512CD
:
20306 printf ("AVX512CD");
20308 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512ER
:
20309 printf ("AVX512ER");
20311 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512PF
:
20312 printf ("AVX512PF");
20314 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512VL
:
20315 printf ("AVX512VL");
20317 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512DQ
:
20318 printf ("AVX512DQ");
20320 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512BW
:
20321 printf ("AVX512BW");
20323 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4FMAPS
:
20324 printf ("AVX512_4FMAPS");
20326 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4VNNIW
:
20327 printf ("AVX512_4VNNIW");
20329 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BITALG
:
20330 printf ("AVX512_BITALG");
20332 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_IFMA
:
20333 printf ("AVX512_IFMA");
20335 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI
:
20336 printf ("AVX512_VBMI");
20338 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI2
:
20339 printf ("AVX512_VBMI2");
20341 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VNNI
:
20342 printf ("AVX512_VNNI");
20344 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BF16
:
20345 printf ("AVX512_BF16");
20348 printf (_("<unknown: %x>"), bit
);
20356 static const char *
20357 get_amdgpu_elf_note_type (unsigned int e_type
)
20361 case NT_AMDGPU_METADATA
:
20362 return _("NT_AMDGPU_METADATA (code object metadata)");
20365 static char buf
[64];
20366 snprintf (buf
, sizeof (buf
), _("Unknown note type: (0x%08x)"), e_type
);
20373 decode_x86_isa (unsigned int bitmask
)
20377 unsigned int bit
= bitmask
& (- bitmask
);
20382 case GNU_PROPERTY_X86_ISA_1_BASELINE
:
20383 printf ("x86-64-baseline");
20385 case GNU_PROPERTY_X86_ISA_1_V2
:
20386 printf ("x86-64-v2");
20388 case GNU_PROPERTY_X86_ISA_1_V3
:
20389 printf ("x86-64-v3");
20391 case GNU_PROPERTY_X86_ISA_1_V4
:
20392 printf ("x86-64-v4");
20395 printf (_("<unknown: %x>"), bit
);
20404 decode_x86_feature_1 (unsigned int bitmask
)
20408 printf (_("<None>"));
20414 unsigned int bit
= bitmask
& (- bitmask
);
20419 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
20422 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
20425 case GNU_PROPERTY_X86_FEATURE_1_LAM_U48
:
20426 printf ("LAM_U48");
20428 case GNU_PROPERTY_X86_FEATURE_1_LAM_U57
:
20429 printf ("LAM_U57");
20432 printf (_("<unknown: %x>"), bit
);
20441 decode_x86_feature_2 (unsigned int bitmask
)
20445 printf (_("<None>"));
20451 unsigned int bit
= bitmask
& (- bitmask
);
20456 case GNU_PROPERTY_X86_FEATURE_2_X86
:
20459 case GNU_PROPERTY_X86_FEATURE_2_X87
:
20462 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
20465 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
20468 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
20471 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
20474 case GNU_PROPERTY_X86_FEATURE_2_TMM
:
20477 case GNU_PROPERTY_X86_FEATURE_2_MASK
:
20480 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
20483 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
20486 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
20487 printf ("XSAVEOPT");
20489 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
20493 printf (_("<unknown: %x>"), bit
);
20502 decode_aarch64_feature_1_and (unsigned int bitmask
)
20506 unsigned int bit
= bitmask
& (- bitmask
);
20511 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
20515 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
20520 printf (_("<unknown: %x>"), bit
);
20529 decode_1_needed (unsigned int bitmask
)
20533 unsigned int bit
= bitmask
& (- bitmask
);
20538 case GNU_PROPERTY_1_NEEDED_INDIRECT_EXTERN_ACCESS
:
20539 printf ("indirect external access");
20542 printf (_("<unknown: %x>"), bit
);
20551 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
20553 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
20554 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
20555 unsigned int size
= is_32bit_elf
? 4 : 8;
20557 printf (_(" Properties: "));
20559 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
20561 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
20565 while (ptr
< ptr_end
)
20569 unsigned int datasz
;
20571 if ((size_t) (ptr_end
- ptr
) < 8)
20573 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
20577 type
= byte_get (ptr
, 4);
20578 datasz
= byte_get (ptr
+ 4, 4);
20582 if (datasz
> (size_t) (ptr_end
- ptr
))
20584 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
20589 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
20591 if (filedata
->file_header
.e_machine
== EM_X86_64
20592 || filedata
->file_header
.e_machine
== EM_IAMCU
20593 || filedata
->file_header
.e_machine
== EM_386
)
20595 unsigned int bitmask
;
20598 bitmask
= byte_get (ptr
, 4);
20604 case GNU_PROPERTY_X86_ISA_1_USED
:
20606 printf (_("x86 ISA used: <corrupt length: %#x> "),
20610 printf ("x86 ISA used: ");
20611 decode_x86_isa (bitmask
);
20615 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
20617 printf (_("x86 ISA needed: <corrupt length: %#x> "),
20621 printf ("x86 ISA needed: ");
20622 decode_x86_isa (bitmask
);
20626 case GNU_PROPERTY_X86_FEATURE_1_AND
:
20628 printf (_("x86 feature: <corrupt length: %#x> "),
20632 printf ("x86 feature: ");
20633 decode_x86_feature_1 (bitmask
);
20637 case GNU_PROPERTY_X86_FEATURE_2_USED
:
20639 printf (_("x86 feature used: <corrupt length: %#x> "),
20643 printf ("x86 feature used: ");
20644 decode_x86_feature_2 (bitmask
);
20648 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
20650 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
20653 printf ("x86 feature needed: ");
20654 decode_x86_feature_2 (bitmask
);
20658 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
20660 printf (_("x86 ISA used: <corrupt length: %#x> "),
20664 printf ("x86 ISA used: ");
20665 decode_x86_compat_isa (bitmask
);
20669 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
20671 printf (_("x86 ISA needed: <corrupt length: %#x> "),
20675 printf ("x86 ISA needed: ");
20676 decode_x86_compat_isa (bitmask
);
20680 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_USED
:
20682 printf (_("x86 ISA used: <corrupt length: %#x> "),
20686 printf ("x86 ISA used: ");
20687 decode_x86_compat_2_isa (bitmask
);
20691 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_NEEDED
:
20693 printf (_("x86 ISA needed: <corrupt length: %#x> "),
20697 printf ("x86 ISA needed: ");
20698 decode_x86_compat_2_isa (bitmask
);
20706 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
20708 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
20710 printf ("AArch64 feature: ");
20712 printf (_("<corrupt length: %#x> "), datasz
);
20714 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
20723 case GNU_PROPERTY_STACK_SIZE
:
20724 printf (_("stack size: "));
20725 if (datasz
!= size
)
20726 printf (_("<corrupt length: %#x> "), datasz
);
20728 printf ("%#" PRIx64
, byte_get (ptr
, size
));
20731 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
20732 printf ("no copy on protected ");
20734 printf (_("<corrupt length: %#x> "), datasz
);
20738 if ((type
>= GNU_PROPERTY_UINT32_AND_LO
20739 && type
<= GNU_PROPERTY_UINT32_AND_HI
)
20740 || (type
>= GNU_PROPERTY_UINT32_OR_LO
20741 && type
<= GNU_PROPERTY_UINT32_OR_HI
))
20745 case GNU_PROPERTY_1_NEEDED
:
20747 printf (_("1_needed: <corrupt length: %#x> "),
20751 unsigned int bitmask
= byte_get (ptr
, 4);
20752 printf ("1_needed: ");
20753 decode_1_needed (bitmask
);
20760 if (type
<= GNU_PROPERTY_UINT32_AND_HI
)
20761 printf (_("UINT32_AND (%#x): "), type
);
20763 printf (_("UINT32_OR (%#x): "), type
);
20765 printf (_("<corrupt length: %#x> "), datasz
);
20767 printf ("%#x", (unsigned int) byte_get (ptr
, 4));
20774 if (type
< GNU_PROPERTY_LOPROC
)
20775 printf (_("<unknown type %#x data: "), type
);
20776 else if (type
< GNU_PROPERTY_LOUSER
)
20777 printf (_("<processor-specific type %#x data: "), type
);
20779 printf (_("<application-specific type %#x data: "), type
);
20780 for (j
= 0; j
< datasz
; ++j
)
20781 printf ("%02x ", ptr
[j
] & 0xff);
20785 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
20786 if (ptr
== ptr_end
)
20799 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
20801 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
20802 switch (pnote
->type
)
20804 case NT_GNU_BUILD_ID
:
20808 printf (_(" Build ID: "));
20809 for (i
= 0; i
< pnote
->descsz
; ++i
)
20810 printf ("%02x", pnote
->descdata
[i
] & 0xff);
20815 case NT_GNU_ABI_TAG
:
20817 unsigned int os
, major
, minor
, subminor
;
20818 const char *osname
;
20820 /* PR 17531: file: 030-599401-0.004. */
20821 if (pnote
->descsz
< 16)
20823 printf (_(" <corrupt GNU_ABI_TAG>\n"));
20827 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20828 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
20829 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
20830 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
20834 case GNU_ABI_TAG_LINUX
:
20837 case GNU_ABI_TAG_HURD
:
20840 case GNU_ABI_TAG_SOLARIS
:
20841 osname
= "Solaris";
20843 case GNU_ABI_TAG_FREEBSD
:
20844 osname
= "FreeBSD";
20846 case GNU_ABI_TAG_NETBSD
:
20849 case GNU_ABI_TAG_SYLLABLE
:
20850 osname
= "Syllable";
20852 case GNU_ABI_TAG_NACL
:
20856 osname
= "Unknown";
20860 printf (_(" OS: %s, ABI: %d.%d.%d\n"), osname
,
20861 major
, minor
, subminor
);
20865 case NT_GNU_GOLD_VERSION
:
20869 printf (_(" Version: "));
20870 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
20871 printf ("%c", pnote
->descdata
[i
]);
20878 unsigned int num_entries
, mask
;
20880 /* Hardware capabilities information. Word 0 is the number of entries.
20881 Word 1 is a bitmask of enabled entries. The rest of the descriptor
20882 is a series of entries, where each entry is a single byte followed
20883 by a nul terminated string. The byte gives the bit number to test
20884 if enabled in the bitmask. */
20885 printf (_(" Hardware Capabilities: "));
20886 if (pnote
->descsz
< 8)
20888 error (_("<corrupt GNU_HWCAP>\n"));
20891 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20892 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
20893 printf (_("num entries: %d, enabled mask: %x\n"), num_entries
, mask
);
20894 /* FIXME: Add code to display the entries... */
20898 case NT_GNU_PROPERTY_TYPE_0
:
20899 print_gnu_property_note (filedata
, pnote
);
20903 /* Handle unrecognised types. An error message should have already been
20904 created by get_gnu_elf_note_type(), so all that we need to do is to
20905 display the data. */
20909 printf (_(" Description data: "));
20910 for (i
= 0; i
< pnote
->descsz
; ++i
)
20911 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
20920 static const char *
20921 get_v850_elf_note_type (enum v850_notes n_type
)
20923 static char buff
[64];
20927 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
20928 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
20929 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
20930 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
20931 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
20932 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
20934 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
20940 print_v850_note (Elf_Internal_Note
* pnote
)
20944 if (pnote
->descsz
!= 4)
20947 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
20951 printf (_("not set\n"));
20955 switch (pnote
->type
)
20957 case V850_NOTE_ALIGNMENT
:
20960 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return true;
20961 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return true;
20965 case V850_NOTE_DATA_SIZE
:
20968 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return true;
20969 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return true;
20973 case V850_NOTE_FPU_INFO
:
20976 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return true;
20977 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return true;
20981 case V850_NOTE_MMU_INFO
:
20982 case V850_NOTE_CACHE_INFO
:
20983 case V850_NOTE_SIMD_INFO
:
20984 if (val
== EF_RH850_SIMD
)
20986 printf (_("yes\n"));
20992 /* An 'unknown note type' message will already have been displayed. */
20996 printf (_("unknown value: %x\n"), val
);
21001 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
21003 unsigned int version
;
21005 switch (pnote
->type
)
21007 case NT_NETBSD_IDENT
:
21008 if (pnote
->descsz
< 1)
21010 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
21011 if ((version
/ 10000) % 100)
21012 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
21013 version
, version
/ 100000000, (version
/ 1000000) % 100,
21014 (version
/ 10000) % 100 > 26 ? "Z" : "",
21015 'A' + (version
/ 10000) % 26);
21017 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
21018 version
, version
/ 100000000, (version
/ 1000000) % 100,
21019 (version
/ 100) % 100);
21022 case NT_NETBSD_MARCH
:
21023 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
21027 case NT_NETBSD_PAX
:
21028 if (pnote
->descsz
< 1)
21030 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
21031 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
21032 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
21033 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
21034 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
21035 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
21036 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
21037 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
21041 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
21042 pnote
->descsz
, pnote
->type
);
21046 static const char *
21047 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
21051 case NT_FREEBSD_THRMISC
:
21052 return _("NT_THRMISC (thrmisc structure)");
21053 case NT_FREEBSD_PROCSTAT_PROC
:
21054 return _("NT_PROCSTAT_PROC (proc data)");
21055 case NT_FREEBSD_PROCSTAT_FILES
:
21056 return _("NT_PROCSTAT_FILES (files data)");
21057 case NT_FREEBSD_PROCSTAT_VMMAP
:
21058 return _("NT_PROCSTAT_VMMAP (vmmap data)");
21059 case NT_FREEBSD_PROCSTAT_GROUPS
:
21060 return _("NT_PROCSTAT_GROUPS (groups data)");
21061 case NT_FREEBSD_PROCSTAT_UMASK
:
21062 return _("NT_PROCSTAT_UMASK (umask data)");
21063 case NT_FREEBSD_PROCSTAT_RLIMIT
:
21064 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
21065 case NT_FREEBSD_PROCSTAT_OSREL
:
21066 return _("NT_PROCSTAT_OSREL (osreldate data)");
21067 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
21068 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
21069 case NT_FREEBSD_PROCSTAT_AUXV
:
21070 return _("NT_PROCSTAT_AUXV (auxv data)");
21071 case NT_FREEBSD_PTLWPINFO
:
21072 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
21073 case NT_FREEBSD_X86_SEGBASES
:
21074 return _("NT_X86_SEGBASES (x86 segment base registers)");
21076 return get_note_type (filedata
, e_type
);
21079 static const char *
21080 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
21082 static char buff
[64];
21086 case NT_NETBSDCORE_PROCINFO
:
21087 /* NetBSD core "procinfo" structure. */
21088 return _("NetBSD procinfo structure");
21090 case NT_NETBSDCORE_AUXV
:
21091 return _("NetBSD ELF auxiliary vector data");
21093 case NT_NETBSDCORE_LWPSTATUS
:
21094 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
21097 /* As of Jan 2020 there are no other machine-independent notes
21098 defined for NetBSD core files. If the note type is less
21099 than the start of the machine-dependent note types, we don't
21102 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
21104 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
21110 switch (filedata
->file_header
.e_machine
)
21112 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
21113 and PT_GETFPREGS == mach+2. */
21118 case EM_SPARC32PLUS
:
21122 case NT_NETBSDCORE_FIRSTMACH
+ 0:
21123 return _("PT_GETREGS (reg structure)");
21124 case NT_NETBSDCORE_FIRSTMACH
+ 2:
21125 return _("PT_GETFPREGS (fpreg structure)");
21131 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
21132 There's also old PT___GETREGS40 == mach + 1 for old reg
21133 structure which lacks GBR. */
21137 case NT_NETBSDCORE_FIRSTMACH
+ 1:
21138 return _("PT___GETREGS40 (old reg structure)");
21139 case NT_NETBSDCORE_FIRSTMACH
+ 3:
21140 return _("PT_GETREGS (reg structure)");
21141 case NT_NETBSDCORE_FIRSTMACH
+ 5:
21142 return _("PT_GETFPREGS (fpreg structure)");
21148 /* On all other arch's, PT_GETREGS == mach+1 and
21149 PT_GETFPREGS == mach+3. */
21153 case NT_NETBSDCORE_FIRSTMACH
+ 1:
21154 return _("PT_GETREGS (reg structure)");
21155 case NT_NETBSDCORE_FIRSTMACH
+ 3:
21156 return _("PT_GETFPREGS (fpreg structure)");
21162 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
21163 e_type
- NT_NETBSDCORE_FIRSTMACH
);
21167 static const char *
21168 get_openbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
21172 case NT_OPENBSD_PROCINFO
:
21173 return _("OpenBSD procinfo structure");
21174 case NT_OPENBSD_AUXV
:
21175 return _("OpenBSD ELF auxiliary vector data");
21176 case NT_OPENBSD_REGS
:
21177 return _("OpenBSD regular registers");
21178 case NT_OPENBSD_FPREGS
:
21179 return _("OpenBSD floating point registers");
21180 case NT_OPENBSD_WCOOKIE
:
21181 return _("OpenBSD window cookie");
21184 return get_note_type (filedata
, e_type
);
21187 static const char *
21188 get_qnx_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
21192 case QNT_DEBUG_FULLPATH
:
21193 return _("QNX debug fullpath");
21194 case QNT_DEBUG_RELOC
:
21195 return _("QNX debug relocation");
21197 return _("QNX stack");
21198 case QNT_GENERATOR
:
21199 return _("QNX generator");
21200 case QNT_DEFAULT_LIB
:
21201 return _("QNX default library");
21202 case QNT_CORE_SYSINFO
:
21203 return _("QNX core sysinfo");
21204 case QNT_CORE_INFO
:
21205 return _("QNX core info");
21206 case QNT_CORE_STATUS
:
21207 return _("QNX core status");
21208 case QNT_CORE_GREG
:
21209 return _("QNX general registers");
21210 case QNT_CORE_FPREG
:
21211 return _("QNX floating point registers");
21213 return _("QNX link map");
21216 return get_note_type (filedata
, e_type
);
21219 static const char *
21220 get_stapsdt_note_type (unsigned e_type
)
21222 static char buff
[64];
21227 return _("NT_STAPSDT (SystemTap probe descriptors)");
21233 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
21238 print_stapsdt_note (Elf_Internal_Note
*pnote
)
21240 size_t len
, maxlen
;
21241 size_t addr_size
= is_32bit_elf
? 4 : 8;
21242 char *data
= pnote
->descdata
;
21243 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
21244 uint64_t pc
, base_addr
, semaphore
;
21245 char *provider
, *probe
, *arg_fmt
;
21247 if (pnote
->descsz
< (addr_size
* 3))
21248 goto stapdt_note_too_small
;
21250 pc
= byte_get ((unsigned char *) data
, addr_size
);
21253 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
21256 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
21259 if (data
>= data_end
)
21260 goto stapdt_note_too_small
;
21261 maxlen
= data_end
- data
;
21262 len
= strnlen (data
, maxlen
);
21269 goto stapdt_note_too_small
;
21271 if (data
>= data_end
)
21272 goto stapdt_note_too_small
;
21273 maxlen
= data_end
- data
;
21274 len
= strnlen (data
, maxlen
);
21281 goto stapdt_note_too_small
;
21283 if (data
>= data_end
)
21284 goto stapdt_note_too_small
;
21285 maxlen
= data_end
- data
;
21286 len
= strnlen (data
, maxlen
);
21293 goto stapdt_note_too_small
;
21295 printf (_(" Provider: %s\n"), provider
);
21296 printf (_(" Name: %s\n"), probe
);
21297 printf (_(" Location: "));
21298 print_vma (pc
, FULL_HEX
);
21299 printf (_(", Base: "));
21300 print_vma (base_addr
, FULL_HEX
);
21301 printf (_(", Semaphore: "));
21302 print_vma (semaphore
, FULL_HEX
);
21304 printf (_(" Arguments: %s\n"), arg_fmt
);
21306 return data
== data_end
;
21308 stapdt_note_too_small
:
21309 printf (_(" <corrupt - note is too small>\n"));
21310 error (_("corrupt stapdt note - the data size is too small\n"));
21315 print_fdo_note (Elf_Internal_Note
* pnote
)
21317 if (pnote
->descsz
> 0 && pnote
->type
== FDO_PACKAGING_METADATA
)
21319 printf (_(" Packaging Metadata: %.*s\n"), (int) pnote
->descsz
, pnote
->descdata
);
21325 static const char *
21326 get_ia64_vms_note_type (unsigned e_type
)
21328 static char buff
[64];
21333 return _("NT_VMS_MHD (module header)");
21335 return _("NT_VMS_LNM (language name)");
21337 return _("NT_VMS_SRC (source files)");
21339 return "NT_VMS_TITLE";
21341 return _("NT_VMS_EIDC (consistency check)");
21342 case NT_VMS_FPMODE
:
21343 return _("NT_VMS_FPMODE (FP mode)");
21344 case NT_VMS_LINKTIME
:
21345 return "NT_VMS_LINKTIME";
21346 case NT_VMS_IMGNAM
:
21347 return _("NT_VMS_IMGNAM (image name)");
21349 return _("NT_VMS_IMGID (image id)");
21350 case NT_VMS_LINKID
:
21351 return _("NT_VMS_LINKID (link id)");
21352 case NT_VMS_IMGBID
:
21353 return _("NT_VMS_IMGBID (build id)");
21354 case NT_VMS_GSTNAM
:
21355 return _("NT_VMS_GSTNAM (sym table name)");
21356 case NT_VMS_ORIG_DYN
:
21357 return "NT_VMS_ORIG_DYN";
21358 case NT_VMS_PATCHTIME
:
21359 return "NT_VMS_PATCHTIME";
21361 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
21367 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
21369 unsigned int maxlen
= pnote
->descsz
;
21371 if (maxlen
< 2 || maxlen
!= pnote
->descsz
)
21372 goto desc_size_fail
;
21374 switch (pnote
->type
)
21378 goto desc_size_fail
;
21380 size_t l
= strnlen (pnote
->descdata
+ 34, maxlen
- 34);
21382 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
21383 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
21384 if (l
+ 34 < maxlen
)
21386 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
21387 if (l
+ 35 < maxlen
)
21388 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
21390 printf (_(" Module version : <missing>\n"));
21394 printf (_(" Module name : <missing>\n"));
21395 printf (_(" Module version : <missing>\n"));
21400 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
21403 case NT_VMS_FPMODE
:
21404 printf (_(" Floating Point mode: "));
21406 goto desc_size_fail
;
21407 /* FIXME: Generate an error if descsz > 8 ? */
21409 printf ("0x%016" PRIx64
"\n",
21410 byte_get ((unsigned char *) pnote
->descdata
, 8));
21413 case NT_VMS_LINKTIME
:
21414 printf (_(" Link time: "));
21416 goto desc_size_fail
;
21417 /* FIXME: Generate an error if descsz > 8 ? */
21419 print_vms_time (byte_get ((unsigned char *) pnote
->descdata
, 8));
21423 case NT_VMS_PATCHTIME
:
21424 printf (_(" Patch time: "));
21426 goto desc_size_fail
;
21427 /* FIXME: Generate an error if descsz > 8 ? */
21429 print_vms_time (byte_get ((unsigned char *) pnote
->descdata
, 8));
21433 case NT_VMS_ORIG_DYN
:
21435 goto desc_size_fail
;
21437 printf (_(" Major id: %u, minor id: %u\n"),
21438 (unsigned) byte_get ((unsigned char *) pnote
->descdata
, 4),
21439 (unsigned) byte_get ((unsigned char *) pnote
->descdata
+ 4, 4));
21440 printf (_(" Last modified : "));
21441 print_vms_time (byte_get ((unsigned char *) pnote
->descdata
+ 8, 8));
21442 printf (_("\n Link flags : "));
21443 printf ("0x%016" PRIx64
"\n",
21444 byte_get ((unsigned char *) pnote
->descdata
+ 16, 8));
21445 printf (_(" Header flags: 0x%08x\n"),
21446 (unsigned) byte_get ((unsigned char *) pnote
->descdata
+ 24, 4));
21447 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
21450 case NT_VMS_IMGNAM
:
21451 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
21454 case NT_VMS_GSTNAM
:
21455 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
21459 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
21462 case NT_VMS_LINKID
:
21463 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
21473 printf (_(" <corrupt - data size is too small>\n"));
21474 error (_("corrupt IA64 note: data size is too small\n"));
21478 struct build_attr_cache
{
21479 Filedata
*filedata
;
21481 uint64_t strtablen
;
21482 Elf_Internal_Sym
*symtab
;
21486 /* Find the symbol associated with a build attribute that is attached
21487 to address OFFSET. If PNAME is non-NULL then store the name of
21488 the symbol (if found) in the provided pointer, Returns NULL if a
21489 symbol could not be found. */
21491 static Elf_Internal_Sym
*
21492 get_symbol_for_build_attribute (Filedata
*filedata
,
21495 const char **pname
)
21497 Elf_Internal_Sym
*saved_sym
= NULL
;
21498 Elf_Internal_Sym
*sym
;
21500 if (filedata
->section_headers
!= NULL
21501 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
21503 Elf_Internal_Shdr
* symsec
;
21505 free (ba_cache
.strtab
);
21506 ba_cache
.strtab
= NULL
;
21507 free (ba_cache
.symtab
);
21508 ba_cache
.symtab
= NULL
;
21510 /* Load the symbol and string sections. */
21511 for (symsec
= filedata
->section_headers
;
21512 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
21515 if (symsec
->sh_type
== SHT_SYMTAB
21516 && get_symtab (filedata
, symsec
,
21517 &ba_cache
.symtab
, &ba_cache
.nsyms
,
21518 &ba_cache
.strtab
, &ba_cache
.strtablen
))
21521 ba_cache
.filedata
= filedata
;
21524 if (ba_cache
.symtab
== NULL
)
21527 /* Find a symbol whose value matches offset. */
21528 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
21529 if (sym
->st_value
== offset
)
21531 if (sym
->st_name
>= ba_cache
.strtablen
)
21532 /* Huh ? This should not happen. */
21535 if (ba_cache
.strtab
[sym
->st_name
] == 0)
21538 /* The AArch64, ARM and RISC-V architectures define mapping symbols
21539 (eg $d, $x, $t) which we want to ignore. */
21540 if (ba_cache
.strtab
[sym
->st_name
] == '$'
21541 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
21542 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
21547 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
21548 and FILE or OBJECT symbols over NOTYPE symbols. We skip
21549 FUNC symbols entirely. */
21550 switch (ELF_ST_TYPE (sym
->st_info
))
21557 /* If the symbol has a size associated
21558 with it then we can stop searching. */
21559 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
21564 /* Ignore function symbols. */
21571 switch (ELF_ST_BIND (sym
->st_info
))
21574 if (saved_sym
== NULL
21575 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
21580 if (saved_sym
== NULL
)
21590 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
21598 if (saved_sym
&& pname
)
21599 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
21604 /* Returns true iff addr1 and addr2 are in the same section. */
21607 same_section (Filedata
* filedata
, uint64_t addr1
, uint64_t addr2
)
21609 Elf_Internal_Shdr
* a1
;
21610 Elf_Internal_Shdr
* a2
;
21612 a1
= find_section_by_address (filedata
, addr1
);
21613 a2
= find_section_by_address (filedata
, addr2
);
21615 return a1
== a2
&& a1
!= NULL
;
21619 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
21620 Filedata
* filedata
)
21622 static uint64_t global_offset
= 0;
21623 static uint64_t global_end
= 0;
21624 static uint64_t func_offset
= 0;
21625 static uint64_t func_end
= 0;
21627 Elf_Internal_Sym
*sym
;
21631 bool is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
21633 switch (pnote
->descsz
)
21636 /* A zero-length description means that the range of
21637 the previous note of the same type should be used. */
21640 if (global_end
> global_offset
)
21641 printf (_(" Applies to region from %#" PRIx64
21642 " to %#" PRIx64
"\n"), global_offset
, global_end
);
21644 printf (_(" Applies to region from %#" PRIx64
21645 "\n"), global_offset
);
21649 if (func_end
> func_offset
)
21650 printf (_(" Applies to region from %#" PRIx64
21651 " to %#" PRIx64
"\n"), func_offset
, func_end
);
21653 printf (_(" Applies to region from %#" PRIx64
21654 "\n"), func_offset
);
21659 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
21664 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
21665 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
21669 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
21670 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
21674 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
21675 printf (_(" <invalid descsz>"));
21680 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
21681 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
21682 in order to avoid them being confused with the start address of the
21683 first function in the file... */
21684 if (sym
== NULL
&& is_open_attr
)
21685 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
21688 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
21689 end
= start
+ sym
->st_size
;
21693 /* FIXME: Need to properly allow for section alignment.
21694 16 is just the alignment used on x86_64. */
21696 && start
> BFD_ALIGN (global_end
, 16)
21697 /* Build notes are not guaranteed to be organised in order of
21698 increasing address, but we should find the all of the notes
21699 for one section in the same place. */
21700 && same_section (filedata
, start
, global_end
))
21701 warn (_("Gap in build notes detected from %#" PRIx64
21702 " to %#" PRIx64
"\n"),
21703 global_end
+ 1, start
- 1);
21705 printf (_(" Applies to region from %#" PRIx64
), start
);
21706 global_offset
= start
;
21710 printf (_(" to %#" PRIx64
), end
);
21716 printf (_(" Applies to region from %#" PRIx64
), start
);
21717 func_offset
= start
;
21721 printf (_(" to %#" PRIx64
), end
);
21727 printf (_(" (%s)"), name
);
21734 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
21736 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
21737 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
21738 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
21740 char name_attribute
;
21741 const char * expected_types
;
21742 const char * name
= pnote
->namedata
;
21746 if (name
== NULL
|| pnote
->namesz
< 2)
21748 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
21749 print_symbol (-20, _(" <corrupt name>"));
21758 /* Version 2 of the spec adds a "GA" prefix to the name field. */
21759 if (name
[0] == 'G' && name
[1] == 'A')
21761 if (pnote
->namesz
< 4)
21763 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
21764 print_symbol (-20, _(" <corrupt name>"));
21773 switch ((name_type
= * name
))
21775 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
21776 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
21777 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
21778 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
21779 printf ("%c", * name
);
21783 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
21784 print_symbol (-20, _("<unknown name type>"));
21791 switch ((name_attribute
= * name
))
21793 case GNU_BUILD_ATTRIBUTE_VERSION
:
21794 text
= _("<version>");
21795 expected_types
= string_expected
;
21798 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
21799 text
= _("<stack prot>");
21800 expected_types
= "!+*";
21803 case GNU_BUILD_ATTRIBUTE_RELRO
:
21804 text
= _("<relro>");
21805 expected_types
= bool_expected
;
21808 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
21809 text
= _("<stack size>");
21810 expected_types
= number_expected
;
21813 case GNU_BUILD_ATTRIBUTE_TOOL
:
21814 text
= _("<tool>");
21815 expected_types
= string_expected
;
21818 case GNU_BUILD_ATTRIBUTE_ABI
:
21820 expected_types
= "$*";
21823 case GNU_BUILD_ATTRIBUTE_PIC
:
21825 expected_types
= number_expected
;
21828 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
21829 text
= _("<short enum>");
21830 expected_types
= bool_expected
;
21834 if (ISPRINT (* name
))
21836 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
21838 if (len
> left
&& ! do_wide
)
21840 printf ("%.*s:", len
, name
);
21846 static char tmpbuf
[128];
21848 error (_("unrecognised byte in name field: %d\n"), * name
);
21849 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
21853 expected_types
= "*$!+";
21858 left
-= printf ("%s", text
);
21860 if (strchr (expected_types
, name_type
) == NULL
)
21861 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
21863 if ((size_t) (name
- pnote
->namedata
) > pnote
->namesz
)
21865 error (_("corrupt name field: namesz: %lu but parsing gets to %td\n"),
21867 name
- pnote
->namedata
);
21871 if (left
< 1 && ! do_wide
)
21876 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
21878 unsigned int bytes
;
21880 unsigned int shift
= 0;
21881 char *decoded
= NULL
;
21883 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
21885 /* The -1 is because the name field is always 0 terminated, and we
21886 want to be able to ensure that the shift in the while loop below
21887 will not overflow. */
21890 if (bytes
> sizeof (val
))
21892 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
21894 bytes
= sizeof (val
);
21896 /* We do not bother to warn if bytes == 0 as this can
21897 happen with some early versions of the gcc plugin. */
21901 uint64_t byte
= *name
++ & 0xff;
21903 val
|= byte
<< shift
;
21907 switch (name_attribute
)
21909 case GNU_BUILD_ATTRIBUTE_PIC
:
21912 case 0: decoded
= "static"; break;
21913 case 1: decoded
= "pic"; break;
21914 case 2: decoded
= "PIC"; break;
21915 case 3: decoded
= "pie"; break;
21916 case 4: decoded
= "PIE"; break;
21920 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
21923 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
21924 case 0: decoded
= "off"; break;
21925 case 1: decoded
= "on"; break;
21926 case 2: decoded
= "all"; break;
21927 case 3: decoded
= "strong"; break;
21928 case 4: decoded
= "explicit"; break;
21936 if (decoded
!= NULL
)
21938 print_symbol (-left
, decoded
);
21949 left
-= printf ("0x%" PRIx64
, val
);
21951 left
-= printf ("0x%-.*" PRIx64
, left
, val
);
21955 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
21956 left
-= print_symbol (- left
, name
);
21958 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
21959 left
-= print_symbol (- left
, "true");
21961 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
21962 left
-= print_symbol (- left
, "false");
21966 if (do_wide
&& left
> 0)
21967 printf ("%-*s", left
, " ");
21972 /* Print the contents of PNOTE as hex. */
21975 print_note_contents_hex (Elf_Internal_Note
*pnote
)
21981 printf (_(" description data: "));
21982 for (i
= 0; i
< pnote
->descsz
; i
++)
21983 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
21992 #if defined HAVE_MSGPACK
21995 print_indents (int n
)
21999 for (int i
= 0; i
< n
; i
++)
22003 /* Print OBJ in human-readable form. */
22006 dump_msgpack_obj (const msgpack_object
*obj
, int indent
)
22010 case MSGPACK_OBJECT_NIL
:
22014 case MSGPACK_OBJECT_BOOLEAN
:
22015 printf ("%s", obj
->via
.boolean
? "true" : "false");
22018 case MSGPACK_OBJECT_POSITIVE_INTEGER
:
22019 printf ("%" PRIu64
, obj
->via
.u64
);
22022 case MSGPACK_OBJECT_NEGATIVE_INTEGER
:
22023 printf ("%" PRIi64
, obj
->via
.i64
);
22026 case MSGPACK_OBJECT_FLOAT32
:
22027 case MSGPACK_OBJECT_FLOAT64
:
22028 printf ("%f", obj
->via
.f64
);
22031 case MSGPACK_OBJECT_STR
:
22032 printf ("\"%.*s\"", obj
->via
.str
.size
, obj
->via
.str
.ptr
);
22035 case MSGPACK_OBJECT_ARRAY
:
22037 const msgpack_object_array
*array
= &obj
->via
.array
;
22042 for (uint32_t i
= 0; i
< array
->size
; ++i
)
22044 const msgpack_object
*item
= &array
->ptr
[i
];
22046 print_indents (indent
);
22047 dump_msgpack_obj (item
, indent
);
22052 print_indents (indent
);
22058 case MSGPACK_OBJECT_MAP
:
22060 const msgpack_object_map
*map
= &obj
->via
.map
;
22065 for (uint32_t i
= 0; i
< map
->size
; ++i
)
22067 const msgpack_object_kv
*kv
= &map
->ptr
[i
];
22068 const msgpack_object
*key
= &kv
->key
;
22069 const msgpack_object
*val
= &kv
->val
;
22071 print_indents (indent
);
22072 dump_msgpack_obj (key
, indent
);
22074 dump_msgpack_obj (val
, indent
);
22080 print_indents (indent
);
22086 case MSGPACK_OBJECT_BIN
:
22090 case MSGPACK_OBJECT_EXT
:
22097 dump_msgpack (const msgpack_unpacked
*msg
)
22100 dump_msgpack_obj (&msg
->data
, 0);
22104 #endif /* defined HAVE_MSGPACK */
22107 print_amdgpu_note (Elf_Internal_Note
*pnote
)
22109 #if defined HAVE_MSGPACK
22110 /* If msgpack is available, decode and dump the note's content. */
22112 msgpack_unpacked msg
;
22113 msgpack_unpack_return msgpack_ret
;
22115 assert (pnote
->type
== NT_AMDGPU_METADATA
);
22117 msgpack_unpacked_init (&msg
);
22118 msgpack_ret
= msgpack_unpack_next (&msg
, pnote
->descdata
, pnote
->descsz
,
22121 switch (msgpack_ret
)
22123 case MSGPACK_UNPACK_SUCCESS
:
22124 dump_msgpack (&msg
);
22129 error (_("failed to unpack msgpack contents in NT_AMDGPU_METADATA note"));
22134 msgpack_unpacked_destroy (&msg
);
22137 /* msgpack is not available, dump contents as hex. */
22138 print_note_contents_hex (pnote
);
22144 print_qnx_note (Elf_Internal_Note
*pnote
)
22146 switch (pnote
->type
)
22149 if (pnote
->descsz
!= 12)
22150 goto desc_size_fail
;
22152 printf (_(" Stack Size: 0x%" PRIx32
"\n"),
22153 (unsigned) byte_get ((unsigned char *) pnote
->descdata
, 4));
22154 printf (_(" Stack allocated: %" PRIx32
"\n"),
22155 (unsigned) byte_get ((unsigned char *) pnote
->descdata
+ 4, 4));
22156 printf (_(" Executable: %s\n"),
22157 ((unsigned) byte_get ((unsigned char *) pnote
->descdata
+ 8, 1)) ? "no": "yes");
22161 print_note_contents_hex(pnote
);
22166 printf (_(" <corrupt - data size is too small>\n"));
22167 error (_("corrupt QNX note: data size is too small\n"));
22172 /* Note that by the ELF standard, the name field is already null byte
22173 terminated, and namesz includes the terminating null byte.
22174 I.E. the value of namesz for the name "FSF" is 4.
22176 If the value of namesz is zero, there is no name present. */
22179 process_note (Elf_Internal_Note
* pnote
,
22180 Filedata
* filedata
)
22182 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
22185 if (pnote
->namesz
== 0)
22186 /* If there is no note name, then use the default set of
22187 note type strings. */
22188 nt
= get_note_type (filedata
, pnote
->type
);
22190 else if (startswith (pnote
->namedata
, "GNU"))
22191 /* GNU-specific object file notes. */
22192 nt
= get_gnu_elf_note_type (pnote
->type
);
22194 else if (startswith (pnote
->namedata
, "AMDGPU"))
22195 /* AMDGPU-specific object file notes. */
22196 nt
= get_amdgpu_elf_note_type (pnote
->type
);
22198 else if (startswith (pnote
->namedata
, "FreeBSD"))
22199 /* FreeBSD-specific core file notes. */
22200 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
22202 else if (startswith (pnote
->namedata
, "NetBSD-CORE"))
22203 /* NetBSD-specific core file notes. */
22204 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
22206 else if (startswith (pnote
->namedata
, "NetBSD"))
22207 /* NetBSD-specific core file notes. */
22208 return process_netbsd_elf_note (pnote
);
22210 else if (startswith (pnote
->namedata
, "PaX"))
22211 /* NetBSD-specific core file notes. */
22212 return process_netbsd_elf_note (pnote
);
22214 else if (startswith (pnote
->namedata
, "OpenBSD"))
22215 /* OpenBSD-specific core file notes. */
22216 nt
= get_openbsd_elfcore_note_type (filedata
, pnote
->type
);
22218 else if (startswith (pnote
->namedata
, "QNX"))
22219 /* QNX-specific core file notes. */
22220 nt
= get_qnx_elfcore_note_type (filedata
, pnote
->type
);
22222 else if (startswith (pnote
->namedata
, "SPU/"))
22224 /* SPU-specific core file notes. */
22225 nt
= pnote
->namedata
+ 4;
22229 else if (startswith (pnote
->namedata
, "IPF/VMS"))
22230 /* VMS/ia64-specific file notes. */
22231 nt
= get_ia64_vms_note_type (pnote
->type
);
22233 else if (startswith (pnote
->namedata
, "stapsdt"))
22234 nt
= get_stapsdt_note_type (pnote
->type
);
22237 /* Don't recognize this note name; just use the default set of
22238 note type strings. */
22239 nt
= get_note_type (filedata
, pnote
->type
);
22243 if (((startswith (pnote
->namedata
, "GA")
22244 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
22245 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
22246 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
22247 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
22248 print_gnu_build_attribute_name (pnote
);
22250 print_symbol (-20, name
);
22253 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
22255 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
22257 if (startswith (pnote
->namedata
, "IPF/VMS"))
22258 return print_ia64_vms_note (pnote
);
22259 else if (startswith (pnote
->namedata
, "GNU"))
22260 return print_gnu_note (filedata
, pnote
);
22261 else if (startswith (pnote
->namedata
, "stapsdt"))
22262 return print_stapsdt_note (pnote
);
22263 else if (startswith (pnote
->namedata
, "CORE"))
22264 return print_core_note (pnote
);
22265 else if (startswith (pnote
->namedata
, "FDO"))
22266 return print_fdo_note (pnote
);
22267 else if (((startswith (pnote
->namedata
, "GA")
22268 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
22269 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
22270 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
22271 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
22272 return print_gnu_build_attribute_description (pnote
, filedata
);
22273 else if (startswith (pnote
->namedata
, "AMDGPU")
22274 && pnote
->type
== NT_AMDGPU_METADATA
)
22275 return print_amdgpu_note (pnote
);
22276 else if (startswith (pnote
->namedata
, "QNX"))
22277 return print_qnx_note (pnote
);
22279 print_note_contents_hex (pnote
);
22284 process_notes_at (Filedata
* filedata
,
22285 Elf_Internal_Shdr
* section
,
22290 Elf_External_Note
*pnotes
;
22291 Elf_External_Note
*external
;
22300 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
22303 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
22311 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
22314 if (pnotes
== NULL
)
22319 if (filedata
->is_separate
)
22320 printf (_("In linked file '%s': "), filedata
->file_name
);
22324 printf (_("Displaying notes found in: %s\n"), printable_section_name (filedata
, section
));
22326 printf (_("Displaying notes found at file offset 0x%08" PRIx64
22327 " with length 0x%08" PRIx64
":\n"),
22330 /* NB: Some note sections may have alignment value of 0 or 1. gABI
22331 specifies that notes should be aligned to 4 bytes in 32-bit
22332 objects and to 8 bytes in 64-bit objects. As a Linux extension,
22333 we also support 4 byte alignment in 64-bit objects. If section
22334 alignment is less than 4, we treate alignment as 4 bytes. */
22337 else if (align
!= 4 && align
!= 8)
22339 warn (_("Corrupt note: alignment %" PRId64
", expecting 4 or 8\n"),
22345 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
22347 end
= (char *) pnotes
+ length
;
22348 while ((char *) external
< end
)
22350 Elf_Internal_Note inote
;
22353 char * temp
= NULL
;
22354 size_t data_remaining
= end
- (char *) external
;
22356 if (!is_ia64_vms (filedata
))
22358 /* PR binutils/15191
22359 Make sure that there is enough data to read. */
22360 min_notesz
= offsetof (Elf_External_Note
, name
);
22361 if (data_remaining
< min_notesz
)
22363 warn (ngettext ("Corrupt note: only %zd byte remains, "
22364 "not enough for a full note\n",
22365 "Corrupt note: only %zd bytes remain, "
22366 "not enough for a full note\n",
22371 data_remaining
-= min_notesz
;
22373 inote
.type
= BYTE_GET (external
->type
);
22374 inote
.namesz
= BYTE_GET (external
->namesz
);
22375 inote
.namedata
= external
->name
;
22376 inote
.descsz
= BYTE_GET (external
->descsz
);
22377 inote
.descdata
= ((char *) external
22378 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
22379 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
22380 next
= ((char *) external
22381 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
22385 Elf64_External_VMS_Note
*vms_external
;
22387 /* PR binutils/15191
22388 Make sure that there is enough data to read. */
22389 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
22390 if (data_remaining
< min_notesz
)
22392 warn (ngettext ("Corrupt note: only %zd byte remains, "
22393 "not enough for a full note\n",
22394 "Corrupt note: only %zd bytes remain, "
22395 "not enough for a full note\n",
22400 data_remaining
-= min_notesz
;
22402 vms_external
= (Elf64_External_VMS_Note
*) external
;
22403 inote
.type
= BYTE_GET (vms_external
->type
);
22404 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
22405 inote
.namedata
= vms_external
->name
;
22406 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
22407 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
22408 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
22409 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
22412 /* PR 17531: file: 3443835e. */
22413 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
22414 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
22415 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
22416 || (size_t) (next
- inote
.descdata
) < inote
.descsz
22417 || ((size_t) (next
- inote
.descdata
)
22418 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
22420 warn (_("note with invalid namesz and/or descsz found at offset %#tx\n"),
22421 (char *) external
- (char *) pnotes
);
22422 warn (_(" type: %#lx, namesize: %#lx, descsize: %#lx, alignment: %u\n"),
22423 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
22427 external
= (Elf_External_Note
*) next
;
22429 /* Verify that name is null terminated. It appears that at least
22430 one version of Linux (RedHat 6.0) generates corefiles that don't
22431 comply with the ELF spec by failing to include the null byte in
22433 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
22435 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
22437 temp
= (char *) malloc (inote
.namesz
+ 1);
22440 error (_("Out of memory allocating space for inote name\n"));
22445 memcpy (temp
, inote
.namedata
, inote
.namesz
);
22446 inote
.namedata
= temp
;
22448 inote
.namedata
[inote
.namesz
] = 0;
22451 if (! process_note (& inote
, filedata
))
22464 process_corefile_note_segments (Filedata
* filedata
)
22466 Elf_Internal_Phdr
*segment
;
22470 if (! get_program_headers (filedata
))
22473 for (i
= 0, segment
= filedata
->program_headers
;
22474 i
< filedata
->file_header
.e_phnum
;
22477 if (segment
->p_type
== PT_NOTE
)
22478 if (! process_notes_at (filedata
, NULL
, segment
->p_offset
,
22479 segment
->p_filesz
, segment
->p_align
))
22487 process_v850_notes (Filedata
* filedata
, uint64_t offset
, uint64_t length
)
22489 Elf_External_Note
* pnotes
;
22490 Elf_External_Note
* external
;
22497 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
22499 if (pnotes
== NULL
)
22503 end
= (char*) pnotes
+ length
;
22505 printf (_("\nDisplaying contents of Renesas V850 notes section at offset"
22506 " %#" PRIx64
" with length %#" PRIx64
":\n"),
22509 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
22511 Elf_External_Note
* next
;
22512 Elf_Internal_Note inote
;
22514 inote
.type
= BYTE_GET (external
->type
);
22515 inote
.namesz
= BYTE_GET (external
->namesz
);
22516 inote
.namedata
= external
->name
;
22517 inote
.descsz
= BYTE_GET (external
->descsz
);
22518 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
22519 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
22521 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
22523 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
22524 inote
.descdata
= inote
.namedata
;
22528 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
22530 if ( ((char *) next
> end
)
22531 || ((char *) next
< (char *) pnotes
))
22533 warn (_("corrupt descsz found in note at offset %#tx\n"),
22534 (char *) external
- (char *) pnotes
);
22535 warn (_(" type: %#lx, namesize: %#lx, descsize: %#lx\n"),
22536 inote
.type
, inote
.namesz
, inote
.descsz
);
22542 /* Prevent out-of-bounds indexing. */
22543 if ( inote
.namedata
+ inote
.namesz
> end
22544 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
22546 warn (_("corrupt namesz found in note at offset %#zx\n"),
22547 (char *) external
- (char *) pnotes
);
22548 warn (_(" type: %#lx, namesize: %#lx, descsize: %#lx\n"),
22549 inote
.type
, inote
.namesz
, inote
.descsz
);
22553 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
22555 if (! print_v850_note (& inote
))
22558 printf ("<corrupt sizes: namesz: %#lx, descsz: %#lx>\n",
22559 inote
.namesz
, inote
.descsz
);
22569 process_note_sections (Filedata
* filedata
)
22571 Elf_Internal_Shdr
*section
;
22573 unsigned int n
= 0;
22576 for (i
= 0, section
= filedata
->section_headers
;
22577 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
22580 if (section
->sh_type
== SHT_NOTE
)
22582 if (! process_notes_at (filedata
, section
, section
->sh_offset
,
22583 section
->sh_size
, section
->sh_addralign
))
22588 if (( filedata
->file_header
.e_machine
== EM_V800
22589 || filedata
->file_header
.e_machine
== EM_V850
22590 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
22591 && section
->sh_type
== SHT_RENESAS_INFO
)
22593 if (! process_v850_notes (filedata
, section
->sh_offset
,
22601 /* Try processing NOTE segments instead. */
22602 return process_corefile_note_segments (filedata
);
22608 process_notes (Filedata
* filedata
)
22610 /* If we have not been asked to display the notes then do nothing. */
22614 if (filedata
->file_header
.e_type
!= ET_CORE
)
22615 return process_note_sections (filedata
);
22617 /* No program headers means no NOTE segment. */
22618 if (filedata
->file_header
.e_phnum
> 0)
22619 return process_corefile_note_segments (filedata
);
22621 if (filedata
->is_separate
)
22622 printf (_("No notes found in linked file '%s'.\n"),
22623 filedata
->file_name
);
22625 printf (_("No notes found file.\n"));
22630 static unsigned char *
22631 display_public_gnu_attributes (unsigned char * start
,
22632 const unsigned char * const end
)
22634 printf (_(" Unknown GNU attribute: %s\n"), start
);
22636 start
+= strnlen ((char *) start
, end
- start
);
22637 display_raw_attribute (start
, end
);
22639 return (unsigned char *) end
;
22642 static unsigned char *
22643 display_generic_attribute (unsigned char * start
,
22645 const unsigned char * const end
)
22648 return (unsigned char *) end
;
22650 return display_tag_value (tag
, start
, end
);
22654 process_arch_specific (Filedata
* filedata
)
22659 switch (filedata
->file_header
.e_machine
)
22662 case EM_ARC_COMPACT
:
22663 case EM_ARC_COMPACT2
:
22664 case EM_ARC_COMPACT3
:
22665 case EM_ARC_COMPACT3_64
:
22666 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
22667 display_arc_attribute
,
22668 display_generic_attribute
);
22670 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
22671 display_arm_attribute
,
22672 display_generic_attribute
);
22675 case EM_MIPS_RS3_LE
:
22676 return process_mips_specific (filedata
);
22679 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
22680 display_msp430_attribute
,
22681 display_msp430_gnu_attribute
);
22684 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
22685 display_riscv_attribute
,
22686 display_generic_attribute
);
22689 return process_nds32_specific (filedata
);
22692 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22693 display_m68k_gnu_attribute
);
22697 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22698 display_power_gnu_attribute
);
22702 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22703 display_s390_gnu_attribute
);
22706 case EM_SPARC32PLUS
:
22708 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22709 display_sparc_gnu_attribute
);
22712 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
22713 display_tic6x_attribute
,
22714 display_generic_attribute
);
22717 return process_attributes (filedata
, "csky", SHT_CSKY_ATTRIBUTES
,
22718 display_csky_attribute
, NULL
);
22721 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
22722 display_public_gnu_attributes
,
22723 display_generic_attribute
);
22728 get_file_header (Filedata
* filedata
)
22730 /* Read in the identity array. */
22731 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
22734 /* Determine how to read the rest of the header. */
22735 switch (filedata
->file_header
.e_ident
[EI_DATA
])
22740 byte_get
= byte_get_little_endian
;
22741 byte_put
= byte_put_little_endian
;
22744 byte_get
= byte_get_big_endian
;
22745 byte_put
= byte_put_big_endian
;
22749 /* For now we only support 32 bit and 64 bit ELF files. */
22750 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
22752 /* Read in the rest of the header. */
22755 Elf32_External_Ehdr ehdr32
;
22757 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
22760 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
22761 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
22762 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
22763 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
22764 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
22765 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
22766 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
22767 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
22768 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
22769 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
22770 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
22771 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
22772 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
22776 Elf64_External_Ehdr ehdr64
;
22778 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
22781 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
22782 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
22783 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
22784 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
22785 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
22786 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
22787 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
22788 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
22789 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
22790 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
22791 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
22792 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
22793 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
22800 free_filedata (Filedata
*filedata
)
22802 free (filedata
->program_interpreter
);
22803 free (filedata
->program_headers
);
22804 free (filedata
->section_headers
);
22805 free (filedata
->string_table
);
22806 free (filedata
->dump
.dump_sects
);
22807 free (filedata
->dynamic_strings
);
22808 free (filedata
->dynamic_symbols
);
22809 free (filedata
->dynamic_syminfo
);
22810 free (filedata
->dynamic_section
);
22812 while (filedata
->symtab_shndx_list
!= NULL
)
22814 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
22815 free (filedata
->symtab_shndx_list
);
22816 filedata
->symtab_shndx_list
= next
;
22819 free (filedata
->section_headers_groups
);
22821 if (filedata
->section_groups
)
22824 struct group_list
* g
;
22825 struct group_list
* next
;
22827 for (i
= 0; i
< filedata
->group_count
; i
++)
22829 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
22836 free (filedata
->section_groups
);
22838 memset (&filedata
->section_headers
, 0,
22839 sizeof (Filedata
) - offsetof (Filedata
, section_headers
));
22843 close_file (Filedata
* filedata
)
22847 if (filedata
->handle
)
22848 fclose (filedata
->handle
);
22854 close_debug_file (void * data
)
22856 free_filedata ((Filedata
*) data
);
22857 close_file ((Filedata
*) data
);
22861 open_file (const char * pathname
, bool is_separate
)
22863 struct stat statbuf
;
22864 Filedata
* filedata
= NULL
;
22866 if (stat (pathname
, & statbuf
) < 0
22867 || ! S_ISREG (statbuf
.st_mode
))
22870 filedata
= calloc (1, sizeof * filedata
);
22871 if (filedata
== NULL
)
22874 filedata
->handle
= fopen (pathname
, "rb");
22875 if (filedata
->handle
== NULL
)
22878 filedata
->file_size
= statbuf
.st_size
;
22879 filedata
->file_name
= pathname
;
22880 filedata
->is_separate
= is_separate
;
22882 if (! get_file_header (filedata
))
22885 if (!get_section_headers (filedata
, false))
22893 if (filedata
->handle
)
22894 fclose (filedata
->handle
);
22901 open_debug_file (const char * pathname
)
22903 return open_file (pathname
, true);
22907 initialise_dump_sects (Filedata
* filedata
)
22909 /* Initialise the dump_sects array from the cmdline_dump_sects array.
22910 Note we do this even if cmdline_dump_sects is empty because we
22911 must make sure that the dump_sets array is zeroed out before each
22912 object file is processed. */
22913 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
22914 memset (filedata
->dump
.dump_sects
, 0,
22915 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
22917 if (cmdline
.num_dump_sects
> 0)
22919 if (filedata
->dump
.num_dump_sects
== 0)
22920 /* A sneaky way of allocating the dump_sects array. */
22921 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
22923 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
22924 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
22925 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
22930 might_need_separate_debug_info (Filedata
* filedata
)
22932 /* Debuginfo files do not need further separate file loading. */
22933 if (filedata
->file_header
.e_shstrndx
== SHN_UNDEF
)
22936 /* Since do_follow_links might be enabled by default, only treat it as an
22937 indication that separate files should be loaded if setting it was a
22938 deliberate user action. */
22939 if (DEFAULT_FOR_FOLLOW_LINKS
== 0 && do_follow_links
)
22942 if (process_links
|| do_syms
|| do_unwind
22943 || dump_any_debugging
|| do_dump
|| do_debugging
)
22949 /* Process one ELF object file according to the command line options.
22950 This file may actually be stored in an archive. The file is
22951 positioned at the start of the ELF object. Returns TRUE if no
22952 problems were encountered, FALSE otherwise. */
22955 process_object (Filedata
* filedata
)
22957 bool have_separate_files
;
22961 if (! get_file_header (filedata
))
22963 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
22967 /* Initialise per file variables. */
22968 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
22969 filedata
->version_info
[i
] = 0;
22971 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
22972 filedata
->dynamic_info
[i
] = 0;
22973 filedata
->dynamic_info_DT_GNU_HASH
= 0;
22974 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
22976 /* Process the file. */
22978 printf (_("\nFile: %s\n"), filedata
->file_name
);
22980 initialise_dump_sects (filedata
);
22982 /* There may be some extensions in the first section header. Don't
22983 bomb if we can't read it. */
22984 get_section_headers (filedata
, true);
22986 if (! process_file_header (filedata
))
22992 /* Throw away the single section header read above, so that we
22993 re-read the entire set. */
22994 free (filedata
->section_headers
);
22995 filedata
->section_headers
= NULL
;
22997 if (! process_section_headers (filedata
))
22999 /* Without loaded section headers we cannot process lots of things. */
23000 do_unwind
= do_version
= do_dump
= do_arch
= false;
23002 if (! do_using_dynamic
)
23003 do_syms
= do_dyn_syms
= do_reloc
= false;
23006 if (! process_section_groups (filedata
))
23007 /* Without loaded section groups we cannot process unwind. */
23010 process_program_headers (filedata
);
23012 res
= process_dynamic_section (filedata
);
23014 if (! process_relocs (filedata
))
23017 if (! process_unwind (filedata
))
23020 if (! process_symbol_table (filedata
))
23023 if (! process_lto_symbol_tables (filedata
))
23026 if (! process_syminfo (filedata
))
23029 if (! process_version_sections (filedata
))
23032 if (might_need_separate_debug_info (filedata
))
23033 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
23035 have_separate_files
= false;
23037 if (! process_section_contents (filedata
))
23040 if (have_separate_files
)
23044 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
23046 initialise_dump_sects (d
->handle
);
23048 if (process_links
&& ! process_file_header (d
->handle
))
23050 else if (! process_section_headers (d
->handle
))
23052 else if (! process_section_contents (d
->handle
))
23054 else if (process_links
)
23056 if (! process_section_groups (d
->handle
))
23058 process_program_headers (d
->handle
);
23059 if (! process_dynamic_section (d
->handle
))
23061 if (! process_relocs (d
->handle
))
23063 if (! process_unwind (d
->handle
))
23065 if (! process_symbol_table (d
->handle
))
23067 if (! process_lto_symbol_tables (d
->handle
))
23069 if (! process_syminfo (d
->handle
))
23071 if (! process_version_sections (d
->handle
))
23073 if (! process_notes (d
->handle
))
23078 /* The file handles are closed by the call to free_debug_memory() below. */
23081 if (! process_notes (filedata
))
23084 if (! process_gnu_liblist (filedata
))
23087 if (! process_arch_specific (filedata
))
23091 free_filedata (filedata
);
23093 free_debug_memory ();
23098 /* Process an ELF archive.
23099 On entry the file is positioned just after the ARMAG string.
23100 Returns TRUE upon success, FALSE otherwise. */
23103 process_archive (Filedata
* filedata
, bool is_thin_archive
)
23105 struct archive_info arch
;
23106 struct archive_info nested_arch
;
23112 /* The ARCH structure is used to hold information about this archive. */
23113 arch
.file_name
= NULL
;
23115 arch
.index_array
= NULL
;
23116 arch
.sym_table
= NULL
;
23117 arch
.longnames
= NULL
;
23119 /* The NESTED_ARCH structure is used as a single-item cache of information
23120 about a nested archive (when members of a thin archive reside within
23121 another regular archive file). */
23122 nested_arch
.file_name
= NULL
;
23123 nested_arch
.file
= NULL
;
23124 nested_arch
.index_array
= NULL
;
23125 nested_arch
.sym_table
= NULL
;
23126 nested_arch
.longnames
= NULL
;
23128 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
23129 filedata
->file_size
, is_thin_archive
,
23130 do_archive_index
) != 0)
23136 if (do_archive_index
)
23138 if (arch
.sym_table
== NULL
)
23139 error (_("%s: unable to dump the index as none was found\n"),
23140 filedata
->file_name
);
23144 uint64_t current_pos
;
23146 printf (_("Index of archive %s: (%" PRIu64
" entries,"
23147 " %#" PRIx64
" bytes in the symbol table)\n"),
23148 filedata
->file_name
, arch
.index_num
,
23151 current_pos
= ftell (filedata
->handle
);
23153 for (i
= l
= 0; i
< arch
.index_num
; i
++)
23156 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
23159 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
23162 if (member_name
!= NULL
)
23164 char * qualified_name
23165 = make_qualified_name (&arch
, &nested_arch
,
23168 if (qualified_name
!= NULL
)
23170 printf (_("Contents of binary %s at offset "),
23172 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
23174 free (qualified_name
);
23176 free (member_name
);
23180 if (l
>= arch
.sym_size
)
23182 error (_("%s: end of the symbol table reached "
23183 "before the end of the index\n"),
23184 filedata
->file_name
);
23188 /* PR 17531: file: 0b6630b2. */
23189 printf ("\t%.*s\n",
23190 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
23191 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
23194 if (arch
.uses_64bit_indices
)
23199 if (l
< arch
.sym_size
)
23201 error (ngettext ("%s: %" PRId64
" byte remains in the symbol table, "
23202 "but without corresponding entries in "
23203 "the index table\n",
23204 "%s: %" PRId64
" bytes remain in the symbol table, "
23205 "but without corresponding entries in "
23206 "the index table\n",
23207 arch
.sym_size
- l
),
23208 filedata
->file_name
, arch
.sym_size
- l
);
23212 if (fseek64 (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
23214 error (_("%s: failed to seek back to start of object files "
23215 "in the archive\n"),
23216 filedata
->file_name
);
23222 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
23223 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
23224 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
23225 && !do_section_groups
&& !do_dyn_syms
)
23227 ret
= true; /* Archive index only. */
23236 char * qualified_name
;
23238 /* Read the next archive header. */
23239 if (fseek64 (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
23241 error (_("%s: failed to seek to next archive header\n"),
23246 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
23247 if (got
!= sizeof arch
.arhdr
)
23251 /* PR 24049 - we cannot use filedata->file_name as this will
23252 have already been freed. */
23253 error (_("%s: failed to read archive header\n"), arch
.file_name
);
23258 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
23260 error (_("%s: did not find a valid archive header\n"),
23266 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
23268 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
23270 name
= get_archive_member_name (&arch
, &nested_arch
);
23273 error (_("%s: bad archive file name\n"), arch
.file_name
);
23277 namelen
= strlen (name
);
23279 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
23280 if (qualified_name
== NULL
)
23282 error (_("%s: bad archive file name\n"), arch
.file_name
);
23288 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
23290 /* This is a proxy for an external member of a thin archive. */
23291 Filedata
* member_filedata
;
23292 char * member_file_name
= adjust_relative_path
23293 (filedata
->file_name
, name
, namelen
);
23296 if (member_file_name
== NULL
)
23298 free (qualified_name
);
23303 member_filedata
= open_file (member_file_name
, false);
23304 if (member_filedata
== NULL
)
23306 error (_("Input file '%s' is not readable.\n"), member_file_name
);
23307 free (member_file_name
);
23308 free (qualified_name
);
23313 filedata
->archive_file_offset
= arch
.nested_member_origin
;
23314 member_filedata
->file_name
= qualified_name
;
23316 /* The call to process_object() expects the file to be at the beginning. */
23317 rewind (member_filedata
->handle
);
23319 if (! process_object (member_filedata
))
23322 close_file (member_filedata
);
23323 free (member_file_name
);
23325 else if (is_thin_archive
)
23327 Filedata thin_filedata
;
23329 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
23331 /* PR 15140: Allow for corrupt thin archives. */
23332 if (nested_arch
.file
== NULL
)
23334 error (_("%s: contains corrupt thin archive: %s\n"),
23335 qualified_name
, name
);
23336 free (qualified_name
);
23343 /* This is a proxy for a member of a nested archive. */
23344 filedata
->archive_file_offset
23345 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
23347 /* The nested archive file will have been opened and setup by
23348 get_archive_member_name. */
23349 if (fseek64 (nested_arch
.file
, filedata
->archive_file_offset
,
23352 error (_("%s: failed to seek to archive member.\n"),
23353 nested_arch
.file_name
);
23354 free (qualified_name
);
23359 thin_filedata
.handle
= nested_arch
.file
;
23360 thin_filedata
.file_name
= qualified_name
;
23362 if (! process_object (& thin_filedata
))
23368 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
23369 filedata
->file_name
= qualified_name
;
23370 if (! process_object (filedata
))
23372 arch
.next_arhdr_offset
+= (filedata
->archive_file_size
+ 1) & -2;
23373 /* Stop looping with "negative" archive_file_size. */
23374 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
23375 arch
.next_arhdr_offset
= -1ul;
23378 free (qualified_name
);
23382 if (nested_arch
.file
!= NULL
)
23383 fclose (nested_arch
.file
);
23384 release_archive (&nested_arch
);
23385 release_archive (&arch
);
23391 process_file (char * file_name
)
23393 Filedata
* filedata
= NULL
;
23394 struct stat statbuf
;
23395 char armag
[SARMAG
];
23398 if (stat (file_name
, &statbuf
) < 0)
23400 if (errno
== ENOENT
)
23401 error (_("'%s': No such file\n"), file_name
);
23403 error (_("Could not locate '%s'. System error message: %s\n"),
23404 file_name
, strerror (errno
));
23408 if (! S_ISREG (statbuf
.st_mode
))
23410 error (_("'%s' is not an ordinary file\n"), file_name
);
23414 filedata
= calloc (1, sizeof * filedata
);
23415 if (filedata
== NULL
)
23417 error (_("Out of memory allocating file data structure\n"));
23421 filedata
->file_name
= file_name
;
23422 filedata
->handle
= fopen (file_name
, "rb");
23423 if (filedata
->handle
== NULL
)
23425 error (_("Input file '%s' is not readable.\n"), file_name
);
23430 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
23432 error (_("%s: Failed to read file's magic number\n"), file_name
);
23433 fclose (filedata
->handle
);
23438 filedata
->file_size
= statbuf
.st_size
;
23439 filedata
->is_separate
= false;
23441 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
23443 if (! process_archive (filedata
, false))
23446 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
23448 if ( ! process_archive (filedata
, true))
23453 if (do_archive_index
&& !check_all
)
23454 error (_("File %s is not an archive so its index cannot be displayed.\n"),
23457 rewind (filedata
->handle
);
23458 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
23460 if (! process_object (filedata
))
23464 fclose (filedata
->handle
);
23465 free (filedata
->section_headers
);
23466 free (filedata
->program_headers
);
23467 free (filedata
->string_table
);
23468 free (filedata
->dump
.dump_sects
);
23471 free (ba_cache
.strtab
);
23472 ba_cache
.strtab
= NULL
;
23473 free (ba_cache
.symtab
);
23474 ba_cache
.symtab
= NULL
;
23475 ba_cache
.filedata
= NULL
;
23480 #ifdef SUPPORT_DISASSEMBLY
23481 /* Needed by the i386 disassembler. For extra credit, someone could
23482 fix this so that we insert symbolic addresses here, esp for GOT/PLT
23486 print_address (unsigned int addr
, FILE * outfile
)
23488 fprintf (outfile
,"0x%8.8x", addr
);
23491 /* Needed by the i386 disassembler. */
23494 db_task_printsym (unsigned int addr
)
23496 print_address (addr
, stderr
);
23501 main (int argc
, char ** argv
)
23505 #ifdef HAVE_LC_MESSAGES
23506 setlocale (LC_MESSAGES
, "");
23508 setlocale (LC_CTYPE
, "");
23509 bindtextdomain (PACKAGE
, LOCALEDIR
);
23510 textdomain (PACKAGE
);
23512 expandargv (&argc
, &argv
);
23514 parse_args (& cmdline
, argc
, argv
);
23516 if (optind
< (argc
- 1))
23517 /* When displaying information for more than one file,
23518 prefix the information with the file name. */
23520 else if (optind
>= argc
)
23522 /* Ensure that the warning is always displayed. */
23525 warn (_("Nothing to do.\n"));
23530 while (optind
< argc
)
23531 if (! process_file (argv
[optind
++]))
23534 free (cmdline
.dump_sects
);
23536 free (dump_ctf_symtab_name
);
23537 free (dump_ctf_strtab_name
);
23538 free (dump_ctf_parent_name
);
23540 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;