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 (unsigned e_flags
, unsigned e_machine
, char buf
[])
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 strcat (buf
, ", ARC EM");
3026 case EF_ARC_CPU_ARCV2HS
:
3027 strcat (buf
, ", ARC HS");
3030 /* We only expect these to occur for EM_ARC_COMPACT. */
3031 case E_ARC_MACH_ARC600
:
3032 strcat (buf
, ", ARC600");
3034 case E_ARC_MACH_ARC601
:
3035 strcat (buf
, ", ARC601");
3037 case E_ARC_MACH_ARC700
:
3038 strcat (buf
, ", 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 strcat (buf
, ", Unknown ARCompact");
3049 strcat (buf
, ", Unknown ARC");
3053 switch (e_flags
& EF_ARC_OSABI_MSK
)
3055 case E_ARC_OSABI_ORIG
:
3056 strcat (buf
, ", (ABI:legacy)");
3058 case E_ARC_OSABI_V2
:
3059 strcat (buf
, ", (ABI:v2)");
3061 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
3062 case E_ARC_OSABI_V3
:
3063 strcat (buf
, ", v3 no-legacy-syscalls ABI");
3065 case E_ARC_OSABI_V4
:
3066 strcat (buf
, ", v4 ABI");
3069 strcat (buf
, ", unrecognised ARC OSABI flag");
3075 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
3078 bool unknown
= false;
3080 eabi
= EF_ARM_EABI_VERSION (e_flags
);
3081 e_flags
&= ~ EF_ARM_EABIMASK
;
3083 /* Handle "generic" ARM flags. */
3084 if (e_flags
& EF_ARM_RELEXEC
)
3086 strcat (buf
, ", relocatable executable");
3087 e_flags
&= ~ EF_ARM_RELEXEC
;
3090 if (e_flags
& EF_ARM_PIC
)
3092 strcat (buf
, ", position independent");
3093 e_flags
&= ~ EF_ARM_PIC
;
3096 /* Now handle EABI specific flags. */
3100 strcat (buf
, ", <unrecognized EABI>");
3105 case EF_ARM_EABI_VER1
:
3106 strcat (buf
, ", Version1 EABI");
3111 /* Process flags one bit at a time. */
3112 flag
= e_flags
& - e_flags
;
3117 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
3118 strcat (buf
, ", sorted symbol tables");
3128 case EF_ARM_EABI_VER2
:
3129 strcat (buf
, ", Version2 EABI");
3134 /* Process flags one bit at a time. */
3135 flag
= e_flags
& - e_flags
;
3140 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
3141 strcat (buf
, ", sorted symbol tables");
3144 case EF_ARM_DYNSYMSUSESEGIDX
:
3145 strcat (buf
, ", dynamic symbols use segment index");
3148 case EF_ARM_MAPSYMSFIRST
:
3149 strcat (buf
, ", mapping symbols precede others");
3159 case EF_ARM_EABI_VER3
:
3160 strcat (buf
, ", Version3 EABI");
3163 case EF_ARM_EABI_VER4
:
3164 strcat (buf
, ", Version4 EABI");
3169 /* Process flags one bit at a time. */
3170 flag
= e_flags
& - e_flags
;
3176 strcat (buf
, ", BE8");
3180 strcat (buf
, ", LE8");
3190 case EF_ARM_EABI_VER5
:
3191 strcat (buf
, ", Version5 EABI");
3196 /* Process flags one bit at a time. */
3197 flag
= e_flags
& - e_flags
;
3203 strcat (buf
, ", BE8");
3207 strcat (buf
, ", LE8");
3210 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
3211 strcat (buf
, ", soft-float ABI");
3214 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
3215 strcat (buf
, ", hard-float ABI");
3225 case EF_ARM_EABI_UNKNOWN
:
3226 strcat (buf
, ", GNU EABI");
3231 /* Process flags one bit at a time. */
3232 flag
= e_flags
& - e_flags
;
3237 case EF_ARM_INTERWORK
:
3238 strcat (buf
, ", interworking enabled");
3241 case EF_ARM_APCS_26
:
3242 strcat (buf
, ", uses APCS/26");
3245 case EF_ARM_APCS_FLOAT
:
3246 strcat (buf
, ", uses APCS/float");
3250 strcat (buf
, ", position independent");
3254 strcat (buf
, ", 8 bit structure alignment");
3257 case EF_ARM_NEW_ABI
:
3258 strcat (buf
, ", uses new ABI");
3261 case EF_ARM_OLD_ABI
:
3262 strcat (buf
, ", uses old ABI");
3265 case EF_ARM_SOFT_FLOAT
:
3266 strcat (buf
, ", software FP");
3269 case EF_ARM_VFP_FLOAT
:
3270 strcat (buf
, ", VFP");
3273 case EF_ARM_MAVERICK_FLOAT
:
3274 strcat (buf
, ", Maverick FP");
3285 strcat (buf
,_(", <unknown>"));
3289 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
3291 --size
; /* Leave space for null terminator. */
3293 switch (e_flags
& EF_AVR_MACH
)
3295 case E_AVR_MACH_AVR1
:
3296 strncat (buf
, ", avr:1", size
);
3298 case E_AVR_MACH_AVR2
:
3299 strncat (buf
, ", avr:2", size
);
3301 case E_AVR_MACH_AVR25
:
3302 strncat (buf
, ", avr:25", size
);
3304 case E_AVR_MACH_AVR3
:
3305 strncat (buf
, ", avr:3", size
);
3307 case E_AVR_MACH_AVR31
:
3308 strncat (buf
, ", avr:31", size
);
3310 case E_AVR_MACH_AVR35
:
3311 strncat (buf
, ", avr:35", size
);
3313 case E_AVR_MACH_AVR4
:
3314 strncat (buf
, ", avr:4", size
);
3316 case E_AVR_MACH_AVR5
:
3317 strncat (buf
, ", avr:5", size
);
3319 case E_AVR_MACH_AVR51
:
3320 strncat (buf
, ", avr:51", size
);
3322 case E_AVR_MACH_AVR6
:
3323 strncat (buf
, ", avr:6", size
);
3325 case E_AVR_MACH_AVRTINY
:
3326 strncat (buf
, ", avr:100", size
);
3328 case E_AVR_MACH_XMEGA1
:
3329 strncat (buf
, ", avr:101", size
);
3331 case E_AVR_MACH_XMEGA2
:
3332 strncat (buf
, ", avr:102", size
);
3334 case E_AVR_MACH_XMEGA3
:
3335 strncat (buf
, ", avr:103", size
);
3337 case E_AVR_MACH_XMEGA4
:
3338 strncat (buf
, ", avr:104", size
);
3340 case E_AVR_MACH_XMEGA5
:
3341 strncat (buf
, ", avr:105", size
);
3343 case E_AVR_MACH_XMEGA6
:
3344 strncat (buf
, ", avr:106", size
);
3346 case E_AVR_MACH_XMEGA7
:
3347 strncat (buf
, ", avr:107", size
);
3350 strncat (buf
, ", avr:<unknown>", size
);
3354 size
-= strlen (buf
);
3355 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
3356 strncat (buf
, ", link-relax", size
);
3360 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
3366 bool has_fpu
= false;
3369 static const char *ABI_STRINGS
[] =
3371 "ABI v0", /* use r5 as return register; only used in N1213HC */
3372 "ABI v1", /* use r0 as return register */
3373 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
3374 "ABI v2fp", /* for FPU */
3378 static const char *VER_STRINGS
[] =
3380 "Andes ELF V1.3 or older",
3384 static const char *ARCH_STRINGS
[] =
3393 abi
= EF_NDS_ABI
& e_flags
;
3394 arch
= EF_NDS_ARCH
& e_flags
;
3395 config
= EF_NDS_INST
& e_flags
;
3396 version
= EF_NDS32_ELF_VERSION
& e_flags
;
3398 memset (buf
, 0, size
);
3405 case E_NDS_ABI_V2FP
:
3406 case E_NDS_ABI_AABI
:
3407 case E_NDS_ABI_V2FP_PLUS
:
3408 /* In case there are holes in the array. */
3409 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
3413 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
3419 case E_NDS32_ELF_VER_1_2
:
3420 case E_NDS32_ELF_VER_1_3
:
3421 case E_NDS32_ELF_VER_1_4
:
3422 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
3426 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
3430 if (E_NDS_ABI_V0
== abi
)
3432 /* OLD ABI; only used in N1213HC, has performance extension 1. */
3433 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
3434 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3435 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
3441 case E_NDS_ARCH_STAR_V1_0
:
3442 case E_NDS_ARCH_STAR_V2_0
:
3443 case E_NDS_ARCH_STAR_V3_0
:
3444 case E_NDS_ARCH_STAR_V3_M
:
3445 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
3449 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
3450 /* ARCH version determines how the e_flags are interpreted.
3451 If it is unknown, we cannot proceed. */
3455 /* Newer ABI; Now handle architecture specific flags. */
3456 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3458 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3459 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
3461 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
3462 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
3464 if (config
& E_NDS32_HAS_DIV_INST
)
3465 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
3467 if (config
& E_NDS32_HAS_16BIT_INST
)
3468 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3472 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3474 if (version
<= E_NDS32_ELF_VER_1_3
)
3475 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
3477 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
3480 if (config
& E_NDS32_HAS_MAC_DX_INST
)
3481 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
3483 if (config
& E_NDS32_HAS_DIV_DX_INST
)
3484 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
3486 if (config
& E_NDS32_HAS_16BIT_INST
)
3488 if (version
<= E_NDS32_ELF_VER_1_3
)
3489 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3491 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3495 if (config
& E_NDS32_HAS_EXT_INST
)
3496 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3498 if (config
& E_NDS32_HAS_EXT2_INST
)
3499 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3501 if (config
& E_NDS32_HAS_FPU_INST
)
3504 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3507 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3510 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3513 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3516 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3521 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3523 case E_NDS32_FPU_REG_8SP_4DP
:
3524 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3526 case E_NDS32_FPU_REG_16SP_8DP
:
3527 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3529 case E_NDS32_FPU_REG_32SP_16DP
:
3530 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3532 case E_NDS32_FPU_REG_32SP_32DP
:
3533 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3538 if (config
& E_NDS32_HAS_AUDIO_INST
)
3539 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3541 if (config
& E_NDS32_HAS_STRING_INST
)
3542 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3544 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3545 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3547 if (config
& E_NDS32_HAS_VIDEO_INST
)
3549 if (version
<= E_NDS32_ELF_VER_1_3
)
3550 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3552 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3555 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3556 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3558 if (config
& E_NDS32_HAS_L2C_INST
)
3559 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3563 decode_AMDGPU_machine_flags (Filedata
*filedata
, unsigned int e_flags
,
3566 unsigned char *e_ident
= filedata
->file_header
.e_ident
;
3567 unsigned char osabi
= e_ident
[EI_OSABI
];
3568 unsigned char abiversion
= e_ident
[EI_ABIVERSION
];
3571 /* HSA OS ABI v2 used a different encoding, but we don't need to support it,
3572 it has been deprecated for a while.
3574 The PAL, MESA3D and NONE OS ABIs are not properly versioned, at the time
3575 of writing, they use the same flags as HSA v3, so the code below uses that
3577 if (osabi
== ELFOSABI_AMDGPU_HSA
&& abiversion
< ELFABIVERSION_AMDGPU_HSA_V3
)
3580 mach
= e_flags
& EF_AMDGPU_MACH
;
3583 #define AMDGPU_CASE(code, string) \
3584 case code: strcat (buf, ", " string); break;
3585 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX600
, "gfx600")
3586 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX601
, "gfx601")
3587 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX700
, "gfx700")
3588 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX701
, "gfx701")
3589 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX702
, "gfx702")
3590 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX703
, "gfx703")
3591 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX704
, "gfx704")
3592 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX801
, "gfx801")
3593 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX802
, "gfx802")
3594 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX803
, "gfx803")
3595 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX810
, "gfx810")
3596 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX900
, "gfx900")
3597 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX902
, "gfx902")
3598 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX904
, "gfx904")
3599 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX906
, "gfx906")
3600 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX908
, "gfx908")
3601 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX909
, "gfx909")
3602 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX90C
, "gfx90c")
3603 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1010
, "gfx1010")
3604 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1011
, "gfx1011")
3605 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1012
, "gfx1012")
3606 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1030
, "gfx1030")
3607 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1031
, "gfx1031")
3608 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1032
, "gfx1032")
3609 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1033
, "gfx1033")
3610 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX602
, "gfx602")
3611 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX705
, "gfx705")
3612 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX805
, "gfx805")
3613 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1035
, "gfx1035")
3614 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1034
, "gfx1034")
3615 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX90A
, "gfx90a")
3616 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX940
, "gfx940")
3617 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1013
, "gfx1013")
3618 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1036
, "gfx1036")
3620 sprintf (buf
, _(", <unknown AMDGPU GPU type: %#x>"), mach
);
3625 buf
+= strlen (buf
);
3626 e_flags
&= ~EF_AMDGPU_MACH
;
3628 if ((osabi
== ELFOSABI_AMDGPU_HSA
3629 && abiversion
== ELFABIVERSION_AMDGPU_HSA_V3
)
3630 || osabi
!= ELFOSABI_AMDGPU_HSA
)
3632 /* For HSA v3 and other OS ABIs. */
3633 if (e_flags
& EF_AMDGPU_FEATURE_XNACK_V3
)
3635 strcat (buf
, ", xnack on");
3636 buf
+= strlen (buf
);
3637 e_flags
&= ~EF_AMDGPU_FEATURE_XNACK_V3
;
3640 if (e_flags
& EF_AMDGPU_FEATURE_SRAMECC_V3
)
3642 strcat (buf
, ", sramecc on");
3643 buf
+= strlen (buf
);
3644 e_flags
&= ~EF_AMDGPU_FEATURE_SRAMECC_V3
;
3652 xnack
= e_flags
& EF_AMDGPU_FEATURE_XNACK_V4
;
3655 case EF_AMDGPU_FEATURE_XNACK_UNSUPPORTED_V4
:
3658 case EF_AMDGPU_FEATURE_XNACK_ANY_V4
:
3659 strcat (buf
, ", xnack any");
3662 case EF_AMDGPU_FEATURE_XNACK_OFF_V4
:
3663 strcat (buf
, ", xnack off");
3666 case EF_AMDGPU_FEATURE_XNACK_ON_V4
:
3667 strcat (buf
, ", xnack on");
3671 sprintf (buf
, _(", <unknown xnack value: %#x>"), xnack
);
3675 buf
+= strlen (buf
);
3676 e_flags
&= ~EF_AMDGPU_FEATURE_XNACK_V4
;
3678 sramecc
= e_flags
& EF_AMDGPU_FEATURE_SRAMECC_V4
;
3681 case EF_AMDGPU_FEATURE_SRAMECC_UNSUPPORTED_V4
:
3684 case EF_AMDGPU_FEATURE_SRAMECC_ANY_V4
:
3685 strcat (buf
, ", sramecc any");
3688 case EF_AMDGPU_FEATURE_SRAMECC_OFF_V4
:
3689 strcat (buf
, ", sramecc off");
3692 case EF_AMDGPU_FEATURE_SRAMECC_ON_V4
:
3693 strcat (buf
, ", sramecc on");
3697 sprintf (buf
, _(", <unknown sramecc value: %#x>"), sramecc
);
3701 buf
+= strlen (buf
);
3702 e_flags
&= ~EF_AMDGPU_FEATURE_SRAMECC_V4
;
3706 sprintf (buf
, _(", unknown flags bits: %#x"), e_flags
);
3710 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3712 static char buf
[1024];
3723 case EM_ARC_COMPACT3
:
3724 strcat (buf
, ", HS5x");
3727 case EM_ARC_COMPACT3_64
:
3728 strcat (buf
, ", HS6x");
3731 case EM_ARC_COMPACT2
:
3732 case EM_ARC_COMPACT
:
3733 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3737 decode_ARM_machine_flags (e_flags
, buf
);
3741 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3745 if (e_flags
& EF_BFIN_PIC
)
3746 strcat (buf
, ", PIC");
3748 if (e_flags
& EF_BFIN_FDPIC
)
3749 strcat (buf
, ", FDPIC");
3751 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3752 strcat (buf
, ", code in L1");
3754 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3755 strcat (buf
, ", data in L1");
3760 switch (e_flags
& EF_FRV_CPU_MASK
)
3762 case EF_FRV_CPU_GENERIC
:
3766 strcat (buf
, ", fr???");
3769 case EF_FRV_CPU_FR300
:
3770 strcat (buf
, ", fr300");
3773 case EF_FRV_CPU_FR400
:
3774 strcat (buf
, ", fr400");
3776 case EF_FRV_CPU_FR405
:
3777 strcat (buf
, ", fr405");
3780 case EF_FRV_CPU_FR450
:
3781 strcat (buf
, ", fr450");
3784 case EF_FRV_CPU_FR500
:
3785 strcat (buf
, ", fr500");
3787 case EF_FRV_CPU_FR550
:
3788 strcat (buf
, ", fr550");
3791 case EF_FRV_CPU_SIMPLE
:
3792 strcat (buf
, ", simple");
3794 case EF_FRV_CPU_TOMCAT
:
3795 strcat (buf
, ", tomcat");
3801 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3802 strcat (buf
, ", m68000");
3803 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3804 strcat (buf
, ", cpu32");
3805 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3806 strcat (buf
, ", fido_a");
3809 char const * isa
= _("unknown");
3810 char const * mac
= _("unknown mac");
3811 char const * additional
= NULL
;
3813 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3815 case EF_M68K_CF_ISA_A_NODIV
:
3817 additional
= ", nodiv";
3819 case EF_M68K_CF_ISA_A
:
3822 case EF_M68K_CF_ISA_A_PLUS
:
3825 case EF_M68K_CF_ISA_B_NOUSP
:
3827 additional
= ", nousp";
3829 case EF_M68K_CF_ISA_B
:
3832 case EF_M68K_CF_ISA_C
:
3835 case EF_M68K_CF_ISA_C_NODIV
:
3837 additional
= ", nodiv";
3840 strcat (buf
, ", cf, isa ");
3843 strcat (buf
, additional
);
3844 if (e_flags
& EF_M68K_CF_FLOAT
)
3845 strcat (buf
, ", float");
3846 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3851 case EF_M68K_CF_MAC
:
3854 case EF_M68K_CF_EMAC
:
3857 case EF_M68K_CF_EMAC_B
:
3870 decode_AMDGPU_machine_flags (filedata
, e_flags
, buf
);
3874 switch (e_flags
& EF_MEP_CPU_MASK
)
3876 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3877 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3878 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3879 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3880 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3881 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3882 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3885 switch (e_flags
& EF_MEP_COP_MASK
)
3887 case EF_MEP_COP_NONE
: break;
3888 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3889 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3890 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3891 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3892 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3895 if (e_flags
& EF_MEP_LIBRARY
)
3896 strcat (buf
, ", Built for Library");
3898 if (e_flags
& EF_MEP_INDEX_MASK
)
3899 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3900 e_flags
& EF_MEP_INDEX_MASK
);
3902 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3903 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3904 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3908 if (e_flags
& EF_PPC_EMB
)
3909 strcat (buf
, ", emb");
3911 if (e_flags
& EF_PPC_RELOCATABLE
)
3912 strcat (buf
, _(", relocatable"));
3914 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3915 strcat (buf
, _(", relocatable-lib"));
3919 if (e_flags
& EF_PPC64_ABI
)
3921 char abi
[] = ", abiv0";
3923 abi
[6] += e_flags
& EF_PPC64_ABI
;
3929 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3930 strcat (buf
, ", RH850 ABI");
3932 if (e_flags
& EF_V800_850E3
)
3933 strcat (buf
, ", V3 architecture");
3935 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3936 strcat (buf
, ", FPU not used");
3938 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3939 strcat (buf
, ", regmode: COMMON");
3941 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3942 strcat (buf
, ", r4 not used");
3944 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3945 strcat (buf
, ", r30 not used");
3947 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3948 strcat (buf
, ", r5 not used");
3950 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3951 strcat (buf
, ", r2 not used");
3953 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3955 switch (e_flags
& - e_flags
)
3957 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3958 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3959 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3960 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3961 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3962 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3963 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3964 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3965 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3966 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3967 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3968 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3975 case EM_CYGNUS_V850
:
3976 switch (e_flags
& EF_V850_ARCH
)
3978 case E_V850E3V5_ARCH
:
3979 strcat (buf
, ", v850e3v5");
3981 case E_V850E2V3_ARCH
:
3982 strcat (buf
, ", v850e2v3");
3985 strcat (buf
, ", v850e2");
3988 strcat (buf
, ", v850e1");
3991 strcat (buf
, ", v850e");
3994 strcat (buf
, ", v850");
3997 strcat (buf
, _(", unknown v850 architecture variant"));
4003 case EM_CYGNUS_M32R
:
4004 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
4005 strcat (buf
, ", m32r");
4009 case EM_MIPS_RS3_LE
:
4010 if (e_flags
& EF_MIPS_NOREORDER
)
4011 strcat (buf
, ", noreorder");
4013 if (e_flags
& EF_MIPS_PIC
)
4014 strcat (buf
, ", pic");
4016 if (e_flags
& EF_MIPS_CPIC
)
4017 strcat (buf
, ", cpic");
4019 if (e_flags
& EF_MIPS_UCODE
)
4020 strcat (buf
, ", ugen_reserved");
4022 if (e_flags
& EF_MIPS_ABI2
)
4023 strcat (buf
, ", abi2");
4025 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
4026 strcat (buf
, ", odk first");
4028 if (e_flags
& EF_MIPS_32BITMODE
)
4029 strcat (buf
, ", 32bitmode");
4031 if (e_flags
& EF_MIPS_NAN2008
)
4032 strcat (buf
, ", nan2008");
4034 if (e_flags
& EF_MIPS_FP64
)
4035 strcat (buf
, ", fp64");
4037 switch ((e_flags
& EF_MIPS_MACH
))
4039 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
4040 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
4041 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
4042 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
4043 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
4044 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
4045 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
4046 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
4047 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
4048 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
4049 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
4050 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
4051 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
4052 case E_MIPS_MACH_GS464
: strcat (buf
, ", gs464"); break;
4053 case E_MIPS_MACH_GS464E
: strcat (buf
, ", gs464e"); break;
4054 case E_MIPS_MACH_GS264E
: strcat (buf
, ", gs264e"); break;
4055 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
4056 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
4057 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
4058 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
4059 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
4060 case E_MIPS_MACH_ALLEGREX
: strcat(buf
, ", allegrex"); break;
4062 /* We simply ignore the field in this case to avoid confusion:
4063 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
4066 default: strcat (buf
, _(", unknown CPU")); break;
4069 switch ((e_flags
& EF_MIPS_ABI
))
4071 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
4072 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
4073 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
4074 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
4076 /* We simply ignore the field in this case to avoid confusion:
4077 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
4078 This means it is likely to be an o32 file, but not for
4081 default: strcat (buf
, _(", unknown ABI")); break;
4084 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
4085 strcat (buf
, ", mdmx");
4087 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
4088 strcat (buf
, ", mips16");
4090 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
4091 strcat (buf
, ", micromips");
4093 switch ((e_flags
& EF_MIPS_ARCH
))
4095 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
4096 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
4097 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
4098 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
4099 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
4100 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
4101 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
4102 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
4103 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
4104 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
4105 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
4106 default: strcat (buf
, _(", unknown ISA")); break;
4111 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
4115 switch (EF_NFP_MACH (e_flags
))
4117 case E_NFP_MACH_3200
:
4118 strcat (buf
, ", NFP-32xx");
4120 case E_NFP_MACH_6000
:
4121 strcat (buf
, ", NFP-6xxx");
4127 if (e_flags
& EF_RISCV_RVC
)
4128 strcat (buf
, ", RVC");
4130 if (e_flags
& EF_RISCV_RVE
)
4131 strcat (buf
, ", RVE");
4133 if (e_flags
& EF_RISCV_TSO
)
4134 strcat (buf
, ", TSO");
4136 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
4138 case EF_RISCV_FLOAT_ABI_SOFT
:
4139 strcat (buf
, ", soft-float ABI");
4142 case EF_RISCV_FLOAT_ABI_SINGLE
:
4143 strcat (buf
, ", single-float ABI");
4146 case EF_RISCV_FLOAT_ABI_DOUBLE
:
4147 strcat (buf
, ", double-float ABI");
4150 case EF_RISCV_FLOAT_ABI_QUAD
:
4151 strcat (buf
, ", quad-float ABI");
4157 switch ((e_flags
& EF_SH_MACH_MASK
))
4159 case EF_SH1
: strcat (buf
, ", sh1"); break;
4160 case EF_SH2
: strcat (buf
, ", sh2"); break;
4161 case EF_SH3
: strcat (buf
, ", sh3"); break;
4162 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
4163 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
4164 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
4165 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
4166 case EF_SH4
: strcat (buf
, ", sh4"); break;
4167 case EF_SH5
: strcat (buf
, ", sh5"); break;
4168 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
4169 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
4170 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
4171 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
4172 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
4173 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
4174 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
4175 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
4176 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
4177 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
4178 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
4179 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
4180 default: strcat (buf
, _(", unknown ISA")); break;
4183 if (e_flags
& EF_SH_PIC
)
4184 strcat (buf
, ", pic");
4186 if (e_flags
& EF_SH_FDPIC
)
4187 strcat (buf
, ", fdpic");
4191 if (e_flags
& EF_OR1K_NODELAY
)
4192 strcat (buf
, ", no delay");
4196 sprintf (buf
+ strlen (buf
), ", CPU Version: %u",
4197 e_flags
& EF_BPF_CPUVER
);
4201 if (e_flags
& EF_SPARC_32PLUS
)
4202 strcat (buf
, ", v8+");
4204 if (e_flags
& EF_SPARC_SUN_US1
)
4205 strcat (buf
, ", ultrasparcI");
4207 if (e_flags
& EF_SPARC_SUN_US3
)
4208 strcat (buf
, ", ultrasparcIII");
4210 if (e_flags
& EF_SPARC_HAL_R1
)
4211 strcat (buf
, ", halr1");
4213 if (e_flags
& EF_SPARC_LEDATA
)
4214 strcat (buf
, ", ledata");
4216 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
4217 strcat (buf
, ", tso");
4219 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
4220 strcat (buf
, ", pso");
4222 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
4223 strcat (buf
, ", rmo");
4227 switch (e_flags
& EF_PARISC_ARCH
)
4229 case EFA_PARISC_1_0
:
4230 strcpy (buf
, ", PA-RISC 1.0");
4232 case EFA_PARISC_1_1
:
4233 strcpy (buf
, ", PA-RISC 1.1");
4235 case EFA_PARISC_2_0
:
4236 strcpy (buf
, ", PA-RISC 2.0");
4241 if (e_flags
& EF_PARISC_TRAPNIL
)
4242 strcat (buf
, ", trapnil");
4243 if (e_flags
& EF_PARISC_EXT
)
4244 strcat (buf
, ", ext");
4245 if (e_flags
& EF_PARISC_LSB
)
4246 strcat (buf
, ", lsb");
4247 if (e_flags
& EF_PARISC_WIDE
)
4248 strcat (buf
, ", wide");
4249 if (e_flags
& EF_PARISC_NO_KABP
)
4250 strcat (buf
, ", no kabp");
4251 if (e_flags
& EF_PARISC_LAZYSWAP
)
4252 strcat (buf
, ", lazyswap");
4257 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
4258 strcat (buf
, ", new calling convention");
4260 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
4261 strcat (buf
, ", gnu calling convention");
4265 if ((e_flags
& EF_IA_64_ABI64
))
4266 strcat (buf
, ", 64-bit");
4268 strcat (buf
, ", 32-bit");
4269 if ((e_flags
& EF_IA_64_REDUCEDFP
))
4270 strcat (buf
, ", reduced fp model");
4271 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
4272 strcat (buf
, ", no function descriptors, constant gp");
4273 else if ((e_flags
& EF_IA_64_CONS_GP
))
4274 strcat (buf
, ", constant gp");
4275 if ((e_flags
& EF_IA_64_ABSOLUTE
))
4276 strcat (buf
, ", absolute");
4277 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4279 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
4280 strcat (buf
, ", vms_linkages");
4281 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
4283 case EF_IA_64_VMS_COMCOD_SUCCESS
:
4285 case EF_IA_64_VMS_COMCOD_WARNING
:
4286 strcat (buf
, ", warning");
4288 case EF_IA_64_VMS_COMCOD_ERROR
:
4289 strcat (buf
, ", error");
4291 case EF_IA_64_VMS_COMCOD_ABORT
:
4292 strcat (buf
, ", abort");
4295 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
4296 e_flags
& EF_IA_64_VMS_COMCOD
);
4297 strcat (buf
, ", <unknown>");
4303 if ((e_flags
& EF_VAX_NONPIC
))
4304 strcat (buf
, ", non-PIC");
4305 if ((e_flags
& EF_VAX_DFLOAT
))
4306 strcat (buf
, ", D-Float");
4307 if ((e_flags
& EF_VAX_GFLOAT
))
4308 strcat (buf
, ", G-Float");
4312 if (e_flags
& EF_VISIUM_ARCH_MCM
)
4313 strcat (buf
, ", mcm");
4314 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
4315 strcat (buf
, ", mcm24");
4316 if (e_flags
& EF_VISIUM_ARCH_GR6
)
4317 strcat (buf
, ", gr6");
4321 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
4323 case E_FLAG_RL78_ANY_CPU
: break;
4324 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
4325 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
4326 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
4328 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
4329 strcat (buf
, ", 64-bit doubles");
4333 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
4334 strcat (buf
, ", 64-bit doubles");
4335 if (e_flags
& E_FLAG_RX_DSP
)
4336 strcat (buf
, ", dsp");
4337 if (e_flags
& E_FLAG_RX_PID
)
4338 strcat (buf
, ", pid");
4339 if (e_flags
& E_FLAG_RX_ABI
)
4340 strcat (buf
, ", RX ABI");
4341 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
4342 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
4343 ? ", uses String instructions" : ", bans String instructions");
4344 if (e_flags
& E_FLAG_RX_V2
)
4345 strcat (buf
, ", V2");
4346 if (e_flags
& E_FLAG_RX_V3
)
4347 strcat (buf
, ", V3");
4351 if (e_flags
& EF_S390_HIGH_GPRS
)
4352 strcat (buf
, ", highgprs");
4356 if ((e_flags
& EF_C6000_REL
))
4357 strcat (buf
, ", relocatable module");
4361 strcat (buf
, _(": architecture variant: "));
4362 switch (e_flags
& EF_MSP430_MACH
)
4364 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
4365 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
4366 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
4367 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
4368 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
4369 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
4370 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
4371 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
4372 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
4373 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
4374 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
4375 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
4376 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
4377 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
4378 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
4380 strcat (buf
, _(": unknown")); break;
4383 if (e_flags
& ~ EF_MSP430_MACH
)
4384 strcat (buf
, _(": unknown extra flag bits also present"));
4388 switch (e_flags
& EF_Z80_MACH_MSK
)
4390 case EF_Z80_MACH_Z80
: strcat (buf
, ", Z80"); break;
4391 case EF_Z80_MACH_Z180
: strcat (buf
, ", Z180"); break;
4392 case EF_Z80_MACH_R800
: strcat (buf
, ", R800"); break;
4393 case EF_Z80_MACH_EZ80_Z80
: strcat (buf
, ", EZ80"); break;
4394 case EF_Z80_MACH_EZ80_ADL
: strcat (buf
, ", EZ80, ADL"); break;
4395 case EF_Z80_MACH_GBZ80
: strcat (buf
, ", GBZ80"); break;
4396 case EF_Z80_MACH_Z80N
: strcat (buf
, ", Z80N"); break;
4398 strcat (buf
, _(", unknown")); break;
4402 if (EF_LOONGARCH_IS_SOFT_FLOAT (e_flags
))
4403 strcat (buf
, ", SOFT-FLOAT");
4404 else if (EF_LOONGARCH_IS_SINGLE_FLOAT (e_flags
))
4405 strcat (buf
, ", SINGLE-FLOAT");
4406 else if (EF_LOONGARCH_IS_DOUBLE_FLOAT (e_flags
))
4407 strcat (buf
, ", DOUBLE-FLOAT");
4409 if (EF_LOONGARCH_IS_OBJ_V0 (e_flags
))
4410 strcat (buf
, ", OBJ-v0");
4411 else if (EF_LOONGARCH_IS_OBJ_V1 (e_flags
))
4412 strcat (buf
, ", OBJ-v1");
4422 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
4424 static char buff
[32];
4428 case ELFOSABI_NONE
: return "UNIX - System V";
4429 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
4430 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
4431 case ELFOSABI_GNU
: return "UNIX - GNU";
4432 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
4433 case ELFOSABI_AIX
: return "UNIX - AIX";
4434 case ELFOSABI_IRIX
: return "UNIX - IRIX";
4435 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
4436 case ELFOSABI_TRU64
: return "UNIX - TRU64";
4437 case ELFOSABI_MODESTO
: return "Novell - Modesto";
4438 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
4439 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
4440 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
4441 case ELFOSABI_AROS
: return "AROS";
4442 case ELFOSABI_FENIXOS
: return "FenixOS";
4443 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
4444 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
4447 switch (filedata
->file_header
.e_machine
)
4452 case ELFOSABI_AMDGPU_HSA
: return "AMD HSA";
4453 case ELFOSABI_AMDGPU_PAL
: return "AMD PAL";
4454 case ELFOSABI_AMDGPU_MESA3D
: return "AMD Mesa3D";
4463 case ELFOSABI_ARM
: return "ARM";
4464 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
4475 case ELFOSABI_STANDALONE
: return _("Standalone App");
4484 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
4485 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
4494 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
4500 get_aarch64_segment_type (unsigned long type
)
4504 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
4505 case PT_AARCH64_MEMTAG_MTE
: return "AARCH64_MEMTAG_MTE";
4506 default: return NULL
;
4511 get_arm_segment_type (unsigned long type
)
4515 case PT_ARM_EXIDX
: return "EXIDX";
4516 default: return NULL
;
4521 get_s390_segment_type (unsigned long type
)
4525 case PT_S390_PGSTE
: return "S390_PGSTE";
4526 default: return NULL
;
4531 get_mips_segment_type (unsigned long type
)
4535 case PT_MIPS_REGINFO
: return "REGINFO";
4536 case PT_MIPS_RTPROC
: return "RTPROC";
4537 case PT_MIPS_OPTIONS
: return "OPTIONS";
4538 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
4539 default: return NULL
;
4544 get_parisc_segment_type (unsigned long type
)
4548 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
4549 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
4550 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
4551 default: return NULL
;
4556 get_ia64_segment_type (unsigned long type
)
4560 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
4561 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
4562 default: return NULL
;
4567 get_tic6x_segment_type (unsigned long type
)
4571 case PT_C6000_PHATTR
: return "C6000_PHATTR";
4572 default: return NULL
;
4577 get_riscv_segment_type (unsigned long type
)
4581 case PT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4582 default: return NULL
;
4587 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
4589 if (e_machine
== EM_PARISC
)
4592 case PT_HP_TLS
: return "HP_TLS";
4593 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
4594 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
4595 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
4596 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
4597 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
4598 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
4599 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
4600 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
4601 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
4602 case PT_HP_PARALLEL
: return "HP_PARALLEL";
4603 case PT_HP_FASTBIND
: return "HP_FASTBIND";
4604 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
4605 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
4606 case PT_HP_STACK
: return "HP_STACK";
4607 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
4608 default: return NULL
;
4611 if (e_machine
== EM_IA_64
)
4614 case PT_HP_TLS
: return "HP_TLS";
4615 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
4616 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
4617 case PT_IA_64_HP_STACK
: return "HP_STACK";
4618 default: return NULL
;
4625 get_solaris_segment_type (unsigned long type
)
4629 case 0x6464e550: return "PT_SUNW_UNWIND";
4630 case 0x6474e550: return "PT_SUNW_EH_FRAME";
4631 case 0x6ffffff7: return "PT_LOSUNW";
4632 case 0x6ffffffa: return "PT_SUNWBSS";
4633 case 0x6ffffffb: return "PT_SUNWSTACK";
4634 case 0x6ffffffc: return "PT_SUNWDTRACE";
4635 case 0x6ffffffd: return "PT_SUNWCAP";
4636 case 0x6fffffff: return "PT_HISUNW";
4637 default: return NULL
;
4642 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
4644 static char buff
[32];
4648 case PT_NULL
: return "NULL";
4649 case PT_LOAD
: return "LOAD";
4650 case PT_DYNAMIC
: return "DYNAMIC";
4651 case PT_INTERP
: return "INTERP";
4652 case PT_NOTE
: return "NOTE";
4653 case PT_SHLIB
: return "SHLIB";
4654 case PT_PHDR
: return "PHDR";
4655 case PT_TLS
: return "TLS";
4656 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
4657 case PT_GNU_STACK
: return "GNU_STACK";
4658 case PT_GNU_RELRO
: return "GNU_RELRO";
4659 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
4660 case PT_GNU_SFRAME
: return "GNU_SFRAME";
4662 case PT_OPENBSD_MUTABLE
: return "OPENBSD_MUTABLE";
4663 case PT_OPENBSD_RANDOMIZE
: return "OPENBSD_RANDOMIZE";
4664 case PT_OPENBSD_WXNEEDED
: return "OPENBSD_WXNEEDED";
4665 case PT_OPENBSD_BOOTDATA
: return "OPENBSD_BOOTDATA";
4668 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
4670 const char * result
;
4672 switch (filedata
->file_header
.e_machine
)
4675 result
= get_aarch64_segment_type (p_type
);
4678 result
= get_arm_segment_type (p_type
);
4681 case EM_MIPS_RS3_LE
:
4682 result
= get_mips_segment_type (p_type
);
4685 result
= get_parisc_segment_type (p_type
);
4688 result
= get_ia64_segment_type (p_type
);
4691 result
= get_tic6x_segment_type (p_type
);
4695 result
= get_s390_segment_type (p_type
);
4698 result
= get_riscv_segment_type (p_type
);
4708 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
4710 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
4712 const char * result
= NULL
;
4714 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
4717 case ELFOSABI_FREEBSD
:
4718 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
4720 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
4725 result
= get_hpux_segment_type (p_type
,
4726 filedata
->file_header
.e_machine
);
4728 case ELFOSABI_SOLARIS
:
4729 result
= get_solaris_segment_type (p_type
);
4737 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4740 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4747 get_arc_section_type_name (unsigned int sh_type
)
4751 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4759 get_mips_section_type_name (unsigned int sh_type
)
4763 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4764 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4765 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4766 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4767 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4768 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4769 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4770 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4771 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4772 case SHT_MIPS_RELD
: return "MIPS_RELD";
4773 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4774 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4775 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4776 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4777 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4778 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4779 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4780 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4781 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4782 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4783 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4784 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4785 case SHT_MIPS_LINE
: return "MIPS_LINE";
4786 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4787 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4788 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4789 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4790 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4791 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4792 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4793 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4794 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4795 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4796 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4797 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4798 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4799 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4800 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4801 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4802 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4803 case SHT_MIPS_XHASH
: return "MIPS_XHASH";
4811 get_parisc_section_type_name (unsigned int sh_type
)
4815 case SHT_PARISC_EXT
: return "PARISC_EXT";
4816 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4817 case SHT_PARISC_DOC
: return "PARISC_DOC";
4818 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4819 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4820 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4821 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4822 default: return NULL
;
4827 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4829 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4830 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4831 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4835 case SHT_IA_64_EXT
: return "IA_64_EXT";
4836 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4837 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4838 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4839 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4840 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4841 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4842 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4843 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4844 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4852 get_x86_64_section_type_name (unsigned int sh_type
)
4856 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4857 default: return NULL
;
4862 get_aarch64_section_type_name (unsigned int sh_type
)
4866 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4867 default: return NULL
;
4872 get_arm_section_type_name (unsigned int sh_type
)
4876 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4877 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4878 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4879 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4880 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4881 default: return NULL
;
4886 get_tic6x_section_type_name (unsigned int sh_type
)
4890 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4891 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4892 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4893 case SHT_TI_ICODE
: return "TI_ICODE";
4894 case SHT_TI_XREF
: return "TI_XREF";
4895 case SHT_TI_HANDLER
: return "TI_HANDLER";
4896 case SHT_TI_INITINFO
: return "TI_INITINFO";
4897 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4898 default: return NULL
;
4903 get_msp430_section_type_name (unsigned int sh_type
)
4907 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4908 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4909 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4910 default: return NULL
;
4915 get_nfp_section_type_name (unsigned int sh_type
)
4919 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4920 case SHT_NFP_INITREG
: return "NFP_INITREG";
4921 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4922 default: return NULL
;
4927 get_v850_section_type_name (unsigned int sh_type
)
4931 case SHT_V850_SCOMMON
: return "V850 Small Common";
4932 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4933 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4934 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4935 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4936 default: return NULL
;
4941 get_riscv_section_type_name (unsigned int sh_type
)
4945 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4946 default: return NULL
;
4951 get_csky_section_type_name (unsigned int sh_type
)
4955 case SHT_CSKY_ATTRIBUTES
: return "CSKY_ATTRIBUTES";
4956 default: return NULL
;
4961 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4963 static char buff
[32];
4964 const char * result
;
4968 case SHT_NULL
: return "NULL";
4969 case SHT_PROGBITS
: return "PROGBITS";
4970 case SHT_SYMTAB
: return "SYMTAB";
4971 case SHT_STRTAB
: return "STRTAB";
4972 case SHT_RELA
: return "RELA";
4973 case SHT_RELR
: return "RELR";
4974 case SHT_HASH
: return "HASH";
4975 case SHT_DYNAMIC
: return "DYNAMIC";
4976 case SHT_NOTE
: return "NOTE";
4977 case SHT_NOBITS
: return "NOBITS";
4978 case SHT_REL
: return "REL";
4979 case SHT_SHLIB
: return "SHLIB";
4980 case SHT_DYNSYM
: return "DYNSYM";
4981 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4982 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4983 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4984 case SHT_GNU_HASH
: return "GNU_HASH";
4985 case SHT_GROUP
: return "GROUP";
4986 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4987 case SHT_GNU_verdef
: return "VERDEF";
4988 case SHT_GNU_verneed
: return "VERNEED";
4989 case SHT_GNU_versym
: return "VERSYM";
4990 case 0x6ffffff0: return "VERSYM";
4991 case 0x6ffffffc: return "VERDEF";
4992 case 0x7ffffffd: return "AUXILIARY";
4993 case 0x7fffffff: return "FILTER";
4994 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4997 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4999 switch (filedata
->file_header
.e_machine
)
5002 case EM_ARC_COMPACT
:
5003 case EM_ARC_COMPACT2
:
5004 case EM_ARC_COMPACT3
:
5005 case EM_ARC_COMPACT3_64
:
5006 result
= get_arc_section_type_name (sh_type
);
5009 case EM_MIPS_RS3_LE
:
5010 result
= get_mips_section_type_name (sh_type
);
5013 result
= get_parisc_section_type_name (sh_type
);
5016 result
= get_ia64_section_type_name (filedata
, sh_type
);
5021 result
= get_x86_64_section_type_name (sh_type
);
5024 result
= get_aarch64_section_type_name (sh_type
);
5027 result
= get_arm_section_type_name (sh_type
);
5030 result
= get_tic6x_section_type_name (sh_type
);
5033 result
= get_msp430_section_type_name (sh_type
);
5036 result
= get_nfp_section_type_name (sh_type
);
5040 case EM_CYGNUS_V850
:
5041 result
= get_v850_section_type_name (sh_type
);
5044 result
= get_riscv_section_type_name (sh_type
);
5047 result
= get_csky_section_type_name (sh_type
);
5057 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
5059 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
5061 switch (filedata
->file_header
.e_machine
)
5064 result
= get_ia64_section_type_name (filedata
, sh_type
);
5067 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
5068 result
= get_solaris_section_type (sh_type
);
5073 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
5074 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
5075 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
5076 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
5088 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
5090 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
5092 switch (filedata
->file_header
.e_machine
)
5096 case EM_CYGNUS_V850
:
5097 result
= get_v850_section_type_name (sh_type
);
5107 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
5110 /* This message is probably going to be displayed in a 15
5111 character wide field, so put the hex value first. */
5112 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
5118 enum long_option_values
5120 OPTION_DEBUG_DUMP
= 512,
5131 OPTION_WITH_SYMBOL_VERSIONS
,
5132 OPTION_RECURSE_LIMIT
,
5133 OPTION_NO_RECURSE_LIMIT
,
5134 OPTION_NO_DEMANGLING
,
5138 static struct option options
[] =
5140 /* Note - This table is alpha-sorted on the 'val'
5141 field in order to make adding new options easier. */
5142 {"arch-specific", no_argument
, 0, 'A'},
5143 {"all", no_argument
, 0, 'a'},
5144 {"demangle", optional_argument
, 0, 'C'},
5145 {"archive-index", no_argument
, 0, 'c'},
5146 {"use-dynamic", no_argument
, 0, 'D'},
5147 {"dynamic", no_argument
, 0, 'd'},
5148 {"headers", no_argument
, 0, 'e'},
5149 {"section-groups", no_argument
, 0, 'g'},
5150 {"help", no_argument
, 0, 'H'},
5151 {"file-header", no_argument
, 0, 'h'},
5152 {"histogram", no_argument
, 0, 'I'},
5153 {"lint", no_argument
, 0, 'L'},
5154 {"enable-checks", no_argument
, 0, 'L'},
5155 {"program-headers", no_argument
, 0, 'l'},
5156 {"segments", no_argument
, 0, 'l'},
5157 {"full-section-name",no_argument
, 0, 'N'},
5158 {"notes", no_argument
, 0, 'n'},
5159 {"process-links", no_argument
, 0, 'P'},
5160 {"string-dump", required_argument
, 0, 'p'},
5161 {"relocated-dump", required_argument
, 0, 'R'},
5162 {"relocs", no_argument
, 0, 'r'},
5163 {"section-headers", no_argument
, 0, 'S'},
5164 {"sections", no_argument
, 0, 'S'},
5165 {"symbols", no_argument
, 0, 's'},
5166 {"syms", no_argument
, 0, 's'},
5167 {"silent-truncation",no_argument
, 0, 'T'},
5168 {"section-details", no_argument
, 0, 't'},
5169 {"unicode", required_argument
, NULL
, 'U'},
5170 {"unwind", no_argument
, 0, 'u'},
5171 {"version-info", no_argument
, 0, 'V'},
5172 {"version", no_argument
, 0, 'v'},
5173 {"wide", no_argument
, 0, 'W'},
5174 {"hex-dump", required_argument
, 0, 'x'},
5175 {"decompress", no_argument
, 0, 'z'},
5177 {"no-demangle", no_argument
, 0, OPTION_NO_DEMANGLING
},
5178 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
5179 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
5180 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
5181 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
5182 {"lto-syms", no_argument
, 0, OPTION_LTO_SYMS
},
5183 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
5184 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
5185 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
5186 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
5187 #ifdef ENABLE_LIBCTF
5188 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
5189 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
5190 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
5191 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
5193 {"sframe", optional_argument
, 0, OPTION_SFRAME_DUMP
},
5194 {"sym-base", optional_argument
, 0, OPTION_SYM_BASE
},
5196 {0, no_argument
, 0, 0}
5200 usage (FILE * stream
)
5202 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
5203 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
5204 fprintf (stream
, _(" Options are:\n"));
5205 fprintf (stream
, _("\
5206 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
5207 fprintf (stream
, _("\
5208 -h --file-header Display the ELF file header\n"));
5209 fprintf (stream
, _("\
5210 -l --program-headers Display the program headers\n"));
5211 fprintf (stream
, _("\
5212 --segments An alias for --program-headers\n"));
5213 fprintf (stream
, _("\
5214 -S --section-headers Display the sections' header\n"));
5215 fprintf (stream
, _("\
5216 --sections An alias for --section-headers\n"));
5217 fprintf (stream
, _("\
5218 -g --section-groups Display the section groups\n"));
5219 fprintf (stream
, _("\
5220 -t --section-details Display the section details\n"));
5221 fprintf (stream
, _("\
5222 -e --headers Equivalent to: -h -l -S\n"));
5223 fprintf (stream
, _("\
5224 -s --syms Display the symbol table\n"));
5225 fprintf (stream
, _("\
5226 --symbols An alias for --syms\n"));
5227 fprintf (stream
, _("\
5228 --dyn-syms Display the dynamic symbol table\n"));
5229 fprintf (stream
, _("\
5230 --lto-syms Display LTO symbol tables\n"));
5231 fprintf (stream
, _("\
5232 --sym-base=[0|8|10|16] \n\
5233 Force base for symbol sizes. The options are \n\
5234 mixed (the default), octal, decimal, hexadecimal.\n"));
5235 fprintf (stream
, _("\
5236 -C --demangle[=STYLE] Decode mangled/processed symbol names\n"));
5237 display_demangler_styles (stream
, _("\
5239 fprintf (stream
, _("\
5240 --no-demangle Do not demangle low-level symbol names. (default)\n"));
5241 fprintf (stream
, _("\
5242 --recurse-limit Enable a demangling recursion limit. (default)\n"));
5243 fprintf (stream
, _("\
5244 --no-recurse-limit Disable a demangling recursion limit\n"));
5245 fprintf (stream
, _("\
5246 -U[dlexhi] --unicode=[default|locale|escape|hex|highlight|invalid]\n\
5247 Display unicode characters as determined by the current locale\n\
5248 (default), escape sequences, \"<hex sequences>\", highlighted\n\
5249 escape sequences, or treat them as invalid and display as\n\
5250 \"{hex sequences}\"\n"));
5251 fprintf (stream
, _("\
5252 -n --notes Display the core notes (if present)\n"));
5253 fprintf (stream
, _("\
5254 -r --relocs Display the relocations (if present)\n"));
5255 fprintf (stream
, _("\
5256 -u --unwind Display the unwind info (if present)\n"));
5257 fprintf (stream
, _("\
5258 -d --dynamic Display the dynamic section (if present)\n"));
5259 fprintf (stream
, _("\
5260 -V --version-info Display the version sections (if present)\n"));
5261 fprintf (stream
, _("\
5262 -A --arch-specific Display architecture specific information (if any)\n"));
5263 fprintf (stream
, _("\
5264 -c --archive-index Display the symbol/file index in an archive\n"));
5265 fprintf (stream
, _("\
5266 -D --use-dynamic Use the dynamic section info when displaying symbols\n"));
5267 fprintf (stream
, _("\
5268 -L --lint|--enable-checks\n\
5269 Display warning messages for possible problems\n"));
5270 fprintf (stream
, _("\
5271 -x --hex-dump=<number|name>\n\
5272 Dump the contents of section <number|name> as bytes\n"));
5273 fprintf (stream
, _("\
5274 -p --string-dump=<number|name>\n\
5275 Dump the contents of section <number|name> as strings\n"));
5276 fprintf (stream
, _("\
5277 -R --relocated-dump=<number|name>\n\
5278 Dump the relocated contents of section <number|name>\n"));
5279 fprintf (stream
, _("\
5280 -z --decompress Decompress section before dumping it\n"));
5281 fprintf (stream
, _("\
5282 -w --debug-dump[a/=abbrev, A/=addr, r/=aranges, c/=cu_index, L/=decodedline,\n\
5283 f/=frames, F/=frames-interp, g/=gdb_index, i/=info, o/=loc,\n\
5284 m/=macro, p/=pubnames, t/=pubtypes, R/=Ranges, l/=rawline,\n\
5285 s/=str, O/=str-offsets, u/=trace_abbrev, T/=trace_aranges,\n\
5287 Display the contents of DWARF debug sections\n"));
5288 fprintf (stream
, _("\
5289 -wk --debug-dump=links Display the contents of sections that link to separate\n\
5290 debuginfo files\n"));
5291 fprintf (stream
, _("\
5292 -P --process-links Display the contents of non-debug sections in separate\n\
5293 debuginfo files. (Implies -wK)\n"));
5294 #if DEFAULT_FOR_FOLLOW_LINKS
5295 fprintf (stream
, _("\
5296 -wK --debug-dump=follow-links\n\
5297 Follow links to separate debug info files (default)\n"));
5298 fprintf (stream
, _("\
5299 -wN --debug-dump=no-follow-links\n\
5300 Do not follow links to separate debug info files\n"));
5302 fprintf (stream
, _("\
5303 -wK --debug-dump=follow-links\n\
5304 Follow links to separate debug info files\n"));
5305 fprintf (stream
, _("\
5306 -wN --debug-dump=no-follow-links\n\
5307 Do not follow links to separate debug info files\n\
5310 #if HAVE_LIBDEBUGINFOD
5311 fprintf (stream
, _("\
5312 -wD --debug-dump=use-debuginfod\n\
5313 When following links, also query debuginfod servers (default)\n"));
5314 fprintf (stream
, _("\
5315 -wE --debug-dump=do-not-use-debuginfod\n\
5316 When following links, do not query debuginfod servers\n"));
5318 fprintf (stream
, _("\
5319 --dwarf-depth=N Do not display DIEs at depth N or greater\n"));
5320 fprintf (stream
, _("\
5321 --dwarf-start=N Display DIEs starting at offset N\n"));
5322 #ifdef ENABLE_LIBCTF
5323 fprintf (stream
, _("\
5324 --ctf=<number|name> Display CTF info from section <number|name>\n"));
5325 fprintf (stream
, _("\
5326 --ctf-parent=<name> Use CTF archive member <name> as the CTF parent\n"));
5327 fprintf (stream
, _("\
5328 --ctf-symbols=<number|name>\n\
5329 Use section <number|name> as the CTF external symtab\n"));
5330 fprintf (stream
, _("\
5331 --ctf-strings=<number|name>\n\
5332 Use section <number|name> as the CTF external strtab\n"));
5334 fprintf (stream
, _("\
5335 --sframe[=NAME] Display SFrame info from section NAME, (default '.sframe')\n"));
5337 #ifdef SUPPORT_DISASSEMBLY
5338 fprintf (stream
, _("\
5339 -i --instruction-dump=<number|name>\n\
5340 Disassemble the contents of section <number|name>\n"));
5342 fprintf (stream
, _("\
5343 -I --histogram Display histogram of bucket list lengths\n"));
5344 fprintf (stream
, _("\
5345 -W --wide Allow output width to exceed 80 characters\n"));
5346 fprintf (stream
, _("\
5347 -T --silent-truncation If a symbol name is truncated, do not add [...] suffix\n"));
5348 fprintf (stream
, _("\
5349 @<file> Read options from <file>\n"));
5350 fprintf (stream
, _("\
5351 -H --help Display this information\n"));
5352 fprintf (stream
, _("\
5353 -v --version Display the version number of readelf\n"));
5355 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
5356 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
5358 exit (stream
== stdout
? 0 : 1);
5361 /* Record the fact that the user wants the contents of section number
5362 SECTION to be displayed using the method(s) encoded as flags bits
5363 in TYPE. Note, TYPE can be zero if we are creating the array for
5367 request_dump_bynumber (struct dump_data
*dumpdata
,
5368 unsigned int section
, dump_type type
)
5370 if (section
>= dumpdata
->num_dump_sects
)
5372 dump_type
* new_dump_sects
;
5374 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
5375 sizeof (* new_dump_sects
));
5377 if (new_dump_sects
== NULL
)
5378 error (_("Out of memory allocating dump request table.\n"));
5381 if (dumpdata
->dump_sects
)
5383 /* Copy current flag settings. */
5384 memcpy (new_dump_sects
, dumpdata
->dump_sects
,
5385 dumpdata
->num_dump_sects
* sizeof (* new_dump_sects
));
5387 free (dumpdata
->dump_sects
);
5390 dumpdata
->dump_sects
= new_dump_sects
;
5391 dumpdata
->num_dump_sects
= section
+ 1;
5395 if (dumpdata
->dump_sects
)
5396 dumpdata
->dump_sects
[section
] |= type
;
5399 /* Request a dump by section name. */
5402 request_dump_byname (const char * section
, dump_type type
)
5404 struct dump_list_entry
* new_request
;
5406 new_request
= (struct dump_list_entry
*)
5407 malloc (sizeof (struct dump_list_entry
));
5409 error (_("Out of memory allocating dump request table.\n"));
5411 new_request
->name
= strdup (section
);
5412 if (!new_request
->name
)
5413 error (_("Out of memory allocating dump request table.\n"));
5415 new_request
->type
= type
;
5417 new_request
->next
= dump_sects_byname
;
5418 dump_sects_byname
= new_request
;
5422 request_dump (struct dump_data
*dumpdata
, dump_type type
)
5428 section
= strtoul (optarg
, & cp
, 0);
5430 if (! *cp
&& section
>= 0)
5431 request_dump_bynumber (dumpdata
, section
, type
);
5433 request_dump_byname (optarg
, type
);
5437 parse_args (struct dump_data
*dumpdata
, int argc
, char ** argv
)
5444 while ((c
= getopt_long
5445 (argc
, argv
, "ACDHILNPR:STU:VWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
5463 do_section_groups
= true;
5466 do_histogram
= true;
5472 do_section_groups
= true;
5477 do_section_details
= true;
5488 do_using_dynamic
= true;
5512 do_histogram
= true;
5518 do_archive_index
= true;
5524 process_links
= true;
5525 do_follow_links
= true;
5526 dump_any_debugging
= true;
5529 request_dump (dumpdata
, HEX_DUMP
);
5532 request_dump (dumpdata
, STRING_DUMP
);
5535 request_dump (dumpdata
, RELOC_DUMP
);
5538 decompress_dumps
= true;
5543 do_debugging
= true;
5545 dump_any_debugging
= true;
5546 dwarf_select_sections_all ();
5550 do_debugging
= false;
5551 if (dwarf_select_sections_by_letters (optarg
))
5554 dump_any_debugging
= true;
5558 case OPTION_DEBUG_DUMP
:
5562 do_debugging
= true;
5563 dump_any_debugging
= true;
5564 dwarf_select_sections_all ();
5568 do_debugging
= false;
5569 if (dwarf_select_sections_by_names (optarg
))
5572 dump_any_debugging
= true;
5576 case OPTION_DWARF_DEPTH
:
5580 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
5583 case OPTION_DWARF_START
:
5587 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
5590 case OPTION_DWARF_CHECK
:
5593 case OPTION_CTF_DUMP
:
5595 request_dump (dumpdata
, CTF_DUMP
);
5597 case OPTION_CTF_SYMBOLS
:
5598 free (dump_ctf_symtab_name
);
5599 dump_ctf_symtab_name
= strdup (optarg
);
5601 case OPTION_CTF_STRINGS
:
5602 free (dump_ctf_strtab_name
);
5603 dump_ctf_strtab_name
= strdup (optarg
);
5605 case OPTION_CTF_PARENT
:
5606 free (dump_ctf_parent_name
);
5607 dump_ctf_parent_name
= strdup (optarg
);
5609 case OPTION_SFRAME_DUMP
:
5611 /* Providing section name is optional. request_dump (), however,
5612 thrives on non NULL optarg. Handle it explicitly here. */
5614 request_dump (dumpdata
, SFRAME_DUMP
);
5618 const char *sframe_sec_name
= strdup (".sframe");
5619 request_dump_byname (sframe_sec_name
, SFRAME_DUMP
);
5622 case OPTION_DYN_SYMS
:
5625 case OPTION_LTO_SYMS
:
5628 #ifdef SUPPORT_DISASSEMBLY
5630 request_dump (dumpdata
, DISASS_DUMP
);
5634 print_version (program_name
);
5643 do_not_show_symbol_truncation
= true;
5649 enum demangling_styles style
;
5651 style
= cplus_demangle_name_to_style (optarg
);
5652 if (style
== unknown_demangling
)
5653 error (_("unknown demangling style `%s'"), optarg
);
5655 cplus_demangle_set_style (style
);
5658 case OPTION_NO_DEMANGLING
:
5659 do_demangle
= false;
5661 case OPTION_RECURSE_LIMIT
:
5662 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
5664 case OPTION_NO_RECURSE_LIMIT
:
5665 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
5667 case OPTION_WITH_SYMBOL_VERSIONS
:
5668 /* Ignored for backward compatibility. */
5673 error (_("Missing arg to -U/--unicode")); /* Can this happen ? */
5674 else if (streq (optarg
, "default") || streq (optarg
, "d"))
5675 unicode_display
= unicode_default
;
5676 else if (streq (optarg
, "locale") || streq (optarg
, "l"))
5677 unicode_display
= unicode_locale
;
5678 else if (streq (optarg
, "escape") || streq (optarg
, "e"))
5679 unicode_display
= unicode_escape
;
5680 else if (streq (optarg
, "invalid") || streq (optarg
, "i"))
5681 unicode_display
= unicode_invalid
;
5682 else if (streq (optarg
, "hex") || streq (optarg
, "x"))
5683 unicode_display
= unicode_hex
;
5684 else if (streq (optarg
, "highlight") || streq (optarg
, "h"))
5685 unicode_display
= unicode_highlight
;
5687 error (_("invalid argument to -U/--unicode: %s"), optarg
);
5690 case OPTION_SYM_BASE
:
5694 sym_base
= strtoul (optarg
, NULL
, 0);
5711 /* xgettext:c-format */
5712 error (_("Invalid option '-%c'\n"), c
);
5719 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
5720 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
5721 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
5722 && !do_section_groups
&& !do_archive_index
5723 && !do_dyn_syms
&& !do_lto_syms
)
5728 do_dynamic
= do_syms
= do_reloc
= do_unwind
= do_sections
= true;
5729 do_segments
= do_header
= do_dump
= do_version
= true;
5730 do_histogram
= do_debugging
= do_arch
= do_notes
= true;
5731 do_section_groups
= do_archive_index
= do_dyn_syms
= true;
5740 get_elf_class (unsigned int elf_class
)
5742 static char buff
[32];
5746 case ELFCLASSNONE
: return _("none");
5747 case ELFCLASS32
: return "ELF32";
5748 case ELFCLASS64
: return "ELF64";
5750 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
5756 get_data_encoding (unsigned int encoding
)
5758 static char buff
[32];
5762 case ELFDATANONE
: return _("none");
5763 case ELFDATA2LSB
: return _("2's complement, little endian");
5764 case ELFDATA2MSB
: return _("2's complement, big endian");
5766 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
5772 check_magic_number (Filedata
* filedata
, Elf_Internal_Ehdr
* header
)
5774 if (header
->e_ident
[EI_MAG0
] == ELFMAG0
5775 && header
->e_ident
[EI_MAG1
] == ELFMAG1
5776 && header
->e_ident
[EI_MAG2
] == ELFMAG2
5777 && header
->e_ident
[EI_MAG3
] == ELFMAG3
)
5780 /* Some compilers produce object files that are not in the ELF file format.
5781 As an aid to users of readelf, try to identify these cases and suggest
5784 FIXME: It is not clear if all four bytes are used as constant magic
5785 valus by all compilers. It may be necessary to recode this function if
5786 different tools use different length sequences. */
5790 unsigned char magic
[4];
5791 const char * obj_message
;
5792 const char * ar_message
;
5796 { { 'B', 'C', 0xc0, 0xde },
5797 N_("This is a LLVM bitcode file - try using llvm-bcanalyzer\n"),
5798 N_("This is a LLVM bitcode file - try extracing and then using llvm-bcanalyzer\n")
5800 { { 'g', 'o', ' ', 'o' },
5801 N_("This is a GO binary file - try using 'go tool objdump' or 'go tool nm'\n"),
5807 for (i
= ARRAY_SIZE (known_magic
); i
--;)
5809 if (header
->e_ident
[EI_MAG0
] == known_magic
[i
].magic
[0]
5810 && header
->e_ident
[EI_MAG1
] == known_magic
[i
].magic
[1]
5811 && header
->e_ident
[EI_MAG2
] == known_magic
[i
].magic
[2]
5812 && header
->e_ident
[EI_MAG3
] == known_magic
[i
].magic
[3])
5814 /* Some compiler's analyzer tools do not handle archives,
5815 so we provide two different kinds of error message. */
5816 if (filedata
->archive_file_size
> 0
5817 && known_magic
[i
].ar_message
!= NULL
)
5818 error ("%s", known_magic
[i
].ar_message
);
5820 error ("%s", known_magic
[i
].obj_message
);
5825 error (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
5829 /* Decode the data held in 'filedata->file_header'. */
5832 process_file_header (Filedata
* filedata
)
5834 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
5836 if (! check_magic_number (filedata
, header
))
5839 if (! filedata
->is_separate
)
5840 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
5846 if (filedata
->is_separate
)
5847 printf (_("ELF Header in linked file '%s':\n"), filedata
->file_name
);
5849 printf (_("ELF Header:\n"));
5850 printf (_(" Magic: "));
5851 for (i
= 0; i
< EI_NIDENT
; i
++)
5852 printf ("%2.2x ", header
->e_ident
[i
]);
5854 printf (_(" Class: %s\n"),
5855 get_elf_class (header
->e_ident
[EI_CLASS
]));
5856 printf (_(" Data: %s\n"),
5857 get_data_encoding (header
->e_ident
[EI_DATA
]));
5858 printf (_(" Version: %d%s\n"),
5859 header
->e_ident
[EI_VERSION
],
5860 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
5862 : (header
->e_ident
[EI_VERSION
] != EV_NONE
5865 printf (_(" OS/ABI: %s\n"),
5866 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
5867 printf (_(" ABI Version: %d\n"),
5868 header
->e_ident
[EI_ABIVERSION
]);
5869 printf (_(" Type: %s\n"),
5870 get_file_type (filedata
));
5871 printf (_(" Machine: %s\n"),
5872 get_machine_name (header
->e_machine
));
5873 printf (_(" Version: 0x%lx\n"),
5876 printf (_(" Entry point address: "));
5877 print_vma (header
->e_entry
, PREFIX_HEX
);
5878 printf (_("\n Start of program headers: "));
5879 print_vma (header
->e_phoff
, DEC
);
5880 printf (_(" (bytes into file)\n Start of section headers: "));
5881 print_vma (header
->e_shoff
, DEC
);
5882 printf (_(" (bytes into file)\n"));
5884 printf (_(" Flags: 0x%lx%s\n"),
5886 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
5887 printf (_(" Size of this header: %u (bytes)\n"),
5889 printf (_(" Size of program headers: %u (bytes)\n"),
5890 header
->e_phentsize
);
5891 printf (_(" Number of program headers: %u"),
5893 if (filedata
->section_headers
!= NULL
5894 && header
->e_phnum
== PN_XNUM
5895 && filedata
->section_headers
[0].sh_info
!= 0)
5896 printf (" (%u)", filedata
->section_headers
[0].sh_info
);
5897 putc ('\n', stdout
);
5898 printf (_(" Size of section headers: %u (bytes)\n"),
5899 header
->e_shentsize
);
5900 printf (_(" Number of section headers: %u"),
5902 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
5904 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5905 printf (" (%u)", header
->e_shnum
);
5907 putc ('\n', stdout
);
5908 printf (_(" Section header string table index: %u"),
5909 header
->e_shstrndx
);
5910 if (filedata
->section_headers
!= NULL
5911 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5913 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5914 printf (" (%u)", header
->e_shstrndx
);
5916 if (header
->e_shstrndx
!= SHN_UNDEF
5917 && header
->e_shstrndx
>= header
->e_shnum
)
5919 header
->e_shstrndx
= SHN_UNDEF
;
5920 printf (_(" <corrupt: out of range>"));
5922 putc ('\n', stdout
);
5925 if (filedata
->section_headers
!= NULL
)
5927 if (header
->e_phnum
== PN_XNUM
5928 && filedata
->section_headers
[0].sh_info
!= 0)
5930 /* Throw away any cached read of PN_XNUM headers. */
5931 free (filedata
->program_headers
);
5932 filedata
->program_headers
= NULL
;
5933 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
5935 if (header
->e_shnum
== SHN_UNDEF
)
5936 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5937 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5938 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5939 if (header
->e_shstrndx
>= header
->e_shnum
)
5940 header
->e_shstrndx
= SHN_UNDEF
;
5946 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5947 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
5950 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5952 Elf32_External_Phdr
* phdrs
;
5953 Elf32_External_Phdr
* external
;
5954 Elf_Internal_Phdr
* internal
;
5956 unsigned int size
= filedata
->file_header
.e_phentsize
;
5957 unsigned int num
= filedata
->file_header
.e_phnum
;
5959 /* PR binutils/17531: Cope with unexpected section header sizes. */
5960 if (size
== 0 || num
== 0)
5962 if (size
< sizeof * phdrs
)
5964 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5967 if (size
> sizeof * phdrs
)
5968 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5970 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5971 size
, num
, _("program headers"));
5975 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5976 i
< filedata
->file_header
.e_phnum
;
5977 i
++, internal
++, external
++)
5979 internal
->p_type
= BYTE_GET (external
->p_type
);
5980 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5981 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5982 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5983 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5984 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5985 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5986 internal
->p_align
= BYTE_GET (external
->p_align
);
5993 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5994 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5997 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5999 Elf64_External_Phdr
* phdrs
;
6000 Elf64_External_Phdr
* external
;
6001 Elf_Internal_Phdr
* internal
;
6003 unsigned int size
= filedata
->file_header
.e_phentsize
;
6004 unsigned int num
= filedata
->file_header
.e_phnum
;
6006 /* PR binutils/17531: Cope with unexpected section header sizes. */
6007 if (size
== 0 || num
== 0)
6009 if (size
< sizeof * phdrs
)
6011 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
6014 if (size
> sizeof * phdrs
)
6015 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
6017 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
6018 size
, num
, _("program headers"));
6022 for (i
= 0, internal
= pheaders
, external
= phdrs
;
6023 i
< filedata
->file_header
.e_phnum
;
6024 i
++, internal
++, external
++)
6026 internal
->p_type
= BYTE_GET (external
->p_type
);
6027 internal
->p_flags
= BYTE_GET (external
->p_flags
);
6028 internal
->p_offset
= BYTE_GET (external
->p_offset
);
6029 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
6030 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
6031 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
6032 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
6033 internal
->p_align
= BYTE_GET (external
->p_align
);
6040 /* Returns TRUE if the program headers were read into `program_headers'. */
6043 get_program_headers (Filedata
* filedata
)
6045 Elf_Internal_Phdr
* phdrs
;
6047 /* Check cache of prior read. */
6048 if (filedata
->program_headers
!= NULL
)
6051 /* Be kind to memory checkers by looking for
6052 e_phnum values which we know must be invalid. */
6053 if (filedata
->file_header
.e_phnum
6054 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
6055 >= filedata
->file_size
)
6057 error (_("Too many program headers - %#x - the file is not that big\n"),
6058 filedata
->file_header
.e_phnum
);
6062 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
6063 sizeof (Elf_Internal_Phdr
));
6066 error (_("Out of memory reading %u program headers\n"),
6067 filedata
->file_header
.e_phnum
);
6072 ? get_32bit_program_headers (filedata
, phdrs
)
6073 : get_64bit_program_headers (filedata
, phdrs
))
6075 filedata
->program_headers
= phdrs
;
6083 /* Print program header info and locate dynamic section. */
6086 process_program_headers (Filedata
* filedata
)
6088 Elf_Internal_Phdr
* segment
;
6090 Elf_Internal_Phdr
* previous_load
= NULL
;
6092 if (filedata
->file_header
.e_phnum
== 0)
6094 /* PR binutils/12467. */
6095 if (filedata
->file_header
.e_phoff
!= 0)
6096 warn (_("possibly corrupt ELF header - it has a non-zero program"
6097 " header offset, but no program headers\n"));
6098 else if (do_segments
)
6100 if (filedata
->is_separate
)
6101 printf (_("\nThere are no program headers in linked file '%s'.\n"),
6102 filedata
->file_name
);
6104 printf (_("\nThere are no program headers in this file.\n"));
6109 if (do_segments
&& !do_header
)
6111 if (filedata
->is_separate
)
6112 printf ("\nIn linked file '%s' the ELF file type is %s\n",
6113 filedata
->file_name
, get_file_type (filedata
));
6115 printf (_("\nElf file type is %s\n"), get_file_type (filedata
));
6116 printf (_("Entry point 0x%" PRIx64
"\n"),
6117 filedata
->file_header
.e_entry
);
6118 printf (ngettext ("There is %d program header,"
6119 " starting at offset %" PRIu64
"\n",
6120 "There are %d program headers,"
6121 " starting at offset %" PRIu64
"\n",
6122 filedata
->file_header
.e_phnum
),
6123 filedata
->file_header
.e_phnum
,
6124 filedata
->file_header
.e_phoff
);
6127 if (! get_program_headers (filedata
))
6132 if (filedata
->file_header
.e_phnum
> 1)
6133 printf (_("\nProgram Headers:\n"));
6135 printf (_("\nProgram Headers:\n"));
6139 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
6142 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
6146 (_(" Type Offset VirtAddr PhysAddr\n"));
6148 (_(" FileSiz MemSiz Flags Align\n"));
6152 uint64_t dynamic_addr
= 0;
6153 uint64_t dynamic_size
= 0;
6154 for (i
= 0, segment
= filedata
->program_headers
;
6155 i
< filedata
->file_header
.e_phnum
;
6160 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
6164 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
6165 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
6166 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
6167 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
6168 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
6170 (segment
->p_flags
& PF_R
? 'R' : ' '),
6171 (segment
->p_flags
& PF_W
? 'W' : ' '),
6172 (segment
->p_flags
& PF_X
? 'E' : ' '));
6173 printf ("%#lx", (unsigned long) segment
->p_align
);
6177 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
6178 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
6181 print_vma (segment
->p_offset
, FULL_HEX
);
6185 print_vma (segment
->p_vaddr
, FULL_HEX
);
6187 print_vma (segment
->p_paddr
, FULL_HEX
);
6190 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
6191 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
6194 print_vma (segment
->p_filesz
, FULL_HEX
);
6198 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
6199 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
6202 print_vma (segment
->p_memsz
, FULL_HEX
);
6206 (segment
->p_flags
& PF_R
? 'R' : ' '),
6207 (segment
->p_flags
& PF_W
? 'W' : ' '),
6208 (segment
->p_flags
& PF_X
? 'E' : ' '));
6210 if ((unsigned long) segment
->p_align
== segment
->p_align
)
6211 printf ("%#lx", (unsigned long) segment
->p_align
);
6214 print_vma (segment
->p_align
, PREFIX_HEX
);
6219 print_vma (segment
->p_offset
, FULL_HEX
);
6221 print_vma (segment
->p_vaddr
, FULL_HEX
);
6223 print_vma (segment
->p_paddr
, FULL_HEX
);
6225 print_vma (segment
->p_filesz
, FULL_HEX
);
6227 print_vma (segment
->p_memsz
, FULL_HEX
);
6229 (segment
->p_flags
& PF_R
? 'R' : ' '),
6230 (segment
->p_flags
& PF_W
? 'W' : ' '),
6231 (segment
->p_flags
& PF_X
? 'E' : ' '));
6232 print_vma (segment
->p_align
, PREFIX_HEX
);
6235 putc ('\n', stdout
);
6238 switch (segment
->p_type
)
6241 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
6242 required by the ELF standard, several programs, including the Linux
6243 kernel, make use of non-ordered segments. */
6245 && previous_load
->p_vaddr
> segment
->p_vaddr
)
6246 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
6248 if (segment
->p_memsz
< segment
->p_filesz
)
6249 error (_("the segment's file size is larger than its memory size\n"));
6250 previous_load
= segment
;
6254 /* PR 20815 - Verify that the program header is loaded into memory. */
6255 if (i
> 0 && previous_load
!= NULL
)
6256 error (_("the PHDR segment must occur before any LOAD segment\n"));
6257 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
6261 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
6263 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
6264 if (load
->p_type
== PT_LOAD
6265 && load
->p_offset
<= segment
->p_offset
6266 && (load
->p_offset
+ load
->p_filesz
6267 >= segment
->p_offset
+ segment
->p_filesz
)
6268 && load
->p_vaddr
<= segment
->p_vaddr
6269 && (load
->p_vaddr
+ load
->p_filesz
6270 >= segment
->p_vaddr
+ segment
->p_filesz
))
6273 if (j
== filedata
->file_header
.e_phnum
)
6274 error (_("the PHDR segment is not covered by a LOAD segment\n"));
6280 error (_("more than one dynamic segment\n"));
6282 /* By default, assume that the .dynamic section is the first
6283 section in the DYNAMIC segment. */
6284 dynamic_addr
= segment
->p_offset
;
6285 dynamic_size
= segment
->p_filesz
;
6287 /* Try to locate the .dynamic section. If there is
6288 a section header table, we can easily locate it. */
6289 if (filedata
->section_headers
!= NULL
)
6291 Elf_Internal_Shdr
* sec
;
6293 sec
= find_section (filedata
, ".dynamic");
6294 if (sec
== NULL
|| sec
->sh_size
== 0)
6296 /* A corresponding .dynamic section is expected, but on
6297 IA-64/OpenVMS it is OK for it to be missing. */
6298 if (!is_ia64_vms (filedata
))
6299 error (_("no .dynamic section in the dynamic segment\n"));
6303 if (sec
->sh_type
== SHT_NOBITS
)
6310 dynamic_addr
= sec
->sh_offset
;
6311 dynamic_size
= sec
->sh_size
;
6313 /* The PT_DYNAMIC segment, which is used by the run-time
6314 loader, should exactly match the .dynamic section. */
6316 && (dynamic_addr
!= segment
->p_offset
6317 || dynamic_size
!= segment
->p_filesz
))
6319 the .dynamic section is not the same as the dynamic segment\n"));
6322 /* PR binutils/17512: Avoid corrupt dynamic section info in the
6323 segment. Check this after matching against the section headers
6324 so we don't warn on debuginfo file (which have NOBITS .dynamic
6326 if (dynamic_addr
> filedata
->file_size
6327 || (dynamic_size
> filedata
->file_size
- dynamic_addr
))
6329 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
6336 if (segment
->p_offset
>= filedata
->file_size
6337 || segment
->p_filesz
> filedata
->file_size
- segment
->p_offset
6338 || segment
->p_filesz
- 1 >= (size_t) -2
6339 || fseek64 (filedata
->handle
,
6340 filedata
->archive_file_offset
+ segment
->p_offset
,
6342 error (_("Unable to find program interpreter name\n"));
6345 size_t len
= segment
->p_filesz
;
6346 free (filedata
->program_interpreter
);
6347 filedata
->program_interpreter
= xmalloc (len
+ 1);
6348 len
= fread (filedata
->program_interpreter
, 1, len
,
6350 filedata
->program_interpreter
[len
] = 0;
6353 printf (_(" [Requesting program interpreter: %s]\n"),
6354 filedata
->program_interpreter
);
6361 && filedata
->section_headers
!= NULL
6362 && filedata
->string_table
!= NULL
)
6364 printf (_("\n Section to Segment mapping:\n"));
6365 printf (_(" Segment Sections...\n"));
6367 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
6370 Elf_Internal_Shdr
* section
;
6372 segment
= filedata
->program_headers
+ i
;
6373 section
= filedata
->section_headers
+ 1;
6375 printf (" %2.2d ", i
);
6377 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
6379 if (!ELF_TBSS_SPECIAL (section
, segment
)
6380 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
6381 printf ("%s ", printable_section_name (filedata
, section
));
6388 filedata
->dynamic_addr
= dynamic_addr
;
6389 filedata
->dynamic_size
= dynamic_size
? dynamic_size
: 1;
6393 filedata
->dynamic_addr
= 0;
6394 filedata
->dynamic_size
= 1;
6398 /* Find the file offset corresponding to VMA by using the program headers. */
6401 offset_from_vma (Filedata
* filedata
, uint64_t vma
, uint64_t size
)
6403 Elf_Internal_Phdr
* seg
;
6405 if (! get_program_headers (filedata
))
6407 warn (_("Cannot interpret virtual addresses without program headers.\n"));
6411 for (seg
= filedata
->program_headers
;
6412 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
6415 if (seg
->p_type
!= PT_LOAD
)
6418 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
6419 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
6420 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
6423 warn (_("Virtual address %#" PRIx64
6424 " not located in any PT_LOAD segment.\n"), vma
);
6429 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
6430 If PROBE is true, this is just a probe and we do not generate any error
6431 messages if the load fails. */
6434 get_32bit_section_headers (Filedata
* filedata
, bool probe
)
6436 Elf32_External_Shdr
* shdrs
;
6437 Elf_Internal_Shdr
* internal
;
6439 unsigned int size
= filedata
->file_header
.e_shentsize
;
6440 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
6442 /* PR binutils/17531: Cope with unexpected section header sizes. */
6443 if (size
== 0 || num
== 0)
6446 /* The section header cannot be at the start of the file - that is
6447 where the ELF file header is located. A file with absolutely no
6448 sections in it will use a shoff of 0. */
6449 if (filedata
->file_header
.e_shoff
== 0)
6452 if (size
< sizeof * shdrs
)
6455 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
6458 if (!probe
&& size
> sizeof * shdrs
)
6459 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
6461 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
6463 probe
? NULL
: _("section headers"));
6467 filedata
->section_headers
= (Elf_Internal_Shdr
*)
6468 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
6469 if (filedata
->section_headers
== NULL
)
6472 error (_("Out of memory reading %u section headers\n"), num
);
6477 for (i
= 0, internal
= filedata
->section_headers
;
6481 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
6482 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
6483 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
6484 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
6485 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
6486 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
6487 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
6488 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
6489 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
6490 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
6491 if (!probe
&& internal
->sh_link
> num
)
6492 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
6493 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
6494 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
6501 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
6504 get_64bit_section_headers (Filedata
* filedata
, bool probe
)
6506 Elf64_External_Shdr
* shdrs
;
6507 Elf_Internal_Shdr
* internal
;
6509 unsigned int size
= filedata
->file_header
.e_shentsize
;
6510 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
6512 /* PR binutils/17531: Cope with unexpected section header sizes. */
6513 if (size
== 0 || num
== 0)
6516 /* The section header cannot be at the start of the file - that is
6517 where the ELF file header is located. A file with absolutely no
6518 sections in it will use a shoff of 0. */
6519 if (filedata
->file_header
.e_shoff
== 0)
6522 if (size
< sizeof * shdrs
)
6525 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
6529 if (! probe
&& size
> sizeof * shdrs
)
6530 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
6532 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
6533 filedata
->file_header
.e_shoff
,
6535 probe
? NULL
: _("section headers"));
6539 filedata
->section_headers
= (Elf_Internal_Shdr
*)
6540 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
6541 if (filedata
->section_headers
== NULL
)
6544 error (_("Out of memory reading %u section headers\n"), num
);
6549 for (i
= 0, internal
= filedata
->section_headers
;
6553 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
6554 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
6555 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
6556 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
6557 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
6558 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
6559 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
6560 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
6561 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
6562 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
6563 if (!probe
&& internal
->sh_link
> num
)
6564 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
6565 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
6566 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
6574 get_section_headers (Filedata
*filedata
, bool probe
)
6576 if (filedata
->section_headers
!= NULL
)
6580 return get_32bit_section_headers (filedata
, probe
);
6582 return get_64bit_section_headers (filedata
, probe
);
6585 static Elf_Internal_Sym
*
6586 get_32bit_elf_symbols (Filedata
*filedata
,
6587 Elf_Internal_Shdr
*section
,
6588 uint64_t *num_syms_return
)
6590 uint64_t number
= 0;
6591 Elf32_External_Sym
* esyms
= NULL
;
6592 Elf_External_Sym_Shndx
* shndx
= NULL
;
6593 Elf_Internal_Sym
* isyms
= NULL
;
6594 Elf_Internal_Sym
* psym
;
6596 elf_section_list
* entry
;
6598 if (section
->sh_size
== 0)
6600 if (num_syms_return
!= NULL
)
6601 * num_syms_return
= 0;
6605 /* Run some sanity checks first. */
6606 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
6608 error (_("Section %s has an invalid sh_entsize of %#" PRIx64
"\n"),
6609 printable_section_name (filedata
, section
),
6610 section
->sh_entsize
);
6614 if (section
->sh_size
> filedata
->file_size
)
6616 error (_("Section %s has an invalid sh_size of %#" PRIx64
"\n"),
6617 printable_section_name (filedata
, section
),
6622 number
= section
->sh_size
/ section
->sh_entsize
;
6624 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
6626 error (_("Size (%#" PRIx64
") of section %s "
6627 "is not a multiple of its sh_entsize (%#" PRIx64
")\n"),
6629 printable_section_name (filedata
, section
),
6630 section
->sh_entsize
);
6634 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
6635 section
->sh_size
, _("symbols"));
6640 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
6642 if (entry
->hdr
->sh_link
!= (size_t) (section
- filedata
->section_headers
))
6647 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
6651 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
6652 entry
->hdr
->sh_offset
,
6653 1, entry
->hdr
->sh_size
,
6654 _("symbol table section indices"));
6658 /* PR17531: file: heap-buffer-overflow */
6659 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
6661 error (_("Index section %s has an sh_size of %#" PRIx64
" - expected %#" PRIx64
"\n"),
6662 printable_section_name (filedata
, entry
->hdr
),
6663 entry
->hdr
->sh_size
,
6669 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
6673 error (_("Out of memory reading %" PRIu64
" symbols\n"), number
);
6677 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
6679 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
6680 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
6681 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
6682 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
6683 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
6685 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
6686 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
6687 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
6688 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
6689 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
6696 if (num_syms_return
!= NULL
)
6697 * num_syms_return
= isyms
== NULL
? 0 : number
;
6702 static Elf_Internal_Sym
*
6703 get_64bit_elf_symbols (Filedata
*filedata
,
6704 Elf_Internal_Shdr
*section
,
6705 uint64_t *num_syms_return
)
6707 uint64_t number
= 0;
6708 Elf64_External_Sym
* esyms
= NULL
;
6709 Elf_External_Sym_Shndx
* shndx
= NULL
;
6710 Elf_Internal_Sym
* isyms
= NULL
;
6711 Elf_Internal_Sym
* psym
;
6713 elf_section_list
* entry
;
6715 if (section
->sh_size
== 0)
6717 if (num_syms_return
!= NULL
)
6718 * num_syms_return
= 0;
6722 /* Run some sanity checks first. */
6723 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
6725 error (_("Section %s has an invalid sh_entsize of %#" PRIx64
"\n"),
6726 printable_section_name (filedata
, section
),
6727 section
->sh_entsize
);
6731 if (section
->sh_size
> filedata
->file_size
)
6733 error (_("Section %s has an invalid sh_size of %#" PRIx64
"\n"),
6734 printable_section_name (filedata
, section
),
6739 number
= section
->sh_size
/ section
->sh_entsize
;
6741 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
6743 error (_("Size (%#" PRIx64
") of section %s "
6744 "is not a multiple of its sh_entsize (%#" PRIx64
")\n"),
6746 printable_section_name (filedata
, section
),
6747 section
->sh_entsize
);
6751 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
6752 section
->sh_size
, _("symbols"));
6757 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
6759 if (entry
->hdr
->sh_link
!= (size_t) (section
- filedata
->section_headers
))
6764 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
6768 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
6769 entry
->hdr
->sh_offset
,
6770 1, entry
->hdr
->sh_size
,
6771 _("symbol table section indices"));
6775 /* PR17531: file: heap-buffer-overflow */
6776 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
6778 error (_("Index section %s has an sh_size of %#" PRIx64
" - expected %#" PRIx64
"\n"),
6779 printable_section_name (filedata
, entry
->hdr
),
6780 entry
->hdr
->sh_size
,
6786 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
6790 error (_("Out of memory reading %" PRIu64
" symbols\n"), number
);
6794 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
6796 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
6797 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
6798 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
6799 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
6801 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
6803 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
6804 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
6805 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
6807 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
6808 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
6815 if (num_syms_return
!= NULL
)
6816 * num_syms_return
= isyms
== NULL
? 0 : number
;
6821 static Elf_Internal_Sym
*
6822 get_elf_symbols (Filedata
*filedata
,
6823 Elf_Internal_Shdr
*section
,
6824 uint64_t *num_syms_return
)
6827 return get_32bit_elf_symbols (filedata
, section
, num_syms_return
);
6829 return get_64bit_elf_symbols (filedata
, section
, num_syms_return
);
6833 get_elf_section_flags (Filedata
* filedata
, uint64_t sh_flags
)
6835 static char buff
[1024];
6837 unsigned int field_size
= is_32bit_elf
? 8 : 16;
6839 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
6840 uint64_t os_flags
= 0;
6841 uint64_t proc_flags
= 0;
6842 uint64_t unknown_flags
= 0;
6850 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
6851 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
6852 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
6853 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
6854 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
6855 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
6856 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
6857 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
6858 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
6859 /* 9 */ { STRING_COMMA_LEN ("TLS") },
6860 /* IA-64 specific. */
6861 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
6862 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
6863 /* IA-64 OpenVMS specific. */
6864 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
6865 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
6866 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
6867 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
6868 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
6869 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
6871 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
6872 /* SPARC specific. */
6873 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
6874 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
6876 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
6877 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
6878 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
6880 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
6882 /* 25 */ { STRING_COMMA_LEN ("VLE") },
6884 /* 26 */ { STRING_COMMA_LEN ("GNU_RETAIN") },
6887 if (do_section_details
)
6889 sprintf (buff
, "[%*.*lx]: ",
6890 field_size
, field_size
, (unsigned long) sh_flags
);
6891 p
+= field_size
+ 4;
6898 flag
= sh_flags
& - sh_flags
;
6901 if (do_section_details
)
6905 case SHF_WRITE
: sindex
= 0; break;
6906 case SHF_ALLOC
: sindex
= 1; break;
6907 case SHF_EXECINSTR
: sindex
= 2; break;
6908 case SHF_MERGE
: sindex
= 3; break;
6909 case SHF_STRINGS
: sindex
= 4; break;
6910 case SHF_INFO_LINK
: sindex
= 5; break;
6911 case SHF_LINK_ORDER
: sindex
= 6; break;
6912 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
6913 case SHF_GROUP
: sindex
= 8; break;
6914 case SHF_TLS
: sindex
= 9; break;
6915 case SHF_EXCLUDE
: sindex
= 18; break;
6916 case SHF_COMPRESSED
: sindex
= 20; break;
6920 switch (filedata
->file_header
.e_machine
)
6923 if (flag
== SHF_IA_64_SHORT
)
6925 else if (flag
== SHF_IA_64_NORECOV
)
6927 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
6930 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
6931 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
6932 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
6933 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
6934 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
6935 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
6945 case EM_OLD_SPARCV9
:
6946 case EM_SPARC32PLUS
:
6949 if (flag
== SHF_ORDERED
)
6956 case SHF_ENTRYSECT
: sindex
= 21; break;
6957 case SHF_ARM_PURECODE
: sindex
= 22; break;
6958 case SHF_COMDEF
: sindex
= 23; break;
6963 if (flag
== SHF_PPC_VLE
)
6970 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
6973 case ELFOSABI_FREEBSD
:
6974 if (flag
== SHF_GNU_RETAIN
)
6978 if (flag
== SHF_GNU_MBIND
)
6979 /* We should not recognize SHF_GNU_MBIND for
6980 ELFOSABI_NONE, but binutils as of 2019-07-23 did
6981 not set the EI_OSABI header byte. */
6992 if (p
!= buff
+ field_size
+ 4)
6994 if (size
< (10 + 2))
6996 warn (_("Internal error: not enough buffer room for section flag info"));
6997 return _("<unknown>");
7004 size
-= flags
[sindex
].len
;
7005 p
= stpcpy (p
, flags
[sindex
].str
);
7007 else if (flag
& SHF_MASKOS
)
7009 else if (flag
& SHF_MASKPROC
)
7012 unknown_flags
|= flag
;
7018 case SHF_WRITE
: *p
= 'W'; break;
7019 case SHF_ALLOC
: *p
= 'A'; break;
7020 case SHF_EXECINSTR
: *p
= 'X'; break;
7021 case SHF_MERGE
: *p
= 'M'; break;
7022 case SHF_STRINGS
: *p
= 'S'; break;
7023 case SHF_INFO_LINK
: *p
= 'I'; break;
7024 case SHF_LINK_ORDER
: *p
= 'L'; break;
7025 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
7026 case SHF_GROUP
: *p
= 'G'; break;
7027 case SHF_TLS
: *p
= 'T'; break;
7028 case SHF_EXCLUDE
: *p
= 'E'; break;
7029 case SHF_COMPRESSED
: *p
= 'C'; break;
7032 if ((filedata
->file_header
.e_machine
== EM_X86_64
7033 || filedata
->file_header
.e_machine
== EM_L1OM
7034 || filedata
->file_header
.e_machine
== EM_K1OM
)
7035 && flag
== SHF_X86_64_LARGE
)
7037 else if (filedata
->file_header
.e_machine
== EM_ARM
7038 && flag
== SHF_ARM_PURECODE
)
7040 else if (filedata
->file_header
.e_machine
== EM_PPC
7041 && flag
== SHF_PPC_VLE
)
7043 else if (flag
& SHF_MASKOS
)
7045 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
7048 case ELFOSABI_FREEBSD
:
7049 if (flag
== SHF_GNU_RETAIN
)
7056 if (flag
== SHF_GNU_MBIND
)
7058 /* We should not recognize SHF_GNU_MBIND for
7059 ELFOSABI_NONE, but binutils as of 2019-07-23 did
7060 not set the EI_OSABI header byte. */
7067 sh_flags
&= ~SHF_MASKOS
;
7071 else if (flag
& SHF_MASKPROC
)
7074 sh_flags
&= ~ SHF_MASKPROC
;
7084 if (do_section_details
)
7088 size
-= 5 + field_size
;
7089 if (p
!= buff
+ field_size
+ 4)
7093 warn (_("Internal error: not enough buffer room for section flag info"));
7094 return _("<unknown>");
7100 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
7101 (unsigned long) os_flags
);
7102 p
+= 5 + field_size
;
7106 size
-= 7 + field_size
;
7107 if (p
!= buff
+ field_size
+ 4)
7111 warn (_("Internal error: not enough buffer room for section flag info"));
7112 return _("<unknown>");
7118 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
7119 (unsigned long) proc_flags
);
7120 p
+= 7 + field_size
;
7124 size
-= 10 + field_size
;
7125 if (p
!= buff
+ field_size
+ 4)
7129 warn (_("Internal error: not enough buffer room for section flag info"));
7130 return _("<unknown>");
7136 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
7137 (unsigned long) unknown_flags
);
7138 p
+= 10 + field_size
;
7146 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
7147 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
,
7152 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
7154 if (size
< sizeof (* echdr
))
7156 error (_("Compressed section is too small even for a compression header\n"));
7160 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
7161 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
7162 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
7163 return sizeof (*echdr
);
7167 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
7169 if (size
< sizeof (* echdr
))
7171 error (_("Compressed section is too small even for a compression header\n"));
7175 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
7176 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
7177 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
7178 return sizeof (*echdr
);
7183 process_section_headers (Filedata
* filedata
)
7185 Elf_Internal_Shdr
* section
;
7188 if (filedata
->file_header
.e_shnum
== 0)
7190 /* PR binutils/12467. */
7191 if (filedata
->file_header
.e_shoff
!= 0)
7193 warn (_("possibly corrupt ELF file header - it has a non-zero"
7194 " section header offset, but no section headers\n"));
7197 else if (do_sections
)
7198 printf (_("\nThere are no sections in this file.\n"));
7203 if (do_sections
&& !do_header
)
7205 if (filedata
->is_separate
&& process_links
)
7206 printf (_("In linked file '%s': "), filedata
->file_name
);
7207 if (! filedata
->is_separate
|| process_links
)
7208 printf (ngettext ("There is %d section header, "
7209 "starting at offset %#" PRIx64
":\n",
7210 "There are %d section headers, "
7211 "starting at offset %#" PRIx64
":\n",
7212 filedata
->file_header
.e_shnum
),
7213 filedata
->file_header
.e_shnum
,
7214 filedata
->file_header
.e_shoff
);
7217 if (!get_section_headers (filedata
, false))
7220 /* Read in the string table, so that we have names to display. */
7221 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
7222 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
7224 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
7226 if (section
->sh_size
!= 0)
7228 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
7229 1, section
->sh_size
,
7232 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
7236 /* Scan the sections for the dynamic symbol table
7237 and dynamic string table and debug sections. */
7238 eh_addr_size
= is_32bit_elf
? 4 : 8;
7239 switch (filedata
->file_header
.e_machine
)
7242 case EM_MIPS_RS3_LE
:
7243 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
7244 FDE addresses. However, the ABI also has a semi-official ILP32
7245 variant for which the normal FDE address size rules apply.
7247 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
7248 section, where XX is the size of longs in bits. Unfortunately,
7249 earlier compilers provided no way of distinguishing ILP32 objects
7250 from LP64 objects, so if there's any doubt, we should assume that
7251 the official LP64 form is being used. */
7252 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
7253 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
7259 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
7261 case E_H8_MACH_H8300
:
7262 case E_H8_MACH_H8300HN
:
7263 case E_H8_MACH_H8300SN
:
7264 case E_H8_MACH_H8300SXN
:
7267 case E_H8_MACH_H8300H
:
7268 case E_H8_MACH_H8300S
:
7269 case E_H8_MACH_H8300SX
:
7277 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
7279 case EF_M32C_CPU_M16C
:
7286 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
7289 uint64_t expected_entsize = is_32bit_elf ? size32 : size64; \
7290 if (section->sh_entsize != expected_entsize) \
7292 error (_("Section %d has invalid sh_entsize of %" PRIx64 "\n"), \
7293 i, section->sh_entsize); \
7294 error (_("(Using the expected size of %" PRIx64 " for the rest of this dump)\n"), \
7295 expected_entsize); \
7296 section->sh_entsize = expected_entsize; \
7301 #define CHECK_ENTSIZE(section, i, type) \
7302 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
7303 sizeof (Elf64_External_##type))
7305 for (i
= 0, section
= filedata
->section_headers
;
7306 i
< filedata
->file_header
.e_shnum
;
7309 const char *name
= section_name_print (filedata
, section
);
7311 /* Run some sanity checks on the headers and
7312 possibly fill in some file data as well. */
7313 switch (section
->sh_type
)
7316 if (filedata
->dynamic_symbols
!= NULL
)
7318 error (_("File contains multiple dynamic symbol tables\n"));
7322 CHECK_ENTSIZE (section
, i
, Sym
);
7323 filedata
->dynamic_symbols
7324 = get_elf_symbols (filedata
, section
, &filedata
->num_dynamic_syms
);
7325 filedata
->dynamic_symtab_section
= section
;
7329 if (streq (name
, ".dynstr"))
7331 if (filedata
->dynamic_strings
!= NULL
)
7333 error (_("File contains multiple dynamic string tables\n"));
7337 filedata
->dynamic_strings
7338 = (char *) get_data (NULL
, filedata
, section
->sh_offset
,
7339 1, section
->sh_size
, _("dynamic strings"));
7340 filedata
->dynamic_strings_length
7341 = filedata
->dynamic_strings
== NULL
? 0 : section
->sh_size
;
7342 filedata
->dynamic_strtab_section
= section
;
7346 case SHT_SYMTAB_SHNDX
:
7348 elf_section_list
* entry
= xmalloc (sizeof * entry
);
7350 entry
->hdr
= section
;
7351 entry
->next
= filedata
->symtab_shndx_list
;
7352 filedata
->symtab_shndx_list
= entry
;
7357 CHECK_ENTSIZE (section
, i
, Sym
);
7361 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
7365 CHECK_ENTSIZE (section
, i
, Rel
);
7366 if (do_checks
&& section
->sh_size
== 0)
7367 warn (_("Section '%s': zero-sized relocation section\n"), name
);
7371 CHECK_ENTSIZE (section
, i
, Rela
);
7372 if (do_checks
&& section
->sh_size
== 0)
7373 warn (_("Section '%s': zero-sized relocation section\n"), name
);
7377 CHECK_ENTSIZE (section
, i
, Relr
);
7382 /* Having a zero sized section is not illegal according to the
7383 ELF standard, but it might be an indication that something
7384 is wrong. So issue a warning if we are running in lint mode. */
7385 if (do_checks
&& section
->sh_size
== 0)
7386 warn (_("Section '%s': has a size of zero - is this intended ?\n"), name
);
7393 if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
7394 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
7395 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
7396 || do_debug_str
|| do_debug_str_offsets
|| do_debug_loc
7398 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
7399 && (startswith (name
, ".debug_")
7400 || startswith (name
, ".zdebug_")))
7403 name
+= sizeof (".zdebug_") - 1;
7405 name
+= sizeof (".debug_") - 1;
7408 || (do_debug_info
&& startswith (name
, "info"))
7409 || (do_debug_info
&& startswith (name
, "types"))
7410 || (do_debug_abbrevs
&& startswith (name
, "abbrev"))
7411 || (do_debug_lines
&& strcmp (name
, "line") == 0)
7412 || (do_debug_lines
&& startswith (name
, "line."))
7413 || (do_debug_pubnames
&& startswith (name
, "pubnames"))
7414 || (do_debug_pubtypes
&& startswith (name
, "pubtypes"))
7415 || (do_debug_pubnames
&& startswith (name
, "gnu_pubnames"))
7416 || (do_debug_pubtypes
&& startswith (name
, "gnu_pubtypes"))
7417 || (do_debug_aranges
&& startswith (name
, "aranges"))
7418 || (do_debug_ranges
&& startswith (name
, "ranges"))
7419 || (do_debug_ranges
&& startswith (name
, "rnglists"))
7420 || (do_debug_frames
&& startswith (name
, "frame"))
7421 || (do_debug_macinfo
&& startswith (name
, "macinfo"))
7422 || (do_debug_macinfo
&& startswith (name
, "macro"))
7423 || (do_debug_str
&& startswith (name
, "str"))
7424 || (do_debug_links
&& startswith (name
, "sup"))
7425 || (do_debug_str_offsets
&& startswith (name
, "str_offsets"))
7426 || (do_debug_loc
&& startswith (name
, "loc"))
7427 || (do_debug_loc
&& startswith (name
, "loclists"))
7428 || (do_debug_addr
&& startswith (name
, "addr"))
7429 || (do_debug_cu_index
&& startswith (name
, "cu_index"))
7430 || (do_debug_cu_index
&& startswith (name
, "tu_index"))
7432 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7434 /* Linkonce section to be combined with .debug_info at link time. */
7435 else if ((do_debugging
|| do_debug_info
)
7436 && startswith (name
, ".gnu.linkonce.wi."))
7437 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7438 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
7439 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7440 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
7441 || streq (name
, ".debug_names")))
7442 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7443 /* Trace sections for Itanium VMS. */
7444 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
7445 || do_trace_aranges
)
7446 && startswith (name
, ".trace_"))
7448 name
+= sizeof (".trace_") - 1;
7451 || (do_trace_info
&& streq (name
, "info"))
7452 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
7453 || (do_trace_aranges
&& streq (name
, "aranges"))
7455 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7457 else if ((do_debugging
|| do_debug_links
)
7458 && (startswith (name
, ".gnu_debuglink")
7459 || startswith (name
, ".gnu_debugaltlink")))
7460 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7466 if (filedata
->is_separate
&& ! process_links
)
7469 if (filedata
->is_separate
)
7470 printf (_("\nSection Headers in linked file '%s':\n"), filedata
->file_name
);
7471 else if (filedata
->file_header
.e_shnum
> 1)
7472 printf (_("\nSection Headers:\n"));
7474 printf (_("\nSection Header:\n"));
7478 if (do_section_details
)
7480 printf (_(" [Nr] Name\n"));
7481 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
7485 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
7489 if (do_section_details
)
7491 printf (_(" [Nr] Name\n"));
7492 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
7496 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
7500 if (do_section_details
)
7502 printf (_(" [Nr] Name\n"));
7503 printf (_(" Type Address Offset Link\n"));
7504 printf (_(" Size EntSize Info Align\n"));
7508 printf (_(" [Nr] Name Type Address Offset\n"));
7509 printf (_(" Size EntSize Flags Link Info Align\n"));
7513 if (do_section_details
)
7514 printf (_(" Flags\n"));
7516 for (i
= 0, section
= filedata
->section_headers
;
7517 i
< filedata
->file_header
.e_shnum
;
7520 /* Run some sanity checks on the section header. */
7522 /* Check the sh_link field. */
7523 switch (section
->sh_type
)
7527 if (section
->sh_link
== 0
7528 && (filedata
->file_header
.e_type
== ET_EXEC
7529 || filedata
->file_header
.e_type
== ET_DYN
))
7530 /* A dynamic relocation section where all entries use a
7531 zero symbol index need not specify a symtab section. */
7534 case SHT_SYMTAB_SHNDX
:
7538 case SHT_GNU_versym
:
7539 if (section
->sh_link
== 0
7540 || section
->sh_link
>= filedata
->file_header
.e_shnum
7541 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
7542 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
7543 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
7544 i
, section
->sh_link
);
7550 case SHT_GNU_verneed
:
7551 case SHT_GNU_verdef
:
7552 case SHT_GNU_LIBLIST
:
7553 if (section
->sh_link
== 0
7554 || section
->sh_link
>= filedata
->file_header
.e_shnum
7555 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
7556 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
7557 i
, section
->sh_link
);
7560 case SHT_INIT_ARRAY
:
7561 case SHT_FINI_ARRAY
:
7562 case SHT_PREINIT_ARRAY
:
7563 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
7564 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
7565 i
, section
->sh_link
);
7569 /* FIXME: Add support for target specific section types. */
7570 #if 0 /* Currently we do not check other section types as there are too
7571 many special cases. Stab sections for example have a type
7572 of SHT_PROGBITS but an sh_link field that links to the .stabstr
7574 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
7575 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
7576 i
, section
->sh_link
);
7581 /* Check the sh_info field. */
7582 switch (section
->sh_type
)
7586 if (section
->sh_info
== 0
7587 && (filedata
->file_header
.e_type
== ET_EXEC
7588 || filedata
->file_header
.e_type
== ET_DYN
))
7589 /* Dynamic relocations apply to segments, so they do not
7590 need to specify the section they relocate. */
7592 if (section
->sh_info
== 0
7593 || section
->sh_info
>= filedata
->file_header
.e_shnum
7594 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
7595 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
7596 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
7597 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
7598 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
7599 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
7600 /* FIXME: Are other section types valid ? */
7601 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
7602 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
7603 i
, section
->sh_info
);
7608 case SHT_SYMTAB_SHNDX
:
7609 case SHT_INIT_ARRAY
:
7610 case SHT_FINI_ARRAY
:
7611 case SHT_PREINIT_ARRAY
:
7612 if (section
->sh_info
!= 0)
7613 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
7614 i
, section
->sh_info
);
7620 /* A symbol index - we assume that it is valid. */
7624 /* FIXME: Add support for target specific section types. */
7625 if (section
->sh_type
== SHT_NOBITS
)
7626 /* NOBITS section headers with non-zero sh_info fields can be
7627 created when a binary is stripped of everything but its debug
7628 information. The stripped sections have their headers
7629 preserved but their types set to SHT_NOBITS. So do not check
7630 this type of section. */
7632 else if (section
->sh_flags
& SHF_INFO_LINK
)
7634 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
7635 warn (_("[%2u]: Expected link to another section in info field"), i
);
7637 else if (section
->sh_type
< SHT_LOOS
7638 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
7639 && section
->sh_info
!= 0)
7640 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
7641 i
, section
->sh_info
);
7645 /* Check the sh_size field. */
7646 if (section
->sh_size
> filedata
->file_size
7647 && section
->sh_type
!= SHT_NOBITS
7648 && section
->sh_type
!= SHT_NULL
7649 && section
->sh_type
< SHT_LOOS
)
7650 warn (_("Size of section %u is larger than the entire file!\n"), i
);
7652 printf (" [%2u] ", i
);
7653 if (do_section_details
)
7654 printf ("%s\n ", printable_section_name (filedata
, section
));
7656 print_symbol (-17, section_name_print (filedata
, section
));
7658 printf (do_wide
? " %-15s " : " %-15.15s ",
7659 get_section_type_name (filedata
, section
->sh_type
));
7663 const char * link_too_big
= NULL
;
7665 print_vma (section
->sh_addr
, LONG_HEX
);
7667 printf ( " %6.6lx %6.6lx %2.2lx",
7668 (unsigned long) section
->sh_offset
,
7669 (unsigned long) section
->sh_size
,
7670 (unsigned long) section
->sh_entsize
);
7672 if (do_section_details
)
7673 fputs (" ", stdout
);
7675 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
7677 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
7680 /* The sh_link value is out of range. Normally this indicates
7681 an error but it can have special values in Solaris binaries. */
7682 switch (filedata
->file_header
.e_machine
)
7689 case EM_OLD_SPARCV9
:
7690 case EM_SPARC32PLUS
:
7693 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
7694 link_too_big
= "BEFORE";
7695 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
7696 link_too_big
= "AFTER";
7703 if (do_section_details
)
7705 if (link_too_big
!= NULL
&& * link_too_big
)
7706 printf ("<%s> ", link_too_big
);
7708 printf ("%2u ", section
->sh_link
);
7709 printf ("%3u %2lu\n", section
->sh_info
,
7710 (unsigned long) section
->sh_addralign
);
7713 printf ("%2u %3u %2lu\n",
7716 (unsigned long) section
->sh_addralign
);
7718 if (link_too_big
&& ! * link_too_big
)
7719 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
7720 i
, section
->sh_link
);
7724 print_vma (section
->sh_addr
, LONG_HEX
);
7726 if ((long) section
->sh_offset
== section
->sh_offset
)
7727 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
7731 print_vma (section
->sh_offset
, LONG_HEX
);
7734 if ((unsigned long) section
->sh_size
== section
->sh_size
)
7735 printf (" %6.6lx", (unsigned long) section
->sh_size
);
7739 print_vma (section
->sh_size
, LONG_HEX
);
7742 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
7743 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
7747 print_vma (section
->sh_entsize
, LONG_HEX
);
7750 if (do_section_details
)
7751 fputs (" ", stdout
);
7753 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
7755 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
7757 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
7758 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
7761 print_vma (section
->sh_addralign
, DEC
);
7765 else if (do_section_details
)
7768 print_vma (section
->sh_addr
, LONG_HEX
);
7769 if ((long) section
->sh_offset
== section
->sh_offset
)
7770 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
7774 print_vma (section
->sh_offset
, LONG_HEX
);
7776 printf (" %u\n ", section
->sh_link
);
7777 print_vma (section
->sh_size
, LONG_HEX
);
7779 print_vma (section
->sh_entsize
, LONG_HEX
);
7781 printf (" %-16u %lu\n",
7783 (unsigned long) section
->sh_addralign
);
7788 print_vma (section
->sh_addr
, LONG_HEX
);
7789 if ((long) section
->sh_offset
== section
->sh_offset
)
7790 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
7794 print_vma (section
->sh_offset
, LONG_HEX
);
7797 print_vma (section
->sh_size
, LONG_HEX
);
7799 print_vma (section
->sh_entsize
, LONG_HEX
);
7801 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
7803 printf (" %2u %3u %lu\n",
7806 (unsigned long) section
->sh_addralign
);
7809 if (do_section_details
)
7811 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
7812 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
7814 /* Minimum section size is 12 bytes for 32-bit compression
7815 header + 12 bytes for compressed data header. */
7816 unsigned char buf
[24];
7818 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
7819 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
7820 sizeof (buf
), _("compression header")))
7822 Elf_Internal_Chdr chdr
;
7824 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
7825 printf (_(" [<corrupt>]\n"));
7828 if (chdr
.ch_type
== ch_compress_zlib
)
7830 else if (chdr
.ch_type
== ch_compress_zstd
)
7833 printf (_(" [<unknown>: 0x%x], "),
7835 print_vma (chdr
.ch_size
, LONG_HEX
);
7836 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
7843 if (!do_section_details
)
7845 /* The ordering of the letters shown here matches the ordering of the
7846 corresponding SHF_xxx values, and hence the order in which these
7847 letters will be displayed to the user. */
7848 printf (_("Key to Flags:\n\
7849 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
7850 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
7851 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
7852 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
7855 case ELFOSABI_FREEBSD
:
7856 printf (_("R (retain), "));
7859 printf (_("D (mbind), "));
7864 if (filedata
->file_header
.e_machine
== EM_X86_64
7865 || filedata
->file_header
.e_machine
== EM_L1OM
7866 || filedata
->file_header
.e_machine
== EM_K1OM
)
7867 printf (_("l (large), "));
7868 else if (filedata
->file_header
.e_machine
== EM_ARM
)
7869 printf (_("y (purecode), "));
7870 else if (filedata
->file_header
.e_machine
== EM_PPC
)
7871 printf (_("v (VLE), "));
7872 printf ("p (processor specific)\n");
7879 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
7880 Elf_Internal_Sym
**symtab
, uint64_t *nsyms
,
7881 char **strtab
, uint64_t *strtablen
)
7885 *symtab
= get_elf_symbols (filedata
, symsec
, nsyms
);
7887 if (*symtab
== NULL
)
7890 if (symsec
->sh_link
!= 0)
7892 Elf_Internal_Shdr
*strsec
;
7894 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
7896 error (_("Bad sh_link in symbol table section\n"));
7903 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7905 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7906 1, strsec
->sh_size
, _("string table"));
7907 if (*strtab
== NULL
)
7914 *strtablen
= strsec
->sh_size
;
7920 get_group_flags (unsigned int flags
)
7922 static char buff
[128];
7926 else if (flags
== GRP_COMDAT
)
7929 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
7931 flags
& GRP_MASKOS
? _("<OS specific>") : "",
7932 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
7933 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
7934 ? _("<unknown>") : ""));
7940 process_section_groups (Filedata
* filedata
)
7942 Elf_Internal_Shdr
* section
;
7944 struct group
* group
;
7945 Elf_Internal_Shdr
* symtab_sec
;
7946 Elf_Internal_Shdr
* strtab_sec
;
7947 Elf_Internal_Sym
* symtab
;
7952 /* Don't process section groups unless needed. */
7953 if (!do_unwind
&& !do_section_groups
)
7956 if (filedata
->file_header
.e_shnum
== 0)
7958 if (do_section_groups
)
7960 if (filedata
->is_separate
)
7961 printf (_("\nThere are no sections group in linked file '%s'.\n"),
7962 filedata
->file_name
);
7964 printf (_("\nThere are no section groups in this file.\n"));
7969 if (filedata
->section_headers
== NULL
)
7971 error (_("Section headers are not available!\n"));
7972 /* PR 13622: This can happen with a corrupt ELF header. */
7976 filedata
->section_headers_groups
7977 = (struct group
**) calloc (filedata
->file_header
.e_shnum
,
7978 sizeof (struct group
*));
7980 if (filedata
->section_headers_groups
== NULL
)
7982 error (_("Out of memory reading %u section group headers\n"),
7983 filedata
->file_header
.e_shnum
);
7987 /* Scan the sections for the group section. */
7988 filedata
->group_count
= 0;
7989 for (i
= 0, section
= filedata
->section_headers
;
7990 i
< filedata
->file_header
.e_shnum
;
7992 if (section
->sh_type
== SHT_GROUP
)
7993 filedata
->group_count
++;
7995 if (filedata
->group_count
== 0)
7997 if (do_section_groups
)
7999 if (filedata
->is_separate
)
8000 printf (_("\nThere are no section groups in linked file '%s'.\n"),
8001 filedata
->file_name
);
8003 printf (_("\nThere are no section groups in this file.\n"));
8009 filedata
->section_groups
= (struct group
*) calloc (filedata
->group_count
,
8010 sizeof (struct group
));
8012 if (filedata
->section_groups
== NULL
)
8014 error (_("Out of memory reading %zu groups\n"), filedata
->group_count
);
8025 if (filedata
->is_separate
)
8026 printf (_("Section groups in linked file '%s'\n"), filedata
->file_name
);
8028 for (i
= 0, section
= filedata
->section_headers
, group
= filedata
->section_groups
;
8029 i
< filedata
->file_header
.e_shnum
;
8032 if (section
->sh_type
== SHT_GROUP
)
8034 const char * name
= printable_section_name (filedata
, section
);
8035 const char * group_name
;
8036 unsigned char * start
;
8037 unsigned char * indices
;
8038 unsigned int entry
, j
, size
;
8039 Elf_Internal_Shdr
* sec
;
8040 Elf_Internal_Sym
* sym
;
8042 /* Get the symbol table. */
8043 if (section
->sh_link
>= filedata
->file_header
.e_shnum
8044 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
8047 error (_("Bad sh_link in group section `%s'\n"), name
);
8051 if (symtab_sec
!= sec
)
8055 symtab
= get_elf_symbols (filedata
, symtab_sec
, & num_syms
);
8060 error (_("Corrupt header in group section `%s'\n"), name
);
8064 if (section
->sh_info
>= num_syms
)
8066 error (_("Bad sh_info in group section `%s'\n"), name
);
8070 sym
= symtab
+ section
->sh_info
;
8072 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
8074 if (sym
->st_shndx
== 0
8075 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
8077 error (_("Bad sh_info in group section `%s'\n"), name
);
8081 group_name
= section_name_print (filedata
,
8082 filedata
->section_headers
8091 /* Get the string table. */
8092 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
8100 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
8105 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
8106 1, strtab_sec
->sh_size
,
8108 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
8110 group_name
= sym
->st_name
< strtab_size
8111 ? strtab
+ sym
->st_name
: _("<corrupt>");
8114 /* PR 17531: file: loop. */
8115 if (section
->sh_entsize
> section
->sh_size
)
8117 error (_("Section %s has sh_entsize (%#" PRIx64
")"
8118 " which is larger than its size (%#" PRIx64
")\n"),
8119 printable_section_name (filedata
, section
),
8120 section
->sh_entsize
,
8125 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
8126 1, section
->sh_size
,
8132 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
8133 entry
= byte_get (indices
, 4);
8136 if (do_section_groups
)
8138 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
8139 get_group_flags (entry
), i
, name
, group_name
, size
);
8141 printf (_(" [Index] Name\n"));
8144 group
->group_index
= i
;
8146 for (j
= 0; j
< size
; j
++)
8148 struct group_list
* g
;
8150 entry
= byte_get (indices
, 4);
8153 if (entry
>= filedata
->file_header
.e_shnum
)
8155 static unsigned num_group_errors
= 0;
8157 if (num_group_errors
++ < 10)
8159 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
8160 entry
, i
, filedata
->file_header
.e_shnum
- 1);
8161 if (num_group_errors
== 10)
8162 warn (_("Further error messages about overlarge group section indices suppressed\n"));
8167 if (filedata
->section_headers_groups
[entry
] != NULL
)
8171 static unsigned num_errs
= 0;
8173 if (num_errs
++ < 10)
8175 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
8177 filedata
->section_headers_groups
[entry
]->group_index
);
8179 warn (_("Further error messages about already contained group sections suppressed\n"));
8185 /* Intel C/C++ compiler may put section 0 in a
8186 section group. We just warn it the first time
8187 and ignore it afterwards. */
8188 static bool warned
= false;
8191 error (_("section 0 in group section [%5u]\n"),
8192 filedata
->section_headers_groups
[entry
]->group_index
);
8198 filedata
->section_headers_groups
[entry
] = group
;
8200 if (do_section_groups
)
8202 sec
= filedata
->section_headers
+ entry
;
8203 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
8206 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
8207 g
->section_index
= entry
;
8208 g
->next
= group
->root
;
8223 /* Data used to display dynamic fixups. */
8225 struct ia64_vms_dynfixup
8227 uint64_t needed_ident
; /* Library ident number. */
8228 uint64_t needed
; /* Index in the dstrtab of the library name. */
8229 uint64_t fixup_needed
; /* Index of the library. */
8230 uint64_t fixup_rela_cnt
; /* Number of fixups. */
8231 uint64_t fixup_rela_off
; /* Fixups offset in the dynamic segment. */
8234 /* Data used to display dynamic relocations. */
8236 struct ia64_vms_dynimgrela
8238 uint64_t img_rela_cnt
; /* Number of relocations. */
8239 uint64_t img_rela_off
; /* Reloc offset in the dynamic segment. */
8242 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
8246 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
8247 struct ia64_vms_dynfixup
* fixup
,
8248 const char * strtab
,
8249 unsigned int strtab_sz
)
8251 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
8253 const char * lib_name
;
8255 imfs
= get_data (NULL
, filedata
,
8256 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
8257 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
8258 _("dynamic section image fixups"));
8262 if (fixup
->needed
< strtab_sz
)
8263 lib_name
= strtab
+ fixup
->needed
;
8266 warn (_("corrupt library name index of %#" PRIx64
8267 " found in dynamic entry"), fixup
->needed
);
8271 printf (_("\nImage fixups for needed library #%" PRId64
8272 ": %s - ident: %" PRIx64
"\n"),
8273 fixup
->fixup_needed
, lib_name
, fixup
->needed_ident
);
8275 (_("Seg Offset Type SymVec DataType\n"));
8277 for (i
= 0; i
< (size_t) fixup
->fixup_rela_cnt
; i
++)
8282 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
8283 printf ("%016" PRIx64
" ", BYTE_GET (imfs
[i
].fixup_offset
));
8284 type
= BYTE_GET (imfs
[i
].type
);
8285 rtype
= elf_ia64_reloc_type (type
);
8287 printf ("0x%08x ", type
);
8289 printf ("%-32s ", rtype
);
8290 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
8291 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
8298 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
8301 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
8303 Elf64_External_VMS_IMAGE_RELA
*imrs
;
8306 imrs
= get_data (NULL
, filedata
,
8307 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
8308 sizeof (*imrs
), imgrela
->img_rela_cnt
,
8309 _("dynamic section image relocations"));
8313 printf (_("\nImage relocs\n"));
8315 (_("Seg Offset Type Addend Seg Sym Off\n"));
8317 for (i
= 0; i
< (size_t) imgrela
->img_rela_cnt
; i
++)
8322 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
8323 printf ("%08" PRIx64
" ", BYTE_GET (imrs
[i
].rela_offset
));
8324 type
= BYTE_GET (imrs
[i
].type
);
8325 rtype
= elf_ia64_reloc_type (type
);
8327 printf ("0x%08x ", type
);
8329 printf ("%-31s ", rtype
);
8330 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
8331 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
8332 printf ("%08" PRIx64
"\n", BYTE_GET (imrs
[i
].sym_offset
));
8339 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
8342 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
8344 struct ia64_vms_dynfixup fixup
;
8345 struct ia64_vms_dynimgrela imgrela
;
8346 Elf_Internal_Dyn
*entry
;
8347 uint64_t strtab_off
= 0;
8348 uint64_t strtab_sz
= 0;
8349 char *strtab
= NULL
;
8352 memset (&fixup
, 0, sizeof (fixup
));
8353 memset (&imgrela
, 0, sizeof (imgrela
));
8355 /* Note: the order of the entries is specified by the OpenVMS specs. */
8356 for (entry
= filedata
->dynamic_section
;
8357 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
8360 switch (entry
->d_tag
)
8362 case DT_IA_64_VMS_STRTAB_OFFSET
:
8363 strtab_off
= entry
->d_un
.d_val
;
8366 strtab_sz
= entry
->d_un
.d_val
;
8368 strtab
= get_data (NULL
, filedata
,
8369 filedata
->dynamic_addr
+ strtab_off
,
8370 1, strtab_sz
, _("dynamic string section"));
8375 case DT_IA_64_VMS_NEEDED_IDENT
:
8376 fixup
.needed_ident
= entry
->d_un
.d_val
;
8379 fixup
.needed
= entry
->d_un
.d_val
;
8381 case DT_IA_64_VMS_FIXUP_NEEDED
:
8382 fixup
.fixup_needed
= entry
->d_un
.d_val
;
8384 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
8385 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
8387 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
8388 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
8389 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
8392 case DT_IA_64_VMS_IMG_RELA_CNT
:
8393 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
8395 case DT_IA_64_VMS_IMG_RELA_OFF
:
8396 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
8397 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
8416 relocation_type rel_type
;
8418 dynamic_relocations
[] =
8420 { "REL", DT_REL
, DT_RELSZ
, reltype_rel
},
8421 { "RELA", DT_RELA
, DT_RELASZ
, reltype_rela
},
8422 { "RELR", DT_RELR
, DT_RELRSZ
, reltype_relr
},
8423 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, reltype_unknown
}
8426 /* Process the reloc section. */
8429 process_relocs (Filedata
* filedata
)
8432 uint64_t rel_offset
;
8437 if (do_using_dynamic
)
8439 relocation_type rel_type
;
8441 bool has_dynamic_reloc
;
8444 has_dynamic_reloc
= false;
8446 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
8448 rel_type
= dynamic_relocations
[i
].rel_type
;
8449 name
= dynamic_relocations
[i
].name
;
8450 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
8451 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
8454 has_dynamic_reloc
= true;
8456 if (rel_type
== reltype_unknown
)
8458 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
8459 switch (filedata
->dynamic_info
[DT_PLTREL
])
8462 rel_type
= reltype_rel
;
8465 rel_type
= reltype_rela
;
8472 if (filedata
->is_separate
)
8474 (_("\nIn linked file '%s' section '%s' at offset %#" PRIx64
8475 " contains %" PRId64
" bytes:\n"),
8476 filedata
->file_name
, name
, rel_offset
, rel_size
);
8479 (_("\n'%s' relocation section at offset %#" PRIx64
8480 " contains %" PRId64
" bytes:\n"),
8481 name
, rel_offset
, rel_size
);
8483 dump_relocations (filedata
,
8484 offset_from_vma (filedata
, rel_offset
, rel_size
),
8486 filedata
->dynamic_symbols
,
8487 filedata
->num_dynamic_syms
,
8488 filedata
->dynamic_strings
,
8489 filedata
->dynamic_strings_length
,
8490 rel_type
, true /* is_dynamic */);
8494 if (is_ia64_vms (filedata
))
8495 if (process_ia64_vms_dynamic_relocs (filedata
))
8496 has_dynamic_reloc
= true;
8498 if (! has_dynamic_reloc
)
8500 if (filedata
->is_separate
)
8501 printf (_("\nThere are no dynamic relocations in linked file '%s'.\n"),
8502 filedata
->file_name
);
8504 printf (_("\nThere are no dynamic relocations in this file.\n"));
8509 Elf_Internal_Shdr
* section
;
8513 for (i
= 0, section
= filedata
->section_headers
;
8514 i
< filedata
->file_header
.e_shnum
;
8517 if ( section
->sh_type
!= SHT_RELA
8518 && section
->sh_type
!= SHT_REL
8519 && section
->sh_type
!= SHT_RELR
)
8522 rel_offset
= section
->sh_offset
;
8523 rel_size
= section
->sh_size
;
8527 relocation_type rel_type
;
8530 if (filedata
->is_separate
)
8531 printf (_("\nIn linked file '%s' relocation section "),
8532 filedata
->file_name
);
8534 printf (_("\nRelocation section "));
8536 if (filedata
->string_table
== NULL
)
8537 printf ("%d", section
->sh_name
);
8539 printf ("'%s'", printable_section_name (filedata
, section
));
8541 num_rela
= rel_size
/ section
->sh_entsize
;
8542 printf (ngettext (" at offset %#" PRIx64
8543 " contains %" PRIu64
" entry:\n",
8544 " at offset %#" PRIx64
8545 " contains %" PRId64
" entries:\n",
8547 rel_offset
, num_rela
);
8549 rel_type
= section
->sh_type
== SHT_RELA
? reltype_rela
:
8550 section
->sh_type
== SHT_REL
? reltype_rel
: reltype_relr
;
8552 if (section
->sh_link
!= 0
8553 && section
->sh_link
< filedata
->file_header
.e_shnum
)
8555 Elf_Internal_Shdr
*symsec
;
8556 Elf_Internal_Sym
*symtab
;
8558 uint64_t strtablen
= 0;
8559 char *strtab
= NULL
;
8561 symsec
= filedata
->section_headers
+ section
->sh_link
;
8562 if (symsec
->sh_type
!= SHT_SYMTAB
8563 && symsec
->sh_type
!= SHT_DYNSYM
)
8566 if (!get_symtab (filedata
, symsec
,
8567 &symtab
, &nsyms
, &strtab
, &strtablen
))
8570 dump_relocations (filedata
, rel_offset
, rel_size
,
8571 symtab
, nsyms
, strtab
, strtablen
,
8573 symsec
->sh_type
== SHT_DYNSYM
);
8578 dump_relocations (filedata
, rel_offset
, rel_size
,
8579 NULL
, 0, NULL
, 0, rel_type
, false /* is_dynamic */);
8587 /* Users sometimes forget the -D option, so try to be helpful. */
8588 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
8590 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
8592 if (filedata
->is_separate
)
8593 printf (_("\nThere are no static relocations in linked file '%s'."),
8594 filedata
->file_name
);
8596 printf (_("\nThere are no static relocations in this file."));
8597 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
8602 if (i
== ARRAY_SIZE (dynamic_relocations
))
8604 if (filedata
->is_separate
)
8605 printf (_("\nThere are no relocations in linked file '%s'.\n"),
8606 filedata
->file_name
);
8608 printf (_("\nThere are no relocations in this file.\n"));
8616 /* An absolute address consists of a section and an offset. If the
8617 section is NULL, the offset itself is the address, otherwise, the
8618 address equals to LOAD_ADDRESS(section) + offset. */
8622 unsigned short section
;
8626 /* Find the nearest symbol at or below ADDR. Returns the symbol
8627 name, if found, and the offset from the symbol to ADDR. */
8630 find_symbol_for_address (Filedata
*filedata
,
8631 Elf_Internal_Sym
*symtab
,
8634 uint64_t strtab_size
,
8635 struct absaddr addr
,
8636 const char **symname
,
8639 uint64_t dist
= 0x100000;
8640 Elf_Internal_Sym
* sym
;
8641 Elf_Internal_Sym
* beg
;
8642 Elf_Internal_Sym
* end
;
8643 Elf_Internal_Sym
* best
= NULL
;
8645 REMOVE_ARCH_BITS (addr
.offset
);
8647 end
= symtab
+ nsyms
;
8653 sym
= beg
+ (end
- beg
) / 2;
8655 value
= sym
->st_value
;
8656 REMOVE_ARCH_BITS (value
);
8658 if (sym
->st_name
!= 0
8659 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
8660 && addr
.offset
>= value
8661 && addr
.offset
- value
< dist
)
8664 dist
= addr
.offset
- value
;
8669 if (addr
.offset
< value
)
8677 *symname
= (best
->st_name
>= strtab_size
8678 ? _("<corrupt>") : strtab
+ best
->st_name
);
8684 *offset
= addr
.offset
;
8687 static /* signed */ int
8688 symcmp (const void *p
, const void *q
)
8690 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
8691 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
8693 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
8696 /* Process the unwind section. */
8698 #include "unwind-ia64.h"
8700 struct ia64_unw_table_entry
8702 struct absaddr start
;
8704 struct absaddr info
;
8707 struct ia64_unw_aux_info
8709 struct ia64_unw_table_entry
* table
; /* Unwind table. */
8710 uint64_t table_len
; /* Length of unwind table. */
8711 unsigned char * info
; /* Unwind info. */
8712 uint64_t info_size
; /* Size of unwind info. */
8713 uint64_t info_addr
; /* Starting address of unwind info. */
8714 uint64_t seg_base
; /* Starting address of segment. */
8715 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8716 uint64_t nsyms
; /* Number of symbols. */
8717 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8718 uint64_t nfuns
; /* Number of entries in funtab. */
8719 char * strtab
; /* The string table. */
8720 uint64_t strtab_size
; /* Size of string table. */
8724 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
8726 struct ia64_unw_table_entry
* tp
;
8731 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8732 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8733 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8734 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8736 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8738 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8742 const unsigned char * dp
;
8743 const unsigned char * head
;
8744 const unsigned char * end
;
8745 const char * procname
;
8747 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8748 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
8750 fputs ("\n<", stdout
);
8754 fputs (procname
, stdout
);
8757 printf ("+%" PRIx64
, offset
);
8760 fputs (">: [", stdout
);
8761 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8762 fputc ('-', stdout
);
8763 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8764 printf ("], info at +0x%" PRIx64
"\n",
8765 tp
->info
.offset
- aux
->seg_base
);
8767 /* PR 17531: file: 86232b32. */
8768 if (aux
->info
== NULL
)
8771 offset
= tp
->info
.offset
;
8772 if (tp
->info
.section
)
8774 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
8776 warn (_("Invalid section %u in table entry %td\n"),
8777 tp
->info
.section
, tp
- aux
->table
);
8781 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
8783 offset
-= aux
->info_addr
;
8784 /* PR 17531: file: 0997b4d1. */
8785 if (offset
>= aux
->info_size
8786 || aux
->info_size
- offset
< 8)
8788 warn (_("Invalid offset %" PRIx64
" in table entry %td\n"),
8789 tp
->info
.offset
, tp
- aux
->table
);
8794 head
= aux
->info
+ offset
;
8795 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
8797 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
8798 (unsigned) UNW_VER (stamp
),
8799 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
8800 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
8801 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
8802 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
8804 if (UNW_VER (stamp
) != 1)
8806 printf (_("\tUnknown version.\n"));
8811 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
8812 /* PR 17531: file: 16ceda89. */
8813 if (end
> aux
->info
+ aux
->info_size
)
8814 end
= aux
->info
+ aux
->info_size
;
8815 for (dp
= head
+ 8; dp
< end
;)
8816 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
8825 slurp_ia64_unwind_table (Filedata
* filedata
,
8826 struct ia64_unw_aux_info
* aux
,
8827 Elf_Internal_Shdr
* sec
)
8829 uint64_t size
, nrelas
, i
;
8830 Elf_Internal_Phdr
* seg
;
8831 struct ia64_unw_table_entry
* tep
;
8832 Elf_Internal_Shdr
* relsec
;
8833 Elf_Internal_Rela
* rela
;
8834 Elf_Internal_Rela
* rp
;
8835 unsigned char * table
;
8837 Elf_Internal_Sym
* sym
;
8838 const char * relname
;
8842 /* First, find the starting address of the segment that includes
8845 if (filedata
->file_header
.e_phnum
)
8847 if (! get_program_headers (filedata
))
8850 for (seg
= filedata
->program_headers
;
8851 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8854 if (seg
->p_type
!= PT_LOAD
)
8857 if (sec
->sh_addr
>= seg
->p_vaddr
8858 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8860 aux
->seg_base
= seg
->p_vaddr
;
8866 /* Second, build the unwind table from the contents of the unwind section: */
8867 size
= sec
->sh_size
;
8868 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8873 aux
->table_len
= size
/ (3 * eh_addr_size
);
8874 aux
->table
= (struct ia64_unw_table_entry
*)
8875 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
8878 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
8880 tep
->start
.section
= SHN_UNDEF
;
8881 tep
->end
.section
= SHN_UNDEF
;
8882 tep
->info
.section
= SHN_UNDEF
;
8883 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8884 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8885 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8886 tep
->start
.offset
+= aux
->seg_base
;
8887 tep
->end
.offset
+= aux
->seg_base
;
8888 tep
->info
.offset
+= aux
->seg_base
;
8892 /* Third, apply any relocations to the unwind table: */
8893 for (relsec
= filedata
->section_headers
;
8894 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8897 if (relsec
->sh_type
!= SHT_RELA
8898 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8899 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8902 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8911 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8913 unsigned int sym_ndx
;
8914 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8915 relname
= elf_ia64_reloc_type (r_type
);
8917 /* PR 17531: file: 9fa67536. */
8918 if (relname
== NULL
)
8920 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8924 if (! startswith (relname
, "R_IA64_SEGREL"))
8926 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8930 i
= rp
->r_offset
/ (3 * eh_addr_size
);
8932 /* PR 17531: file: 5bc8d9bf. */
8933 if (i
>= aux
->table_len
)
8935 warn (_("Skipping reloc with overlarge offset: %#" PRIx64
"\n"),
8940 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8941 if (sym_ndx
>= aux
->nsyms
)
8943 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8947 sym
= aux
->symtab
+ sym_ndx
;
8949 switch (rp
->r_offset
/ eh_addr_size
% 3)
8952 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8953 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
8956 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8957 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
8960 aux
->table
[i
].info
.section
= sym
->st_shndx
;
8961 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
8975 ia64_process_unwind (Filedata
* filedata
)
8977 Elf_Internal_Shdr
* sec
;
8978 Elf_Internal_Shdr
* unwsec
= NULL
;
8979 uint64_t i
, unwcount
= 0, unwstart
= 0;
8980 struct ia64_unw_aux_info aux
;
8983 memset (& aux
, 0, sizeof (aux
));
8985 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8987 if (sec
->sh_type
== SHT_SYMTAB
)
8991 error (_("Multiple symbol tables encountered\n"));
8997 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8998 &aux
.strtab
, &aux
.strtab_size
))
9001 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
9006 printf (_("\nThere are no unwind sections in this file.\n"));
9008 while (unwcount
-- > 0)
9013 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
9014 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9015 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
9020 /* We have already counted the number of SHT_IA64_UNWIND
9021 sections so the loop above should never fail. */
9022 assert (unwsec
!= NULL
);
9025 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
9027 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
9029 /* We need to find which section group it is in. */
9030 struct group_list
* g
;
9032 if (filedata
->section_headers_groups
== NULL
9033 || filedata
->section_headers_groups
[i
] == NULL
)
9034 i
= filedata
->file_header
.e_shnum
;
9037 g
= filedata
->section_headers_groups
[i
]->root
;
9039 for (; g
!= NULL
; g
= g
->next
)
9041 sec
= filedata
->section_headers
+ g
->section_index
;
9043 if (section_name_valid (filedata
, sec
)
9044 && streq (section_name (filedata
, sec
),
9045 ELF_STRING_ia64_unwind_info
))
9050 i
= filedata
->file_header
.e_shnum
;
9053 else if (section_name_valid (filedata
, unwsec
)
9054 && startswith (section_name (filedata
, unwsec
),
9055 ELF_STRING_ia64_unwind_once
))
9057 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
9058 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
9059 suffix
= section_name (filedata
, unwsec
) + len
;
9060 for (i
= 0, sec
= filedata
->section_headers
;
9061 i
< filedata
->file_header
.e_shnum
;
9063 if (section_name_valid (filedata
, sec
)
9064 && startswith (section_name (filedata
, sec
),
9065 ELF_STRING_ia64_unwind_info_once
)
9066 && streq (section_name (filedata
, sec
) + len2
, suffix
))
9071 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
9072 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
9073 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
9074 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
9076 if (section_name_valid (filedata
, unwsec
)
9077 && startswith (section_name (filedata
, unwsec
),
9078 ELF_STRING_ia64_unwind
))
9079 suffix
= section_name (filedata
, unwsec
) + len
;
9080 for (i
= 0, sec
= filedata
->section_headers
;
9081 i
< filedata
->file_header
.e_shnum
;
9083 if (section_name_valid (filedata
, sec
)
9084 && startswith (section_name (filedata
, sec
),
9085 ELF_STRING_ia64_unwind_info
)
9086 && streq (section_name (filedata
, sec
) + len2
, suffix
))
9090 if (i
== filedata
->file_header
.e_shnum
)
9092 printf (_("\nCould not find unwind info section for "));
9094 if (filedata
->string_table
== NULL
)
9095 printf ("%d", unwsec
->sh_name
);
9097 printf ("'%s'", printable_section_name (filedata
, unwsec
));
9101 aux
.info_addr
= sec
->sh_addr
;
9102 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
9105 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
9107 printf (_("\nUnwind section "));
9109 if (filedata
->string_table
== NULL
)
9110 printf ("%d", unwsec
->sh_name
);
9112 printf ("'%s'", printable_section_name (filedata
, unwsec
));
9114 printf (_(" at offset %#" PRIx64
" contains %" PRIu64
" entries:\n"),
9116 unwsec
->sh_size
/ (3 * eh_addr_size
));
9118 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
9119 && aux
.table_len
> 0)
9120 dump_ia64_unwind (filedata
, & aux
);
9122 free ((char *) aux
.table
);
9123 free ((char *) aux
.info
);
9130 free ((char *) aux
.strtab
);
9135 struct hppa_unw_table_entry
9137 struct absaddr start
;
9139 unsigned int Cannot_unwind
:1; /* 0 */
9140 unsigned int Millicode
:1; /* 1 */
9141 unsigned int Millicode_save_sr0
:1; /* 2 */
9142 unsigned int Region_description
:2; /* 3..4 */
9143 unsigned int reserved1
:1; /* 5 */
9144 unsigned int Entry_SR
:1; /* 6 */
9145 unsigned int Entry_FR
:4; /* Number saved 7..10 */
9146 unsigned int Entry_GR
:5; /* Number saved 11..15 */
9147 unsigned int Args_stored
:1; /* 16 */
9148 unsigned int Variable_Frame
:1; /* 17 */
9149 unsigned int Separate_Package_Body
:1; /* 18 */
9150 unsigned int Frame_Extension_Millicode
:1; /* 19 */
9151 unsigned int Stack_Overflow_Check
:1; /* 20 */
9152 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
9153 unsigned int Ada_Region
:1; /* 22 */
9154 unsigned int cxx_info
:1; /* 23 */
9155 unsigned int cxx_try_catch
:1; /* 24 */
9156 unsigned int sched_entry_seq
:1; /* 25 */
9157 unsigned int reserved2
:1; /* 26 */
9158 unsigned int Save_SP
:1; /* 27 */
9159 unsigned int Save_RP
:1; /* 28 */
9160 unsigned int Save_MRP_in_frame
:1; /* 29 */
9161 unsigned int extn_ptr_defined
:1; /* 30 */
9162 unsigned int Cleanup_defined
:1; /* 31 */
9164 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
9165 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
9166 unsigned int Large_frame
:1; /* 2 */
9167 unsigned int Pseudo_SP_Set
:1; /* 3 */
9168 unsigned int reserved4
:1; /* 4 */
9169 unsigned int Total_frame_size
:27; /* 5..31 */
9172 struct hppa_unw_aux_info
9174 struct hppa_unw_table_entry
* table
; /* Unwind table. */
9175 uint64_t table_len
; /* Length of unwind table. */
9176 uint64_t seg_base
; /* Starting address of segment. */
9177 Elf_Internal_Sym
* symtab
; /* The symbol table. */
9178 uint64_t nsyms
; /* Number of symbols. */
9179 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
9180 uint64_t nfuns
; /* Number of entries in funtab. */
9181 char * strtab
; /* The string table. */
9182 uint64_t strtab_size
; /* Size of string table. */
9186 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
9188 struct hppa_unw_table_entry
* tp
;
9192 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9193 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9194 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9195 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9197 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9199 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
9202 const char * procname
;
9204 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
9205 aux
->strtab_size
, tp
->start
, &procname
,
9208 fputs ("\n<", stdout
);
9212 fputs (procname
, stdout
);
9215 printf ("+%" PRIx64
, offset
);
9218 fputs (">: [", stdout
);
9219 print_vma (tp
->start
.offset
, PREFIX_HEX
);
9220 fputc ('-', stdout
);
9221 print_vma (tp
->end
.offset
, PREFIX_HEX
);
9224 #define PF(_m) if (tp->_m) printf (#_m " ");
9225 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
9228 PF(Millicode_save_sr0
);
9229 /* PV(Region_description); */
9235 PF(Separate_Package_Body
);
9236 PF(Frame_Extension_Millicode
);
9237 PF(Stack_Overflow_Check
);
9238 PF(Two_Instruction_SP_Increment
);
9242 PF(sched_entry_seq
);
9245 PF(Save_MRP_in_frame
);
9246 PF(extn_ptr_defined
);
9247 PF(Cleanup_defined
);
9248 PF(MPE_XL_interrupt_marker
);
9249 PF(HP_UX_interrupt_marker
);
9252 PV(Total_frame_size
);
9265 slurp_hppa_unwind_table (Filedata
* filedata
,
9266 struct hppa_unw_aux_info
* aux
,
9267 Elf_Internal_Shdr
* sec
)
9269 uint64_t size
, unw_ent_size
, nentries
, nrelas
, i
;
9270 Elf_Internal_Phdr
* seg
;
9271 struct hppa_unw_table_entry
* tep
;
9272 Elf_Internal_Shdr
* relsec
;
9273 Elf_Internal_Rela
* rela
;
9274 Elf_Internal_Rela
* rp
;
9275 unsigned char * table
;
9277 Elf_Internal_Sym
* sym
;
9278 const char * relname
;
9280 /* First, find the starting address of the segment that includes
9282 if (filedata
->file_header
.e_phnum
)
9284 if (! get_program_headers (filedata
))
9287 for (seg
= filedata
->program_headers
;
9288 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
9291 if (seg
->p_type
!= PT_LOAD
)
9294 if (sec
->sh_addr
>= seg
->p_vaddr
9295 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
9297 aux
->seg_base
= seg
->p_vaddr
;
9303 /* Second, build the unwind table from the contents of the unwind
9305 size
= sec
->sh_size
;
9306 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
9312 nentries
= size
/ unw_ent_size
;
9313 size
= unw_ent_size
* nentries
;
9315 aux
->table_len
= nentries
;
9316 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
9317 xcmalloc (nentries
, sizeof (aux
->table
[0]));
9319 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
9321 unsigned int tmp1
, tmp2
;
9323 tep
->start
.section
= SHN_UNDEF
;
9324 tep
->end
.section
= SHN_UNDEF
;
9326 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
9327 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
9328 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
9329 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
9331 tep
->start
.offset
+= aux
->seg_base
;
9332 tep
->end
.offset
+= aux
->seg_base
;
9334 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
9335 tep
->Millicode
= (tmp1
>> 30) & 0x1;
9336 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
9337 tep
->Region_description
= (tmp1
>> 27) & 0x3;
9338 tep
->reserved1
= (tmp1
>> 26) & 0x1;
9339 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
9340 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
9341 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
9342 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
9343 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
9344 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
9345 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
9346 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
9347 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
9348 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
9349 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
9350 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
9351 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
9352 tep
->reserved2
= (tmp1
>> 5) & 0x1;
9353 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
9354 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
9355 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
9356 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
9357 tep
->Cleanup_defined
= tmp1
& 0x1;
9359 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
9360 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
9361 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
9362 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
9363 tep
->reserved4
= (tmp2
>> 27) & 0x1;
9364 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
9368 /* Third, apply any relocations to the unwind table. */
9369 for (relsec
= filedata
->section_headers
;
9370 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
9373 if (relsec
->sh_type
!= SHT_RELA
9374 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
9375 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
9378 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
9382 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
9384 unsigned int sym_ndx
;
9385 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
9386 relname
= elf_hppa_reloc_type (r_type
);
9388 if (relname
== NULL
)
9390 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
9394 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
9395 if (! startswith (relname
, "R_PARISC_SEGREL"))
9397 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
9401 i
= rp
->r_offset
/ unw_ent_size
;
9402 if (i
>= aux
->table_len
)
9404 warn (_("Skipping reloc with overlarge offset: %#" PRIx64
"\n"),
9409 sym_ndx
= get_reloc_symindex (rp
->r_info
);
9410 if (sym_ndx
>= aux
->nsyms
)
9412 warn (_("Skipping reloc with invalid symbol index: %u\n"),
9416 sym
= aux
->symtab
+ sym_ndx
;
9418 switch ((rp
->r_offset
% unw_ent_size
) / 4)
9421 aux
->table
[i
].start
.section
= sym
->st_shndx
;
9422 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
9425 aux
->table
[i
].end
.section
= sym
->st_shndx
;
9426 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
9440 hppa_process_unwind (Filedata
* filedata
)
9442 struct hppa_unw_aux_info aux
;
9443 Elf_Internal_Shdr
* unwsec
= NULL
;
9444 Elf_Internal_Shdr
* sec
;
9448 if (filedata
->string_table
== NULL
)
9451 memset (& aux
, 0, sizeof (aux
));
9453 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9455 if (sec
->sh_type
== SHT_SYMTAB
)
9459 error (_("Multiple symbol tables encountered\n"));
9465 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9466 &aux
.strtab
, &aux
.strtab_size
))
9469 else if (section_name_valid (filedata
, sec
)
9470 && streq (section_name (filedata
, sec
), ".PARISC.unwind"))
9475 printf (_("\nThere are no unwind sections in this file.\n"));
9477 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9479 if (section_name_valid (filedata
, sec
)
9480 && streq (section_name (filedata
, sec
), ".PARISC.unwind"))
9482 uint64_t num_unwind
= sec
->sh_size
/ 16;
9484 printf (ngettext ("\nUnwind section '%s' at offset %#" PRIx64
" "
9485 "contains %" PRIu64
" entry:\n",
9486 "\nUnwind section '%s' at offset %#" PRIx64
" "
9487 "contains %" PRIu64
" entries:\n",
9489 printable_section_name (filedata
, sec
),
9493 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
9496 if (res
&& aux
.table_len
> 0)
9498 if (! dump_hppa_unwind (filedata
, &aux
))
9502 free ((char *) aux
.table
);
9508 free ((char *) aux
.strtab
);
9515 unsigned char * data
; /* The unwind data. */
9516 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
9517 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
9518 uint64_t nrelas
; /* The number of relocations. */
9519 unsigned int rel_type
; /* REL or RELA ? */
9520 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
9523 struct arm_unw_aux_info
9525 Filedata
* filedata
; /* The file containing the unwind sections. */
9526 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
9527 uint64_t nsyms
; /* Number of symbols. */
9528 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
9529 uint64_t nfuns
; /* Number of these symbols. */
9530 char * strtab
; /* The file's string table. */
9531 uint64_t strtab_size
; /* Size of string table. */
9535 arm_print_vma_and_name (Filedata
* filedata
,
9536 struct arm_unw_aux_info
* aux
,
9538 struct absaddr addr
)
9540 const char *procname
;
9541 uint64_t sym_offset
;
9543 if (addr
.section
== SHN_UNDEF
)
9546 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
9547 aux
->strtab_size
, addr
, &procname
,
9550 print_vma (fn
, PREFIX_HEX
);
9554 fputs (" <", stdout
);
9555 fputs (procname
, stdout
);
9558 printf ("+0x%" PRIx64
, sym_offset
);
9559 fputc ('>', stdout
);
9566 arm_free_section (struct arm_section
*arm_sec
)
9568 free (arm_sec
->data
);
9569 free (arm_sec
->rela
);
9572 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
9573 cached section and install SEC instead.
9574 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
9575 and return its valued in * WORDP, relocating if necessary.
9576 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
9577 relocation's offset in ADDR.
9578 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
9579 into the string table of the symbol associated with the reloc. If no
9580 reloc was applied store -1 there.
9581 5) Return TRUE upon success, FALSE otherwise. */
9584 get_unwind_section_word (Filedata
* filedata
,
9585 struct arm_unw_aux_info
* aux
,
9586 struct arm_section
* arm_sec
,
9587 Elf_Internal_Shdr
* sec
,
9588 uint64_t word_offset
,
9589 unsigned int * wordp
,
9590 struct absaddr
* addr
,
9591 uint64_t * sym_name
)
9593 Elf_Internal_Rela
*rp
;
9594 Elf_Internal_Sym
*sym
;
9595 const char * relname
;
9599 if (sec
== NULL
|| arm_sec
== NULL
)
9602 addr
->section
= SHN_UNDEF
;
9605 if (sym_name
!= NULL
)
9606 *sym_name
= (uint64_t) -1;
9608 /* If necessary, update the section cache. */
9609 if (sec
!= arm_sec
->sec
)
9611 Elf_Internal_Shdr
*relsec
;
9613 arm_free_section (arm_sec
);
9616 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
9617 sec
->sh_size
, _("unwind data"));
9618 arm_sec
->rela
= NULL
;
9619 arm_sec
->nrelas
= 0;
9621 for (relsec
= filedata
->section_headers
;
9622 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
9625 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
9626 || filedata
->section_headers
+ relsec
->sh_info
!= sec
9627 /* PR 15745: Check the section type as well. */
9628 || (relsec
->sh_type
!= SHT_REL
9629 && relsec
->sh_type
!= SHT_RELA
))
9632 arm_sec
->rel_type
= relsec
->sh_type
;
9633 if (relsec
->sh_type
== SHT_REL
)
9635 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
9637 & arm_sec
->rela
, & arm_sec
->nrelas
))
9640 else /* relsec->sh_type == SHT_RELA */
9642 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
9644 & arm_sec
->rela
, & arm_sec
->nrelas
))
9650 arm_sec
->next_rela
= arm_sec
->rela
;
9653 /* If there is no unwind data we can do nothing. */
9654 if (arm_sec
->data
== NULL
)
9657 /* If the offset is invalid then fail. */
9658 if (/* PR 21343 *//* PR 18879 */
9660 || word_offset
> sec
->sh_size
- 4)
9663 /* Get the word at the required offset. */
9664 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
9666 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
9667 if (arm_sec
->rela
== NULL
)
9673 /* Look through the relocs to find the one that applies to the provided offset. */
9675 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
9677 uint64_t prelval
, offset
;
9679 if (rp
->r_offset
> word_offset
&& !wrapped
)
9684 if (rp
->r_offset
> word_offset
)
9687 if (rp
->r_offset
& 3)
9689 warn (_("Skipping unexpected relocation at offset %#" PRIx64
"\n"),
9694 if (rp
->r_offset
< word_offset
)
9697 /* PR 17531: file: 027-161405-0.004 */
9698 if (aux
->symtab
== NULL
)
9701 if (arm_sec
->rel_type
== SHT_REL
)
9703 offset
= word
& 0x7fffffff;
9704 if (offset
& 0x40000000)
9705 offset
|= ~ (uint64_t) 0x7fffffff;
9707 else if (arm_sec
->rel_type
== SHT_RELA
)
9708 offset
= rp
->r_addend
;
9711 error (_("Unknown section relocation type %d encountered\n"),
9716 /* PR 17531 file: 027-1241568-0.004. */
9717 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
9719 error (_("Bad symbol index in unwind relocation "
9720 "(%" PRIu64
" > %" PRIu64
")\n"),
9721 ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
9725 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
9726 offset
+= sym
->st_value
;
9727 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
9729 /* Check that we are processing the expected reloc type. */
9730 if (filedata
->file_header
.e_machine
== EM_ARM
)
9732 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
9733 if (relname
== NULL
)
9735 warn (_("Skipping unknown ARM relocation type: %d\n"),
9736 (int) ELF32_R_TYPE (rp
->r_info
));
9740 if (streq (relname
, "R_ARM_NONE"))
9743 if (! streq (relname
, "R_ARM_PREL31"))
9745 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
9749 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9751 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
9752 if (relname
== NULL
)
9754 warn (_("Skipping unknown C6000 relocation type: %d\n"),
9755 (int) ELF32_R_TYPE (rp
->r_info
));
9759 if (streq (relname
, "R_C6000_NONE"))
9762 if (! streq (relname
, "R_C6000_PREL31"))
9764 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
9772 /* This function currently only supports ARM and TI unwinders. */
9773 warn (_("Only TI and ARM unwinders are currently supported\n"));
9777 word
= (word
& ~ (uint64_t) 0x7fffffff) | (prelval
& 0x7fffffff);
9778 addr
->section
= sym
->st_shndx
;
9779 addr
->offset
= offset
;
9782 * sym_name
= sym
->st_name
;
9787 arm_sec
->next_rela
= rp
;
9792 static const char *tic6x_unwind_regnames
[16] =
9794 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
9795 "A14", "A13", "A12", "A11", "A10",
9796 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
9800 decode_tic6x_unwind_regmask (unsigned int mask
)
9804 for (i
= 12; mask
; mask
>>= 1, i
--)
9808 fputs (tic6x_unwind_regnames
[i
], stdout
);
9810 fputs (", ", stdout
);
9816 if (remaining == 0 && more_words) \
9819 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
9820 data_offset, & word, & addr, NULL)) \
9826 #define GET_OP(OP) \
9831 (OP) = word >> 24; \
9836 printf (_("[Truncated opcode]\n")); \
9839 printf ("0x%02x ", OP)
9842 decode_arm_unwind_bytecode (Filedata
* filedata
,
9843 struct arm_unw_aux_info
* aux
,
9845 unsigned int remaining
,
9846 unsigned int more_words
,
9847 uint64_t data_offset
,
9848 Elf_Internal_Shdr
* data_sec
,
9849 struct arm_section
* data_arm_sec
)
9851 struct absaddr addr
;
9854 /* Decode the unwinding instructions. */
9857 unsigned int op
, op2
;
9866 printf (" 0x%02x ", op
);
9868 if ((op
& 0xc0) == 0x00)
9870 int offset
= ((op
& 0x3f) << 2) + 4;
9872 printf (" vsp = vsp + %d", offset
);
9874 else if ((op
& 0xc0) == 0x40)
9876 int offset
= ((op
& 0x3f) << 2) + 4;
9878 printf (" vsp = vsp - %d", offset
);
9880 else if ((op
& 0xf0) == 0x80)
9883 if (op
== 0x80 && op2
== 0)
9884 printf (_("Refuse to unwind"));
9887 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
9892 for (i
= 0; i
< 12; i
++)
9893 if (mask
& (1 << i
))
9899 printf ("r%d", 4 + i
);
9904 else if ((op
& 0xf0) == 0x90)
9906 if (op
== 0x9d || op
== 0x9f)
9907 printf (_(" [Reserved]"));
9909 printf (" vsp = r%d", op
& 0x0f);
9911 else if ((op
& 0xf0) == 0xa0)
9913 int end
= 4 + (op
& 0x07);
9918 for (i
= 4; i
<= end
; i
++)
9934 else if (op
== 0xb0)
9935 printf (_(" finish"));
9936 else if (op
== 0xb1)
9939 if (op2
== 0 || (op2
& 0xf0) != 0)
9940 printf (_("[Spare]"));
9943 unsigned int mask
= op2
& 0x0f;
9948 for (i
= 0; i
< 12; i
++)
9949 if (mask
& (1 << i
))
9960 else if (op
== 0xb2)
9962 unsigned char buf
[9];
9963 unsigned int i
, len
;
9966 for (i
= 0; i
< sizeof (buf
); i
++)
9969 if ((buf
[i
] & 0x80) == 0)
9972 if (i
== sizeof (buf
))
9974 error (_("corrupt change to vsp\n"));
9979 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
9980 assert (len
== i
+ 1);
9981 offset
= offset
* 4 + 0x204;
9982 printf ("vsp = vsp + %" PRId64
, offset
);
9985 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
9987 unsigned int first
, last
;
9994 printf ("pop {D%d", first
);
9996 printf ("-D%d", first
+ last
);
9999 else if (op
== 0xb4)
10000 printf (_(" pop {ra_auth_code}"));
10001 else if (op
== 0xb5)
10002 printf (_(" vsp as modifier for PAC validation"));
10003 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
10005 unsigned int count
= op
& 0x07;
10007 printf ("pop {D8");
10009 printf ("-D%d", 8 + count
);
10012 else if (op
>= 0xc0 && op
<= 0xc5)
10014 unsigned int count
= op
& 0x07;
10016 printf (" pop {wR10");
10018 printf ("-wR%d", 10 + count
);
10021 else if (op
== 0xc6)
10023 unsigned int first
, last
;
10028 printf ("pop {wR%d", first
);
10030 printf ("-wR%d", first
+ last
);
10033 else if (op
== 0xc7)
10036 if (op2
== 0 || (op2
& 0xf0) != 0)
10037 printf (_("[Spare]"));
10040 unsigned int mask
= op2
& 0x0f;
10045 for (i
= 0; i
< 4; i
++)
10046 if (mask
& (1 << i
))
10052 printf ("wCGR%d", i
);
10059 printf (_(" [unsupported opcode]"));
10070 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
10071 struct arm_unw_aux_info
* aux
,
10073 unsigned int remaining
,
10074 unsigned int more_words
,
10075 uint64_t data_offset
,
10076 Elf_Internal_Shdr
* data_sec
,
10077 struct arm_section
* data_arm_sec
)
10079 struct absaddr addr
;
10081 /* Decode the unwinding instructions. */
10084 unsigned int op
, op2
;
10087 if (remaining
== 0)
10093 printf (" 0x%02x ", op
);
10095 if ((op
& 0xc0) == 0x00)
10097 int offset
= ((op
& 0x3f) << 3) + 8;
10098 printf (" sp = sp + %d", offset
);
10100 else if ((op
& 0xc0) == 0x80)
10103 if (op
== 0x80 && op2
== 0)
10104 printf (_("Refuse to unwind"));
10107 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
10109 printf ("pop compact {");
10113 decode_tic6x_unwind_regmask (mask
);
10117 else if ((op
& 0xf0) == 0xc0)
10120 unsigned int nregs
;
10125 unsigned int offset
;
10129 /* Scan entire instruction first so that GET_OP output is not
10130 interleaved with disassembly. */
10132 for (i
= 0; nregs
< (op
& 0xf); i
++)
10138 regpos
[nregs
].offset
= i
* 2;
10139 regpos
[nregs
].reg
= reg
;
10146 regpos
[nregs
].offset
= i
* 2 + 1;
10147 regpos
[nregs
].reg
= reg
;
10152 printf (_("pop frame {"));
10155 printf (_("*corrupt* - no registers specified"));
10160 for (i
= i
* 2; i
> 0; i
--)
10162 if (regpos
[reg
].offset
== i
- 1)
10164 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
10171 fputs (name
, stdout
);
10179 else if (op
== 0xd0)
10180 printf (" MOV FP, SP");
10181 else if (op
== 0xd1)
10182 printf (" __c6xabi_pop_rts");
10183 else if (op
== 0xd2)
10185 unsigned char buf
[9];
10186 unsigned int i
, len
;
10189 for (i
= 0; i
< sizeof (buf
); i
++)
10192 if ((buf
[i
] & 0x80) == 0)
10195 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
10196 if (i
== sizeof (buf
))
10198 warn (_("Corrupt stack pointer adjustment detected\n"));
10202 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
10203 assert (len
== i
+ 1);
10204 offset
= offset
* 8 + 0x408;
10205 printf (_("sp = sp + %" PRId64
), offset
);
10207 else if ((op
& 0xf0) == 0xe0)
10209 if ((op
& 0x0f) == 7)
10210 printf (" RETURN");
10212 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
10216 printf (_(" [unsupported opcode]"));
10225 arm_expand_prel31 (Filedata
* filedata
, uint64_t word
, uint64_t where
)
10229 offset
= word
& 0x7fffffff;
10230 if (offset
& 0x40000000)
10231 offset
|= ~ (uint64_t) 0x7fffffff;
10233 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
10236 return offset
+ where
;
10240 decode_arm_unwind (Filedata
* filedata
,
10241 struct arm_unw_aux_info
* aux
,
10243 unsigned int remaining
,
10244 uint64_t data_offset
,
10245 Elf_Internal_Shdr
* data_sec
,
10246 struct arm_section
* data_arm_sec
)
10249 unsigned int more_words
= 0;
10250 struct absaddr addr
;
10251 uint64_t sym_name
= (uint64_t) -1;
10254 if (remaining
== 0)
10256 /* Fetch the first word.
10257 Note - when decoding an object file the address extracted
10258 here will always be 0. So we also pass in the sym_name
10259 parameter so that we can find the symbol associated with
10260 the personality routine. */
10261 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
10262 & word
, & addr
, & sym_name
))
10269 addr
.section
= SHN_UNDEF
;
10273 if ((word
& 0x80000000) == 0)
10275 /* Expand prel31 for personality routine. */
10277 const char *procname
;
10279 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
10280 printf (_(" Personality routine: "));
10282 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
10283 && sym_name
!= (uint64_t) -1 && sym_name
< aux
->strtab_size
)
10285 procname
= aux
->strtab
+ sym_name
;
10286 print_vma (fn
, PREFIX_HEX
);
10289 fputs (" <", stdout
);
10290 fputs (procname
, stdout
);
10291 fputc ('>', stdout
);
10295 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
10296 fputc ('\n', stdout
);
10298 /* The GCC personality routines use the standard compact
10299 encoding, starting with one byte giving the number of
10301 if (procname
!= NULL
10302 && (startswith (procname
, "__gcc_personality_v0")
10303 || startswith (procname
, "__gxx_personality_v0")
10304 || startswith (procname
, "__gcj_personality_v0")
10305 || startswith (procname
, "__gnu_objc_personality_v0")))
10312 printf (_(" [Truncated data]\n"));
10315 more_words
= word
>> 24;
10325 /* ARM EHABI Section 6.3:
10327 An exception-handling table entry for the compact model looks like:
10329 31 30-28 27-24 23-0
10330 -- ----- ----- ----
10331 1 0 index Data for personalityRoutine[index] */
10333 if (filedata
->file_header
.e_machine
== EM_ARM
10334 && (word
& 0x70000000))
10336 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
10340 per_index
= (word
>> 24) & 0x7f;
10341 printf (_(" Compact model index: %d\n"), per_index
);
10342 if (per_index
== 0)
10348 else if (per_index
< 3)
10350 more_words
= (word
>> 16) & 0xff;
10356 switch (filedata
->file_header
.e_machine
)
10361 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
10362 data_offset
, data_sec
, data_arm_sec
))
10367 warn (_("Unknown ARM compact model index encountered\n"));
10368 printf (_(" [reserved]\n"));
10376 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
10377 data_offset
, data_sec
, data_arm_sec
))
10380 else if (per_index
< 5)
10382 if (((word
>> 17) & 0x7f) == 0x7f)
10383 printf (_(" Restore stack from frame pointer\n"));
10385 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
10386 printf (_(" Registers restored: "));
10387 if (per_index
== 4)
10388 printf (" (compact) ");
10389 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
10391 printf (_(" Return register: %s\n"),
10392 tic6x_unwind_regnames
[word
& 0xf]);
10395 printf (_(" [reserved (%d)]\n"), per_index
);
10399 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
10400 filedata
->file_header
.e_machine
);
10404 /* Decode the descriptors. Not implemented. */
10410 dump_arm_unwind (Filedata
* filedata
,
10411 struct arm_unw_aux_info
* aux
,
10412 Elf_Internal_Shdr
* exidx_sec
)
10414 struct arm_section exidx_arm_sec
, extab_arm_sec
;
10415 unsigned int i
, exidx_len
;
10419 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
10420 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
10421 exidx_len
= exidx_sec
->sh_size
/ 8;
10423 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
10424 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
10425 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
10426 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
10427 aux
->nfuns
= nfuns
;
10428 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
10430 for (i
= 0; i
< exidx_len
; i
++)
10432 unsigned int exidx_fn
, exidx_entry
;
10433 struct absaddr fn_addr
, entry_addr
;
10436 fputc ('\n', stdout
);
10438 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
10439 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
10440 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
10441 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
10443 free (aux
->funtab
);
10444 arm_free_section (& exidx_arm_sec
);
10445 arm_free_section (& extab_arm_sec
);
10449 /* ARM EHABI, Section 5:
10450 An index table entry consists of 2 words.
10451 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
10452 if (exidx_fn
& 0x80000000)
10454 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
10458 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
10460 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
10461 fputs (": ", stdout
);
10463 if (exidx_entry
== 1)
10465 print_vma (exidx_entry
, PREFIX_HEX
);
10466 fputs (" [cantunwind]\n", stdout
);
10468 else if (exidx_entry
& 0x80000000)
10470 print_vma (exidx_entry
, PREFIX_HEX
);
10471 fputc ('\n', stdout
);
10472 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
10476 uint64_t table
, table_offset
= 0;
10477 Elf_Internal_Shdr
*table_sec
;
10479 fputs ("@", stdout
);
10480 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
10481 print_vma (table
, PREFIX_HEX
);
10484 /* Locate the matching .ARM.extab. */
10485 if (entry_addr
.section
!= SHN_UNDEF
10486 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
10488 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
10489 table_offset
= entry_addr
.offset
;
10491 if (table_offset
> table_sec
->sh_size
)
10493 warn (_("Unwind entry contains corrupt offset (%#" PRIx64
") into section %s\n"),
10495 printable_section_name (filedata
, table_sec
));
10502 table_sec
= find_section_by_address (filedata
, table
);
10503 if (table_sec
!= NULL
)
10504 table_offset
= table
- table_sec
->sh_addr
;
10507 if (table_sec
== NULL
)
10509 warn (_("Could not locate .ARM.extab section containing %#" PRIx64
".\n"),
10515 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
10523 free (aux
->funtab
);
10524 arm_free_section (&exidx_arm_sec
);
10525 arm_free_section (&extab_arm_sec
);
10530 /* Used for both ARM and C6X unwinding tables. */
10533 arm_process_unwind (Filedata
* filedata
)
10535 struct arm_unw_aux_info aux
;
10536 Elf_Internal_Shdr
*unwsec
= NULL
;
10537 Elf_Internal_Shdr
*sec
;
10539 unsigned int sec_type
;
10542 switch (filedata
->file_header
.e_machine
)
10545 sec_type
= SHT_ARM_EXIDX
;
10549 sec_type
= SHT_C6000_UNWIND
;
10553 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
10554 filedata
->file_header
.e_machine
);
10558 if (filedata
->string_table
== NULL
)
10561 memset (& aux
, 0, sizeof (aux
));
10562 aux
.filedata
= filedata
;
10564 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
10566 if (sec
->sh_type
== SHT_SYMTAB
)
10570 error (_("Multiple symbol tables encountered\n"));
10576 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
10577 &aux
.strtab
, &aux
.strtab_size
))
10580 else if (sec
->sh_type
== sec_type
)
10584 if (unwsec
== NULL
)
10585 printf (_("\nThere are no unwind sections in this file.\n"));
10587 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
10589 if (sec
->sh_type
== sec_type
)
10591 uint64_t num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
10592 printf (ngettext ("\nUnwind section '%s' at offset %#" PRIx64
" "
10593 "contains %" PRIu64
" entry:\n",
10594 "\nUnwind section '%s' at offset %#" PRIx64
" "
10595 "contains %" PRIu64
" entries:\n",
10597 printable_section_name (filedata
, sec
),
10601 if (! dump_arm_unwind (filedata
, &aux
, sec
))
10607 free ((char *) aux
.strtab
);
10613 no_processor_specific_unwind (Filedata
* filedata ATTRIBUTE_UNUSED
)
10615 printf (_("No processor specific unwind information to decode\n"));
10620 process_unwind (Filedata
* filedata
)
10622 struct unwind_handler
10624 unsigned int machtype
;
10625 bool (* handler
)(Filedata
*);
10628 { EM_ARM
, arm_process_unwind
},
10629 { EM_IA_64
, ia64_process_unwind
},
10630 { EM_PARISC
, hppa_process_unwind
},
10631 { EM_TI_C6000
, arm_process_unwind
},
10632 { EM_386
, no_processor_specific_unwind
},
10633 { EM_X86_64
, no_processor_specific_unwind
},
10641 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
10642 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
10643 return handlers
[i
].handler (filedata
);
10645 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
10646 get_machine_name (filedata
->file_header
.e_machine
));
10651 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
10653 switch (entry
->d_tag
)
10655 case DT_AARCH64_BTI_PLT
:
10656 case DT_AARCH64_PAC_PLT
:
10659 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10666 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
10668 switch (entry
->d_tag
)
10670 case DT_MIPS_FLAGS
:
10671 if (entry
->d_un
.d_val
== 0)
10672 printf (_("NONE"));
10675 static const char * opts
[] =
10677 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
10678 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
10679 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
10680 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
10686 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
10687 if (entry
->d_un
.d_val
& (1 << cnt
))
10689 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
10695 case DT_MIPS_IVERSION
:
10696 if (valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
10697 printf (_("Interface Version: %s"),
10698 get_dynamic_name (filedata
, entry
->d_un
.d_val
));
10700 printf (_("Interface Version: <corrupt: %" PRIx64
">"),
10701 entry
->d_un
.d_ptr
);
10704 case DT_MIPS_TIME_STAMP
:
10708 time_t atime
= entry
->d_un
.d_val
;
10710 tmp
= gmtime (&atime
);
10711 /* PR 17531: file: 6accc532. */
10713 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
10715 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
10716 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10717 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10718 printf (_("Time Stamp: %s"), timebuf
);
10722 case DT_MIPS_RLD_VERSION
:
10723 case DT_MIPS_LOCAL_GOTNO
:
10724 case DT_MIPS_CONFLICTNO
:
10725 case DT_MIPS_LIBLISTNO
:
10726 case DT_MIPS_SYMTABNO
:
10727 case DT_MIPS_UNREFEXTNO
:
10728 case DT_MIPS_HIPAGENO
:
10729 case DT_MIPS_DELTA_CLASS_NO
:
10730 case DT_MIPS_DELTA_INSTANCE_NO
:
10731 case DT_MIPS_DELTA_RELOC_NO
:
10732 case DT_MIPS_DELTA_SYM_NO
:
10733 case DT_MIPS_DELTA_CLASSSYM_NO
:
10734 case DT_MIPS_COMPACT_SIZE
:
10735 print_vma (entry
->d_un
.d_val
, DEC
);
10738 case DT_MIPS_XHASH
:
10739 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10740 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10741 /* Falls through. */
10744 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10750 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
10752 switch (entry
->d_tag
)
10754 case DT_HP_DLD_FLAGS
:
10763 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
10764 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
10765 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
10766 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
10767 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
10768 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
10769 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
10770 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
10771 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
10772 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
10773 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
10774 { DT_HP_GST
, "HP_GST" },
10775 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
10776 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
10777 { DT_HP_NODELETE
, "HP_NODELETE" },
10778 { DT_HP_GROUP
, "HP_GROUP" },
10779 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
10783 uint64_t val
= entry
->d_un
.d_val
;
10785 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
10786 if (val
& flags
[cnt
].bit
)
10790 fputs (flags
[cnt
].str
, stdout
);
10792 val
^= flags
[cnt
].bit
;
10795 if (val
!= 0 || first
)
10799 print_vma (val
, HEX
);
10805 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10811 /* VMS vs Unix time offset and factor. */
10813 #define VMS_EPOCH_OFFSET 35067168000000000LL
10814 #define VMS_GRANULARITY_FACTOR 10000000
10816 #define INT64_MIN (-9223372036854775807LL - 1)
10819 /* Display a VMS time in a human readable format. */
10822 print_vms_time (int64_t vmstime
)
10824 struct tm
*tm
= NULL
;
10827 if (vmstime
>= INT64_MIN
+ VMS_EPOCH_OFFSET
)
10829 vmstime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
10831 if (unxtime
== vmstime
)
10832 tm
= gmtime (&unxtime
);
10835 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
10836 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
10837 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
10841 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
10843 switch (entry
->d_tag
)
10845 case DT_IA_64_PLT_RESERVE
:
10846 /* First 3 slots reserved. */
10847 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10849 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
10852 case DT_IA_64_VMS_LINKTIME
:
10853 print_vms_time (entry
->d_un
.d_val
);
10856 case DT_IA_64_VMS_LNKFLAGS
:
10857 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10858 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
10859 printf (" CALL_DEBUG");
10860 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
10861 printf (" NOP0BUFS");
10862 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
10863 printf (" P0IMAGE");
10864 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
10865 printf (" MKTHREADS");
10866 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
10867 printf (" UPCALLS");
10868 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
10869 printf (" IMGSTA");
10870 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
10871 printf (" INITIALIZE");
10872 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
10874 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
10875 printf (" EXE_INIT");
10876 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
10877 printf (" TBK_IN_IMG");
10878 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
10879 printf (" DBG_IN_IMG");
10880 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
10881 printf (" TBK_IN_DSF");
10882 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
10883 printf (" DBG_IN_DSF");
10884 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
10885 printf (" SIGNATURES");
10886 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
10887 printf (" REL_SEG_OFF");
10891 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10898 get_32bit_dynamic_section (Filedata
* filedata
)
10900 Elf32_External_Dyn
* edyn
;
10901 Elf32_External_Dyn
* ext
;
10902 Elf_Internal_Dyn
* entry
;
10904 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
10905 filedata
->dynamic_addr
, 1,
10906 filedata
->dynamic_size
,
10907 _("dynamic section"));
10911 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
10912 might not have the luxury of section headers. Look for the DT_NULL
10913 terminator to determine the number of entries. */
10914 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
10915 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
10918 filedata
->dynamic_nent
++;
10919 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
10923 filedata
->dynamic_section
10924 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
10925 if (filedata
->dynamic_section
== NULL
)
10927 error (_("Out of memory allocating space for %" PRIu64
" dynamic entries\n"),
10928 filedata
->dynamic_nent
);
10933 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10934 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10937 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10938 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10947 get_64bit_dynamic_section (Filedata
* filedata
)
10949 Elf64_External_Dyn
* edyn
;
10950 Elf64_External_Dyn
* ext
;
10951 Elf_Internal_Dyn
* entry
;
10953 /* Read in the data. */
10954 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
10955 filedata
->dynamic_addr
, 1,
10956 filedata
->dynamic_size
,
10957 _("dynamic section"));
10961 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
10962 might not have the luxury of section headers. Look for the DT_NULL
10963 terminator to determine the number of entries. */
10964 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
10965 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
10966 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
10969 filedata
->dynamic_nent
++;
10970 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
10974 filedata
->dynamic_section
10975 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
10976 if (filedata
->dynamic_section
== NULL
)
10978 error (_("Out of memory allocating space for %" PRIu64
" dynamic entries\n"),
10979 filedata
->dynamic_nent
);
10984 /* Convert from external to internal formats. */
10985 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10986 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10989 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10990 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10999 get_dynamic_section (Filedata
*filedata
)
11001 if (filedata
->dynamic_section
)
11005 return get_32bit_dynamic_section (filedata
);
11007 return get_64bit_dynamic_section (filedata
);
11011 print_dynamic_flags (uint64_t flags
)
11019 flag
= flags
& - flags
;
11025 putc (' ', stdout
);
11029 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
11030 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
11031 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
11032 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
11033 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
11034 default: fputs (_("unknown"), stdout
); break;
11041 get_dynamic_data (Filedata
* filedata
, uint64_t number
, unsigned int ent_size
)
11043 unsigned char * e_data
;
11046 /* If size_t is smaller than uint64_t, eg because you are building
11047 on a 32-bit host, then make sure that when number is cast to
11048 size_t no information is lost. */
11049 if ((size_t) number
!= number
11050 || ent_size
* number
/ ent_size
!= number
)
11052 error (_("Size overflow prevents reading %" PRIu64
11053 " elements of size %u\n"),
11058 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
11059 attempting to allocate memory when the read is bound to fail. */
11060 if (ent_size
* number
> filedata
->file_size
)
11062 error (_("Invalid number of dynamic entries: %" PRIu64
"\n"),
11067 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11068 if (e_data
== NULL
)
11070 error (_("Out of memory reading %" PRIu64
" dynamic entries\n"),
11075 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11077 error (_("Unable to read in %" PRIu64
" bytes of dynamic data\n"),
11078 number
* ent_size
);
11083 i_data
= (uint64_t *) cmalloc ((size_t) number
, sizeof (*i_data
));
11084 if (i_data
== NULL
)
11086 error (_("Out of memory allocating space for %" PRIu64
" dynamic entries\n"),
11093 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11101 get_num_dynamic_syms (Filedata
* filedata
)
11103 uint64_t num_of_syms
= 0;
11105 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
11106 return num_of_syms
;
11108 if (filedata
->dynamic_info
[DT_HASH
])
11110 unsigned char nb
[8];
11111 unsigned char nc
[8];
11112 unsigned int hash_ent_size
= 4;
11114 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11115 || filedata
->file_header
.e_machine
== EM_S390
11116 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11117 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11120 if (fseek64 (filedata
->handle
,
11121 (filedata
->archive_file_offset
11122 + offset_from_vma (filedata
,
11123 filedata
->dynamic_info
[DT_HASH
],
11124 sizeof nb
+ sizeof nc
)),
11127 error (_("Unable to seek to start of dynamic information\n"));
11131 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11133 error (_("Failed to read in number of buckets\n"));
11137 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11139 error (_("Failed to read in number of chains\n"));
11143 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
11144 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
11146 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
11148 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
11150 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
11153 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
11154 num_of_syms
= filedata
->nchains
;
11157 if (num_of_syms
== 0)
11159 free (filedata
->buckets
);
11160 filedata
->buckets
= NULL
;
11161 free (filedata
->chains
);
11162 filedata
->chains
= NULL
;
11163 filedata
->nbuckets
= 0;
11167 if (filedata
->dynamic_info_DT_GNU_HASH
)
11169 unsigned char nb
[16];
11170 uint64_t i
, maxchain
= 0xffffffff, bitmaskwords
;
11171 uint64_t buckets_vma
;
11174 if (fseek64 (filedata
->handle
,
11175 (filedata
->archive_file_offset
11176 + offset_from_vma (filedata
,
11177 filedata
->dynamic_info_DT_GNU_HASH
,
11181 error (_("Unable to seek to start of dynamic information\n"));
11185 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11187 error (_("Failed to read in number of buckets\n"));
11191 filedata
->ngnubuckets
= byte_get (nb
, 4);
11192 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
11193 bitmaskwords
= byte_get (nb
+ 8, 4);
11194 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
11196 buckets_vma
+= bitmaskwords
* 4;
11198 buckets_vma
+= bitmaskwords
* 8;
11200 if (fseek64 (filedata
->handle
,
11201 (filedata
->archive_file_offset
11202 + offset_from_vma (filedata
, buckets_vma
, 4)),
11205 error (_("Unable to seek to start of dynamic information\n"));
11209 filedata
->gnubuckets
11210 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
11212 if (filedata
->gnubuckets
== NULL
)
11215 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
11216 if (filedata
->gnubuckets
[i
] != 0)
11218 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
11221 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
11222 maxchain
= filedata
->gnubuckets
[i
];
11225 if (maxchain
== 0xffffffff)
11228 maxchain
-= filedata
->gnusymidx
;
11230 if (fseek64 (filedata
->handle
,
11231 (filedata
->archive_file_offset
11232 + offset_from_vma (filedata
,
11233 buckets_vma
+ 4 * (filedata
->ngnubuckets
11238 error (_("Unable to seek to start of dynamic information\n"));
11244 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11246 error (_("Failed to determine last chain length\n"));
11250 if (maxchain
+ 1 == 0)
11255 while ((byte_get (nb
, 4) & 1) == 0);
11257 if (fseek64 (filedata
->handle
,
11258 (filedata
->archive_file_offset
11259 + offset_from_vma (filedata
, (buckets_vma
11260 + 4 * filedata
->ngnubuckets
),
11264 error (_("Unable to seek to start of dynamic information\n"));
11268 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11269 filedata
->ngnuchains
= maxchain
;
11271 if (filedata
->gnuchains
== NULL
)
11274 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
11276 if (fseek64 (filedata
->handle
,
11277 (filedata
->archive_file_offset
11278 + offset_from_vma (filedata
, (buckets_vma
11279 + 4 * (filedata
->ngnubuckets
11283 error (_("Unable to seek to start of dynamic information\n"));
11287 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
11288 if (filedata
->mipsxlat
== NULL
)
11292 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
11293 if (filedata
->gnubuckets
[hn
] != 0)
11295 uint64_t si
= filedata
->gnubuckets
[hn
];
11296 uint64_t off
= si
- filedata
->gnusymidx
;
11300 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
11302 if (off
< filedata
->ngnuchains
11303 && filedata
->mipsxlat
[off
] >= num_of_syms
)
11304 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
11308 if (si
>= num_of_syms
)
11309 num_of_syms
= si
+ 1;
11313 while (off
< filedata
->ngnuchains
11314 && (filedata
->gnuchains
[off
++] & 1) == 0);
11317 if (num_of_syms
== 0)
11320 free (filedata
->mipsxlat
);
11321 filedata
->mipsxlat
= NULL
;
11322 free (filedata
->gnuchains
);
11323 filedata
->gnuchains
= NULL
;
11324 free (filedata
->gnubuckets
);
11325 filedata
->gnubuckets
= NULL
;
11326 filedata
->ngnubuckets
= 0;
11327 filedata
->ngnuchains
= 0;
11331 return num_of_syms
;
11334 /* Parse and display the contents of the dynamic section. */
11337 process_dynamic_section (Filedata
* filedata
)
11339 Elf_Internal_Dyn
* entry
;
11341 if (filedata
->dynamic_size
<= 1)
11345 if (filedata
->is_separate
)
11346 printf (_("\nThere is no dynamic section in linked file '%s'.\n"),
11347 filedata
->file_name
);
11349 printf (_("\nThere is no dynamic section in this file.\n"));
11355 if (!get_dynamic_section (filedata
))
11358 /* Find the appropriate symbol table. */
11359 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
11361 uint64_t num_of_syms
;
11363 for (entry
= filedata
->dynamic_section
;
11364 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11366 if (entry
->d_tag
== DT_SYMTAB
)
11367 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
11368 else if (entry
->d_tag
== DT_SYMENT
)
11369 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
11370 else if (entry
->d_tag
== DT_HASH
)
11371 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
11372 else if (entry
->d_tag
== DT_GNU_HASH
)
11373 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11374 else if ((filedata
->file_header
.e_machine
== EM_MIPS
11375 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
11376 && entry
->d_tag
== DT_MIPS_XHASH
)
11378 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
11379 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11382 num_of_syms
= get_num_dynamic_syms (filedata
);
11384 if (num_of_syms
!= 0
11385 && filedata
->dynamic_symbols
== NULL
11386 && filedata
->dynamic_info
[DT_SYMTAB
]
11387 && filedata
->dynamic_info
[DT_SYMENT
])
11389 Elf_Internal_Phdr
*seg
;
11390 uint64_t vma
= filedata
->dynamic_info
[DT_SYMTAB
];
11392 if (! get_program_headers (filedata
))
11394 error (_("Cannot interpret virtual addresses "
11395 "without program headers.\n"));
11399 for (seg
= filedata
->program_headers
;
11400 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
11403 if (seg
->p_type
!= PT_LOAD
)
11406 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
11408 /* See PR 21379 for a reproducer. */
11409 error (_("Invalid PT_LOAD entry\n"));
11413 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
11414 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
11416 /* Since we do not know how big the symbol table is,
11417 we default to reading in up to the end of PT_LOAD
11418 segment and processing that. This is overkill, I
11419 know, but it should work. */
11420 Elf_Internal_Shdr section
;
11421 section
.sh_offset
= (vma
- seg
->p_vaddr
11423 section
.sh_size
= (num_of_syms
11424 * filedata
->dynamic_info
[DT_SYMENT
]);
11425 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
11428 && filedata
->dynamic_symtab_section
!= NULL
11429 && ((filedata
->dynamic_symtab_section
->sh_offset
11430 != section
.sh_offset
)
11431 || (filedata
->dynamic_symtab_section
->sh_size
11432 != section
.sh_size
)
11433 || (filedata
->dynamic_symtab_section
->sh_entsize
11434 != section
.sh_entsize
)))
11436 the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
11438 section
.sh_name
= filedata
->string_table_length
;
11439 filedata
->dynamic_symbols
11440 = get_elf_symbols (filedata
, §ion
,
11441 &filedata
->num_dynamic_syms
);
11442 if (filedata
->dynamic_symbols
== NULL
11443 || filedata
->num_dynamic_syms
!= num_of_syms
)
11445 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
11454 /* Similarly find a string table. */
11455 if (filedata
->dynamic_strings
== NULL
)
11456 for (entry
= filedata
->dynamic_section
;
11457 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11460 if (entry
->d_tag
== DT_STRTAB
)
11461 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
11463 if (entry
->d_tag
== DT_STRSZ
)
11464 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
11466 if (filedata
->dynamic_info
[DT_STRTAB
]
11467 && filedata
->dynamic_info
[DT_STRSZ
])
11470 uint64_t str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
11472 offset
= offset_from_vma (filedata
,
11473 filedata
->dynamic_info
[DT_STRTAB
],
11476 && filedata
->dynamic_strtab_section
11477 && ((filedata
->dynamic_strtab_section
->sh_offset
11478 != (file_ptr
) offset
)
11479 || (filedata
->dynamic_strtab_section
->sh_size
11482 the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
11484 filedata
->dynamic_strings
11485 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
11486 _("dynamic string table"));
11487 if (filedata
->dynamic_strings
== NULL
)
11489 error (_("Corrupt DT_STRTAB dynamic entry\n"));
11493 filedata
->dynamic_strings_length
= str_tab_len
;
11498 /* And find the syminfo section if available. */
11499 if (filedata
->dynamic_syminfo
== NULL
)
11501 uint64_t syminsz
= 0;
11503 for (entry
= filedata
->dynamic_section
;
11504 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11507 if (entry
->d_tag
== DT_SYMINENT
)
11509 /* Note: these braces are necessary to avoid a syntax
11510 error from the SunOS4 C compiler. */
11511 /* PR binutils/17531: A corrupt file can trigger this test.
11512 So do not use an assert, instead generate an error message. */
11513 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
11514 error (_("Bad value (%d) for SYMINENT entry\n"),
11515 (int) entry
->d_un
.d_val
);
11517 else if (entry
->d_tag
== DT_SYMINSZ
)
11518 syminsz
= entry
->d_un
.d_val
;
11519 else if (entry
->d_tag
== DT_SYMINFO
)
11520 filedata
->dynamic_syminfo_offset
11521 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
11524 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
11526 Elf_External_Syminfo
* extsyminfo
;
11527 Elf_External_Syminfo
* extsym
;
11528 Elf_Internal_Syminfo
* syminfo
;
11530 /* There is a syminfo section. Read the data. */
11531 extsyminfo
= (Elf_External_Syminfo
*)
11532 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
11533 1, syminsz
, _("symbol information"));
11537 if (filedata
->dynamic_syminfo
!= NULL
)
11539 error (_("Multiple dynamic symbol information sections found\n"));
11540 free (filedata
->dynamic_syminfo
);
11542 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
11543 if (filedata
->dynamic_syminfo
== NULL
)
11545 error (_("Out of memory allocating %" PRIu64
11546 " bytes for dynamic symbol info\n"),
11551 filedata
->dynamic_syminfo_nent
11552 = syminsz
/ sizeof (Elf_External_Syminfo
);
11553 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
11554 syminfo
< (filedata
->dynamic_syminfo
11555 + filedata
->dynamic_syminfo_nent
);
11556 ++syminfo
, ++extsym
)
11558 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
11559 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
11566 if (do_dynamic
&& filedata
->dynamic_addr
)
11568 if (filedata
->is_separate
)
11569 printf (ngettext ("\nIn linked file '%s' the dynamic section at offset %#" PRIx64
" contains %" PRIu64
" entry:\n",
11570 "\nIn linked file '%s' the dynamic section at offset %#" PRIx64
" contains %" PRIu64
" entries:\n",
11571 filedata
->dynamic_nent
),
11572 filedata
->file_name
,
11573 filedata
->dynamic_addr
,
11574 filedata
->dynamic_nent
);
11576 printf (ngettext ("\nDynamic section at offset %#" PRIx64
" contains %" PRIu64
" entry:\n",
11577 "\nDynamic section at offset %#" PRIx64
" contains %" PRIu64
" entries:\n",
11578 filedata
->dynamic_nent
),
11579 filedata
->dynamic_addr
,
11580 filedata
->dynamic_nent
);
11583 printf (_(" Tag Type Name/Value\n"));
11585 for (entry
= filedata
->dynamic_section
;
11586 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11591 const char * dtype
;
11594 print_vma (entry
->d_tag
, FULL_HEX
);
11595 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
11596 printf (" (%s)%*s", dtype
,
11597 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
11600 switch (entry
->d_tag
)
11604 print_dynamic_flags (entry
->d_un
.d_val
);
11614 switch (entry
->d_tag
)
11617 printf (_("Auxiliary library"));
11621 printf (_("Filter library"));
11625 printf (_("Configuration file"));
11629 printf (_("Dependency audit library"));
11633 printf (_("Audit library"));
11637 if (valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
11638 printf (": [%s]\n",
11639 get_dynamic_name (filedata
, entry
->d_un
.d_val
));
11643 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11652 printf (_("Flags:"));
11654 if (entry
->d_un
.d_val
== 0)
11655 printf (_(" None\n"));
11658 uint64_t val
= entry
->d_un
.d_val
;
11660 if (val
& DTF_1_PARINIT
)
11662 printf (" PARINIT");
11663 val
^= DTF_1_PARINIT
;
11665 if (val
& DTF_1_CONFEXP
)
11667 printf (" CONFEXP");
11668 val
^= DTF_1_CONFEXP
;
11671 printf (" %" PRIx64
, val
);
11680 printf (_("Flags:"));
11682 if (entry
->d_un
.d_val
== 0)
11683 printf (_(" None\n"));
11686 uint64_t val
= entry
->d_un
.d_val
;
11688 if (val
& DF_P1_LAZYLOAD
)
11690 printf (" LAZYLOAD");
11691 val
^= DF_P1_LAZYLOAD
;
11693 if (val
& DF_P1_GROUPPERM
)
11695 printf (" GROUPPERM");
11696 val
^= DF_P1_GROUPPERM
;
11699 printf (" %" PRIx64
, val
);
11708 printf (_("Flags:"));
11709 if (entry
->d_un
.d_val
== 0)
11710 printf (_(" None\n"));
11713 uint64_t val
= entry
->d_un
.d_val
;
11715 if (val
& DF_1_NOW
)
11720 if (val
& DF_1_GLOBAL
)
11722 printf (" GLOBAL");
11723 val
^= DF_1_GLOBAL
;
11725 if (val
& DF_1_GROUP
)
11730 if (val
& DF_1_NODELETE
)
11732 printf (" NODELETE");
11733 val
^= DF_1_NODELETE
;
11735 if (val
& DF_1_LOADFLTR
)
11737 printf (" LOADFLTR");
11738 val
^= DF_1_LOADFLTR
;
11740 if (val
& DF_1_INITFIRST
)
11742 printf (" INITFIRST");
11743 val
^= DF_1_INITFIRST
;
11745 if (val
& DF_1_NOOPEN
)
11747 printf (" NOOPEN");
11748 val
^= DF_1_NOOPEN
;
11750 if (val
& DF_1_ORIGIN
)
11752 printf (" ORIGIN");
11753 val
^= DF_1_ORIGIN
;
11755 if (val
& DF_1_DIRECT
)
11757 printf (" DIRECT");
11758 val
^= DF_1_DIRECT
;
11760 if (val
& DF_1_TRANS
)
11765 if (val
& DF_1_INTERPOSE
)
11767 printf (" INTERPOSE");
11768 val
^= DF_1_INTERPOSE
;
11770 if (val
& DF_1_NODEFLIB
)
11772 printf (" NODEFLIB");
11773 val
^= DF_1_NODEFLIB
;
11775 if (val
& DF_1_NODUMP
)
11777 printf (" NODUMP");
11778 val
^= DF_1_NODUMP
;
11780 if (val
& DF_1_CONFALT
)
11782 printf (" CONFALT");
11783 val
^= DF_1_CONFALT
;
11785 if (val
& DF_1_ENDFILTEE
)
11787 printf (" ENDFILTEE");
11788 val
^= DF_1_ENDFILTEE
;
11790 if (val
& DF_1_DISPRELDNE
)
11792 printf (" DISPRELDNE");
11793 val
^= DF_1_DISPRELDNE
;
11795 if (val
& DF_1_DISPRELPND
)
11797 printf (" DISPRELPND");
11798 val
^= DF_1_DISPRELPND
;
11800 if (val
& DF_1_NODIRECT
)
11802 printf (" NODIRECT");
11803 val
^= DF_1_NODIRECT
;
11805 if (val
& DF_1_IGNMULDEF
)
11807 printf (" IGNMULDEF");
11808 val
^= DF_1_IGNMULDEF
;
11810 if (val
& DF_1_NOKSYMS
)
11812 printf (" NOKSYMS");
11813 val
^= DF_1_NOKSYMS
;
11815 if (val
& DF_1_NOHDR
)
11820 if (val
& DF_1_EDITED
)
11822 printf (" EDITED");
11823 val
^= DF_1_EDITED
;
11825 if (val
& DF_1_NORELOC
)
11827 printf (" NORELOC");
11828 val
^= DF_1_NORELOC
;
11830 if (val
& DF_1_SYMINTPOSE
)
11832 printf (" SYMINTPOSE");
11833 val
^= DF_1_SYMINTPOSE
;
11835 if (val
& DF_1_GLOBAUDIT
)
11837 printf (" GLOBAUDIT");
11838 val
^= DF_1_GLOBAUDIT
;
11840 if (val
& DF_1_SINGLETON
)
11842 printf (" SINGLETON");
11843 val
^= DF_1_SINGLETON
;
11845 if (val
& DF_1_STUB
)
11850 if (val
& DF_1_PIE
)
11855 if (val
& DF_1_KMOD
)
11860 if (val
& DF_1_WEAKFILTER
)
11862 printf (" WEAKFILTER");
11863 val
^= DF_1_WEAKFILTER
;
11865 if (val
& DF_1_NOCOMMON
)
11867 printf (" NOCOMMON");
11868 val
^= DF_1_NOCOMMON
;
11871 printf (" %" PRIx64
, val
);
11878 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11880 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
11901 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11907 if (valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
11908 name
= get_dynamic_name (filedata
, entry
->d_un
.d_val
);
11914 switch (entry
->d_tag
)
11917 printf (_("Shared library: [%s]"), name
);
11919 if (filedata
->program_interpreter
11920 && streq (name
, filedata
->program_interpreter
))
11921 printf (_(" program interpreter"));
11925 printf (_("Library soname: [%s]"), name
);
11929 printf (_("Library rpath: [%s]"), name
);
11933 printf (_("Library runpath: [%s]"), name
);
11937 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11942 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11957 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11958 /* Fall through. */
11962 case DT_PREINIT_ARRAYSZ
:
11963 case DT_INIT_ARRAYSZ
:
11964 case DT_FINI_ARRAYSZ
:
11965 case DT_GNU_CONFLICTSZ
:
11966 case DT_GNU_LIBLISTSZ
:
11969 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11970 printf (_(" (bytes)\n"));
11975 case DT_VERNEEDNUM
:
11980 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11989 case DT_INIT_ARRAY
:
11990 case DT_FINI_ARRAY
:
11993 if (entry
->d_tag
== DT_USED
11994 && valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
11997 = get_dynamic_name (filedata
, entry
->d_un
.d_val
);
12001 printf (_("Not needed object: [%s]\n"), name
);
12006 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12012 /* The value of this entry is ignored. */
12017 case DT_GNU_PRELINKED
:
12021 time_t atime
= entry
->d_un
.d_val
;
12023 tmp
= gmtime (&atime
);
12024 /* PR 17533 file: 041-1244816-0.004. */
12026 printf (_("<corrupt time val: %" PRIx64
),
12029 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
12030 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
12031 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
12037 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
12040 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12045 case DT_GNU_FLAGS_1
:
12048 printf (_("Flags:"));
12049 if (entry
->d_un
.d_val
== 0)
12050 printf (_(" None\n"));
12053 uint64_t val
= entry
->d_un
.d_val
;
12055 if (val
& DF_GNU_1_UNIQUE
)
12057 printf (" UNIQUE");
12058 val
^= DF_GNU_1_UNIQUE
;
12061 printf (" %" PRIx64
, val
);
12068 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
12069 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
12070 = entry
->d_un
.d_val
;
12074 switch (filedata
->file_header
.e_machine
)
12077 dynamic_section_aarch64_val (entry
);
12080 case EM_MIPS_RS3_LE
:
12081 dynamic_section_mips_val (filedata
, entry
);
12084 dynamic_section_parisc_val (entry
);
12087 dynamic_section_ia64_val (entry
);
12090 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12102 get_ver_flags (unsigned int flags
)
12104 static char buff
[128];
12111 if (flags
& VER_FLG_BASE
)
12112 strcat (buff
, "BASE");
12114 if (flags
& VER_FLG_WEAK
)
12116 if (flags
& VER_FLG_BASE
)
12117 strcat (buff
, " | ");
12119 strcat (buff
, "WEAK");
12122 if (flags
& VER_FLG_INFO
)
12124 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
12125 strcat (buff
, " | ");
12127 strcat (buff
, "INFO");
12130 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
12132 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
12133 strcat (buff
, " | ");
12135 strcat (buff
, _("<unknown>"));
12141 /* Display the contents of the version sections. */
12144 process_version_sections (Filedata
* filedata
)
12146 Elf_Internal_Shdr
* section
;
12148 bool found
= false;
12153 for (i
= 0, section
= filedata
->section_headers
;
12154 i
< filedata
->file_header
.e_shnum
;
12157 switch (section
->sh_type
)
12159 case SHT_GNU_verdef
:
12161 Elf_External_Verdef
* edefs
;
12168 if (filedata
->is_separate
)
12169 printf (ngettext ("\nIn linked file '%s' the version definition section '%s' contains %u entry:\n",
12170 "\nIn linked file '%s' the version definition section '%s' contains %u entries:\n",
12172 filedata
->file_name
,
12173 printable_section_name (filedata
, section
),
12176 printf (ngettext ("\nVersion definition section '%s' "
12177 "contains %u entry:\n",
12178 "\nVersion definition section '%s' "
12179 "contains %u entries:\n",
12181 printable_section_name (filedata
, section
),
12184 printf (_(" Addr: 0x%016" PRIx64
), section
->sh_addr
);
12185 printf (_(" Offset: 0x%08" PRIx64
" Link: %u (%s)\n"),
12186 section
->sh_offset
, section
->sh_link
,
12187 printable_section_name_from_index (filedata
, section
->sh_link
));
12189 edefs
= (Elf_External_Verdef
*)
12190 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
12191 _("version definition section"));
12194 endbuf
= (char *) edefs
+ section
->sh_size
;
12196 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
12199 Elf_External_Verdef
* edef
;
12200 Elf_Internal_Verdef ent
;
12201 Elf_External_Verdaux
* eaux
;
12202 Elf_Internal_Verdaux aux
;
12206 vstart
= ((char *) edefs
) + idx
;
12207 if (vstart
+ sizeof (*edef
) > endbuf
)
12210 edef
= (Elf_External_Verdef
*) vstart
;
12212 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
12213 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
12214 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
12215 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
12216 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
12217 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
12218 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
12220 printf (_(" %#06zx: Rev: %d Flags: %s"),
12221 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
12223 printf (_(" Index: %d Cnt: %d "),
12224 ent
.vd_ndx
, ent
.vd_cnt
);
12226 /* Check for overflow. */
12227 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
12230 vstart
+= ent
.vd_aux
;
12232 if (vstart
+ sizeof (*eaux
) > endbuf
)
12234 eaux
= (Elf_External_Verdaux
*) vstart
;
12236 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
12237 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
12239 if (valid_dynamic_name (filedata
, aux
.vda_name
))
12240 printf (_("Name: %s\n"),
12241 get_dynamic_name (filedata
, aux
.vda_name
));
12243 printf (_("Name index: %ld\n"), aux
.vda_name
);
12245 isum
= idx
+ ent
.vd_aux
;
12247 for (j
= 1; j
< ent
.vd_cnt
; j
++)
12249 if (aux
.vda_next
< sizeof (*eaux
)
12250 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
12252 warn (_("Invalid vda_next field of %lx\n"),
12257 /* Check for overflow. */
12258 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
12261 isum
+= aux
.vda_next
;
12262 vstart
+= aux
.vda_next
;
12264 if (vstart
+ sizeof (*eaux
) > endbuf
)
12266 eaux
= (Elf_External_Verdaux
*) vstart
;
12268 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
12269 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
12271 if (valid_dynamic_name (filedata
, aux
.vda_name
))
12272 printf (_(" %#06zx: Parent %d: %s\n"),
12274 get_dynamic_name (filedata
, aux
.vda_name
));
12276 printf (_(" %#06zx: Parent %d, name index: %ld\n"),
12277 isum
, j
, aux
.vda_name
);
12280 if (j
< ent
.vd_cnt
)
12281 printf (_(" Version def aux past end of section\n"));
12284 file: id:000001,src:000172+005151,op:splice,rep:2. */
12285 if (ent
.vd_next
< sizeof (*edef
)
12286 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
12288 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
12289 cnt
= section
->sh_info
;
12292 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
12295 idx
+= ent
.vd_next
;
12298 if (cnt
< section
->sh_info
)
12299 printf (_(" Version definition past end of section\n"));
12305 case SHT_GNU_verneed
:
12307 Elf_External_Verneed
* eneed
;
12314 if (filedata
->is_separate
)
12315 printf (ngettext ("\nIn linked file '%s' the version needs section '%s' contains %u entry:\n",
12316 "\nIn linked file '%s' the version needs section '%s' contains %u entries:\n",
12318 filedata
->file_name
,
12319 printable_section_name (filedata
, section
),
12322 printf (ngettext ("\nVersion needs section '%s' "
12323 "contains %u entry:\n",
12324 "\nVersion needs section '%s' "
12325 "contains %u entries:\n",
12327 printable_section_name (filedata
, section
),
12330 printf (_(" Addr: 0x%016" PRIx64
), section
->sh_addr
);
12331 printf (_(" Offset: 0x%08" PRIx64
" Link: %u (%s)\n"),
12332 section
->sh_offset
, section
->sh_link
,
12333 printable_section_name_from_index (filedata
, section
->sh_link
));
12335 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
12336 section
->sh_offset
, 1,
12338 _("Version Needs section"));
12341 endbuf
= (char *) eneed
+ section
->sh_size
;
12343 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
12345 Elf_External_Verneed
* entry
;
12346 Elf_Internal_Verneed ent
;
12351 vstart
= ((char *) eneed
) + idx
;
12352 if (vstart
+ sizeof (*entry
) > endbuf
)
12355 entry
= (Elf_External_Verneed
*) vstart
;
12357 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
12358 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
12359 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
12360 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
12361 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
12363 printf (_(" %#06zx: Version: %d"), idx
, ent
.vn_version
);
12365 if (valid_dynamic_name (filedata
, ent
.vn_file
))
12366 printf (_(" File: %s"),
12367 get_dynamic_name (filedata
, ent
.vn_file
));
12369 printf (_(" File: %lx"), ent
.vn_file
);
12371 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
12373 /* Check for overflow. */
12374 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
12376 vstart
+= ent
.vn_aux
;
12378 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
12380 Elf_External_Vernaux
* eaux
;
12381 Elf_Internal_Vernaux aux
;
12383 if (vstart
+ sizeof (*eaux
) > endbuf
)
12385 eaux
= (Elf_External_Vernaux
*) vstart
;
12387 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
12388 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
12389 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
12390 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
12391 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
12393 if (valid_dynamic_name (filedata
, aux
.vna_name
))
12394 printf (_(" %#06zx: Name: %s"),
12395 isum
, get_dynamic_name (filedata
, aux
.vna_name
));
12397 printf (_(" %#06zx: Name index: %lx"),
12398 isum
, aux
.vna_name
);
12400 printf (_(" Flags: %s Version: %d\n"),
12401 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
12403 if (aux
.vna_next
< sizeof (*eaux
)
12404 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
12406 warn (_("Invalid vna_next field of %lx\n"),
12411 /* Check for overflow. */
12412 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
12414 isum
+= aux
.vna_next
;
12415 vstart
+= aux
.vna_next
;
12418 if (j
< ent
.vn_cnt
)
12419 warn (_("Missing Version Needs auxiliary information\n"));
12421 if (ent
.vn_next
< sizeof (*entry
)
12422 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
12424 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
12425 cnt
= section
->sh_info
;
12428 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
12430 idx
+= ent
.vn_next
;
12433 if (cnt
< section
->sh_info
)
12434 warn (_("Missing Version Needs information\n"));
12440 case SHT_GNU_versym
:
12442 Elf_Internal_Shdr
* link_section
;
12445 unsigned char * edata
;
12446 unsigned short * data
;
12448 Elf_Internal_Sym
* symbols
;
12449 Elf_Internal_Shdr
* string_sec
;
12453 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
12456 link_section
= filedata
->section_headers
+ section
->sh_link
;
12457 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
12459 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
12464 symbols
= get_elf_symbols (filedata
, link_section
, & num_syms
);
12465 if (symbols
== NULL
)
12468 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
12470 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
12471 string_sec
->sh_size
,
12472 _("version string table"));
12479 if (filedata
->is_separate
)
12480 printf (ngettext ("\nIn linked file '%s' the version symbols section '%s' contains %" PRIu64
" entry:\n",
12481 "\nIn linked file '%s' the version symbols section '%s' contains %" PRIu64
" entries:\n",
12483 filedata
->file_name
,
12484 printable_section_name (filedata
, section
),
12487 printf (ngettext ("\nVersion symbols section '%s' "
12488 "contains %" PRIu64
" entry:\n",
12489 "\nVersion symbols section '%s' "
12490 "contains %" PRIu64
" entries:\n",
12492 printable_section_name (filedata
, section
),
12495 printf (_(" Addr: 0x%016" PRIx64
), section
->sh_addr
);
12496 printf (_(" Offset: 0x%08" PRIx64
" Link: %u (%s)\n"),
12497 section
->sh_offset
, section
->sh_link
,
12498 printable_section_name (filedata
, link_section
));
12500 off
= offset_from_vma (filedata
,
12501 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
12502 total
* sizeof (short));
12503 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
12504 sizeof (short), total
,
12505 _("version symbol data"));
12513 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
12515 for (cnt
= total
; cnt
--;)
12516 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
12521 for (cnt
= 0; cnt
< total
; cnt
+= 4)
12525 char *invalid
= _("*invalid*");
12527 printf (" %03x:", cnt
);
12529 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
12530 switch (data
[cnt
+ j
])
12533 fputs (_(" 0 (*local*) "), stdout
);
12537 fputs (_(" 1 (*global*) "), stdout
);
12541 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
12542 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
12544 /* If this index value is greater than the size of the symbols
12545 array, break to avoid an out-of-bounds read. */
12546 if (cnt
+ j
>= num_syms
)
12548 warn (_("invalid index into symbol array\n"));
12553 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
12555 Elf_Internal_Verneed ivn
;
12558 offset
= offset_from_vma
12560 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
12561 sizeof (Elf_External_Verneed
));
12565 Elf_Internal_Vernaux ivna
;
12566 Elf_External_Verneed evn
;
12567 Elf_External_Vernaux evna
;
12570 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
12571 _("version need")) == NULL
)
12574 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
12575 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
12577 a_off
= offset
+ ivn
.vn_aux
;
12581 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
12582 1, _("version need aux (2)")) == NULL
)
12585 ivna
.vna_other
= 0;
12589 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
12590 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
12593 a_off
+= ivna
.vna_next
;
12595 while (ivna
.vna_other
!= data
[cnt
+ j
]
12596 && ivna
.vna_next
!= 0);
12598 if (ivna
.vna_other
== data
[cnt
+ j
])
12600 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
12602 if (ivna
.vna_name
>= string_sec
->sh_size
)
12605 name
= strtab
+ ivna
.vna_name
;
12609 offset
+= ivn
.vn_next
;
12611 while (ivn
.vn_next
);
12614 if (data
[cnt
+ j
] != 0x8001
12615 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
12617 Elf_Internal_Verdef ivd
;
12618 Elf_External_Verdef evd
;
12621 offset
= offset_from_vma
12623 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
12628 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
12629 _("version def")) == NULL
)
12632 /* PR 17531: file: 046-1082287-0.004. */
12633 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
12638 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
12639 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
12642 offset
+= ivd
.vd_next
;
12644 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
12645 && ivd
.vd_next
!= 0);
12647 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
12649 Elf_External_Verdaux evda
;
12650 Elf_Internal_Verdaux ivda
;
12652 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
12654 if (get_data (&evda
, filedata
,
12655 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
12657 _("version def aux")) == NULL
)
12660 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
12662 if (ivda
.vda_name
>= string_sec
->sh_size
)
12664 else if (name
!= NULL
&& name
!= invalid
)
12665 name
= _("*both*");
12667 name
= strtab
+ ivda
.vda_name
;
12671 nn
+= printf ("(%s%-*s",
12673 12 - (int) strlen (name
),
12677 printf ("%*c", 18 - nn
, ' ');
12696 if (filedata
->is_separate
)
12697 printf (_("\nNo version information found in linked file '%s'.\n"),
12698 filedata
->file_name
);
12700 printf (_("\nNo version information found in this file.\n"));
12706 static const char *
12707 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
12709 static char buff
[64];
12713 case STB_LOCAL
: return "LOCAL";
12714 case STB_GLOBAL
: return "GLOBAL";
12715 case STB_WEAK
: return "WEAK";
12717 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
12718 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
12720 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
12722 if (binding
== STB_GNU_UNIQUE
12723 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
12725 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
12728 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
12733 static const char *
12734 get_symbol_type (Filedata
* filedata
, unsigned int type
)
12736 static char buff
[64];
12740 case STT_NOTYPE
: return "NOTYPE";
12741 case STT_OBJECT
: return "OBJECT";
12742 case STT_FUNC
: return "FUNC";
12743 case STT_SECTION
: return "SECTION";
12744 case STT_FILE
: return "FILE";
12745 case STT_COMMON
: return "COMMON";
12746 case STT_TLS
: return "TLS";
12747 case STT_RELC
: return "RELC";
12748 case STT_SRELC
: return "SRELC";
12750 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
12752 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
12753 return "THUMB_FUNC";
12755 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
12758 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
12759 return "PARISC_MILLI";
12761 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
12763 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
12765 if (filedata
->file_header
.e_machine
== EM_PARISC
)
12767 if (type
== STT_HP_OPAQUE
)
12768 return "HP_OPAQUE";
12769 if (type
== STT_HP_STUB
)
12773 if (type
== STT_GNU_IFUNC
12774 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
12775 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
12778 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
12781 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
12786 static const char *
12787 get_symbol_visibility (unsigned int visibility
)
12789 switch (visibility
)
12791 case STV_DEFAULT
: return "DEFAULT";
12792 case STV_INTERNAL
: return "INTERNAL";
12793 case STV_HIDDEN
: return "HIDDEN";
12794 case STV_PROTECTED
: return "PROTECTED";
12796 error (_("Unrecognized visibility value: %u\n"), visibility
);
12797 return _("<unknown>");
12801 static const char *
12802 get_alpha_symbol_other (unsigned int other
)
12806 case STO_ALPHA_NOPV
: return "NOPV";
12807 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
12809 error (_("Unrecognized alpha specific other value: %u\n"), other
);
12810 return _("<unknown>");
12814 static const char *
12815 get_solaris_symbol_visibility (unsigned int visibility
)
12817 switch (visibility
)
12819 case 4: return "EXPORTED";
12820 case 5: return "SINGLETON";
12821 case 6: return "ELIMINATE";
12822 default: return get_symbol_visibility (visibility
);
12826 static const char *
12827 get_aarch64_symbol_other (unsigned int other
)
12829 static char buf
[32];
12831 if (other
& STO_AARCH64_VARIANT_PCS
)
12833 other
&= ~STO_AARCH64_VARIANT_PCS
;
12835 return "VARIANT_PCS";
12836 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
12842 static const char *
12843 get_mips_symbol_other (unsigned int other
)
12847 case STO_OPTIONAL
: return "OPTIONAL";
12848 case STO_MIPS_PLT
: return "MIPS PLT";
12849 case STO_MIPS_PIC
: return "MIPS PIC";
12850 case STO_MICROMIPS
: return "MICROMIPS";
12851 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
12852 case STO_MIPS16
: return "MIPS16";
12853 default: return NULL
;
12857 static const char *
12858 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
12860 if (is_ia64_vms (filedata
))
12862 static char res
[32];
12866 /* Function types is for images and .STB files only. */
12867 switch (filedata
->file_header
.e_type
)
12871 switch (VMS_ST_FUNC_TYPE (other
))
12873 case VMS_SFT_CODE_ADDR
:
12874 strcat (res
, " CA");
12876 case VMS_SFT_SYMV_IDX
:
12877 strcat (res
, " VEC");
12880 strcat (res
, " FD");
12882 case VMS_SFT_RESERVE
:
12883 strcat (res
, " RSV");
12886 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
12887 VMS_ST_FUNC_TYPE (other
));
12888 strcat (res
, " <unknown>");
12895 switch (VMS_ST_LINKAGE (other
))
12897 case VMS_STL_IGNORE
:
12898 strcat (res
, " IGN");
12900 case VMS_STL_RESERVE
:
12901 strcat (res
, " RSV");
12904 strcat (res
, " STD");
12907 strcat (res
, " LNK");
12910 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
12911 VMS_ST_LINKAGE (other
));
12912 strcat (res
, " <unknown>");
12924 static const char *
12925 get_ppc64_symbol_other (unsigned int other
)
12927 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
12930 other
>>= STO_PPC64_LOCAL_BIT
;
12933 static char buf
[64];
12935 other
= ppc64_decode_local_entry (other
);
12936 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
12942 static const char *
12943 get_riscv_symbol_other (unsigned int other
)
12945 static char buf
[32];
12948 if (other
& STO_RISCV_VARIANT_CC
)
12950 strcat (buf
, _(" VARIANT_CC"));
12951 other
&= ~STO_RISCV_VARIANT_CC
;
12955 snprintf (buf
, sizeof buf
, " %x", other
);
12964 static const char *
12965 get_symbol_other (Filedata
* filedata
, unsigned int other
)
12967 const char * result
= NULL
;
12968 static char buff
[64];
12973 switch (filedata
->file_header
.e_machine
)
12976 result
= get_alpha_symbol_other (other
);
12979 result
= get_aarch64_symbol_other (other
);
12982 result
= get_mips_symbol_other (other
);
12985 result
= get_ia64_symbol_other (filedata
, other
);
12988 result
= get_ppc64_symbol_other (other
);
12991 result
= get_riscv_symbol_other (other
);
13001 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
13005 static const char *
13006 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
13008 static char buff
[32];
13012 case SHN_UNDEF
: return "UND";
13013 case SHN_ABS
: return "ABS";
13014 case SHN_COMMON
: return "COM";
13016 if (type
== SHN_IA_64_ANSI_COMMON
13017 && filedata
->file_header
.e_machine
== EM_IA_64
13018 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
13020 else if ((filedata
->file_header
.e_machine
== EM_X86_64
13021 || filedata
->file_header
.e_machine
== EM_L1OM
13022 || filedata
->file_header
.e_machine
== EM_K1OM
)
13023 && type
== SHN_X86_64_LCOMMON
)
13024 return "LARGE_COM";
13025 else if ((type
== SHN_MIPS_SCOMMON
13026 && filedata
->file_header
.e_machine
== EM_MIPS
)
13027 || (type
== SHN_TIC6X_SCOMMON
13028 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
13030 else if (type
== SHN_MIPS_SUNDEFINED
13031 && filedata
->file_header
.e_machine
== EM_MIPS
)
13033 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
13034 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
13035 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
13036 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
13037 else if (type
>= SHN_LORESERVE
)
13038 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
13039 else if (filedata
->file_header
.e_shnum
!= 0
13040 && type
>= filedata
->file_header
.e_shnum
)
13041 sprintf (buff
, _("bad section index[%3d]"), type
);
13043 sprintf (buff
, "%3d", type
);
13050 static const char *
13051 get_symbol_version_string (Filedata
*filedata
,
13053 const char *strtab
,
13054 size_t strtab_size
,
13056 Elf_Internal_Sym
*psym
,
13057 enum versioned_symbol_info
*sym_info
,
13058 unsigned short *vna_other
)
13060 unsigned char data
[2];
13061 unsigned short vers_data
;
13063 unsigned short max_vd_ndx
;
13066 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
13069 offset
= offset_from_vma (filedata
,
13070 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
13071 sizeof data
+ si
* sizeof (vers_data
));
13073 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
13074 sizeof (data
), 1, _("version data")) == NULL
)
13077 vers_data
= byte_get (data
, 2);
13079 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
13082 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
13085 /* Usually we'd only see verdef for defined symbols, and verneed for
13086 undefined symbols. However, symbols defined by the linker in
13087 .dynbss for variables copied from a shared library in order to
13088 avoid text relocations are defined yet have verneed. We could
13089 use a heuristic to detect the special case, for example, check
13090 for verneed first on symbols defined in SHT_NOBITS sections, but
13091 it is simpler and more reliable to just look for both verdef and
13092 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
13094 if (psym
->st_shndx
!= SHN_UNDEF
13095 && vers_data
!= 0x8001
13096 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
13098 Elf_Internal_Verdef ivd
;
13099 Elf_Internal_Verdaux ivda
;
13100 Elf_External_Verdaux evda
;
13103 off
= offset_from_vma (filedata
,
13104 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
13105 sizeof (Elf_External_Verdef
));
13109 Elf_External_Verdef evd
;
13111 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
13112 _("version def")) == NULL
)
13121 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
13122 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
13123 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
13124 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
13127 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
13128 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
13130 off
+= ivd
.vd_next
;
13132 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
13134 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
13136 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
13139 off
-= ivd
.vd_next
;
13142 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
13143 _("version def aux")) != NULL
)
13145 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
13147 if (psym
->st_name
!= ivda
.vda_name
)
13148 return (ivda
.vda_name
< strtab_size
13149 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
13154 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
13156 Elf_External_Verneed evn
;
13157 Elf_Internal_Verneed ivn
;
13158 Elf_Internal_Vernaux ivna
;
13160 offset
= offset_from_vma (filedata
,
13161 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
13167 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
13168 _("version need")) == NULL
)
13171 ivna
.vna_other
= 0;
13176 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
13177 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
13179 vna_off
= offset
+ ivn
.vn_aux
;
13183 Elf_External_Vernaux evna
;
13185 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
13186 _("version need aux (3)")) == NULL
)
13189 ivna
.vna_other
= 0;
13194 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
13195 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
13196 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
13199 vna_off
+= ivna
.vna_next
;
13201 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
13203 if (ivna
.vna_other
== vers_data
)
13206 offset
+= ivn
.vn_next
;
13208 while (ivn
.vn_next
!= 0);
13210 if (ivna
.vna_other
== vers_data
)
13212 *sym_info
= symbol_undefined
;
13213 *vna_other
= ivna
.vna_other
;
13214 return (ivna
.vna_name
< strtab_size
13215 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
13217 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
13218 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
13219 return _("<corrupt>");
13224 /* Display a symbol size on stdout. Format is based on --sym-base setting. */
13226 static unsigned int
13227 print_dynamic_symbol_size (uint64_t vma
, int base
)
13232 return print_vma (vma
, OCTAL_5
);
13235 return print_vma (vma
, UNSIGNED_5
);
13238 return print_vma (vma
, PREFIX_HEX_5
);
13242 return print_vma (vma
, DEC_5
);
13247 print_dynamic_symbol (Filedata
*filedata
, uint64_t si
,
13248 Elf_Internal_Sym
*symtab
,
13249 Elf_Internal_Shdr
*section
,
13250 char *strtab
, size_t strtab_size
)
13252 const char *version_string
;
13253 enum versioned_symbol_info sym_info
;
13254 unsigned short vna_other
;
13257 Elf_Internal_Sym
*psym
= symtab
+ si
;
13259 printf ("%6" PRId64
": ", si
);
13260 print_vma (psym
->st_value
, LONG_HEX
);
13262 print_dynamic_symbol_size (psym
->st_size
, sym_base
);
13263 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
13264 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
13265 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
13266 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
13269 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
13271 printf (" %-7s", get_symbol_visibility (vis
));
13272 /* Check to see if any other bits in the st_other field are set.
13273 Note - displaying this information disrupts the layout of the
13274 table being generated, but for the moment this case is very rare. */
13275 if (psym
->st_other
^ vis
)
13276 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
13278 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
13280 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
13281 && psym
->st_shndx
< filedata
->file_header
.e_shnum
13282 && filedata
->section_headers
!= NULL
13283 && psym
->st_name
== 0)
13286 = section_name_valid (filedata
,
13287 filedata
->section_headers
+ psym
->st_shndx
);
13289 section_name_print (filedata
,
13290 filedata
->section_headers
+ psym
->st_shndx
)
13295 is_valid
= valid_symbol_name (strtab
, strtab_size
, psym
->st_name
);
13296 sstr
= is_valid
? strtab
+ psym
->st_name
: _("<corrupt>");
13300 = get_symbol_version_string (filedata
,
13302 || section
->sh_type
== SHT_DYNSYM
),
13303 strtab
, strtab_size
, si
,
13304 psym
, &sym_info
, &vna_other
);
13306 int len_avail
= 21;
13307 if (! do_wide
&& version_string
!= NULL
)
13311 len_avail
-= 1 + strlen (version_string
);
13313 if (sym_info
== symbol_undefined
)
13314 len_avail
-= sprintf (buffer
," (%d)", vna_other
);
13315 else if (sym_info
!= symbol_hidden
)
13319 print_symbol (len_avail
, sstr
);
13321 if (version_string
)
13323 if (sym_info
== symbol_undefined
)
13324 printf ("@%s (%d)", version_string
, vna_other
);
13326 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
13332 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
13334 && si
>= section
->sh_info
13335 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
13336 && filedata
->file_header
.e_machine
!= EM_MIPS
13337 /* Solaris binaries have been found to violate this requirement as
13338 well. Not sure if this is a bug or an ABI requirement. */
13339 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
13340 warn (_("local symbol %" PRIu64
" found at index >= %s's sh_info value of %u\n"),
13341 si
, printable_section_name (filedata
, section
), section
->sh_info
);
13344 static const char *
13345 get_lto_kind (unsigned int kind
)
13349 case 0: return "DEF";
13350 case 1: return "WEAKDEF";
13351 case 2: return "UNDEF";
13352 case 3: return "WEAKUNDEF";
13353 case 4: return "COMMON";
13358 static char buffer
[30];
13359 error (_("Unknown LTO symbol definition encountered: %u\n"), kind
);
13360 sprintf (buffer
, "<unknown: %u>", kind
);
13364 static const char *
13365 get_lto_visibility (unsigned int visibility
)
13367 switch (visibility
)
13369 case 0: return "DEFAULT";
13370 case 1: return "PROTECTED";
13371 case 2: return "INTERNAL";
13372 case 3: return "HIDDEN";
13377 static char buffer
[30];
13378 error (_("Unknown LTO symbol visibility encountered: %u\n"), visibility
);
13379 sprintf (buffer
, "<unknown: %u>", visibility
);
13383 static const char *
13384 get_lto_sym_type (unsigned int sym_type
)
13388 case 0: return "UNKNOWN";
13389 case 1: return "FUNCTION";
13390 case 2: return "VARIABLE";
13395 static char buffer
[30];
13396 error (_("Unknown LTO symbol type encountered: %u\n"), sym_type
);
13397 sprintf (buffer
, "<unknown: %u>", sym_type
);
13401 /* Display an LTO format symbol table.
13402 FIXME: The format of LTO symbol tables is not formalized.
13403 So this code could need changing in the future. */
13406 display_lto_symtab (Filedata
* filedata
,
13407 Elf_Internal_Shdr
* section
)
13409 if (section
->sh_size
== 0)
13411 if (filedata
->is_separate
)
13412 printf (_("\nThe LTO Symbol table section '%s' in linked file '%s' is empty!\n"),
13413 printable_section_name (filedata
, section
),
13414 filedata
->file_name
);
13416 printf (_("\nLTO Symbol table '%s' is empty!\n"),
13417 printable_section_name (filedata
, section
));
13422 if (section
->sh_size
> filedata
->file_size
)
13424 error (_("Section %s has an invalid sh_size of %#" PRIx64
"\n"),
13425 printable_section_name (filedata
, section
),
13430 void * alloced_data
= get_data (NULL
, filedata
, section
->sh_offset
,
13431 section
->sh_size
, 1, _("LTO symbols"));
13432 if (alloced_data
== NULL
)
13435 /* Look for extended data for the symbol table. */
13436 Elf_Internal_Shdr
* ext
;
13437 void * ext_data_orig
= NULL
;
13438 char * ext_data
= NULL
;
13439 char * ext_data_end
= NULL
;
13440 char * ext_name
= NULL
;
13442 if (asprintf (& ext_name
, ".gnu.lto_.ext_symtab.%s",
13443 (section_name (filedata
, section
)
13444 + sizeof (".gnu.lto_.symtab.") - 1)) > 0
13445 && ext_name
!= NULL
/* Paranoia. */
13446 && (ext
= find_section (filedata
, ext_name
)) != NULL
)
13448 if (ext
->sh_size
< 3)
13449 error (_("LTO Symbol extension table '%s' is empty!\n"),
13450 printable_section_name (filedata
, ext
));
13453 ext_data_orig
= ext_data
= get_data (NULL
, filedata
, ext
->sh_offset
,
13455 _("LTO ext symbol data"));
13456 if (ext_data
!= NULL
)
13458 ext_data_end
= ext_data
+ ext
->sh_size
;
13459 if (* ext_data
++ != 1)
13460 error (_("Unexpected version number in symbol extension table\n"));
13465 const unsigned char * data
= (const unsigned char *) alloced_data
;
13466 const unsigned char * end
= data
+ section
->sh_size
;
13468 if (filedata
->is_separate
)
13469 printf (_("\nIn linked file '%s': "), filedata
->file_name
);
13473 if (ext_data_orig
!= NULL
)
13476 printf (_("LTO Symbol table '%s' and extension table '%s' contain:\n"),
13477 printable_section_name (filedata
, section
),
13478 printable_section_name (filedata
, ext
));
13481 printf (_("LTO Symbol table '%s'\n"),
13482 printable_section_name (filedata
, section
));
13483 printf (_(" and extension table '%s' contain:\n"),
13484 printable_section_name (filedata
, ext
));
13488 printf (_("LTO Symbol table '%s' contains:\n"),
13489 printable_section_name (filedata
, section
));
13491 /* FIXME: Add a wide version. */
13492 if (ext_data_orig
!= NULL
)
13493 printf (_(" Comdat_Key Kind Visibility Size Slot Type Section Name\n"));
13495 printf (_(" Comdat_Key Kind Visibility Size Slot Name\n"));
13497 /* FIXME: We do not handle style prefixes. */
13501 const unsigned char * sym_name
= data
;
13502 data
+= strnlen ((const char *) sym_name
, end
- data
) + 1;
13506 const unsigned char * comdat_key
= data
;
13507 data
+= strnlen ((const char *) comdat_key
, end
- data
) + 1;
13511 if (data
+ 2 + 8 + 4 > end
)
13514 unsigned int kind
= *data
++;
13515 unsigned int visibility
= *data
++;
13517 uint64_t size
= byte_get (data
, 8);
13520 uint64_t slot
= byte_get (data
, 4);
13523 if (ext_data
!= NULL
)
13525 if (ext_data
< (ext_data_end
- 1))
13527 unsigned int sym_type
= * ext_data
++;
13528 unsigned int sec_kind
= * ext_data
++;
13530 printf (" %10s %10s %11s %08" PRIx64
" %08" PRIx64
" %9s %08x _",
13531 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
13532 get_lto_kind (kind
),
13533 get_lto_visibility (visibility
),
13536 get_lto_sym_type (sym_type
),
13538 print_symbol (6, (const char *) sym_name
);
13542 error (_("Ran out of LTO symbol extension data\n"));
13544 /* FIXME: return FAIL result ? */
13549 printf (" %10s %10s %11s %08" PRIx64
" %08" PRIx64
" _",
13550 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
13551 get_lto_kind (kind
),
13552 get_lto_visibility (visibility
),
13555 print_symbol (21, (const char *) sym_name
);
13560 if (ext_data
!= NULL
&& ext_data
< ext_data_end
)
13562 error (_("Data remains in the LTO symbol extension table\n"));
13566 free (alloced_data
);
13567 free (ext_data_orig
);
13572 error (_("Buffer overrun encountered whilst decoding LTO symbol table\n"));
13573 free (alloced_data
);
13574 free (ext_data_orig
);
13579 /* Display LTO symbol tables. */
13582 process_lto_symbol_tables (Filedata
* filedata
)
13584 Elf_Internal_Shdr
* section
;
13591 if (filedata
->section_headers
== NULL
)
13594 for (i
= 0, section
= filedata
->section_headers
;
13595 i
< filedata
->file_header
.e_shnum
;
13597 if (section_name_valid (filedata
, section
)
13598 && startswith (section_name (filedata
, section
), ".gnu.lto_.symtab."))
13599 res
&= display_lto_symtab (filedata
, section
);
13604 /* Dump the symbol table. */
13607 process_symbol_table (Filedata
* filedata
)
13609 Elf_Internal_Shdr
* section
;
13611 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
13614 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
13616 && do_using_dynamic
13617 && filedata
->dynamic_strings
!= NULL
13618 && filedata
->dynamic_symbols
!= NULL
)
13622 if (filedata
->is_separate
)
13624 printf (ngettext ("\nIn linked file '%s' the dynamic symbol table"
13625 " contains %" PRIu64
" entry:\n",
13626 "\nIn linked file '%s' the dynamic symbol table"
13627 " contains %" PRIu64
" entries:\n",
13628 filedata
->num_dynamic_syms
),
13629 filedata
->file_name
,
13630 filedata
->num_dynamic_syms
);
13634 printf (ngettext ("\nSymbol table for image contains %" PRIu64
13636 "\nSymbol table for image contains %" PRIu64
13638 filedata
->num_dynamic_syms
),
13639 filedata
->num_dynamic_syms
);
13642 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
13644 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
13646 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
13647 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
13648 filedata
->dynamic_strings
,
13649 filedata
->dynamic_strings_length
);
13651 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
13652 && filedata
->section_headers
!= NULL
)
13656 for (i
= 0, section
= filedata
->section_headers
;
13657 i
< filedata
->file_header
.e_shnum
;
13660 char * strtab
= NULL
;
13661 uint64_t strtab_size
= 0;
13662 Elf_Internal_Sym
* symtab
;
13663 uint64_t si
, num_syms
;
13665 if ((section
->sh_type
!= SHT_SYMTAB
13666 && section
->sh_type
!= SHT_DYNSYM
)
13668 && section
->sh_type
== SHT_SYMTAB
))
13671 if (section
->sh_entsize
== 0)
13673 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
13674 printable_section_name (filedata
, section
));
13678 num_syms
= section
->sh_size
/ section
->sh_entsize
;
13680 if (filedata
->is_separate
)
13681 printf (ngettext ("\nIn linked file '%s' symbol section '%s'"
13682 " contains %" PRIu64
" entry:\n",
13683 "\nIn linked file '%s' symbol section '%s'"
13684 " contains %" PRIu64
" entries:\n",
13686 filedata
->file_name
,
13687 printable_section_name (filedata
, section
),
13690 printf (ngettext ("\nSymbol table '%s' contains %" PRIu64
13692 "\nSymbol table '%s' contains %" PRIu64
13695 printable_section_name (filedata
, section
),
13699 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
13701 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
13703 symtab
= get_elf_symbols (filedata
, section
, & num_syms
);
13704 if (symtab
== NULL
)
13707 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
13709 strtab
= filedata
->string_table
;
13710 strtab_size
= filedata
->string_table_length
;
13712 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
13714 Elf_Internal_Shdr
* string_sec
;
13716 string_sec
= filedata
->section_headers
+ section
->sh_link
;
13718 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
13719 1, string_sec
->sh_size
,
13720 _("string table"));
13721 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
13724 for (si
= 0; si
< num_syms
; si
++)
13725 print_dynamic_symbol (filedata
, si
, symtab
, section
,
13726 strtab
, strtab_size
);
13729 if (strtab
!= filedata
->string_table
)
13735 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
13737 if (do_histogram
&& filedata
->buckets
!= NULL
)
13743 uint64_t maxlength
= 0;
13744 uint64_t nzero_counts
= 0;
13745 uint64_t nsyms
= 0;
13748 printf (ngettext ("\nHistogram for bucket list length "
13749 "(total of %" PRIu64
" bucket):\n",
13750 "\nHistogram for bucket list length "
13751 "(total of %" PRIu64
" buckets):\n",
13752 filedata
->nbuckets
),
13753 filedata
->nbuckets
);
13755 lengths
= calloc (filedata
->nbuckets
, sizeof (*lengths
));
13756 if (lengths
== NULL
)
13758 error (_("Out of memory allocating space for histogram buckets\n"));
13761 visited
= xcmalloc (filedata
->nchains
, 1);
13762 memset (visited
, 0, filedata
->nchains
);
13764 printf (_(" Length Number %% of total Coverage\n"));
13765 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
13767 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
13770 if (maxlength
< ++lengths
[hn
])
13772 if (si
>= filedata
->nchains
|| visited
[si
])
13774 error (_("histogram chain is corrupt\n"));
13782 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
13783 if (counts
== NULL
)
13786 error (_("Out of memory allocating space for histogram counts\n"));
13790 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
13791 ++counts
[lengths
[hn
]];
13793 if (filedata
->nbuckets
> 0)
13796 printf (" 0 %-10" PRIu64
" (%5.1f%%)\n",
13797 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
13798 for (i
= 1; i
<= maxlength
; ++i
)
13800 nzero_counts
+= counts
[i
] * i
;
13801 printf ("%7" PRIu64
" %-10" PRIu64
" (%5.1f%%) %5.1f%%\n",
13802 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
13803 (nzero_counts
* 100.0) / nsyms
);
13811 free (filedata
->buckets
);
13812 filedata
->buckets
= NULL
;
13813 filedata
->nbuckets
= 0;
13814 free (filedata
->chains
);
13815 filedata
->chains
= NULL
;
13817 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
13822 uint64_t maxlength
= 0;
13823 uint64_t nzero_counts
= 0;
13824 uint64_t nsyms
= 0;
13826 printf (ngettext ("\nHistogram for `%s' bucket list length "
13827 "(total of %" PRIu64
" bucket):\n",
13828 "\nHistogram for `%s' bucket list length "
13829 "(total of %" PRIu64
" buckets):\n",
13830 filedata
->ngnubuckets
),
13831 GNU_HASH_SECTION_NAME (filedata
),
13832 filedata
->ngnubuckets
);
13834 lengths
= calloc (filedata
->ngnubuckets
, sizeof (*lengths
));
13835 if (lengths
== NULL
)
13837 error (_("Out of memory allocating space for gnu histogram buckets\n"));
13841 printf (_(" Length Number %% of total Coverage\n"));
13843 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
13844 if (filedata
->gnubuckets
[hn
] != 0)
13846 uint64_t off
, length
= 1;
13848 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
13849 /* PR 17531 file: 010-77222-0.004. */
13850 off
< filedata
->ngnuchains
13851 && (filedata
->gnuchains
[off
] & 1) == 0;
13854 lengths
[hn
] = length
;
13855 if (length
> maxlength
)
13856 maxlength
= length
;
13860 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
13861 if (counts
== NULL
)
13864 error (_("Out of memory allocating space for gnu histogram counts\n"));
13868 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
13869 ++counts
[lengths
[hn
]];
13871 if (filedata
->ngnubuckets
> 0)
13874 printf (" 0 %-10" PRIu64
" (%5.1f%%)\n",
13875 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
13876 for (j
= 1; j
<= maxlength
; ++j
)
13878 nzero_counts
+= counts
[j
] * j
;
13879 printf ("%7" PRIu64
" %-10" PRIu64
" (%5.1f%%) %5.1f%%\n",
13880 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
13881 (nzero_counts
* 100.0) / nsyms
);
13888 free (filedata
->gnubuckets
);
13889 filedata
->gnubuckets
= NULL
;
13890 filedata
->ngnubuckets
= 0;
13891 free (filedata
->gnuchains
);
13892 filedata
->gnuchains
= NULL
;
13893 filedata
->ngnuchains
= 0;
13894 free (filedata
->mipsxlat
);
13895 filedata
->mipsxlat
= NULL
;
13899 free (filedata
->gnubuckets
);
13900 filedata
->gnubuckets
= NULL
;
13901 filedata
->ngnubuckets
= 0;
13902 free (filedata
->gnuchains
);
13903 filedata
->gnuchains
= NULL
;
13904 filedata
->ngnuchains
= 0;
13905 free (filedata
->mipsxlat
);
13906 filedata
->mipsxlat
= NULL
;
13907 free (filedata
->buckets
);
13908 filedata
->buckets
= NULL
;
13909 filedata
->nbuckets
= 0;
13910 free (filedata
->chains
);
13911 filedata
->chains
= NULL
;
13916 process_syminfo (Filedata
* filedata
)
13920 if (filedata
->dynamic_syminfo
== NULL
13922 /* No syminfo, this is ok. */
13925 /* There better should be a dynamic symbol section. */
13926 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
13929 if (filedata
->is_separate
)
13930 printf (ngettext ("\nIn linked file '%s: the dynamic info segment at offset %#" PRIx64
" contains %d entry:\n",
13931 "\nIn linked file '%s: the dynamic info segment at offset %#" PRIx64
" contains %d entries:\n",
13932 filedata
->dynamic_syminfo_nent
),
13933 filedata
->file_name
,
13934 filedata
->dynamic_syminfo_offset
,
13935 filedata
->dynamic_syminfo_nent
);
13937 printf (ngettext ("\nDynamic info segment at offset %#" PRIx64
13938 " contains %d entry:\n",
13939 "\nDynamic info segment at offset %#" PRIx64
13940 " contains %d entries:\n",
13941 filedata
->dynamic_syminfo_nent
),
13942 filedata
->dynamic_syminfo_offset
,
13943 filedata
->dynamic_syminfo_nent
);
13945 printf (_(" Num: Name BoundTo Flags\n"));
13946 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
13948 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
13950 printf ("%4d: ", i
);
13951 if (i
>= filedata
->num_dynamic_syms
)
13952 printf (_("<corrupt index>"));
13953 else if (valid_dynamic_name (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
13954 print_symbol (30, get_dynamic_name (filedata
,
13955 filedata
->dynamic_symbols
[i
].st_name
));
13957 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
13960 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
13962 case SYMINFO_BT_SELF
:
13963 fputs ("SELF ", stdout
);
13965 case SYMINFO_BT_PARENT
:
13966 fputs ("PARENT ", stdout
);
13969 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
13970 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
13971 && valid_dynamic_name (filedata
,
13972 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
13974 print_symbol (10, get_dynamic_name (filedata
,
13975 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
13979 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
13983 if (flags
& SYMINFO_FLG_DIRECT
)
13984 printf (" DIRECT");
13985 if (flags
& SYMINFO_FLG_PASSTHRU
)
13986 printf (" PASSTHRU");
13987 if (flags
& SYMINFO_FLG_COPY
)
13989 if (flags
& SYMINFO_FLG_LAZYLOAD
)
13990 printf (" LAZYLOAD");
13998 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
13999 is contained by the region START .. END. The types of ADDR, START
14000 and END should all be the same. Note both ADDR + NELEM and END
14001 point to just beyond the end of the regions that are being tested. */
14002 #define IN_RANGE(START,END,ADDR,NELEM) \
14003 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
14005 /* Check to see if the given reloc needs to be handled in a target specific
14006 manner. If so then process the reloc and return TRUE otherwise return
14009 If called with reloc == NULL, then this is a signal that reloc processing
14010 for the current section has finished, and any saved state should be
14014 target_specific_reloc_handling (Filedata
*filedata
,
14015 Elf_Internal_Rela
*reloc
,
14016 unsigned char *start
,
14017 unsigned char *end
,
14018 Elf_Internal_Sym
*symtab
,
14021 unsigned int reloc_type
= 0;
14022 uint64_t sym_index
= 0;
14026 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
14027 sym_index
= get_reloc_symindex (reloc
->r_info
);
14030 switch (filedata
->file_header
.e_machine
)
14034 switch (reloc_type
)
14036 /* For .uleb128 .LFE1-.LFB1, loongarch write 0 to object file
14037 at assembly time. */
14038 case 107: /* R_LARCH_ADD_ULEB128. */
14039 case 108: /* R_LARCH_SUB_ULEB128. */
14041 uint64_t value
= 0;
14042 unsigned int reloc_size
= 0;
14045 if (reloc
->r_offset
< (size_t) (end
- start
))
14046 value
= read_leb128 (start
+ reloc
->r_offset
, end
, false,
14047 &reloc_size
, &leb_ret
);
14048 if (leb_ret
!= 0 || reloc_size
== 0 || reloc_size
> 8)
14049 error (_("LoongArch ULEB128 field at 0x%lx contains invalid "
14050 "ULEB128 value\n"),
14051 (long) reloc
->r_offset
);
14053 else if (sym_index
>= num_syms
)
14054 error (_("%s reloc contains invalid symbol index "
14057 ? "R_LARCH_ADD_ULEB128"
14058 : "R_LARCH_SUB_ULEB128"),
14062 if (reloc_type
== 107)
14063 value
+= reloc
->r_addend
+ symtab
[sym_index
].st_value
;
14065 value
-= reloc
->r_addend
+ symtab
[sym_index
].st_value
;
14067 /* Write uleb128 value to p. */
14068 bfd_byte
*p
= start
+ reloc
->r_offset
;
14071 bfd_byte c
= value
& 0x7f;
14073 if (--reloc_size
!= 0)
14077 while (reloc_size
);
14087 case EM_MSP430_OLD
:
14089 static Elf_Internal_Sym
* saved_sym
= NULL
;
14097 switch (reloc_type
)
14099 case 10: /* R_MSP430_SYM_DIFF */
14100 case 12: /* R_MSP430_GNU_SUB_ULEB128 */
14101 if (uses_msp430x_relocs (filedata
))
14103 /* Fall through. */
14104 case 21: /* R_MSP430X_SYM_DIFF */
14105 case 23: /* R_MSP430X_GNU_SUB_ULEB128 */
14107 if (sym_index
>= num_syms
)
14108 error (_("%s reloc contains invalid symbol index "
14109 "%" PRIu64
"\n"), "MSP430 SYM_DIFF", sym_index
);
14111 saved_sym
= symtab
+ sym_index
;
14114 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
14115 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
14116 goto handle_sym_diff
;
14118 case 5: /* R_MSP430_16_BYTE */
14119 case 9: /* R_MSP430_8 */
14120 case 11: /* R_MSP430_GNU_SET_ULEB128 */
14121 if (uses_msp430x_relocs (filedata
))
14123 goto handle_sym_diff
;
14125 case 2: /* R_MSP430_ABS16 */
14126 case 15: /* R_MSP430X_ABS16 */
14127 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
14128 if (! uses_msp430x_relocs (filedata
))
14130 goto handle_sym_diff
;
14133 if (saved_sym
!= NULL
)
14136 unsigned int reloc_size
= 0;
14138 switch (reloc_type
)
14140 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
14143 case 11: /* R_MSP430_GNU_SET_ULEB128 */
14144 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
14145 if (reloc
->r_offset
< (size_t) (end
- start
))
14146 read_leb128 (start
+ reloc
->r_offset
, end
, false,
14147 &reloc_size
, &leb_ret
);
14154 if (leb_ret
!= 0 || reloc_size
== 0 || reloc_size
> 8)
14155 error (_("MSP430 ULEB128 field at %#" PRIx64
14156 " contains invalid ULEB128 value\n"),
14158 else if (sym_index
>= num_syms
)
14159 error (_("%s reloc contains invalid symbol index "
14160 "%" PRIu64
"\n"), "MSP430", sym_index
);
14163 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
14164 - saved_sym
->st_value
);
14166 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
14167 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
14170 error (_("MSP430 sym diff reloc contains invalid offset: "
14181 if (saved_sym
!= NULL
)
14182 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
14189 case EM_CYGNUS_MN10300
:
14191 static Elf_Internal_Sym
* saved_sym
= NULL
;
14199 switch (reloc_type
)
14201 case 34: /* R_MN10300_ALIGN */
14203 case 33: /* R_MN10300_SYM_DIFF */
14204 if (sym_index
>= num_syms
)
14205 error (_("%s reloc contains invalid symbol index "
14206 "%" PRIu64
"\n"), "MN10300_SYM_DIFF", sym_index
);
14208 saved_sym
= symtab
+ sym_index
;
14211 case 1: /* R_MN10300_32 */
14212 case 2: /* R_MN10300_16 */
14213 if (saved_sym
!= NULL
)
14215 int reloc_size
= reloc_type
== 1 ? 4 : 2;
14218 if (sym_index
>= num_syms
)
14219 error (_("%s reloc contains invalid symbol index "
14220 "%" PRIu64
"\n"), "MN10300", sym_index
);
14223 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
14224 - saved_sym
->st_value
);
14226 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
14227 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
14229 error (_("MN10300 sym diff reloc contains invalid offset:"
14230 " %#" PRIx64
"\n"),
14239 if (saved_sym
!= NULL
)
14240 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
14248 static uint64_t saved_sym1
= 0;
14249 static uint64_t saved_sym2
= 0;
14250 static uint64_t value
;
14254 saved_sym1
= saved_sym2
= 0;
14258 switch (reloc_type
)
14260 case 0x80: /* R_RL78_SYM. */
14261 saved_sym1
= saved_sym2
;
14262 if (sym_index
>= num_syms
)
14263 error (_("%s reloc contains invalid symbol index "
14264 "%" PRIu64
"\n"), "RL78_SYM", sym_index
);
14267 saved_sym2
= symtab
[sym_index
].st_value
;
14268 saved_sym2
+= reloc
->r_addend
;
14272 case 0x83: /* R_RL78_OPsub. */
14273 value
= saved_sym1
- saved_sym2
;
14274 saved_sym2
= saved_sym1
= 0;
14278 case 0x41: /* R_RL78_ABS32. */
14279 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
14280 byte_put (start
+ reloc
->r_offset
, value
, 4);
14282 error (_("RL78 sym diff reloc contains invalid offset: "
14288 case 0x43: /* R_RL78_ABS16. */
14289 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
14290 byte_put (start
+ reloc
->r_offset
, value
, 2);
14292 error (_("RL78 sym diff reloc contains invalid offset: "
14308 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
14309 DWARF debug sections. This is a target specific test. Note - we do not
14310 go through the whole including-target-headers-multiple-times route, (as
14311 we have already done with <elf/h8.h>) because this would become very
14312 messy and even then this function would have to contain target specific
14313 information (the names of the relocs instead of their numeric values).
14314 FIXME: This is not the correct way to solve this problem. The proper way
14315 is to have target specific reloc sizing and typing functions created by
14316 the reloc-macros.h header, in the same way that it already creates the
14317 reloc naming functions. */
14320 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14322 /* Please keep this table alpha-sorted for ease of visual lookup. */
14323 switch (filedata
->file_header
.e_machine
)
14327 return reloc_type
== 1; /* R_386_32. */
14329 return reloc_type
== 1; /* R_68K_32. */
14331 return reloc_type
== 1; /* R_860_32. */
14333 return reloc_type
== 2; /* R_960_32. */
14335 return (reloc_type
== 258
14336 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
14338 return reloc_type
== 11; /* R_BPF_DATA_32 */
14339 case EM_ADAPTEVA_EPIPHANY
:
14340 return reloc_type
== 3;
14342 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
14344 return reloc_type
== 1; /* R_ARC_32. */
14345 case EM_ARC_COMPACT
:
14346 case EM_ARC_COMPACT2
:
14347 case EM_ARC_COMPACT3
:
14348 case EM_ARC_COMPACT3_64
:
14349 return reloc_type
== 4; /* R_ARC_32. */
14351 return reloc_type
== 2; /* R_ARM_ABS32 */
14354 return reloc_type
== 1;
14356 return reloc_type
== 0x12; /* R_byte4_data. */
14358 return reloc_type
== 3; /* R_CRIS_32. */
14360 return reloc_type
== 3; /* R_CR16_NUM32. */
14362 return reloc_type
== 15; /* R_CRX_NUM32. */
14364 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
14365 case EM_CYGNUS_FRV
:
14366 return reloc_type
== 1;
14367 case EM_CYGNUS_D10V
:
14369 return reloc_type
== 6; /* R_D10V_32. */
14370 case EM_CYGNUS_D30V
:
14372 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
14374 return reloc_type
== 3; /* R_DLX_RELOC_32. */
14375 case EM_CYGNUS_FR30
:
14377 return reloc_type
== 3; /* R_FR30_32. */
14379 return reloc_type
== 1; /* R_FT32_32. */
14383 return reloc_type
== 1; /* R_H8_DIR32. */
14385 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
14386 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
14387 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
14388 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
14391 return reloc_type
== 2; /* R_IP2K_32. */
14393 return reloc_type
== 2; /* R_IQ2000_32. */
14394 case EM_LATTICEMICO32
:
14395 return reloc_type
== 3; /* R_LM32_32. */
14397 return reloc_type
== 1; /* R_LARCH_32. */
14400 return reloc_type
== 3; /* R_M32C_32. */
14402 return reloc_type
== 34; /* R_M32R_32_RELA. */
14405 return reloc_type
== 6; /* R_M68HC11_32. */
14407 return reloc_type
== 7 || /* R_S12Z_EXT32 */
14408 reloc_type
== 6; /* R_S12Z_CW32. */
14410 return reloc_type
== 1; /* R_MCORE_ADDR32. */
14411 case EM_CYGNUS_MEP
:
14412 return reloc_type
== 4; /* R_MEP_32. */
14414 return reloc_type
== 2; /* R_METAG_ADDR32. */
14415 case EM_MICROBLAZE
:
14416 return reloc_type
== 1; /* R_MICROBLAZE_32. */
14418 return reloc_type
== 2; /* R_MIPS_32. */
14420 return reloc_type
== 4; /* R_MMIX_32. */
14421 case EM_CYGNUS_MN10200
:
14423 return reloc_type
== 1; /* R_MN10200_32. */
14424 case EM_CYGNUS_MN10300
:
14426 return reloc_type
== 1; /* R_MN10300_32. */
14428 return reloc_type
== 1; /* R_MOXIE_32. */
14429 case EM_MSP430_OLD
:
14431 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
14433 return reloc_type
== 2; /* R_MT_32. */
14435 return reloc_type
== 20; /* R_NDS32_32_RELA. */
14436 case EM_ALTERA_NIOS2
:
14437 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
14439 return reloc_type
== 1; /* R_NIOS_32. */
14441 return reloc_type
== 1; /* R_OR1K_32. */
14443 return (reloc_type
== 1 /* R_PARISC_DIR32. */
14444 || reloc_type
== 2 /* R_PARISC_DIR21L. */
14445 || reloc_type
== 41); /* R_PARISC_SECREL32. */
14448 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
14450 return reloc_type
== 1; /* R_PPC64_ADDR32. */
14452 return reloc_type
== 1; /* R_PPC_ADDR32. */
14454 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
14456 return reloc_type
== 1; /* R_RISCV_32. */
14458 return reloc_type
== 1; /* R_RL78_DIR32. */
14460 return reloc_type
== 1; /* R_RX_DIR32. */
14462 return reloc_type
== 1; /* R_I370_ADDR31. */
14465 return reloc_type
== 4; /* R_S390_32. */
14467 return reloc_type
== 8; /* R_SCORE_ABS32. */
14469 return reloc_type
== 1; /* R_SH_DIR32. */
14470 case EM_SPARC32PLUS
:
14473 return reloc_type
== 3 /* R_SPARC_32. */
14474 || reloc_type
== 23; /* R_SPARC_UA32. */
14476 return reloc_type
== 6; /* R_SPU_ADDR32 */
14478 return reloc_type
== 1; /* R_C6000_ABS32. */
14480 return reloc_type
== 2; /* R_TILEGX_32. */
14482 return reloc_type
== 1; /* R_TILEPRO_32. */
14483 case EM_CYGNUS_V850
:
14485 return reloc_type
== 6; /* R_V850_ABS32. */
14487 return reloc_type
== 0x33; /* R_V810_WORD. */
14489 return reloc_type
== 1; /* R_VAX_32. */
14491 return reloc_type
== 3; /* R_VISIUM_32. */
14492 case EM_WEBASSEMBLY
:
14493 return reloc_type
== 1; /* R_WASM32_32. */
14497 return reloc_type
== 10; /* R_X86_64_32. */
14499 return reloc_type
== 4; /* R_XGATE_32. */
14501 return reloc_type
== 1; /* R_XSTROMY16_32. */
14502 case EM_XTENSA_OLD
:
14504 return reloc_type
== 1; /* R_XTENSA_32. */
14506 return reloc_type
== 6; /* R_Z80_32. */
14509 static unsigned int prev_warn
= 0;
14511 /* Avoid repeating the same warning multiple times. */
14512 if (prev_warn
!= filedata
->file_header
.e_machine
)
14513 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
14514 filedata
->file_header
.e_machine
);
14515 prev_warn
= filedata
->file_header
.e_machine
;
14521 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14522 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
14525 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14527 switch (filedata
->file_header
.e_machine
)
14528 /* Please keep this table alpha-sorted for ease of visual lookup. */
14532 return reloc_type
== 2; /* R_386_PC32. */
14534 return reloc_type
== 4; /* R_68K_PC32. */
14536 return reloc_type
== 261; /* R_AARCH64_PREL32 */
14537 case EM_ADAPTEVA_EPIPHANY
:
14538 return reloc_type
== 6;
14540 return reloc_type
== 10; /* R_ALPHA_SREL32. */
14541 case EM_ARC_COMPACT
:
14542 case EM_ARC_COMPACT2
:
14543 case EM_ARC_COMPACT3
:
14544 case EM_ARC_COMPACT3_64
:
14545 return reloc_type
== 49; /* R_ARC_32_PCREL. */
14547 return reloc_type
== 3; /* R_ARM_REL32 */
14550 return reloc_type
== 36; /* R_AVR_32_PCREL. */
14552 return reloc_type
== 99; /* R_LARCH_32_PCREL. */
14553 case EM_MICROBLAZE
:
14554 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
14556 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
14558 return reloc_type
== 9; /* R_PARISC_PCREL32. */
14560 return reloc_type
== 26; /* R_PPC_REL32. */
14562 return reloc_type
== 26; /* R_PPC64_REL32. */
14564 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
14567 return reloc_type
== 5; /* R_390_PC32. */
14569 return reloc_type
== 2; /* R_SH_REL32. */
14570 case EM_SPARC32PLUS
:
14573 return reloc_type
== 6; /* R_SPARC_DISP32. */
14575 return reloc_type
== 13; /* R_SPU_REL32. */
14577 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
14579 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
14581 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
14585 return reloc_type
== 2; /* R_X86_64_PC32. */
14587 return reloc_type
== 4; /* R_VAX_PCREL32. */
14588 case EM_XTENSA_OLD
:
14590 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
14592 /* Do not abort or issue an error message here. Not all targets use
14593 pc-relative 32-bit relocs in their DWARF debug information and we
14594 have already tested for target coverage in is_32bit_abs_reloc. A
14595 more helpful warning message will be generated by apply_relocations
14596 anyway, so just return. */
14601 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14602 a 64-bit absolute RELA relocation used in DWARF debug sections. */
14605 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14607 switch (filedata
->file_header
.e_machine
)
14610 return reloc_type
== 257; /* R_AARCH64_ABS64. */
14611 case EM_ARC_COMPACT3_64
:
14612 return reloc_type
== 5; /* R_ARC_64. */
14614 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
14616 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
14617 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
14619 return reloc_type
== 2; /* R_LARCH_64 */
14621 return reloc_type
== 80; /* R_PARISC_DIR64. */
14623 return reloc_type
== 38; /* R_PPC64_ADDR64. */
14625 return reloc_type
== 2; /* R_RISCV_64. */
14626 case EM_SPARC32PLUS
:
14629 return reloc_type
== 32 /* R_SPARC_64. */
14630 || reloc_type
== 54; /* R_SPARC_UA64. */
14634 return reloc_type
== 1; /* R_X86_64_64. */
14637 return reloc_type
== 22; /* R_S390_64. */
14639 return reloc_type
== 1; /* R_TILEGX_64. */
14641 return reloc_type
== 18; /* R_MIPS_64. */
14647 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
14648 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
14651 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14653 switch (filedata
->file_header
.e_machine
)
14656 return reloc_type
== 260; /* R_AARCH64_PREL64. */
14658 return reloc_type
== 11; /* R_ALPHA_SREL64. */
14660 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
14661 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
14663 return reloc_type
== 72; /* R_PARISC_PCREL64. */
14665 return reloc_type
== 44; /* R_PPC64_REL64. */
14666 case EM_SPARC32PLUS
:
14669 return reloc_type
== 46; /* R_SPARC_DISP64. */
14673 return reloc_type
== 24; /* R_X86_64_PC64. */
14676 return reloc_type
== 23; /* R_S390_PC64. */
14678 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
14684 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14685 a 24-bit absolute RELA relocation used in DWARF debug sections. */
14688 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14690 switch (filedata
->file_header
.e_machine
)
14692 case EM_CYGNUS_MN10200
:
14694 return reloc_type
== 4; /* R_MN10200_24. */
14696 return reloc_type
== 5; /* R_FT32_20. */
14698 return reloc_type
== 5; /* R_Z80_24. */
14704 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14705 a 16-bit absolute RELA relocation used in DWARF debug sections. */
14708 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14710 /* Please keep this table alpha-sorted for ease of visual lookup. */
14711 switch (filedata
->file_header
.e_machine
)
14714 case EM_ARC_COMPACT
:
14715 case EM_ARC_COMPACT2
:
14716 case EM_ARC_COMPACT3
:
14717 case EM_ARC_COMPACT3_64
:
14718 return reloc_type
== 2; /* R_ARC_16. */
14719 case EM_ADAPTEVA_EPIPHANY
:
14720 return reloc_type
== 5;
14723 return reloc_type
== 4; /* R_AVR_16. */
14724 case EM_CYGNUS_D10V
:
14726 return reloc_type
== 3; /* R_D10V_16. */
14728 return reloc_type
== 2; /* R_FT32_16. */
14732 return reloc_type
== R_H8_DIR16
;
14735 return reloc_type
== 1; /* R_IP2K_16. */
14738 return reloc_type
== 1; /* R_M32C_16 */
14739 case EM_CYGNUS_MN10200
:
14741 return reloc_type
== 2; /* R_MN10200_16. */
14742 case EM_CYGNUS_MN10300
:
14744 return reloc_type
== 2; /* R_MN10300_16. */
14746 if (uses_msp430x_relocs (filedata
))
14747 return reloc_type
== 2; /* R_MSP430_ABS16. */
14748 /* Fall through. */
14749 case EM_MSP430_OLD
:
14750 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
14752 return reloc_type
== 19; /* R_NDS32_16_RELA. */
14753 case EM_ALTERA_NIOS2
:
14754 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
14756 return reloc_type
== 9; /* R_NIOS_16. */
14758 return reloc_type
== 2; /* R_OR1K_16. */
14760 return reloc_type
== 55; /* R_RISCV_SET16. */
14762 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
14764 return reloc_type
== 2; /* R_C6000_ABS16. */
14766 return reloc_type
== 2; /* R_VISIUM_16. */
14768 return reloc_type
== 3; /* R_XGATE_16. */
14770 return reloc_type
== 4; /* R_Z80_16. */
14776 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14777 a 8-bit absolute RELA relocation used in DWARF debug sections. */
14780 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14782 switch (filedata
->file_header
.e_machine
)
14785 return reloc_type
== 54; /* R_RISCV_SET8. */
14787 return reloc_type
== 1; /* R_Z80_8. */
14793 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14794 a 6-bit absolute RELA relocation used in DWARF debug sections. */
14797 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14799 switch (filedata
->file_header
.e_machine
)
14802 return reloc_type
== 53; /* R_RISCV_SET6. */
14808 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14809 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
14812 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14814 /* Please keep this table alpha-sorted for ease of visual lookup. */
14815 switch (filedata
->file_header
.e_machine
)
14818 return reloc_type
== 50; /* R_LARCH_ADD32. */
14820 return reloc_type
== 35; /* R_RISCV_ADD32. */
14826 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14827 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
14830 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14832 /* Please keep this table alpha-sorted for ease of visual lookup. */
14833 switch (filedata
->file_header
.e_machine
)
14836 return reloc_type
== 55; /* R_LARCH_SUB32. */
14838 return reloc_type
== 39; /* R_RISCV_SUB32. */
14844 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14845 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
14848 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14850 /* Please keep this table alpha-sorted for ease of visual lookup. */
14851 switch (filedata
->file_header
.e_machine
)
14854 return reloc_type
== 51; /* R_LARCH_ADD64. */
14856 return reloc_type
== 36; /* R_RISCV_ADD64. */
14862 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14863 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
14866 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14868 /* Please keep this table alpha-sorted for ease of visual lookup. */
14869 switch (filedata
->file_header
.e_machine
)
14872 return reloc_type
== 56; /* R_LARCH_SUB64. */
14874 return reloc_type
== 40; /* R_RISCV_SUB64. */
14880 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14881 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
14884 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14886 /* Please keep this table alpha-sorted for ease of visual lookup. */
14887 switch (filedata
->file_header
.e_machine
)
14890 return reloc_type
== 48; /* R_LARCH_ADD16. */
14892 return reloc_type
== 34; /* R_RISCV_ADD16. */
14898 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14899 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
14902 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14904 /* Please keep this table alpha-sorted for ease of visual lookup. */
14905 switch (filedata
->file_header
.e_machine
)
14908 return reloc_type
== 53; /* R_LARCH_SUB16. */
14910 return reloc_type
== 38; /* R_RISCV_SUB16. */
14916 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14917 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
14920 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14922 /* Please keep this table alpha-sorted for ease of visual lookup. */
14923 switch (filedata
->file_header
.e_machine
)
14926 return reloc_type
== 47; /* R_LARCH_ADD8. */
14928 return reloc_type
== 33; /* R_RISCV_ADD8. */
14934 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14935 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
14938 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14940 /* Please keep this table alpha-sorted for ease of visual lookup. */
14941 switch (filedata
->file_header
.e_machine
)
14944 return reloc_type
== 52; /* R_LARCH_SUB8. */
14946 return reloc_type
== 37; /* R_RISCV_SUB8. */
14952 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14953 a 6-bit inplace add RELA relocation used in DWARF debug sections. */
14956 is_6bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14958 switch (filedata
->file_header
.e_machine
)
14961 return reloc_type
== 105; /* R_LARCH_ADD6. */
14967 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14968 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
14971 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14973 switch (filedata
->file_header
.e_machine
)
14976 return reloc_type
== 106; /* R_LARCH_SUB6. */
14978 return reloc_type
== 52; /* R_RISCV_SUB6. */
14984 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
14985 relocation entries (possibly formerly used for SHT_GROUP sections). */
14988 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14990 switch (filedata
->file_header
.e_machine
)
14992 case EM_386
: /* R_386_NONE. */
14993 case EM_68K
: /* R_68K_NONE. */
14994 case EM_ADAPTEVA_EPIPHANY
:
14995 case EM_ALPHA
: /* R_ALPHA_NONE. */
14996 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
14997 case EM_ARC
: /* R_ARC_NONE. */
14998 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
14999 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
15000 case EM_ARC_COMPACT3
: /* R_ARC_NONE. */
15001 case EM_ARC_COMPACT3_64
: /* R_ARC_NONE. */
15002 case EM_ARM
: /* R_ARM_NONE. */
15003 case EM_CRIS
: /* R_CRIS_NONE. */
15004 case EM_FT32
: /* R_FT32_NONE. */
15005 case EM_IA_64
: /* R_IA64_NONE. */
15006 case EM_K1OM
: /* R_X86_64_NONE. */
15007 case EM_L1OM
: /* R_X86_64_NONE. */
15008 case EM_M32R
: /* R_M32R_NONE. */
15009 case EM_MIPS
: /* R_MIPS_NONE. */
15010 case EM_MN10300
: /* R_MN10300_NONE. */
15011 case EM_MOXIE
: /* R_MOXIE_NONE. */
15012 case EM_NIOS32
: /* R_NIOS_NONE. */
15013 case EM_OR1K
: /* R_OR1K_NONE. */
15014 case EM_PARISC
: /* R_PARISC_NONE. */
15015 case EM_PPC64
: /* R_PPC64_NONE. */
15016 case EM_PPC
: /* R_PPC_NONE. */
15017 case EM_RISCV
: /* R_RISCV_NONE. */
15018 case EM_S390
: /* R_390_NONE. */
15020 case EM_SH
: /* R_SH_NONE. */
15021 case EM_SPARC32PLUS
:
15022 case EM_SPARC
: /* R_SPARC_NONE. */
15024 case EM_TILEGX
: /* R_TILEGX_NONE. */
15025 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
15026 case EM_TI_C6000
:/* R_C6000_NONE. */
15027 case EM_X86_64
: /* R_X86_64_NONE. */
15028 case EM_Z80
: /* R_Z80_NONE. */
15029 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
15030 return reloc_type
== 0;
15033 return reloc_type
== 0 || reloc_type
== 256;
15036 return (reloc_type
== 0 /* R_AVR_NONE. */
15037 || reloc_type
== 30 /* R_AVR_DIFF8. */
15038 || reloc_type
== 31 /* R_AVR_DIFF16. */
15039 || reloc_type
== 32 /* R_AVR_DIFF32. */);
15041 return reloc_type
== 3; /* R_METAG_NONE. */
15043 return (reloc_type
== 0 /* R_NDS32_NONE. */
15044 || reloc_type
== 205 /* R_NDS32_DIFF8. */
15045 || reloc_type
== 206 /* R_NDS32_DIFF16. */
15046 || reloc_type
== 207 /* R_NDS32_DIFF32. */
15047 || reloc_type
== 208 /* R_NDS32_DIFF_ULEB128. */);
15049 return (reloc_type
== 0 /* R_PRU_NONE. */
15050 || reloc_type
== 65 /* R_PRU_DIFF8. */
15051 || reloc_type
== 66 /* R_PRU_DIFF16. */
15052 || reloc_type
== 67 /* R_PRU_DIFF32. */);
15053 case EM_XTENSA_OLD
:
15055 return (reloc_type
== 0 /* R_XTENSA_NONE. */
15056 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
15057 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
15058 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
15059 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
15060 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
15061 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
15062 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
15063 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
15064 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
15069 /* Returns TRUE if there is a relocation against
15070 section NAME at OFFSET bytes. */
15073 reloc_at (struct dwarf_section
* dsec
, uint64_t offset
)
15075 Elf_Internal_Rela
* relocs
;
15076 Elf_Internal_Rela
* rp
;
15078 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
15081 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
15083 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
15084 if (rp
->r_offset
== offset
)
15090 /* Apply relocations to a section.
15091 Returns TRUE upon success, FALSE otherwise.
15092 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
15093 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
15094 will be set to the number of relocs loaded.
15096 Note: So far support has been added only for those relocations
15097 which can be found in debug sections. FIXME: Add support for
15098 more relocations ? */
15101 apply_relocations (Filedata
*filedata
,
15102 const Elf_Internal_Shdr
*section
,
15103 unsigned char *start
,
15105 void **relocs_return
,
15106 uint64_t *num_relocs_return
)
15108 Elf_Internal_Shdr
* relsec
;
15109 unsigned char * end
= start
+ size
;
15111 if (relocs_return
!= NULL
)
15113 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
15114 * num_relocs_return
= 0;
15117 if (filedata
->file_header
.e_type
!= ET_REL
)
15118 /* No relocs to apply. */
15121 /* Find the reloc section associated with the section. */
15122 for (relsec
= filedata
->section_headers
;
15123 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
15127 uint64_t num_relocs
;
15128 Elf_Internal_Rela
* relocs
;
15129 Elf_Internal_Rela
* rp
;
15130 Elf_Internal_Shdr
* symsec
;
15131 Elf_Internal_Sym
* symtab
;
15133 Elf_Internal_Sym
* sym
;
15135 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
15136 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
15137 || filedata
->section_headers
+ relsec
->sh_info
!= section
15138 || relsec
->sh_size
== 0
15139 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
15142 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
15143 if (symsec
->sh_type
!= SHT_SYMTAB
15144 && symsec
->sh_type
!= SHT_DYNSYM
)
15147 is_rela
= relsec
->sh_type
== SHT_RELA
;
15151 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
15152 relsec
->sh_size
, & relocs
, & num_relocs
))
15157 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
15158 relsec
->sh_size
, & relocs
, & num_relocs
))
15162 /* SH uses RELA but uses in place value instead of the addend field. */
15163 if (filedata
->file_header
.e_machine
== EM_SH
)
15166 symtab
= get_elf_symbols (filedata
, symsec
, & num_syms
);
15168 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
15171 unsigned int reloc_type
;
15172 unsigned int reloc_size
;
15173 bool reloc_inplace
= false;
15174 bool reloc_subtract
= false;
15175 unsigned char *rloc
;
15176 uint64_t sym_index
;
15178 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
15180 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
15182 else if (is_none_reloc (filedata
, reloc_type
))
15184 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
15185 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
15187 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
15188 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
15190 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
15192 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
15194 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
15195 || is_6bit_abs_reloc (filedata
, reloc_type
))
15197 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
15199 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
15202 reloc_inplace
= true;
15204 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
15206 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
15209 reloc_inplace
= true;
15211 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
15213 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
15216 reloc_inplace
= true;
15218 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
15220 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
15223 reloc_inplace
= true;
15225 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
15227 || is_6bit_inplace_add_reloc (filedata
, reloc_type
))
15230 reloc_inplace
= true;
15234 static unsigned int prev_reloc
= 0;
15236 if (reloc_type
!= prev_reloc
)
15237 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
15238 reloc_type
, printable_section_name (filedata
, section
));
15239 prev_reloc
= reloc_type
;
15243 rloc
= start
+ rp
->r_offset
;
15244 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
15246 warn (_("skipping invalid relocation offset %#" PRIx64
15247 " in section %s\n"),
15249 printable_section_name (filedata
, section
));
15253 sym_index
= get_reloc_symindex (rp
->r_info
);
15254 if (sym_index
>= num_syms
)
15256 warn (_("skipping invalid relocation symbol index %#" PRIx64
15257 " in section %s\n"),
15258 sym_index
, printable_section_name (filedata
, section
));
15261 sym
= symtab
+ sym_index
;
15263 /* If the reloc has a symbol associated with it,
15264 make sure that it is of an appropriate type.
15266 Relocations against symbols without type can happen.
15267 Gcc -feliminate-dwarf2-dups may generate symbols
15268 without type for debug info.
15270 Icc generates relocations against function symbols
15271 instead of local labels.
15273 Relocations against object symbols can happen, eg when
15274 referencing a global array. For an example of this see
15275 the _clz.o binary in libgcc.a. */
15277 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
15278 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
15280 warn (_("skipping unexpected symbol type %s in section %s relocation %tu\n"),
15281 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
15282 printable_section_name (filedata
, relsec
),
15289 addend
+= rp
->r_addend
;
15290 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
15291 partial_inplace. */
15293 || (filedata
->file_header
.e_machine
== EM_XTENSA
15294 && reloc_type
== 1)
15295 || ((filedata
->file_header
.e_machine
== EM_PJ
15296 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
15297 && reloc_type
== 1)
15298 || ((filedata
->file_header
.e_machine
== EM_D30V
15299 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
15300 && reloc_type
== 12)
15303 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
15304 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
15306 addend
+= byte_get (rloc
, reloc_size
);
15309 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
15310 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
15312 /* On HPPA, all pc-relative relocations are biased by 8. */
15313 if (filedata
->file_header
.e_machine
== EM_PARISC
)
15315 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
15318 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
15319 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
)
15320 || is_6bit_inplace_add_reloc (filedata
, reloc_type
))
15322 if (reloc_subtract
)
15323 addend
-= sym
->st_value
;
15325 addend
+= sym
->st_value
;
15326 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
15327 byte_put (rloc
, addend
, reloc_size
);
15329 else if (reloc_subtract
)
15330 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
15332 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
15336 /* Let the target specific reloc processing code know that
15337 we have finished with these relocs. */
15338 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
15342 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
15343 * num_relocs_return
= num_relocs
;
15354 #ifdef SUPPORT_DISASSEMBLY
15356 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15358 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
15360 /* FIXME: XXX -- to be done --- XXX */
15366 /* Reads in the contents of SECTION from FILE, returning a pointer
15367 to a malloc'ed buffer or NULL if something went wrong. */
15370 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15372 uint64_t num_bytes
= section
->sh_size
;
15374 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
15376 printf (_("Section '%s' has no data to dump.\n"),
15377 printable_section_name (filedata
, section
));
15381 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
15382 _("section contents"));
15385 /* Uncompresses a section that was compressed using zlib/zstd, in place. */
15388 uncompress_section_contents (bool is_zstd
,
15389 unsigned char ** buffer
,
15390 uint64_t uncompressed_size
,
15392 uint64_t file_size
)
15394 uint64_t compressed_size
= *size
;
15395 unsigned char *compressed_buffer
= *buffer
;
15396 unsigned char *uncompressed_buffer
= NULL
;
15400 /* Similar to _bfd_section_size_insane() in the BFD library we expect an
15401 upper limit of ~10x compression. Any compression larger than that is
15402 thought to be due to fuzzing of the compression header. */
15403 if (uncompressed_size
> file_size
* 10)
15405 error (_("Uncompressed section size is suspiciously large: 0x%" PRIu64
"\n"),
15406 uncompressed_size
);
15410 uncompressed_buffer
= xmalloc (uncompressed_size
);
15415 size_t ret
= ZSTD_decompress (uncompressed_buffer
, uncompressed_size
,
15416 compressed_buffer
, compressed_size
);
15417 if (ZSTD_isError (ret
))
15423 /* It is possible the section consists of several compressed
15424 buffers concatenated together, so we uncompress in a loop. */
15425 /* PR 18313: The state field in the z_stream structure is supposed
15426 to be invisible to the user (ie us), but some compilers will
15427 still complain about it being used without initialisation. So
15428 we first zero the entire z_stream structure and then set the fields
15430 memset (&strm
, 0, sizeof strm
);
15431 strm
.avail_in
= compressed_size
;
15432 strm
.next_in
= (Bytef
*)compressed_buffer
;
15433 strm
.avail_out
= uncompressed_size
;
15435 rc
= inflateInit (&strm
);
15436 while (strm
.avail_in
> 0)
15440 strm
.next_out
= ((Bytef
*)uncompressed_buffer
15441 + (uncompressed_size
- strm
.avail_out
));
15442 rc
= inflate (&strm
, Z_FINISH
);
15443 if (rc
!= Z_STREAM_END
)
15445 rc
= inflateReset (&strm
);
15447 if (inflateEnd (&strm
) != Z_OK
|| rc
!= Z_OK
|| strm
.avail_out
!= 0)
15451 *buffer
= uncompressed_buffer
;
15452 *size
= uncompressed_size
;
15456 free (uncompressed_buffer
);
15457 /* Indicate decompression failure. */
15463 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15465 Elf_Internal_Shdr
*relsec
;
15466 uint64_t num_bytes
;
15467 unsigned char *data
;
15468 unsigned char *end
;
15469 unsigned char *real_start
;
15470 unsigned char *start
;
15471 bool some_strings_shown
;
15473 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
15475 /* PR 21820: Do not fail if the section was empty. */
15476 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
15478 num_bytes
= section
->sh_size
;
15480 if (filedata
->is_separate
)
15481 printf (_("\nString dump of section '%s' in linked file %s:\n"),
15482 printable_section_name (filedata
, section
),
15483 filedata
->file_name
);
15485 printf (_("\nString dump of section '%s':\n"),
15486 printable_section_name (filedata
, section
));
15488 if (decompress_dumps
)
15490 uint64_t new_size
= num_bytes
;
15491 uint64_t uncompressed_size
= 0;
15492 bool is_zstd
= false;
15494 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
15496 Elf_Internal_Chdr chdr
;
15497 unsigned int compression_header_size
15498 = get_compression_header (& chdr
, (unsigned char *) start
,
15500 if (compression_header_size
== 0)
15501 /* An error message will have already been generated
15502 by get_compression_header. */
15505 if (chdr
.ch_type
== ch_compress_zlib
)
15508 else if (chdr
.ch_type
== ch_compress_zstd
)
15513 warn (_("section '%s' has unsupported compress type: %d\n"),
15514 printable_section_name (filedata
, section
), chdr
.ch_type
);
15517 uncompressed_size
= chdr
.ch_size
;
15518 start
+= compression_header_size
;
15519 new_size
-= compression_header_size
;
15521 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
15523 /* Read the zlib header. In this case, it should be "ZLIB"
15524 followed by the uncompressed section size, 8 bytes in
15525 big-endian order. */
15526 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
15527 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
15528 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
15529 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
15530 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
15531 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
15532 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
15533 uncompressed_size
+= start
[11];
15538 if (uncompressed_size
)
15540 if (uncompress_section_contents (is_zstd
, &start
, uncompressed_size
,
15541 &new_size
, filedata
->file_size
))
15542 num_bytes
= new_size
;
15545 error (_("Unable to decompress section %s\n"),
15546 printable_section_name (filedata
, section
));
15551 start
= real_start
;
15554 /* If the section being dumped has relocations against it the user might
15555 be expecting these relocations to have been applied. Check for this
15556 case and issue a warning message in order to avoid confusion.
15557 FIXME: Maybe we ought to have an option that dumps a section with
15558 relocs applied ? */
15559 for (relsec
= filedata
->section_headers
;
15560 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
15563 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
15564 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
15565 || filedata
->section_headers
+ relsec
->sh_info
!= section
15566 || relsec
->sh_size
== 0
15567 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
15570 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
15575 end
= start
+ num_bytes
;
15576 some_strings_shown
= false;
15578 #ifdef HAVE_MBSTATE_T
15580 /* Initialise the multibyte conversion state. */
15581 memset (& state
, 0, sizeof (state
));
15584 bool continuing
= false;
15588 while (!ISPRINT (* data
))
15589 if (++ data
>= end
)
15594 size_t maxlen
= end
- data
;
15599 continuing
= false;
15603 printf (" [%6tx] ", data
- start
);
15617 /* PR 25543: Treat new-lines as string-ending characters. */
15626 /* Do not print control characters directly as they can affect terminal
15627 settings. Such characters usually appear in the names generated
15628 by the assembler for local labels. */
15631 printf ("^%c", c
+ 0x40);
15633 else if (ISPRINT (c
))
15640 #ifdef HAVE_MBSTATE_T
15643 /* Let printf do the hard work of displaying multibyte characters. */
15644 printf ("%.1s", data
- 1);
15645 #ifdef HAVE_MBSTATE_T
15646 /* Try to find out how many bytes made up the character that was
15647 just printed. Advance the symbol pointer past the bytes that
15649 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
15653 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
15663 printf (_("<corrupt>\n"));
15666 some_strings_shown
= true;
15670 if (! some_strings_shown
)
15671 printf (_(" No strings found in this section."));
15684 dump_section_as_bytes (Elf_Internal_Shdr
*section
,
15685 Filedata
*filedata
,
15688 Elf_Internal_Shdr
*relsec
;
15690 uint64_t section_size
;
15692 unsigned char *data
;
15693 unsigned char *real_start
;
15694 unsigned char *start
;
15696 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
15698 /* PR 21820: Do not fail if the section was empty. */
15699 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
15701 section_size
= section
->sh_size
;
15703 if (filedata
->is_separate
)
15704 printf (_("\nHex dump of section '%s' in linked file %s:\n"),
15705 printable_section_name (filedata
, section
),
15706 filedata
->file_name
);
15708 printf (_("\nHex dump of section '%s':\n"),
15709 printable_section_name (filedata
, section
));
15711 if (decompress_dumps
)
15713 uint64_t new_size
= section_size
;
15714 uint64_t uncompressed_size
= 0;
15715 bool is_zstd
= false;
15717 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
15719 Elf_Internal_Chdr chdr
;
15720 unsigned int compression_header_size
15721 = get_compression_header (& chdr
, start
, section_size
);
15723 if (compression_header_size
== 0)
15724 /* An error message will have already been generated
15725 by get_compression_header. */
15728 if (chdr
.ch_type
== ch_compress_zlib
)
15731 else if (chdr
.ch_type
== ch_compress_zstd
)
15736 warn (_("section '%s' has unsupported compress type: %d\n"),
15737 printable_section_name (filedata
, section
), chdr
.ch_type
);
15740 uncompressed_size
= chdr
.ch_size
;
15741 start
+= compression_header_size
;
15742 new_size
-= compression_header_size
;
15744 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
15746 /* Read the zlib header. In this case, it should be "ZLIB"
15747 followed by the uncompressed section size, 8 bytes in
15748 big-endian order. */
15749 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
15750 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
15751 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
15752 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
15753 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
15754 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
15755 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
15756 uncompressed_size
+= start
[11];
15761 if (uncompressed_size
)
15763 if (uncompress_section_contents (is_zstd
, &start
, uncompressed_size
,
15764 &new_size
, filedata
->file_size
))
15766 section_size
= new_size
;
15770 error (_("Unable to decompress section %s\n"),
15771 printable_section_name (filedata
, section
));
15772 /* FIXME: Print the section anyway ? */
15777 start
= real_start
;
15782 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
15787 /* If the section being dumped has relocations against it the user might
15788 be expecting these relocations to have been applied. Check for this
15789 case and issue a warning message in order to avoid confusion.
15790 FIXME: Maybe we ought to have an option that dumps a section with
15791 relocs applied ? */
15792 for (relsec
= filedata
->section_headers
;
15793 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
15796 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
15797 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
15798 || filedata
->section_headers
+ relsec
->sh_info
!= section
15799 || relsec
->sh_size
== 0
15800 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
15803 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
15808 addr
= section
->sh_addr
;
15809 bytes
= section_size
;
15818 lbytes
= (bytes
> 16 ? 16 : bytes
);
15820 printf (" 0x%8.8" PRIx64
" ", addr
);
15822 for (j
= 0; j
< 16; j
++)
15825 printf ("%2.2x", data
[j
]);
15833 for (j
= 0; j
< lbytes
; j
++)
15836 if (k
>= ' ' && k
< 0x7f)
15859 #ifdef ENABLE_LIBCTF
15860 static ctf_sect_t
*
15861 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
15863 buf
->cts_name
= section_name_print (filedata
, shdr
);
15864 buf
->cts_size
= shdr
->sh_size
;
15865 buf
->cts_entsize
= shdr
->sh_entsize
;
15870 /* Formatting callback function passed to ctf_dump. Returns either the pointer
15871 it is passed, or a pointer to newly-allocated storage, in which case
15872 dump_ctf() will free it when it no longer needs it. */
15875 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
15876 char *s
, void *arg
)
15878 const char *blanks
= arg
;
15881 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
15886 /* Dump CTF errors/warnings. */
15888 dump_ctf_errs (ctf_dict_t
*fp
)
15890 ctf_next_t
*it
= NULL
;
15895 /* Dump accumulated errors and warnings. */
15896 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
15898 error (_("%s: %s"), is_warning
? _("warning"): _("error"),
15902 if (err
!= ECTF_NEXT_END
)
15903 error (_("CTF error: cannot get CTF errors: `%s'"), ctf_errmsg (err
));
15906 /* Dump one CTF archive member. */
15909 dump_ctf_archive_member (ctf_dict_t
*ctf
, const char *name
, ctf_dict_t
*parent
,
15912 const char *things
[] = {"Header", "Labels", "Data objects",
15913 "Function objects", "Variables", "Types", "Strings",
15915 const char **thing
;
15918 /* Don't print out the name of the default-named archive member if it appears
15919 first in the list. The name .ctf appears everywhere, even for things that
15920 aren't really archives, so printing it out is liable to be confusing; also,
15921 the common case by far is for only one archive member to exist, and hiding
15922 it in that case seems worthwhile. */
15924 if (strcmp (name
, ".ctf") != 0 || member
!= 0)
15925 printf (_("\nCTF archive member: %s:\n"), name
);
15927 if (ctf_parent_name (ctf
) != NULL
)
15928 ctf_import (ctf
, parent
);
15930 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
15932 ctf_dump_state_t
*s
= NULL
;
15935 printf ("\n %s:\n", *thing
);
15936 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
15937 (void *) " ")) != NULL
)
15939 printf ("%s\n", item
);
15943 if (ctf_errno (ctf
))
15945 error (_("Iteration failed: %s, %s\n"), *thing
,
15946 ctf_errmsg (ctf_errno (ctf
)));
15951 dump_ctf_errs (ctf
);
15955 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15957 Elf_Internal_Shdr
* symtab_sec
= NULL
;
15958 Elf_Internal_Shdr
* strtab_sec
= NULL
;
15959 void * data
= NULL
;
15960 void * symdata
= NULL
;
15961 void * strdata
= NULL
;
15962 ctf_sect_t ctfsect
, symsect
, strsect
;
15963 ctf_sect_t
* symsectp
= NULL
;
15964 ctf_sect_t
* strsectp
= NULL
;
15965 ctf_archive_t
* ctfa
= NULL
;
15966 ctf_dict_t
* parent
= NULL
;
15969 ctf_next_t
*i
= NULL
;
15975 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
15976 data
= get_section_contents (section
, filedata
);
15977 ctfsect
.cts_data
= data
;
15979 if (!dump_ctf_symtab_name
)
15980 dump_ctf_symtab_name
= strdup (".dynsym");
15982 if (!dump_ctf_strtab_name
)
15983 dump_ctf_strtab_name
= strdup (".dynstr");
15985 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
15987 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
15989 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
15992 if ((symdata
= (void *) get_data (NULL
, filedata
,
15993 symtab_sec
->sh_offset
, 1,
15994 symtab_sec
->sh_size
,
15995 _("symbols"))) == NULL
)
15997 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
15998 symsect
.cts_data
= symdata
;
16001 if (dump_ctf_strtab_name
&& dump_ctf_strtab_name
[0] != 0)
16003 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
16005 error (_("No string table section named %s\n"),
16006 dump_ctf_strtab_name
);
16009 if ((strdata
= (void *) get_data (NULL
, filedata
,
16010 strtab_sec
->sh_offset
, 1,
16011 strtab_sec
->sh_size
,
16012 _("strings"))) == NULL
)
16014 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
16015 strsect
.cts_data
= strdata
;
16018 /* Load the CTF file and dump it. It may be a raw CTF section, or an archive:
16019 libctf papers over the difference, so we can pretend it is always an
16022 if ((ctfa
= ctf_arc_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
16024 dump_ctf_errs (NULL
);
16025 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
16029 ctf_arc_symsect_endianness (ctfa
, filedata
->file_header
.e_ident
[EI_DATA
]
16032 /* Preload the parent dict, since it will need to be imported into every
16034 if ((parent
= ctf_dict_open (ctfa
, dump_ctf_parent_name
, &err
)) == NULL
)
16036 dump_ctf_errs (NULL
);
16037 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
16043 if (filedata
->is_separate
)
16044 printf (_("\nDump of CTF section '%s' in linked file %s:\n"),
16045 printable_section_name (filedata
, section
),
16046 filedata
->file_name
);
16048 printf (_("\nDump of CTF section '%s':\n"),
16049 printable_section_name (filedata
, section
));
16051 while ((fp
= ctf_archive_next (ctfa
, &i
, &name
, 0, &err
)) != NULL
)
16052 dump_ctf_archive_member (fp
, name
, parent
, member
++);
16053 if (err
!= ECTF_NEXT_END
)
16055 dump_ctf_errs (NULL
);
16056 error (_("CTF member open failure: %s\n"), ctf_errmsg (err
));
16061 ctf_dict_close (parent
);
16071 dump_section_as_sframe (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
16073 void * data
= NULL
;
16074 sframe_decoder_ctx
*sfd_ctx
= NULL
;
16075 const char *print_name
= printable_section_name (filedata
, section
);
16081 if (strcmp (print_name
, "") == 0)
16083 error (_("Section name must be provided \n"));
16088 data
= get_section_contents (section
, filedata
);
16089 sf_size
= section
->sh_size
;
16090 /* Decode the contents of the section. */
16091 sfd_ctx
= sframe_decode ((const char*)data
, sf_size
, &err
);
16095 error (_("SFrame decode failure: %s\n"), sframe_errmsg (err
));
16099 printf (_("Contents of the SFrame section %s:"), print_name
);
16100 /* Dump the contents as text. */
16101 dump_sframe (sfd_ctx
, section
->sh_addr
);
16109 load_specific_debug_section (enum dwarf_section_display_enum debug
,
16110 const Elf_Internal_Shdr
* sec
,
16113 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
16115 Filedata
* filedata
= (Filedata
*) data
;
16117 if (section
->start
!= NULL
)
16119 /* If it is already loaded, do nothing. */
16120 if (streq (section
->filename
, filedata
->file_name
))
16122 free (section
->start
);
16125 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
16126 section
->address
= sec
->sh_addr
;
16127 section
->filename
= filedata
->file_name
;
16128 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
16130 sec
->sh_size
, buf
);
16131 if (section
->start
== NULL
)
16135 unsigned char *start
= section
->start
;
16136 uint64_t size
= sec
->sh_size
;
16137 uint64_t uncompressed_size
= 0;
16138 bool is_zstd
= false;
16140 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
16142 Elf_Internal_Chdr chdr
;
16143 unsigned int compression_header_size
;
16145 if (size
< (is_32bit_elf
16146 ? sizeof (Elf32_External_Chdr
)
16147 : sizeof (Elf64_External_Chdr
)))
16149 warn (_("compressed section %s is too small to contain a compression header\n"),
16154 compression_header_size
= get_compression_header (&chdr
, start
, size
);
16155 if (compression_header_size
== 0)
16156 /* An error message will have already been generated
16157 by get_compression_header. */
16160 if (chdr
.ch_type
== ch_compress_zlib
)
16163 else if (chdr
.ch_type
== ch_compress_zstd
)
16168 warn (_("section '%s' has unsupported compress type: %d\n"),
16169 section
->name
, chdr
.ch_type
);
16172 uncompressed_size
= chdr
.ch_size
;
16173 start
+= compression_header_size
;
16174 size
-= compression_header_size
;
16176 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
16178 /* Read the zlib header. In this case, it should be "ZLIB"
16179 followed by the uncompressed section size, 8 bytes in
16180 big-endian order. */
16181 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
16182 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
16183 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
16184 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
16185 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
16186 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
16187 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
16188 uncompressed_size
+= start
[11];
16193 if (uncompressed_size
)
16195 if (uncompress_section_contents (is_zstd
, &start
, uncompressed_size
,
16196 &size
, filedata
->file_size
))
16198 /* Free the compressed buffer, update the section buffer
16199 and the section size if uncompress is successful. */
16200 free (section
->start
);
16201 section
->start
= start
;
16205 error (_("Unable to decompress section %s\n"),
16206 printable_section_name (filedata
, sec
));
16211 section
->size
= size
;
16214 if (section
->start
== NULL
)
16217 if (debug_displays
[debug
].relocate
)
16219 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
16220 & section
->reloc_info
, & section
->num_relocs
))
16225 section
->reloc_info
= NULL
;
16226 section
->num_relocs
= 0;
16232 #if HAVE_LIBDEBUGINFOD
16233 /* Return a hex string representation of the build-id. */
16235 get_build_id (void * data
)
16237 Filedata
* filedata
= (Filedata
*) data
;
16238 Elf_Internal_Shdr
* shdr
;
16241 /* Iterate through notes to find note.gnu.build-id.
16242 FIXME: Only the first note in any note section is examined. */
16243 for (i
= 0, shdr
= filedata
->section_headers
;
16244 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
16247 if (shdr
->sh_type
!= SHT_NOTE
)
16252 size_t data_remaining
;
16254 Elf_External_Note
* enote
;
16255 Elf_Internal_Note inote
;
16257 uint64_t offset
= shdr
->sh_offset
;
16258 uint64_t align
= shdr
->sh_addralign
;
16259 uint64_t length
= shdr
->sh_size
;
16261 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
16267 else if (align
!= 4 && align
!= 8)
16273 end
= (char *) enote
+ length
;
16274 data_remaining
= end
- (char *) enote
;
16276 if (!is_ia64_vms (filedata
))
16278 min_notesz
= offsetof (Elf_External_Note
, name
);
16279 if (data_remaining
< min_notesz
)
16282 malformed note encountered in section %s whilst scanning for build-id note\n"),
16283 printable_section_name (filedata
, shdr
));
16287 data_remaining
-= min_notesz
;
16289 inote
.type
= BYTE_GET (enote
->type
);
16290 inote
.namesz
= BYTE_GET (enote
->namesz
);
16291 inote
.namedata
= enote
->name
;
16292 inote
.descsz
= BYTE_GET (enote
->descsz
);
16293 inote
.descdata
= ((char *) enote
16294 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
16295 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
16296 next
= ((char *) enote
16297 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
16301 Elf64_External_VMS_Note
*vms_enote
;
16303 /* PR binutils/15191
16304 Make sure that there is enough data to read. */
16305 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
16306 if (data_remaining
< min_notesz
)
16309 malformed note encountered in section %s whilst scanning for build-id note\n"),
16310 printable_section_name (filedata
, shdr
));
16314 data_remaining
-= min_notesz
;
16316 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
16317 inote
.type
= BYTE_GET (vms_enote
->type
);
16318 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
16319 inote
.namedata
= vms_enote
->name
;
16320 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
16321 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
16322 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
16323 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
16326 /* Skip malformed notes. */
16327 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
16328 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
16329 || (size_t) (next
- inote
.descdata
) < inote
.descsz
16330 || ((size_t) (next
- inote
.descdata
)
16331 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
16334 malformed note encountered in section %s whilst scanning for build-id note\n"),
16335 printable_section_name (filedata
, shdr
));
16340 /* Check if this is the build-id note. If so then convert the build-id
16341 bytes to a hex string. */
16342 if (inote
.namesz
> 0
16343 && startswith (inote
.namedata
, "GNU")
16344 && inote
.type
== NT_GNU_BUILD_ID
)
16349 build_id
= malloc (inote
.descsz
* 2 + 1);
16350 if (build_id
== NULL
)
16356 for (j
= 0; j
< inote
.descsz
; ++j
)
16357 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
16358 build_id
[inote
.descsz
* 2] = '\0';
16361 return (unsigned char *) build_id
;
16368 #endif /* HAVE_LIBDEBUGINFOD */
16370 /* If this is not NULL, load_debug_section will only look for sections
16371 within the list of sections given here. */
16372 static unsigned int * section_subset
= NULL
;
16375 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
16377 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
16378 Elf_Internal_Shdr
* sec
;
16379 Filedata
* filedata
= (Filedata
*) data
;
16381 if (!dump_any_debugging
)
16384 /* Without section headers we cannot find any sections. */
16385 if (filedata
->section_headers
== NULL
)
16388 if (filedata
->string_table
== NULL
16389 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
16390 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
16392 Elf_Internal_Shdr
* strs
;
16394 /* Read in the string table, so that we have section names to scan. */
16395 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
16397 if (strs
!= NULL
&& strs
->sh_size
!= 0)
16399 filedata
->string_table
16400 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
16401 1, strs
->sh_size
, _("string table"));
16403 filedata
->string_table_length
16404 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
16408 /* Locate the debug section. */
16409 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
16411 section
->name
= section
->uncompressed_name
;
16414 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
16416 section
->name
= section
->compressed_name
;
16421 /* If we're loading from a subset of sections, and we've loaded
16422 a section matching this name before, it's likely that it's a
16424 if (section_subset
!= NULL
)
16425 free_debug_section (debug
);
16427 return load_specific_debug_section (debug
, sec
, data
);
16431 free_debug_section (enum dwarf_section_display_enum debug
)
16433 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
16435 if (section
->start
== NULL
)
16438 free ((char *) section
->start
);
16439 section
->start
= NULL
;
16440 section
->address
= 0;
16443 free (section
->reloc_info
);
16444 section
->reloc_info
= NULL
;
16445 section
->num_relocs
= 0;
16449 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
16451 const char *name
= (section_name_valid (filedata
, section
)
16452 ? section_name (filedata
, section
) : "");
16453 const char *print_name
= printable_section_name (filedata
, section
);
16455 bool result
= true;
16458 length
= section
->sh_size
;
16461 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
16464 if (section
->sh_type
== SHT_NOBITS
)
16466 /* There is no point in dumping the contents of a debugging section
16467 which has the NOBITS type - the bits in the file will be random.
16468 This can happen when a file containing a .eh_frame section is
16469 stripped with the --only-keep-debug command line option. */
16470 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
16475 if (startswith (name
, ".gnu.linkonce.wi."))
16476 name
= ".debug_info";
16478 /* See if we know how to display the contents of this section. */
16479 for (i
= 0; i
< max
; i
++)
16481 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
16482 struct dwarf_section_display
* display
= debug_displays
+ i
;
16483 struct dwarf_section
* sec
= & display
->section
;
16485 if (streq (sec
->uncompressed_name
, name
)
16486 || (id
== line
&& startswith (name
, ".debug_line."))
16487 || streq (sec
->compressed_name
, name
))
16489 bool secondary
= (section
!= find_section (filedata
, name
));
16492 free_debug_section (id
);
16494 if (i
== line
&& startswith (name
, ".debug_line."))
16496 else if (streq (sec
->uncompressed_name
, name
))
16497 sec
->name
= sec
->uncompressed_name
;
16499 sec
->name
= sec
->compressed_name
;
16501 if (load_specific_debug_section (id
, section
, filedata
))
16503 /* If this debug section is part of a CU/TU set in a .dwp file,
16504 restrict load_debug_section to the sections in that set. */
16505 section_subset
= find_cu_tu_set (filedata
, shndx
);
16507 result
&= display
->display (sec
, filedata
);
16509 section_subset
= NULL
;
16511 if (secondary
|| (id
!= info
&& id
!= abbrev
&& id
!= debug_addr
))
16512 free_debug_section (id
);
16520 printf (_("Unrecognized debug section: %s\n"), print_name
);
16527 /* Set DUMP_SECTS for all sections where dumps were requested
16528 based on section name. */
16531 initialise_dumps_byname (Filedata
* filedata
)
16533 struct dump_list_entry
* cur
;
16535 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
16540 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
16541 if (section_name_valid (filedata
, filedata
->section_headers
+ i
)
16542 && streq (section_name (filedata
, filedata
->section_headers
+ i
),
16545 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
16549 if (!any
&& !filedata
->is_separate
)
16550 warn (_("Section '%s' was not dumped because it does not exist\n"),
16556 process_section_contents (Filedata
* filedata
)
16558 Elf_Internal_Shdr
* section
;
16565 initialise_dumps_byname (filedata
);
16567 for (i
= 0, section
= filedata
->section_headers
;
16568 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
16571 dump_type dump
= filedata
->dump
.dump_sects
[i
];
16573 if (filedata
->is_separate
&& ! process_links
)
16574 dump
&= DEBUG_DUMP
;
16576 #ifdef SUPPORT_DISASSEMBLY
16577 if (dump
& DISASS_DUMP
)
16579 if (! disassemble_section (section
, filedata
))
16583 if (dump
& HEX_DUMP
)
16585 if (! dump_section_as_bytes (section
, filedata
, false))
16589 if (dump
& RELOC_DUMP
)
16591 if (! dump_section_as_bytes (section
, filedata
, true))
16595 if (dump
& STRING_DUMP
)
16597 if (! dump_section_as_strings (section
, filedata
))
16601 if (dump
& DEBUG_DUMP
)
16603 if (! display_debug_section (i
, section
, filedata
))
16607 #ifdef ENABLE_LIBCTF
16608 if (dump
& CTF_DUMP
)
16610 if (! dump_section_as_ctf (section
, filedata
))
16614 if (dump
& SFRAME_DUMP
)
16616 if (! dump_section_as_sframe (section
, filedata
))
16621 if (! filedata
->is_separate
)
16623 /* Check to see if the user requested a
16624 dump of a section that does not exist. */
16625 for (; i
< filedata
->dump
.num_dump_sects
; i
++)
16626 if (filedata
->dump
.dump_sects
[i
])
16628 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
16637 process_mips_fpe_exception (int mask
)
16643 if (mask
& OEX_FPU_INEX
)
16644 fputs ("INEX", stdout
), first
= false;
16645 if (mask
& OEX_FPU_UFLO
)
16646 printf ("%sUFLO", first
? "" : "|"), first
= false;
16647 if (mask
& OEX_FPU_OFLO
)
16648 printf ("%sOFLO", first
? "" : "|"), first
= false;
16649 if (mask
& OEX_FPU_DIV0
)
16650 printf ("%sDIV0", first
? "" : "|"), first
= false;
16651 if (mask
& OEX_FPU_INVAL
)
16652 printf ("%sINVAL", first
? "" : "|");
16655 fputs ("0", stdout
);
16658 /* Display's the value of TAG at location P. If TAG is
16659 greater than 0 it is assumed to be an unknown tag, and
16660 a message is printed to this effect. Otherwise it is
16661 assumed that a message has already been printed.
16663 If the bottom bit of TAG is set it assumed to have a
16664 string value, otherwise it is assumed to have an integer
16667 Returns an updated P pointing to the first unread byte
16668 beyond the end of TAG's value.
16670 Reads at or beyond END will not be made. */
16672 static unsigned char *
16673 display_tag_value (signed int tag
,
16675 const unsigned char * const end
)
16680 printf (" Tag_unknown_%d: ", tag
);
16684 warn (_("<corrupt tag>\n"));
16688 /* PR 17531 file: 027-19978-0.004. */
16689 size_t maxlen
= (end
- p
) - 1;
16694 print_symbol ((int) maxlen
, (const char *) p
);
16695 p
+= strnlen ((char *) p
, maxlen
) + 1;
16699 printf (_("<corrupt string tag>"));
16700 p
= (unsigned char *) end
;
16706 READ_ULEB (val
, p
, end
);
16707 printf ("%" PRId64
" (0x%" PRIx64
")\n", val
, val
);
16714 /* ARC ABI attributes section. */
16716 static unsigned char *
16717 display_arc_attribute (unsigned char * p
,
16718 const unsigned char * const end
)
16723 READ_ULEB (tag
, p
, end
);
16727 case Tag_ARC_PCS_config
:
16728 READ_ULEB (val
, p
, end
);
16729 printf (" Tag_ARC_PCS_config: ");
16733 printf (_("Absent/Non standard\n"));
16736 printf (_("Bare metal/mwdt\n"));
16739 printf (_("Bare metal/newlib\n"));
16742 printf (_("Linux/uclibc\n"));
16745 printf (_("Linux/glibc\n"));
16748 printf (_("Unknown\n"));
16753 case Tag_ARC_CPU_base
:
16754 READ_ULEB (val
, p
, end
);
16755 printf (" Tag_ARC_CPU_base: ");
16760 printf (_("Absent\n"));
16762 case TAG_CPU_ARC6xx
:
16763 printf ("ARC6xx\n");
16765 case TAG_CPU_ARC7xx
:
16766 printf ("ARC7xx\n");
16768 case TAG_CPU_ARCEM
:
16769 printf ("ARCEM\n");
16771 case TAG_CPU_ARCHS
:
16772 printf ("ARCHS\n");
16777 case Tag_ARC_CPU_variation
:
16778 READ_ULEB (val
, p
, end
);
16779 printf (" Tag_ARC_CPU_variation: ");
16783 if (val
> 0 && val
< 16)
16784 printf ("Core%d\n", val
);
16786 printf ("Unknown\n");
16790 printf (_("Absent\n"));
16795 case Tag_ARC_CPU_name
:
16796 printf (" Tag_ARC_CPU_name: ");
16797 p
= display_tag_value (-1, p
, end
);
16800 case Tag_ARC_ABI_rf16
:
16801 READ_ULEB (val
, p
, end
);
16802 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
16805 case Tag_ARC_ABI_osver
:
16806 READ_ULEB (val
, p
, end
);
16807 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
16810 case Tag_ARC_ABI_pic
:
16811 case Tag_ARC_ABI_sda
:
16812 READ_ULEB (val
, p
, end
);
16813 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
16814 : " Tag_ARC_ABI_pic: ");
16818 printf (_("Absent\n"));
16827 printf (_("Unknown\n"));
16832 case Tag_ARC_ABI_tls
:
16833 READ_ULEB (val
, p
, end
);
16834 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
16837 case Tag_ARC_ABI_enumsize
:
16838 READ_ULEB (val
, p
, end
);
16839 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
16843 case Tag_ARC_ABI_exceptions
:
16844 READ_ULEB (val
, p
, end
);
16845 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
16849 case Tag_ARC_ABI_double_size
:
16850 READ_ULEB (val
, p
, end
);
16851 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
16854 case Tag_ARC_ISA_config
:
16855 printf (" Tag_ARC_ISA_config: ");
16856 p
= display_tag_value (-1, p
, end
);
16859 case Tag_ARC_ISA_apex
:
16860 printf (" Tag_ARC_ISA_apex: ");
16861 p
= display_tag_value (-1, p
, end
);
16864 case Tag_ARC_ISA_mpy_option
:
16865 READ_ULEB (val
, p
, end
);
16866 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
16869 case Tag_ARC_ATR_version
:
16870 READ_ULEB (val
, p
, end
);
16871 printf (" Tag_ARC_ATR_version: %d\n", val
);
16875 return display_tag_value (tag
& 1, p
, end
);
16881 /* ARM EABI attributes section. */
16886 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
16888 const char *const *table
;
16889 } arm_attr_public_tag
;
16891 static const char *const arm_attr_tag_CPU_arch
[] =
16892 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
16893 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
16894 "v8-M.mainline", "v8.1-A", "v8.2-A", "v8.3-A",
16895 "v8.1-M.mainline", "v9"};
16896 static const char *const arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
16897 static const char *const arm_attr_tag_THUMB_ISA_use
[] =
16898 {"No", "Thumb-1", "Thumb-2", "Yes"};
16899 static const char *const arm_attr_tag_FP_arch
[] =
16900 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
16901 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
16902 static const char *const arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
16903 static const char *const arm_attr_tag_Advanced_SIMD_arch
[] =
16904 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
16905 "NEON for ARMv8.1"};
16906 static const char *const arm_attr_tag_PCS_config
[] =
16907 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
16908 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
16909 static const char *const arm_attr_tag_ABI_PCS_R9_use
[] =
16910 {"V6", "SB", "TLS", "Unused"};
16911 static const char *const arm_attr_tag_ABI_PCS_RW_data
[] =
16912 {"Absolute", "PC-relative", "SB-relative", "None"};
16913 static const char *const arm_attr_tag_ABI_PCS_RO_data
[] =
16914 {"Absolute", "PC-relative", "None"};
16915 static const char *const arm_attr_tag_ABI_PCS_GOT_use
[] =
16916 {"None", "direct", "GOT-indirect"};
16917 static const char *const arm_attr_tag_ABI_PCS_wchar_t
[] =
16918 {"None", "??? 1", "2", "??? 3", "4"};
16919 static const char *const arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
16920 static const char *const arm_attr_tag_ABI_FP_denormal
[] =
16921 {"Unused", "Needed", "Sign only"};
16922 static const char *const arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
16923 static const char *const arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
16924 static const char *const arm_attr_tag_ABI_FP_number_model
[] =
16925 {"Unused", "Finite", "RTABI", "IEEE 754"};
16926 static const char *const arm_attr_tag_ABI_enum_size
[] =
16927 {"Unused", "small", "int", "forced to int"};
16928 static const char *const arm_attr_tag_ABI_HardFP_use
[] =
16929 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
16930 static const char *const arm_attr_tag_ABI_VFP_args
[] =
16931 {"AAPCS", "VFP registers", "custom", "compatible"};
16932 static const char *const arm_attr_tag_ABI_WMMX_args
[] =
16933 {"AAPCS", "WMMX registers", "custom"};
16934 static const char *const arm_attr_tag_ABI_optimization_goals
[] =
16935 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
16936 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
16937 static const char *const arm_attr_tag_ABI_FP_optimization_goals
[] =
16938 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
16939 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
16940 static const char *const arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
16941 static const char *const arm_attr_tag_FP_HP_extension
[] =
16942 {"Not Allowed", "Allowed"};
16943 static const char *const arm_attr_tag_ABI_FP_16bit_format
[] =
16944 {"None", "IEEE 754", "Alternative Format"};
16945 static const char *const arm_attr_tag_DSP_extension
[] =
16946 {"Follow architecture", "Allowed"};
16947 static const char *const arm_attr_tag_MPextension_use
[] =
16948 {"Not Allowed", "Allowed"};
16949 static const char *const arm_attr_tag_DIV_use
[] =
16950 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
16951 "Allowed in v7-A with integer division extension"};
16952 static const char *const arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
16953 static const char *const arm_attr_tag_Virtualization_use
[] =
16954 {"Not Allowed", "TrustZone", "Virtualization Extensions",
16955 "TrustZone and Virtualization Extensions"};
16956 static const char *const arm_attr_tag_MPextension_use_legacy
[] =
16957 {"Not Allowed", "Allowed"};
16959 static const char *const arm_attr_tag_MVE_arch
[] =
16960 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
16962 static const char * arm_attr_tag_PAC_extension
[] =
16963 {"No PAC/AUT instructions",
16964 "PAC/AUT instructions permitted in the NOP space",
16965 "PAC/AUT instructions permitted in the NOP and in the non-NOP space"};
16967 static const char * arm_attr_tag_BTI_extension
[] =
16968 {"BTI instructions not permitted",
16969 "BTI instructions permitted in the NOP space",
16970 "BTI instructions permitted in the NOP and in the non-NOP space"};
16972 static const char * arm_attr_tag_BTI_use
[] =
16973 {"Compiled without branch target enforcement",
16974 "Compiled with branch target enforcement"};
16976 static const char * arm_attr_tag_PACRET_use
[] =
16977 {"Compiled without return address signing and authentication",
16978 "Compiled with return address signing and authentication"};
16980 #define LOOKUP(id, name) \
16981 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
16982 static arm_attr_public_tag arm_attr_public_tags
[] =
16984 {4, "CPU_raw_name", 1, NULL
},
16985 {5, "CPU_name", 1, NULL
},
16986 LOOKUP(6, CPU_arch
),
16987 {7, "CPU_arch_profile", 0, NULL
},
16988 LOOKUP(8, ARM_ISA_use
),
16989 LOOKUP(9, THUMB_ISA_use
),
16990 LOOKUP(10, FP_arch
),
16991 LOOKUP(11, WMMX_arch
),
16992 LOOKUP(12, Advanced_SIMD_arch
),
16993 LOOKUP(13, PCS_config
),
16994 LOOKUP(14, ABI_PCS_R9_use
),
16995 LOOKUP(15, ABI_PCS_RW_data
),
16996 LOOKUP(16, ABI_PCS_RO_data
),
16997 LOOKUP(17, ABI_PCS_GOT_use
),
16998 LOOKUP(18, ABI_PCS_wchar_t
),
16999 LOOKUP(19, ABI_FP_rounding
),
17000 LOOKUP(20, ABI_FP_denormal
),
17001 LOOKUP(21, ABI_FP_exceptions
),
17002 LOOKUP(22, ABI_FP_user_exceptions
),
17003 LOOKUP(23, ABI_FP_number_model
),
17004 {24, "ABI_align_needed", 0, NULL
},
17005 {25, "ABI_align_preserved", 0, NULL
},
17006 LOOKUP(26, ABI_enum_size
),
17007 LOOKUP(27, ABI_HardFP_use
),
17008 LOOKUP(28, ABI_VFP_args
),
17009 LOOKUP(29, ABI_WMMX_args
),
17010 LOOKUP(30, ABI_optimization_goals
),
17011 LOOKUP(31, ABI_FP_optimization_goals
),
17012 {32, "compatibility", 0, NULL
},
17013 LOOKUP(34, CPU_unaligned_access
),
17014 LOOKUP(36, FP_HP_extension
),
17015 LOOKUP(38, ABI_FP_16bit_format
),
17016 LOOKUP(42, MPextension_use
),
17017 LOOKUP(44, DIV_use
),
17018 LOOKUP(46, DSP_extension
),
17019 LOOKUP(48, MVE_arch
),
17020 LOOKUP(50, PAC_extension
),
17021 LOOKUP(52, BTI_extension
),
17022 LOOKUP(74, BTI_use
),
17023 LOOKUP(76, PACRET_use
),
17024 {64, "nodefaults", 0, NULL
},
17025 {65, "also_compatible_with", 0, NULL
},
17026 LOOKUP(66, T2EE_use
),
17027 {67, "conformance", 1, NULL
},
17028 LOOKUP(68, Virtualization_use
),
17029 LOOKUP(70, MPextension_use_legacy
)
17033 static unsigned char *
17034 display_arm_attribute (unsigned char * p
,
17035 const unsigned char * const end
)
17039 arm_attr_public_tag
* attr
;
17043 READ_ULEB (tag
, p
, end
);
17045 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
17047 if (arm_attr_public_tags
[i
].tag
== tag
)
17049 attr
= &arm_attr_public_tags
[i
];
17056 printf (" Tag_%s: ", attr
->name
);
17057 switch (attr
->type
)
17062 case 7: /* Tag_CPU_arch_profile. */
17063 READ_ULEB (val
, p
, end
);
17066 case 0: printf (_("None\n")); break;
17067 case 'A': printf (_("Application\n")); break;
17068 case 'R': printf (_("Realtime\n")); break;
17069 case 'M': printf (_("Microcontroller\n")); break;
17070 case 'S': printf (_("Application or Realtime\n")); break;
17071 default: printf ("??? (%d)\n", val
); break;
17075 case 24: /* Tag_align_needed. */
17076 READ_ULEB (val
, p
, end
);
17079 case 0: printf (_("None\n")); break;
17080 case 1: printf (_("8-byte\n")); break;
17081 case 2: printf (_("4-byte\n")); break;
17082 case 3: printf ("??? 3\n"); break;
17085 printf (_("8-byte and up to %d-byte extended\n"),
17088 printf ("??? (%d)\n", val
);
17093 case 25: /* Tag_align_preserved. */
17094 READ_ULEB (val
, p
, end
);
17097 case 0: printf (_("None\n")); break;
17098 case 1: printf (_("8-byte, except leaf SP\n")); break;
17099 case 2: printf (_("8-byte\n")); break;
17100 case 3: printf ("??? 3\n"); break;
17103 printf (_("8-byte and up to %d-byte extended\n"),
17106 printf ("??? (%d)\n", val
);
17111 case 32: /* Tag_compatibility. */
17113 READ_ULEB (val
, p
, end
);
17114 printf (_("flag = %d, vendor = "), val
);
17117 size_t maxlen
= (end
- p
) - 1;
17119 print_symbol ((int) maxlen
, (const char *) p
);
17120 p
+= strnlen ((char *) p
, maxlen
) + 1;
17124 printf (_("<corrupt>"));
17125 p
= (unsigned char *) end
;
17131 case 64: /* Tag_nodefaults. */
17132 /* PR 17531: file: 001-505008-0.01. */
17135 printf (_("True\n"));
17138 case 65: /* Tag_also_compatible_with. */
17139 READ_ULEB (val
, p
, end
);
17140 if (val
== 6 /* Tag_CPU_arch. */)
17142 READ_ULEB (val
, p
, end
);
17143 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
17144 printf ("??? (%d)\n", val
);
17146 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
17150 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
17155 printf (_("<unknown: %d>\n"), tag
);
17161 return display_tag_value (-1, p
, end
);
17163 return display_tag_value (0, p
, end
);
17166 assert (attr
->type
& 0x80);
17167 READ_ULEB (val
, p
, end
);
17168 type
= attr
->type
& 0x7f;
17170 printf ("??? (%d)\n", val
);
17172 printf ("%s\n", attr
->table
[val
]);
17177 return display_tag_value (tag
, p
, end
);
17180 static unsigned char *
17181 display_gnu_attribute (unsigned char * p
,
17182 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
17183 const unsigned char * const end
)
17188 READ_ULEB (tag
, p
, end
);
17190 /* Tag_compatibility is the only generic GNU attribute defined at
17194 READ_ULEB (val
, p
, end
);
17196 printf (_("flag = %d, vendor = "), val
);
17199 printf (_("<corrupt>\n"));
17200 warn (_("corrupt vendor attribute\n"));
17206 size_t maxlen
= (end
- p
) - 1;
17208 print_symbol ((int) maxlen
, (const char *) p
);
17209 p
+= strnlen ((char *) p
, maxlen
) + 1;
17213 printf (_("<corrupt>"));
17214 p
= (unsigned char *) end
;
17221 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
17222 return display_proc_gnu_attribute (p
, tag
, end
);
17224 return display_tag_value (tag
, p
, end
);
17227 static unsigned char *
17228 display_m68k_gnu_attribute (unsigned char * p
,
17230 const unsigned char * const end
)
17234 if (tag
== Tag_GNU_M68K_ABI_FP
)
17236 printf (" Tag_GNU_M68K_ABI_FP: ");
17239 printf (_("<corrupt>\n"));
17242 READ_ULEB (val
, p
, end
);
17245 printf ("(%#x), ", val
);
17250 printf (_("unspecified hard/soft float\n"));
17253 printf (_("hard float\n"));
17256 printf (_("soft float\n"));
17262 return display_tag_value (tag
& 1, p
, end
);
17265 static unsigned char *
17266 display_power_gnu_attribute (unsigned char * p
,
17268 const unsigned char * const end
)
17272 if (tag
== Tag_GNU_Power_ABI_FP
)
17274 printf (" Tag_GNU_Power_ABI_FP: ");
17277 printf (_("<corrupt>\n"));
17280 READ_ULEB (val
, p
, end
);
17283 printf ("(%#x), ", val
);
17288 printf (_("unspecified hard/soft float, "));
17291 printf (_("hard float, "));
17294 printf (_("soft float, "));
17297 printf (_("single-precision hard float, "));
17304 printf (_("unspecified long double\n"));
17307 printf (_("128-bit IBM long double\n"));
17310 printf (_("64-bit long double\n"));
17313 printf (_("128-bit IEEE long double\n"));
17319 if (tag
== Tag_GNU_Power_ABI_Vector
)
17321 printf (" Tag_GNU_Power_ABI_Vector: ");
17324 printf (_("<corrupt>\n"));
17327 READ_ULEB (val
, p
, end
);
17330 printf ("(%#x), ", val
);
17335 printf (_("unspecified\n"));
17338 printf (_("generic\n"));
17341 printf ("AltiVec\n");
17350 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
17352 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
17355 printf (_("<corrupt>\n"));
17358 READ_ULEB (val
, p
, end
);
17361 printf ("(%#x), ", val
);
17366 printf (_("unspecified\n"));
17369 printf ("r3/r4\n");
17372 printf (_("memory\n"));
17381 return display_tag_value (tag
& 1, p
, end
);
17384 static unsigned char *
17385 display_s390_gnu_attribute (unsigned char * p
,
17387 const unsigned char * const end
)
17391 if (tag
== Tag_GNU_S390_ABI_Vector
)
17393 printf (" Tag_GNU_S390_ABI_Vector: ");
17394 READ_ULEB (val
, p
, end
);
17399 printf (_("any\n"));
17402 printf (_("software\n"));
17405 printf (_("hardware\n"));
17408 printf ("??? (%d)\n", val
);
17414 return display_tag_value (tag
& 1, p
, end
);
17418 display_sparc_hwcaps (unsigned int mask
)
17424 if (mask
& ELF_SPARC_HWCAP_MUL32
)
17425 fputs ("mul32", stdout
), first
= false;
17426 if (mask
& ELF_SPARC_HWCAP_DIV32
)
17427 printf ("%sdiv32", first
? "" : "|"), first
= false;
17428 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
17429 printf ("%sfsmuld", first
? "" : "|"), first
= false;
17430 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
17431 printf ("%sv8plus", first
? "" : "|"), first
= false;
17432 if (mask
& ELF_SPARC_HWCAP_POPC
)
17433 printf ("%spopc", first
? "" : "|"), first
= false;
17434 if (mask
& ELF_SPARC_HWCAP_VIS
)
17435 printf ("%svis", first
? "" : "|"), first
= false;
17436 if (mask
& ELF_SPARC_HWCAP_VIS2
)
17437 printf ("%svis2", first
? "" : "|"), first
= false;
17438 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
17439 printf ("%sASIBlkInit", first
? "" : "|"), first
= false;
17440 if (mask
& ELF_SPARC_HWCAP_FMAF
)
17441 printf ("%sfmaf", first
? "" : "|"), first
= false;
17442 if (mask
& ELF_SPARC_HWCAP_VIS3
)
17443 printf ("%svis3", first
? "" : "|"), first
= false;
17444 if (mask
& ELF_SPARC_HWCAP_HPC
)
17445 printf ("%shpc", first
? "" : "|"), first
= false;
17446 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
17447 printf ("%srandom", first
? "" : "|"), first
= false;
17448 if (mask
& ELF_SPARC_HWCAP_TRANS
)
17449 printf ("%strans", first
? "" : "|"), first
= false;
17450 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
17451 printf ("%sfjfmau", first
? "" : "|"), first
= false;
17452 if (mask
& ELF_SPARC_HWCAP_IMA
)
17453 printf ("%sima", first
? "" : "|"), first
= false;
17454 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
17455 printf ("%scspare", first
? "" : "|"), first
= false;
17458 fputc ('0', stdout
);
17459 fputc ('\n', stdout
);
17463 display_sparc_hwcaps2 (unsigned int mask
)
17469 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
17470 fputs ("fjathplus", stdout
), first
= false;
17471 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
17472 printf ("%svis3b", first
? "" : "|"), first
= false;
17473 if (mask
& ELF_SPARC_HWCAP2_ADP
)
17474 printf ("%sadp", first
? "" : "|"), first
= false;
17475 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
17476 printf ("%ssparc5", first
? "" : "|"), first
= false;
17477 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
17478 printf ("%smwait", first
? "" : "|"), first
= false;
17479 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
17480 printf ("%sxmpmul", first
? "" : "|"), first
= false;
17481 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
17482 printf ("%sxmont2", first
? "" : "|"), first
= false;
17483 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
17484 printf ("%snsec", first
? "" : "|"), first
= false;
17485 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
17486 printf ("%sfjathhpc", first
? "" : "|"), first
= false;
17487 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
17488 printf ("%sfjdes", first
? "" : "|"), first
= false;
17489 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
17490 printf ("%sfjaes", first
? "" : "|"), first
= false;
17493 fputc ('0', stdout
);
17494 fputc ('\n', stdout
);
17497 static unsigned char *
17498 display_sparc_gnu_attribute (unsigned char * p
,
17500 const unsigned char * const end
)
17504 if (tag
== Tag_GNU_Sparc_HWCAPS
)
17506 READ_ULEB (val
, p
, end
);
17507 printf (" Tag_GNU_Sparc_HWCAPS: ");
17508 display_sparc_hwcaps (val
);
17511 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
17513 READ_ULEB (val
, p
, end
);
17514 printf (" Tag_GNU_Sparc_HWCAPS2: ");
17515 display_sparc_hwcaps2 (val
);
17519 return display_tag_value (tag
, p
, end
);
17523 print_mips_fp_abi_value (unsigned int val
)
17527 case Val_GNU_MIPS_ABI_FP_ANY
:
17528 printf (_("Hard or soft float\n"));
17530 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
17531 printf (_("Hard float (double precision)\n"));
17533 case Val_GNU_MIPS_ABI_FP_SINGLE
:
17534 printf (_("Hard float (single precision)\n"));
17536 case Val_GNU_MIPS_ABI_FP_SOFT
:
17537 printf (_("Soft float\n"));
17539 case Val_GNU_MIPS_ABI_FP_OLD_64
:
17540 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
17542 case Val_GNU_MIPS_ABI_FP_XX
:
17543 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
17545 case Val_GNU_MIPS_ABI_FP_64
:
17546 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
17548 case Val_GNU_MIPS_ABI_FP_64A
:
17549 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
17551 case Val_GNU_MIPS_ABI_FP_NAN2008
:
17552 printf (_("NaN 2008 compatibility\n"));
17555 printf ("??? (%d)\n", val
);
17560 static unsigned char *
17561 display_mips_gnu_attribute (unsigned char * p
,
17563 const unsigned char * const end
)
17565 if (tag
== Tag_GNU_MIPS_ABI_FP
)
17569 printf (" Tag_GNU_MIPS_ABI_FP: ");
17570 READ_ULEB (val
, p
, end
);
17571 print_mips_fp_abi_value (val
);
17575 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
17579 printf (" Tag_GNU_MIPS_ABI_MSA: ");
17580 READ_ULEB (val
, p
, end
);
17584 case Val_GNU_MIPS_ABI_MSA_ANY
:
17585 printf (_("Any MSA or not\n"));
17587 case Val_GNU_MIPS_ABI_MSA_128
:
17588 printf (_("128-bit MSA\n"));
17591 printf ("??? (%d)\n", val
);
17597 return display_tag_value (tag
& 1, p
, end
);
17600 static unsigned char *
17601 display_tic6x_attribute (unsigned char * p
,
17602 const unsigned char * const end
)
17607 READ_ULEB (tag
, p
, end
);
17612 printf (" Tag_ISA: ");
17613 READ_ULEB (val
, p
, end
);
17617 case C6XABI_Tag_ISA_none
:
17618 printf (_("None\n"));
17620 case C6XABI_Tag_ISA_C62X
:
17623 case C6XABI_Tag_ISA_C67X
:
17626 case C6XABI_Tag_ISA_C67XP
:
17627 printf ("C67x+\n");
17629 case C6XABI_Tag_ISA_C64X
:
17632 case C6XABI_Tag_ISA_C64XP
:
17633 printf ("C64x+\n");
17635 case C6XABI_Tag_ISA_C674X
:
17636 printf ("C674x\n");
17639 printf ("??? (%d)\n", val
);
17644 case Tag_ABI_wchar_t
:
17645 printf (" Tag_ABI_wchar_t: ");
17646 READ_ULEB (val
, p
, end
);
17650 printf (_("Not used\n"));
17653 printf (_("2 bytes\n"));
17656 printf (_("4 bytes\n"));
17659 printf ("??? (%d)\n", val
);
17664 case Tag_ABI_stack_align_needed
:
17665 printf (" Tag_ABI_stack_align_needed: ");
17666 READ_ULEB (val
, p
, end
);
17670 printf (_("8-byte\n"));
17673 printf (_("16-byte\n"));
17676 printf ("??? (%d)\n", val
);
17681 case Tag_ABI_stack_align_preserved
:
17682 READ_ULEB (val
, p
, end
);
17683 printf (" Tag_ABI_stack_align_preserved: ");
17687 printf (_("8-byte\n"));
17690 printf (_("16-byte\n"));
17693 printf ("??? (%d)\n", val
);
17699 READ_ULEB (val
, p
, end
);
17700 printf (" Tag_ABI_DSBT: ");
17704 printf (_("DSBT addressing not used\n"));
17707 printf (_("DSBT addressing used\n"));
17710 printf ("??? (%d)\n", val
);
17716 READ_ULEB (val
, p
, end
);
17717 printf (" Tag_ABI_PID: ");
17721 printf (_("Data addressing position-dependent\n"));
17724 printf (_("Data addressing position-independent, GOT near DP\n"));
17727 printf (_("Data addressing position-independent, GOT far from DP\n"));
17730 printf ("??? (%d)\n", val
);
17736 READ_ULEB (val
, p
, end
);
17737 printf (" Tag_ABI_PIC: ");
17741 printf (_("Code addressing position-dependent\n"));
17744 printf (_("Code addressing position-independent\n"));
17747 printf ("??? (%d)\n", val
);
17752 case Tag_ABI_array_object_alignment
:
17753 READ_ULEB (val
, p
, end
);
17754 printf (" Tag_ABI_array_object_alignment: ");
17758 printf (_("8-byte\n"));
17761 printf (_("4-byte\n"));
17764 printf (_("16-byte\n"));
17767 printf ("??? (%d)\n", val
);
17772 case Tag_ABI_array_object_align_expected
:
17773 READ_ULEB (val
, p
, end
);
17774 printf (" Tag_ABI_array_object_align_expected: ");
17778 printf (_("8-byte\n"));
17781 printf (_("4-byte\n"));
17784 printf (_("16-byte\n"));
17787 printf ("??? (%d)\n", val
);
17792 case Tag_ABI_compatibility
:
17794 READ_ULEB (val
, p
, end
);
17795 printf (" Tag_ABI_compatibility: ");
17796 printf (_("flag = %d, vendor = "), val
);
17799 size_t maxlen
= (end
- p
) - 1;
17801 print_symbol ((int) maxlen
, (const char *) p
);
17802 p
+= strnlen ((char *) p
, maxlen
) + 1;
17806 printf (_("<corrupt>"));
17807 p
= (unsigned char *) end
;
17813 case Tag_ABI_conformance
:
17815 printf (" Tag_ABI_conformance: \"");
17818 size_t maxlen
= (end
- p
) - 1;
17820 print_symbol ((int) maxlen
, (const char *) p
);
17821 p
+= strnlen ((char *) p
, maxlen
) + 1;
17825 printf (_("<corrupt>"));
17826 p
= (unsigned char *) end
;
17833 return display_tag_value (tag
, p
, end
);
17837 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
17840 size_t bytes
= end
- p
;
17847 int lbytes
= (bytes
> 16 ? 16 : bytes
);
17849 printf (" 0x%8.8" PRIx64
" ", addr
);
17851 for (j
= 0; j
< 16; j
++)
17854 printf ("%2.2x", p
[j
]);
17862 for (j
= 0; j
< lbytes
; j
++)
17865 if (k
>= ' ' && k
< 0x7f)
17881 static unsigned char *
17882 display_msp430_attribute (unsigned char * p
,
17883 const unsigned char * const end
)
17888 READ_ULEB (tag
, p
, end
);
17892 case OFBA_MSPABI_Tag_ISA
:
17893 printf (" Tag_ISA: ");
17894 READ_ULEB (val
, p
, end
);
17897 case 0: printf (_("None\n")); break;
17898 case 1: printf (_("MSP430\n")); break;
17899 case 2: printf (_("MSP430X\n")); break;
17900 default: printf ("??? (%" PRId64
")\n", val
); break;
17904 case OFBA_MSPABI_Tag_Code_Model
:
17905 printf (" Tag_Code_Model: ");
17906 READ_ULEB (val
, p
, end
);
17909 case 0: printf (_("None\n")); break;
17910 case 1: printf (_("Small\n")); break;
17911 case 2: printf (_("Large\n")); break;
17912 default: printf ("??? (%" PRId64
")\n", val
); break;
17916 case OFBA_MSPABI_Tag_Data_Model
:
17917 printf (" Tag_Data_Model: ");
17918 READ_ULEB (val
, p
, end
);
17921 case 0: printf (_("None\n")); break;
17922 case 1: printf (_("Small\n")); break;
17923 case 2: printf (_("Large\n")); break;
17924 case 3: printf (_("Restricted Large\n")); break;
17925 default: printf ("??? (%" PRId64
")\n", val
); break;
17930 printf (_(" <unknown tag %" PRId64
">: "), tag
);
17937 size_t maxlen
= (end
- p
) - 1;
17939 print_symbol ((int) maxlen
, (const char *) p
);
17940 p
+= strnlen ((char *) p
, maxlen
) + 1;
17944 printf (_("<corrupt>"));
17945 p
= (unsigned char *) end
;
17951 READ_ULEB (val
, p
, end
);
17952 printf ("%" PRId64
" (0x%" PRIx64
")\n", val
, val
);
17961 static unsigned char *
17962 display_msp430_gnu_attribute (unsigned char * p
,
17964 const unsigned char * const end
)
17966 if (tag
== Tag_GNU_MSP430_Data_Region
)
17970 printf (" Tag_GNU_MSP430_Data_Region: ");
17971 READ_ULEB (val
, p
, end
);
17975 case Val_GNU_MSP430_Data_Region_Any
:
17976 printf (_("Any Region\n"));
17978 case Val_GNU_MSP430_Data_Region_Lower
:
17979 printf (_("Lower Region Only\n"));
17982 printf ("??? (%" PRIu64
")\n", val
);
17986 return display_tag_value (tag
& 1, p
, end
);
17989 struct riscv_attr_tag_t
{
17994 static struct riscv_attr_tag_t riscv_attr_tag
[] =
17996 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
17999 T(priv_spec_minor
),
18000 T(priv_spec_revision
),
18001 T(unaligned_access
),
18006 static unsigned char *
18007 display_riscv_attribute (unsigned char *p
,
18008 const unsigned char * const end
)
18012 struct riscv_attr_tag_t
*attr
= NULL
;
18015 READ_ULEB (tag
, p
, end
);
18017 /* Find the name of attribute. */
18018 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
18020 if (riscv_attr_tag
[i
].tag
== tag
)
18022 attr
= &riscv_attr_tag
[i
];
18028 printf (" %s: ", attr
->name
);
18030 return display_tag_value (tag
, p
, end
);
18034 case Tag_RISCV_priv_spec
:
18035 case Tag_RISCV_priv_spec_minor
:
18036 case Tag_RISCV_priv_spec_revision
:
18037 READ_ULEB (val
, p
, end
);
18038 printf ("%" PRIu64
"\n", val
);
18040 case Tag_RISCV_unaligned_access
:
18041 READ_ULEB (val
, p
, end
);
18045 printf (_("No unaligned access\n"));
18048 printf (_("Unaligned access\n"));
18052 case Tag_RISCV_stack_align
:
18053 READ_ULEB (val
, p
, end
);
18054 printf (_("%" PRIu64
"-bytes\n"), val
);
18056 case Tag_RISCV_arch
:
18057 p
= display_tag_value (-1, p
, end
);
18060 return display_tag_value (tag
, p
, end
);
18066 static unsigned char *
18067 display_csky_attribute (unsigned char * p
,
18068 const unsigned char * const end
)
18072 READ_ULEB (tag
, p
, end
);
18074 if (tag
>= Tag_CSKY_MAX
)
18076 return display_tag_value (-1, p
, end
);
18081 case Tag_CSKY_ARCH_NAME
:
18082 printf (" Tag_CSKY_ARCH_NAME:\t\t");
18083 return display_tag_value (-1, p
, end
);
18084 case Tag_CSKY_CPU_NAME
:
18085 printf (" Tag_CSKY_CPU_NAME:\t\t");
18086 return display_tag_value (-1, p
, end
);
18088 case Tag_CSKY_ISA_FLAGS
:
18089 printf (" Tag_CSKY_ISA_FLAGS:\t\t");
18090 return display_tag_value (0, p
, end
);
18091 case Tag_CSKY_ISA_EXT_FLAGS
:
18092 printf (" Tag_CSKY_ISA_EXT_FLAGS:\t");
18093 return display_tag_value (0, p
, end
);
18095 case Tag_CSKY_DSP_VERSION
:
18096 printf (" Tag_CSKY_DSP_VERSION:\t\t");
18097 READ_ULEB (val
, p
, end
);
18098 if (val
== VAL_CSKY_DSP_VERSION_EXTENSION
)
18099 printf ("DSP Extension\n");
18100 else if (val
== VAL_CSKY_DSP_VERSION_2
)
18101 printf ("DSP 2.0\n");
18104 case Tag_CSKY_VDSP_VERSION
:
18105 printf (" Tag_CSKY_VDSP_VERSION:\t");
18106 READ_ULEB (val
, p
, end
);
18107 printf ("VDSP Version %" PRId64
"\n", val
);
18110 case Tag_CSKY_FPU_VERSION
:
18111 printf (" Tag_CSKY_FPU_VERSION:\t\t");
18112 READ_ULEB (val
, p
, end
);
18113 if (val
== VAL_CSKY_FPU_VERSION_1
)
18114 printf ("ABIV1 FPU Version 1\n");
18115 else if (val
== VAL_CSKY_FPU_VERSION_2
)
18116 printf ("FPU Version 2\n");
18119 case Tag_CSKY_FPU_ABI
:
18120 printf (" Tag_CSKY_FPU_ABI:\t\t");
18121 READ_ULEB (val
, p
, end
);
18122 if (val
== VAL_CSKY_FPU_ABI_HARD
)
18124 else if (val
== VAL_CSKY_FPU_ABI_SOFTFP
)
18125 printf ("SoftFP\n");
18126 else if (val
== VAL_CSKY_FPU_ABI_SOFT
)
18129 case Tag_CSKY_FPU_ROUNDING
:
18130 READ_ULEB (val
, p
, end
);
18133 printf (" Tag_CSKY_FPU_ROUNDING:\t");
18134 printf ("Needed\n");
18137 case Tag_CSKY_FPU_DENORMAL
:
18138 READ_ULEB (val
, p
, end
);
18141 printf (" Tag_CSKY_FPU_DENORMAL:\t");
18142 printf ("Needed\n");
18145 case Tag_CSKY_FPU_Exception
:
18146 READ_ULEB (val
, p
, end
);
18149 printf (" Tag_CSKY_FPU_Exception:\t");
18150 printf ("Needed\n");
18153 case Tag_CSKY_FPU_NUMBER_MODULE
:
18154 printf (" Tag_CSKY_FPU_NUMBER_MODULE:\t");
18155 return display_tag_value (-1, p
, end
);
18156 case Tag_CSKY_FPU_HARDFP
:
18157 printf (" Tag_CSKY_FPU_HARDFP:\t\t");
18158 READ_ULEB (val
, p
, end
);
18159 if (val
& VAL_CSKY_FPU_HARDFP_HALF
)
18161 if (val
& VAL_CSKY_FPU_HARDFP_SINGLE
)
18162 printf (" Single");
18163 if (val
& VAL_CSKY_FPU_HARDFP_DOUBLE
)
18164 printf (" Double");
18168 return display_tag_value (tag
, p
, end
);
18174 process_attributes (Filedata
* filedata
,
18175 const char * public_name
,
18176 unsigned int proc_type
,
18177 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
18178 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
18180 Elf_Internal_Shdr
* sect
;
18184 /* Find the section header so that we get the size. */
18185 for (i
= 0, sect
= filedata
->section_headers
;
18186 i
< filedata
->file_header
.e_shnum
;
18189 unsigned char * contents
;
18192 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
18195 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
18196 sect
->sh_size
, _("attributes"));
18197 if (contents
== NULL
)
18204 /* The first character is the version of the attributes.
18205 Currently only version 1, (aka 'A') is recognised here. */
18208 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
18213 uint64_t section_len
;
18215 section_len
= sect
->sh_size
- 1;
18218 while (section_len
> 0)
18221 unsigned int namelen
;
18222 bool public_section
;
18225 if (section_len
<= 4)
18227 error (_("Tag section ends prematurely\n"));
18231 attr_len
= byte_get (p
, 4);
18234 if (attr_len
> section_len
)
18236 error (_("Bad attribute length (%u > %u)\n"),
18237 (unsigned) attr_len
, (unsigned) section_len
);
18238 attr_len
= section_len
;
18241 /* PR 17531: file: 001-101425-0.004 */
18242 else if (attr_len
< 5)
18244 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
18249 section_len
-= attr_len
;
18252 namelen
= strnlen ((char *) p
, attr_len
) + 1;
18253 if (namelen
== 0 || namelen
>= attr_len
)
18255 error (_("Corrupt attribute section name\n"));
18260 printf (_("Attribute Section: "));
18261 print_symbol (INT_MAX
, (const char *) p
);
18264 if (public_name
&& streq ((char *) p
, public_name
))
18265 public_section
= true;
18267 public_section
= false;
18269 if (streq ((char *) p
, "gnu"))
18270 gnu_section
= true;
18272 gnu_section
= false;
18275 attr_len
-= namelen
;
18277 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
18282 unsigned char * end
;
18284 /* PR binutils/17531: Safe handling of corrupt files. */
18287 error (_("Unused bytes at end of section\n"));
18294 size
= byte_get (p
, 4);
18295 if (size
> attr_len
)
18297 error (_("Bad subsection length (%u > %u)\n"),
18298 (unsigned) size
, (unsigned) attr_len
);
18302 /* PR binutils/17531: Safe handling of corrupt files. */
18305 error (_("Bad subsection length (%u < 6)\n"),
18313 end
= p
+ size
- 1;
18314 assert (end
<= contents
+ sect
->sh_size
);
18320 printf (_("File Attributes\n"));
18323 printf (_("Section Attributes:"));
18326 printf (_("Symbol Attributes:"));
18327 /* Fall through. */
18331 READ_ULEB (val
, p
, end
);
18334 printf (" %d", val
);
18339 printf (_("Unknown tag: %d\n"), tag
);
18340 public_section
= false;
18344 if (public_section
&& display_pub_attribute
!= NULL
)
18347 p
= display_pub_attribute (p
, end
);
18350 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
18353 p
= display_gnu_attribute (p
,
18354 display_proc_gnu_attribute
,
18360 printf (_(" Unknown attribute:\n"));
18361 display_raw_attribute (p
, end
);
18376 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
18377 Print the Address, Access and Initial fields of an entry at VMA ADDR
18378 and return the VMA of the next entry, or -1 if there was a problem.
18379 Does not read from DATA_END or beyond. */
18382 print_mips_got_entry (unsigned char * data
, uint64_t pltgot
, uint64_t addr
,
18383 unsigned char * data_end
)
18386 print_vma (addr
, LONG_HEX
);
18388 if (addr
< pltgot
+ 0xfff0)
18389 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
18391 printf ("%10s", "");
18394 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
18398 unsigned char * from
= data
+ addr
- pltgot
;
18400 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
18402 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
18403 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
18404 return (uint64_t) -1;
18408 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
18409 print_vma (entry
, LONG_HEX
);
18412 return addr
+ (is_32bit_elf
? 4 : 8);
18415 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
18416 PLTGOT. Print the Address and Initial fields of an entry at VMA
18417 ADDR and return the VMA of the next entry. */
18420 print_mips_pltgot_entry (unsigned char * data
, uint64_t pltgot
, uint64_t addr
)
18423 print_vma (addr
, LONG_HEX
);
18426 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
18431 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
18432 print_vma (entry
, LONG_HEX
);
18434 return addr
+ (is_32bit_elf
? 4 : 8);
18438 print_mips_ases (unsigned int mask
)
18440 if (mask
& AFL_ASE_DSP
)
18441 fputs ("\n\tDSP ASE", stdout
);
18442 if (mask
& AFL_ASE_DSPR2
)
18443 fputs ("\n\tDSP R2 ASE", stdout
);
18444 if (mask
& AFL_ASE_DSPR3
)
18445 fputs ("\n\tDSP R3 ASE", stdout
);
18446 if (mask
& AFL_ASE_EVA
)
18447 fputs ("\n\tEnhanced VA Scheme", stdout
);
18448 if (mask
& AFL_ASE_MCU
)
18449 fputs ("\n\tMCU (MicroController) ASE", stdout
);
18450 if (mask
& AFL_ASE_MDMX
)
18451 fputs ("\n\tMDMX ASE", stdout
);
18452 if (mask
& AFL_ASE_MIPS3D
)
18453 fputs ("\n\tMIPS-3D ASE", stdout
);
18454 if (mask
& AFL_ASE_MT
)
18455 fputs ("\n\tMT ASE", stdout
);
18456 if (mask
& AFL_ASE_SMARTMIPS
)
18457 fputs ("\n\tSmartMIPS ASE", stdout
);
18458 if (mask
& AFL_ASE_VIRT
)
18459 fputs ("\n\tVZ ASE", stdout
);
18460 if (mask
& AFL_ASE_MSA
)
18461 fputs ("\n\tMSA ASE", stdout
);
18462 if (mask
& AFL_ASE_MIPS16
)
18463 fputs ("\n\tMIPS16 ASE", stdout
);
18464 if (mask
& AFL_ASE_MICROMIPS
)
18465 fputs ("\n\tMICROMIPS ASE", stdout
);
18466 if (mask
& AFL_ASE_XPA
)
18467 fputs ("\n\tXPA ASE", stdout
);
18468 if (mask
& AFL_ASE_MIPS16E2
)
18469 fputs ("\n\tMIPS16e2 ASE", stdout
);
18470 if (mask
& AFL_ASE_CRC
)
18471 fputs ("\n\tCRC ASE", stdout
);
18472 if (mask
& AFL_ASE_GINV
)
18473 fputs ("\n\tGINV ASE", stdout
);
18474 if (mask
& AFL_ASE_LOONGSON_MMI
)
18475 fputs ("\n\tLoongson MMI ASE", stdout
);
18476 if (mask
& AFL_ASE_LOONGSON_CAM
)
18477 fputs ("\n\tLoongson CAM ASE", stdout
);
18478 if (mask
& AFL_ASE_LOONGSON_EXT
)
18479 fputs ("\n\tLoongson EXT ASE", stdout
);
18480 if (mask
& AFL_ASE_LOONGSON_EXT2
)
18481 fputs ("\n\tLoongson EXT2 ASE", stdout
);
18483 fprintf (stdout
, "\n\t%s", _("None"));
18484 else if ((mask
& ~AFL_ASE_MASK
) != 0)
18485 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
18489 print_mips_isa_ext (unsigned int isa_ext
)
18494 fputs (_("None"), stdout
);
18497 fputs ("RMI XLR", stdout
);
18499 case AFL_EXT_OCTEON3
:
18500 fputs ("Cavium Networks Octeon3", stdout
);
18502 case AFL_EXT_OCTEON2
:
18503 fputs ("Cavium Networks Octeon2", stdout
);
18505 case AFL_EXT_OCTEONP
:
18506 fputs ("Cavium Networks OcteonP", stdout
);
18508 case AFL_EXT_OCTEON
:
18509 fputs ("Cavium Networks Octeon", stdout
);
18512 fputs ("Toshiba R5900", stdout
);
18515 fputs ("MIPS R4650", stdout
);
18518 fputs ("LSI R4010", stdout
);
18521 fputs ("NEC VR4100", stdout
);
18524 fputs ("Toshiba R3900", stdout
);
18526 case AFL_EXT_10000
:
18527 fputs ("MIPS R10000", stdout
);
18530 fputs ("Broadcom SB-1", stdout
);
18533 fputs ("NEC VR4111/VR4181", stdout
);
18536 fputs ("NEC VR4120", stdout
);
18539 fputs ("NEC VR5400", stdout
);
18542 fputs ("NEC VR5500", stdout
);
18544 case AFL_EXT_LOONGSON_2E
:
18545 fputs ("ST Microelectronics Loongson 2E", stdout
);
18547 case AFL_EXT_LOONGSON_2F
:
18548 fputs ("ST Microelectronics Loongson 2F", stdout
);
18550 case AFL_EXT_INTERAPTIV_MR2
:
18551 fputs ("Imagination interAptiv MR2", stdout
);
18554 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
18559 get_mips_reg_size (int reg_size
)
18561 return (reg_size
== AFL_REG_NONE
) ? 0
18562 : (reg_size
== AFL_REG_32
) ? 32
18563 : (reg_size
== AFL_REG_64
) ? 64
18564 : (reg_size
== AFL_REG_128
) ? 128
18569 process_mips_specific (Filedata
* filedata
)
18571 Elf_Internal_Dyn
* entry
;
18572 Elf_Internal_Shdr
*sect
= NULL
;
18573 size_t liblist_offset
= 0;
18574 size_t liblistno
= 0;
18575 size_t conflictsno
= 0;
18576 size_t options_offset
= 0;
18577 size_t conflicts_offset
= 0;
18578 size_t pltrelsz
= 0;
18580 uint64_t pltgot
= 0;
18581 uint64_t mips_pltgot
= 0;
18582 uint64_t jmprel
= 0;
18583 uint64_t local_gotno
= 0;
18584 uint64_t gotsym
= 0;
18585 uint64_t symtabno
= 0;
18588 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18589 display_mips_gnu_attribute
))
18592 sect
= find_section (filedata
, ".MIPS.abiflags");
18596 Elf_External_ABIFlags_v0
*abiflags_ext
;
18597 Elf_Internal_ABIFlags_v0 abiflags_in
;
18599 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
18601 error (_("Corrupt MIPS ABI Flags section.\n"));
18606 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
18607 sect
->sh_size
, _("MIPS ABI Flags section"));
18610 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
18611 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
18612 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
18613 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
18614 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
18615 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
18616 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
18617 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
18618 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
18619 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
18620 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
18622 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
18623 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
18624 if (abiflags_in
.isa_rev
> 1)
18625 printf ("r%d", abiflags_in
.isa_rev
);
18626 printf ("\nGPR size: %d",
18627 get_mips_reg_size (abiflags_in
.gpr_size
));
18628 printf ("\nCPR1 size: %d",
18629 get_mips_reg_size (abiflags_in
.cpr1_size
));
18630 printf ("\nCPR2 size: %d",
18631 get_mips_reg_size (abiflags_in
.cpr2_size
));
18632 fputs ("\nFP ABI: ", stdout
);
18633 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
18634 fputs ("ISA Extension: ", stdout
);
18635 print_mips_isa_ext (abiflags_in
.isa_ext
);
18636 fputs ("\nASEs:", stdout
);
18637 print_mips_ases (abiflags_in
.ases
);
18638 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
18639 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
18640 fputc ('\n', stdout
);
18641 free (abiflags_ext
);
18646 /* We have a lot of special sections. Thanks SGI! */
18647 if (filedata
->dynamic_section
== NULL
)
18649 /* No dynamic information available. See if there is static GOT. */
18650 sect
= find_section (filedata
, ".got");
18653 unsigned char *data_end
;
18654 unsigned char *data
;
18658 pltgot
= sect
->sh_addr
;
18661 addr_size
= (is_32bit_elf
? 4 : 8);
18662 end
= pltgot
+ sect
->sh_size
;
18664 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
18666 _("Global Offset Table data"));
18667 /* PR 12855: Null data is handled gracefully throughout. */
18668 data_end
= data
+ (end
- pltgot
);
18670 printf (_("\nStatic GOT:\n"));
18671 printf (_(" Canonical gp value: "));
18672 print_vma (ent
+ 0x7ff0, LONG_HEX
);
18675 /* In a dynamic binary GOT[0] is reserved for the dynamic
18676 loader to store the lazy resolver pointer, however in
18677 a static binary it may well have been omitted and GOT
18678 reduced to a table of addresses.
18679 PR 21344: Check for the entry being fully available
18680 before fetching it. */
18682 && data
+ ent
- pltgot
+ addr_size
<= data_end
18683 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
18685 printf (_(" Reserved entries:\n"));
18686 printf (_(" %*s %10s %*s\n"),
18687 addr_size
* 2, _("Address"), _("Access"),
18688 addr_size
* 2, _("Value"));
18689 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18691 if (ent
== (uint64_t) -1)
18692 goto sgot_print_fail
;
18694 /* Check for the MSB of GOT[1] being set, identifying a
18695 GNU object. This entry will be used by some runtime
18696 loaders, to store the module pointer. Otherwise this
18697 is an ordinary local entry.
18698 PR 21344: Check for the entry being fully available
18699 before fetching it. */
18701 && data
+ ent
- pltgot
+ addr_size
<= data_end
18702 && (byte_get (data
+ ent
- pltgot
, addr_size
)
18703 >> (addr_size
* 8 - 1)) != 0)
18705 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18707 if (ent
== (uint64_t) -1)
18708 goto sgot_print_fail
;
18713 if (data
!= NULL
&& ent
< end
)
18715 printf (_(" Local entries:\n"));
18716 printf (" %*s %10s %*s\n",
18717 addr_size
* 2, _("Address"), _("Access"),
18718 addr_size
* 2, _("Value"));
18721 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18723 if (ent
== (uint64_t) -1)
18724 goto sgot_print_fail
;
18735 for (entry
= filedata
->dynamic_section
;
18736 /* PR 17531 file: 012-50589-0.004. */
18737 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
18738 && entry
->d_tag
!= DT_NULL
);
18740 switch (entry
->d_tag
)
18742 case DT_MIPS_LIBLIST
:
18744 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
18745 liblistno
* sizeof (Elf32_External_Lib
));
18747 case DT_MIPS_LIBLISTNO
:
18748 liblistno
= entry
->d_un
.d_val
;
18750 case DT_MIPS_OPTIONS
:
18751 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
18753 case DT_MIPS_CONFLICT
:
18755 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
18756 conflictsno
* sizeof (Elf32_External_Conflict
));
18758 case DT_MIPS_CONFLICTNO
:
18759 conflictsno
= entry
->d_un
.d_val
;
18762 pltgot
= entry
->d_un
.d_ptr
;
18764 case DT_MIPS_LOCAL_GOTNO
:
18765 local_gotno
= entry
->d_un
.d_val
;
18767 case DT_MIPS_GOTSYM
:
18768 gotsym
= entry
->d_un
.d_val
;
18770 case DT_MIPS_SYMTABNO
:
18771 symtabno
= entry
->d_un
.d_val
;
18773 case DT_MIPS_PLTGOT
:
18774 mips_pltgot
= entry
->d_un
.d_ptr
;
18777 pltrel
= entry
->d_un
.d_val
;
18780 pltrelsz
= entry
->d_un
.d_val
;
18783 jmprel
= entry
->d_un
.d_ptr
;
18789 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
18791 Elf32_External_Lib
* elib
;
18794 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
18795 sizeof (Elf32_External_Lib
),
18797 _("liblist section data"));
18800 printf (ngettext ("\nSection '.liblist' contains %zu entry:\n",
18801 "\nSection '.liblist' contains %zu entries:\n",
18804 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
18807 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
18814 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
18815 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
18816 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
18817 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
18818 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
18820 tmp
= gmtime (&atime
);
18821 snprintf (timebuf
, sizeof (timebuf
),
18822 "%04u-%02u-%02uT%02u:%02u:%02u",
18823 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
18824 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
18826 printf ("%3zu: ", cnt
);
18827 if (valid_dynamic_name (filedata
, liblist
.l_name
))
18828 print_symbol (20, get_dynamic_name (filedata
, liblist
.l_name
));
18830 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
18831 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
18832 liblist
.l_version
);
18834 if (liblist
.l_flags
== 0)
18838 static const struct
18845 { " EXACT_MATCH", LL_EXACT_MATCH
},
18846 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
18847 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
18848 { " EXPORTS", LL_EXPORTS
},
18849 { " DELAY_LOAD", LL_DELAY_LOAD
},
18850 { " DELTA", LL_DELTA
}
18852 int flags
= liblist
.l_flags
;
18855 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
18856 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
18858 fputs (l_flags_vals
[fcnt
].name
, stdout
);
18859 flags
^= l_flags_vals
[fcnt
].bit
;
18862 printf (" %#x", (unsigned int) flags
);
18874 if (options_offset
!= 0)
18876 Elf_External_Options
* eopt
;
18880 /* Find the section header so that we get the size. */
18881 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
18882 /* PR 17533 file: 012-277276-0.004. */
18885 error (_("No MIPS_OPTIONS header found\n"));
18889 if (sect
->sh_size
< sizeof (* eopt
))
18891 error (_("The MIPS options section is too small.\n"));
18895 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
18896 sect
->sh_size
, _("options"));
18899 Elf_Internal_Options option
;
18902 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
18904 Elf_External_Options
* eoption
;
18905 unsigned int optsize
;
18907 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
18909 optsize
= BYTE_GET (eoption
->size
);
18911 /* PR 17531: file: ffa0fa3b. */
18912 if (optsize
< sizeof (* eopt
)
18913 || optsize
> sect
->sh_size
- offset
)
18915 error (_("Invalid size (%u) for MIPS option\n"),
18924 printf (ngettext ("\nSection '%s' contains %d entry:\n",
18925 "\nSection '%s' contains %d entries:\n",
18927 printable_section_name (filedata
, sect
), cnt
);
18933 Elf_External_Options
* eoption
;
18935 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
18937 option
.kind
= BYTE_GET (eoption
->kind
);
18938 option
.size
= BYTE_GET (eoption
->size
);
18939 option
.section
= BYTE_GET (eoption
->section
);
18940 option
.info
= BYTE_GET (eoption
->info
);
18942 switch (option
.kind
)
18945 /* This shouldn't happen. */
18946 printf (" NULL %" PRId16
" %" PRIx32
,
18947 option
.section
, option
.info
);
18951 printf (" REGINFO ");
18952 if (filedata
->file_header
.e_machine
== EM_MIPS
)
18954 Elf32_External_RegInfo
* ereg
;
18955 Elf32_RegInfo reginfo
;
18958 if (option
.size
< (sizeof (Elf_External_Options
)
18959 + sizeof (Elf32_External_RegInfo
)))
18961 printf (_("<corrupt>\n"));
18962 error (_("Truncated MIPS REGINFO option\n"));
18967 ereg
= (Elf32_External_RegInfo
*) (eoption
+ 1);
18969 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
18970 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
18971 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
18972 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
18973 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
18974 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
18976 printf ("GPR %08" PRIx32
" GP 0x%" PRIx32
"\n",
18977 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
18979 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
18980 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
18981 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
18982 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
18987 Elf64_External_RegInfo
* ereg
;
18988 Elf64_Internal_RegInfo reginfo
;
18990 if (option
.size
< (sizeof (Elf_External_Options
)
18991 + sizeof (Elf64_External_RegInfo
)))
18993 printf (_("<corrupt>\n"));
18994 error (_("Truncated MIPS REGINFO option\n"));
18999 ereg
= (Elf64_External_RegInfo
*) (eoption
+ 1);
19000 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
19001 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
19002 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
19003 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
19004 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
19005 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
19007 printf ("GPR %08" PRIx32
" GP 0x%" PRIx64
"\n",
19008 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
19010 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
19011 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
19012 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
19013 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
19015 offset
+= option
.size
;
19018 case ODK_EXCEPTIONS
:
19019 fputs (" EXCEPTIONS fpe_min(", stdout
);
19020 process_mips_fpe_exception (option
.info
& OEX_FPU_MIN
);
19021 fputs (") fpe_max(", stdout
);
19022 process_mips_fpe_exception ((option
.info
& OEX_FPU_MAX
) >> 8);
19023 fputs (")", stdout
);
19025 if (option
.info
& OEX_PAGE0
)
19026 fputs (" PAGE0", stdout
);
19027 if (option
.info
& OEX_SMM
)
19028 fputs (" SMM", stdout
);
19029 if (option
.info
& OEX_FPDBUG
)
19030 fputs (" FPDBUG", stdout
);
19031 if (option
.info
& OEX_DISMISS
)
19032 fputs (" DISMISS", stdout
);
19036 fputs (" PAD ", stdout
);
19037 if (option
.info
& OPAD_PREFIX
)
19038 fputs (" PREFIX", stdout
);
19039 if (option
.info
& OPAD_POSTFIX
)
19040 fputs (" POSTFIX", stdout
);
19041 if (option
.info
& OPAD_SYMBOL
)
19042 fputs (" SYMBOL", stdout
);
19046 fputs (" HWPATCH ", stdout
);
19047 if (option
.info
& OHW_R4KEOP
)
19048 fputs (" R4KEOP", stdout
);
19049 if (option
.info
& OHW_R8KPFETCH
)
19050 fputs (" R8KPFETCH", stdout
);
19051 if (option
.info
& OHW_R5KEOP
)
19052 fputs (" R5KEOP", stdout
);
19053 if (option
.info
& OHW_R5KCVTL
)
19054 fputs (" R5KCVTL", stdout
);
19058 fputs (" FILL ", stdout
);
19059 /* XXX Print content of info word? */
19063 fputs (" TAGS ", stdout
);
19064 /* XXX Print content of info word? */
19068 fputs (" HWAND ", stdout
);
19069 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
19070 fputs (" R4KEOP_CHECKED", stdout
);
19071 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
19072 fputs (" R4KEOP_CLEAN", stdout
);
19076 fputs (" HWOR ", stdout
);
19077 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
19078 fputs (" R4KEOP_CHECKED", stdout
);
19079 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
19080 fputs (" R4KEOP_CLEAN", stdout
);
19084 printf (" GP_GROUP %#06x self-contained %#06x",
19085 option
.info
& OGP_GROUP
,
19086 (option
.info
& OGP_SELF
) >> 16);
19090 printf (" IDENT %#06x self-contained %#06x",
19091 option
.info
& OGP_GROUP
,
19092 (option
.info
& OGP_SELF
) >> 16);
19096 /* This shouldn't happen. */
19097 printf (" %3d ??? %" PRId16
" %" PRIx32
,
19098 option
.kind
, option
.section
, option
.info
);
19102 len
= sizeof (* eopt
);
19103 while (len
< option
.size
)
19105 unsigned char datum
= *((unsigned char *) eoption
+ len
);
19107 if (ISPRINT (datum
))
19108 printf ("%c", datum
);
19110 printf ("\\%03o", datum
);
19113 fputs ("\n", stdout
);
19115 offset
+= option
.size
;
19123 if (conflicts_offset
!= 0 && conflictsno
!= 0)
19125 Elf32_Conflict
* iconf
;
19128 if (filedata
->dynamic_symbols
== NULL
)
19130 error (_("conflict list found without a dynamic symbol table\n"));
19134 /* PR 21345 - print a slightly more helpful error message
19135 if we are sure that the cmalloc will fail. */
19136 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
19138 error (_("Overlarge number of conflicts detected: %zx\n"),
19143 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
19146 error (_("Out of memory allocating space for dynamic conflicts\n"));
19152 Elf32_External_Conflict
* econf32
;
19154 econf32
= (Elf32_External_Conflict
*)
19155 get_data (NULL
, filedata
, conflicts_offset
,
19156 sizeof (*econf32
), conflictsno
, _("conflict"));
19163 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
19164 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
19170 Elf64_External_Conflict
* econf64
;
19172 econf64
= (Elf64_External_Conflict
*)
19173 get_data (NULL
, filedata
, conflicts_offset
,
19174 sizeof (*econf64
), conflictsno
, _("conflict"));
19181 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
19182 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
19187 printf (ngettext ("\nSection '.conflict' contains %zu entry:\n",
19188 "\nSection '.conflict' contains %zu entries:\n",
19191 puts (_(" Num: Index Value Name"));
19193 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
19195 printf ("%5zu: %8lu ", cnt
, iconf
[cnt
]);
19197 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
19198 printf (_("<corrupt symbol index>"));
19201 Elf_Internal_Sym
* psym
;
19203 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
19204 print_vma (psym
->st_value
, FULL_HEX
);
19206 if (valid_dynamic_name (filedata
, psym
->st_name
))
19207 print_symbol (25, get_dynamic_name (filedata
, psym
->st_name
));
19209 printf (_("<corrupt: %14ld>"), psym
->st_name
);
19217 if (pltgot
!= 0 && local_gotno
!= 0)
19219 uint64_t ent
, local_end
, global_end
;
19221 unsigned char * data
;
19222 unsigned char * data_end
;
19226 addr_size
= (is_32bit_elf
? 4 : 8);
19227 local_end
= pltgot
+ local_gotno
* addr_size
;
19229 /* PR binutils/17533 file: 012-111227-0.004 */
19230 if (symtabno
< gotsym
)
19232 error (_("The GOT symbol offset (%" PRIu64
19233 ") is greater than the symbol table size (%" PRIu64
")\n"),
19238 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
19239 /* PR 17531: file: 54c91a34. */
19240 if (global_end
< local_end
)
19242 error (_("Too many GOT symbols: %" PRIu64
"\n"), symtabno
);
19246 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
19247 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
19248 global_end
- pltgot
, 1,
19249 _("Global Offset Table data"));
19250 /* PR 12855: Null data is handled gracefully throughout. */
19251 data_end
= data
+ (global_end
- pltgot
);
19253 printf (_("\nPrimary GOT:\n"));
19254 printf (_(" Canonical gp value: "));
19255 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
19258 printf (_(" Reserved entries:\n"));
19259 printf (_(" %*s %10s %*s Purpose\n"),
19260 addr_size
* 2, _("Address"), _("Access"),
19261 addr_size
* 2, _("Initial"));
19262 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19263 printf (_(" Lazy resolver\n"));
19264 if (ent
== (uint64_t) -1)
19265 goto got_print_fail
;
19267 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
19268 This entry will be used by some runtime loaders, to store the
19269 module pointer. Otherwise this is an ordinary local entry.
19270 PR 21344: Check for the entry being fully available before
19273 && data
+ ent
- pltgot
+ addr_size
<= data_end
19274 && (byte_get (data
+ ent
- pltgot
, addr_size
)
19275 >> (addr_size
* 8 - 1)) != 0)
19277 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19278 printf (_(" Module pointer (GNU extension)\n"));
19279 if (ent
== (uint64_t) -1)
19280 goto got_print_fail
;
19284 if (data
!= NULL
&& ent
< local_end
)
19286 printf (_(" Local entries:\n"));
19287 printf (" %*s %10s %*s\n",
19288 addr_size
* 2, _("Address"), _("Access"),
19289 addr_size
* 2, _("Initial"));
19290 while (ent
< local_end
)
19292 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19294 if (ent
== (uint64_t) -1)
19295 goto got_print_fail
;
19300 if (data
!= NULL
&& gotsym
< symtabno
)
19304 printf (_(" Global entries:\n"));
19305 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
19306 addr_size
* 2, _("Address"),
19308 addr_size
* 2, _("Initial"),
19309 addr_size
* 2, _("Sym.Val."),
19311 /* Note for translators: "Ndx" = abbreviated form of "Index". */
19312 _("Ndx"), _("Name"));
19314 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
19316 for (i
= gotsym
; i
< symtabno
; i
++)
19318 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19321 if (filedata
->dynamic_symbols
== NULL
)
19322 printf (_("<no dynamic symbols>"));
19323 else if (i
< filedata
->num_dynamic_syms
)
19325 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
19327 print_vma (psym
->st_value
, LONG_HEX
);
19328 printf (" %-7s %3s ",
19329 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
19330 get_symbol_index_type (filedata
, psym
->st_shndx
));
19332 if (valid_dynamic_name (filedata
, psym
->st_name
))
19333 print_symbol (sym_width
,
19334 get_dynamic_name (filedata
, psym
->st_name
));
19336 printf (_("<corrupt: %14ld>"), psym
->st_name
);
19339 printf (_("<symbol index %zu exceeds number of dynamic symbols>"),
19343 if (ent
== (uint64_t) -1)
19353 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
19356 uint64_t offset
, rel_offset
;
19358 unsigned char * data
;
19359 int addr_size
, sym_width
;
19360 Elf_Internal_Rela
* rels
;
19362 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
19363 if (pltrel
== DT_RELA
)
19365 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
19370 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
19375 addr_size
= (is_32bit_elf
? 4 : 8);
19376 end
= mips_pltgot
+ (2 + count
) * addr_size
;
19378 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
19379 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
19380 1, _("Procedure Linkage Table data"));
19387 printf ("\nPLT GOT:\n\n");
19388 printf (_(" Reserved entries:\n"));
19389 printf (_(" %*s %*s Purpose\n"),
19390 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
19391 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
19392 printf (_(" PLT lazy resolver\n"));
19393 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
19394 printf (_(" Module pointer\n"));
19397 printf (_(" Entries:\n"));
19398 printf (" %*s %*s %*s %-7s %3s %s\n",
19399 addr_size
* 2, _("Address"),
19400 addr_size
* 2, _("Initial"),
19401 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
19402 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
19403 for (i
= 0; i
< count
; i
++)
19405 uint64_t idx
= get_reloc_symindex (rels
[i
].r_info
);
19407 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
19410 if (idx
>= filedata
->num_dynamic_syms
)
19411 printf (_("<corrupt symbol index: %" PRIu64
">"), idx
);
19414 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
19416 print_vma (psym
->st_value
, LONG_HEX
);
19417 printf (" %-7s %3s ",
19418 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
19419 get_symbol_index_type (filedata
, psym
->st_shndx
));
19420 if (valid_dynamic_name (filedata
, psym
->st_name
))
19421 print_symbol (sym_width
,
19422 get_dynamic_name (filedata
, psym
->st_name
));
19424 printf (_("<corrupt: %14ld>"), psym
->st_name
);
19438 process_nds32_specific (Filedata
* filedata
)
19440 Elf_Internal_Shdr
*sect
= NULL
;
19442 sect
= find_section (filedata
, ".nds32_e_flags");
19443 if (sect
!= NULL
&& sect
->sh_size
>= 4)
19445 unsigned char *buf
;
19448 printf ("\nNDS32 elf flags section:\n");
19449 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
19450 _("NDS32 elf flags section"));
19455 flag
= byte_get (buf
, 4);
19457 switch (flag
& 0x3)
19460 printf ("(VEC_SIZE):\tNo entry.\n");
19463 printf ("(VEC_SIZE):\t4 bytes\n");
19466 printf ("(VEC_SIZE):\t16 bytes\n");
19469 printf ("(VEC_SIZE):\treserved\n");
19478 process_gnu_liblist (Filedata
* filedata
)
19480 Elf_Internal_Shdr
* section
;
19481 Elf_Internal_Shdr
* string_sec
;
19482 Elf32_External_Lib
* elib
;
19484 size_t strtab_size
;
19486 uint64_t num_liblist
;
19493 for (i
= 0, section
= filedata
->section_headers
;
19494 i
< filedata
->file_header
.e_shnum
;
19497 switch (section
->sh_type
)
19499 case SHT_GNU_LIBLIST
:
19500 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
19503 elib
= (Elf32_External_Lib
*)
19504 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
19505 _("liblist section data"));
19513 string_sec
= filedata
->section_headers
+ section
->sh_link
;
19514 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
19515 string_sec
->sh_size
,
19516 _("liblist string table"));
19518 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
19525 strtab_size
= string_sec
->sh_size
;
19527 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
19528 printf (ngettext ("\nLibrary list section '%s' contains %" PRIu64
19530 "\nLibrary list section '%s' contains %" PRIu64
19533 printable_section_name (filedata
, section
),
19536 puts (_(" Library Time Stamp Checksum Version Flags"));
19538 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
19546 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
19547 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
19548 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
19549 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
19550 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
19552 tmp
= gmtime (&atime
);
19553 snprintf (timebuf
, sizeof (timebuf
),
19554 "%04u-%02u-%02uT%02u:%02u:%02u",
19555 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
19556 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
19558 printf ("%3zu: ", cnt
);
19560 printf ("%-20s", liblist
.l_name
< strtab_size
19561 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
19563 printf ("%-20.20s", liblist
.l_name
< strtab_size
19564 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
19565 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
19566 liblist
.l_version
, liblist
.l_flags
);
19577 static const char *
19578 get_note_type (Filedata
* filedata
, unsigned e_type
)
19580 static char buff
[64];
19582 if (filedata
->file_header
.e_type
== ET_CORE
)
19586 return _("NT_AUXV (auxiliary vector)");
19588 return _("NT_PRSTATUS (prstatus structure)");
19590 return _("NT_FPREGSET (floating point registers)");
19592 return _("NT_PRPSINFO (prpsinfo structure)");
19593 case NT_TASKSTRUCT
:
19594 return _("NT_TASKSTRUCT (task structure)");
19596 return _("NT_GDB_TDESC (GDB XML target description)");
19598 return _("NT_PRXFPREG (user_xfpregs structure)");
19600 return _("NT_PPC_VMX (ppc Altivec registers)");
19602 return _("NT_PPC_VSX (ppc VSX registers)");
19604 return _("NT_PPC_TAR (ppc TAR register)");
19606 return _("NT_PPC_PPR (ppc PPR register)");
19608 return _("NT_PPC_DSCR (ppc DSCR register)");
19610 return _("NT_PPC_EBB (ppc EBB registers)");
19612 return _("NT_PPC_PMU (ppc PMU registers)");
19613 case NT_PPC_TM_CGPR
:
19614 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
19615 case NT_PPC_TM_CFPR
:
19616 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
19617 case NT_PPC_TM_CVMX
:
19618 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
19619 case NT_PPC_TM_CVSX
:
19620 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
19621 case NT_PPC_TM_SPR
:
19622 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
19623 case NT_PPC_TM_CTAR
:
19624 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
19625 case NT_PPC_TM_CPPR
:
19626 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
19627 case NT_PPC_TM_CDSCR
:
19628 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
19630 return _("NT_386_TLS (x86 TLS information)");
19631 case NT_386_IOPERM
:
19632 return _("NT_386_IOPERM (x86 I/O permissions)");
19633 case NT_X86_XSTATE
:
19634 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
19636 return _("NT_X86_CET (x86 CET state)");
19637 case NT_S390_HIGH_GPRS
:
19638 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
19639 case NT_S390_TIMER
:
19640 return _("NT_S390_TIMER (s390 timer register)");
19641 case NT_S390_TODCMP
:
19642 return _("NT_S390_TODCMP (s390 TOD comparator register)");
19643 case NT_S390_TODPREG
:
19644 return _("NT_S390_TODPREG (s390 TOD programmable register)");
19646 return _("NT_S390_CTRS (s390 control registers)");
19647 case NT_S390_PREFIX
:
19648 return _("NT_S390_PREFIX (s390 prefix register)");
19649 case NT_S390_LAST_BREAK
:
19650 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
19651 case NT_S390_SYSTEM_CALL
:
19652 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
19654 return _("NT_S390_TDB (s390 transaction diagnostic block)");
19655 case NT_S390_VXRS_LOW
:
19656 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
19657 case NT_S390_VXRS_HIGH
:
19658 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
19659 case NT_S390_GS_CB
:
19660 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
19661 case NT_S390_GS_BC
:
19662 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
19664 return _("NT_ARM_VFP (arm VFP registers)");
19666 return _("NT_ARM_TLS (AArch TLS registers)");
19667 case NT_ARM_HW_BREAK
:
19668 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
19669 case NT_ARM_HW_WATCH
:
19670 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
19671 case NT_ARM_SYSTEM_CALL
:
19672 return _("NT_ARM_SYSTEM_CALL (AArch system call number)");
19674 return _("NT_ARM_SVE (AArch SVE registers)");
19675 case NT_ARM_PAC_MASK
:
19676 return _("NT_ARM_PAC_MASK (AArch pointer authentication code masks)");
19677 case NT_ARM_PACA_KEYS
:
19678 return _("NT_ARM_PACA_KEYS (ARM pointer authentication address keys)");
19679 case NT_ARM_PACG_KEYS
:
19680 return _("NT_ARM_PACG_KEYS (ARM pointer authentication generic keys)");
19681 case NT_ARM_TAGGED_ADDR_CTRL
:
19682 return _("NT_ARM_TAGGED_ADDR_CTRL (AArch tagged address control)");
19684 return _("NT_ARM_SSVE (AArch64 streaming SVE registers)");
19686 return _("NT_ARM_ZA (AArch64 SME ZA register)");
19687 case NT_ARM_PAC_ENABLED_KEYS
:
19688 return _("NT_ARM_PAC_ENABLED_KEYS (AArch64 pointer authentication enabled keys)");
19690 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
19692 return _("NT_RISCV_CSR (RISC-V control and status registers)");
19694 return _("NT_PSTATUS (pstatus structure)");
19696 return _("NT_FPREGS (floating point registers)");
19698 return _("NT_PSINFO (psinfo structure)");
19700 return _("NT_LWPSTATUS (lwpstatus_t structure)");
19702 return _("NT_LWPSINFO (lwpsinfo_t structure)");
19703 case NT_WIN32PSTATUS
:
19704 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
19706 return _("NT_SIGINFO (siginfo_t data)");
19708 return _("NT_FILE (mapped files)");
19716 return _("NT_VERSION (version)");
19718 return _("NT_ARCH (architecture)");
19719 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
19721 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
19723 case NT_GO_BUILDID
:
19724 return _("GO BUILDID");
19725 case FDO_PACKAGING_METADATA
:
19726 return _("FDO_PACKAGING_METADATA");
19731 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19736 print_core_note (Elf_Internal_Note
*pnote
)
19738 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
19739 uint64_t count
, page_size
;
19740 unsigned char *descdata
, *filenames
, *descend
;
19742 if (pnote
->type
!= NT_FILE
)
19751 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
19752 /* Still "successful". */
19756 if (pnote
->descsz
< 2 * addr_size
)
19758 error (_(" Malformed note - too short for header\n"));
19762 descdata
= (unsigned char *) pnote
->descdata
;
19763 descend
= descdata
+ pnote
->descsz
;
19765 if (descdata
[pnote
->descsz
- 1] != '\0')
19767 error (_(" Malformed note - does not end with \\0\n"));
19771 count
= byte_get (descdata
, addr_size
);
19772 descdata
+= addr_size
;
19774 page_size
= byte_get (descdata
, addr_size
);
19775 descdata
+= addr_size
;
19777 if (count
> ((uint64_t) -1 - 2 * addr_size
) / (3 * addr_size
)
19778 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
19780 error (_(" Malformed note - too short for supplied file count\n"));
19784 printf (_(" Page size: "));
19785 print_vma (page_size
, DEC
);
19788 printf (_(" %*s%*s%*s\n"),
19789 (int) (2 + 2 * addr_size
), _("Start"),
19790 (int) (4 + 2 * addr_size
), _("End"),
19791 (int) (4 + 2 * addr_size
), _("Page Offset"));
19792 filenames
= descdata
+ count
* 3 * addr_size
;
19793 while (count
-- > 0)
19795 uint64_t start
, end
, file_ofs
;
19797 if (filenames
== descend
)
19799 error (_(" Malformed note - filenames end too early\n"));
19803 start
= byte_get (descdata
, addr_size
);
19804 descdata
+= addr_size
;
19805 end
= byte_get (descdata
, addr_size
);
19806 descdata
+= addr_size
;
19807 file_ofs
= byte_get (descdata
, addr_size
);
19808 descdata
+= addr_size
;
19811 print_vma (start
, FULL_HEX
);
19813 print_vma (end
, FULL_HEX
);
19815 print_vma (file_ofs
, FULL_HEX
);
19816 printf ("\n %s\n", filenames
);
19818 filenames
+= 1 + strlen ((char *) filenames
);
19824 static const char *
19825 get_gnu_elf_note_type (unsigned e_type
)
19827 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
19830 case NT_GNU_ABI_TAG
:
19831 return _("NT_GNU_ABI_TAG (ABI version tag)");
19833 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
19834 case NT_GNU_BUILD_ID
:
19835 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
19836 case NT_GNU_GOLD_VERSION
:
19837 return _("NT_GNU_GOLD_VERSION (gold version)");
19838 case NT_GNU_PROPERTY_TYPE_0
:
19839 return _("NT_GNU_PROPERTY_TYPE_0");
19840 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
19841 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
19842 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
19843 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
19846 static char buff
[64];
19848 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19855 decode_x86_compat_isa (unsigned int bitmask
)
19859 unsigned int bit
= bitmask
& (- bitmask
);
19864 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
19867 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
19870 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
19873 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
19876 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
19879 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
19882 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
19885 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
19888 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
19891 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
19894 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
19897 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
19898 printf ("AVX512F");
19900 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
19901 printf ("AVX512CD");
19903 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
19904 printf ("AVX512ER");
19906 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
19907 printf ("AVX512PF");
19909 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
19910 printf ("AVX512VL");
19912 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
19913 printf ("AVX512DQ");
19915 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
19916 printf ("AVX512BW");
19919 printf (_("<unknown: %x>"), bit
);
19928 decode_x86_compat_2_isa (unsigned int bitmask
)
19932 printf (_("<None>"));
19938 unsigned int bit
= bitmask
& (- bitmask
);
19943 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_CMOV
:
19946 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE
:
19949 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE2
:
19952 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE3
:
19955 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSSE3
:
19958 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_1
:
19961 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_2
:
19964 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX
:
19967 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX2
:
19970 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_FMA
:
19973 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512F
:
19974 printf ("AVX512F");
19976 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512CD
:
19977 printf ("AVX512CD");
19979 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512ER
:
19980 printf ("AVX512ER");
19982 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512PF
:
19983 printf ("AVX512PF");
19985 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512VL
:
19986 printf ("AVX512VL");
19988 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512DQ
:
19989 printf ("AVX512DQ");
19991 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512BW
:
19992 printf ("AVX512BW");
19994 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4FMAPS
:
19995 printf ("AVX512_4FMAPS");
19997 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4VNNIW
:
19998 printf ("AVX512_4VNNIW");
20000 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BITALG
:
20001 printf ("AVX512_BITALG");
20003 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_IFMA
:
20004 printf ("AVX512_IFMA");
20006 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI
:
20007 printf ("AVX512_VBMI");
20009 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI2
:
20010 printf ("AVX512_VBMI2");
20012 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VNNI
:
20013 printf ("AVX512_VNNI");
20015 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BF16
:
20016 printf ("AVX512_BF16");
20019 printf (_("<unknown: %x>"), bit
);
20027 static const char *
20028 get_amdgpu_elf_note_type (unsigned int e_type
)
20032 case NT_AMDGPU_METADATA
:
20033 return _("NT_AMDGPU_METADATA (code object metadata)");
20036 static char buf
[64];
20037 snprintf (buf
, sizeof (buf
), _("Unknown note type: (0x%08x)"), e_type
);
20044 decode_x86_isa (unsigned int bitmask
)
20048 unsigned int bit
= bitmask
& (- bitmask
);
20053 case GNU_PROPERTY_X86_ISA_1_BASELINE
:
20054 printf ("x86-64-baseline");
20056 case GNU_PROPERTY_X86_ISA_1_V2
:
20057 printf ("x86-64-v2");
20059 case GNU_PROPERTY_X86_ISA_1_V3
:
20060 printf ("x86-64-v3");
20062 case GNU_PROPERTY_X86_ISA_1_V4
:
20063 printf ("x86-64-v4");
20066 printf (_("<unknown: %x>"), bit
);
20075 decode_x86_feature_1 (unsigned int bitmask
)
20079 printf (_("<None>"));
20085 unsigned int bit
= bitmask
& (- bitmask
);
20090 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
20093 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
20096 case GNU_PROPERTY_X86_FEATURE_1_LAM_U48
:
20097 printf ("LAM_U48");
20099 case GNU_PROPERTY_X86_FEATURE_1_LAM_U57
:
20100 printf ("LAM_U57");
20103 printf (_("<unknown: %x>"), bit
);
20112 decode_x86_feature_2 (unsigned int bitmask
)
20116 printf (_("<None>"));
20122 unsigned int bit
= bitmask
& (- bitmask
);
20127 case GNU_PROPERTY_X86_FEATURE_2_X86
:
20130 case GNU_PROPERTY_X86_FEATURE_2_X87
:
20133 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
20136 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
20139 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
20142 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
20145 case GNU_PROPERTY_X86_FEATURE_2_TMM
:
20148 case GNU_PROPERTY_X86_FEATURE_2_MASK
:
20151 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
20154 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
20157 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
20158 printf ("XSAVEOPT");
20160 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
20164 printf (_("<unknown: %x>"), bit
);
20173 decode_aarch64_feature_1_and (unsigned int bitmask
)
20177 unsigned int bit
= bitmask
& (- bitmask
);
20182 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
20186 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
20191 printf (_("<unknown: %x>"), bit
);
20200 decode_1_needed (unsigned int bitmask
)
20204 unsigned int bit
= bitmask
& (- bitmask
);
20209 case GNU_PROPERTY_1_NEEDED_INDIRECT_EXTERN_ACCESS
:
20210 printf ("indirect external access");
20213 printf (_("<unknown: %x>"), bit
);
20222 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
20224 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
20225 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
20226 unsigned int size
= is_32bit_elf
? 4 : 8;
20228 printf (_(" Properties: "));
20230 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
20232 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
20236 while (ptr
< ptr_end
)
20240 unsigned int datasz
;
20242 if ((size_t) (ptr_end
- ptr
) < 8)
20244 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
20248 type
= byte_get (ptr
, 4);
20249 datasz
= byte_get (ptr
+ 4, 4);
20253 if (datasz
> (size_t) (ptr_end
- ptr
))
20255 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
20260 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
20262 if (filedata
->file_header
.e_machine
== EM_X86_64
20263 || filedata
->file_header
.e_machine
== EM_IAMCU
20264 || filedata
->file_header
.e_machine
== EM_386
)
20266 unsigned int bitmask
;
20269 bitmask
= byte_get (ptr
, 4);
20275 case GNU_PROPERTY_X86_ISA_1_USED
:
20277 printf (_("x86 ISA used: <corrupt length: %#x> "),
20281 printf ("x86 ISA used: ");
20282 decode_x86_isa (bitmask
);
20286 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
20288 printf (_("x86 ISA needed: <corrupt length: %#x> "),
20292 printf ("x86 ISA needed: ");
20293 decode_x86_isa (bitmask
);
20297 case GNU_PROPERTY_X86_FEATURE_1_AND
:
20299 printf (_("x86 feature: <corrupt length: %#x> "),
20303 printf ("x86 feature: ");
20304 decode_x86_feature_1 (bitmask
);
20308 case GNU_PROPERTY_X86_FEATURE_2_USED
:
20310 printf (_("x86 feature used: <corrupt length: %#x> "),
20314 printf ("x86 feature used: ");
20315 decode_x86_feature_2 (bitmask
);
20319 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
20321 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
20324 printf ("x86 feature needed: ");
20325 decode_x86_feature_2 (bitmask
);
20329 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
20331 printf (_("x86 ISA used: <corrupt length: %#x> "),
20335 printf ("x86 ISA used: ");
20336 decode_x86_compat_isa (bitmask
);
20340 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
20342 printf (_("x86 ISA needed: <corrupt length: %#x> "),
20346 printf ("x86 ISA needed: ");
20347 decode_x86_compat_isa (bitmask
);
20351 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_USED
:
20353 printf (_("x86 ISA used: <corrupt length: %#x> "),
20357 printf ("x86 ISA used: ");
20358 decode_x86_compat_2_isa (bitmask
);
20362 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_NEEDED
:
20364 printf (_("x86 ISA needed: <corrupt length: %#x> "),
20368 printf ("x86 ISA needed: ");
20369 decode_x86_compat_2_isa (bitmask
);
20377 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
20379 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
20381 printf ("AArch64 feature: ");
20383 printf (_("<corrupt length: %#x> "), datasz
);
20385 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
20394 case GNU_PROPERTY_STACK_SIZE
:
20395 printf (_("stack size: "));
20396 if (datasz
!= size
)
20397 printf (_("<corrupt length: %#x> "), datasz
);
20399 printf ("%#" PRIx64
, byte_get (ptr
, size
));
20402 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
20403 printf ("no copy on protected ");
20405 printf (_("<corrupt length: %#x> "), datasz
);
20409 if ((type
>= GNU_PROPERTY_UINT32_AND_LO
20410 && type
<= GNU_PROPERTY_UINT32_AND_HI
)
20411 || (type
>= GNU_PROPERTY_UINT32_OR_LO
20412 && type
<= GNU_PROPERTY_UINT32_OR_HI
))
20416 case GNU_PROPERTY_1_NEEDED
:
20418 printf (_("1_needed: <corrupt length: %#x> "),
20422 unsigned int bitmask
= byte_get (ptr
, 4);
20423 printf ("1_needed: ");
20424 decode_1_needed (bitmask
);
20431 if (type
<= GNU_PROPERTY_UINT32_AND_HI
)
20432 printf (_("UINT32_AND (%#x): "), type
);
20434 printf (_("UINT32_OR (%#x): "), type
);
20436 printf (_("<corrupt length: %#x> "), datasz
);
20438 printf ("%#x", (unsigned int) byte_get (ptr
, 4));
20445 if (type
< GNU_PROPERTY_LOPROC
)
20446 printf (_("<unknown type %#x data: "), type
);
20447 else if (type
< GNU_PROPERTY_LOUSER
)
20448 printf (_("<processor-specific type %#x data: "), type
);
20450 printf (_("<application-specific type %#x data: "), type
);
20451 for (j
= 0; j
< datasz
; ++j
)
20452 printf ("%02x ", ptr
[j
] & 0xff);
20456 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
20457 if (ptr
== ptr_end
)
20470 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
20472 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
20473 switch (pnote
->type
)
20475 case NT_GNU_BUILD_ID
:
20479 printf (_(" Build ID: "));
20480 for (i
= 0; i
< pnote
->descsz
; ++i
)
20481 printf ("%02x", pnote
->descdata
[i
] & 0xff);
20486 case NT_GNU_ABI_TAG
:
20488 unsigned int os
, major
, minor
, subminor
;
20489 const char *osname
;
20491 /* PR 17531: file: 030-599401-0.004. */
20492 if (pnote
->descsz
< 16)
20494 printf (_(" <corrupt GNU_ABI_TAG>\n"));
20498 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20499 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
20500 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
20501 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
20505 case GNU_ABI_TAG_LINUX
:
20508 case GNU_ABI_TAG_HURD
:
20511 case GNU_ABI_TAG_SOLARIS
:
20512 osname
= "Solaris";
20514 case GNU_ABI_TAG_FREEBSD
:
20515 osname
= "FreeBSD";
20517 case GNU_ABI_TAG_NETBSD
:
20520 case GNU_ABI_TAG_SYLLABLE
:
20521 osname
= "Syllable";
20523 case GNU_ABI_TAG_NACL
:
20527 osname
= "Unknown";
20531 printf (_(" OS: %s, ABI: %d.%d.%d\n"), osname
,
20532 major
, minor
, subminor
);
20536 case NT_GNU_GOLD_VERSION
:
20540 printf (_(" Version: "));
20541 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
20542 printf ("%c", pnote
->descdata
[i
]);
20549 unsigned int num_entries
, mask
;
20551 /* Hardware capabilities information. Word 0 is the number of entries.
20552 Word 1 is a bitmask of enabled entries. The rest of the descriptor
20553 is a series of entries, where each entry is a single byte followed
20554 by a nul terminated string. The byte gives the bit number to test
20555 if enabled in the bitmask. */
20556 printf (_(" Hardware Capabilities: "));
20557 if (pnote
->descsz
< 8)
20559 error (_("<corrupt GNU_HWCAP>\n"));
20562 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20563 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
20564 printf (_("num entries: %d, enabled mask: %x\n"), num_entries
, mask
);
20565 /* FIXME: Add code to display the entries... */
20569 case NT_GNU_PROPERTY_TYPE_0
:
20570 print_gnu_property_note (filedata
, pnote
);
20574 /* Handle unrecognised types. An error message should have already been
20575 created by get_gnu_elf_note_type(), so all that we need to do is to
20576 display the data. */
20580 printf (_(" Description data: "));
20581 for (i
= 0; i
< pnote
->descsz
; ++i
)
20582 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
20591 static const char *
20592 get_v850_elf_note_type (enum v850_notes n_type
)
20594 static char buff
[64];
20598 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
20599 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
20600 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
20601 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
20602 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
20603 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
20605 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
20611 print_v850_note (Elf_Internal_Note
* pnote
)
20615 if (pnote
->descsz
!= 4)
20618 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
20622 printf (_("not set\n"));
20626 switch (pnote
->type
)
20628 case V850_NOTE_ALIGNMENT
:
20631 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return true;
20632 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return true;
20636 case V850_NOTE_DATA_SIZE
:
20639 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return true;
20640 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return true;
20644 case V850_NOTE_FPU_INFO
:
20647 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return true;
20648 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return true;
20652 case V850_NOTE_MMU_INFO
:
20653 case V850_NOTE_CACHE_INFO
:
20654 case V850_NOTE_SIMD_INFO
:
20655 if (val
== EF_RH850_SIMD
)
20657 printf (_("yes\n"));
20663 /* An 'unknown note type' message will already have been displayed. */
20667 printf (_("unknown value: %x\n"), val
);
20672 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
20674 unsigned int version
;
20676 switch (pnote
->type
)
20678 case NT_NETBSD_IDENT
:
20679 if (pnote
->descsz
< 1)
20681 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
20682 if ((version
/ 10000) % 100)
20683 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
20684 version
, version
/ 100000000, (version
/ 1000000) % 100,
20685 (version
/ 10000) % 100 > 26 ? "Z" : "",
20686 'A' + (version
/ 10000) % 26);
20688 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
20689 version
, version
/ 100000000, (version
/ 1000000) % 100,
20690 (version
/ 100) % 100);
20693 case NT_NETBSD_MARCH
:
20694 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
20698 case NT_NETBSD_PAX
:
20699 if (pnote
->descsz
< 1)
20701 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
20702 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
20703 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
20704 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
20705 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
20706 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
20707 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
20708 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
20712 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
20713 pnote
->descsz
, pnote
->type
);
20717 static const char *
20718 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
20722 case NT_FREEBSD_THRMISC
:
20723 return _("NT_THRMISC (thrmisc structure)");
20724 case NT_FREEBSD_PROCSTAT_PROC
:
20725 return _("NT_PROCSTAT_PROC (proc data)");
20726 case NT_FREEBSD_PROCSTAT_FILES
:
20727 return _("NT_PROCSTAT_FILES (files data)");
20728 case NT_FREEBSD_PROCSTAT_VMMAP
:
20729 return _("NT_PROCSTAT_VMMAP (vmmap data)");
20730 case NT_FREEBSD_PROCSTAT_GROUPS
:
20731 return _("NT_PROCSTAT_GROUPS (groups data)");
20732 case NT_FREEBSD_PROCSTAT_UMASK
:
20733 return _("NT_PROCSTAT_UMASK (umask data)");
20734 case NT_FREEBSD_PROCSTAT_RLIMIT
:
20735 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
20736 case NT_FREEBSD_PROCSTAT_OSREL
:
20737 return _("NT_PROCSTAT_OSREL (osreldate data)");
20738 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
20739 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
20740 case NT_FREEBSD_PROCSTAT_AUXV
:
20741 return _("NT_PROCSTAT_AUXV (auxv data)");
20742 case NT_FREEBSD_PTLWPINFO
:
20743 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
20744 case NT_FREEBSD_X86_SEGBASES
:
20745 return _("NT_X86_SEGBASES (x86 segment base registers)");
20747 return get_note_type (filedata
, e_type
);
20750 static const char *
20751 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
20753 static char buff
[64];
20757 case NT_NETBSDCORE_PROCINFO
:
20758 /* NetBSD core "procinfo" structure. */
20759 return _("NetBSD procinfo structure");
20761 case NT_NETBSDCORE_AUXV
:
20762 return _("NetBSD ELF auxiliary vector data");
20764 case NT_NETBSDCORE_LWPSTATUS
:
20765 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
20768 /* As of Jan 2020 there are no other machine-independent notes
20769 defined for NetBSD core files. If the note type is less
20770 than the start of the machine-dependent note types, we don't
20773 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
20775 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
20781 switch (filedata
->file_header
.e_machine
)
20783 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
20784 and PT_GETFPREGS == mach+2. */
20789 case EM_SPARC32PLUS
:
20793 case NT_NETBSDCORE_FIRSTMACH
+ 0:
20794 return _("PT_GETREGS (reg structure)");
20795 case NT_NETBSDCORE_FIRSTMACH
+ 2:
20796 return _("PT_GETFPREGS (fpreg structure)");
20802 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
20803 There's also old PT___GETREGS40 == mach + 1 for old reg
20804 structure which lacks GBR. */
20808 case NT_NETBSDCORE_FIRSTMACH
+ 1:
20809 return _("PT___GETREGS40 (old reg structure)");
20810 case NT_NETBSDCORE_FIRSTMACH
+ 3:
20811 return _("PT_GETREGS (reg structure)");
20812 case NT_NETBSDCORE_FIRSTMACH
+ 5:
20813 return _("PT_GETFPREGS (fpreg structure)");
20819 /* On all other arch's, PT_GETREGS == mach+1 and
20820 PT_GETFPREGS == mach+3. */
20824 case NT_NETBSDCORE_FIRSTMACH
+ 1:
20825 return _("PT_GETREGS (reg structure)");
20826 case NT_NETBSDCORE_FIRSTMACH
+ 3:
20827 return _("PT_GETFPREGS (fpreg structure)");
20833 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
20834 e_type
- NT_NETBSDCORE_FIRSTMACH
);
20838 static const char *
20839 get_openbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
20843 case NT_OPENBSD_PROCINFO
:
20844 return _("OpenBSD procinfo structure");
20845 case NT_OPENBSD_AUXV
:
20846 return _("OpenBSD ELF auxiliary vector data");
20847 case NT_OPENBSD_REGS
:
20848 return _("OpenBSD regular registers");
20849 case NT_OPENBSD_FPREGS
:
20850 return _("OpenBSD floating point registers");
20851 case NT_OPENBSD_WCOOKIE
:
20852 return _("OpenBSD window cookie");
20855 return get_note_type (filedata
, e_type
);
20858 static const char *
20859 get_qnx_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
20863 case QNT_DEBUG_FULLPATH
:
20864 return _("QNX debug fullpath");
20865 case QNT_DEBUG_RELOC
:
20866 return _("QNX debug relocation");
20868 return _("QNX stack");
20869 case QNT_GENERATOR
:
20870 return _("QNX generator");
20871 case QNT_DEFAULT_LIB
:
20872 return _("QNX default library");
20873 case QNT_CORE_SYSINFO
:
20874 return _("QNX core sysinfo");
20875 case QNT_CORE_INFO
:
20876 return _("QNX core info");
20877 case QNT_CORE_STATUS
:
20878 return _("QNX core status");
20879 case QNT_CORE_GREG
:
20880 return _("QNX general registers");
20881 case QNT_CORE_FPREG
:
20882 return _("QNX floating point registers");
20884 return _("QNX link map");
20887 return get_note_type (filedata
, e_type
);
20890 static const char *
20891 get_stapsdt_note_type (unsigned e_type
)
20893 static char buff
[64];
20898 return _("NT_STAPSDT (SystemTap probe descriptors)");
20904 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
20909 print_stapsdt_note (Elf_Internal_Note
*pnote
)
20911 size_t len
, maxlen
;
20912 size_t addr_size
= is_32bit_elf
? 4 : 8;
20913 char *data
= pnote
->descdata
;
20914 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
20915 uint64_t pc
, base_addr
, semaphore
;
20916 char *provider
, *probe
, *arg_fmt
;
20918 if (pnote
->descsz
< (addr_size
* 3))
20919 goto stapdt_note_too_small
;
20921 pc
= byte_get ((unsigned char *) data
, addr_size
);
20924 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
20927 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
20930 if (data
>= data_end
)
20931 goto stapdt_note_too_small
;
20932 maxlen
= data_end
- data
;
20933 len
= strnlen (data
, maxlen
);
20940 goto stapdt_note_too_small
;
20942 if (data
>= data_end
)
20943 goto stapdt_note_too_small
;
20944 maxlen
= data_end
- data
;
20945 len
= strnlen (data
, maxlen
);
20952 goto stapdt_note_too_small
;
20954 if (data
>= data_end
)
20955 goto stapdt_note_too_small
;
20956 maxlen
= data_end
- data
;
20957 len
= strnlen (data
, maxlen
);
20964 goto stapdt_note_too_small
;
20966 printf (_(" Provider: %s\n"), provider
);
20967 printf (_(" Name: %s\n"), probe
);
20968 printf (_(" Location: "));
20969 print_vma (pc
, FULL_HEX
);
20970 printf (_(", Base: "));
20971 print_vma (base_addr
, FULL_HEX
);
20972 printf (_(", Semaphore: "));
20973 print_vma (semaphore
, FULL_HEX
);
20975 printf (_(" Arguments: %s\n"), arg_fmt
);
20977 return data
== data_end
;
20979 stapdt_note_too_small
:
20980 printf (_(" <corrupt - note is too small>\n"));
20981 error (_("corrupt stapdt note - the data size is too small\n"));
20986 print_fdo_note (Elf_Internal_Note
* pnote
)
20988 if (pnote
->descsz
> 0 && pnote
->type
== FDO_PACKAGING_METADATA
)
20990 printf (_(" Packaging Metadata: %.*s\n"), (int) pnote
->descsz
, pnote
->descdata
);
20996 static const char *
20997 get_ia64_vms_note_type (unsigned e_type
)
20999 static char buff
[64];
21004 return _("NT_VMS_MHD (module header)");
21006 return _("NT_VMS_LNM (language name)");
21008 return _("NT_VMS_SRC (source files)");
21010 return "NT_VMS_TITLE";
21012 return _("NT_VMS_EIDC (consistency check)");
21013 case NT_VMS_FPMODE
:
21014 return _("NT_VMS_FPMODE (FP mode)");
21015 case NT_VMS_LINKTIME
:
21016 return "NT_VMS_LINKTIME";
21017 case NT_VMS_IMGNAM
:
21018 return _("NT_VMS_IMGNAM (image name)");
21020 return _("NT_VMS_IMGID (image id)");
21021 case NT_VMS_LINKID
:
21022 return _("NT_VMS_LINKID (link id)");
21023 case NT_VMS_IMGBID
:
21024 return _("NT_VMS_IMGBID (build id)");
21025 case NT_VMS_GSTNAM
:
21026 return _("NT_VMS_GSTNAM (sym table name)");
21027 case NT_VMS_ORIG_DYN
:
21028 return "NT_VMS_ORIG_DYN";
21029 case NT_VMS_PATCHTIME
:
21030 return "NT_VMS_PATCHTIME";
21032 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
21038 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
21040 unsigned int maxlen
= pnote
->descsz
;
21042 if (maxlen
< 2 || maxlen
!= pnote
->descsz
)
21043 goto desc_size_fail
;
21045 switch (pnote
->type
)
21049 goto desc_size_fail
;
21051 size_t l
= strnlen (pnote
->descdata
+ 34, maxlen
- 34);
21053 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
21054 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
21055 if (l
+ 34 < maxlen
)
21057 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
21058 if (l
+ 35 < maxlen
)
21059 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
21061 printf (_(" Module version : <missing>\n"));
21065 printf (_(" Module name : <missing>\n"));
21066 printf (_(" Module version : <missing>\n"));
21071 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
21074 case NT_VMS_FPMODE
:
21075 printf (_(" Floating Point mode: "));
21077 goto desc_size_fail
;
21078 /* FIXME: Generate an error if descsz > 8 ? */
21080 printf ("0x%016" PRIx64
"\n",
21081 byte_get ((unsigned char *) pnote
->descdata
, 8));
21084 case NT_VMS_LINKTIME
:
21085 printf (_(" Link time: "));
21087 goto desc_size_fail
;
21088 /* FIXME: Generate an error if descsz > 8 ? */
21090 print_vms_time (byte_get ((unsigned char *) pnote
->descdata
, 8));
21094 case NT_VMS_PATCHTIME
:
21095 printf (_(" Patch time: "));
21097 goto desc_size_fail
;
21098 /* FIXME: Generate an error if descsz > 8 ? */
21100 print_vms_time (byte_get ((unsigned char *) pnote
->descdata
, 8));
21104 case NT_VMS_ORIG_DYN
:
21106 goto desc_size_fail
;
21108 printf (_(" Major id: %u, minor id: %u\n"),
21109 (unsigned) byte_get ((unsigned char *) pnote
->descdata
, 4),
21110 (unsigned) byte_get ((unsigned char *) pnote
->descdata
+ 4, 4));
21111 printf (_(" Last modified : "));
21112 print_vms_time (byte_get ((unsigned char *) pnote
->descdata
+ 8, 8));
21113 printf (_("\n Link flags : "));
21114 printf ("0x%016" PRIx64
"\n",
21115 byte_get ((unsigned char *) pnote
->descdata
+ 16, 8));
21116 printf (_(" Header flags: 0x%08x\n"),
21117 (unsigned) byte_get ((unsigned char *) pnote
->descdata
+ 24, 4));
21118 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
21121 case NT_VMS_IMGNAM
:
21122 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
21125 case NT_VMS_GSTNAM
:
21126 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
21130 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
21133 case NT_VMS_LINKID
:
21134 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
21144 printf (_(" <corrupt - data size is too small>\n"));
21145 error (_("corrupt IA64 note: data size is too small\n"));
21149 struct build_attr_cache
{
21150 Filedata
*filedata
;
21152 uint64_t strtablen
;
21153 Elf_Internal_Sym
*symtab
;
21157 /* Find the symbol associated with a build attribute that is attached
21158 to address OFFSET. If PNAME is non-NULL then store the name of
21159 the symbol (if found) in the provided pointer, Returns NULL if a
21160 symbol could not be found. */
21162 static Elf_Internal_Sym
*
21163 get_symbol_for_build_attribute (Filedata
*filedata
,
21166 const char **pname
)
21168 Elf_Internal_Sym
*saved_sym
= NULL
;
21169 Elf_Internal_Sym
*sym
;
21171 if (filedata
->section_headers
!= NULL
21172 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
21174 Elf_Internal_Shdr
* symsec
;
21176 free (ba_cache
.strtab
);
21177 ba_cache
.strtab
= NULL
;
21178 free (ba_cache
.symtab
);
21179 ba_cache
.symtab
= NULL
;
21181 /* Load the symbol and string sections. */
21182 for (symsec
= filedata
->section_headers
;
21183 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
21186 if (symsec
->sh_type
== SHT_SYMTAB
21187 && get_symtab (filedata
, symsec
,
21188 &ba_cache
.symtab
, &ba_cache
.nsyms
,
21189 &ba_cache
.strtab
, &ba_cache
.strtablen
))
21192 ba_cache
.filedata
= filedata
;
21195 if (ba_cache
.symtab
== NULL
)
21198 /* Find a symbol whose value matches offset. */
21199 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
21200 if (sym
->st_value
== offset
)
21202 if (sym
->st_name
>= ba_cache
.strtablen
)
21203 /* Huh ? This should not happen. */
21206 if (ba_cache
.strtab
[sym
->st_name
] == 0)
21209 /* The AArch64, ARM and RISC-V architectures define mapping symbols
21210 (eg $d, $x, $t) which we want to ignore. */
21211 if (ba_cache
.strtab
[sym
->st_name
] == '$'
21212 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
21213 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
21218 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
21219 and FILE or OBJECT symbols over NOTYPE symbols. We skip
21220 FUNC symbols entirely. */
21221 switch (ELF_ST_TYPE (sym
->st_info
))
21228 /* If the symbol has a size associated
21229 with it then we can stop searching. */
21230 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
21235 /* Ignore function symbols. */
21242 switch (ELF_ST_BIND (sym
->st_info
))
21245 if (saved_sym
== NULL
21246 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
21251 if (saved_sym
== NULL
)
21261 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
21269 if (saved_sym
&& pname
)
21270 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
21275 /* Returns true iff addr1 and addr2 are in the same section. */
21278 same_section (Filedata
* filedata
, uint64_t addr1
, uint64_t addr2
)
21280 Elf_Internal_Shdr
* a1
;
21281 Elf_Internal_Shdr
* a2
;
21283 a1
= find_section_by_address (filedata
, addr1
);
21284 a2
= find_section_by_address (filedata
, addr2
);
21286 return a1
== a2
&& a1
!= NULL
;
21290 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
21291 Filedata
* filedata
)
21293 static uint64_t global_offset
= 0;
21294 static uint64_t global_end
= 0;
21295 static uint64_t func_offset
= 0;
21296 static uint64_t func_end
= 0;
21298 Elf_Internal_Sym
*sym
;
21302 bool is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
21304 switch (pnote
->descsz
)
21307 /* A zero-length description means that the range of
21308 the previous note of the same type should be used. */
21311 if (global_end
> global_offset
)
21312 printf (_(" Applies to region from %#" PRIx64
21313 " to %#" PRIx64
"\n"), global_offset
, global_end
);
21315 printf (_(" Applies to region from %#" PRIx64
21316 "\n"), global_offset
);
21320 if (func_end
> func_offset
)
21321 printf (_(" Applies to region from %#" PRIx64
21322 " to %#" PRIx64
"\n"), func_offset
, func_end
);
21324 printf (_(" Applies to region from %#" PRIx64
21325 "\n"), func_offset
);
21330 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
21335 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
21336 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
21340 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
21341 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
21345 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
21346 printf (_(" <invalid descsz>"));
21351 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
21352 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
21353 in order to avoid them being confused with the start address of the
21354 first function in the file... */
21355 if (sym
== NULL
&& is_open_attr
)
21356 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
21359 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
21360 end
= start
+ sym
->st_size
;
21364 /* FIXME: Need to properly allow for section alignment.
21365 16 is just the alignment used on x86_64. */
21367 && start
> BFD_ALIGN (global_end
, 16)
21368 /* Build notes are not guaranteed to be organised in order of
21369 increasing address, but we should find the all of the notes
21370 for one section in the same place. */
21371 && same_section (filedata
, start
, global_end
))
21372 warn (_("Gap in build notes detected from %#" PRIx64
21373 " to %#" PRIx64
"\n"),
21374 global_end
+ 1, start
- 1);
21376 printf (_(" Applies to region from %#" PRIx64
), start
);
21377 global_offset
= start
;
21381 printf (_(" to %#" PRIx64
), end
);
21387 printf (_(" Applies to region from %#" PRIx64
), start
);
21388 func_offset
= start
;
21392 printf (_(" to %#" PRIx64
), end
);
21398 printf (_(" (%s)"), name
);
21405 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
21407 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
21408 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
21409 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
21411 char name_attribute
;
21412 const char * expected_types
;
21413 const char * name
= pnote
->namedata
;
21417 if (name
== NULL
|| pnote
->namesz
< 2)
21419 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
21420 print_symbol (-20, _(" <corrupt name>"));
21429 /* Version 2 of the spec adds a "GA" prefix to the name field. */
21430 if (name
[0] == 'G' && name
[1] == 'A')
21432 if (pnote
->namesz
< 4)
21434 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
21435 print_symbol (-20, _(" <corrupt name>"));
21444 switch ((name_type
= * name
))
21446 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
21447 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
21448 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
21449 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
21450 printf ("%c", * name
);
21454 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
21455 print_symbol (-20, _("<unknown name type>"));
21462 switch ((name_attribute
= * name
))
21464 case GNU_BUILD_ATTRIBUTE_VERSION
:
21465 text
= _("<version>");
21466 expected_types
= string_expected
;
21469 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
21470 text
= _("<stack prot>");
21471 expected_types
= "!+*";
21474 case GNU_BUILD_ATTRIBUTE_RELRO
:
21475 text
= _("<relro>");
21476 expected_types
= bool_expected
;
21479 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
21480 text
= _("<stack size>");
21481 expected_types
= number_expected
;
21484 case GNU_BUILD_ATTRIBUTE_TOOL
:
21485 text
= _("<tool>");
21486 expected_types
= string_expected
;
21489 case GNU_BUILD_ATTRIBUTE_ABI
:
21491 expected_types
= "$*";
21494 case GNU_BUILD_ATTRIBUTE_PIC
:
21496 expected_types
= number_expected
;
21499 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
21500 text
= _("<short enum>");
21501 expected_types
= bool_expected
;
21505 if (ISPRINT (* name
))
21507 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
21509 if (len
> left
&& ! do_wide
)
21511 printf ("%.*s:", len
, name
);
21517 static char tmpbuf
[128];
21519 error (_("unrecognised byte in name field: %d\n"), * name
);
21520 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
21524 expected_types
= "*$!+";
21529 left
-= printf ("%s", text
);
21531 if (strchr (expected_types
, name_type
) == NULL
)
21532 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
21534 if ((size_t) (name
- pnote
->namedata
) > pnote
->namesz
)
21536 error (_("corrupt name field: namesz: %lu but parsing gets to %td\n"),
21538 name
- pnote
->namedata
);
21542 if (left
< 1 && ! do_wide
)
21547 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
21549 unsigned int bytes
;
21551 unsigned int shift
= 0;
21552 char *decoded
= NULL
;
21554 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
21556 /* The -1 is because the name field is always 0 terminated, and we
21557 want to be able to ensure that the shift in the while loop below
21558 will not overflow. */
21561 if (bytes
> sizeof (val
))
21563 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
21565 bytes
= sizeof (val
);
21567 /* We do not bother to warn if bytes == 0 as this can
21568 happen with some early versions of the gcc plugin. */
21572 uint64_t byte
= *name
++ & 0xff;
21574 val
|= byte
<< shift
;
21578 switch (name_attribute
)
21580 case GNU_BUILD_ATTRIBUTE_PIC
:
21583 case 0: decoded
= "static"; break;
21584 case 1: decoded
= "pic"; break;
21585 case 2: decoded
= "PIC"; break;
21586 case 3: decoded
= "pie"; break;
21587 case 4: decoded
= "PIE"; break;
21591 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
21594 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
21595 case 0: decoded
= "off"; break;
21596 case 1: decoded
= "on"; break;
21597 case 2: decoded
= "all"; break;
21598 case 3: decoded
= "strong"; break;
21599 case 4: decoded
= "explicit"; break;
21607 if (decoded
!= NULL
)
21609 print_symbol (-left
, decoded
);
21620 left
-= printf ("0x%" PRIx64
, val
);
21622 left
-= printf ("0x%-.*" PRIx64
, left
, val
);
21626 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
21627 left
-= print_symbol (- left
, name
);
21629 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
21630 left
-= print_symbol (- left
, "true");
21632 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
21633 left
-= print_symbol (- left
, "false");
21637 if (do_wide
&& left
> 0)
21638 printf ("%-*s", left
, " ");
21643 /* Print the contents of PNOTE as hex. */
21646 print_note_contents_hex (Elf_Internal_Note
*pnote
)
21652 printf (_(" description data: "));
21653 for (i
= 0; i
< pnote
->descsz
; i
++)
21654 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
21663 #if defined HAVE_MSGPACK
21666 print_indents (int n
)
21670 for (int i
= 0; i
< n
; i
++)
21674 /* Print OBJ in human-readable form. */
21677 dump_msgpack_obj (const msgpack_object
*obj
, int indent
)
21681 case MSGPACK_OBJECT_NIL
:
21685 case MSGPACK_OBJECT_BOOLEAN
:
21686 printf ("%s", obj
->via
.boolean
? "true" : "false");
21689 case MSGPACK_OBJECT_POSITIVE_INTEGER
:
21690 printf ("%" PRIu64
, obj
->via
.u64
);
21693 case MSGPACK_OBJECT_NEGATIVE_INTEGER
:
21694 printf ("%" PRIi64
, obj
->via
.i64
);
21697 case MSGPACK_OBJECT_FLOAT32
:
21698 case MSGPACK_OBJECT_FLOAT64
:
21699 printf ("%f", obj
->via
.f64
);
21702 case MSGPACK_OBJECT_STR
:
21703 printf ("\"%.*s\"", obj
->via
.str
.size
, obj
->via
.str
.ptr
);
21706 case MSGPACK_OBJECT_ARRAY
:
21708 const msgpack_object_array
*array
= &obj
->via
.array
;
21713 for (uint32_t i
= 0; i
< array
->size
; ++i
)
21715 const msgpack_object
*item
= &array
->ptr
[i
];
21717 print_indents (indent
);
21718 dump_msgpack_obj (item
, indent
);
21723 print_indents (indent
);
21729 case MSGPACK_OBJECT_MAP
:
21731 const msgpack_object_map
*map
= &obj
->via
.map
;
21736 for (uint32_t i
= 0; i
< map
->size
; ++i
)
21738 const msgpack_object_kv
*kv
= &map
->ptr
[i
];
21739 const msgpack_object
*key
= &kv
->key
;
21740 const msgpack_object
*val
= &kv
->val
;
21742 print_indents (indent
);
21743 dump_msgpack_obj (key
, indent
);
21745 dump_msgpack_obj (val
, indent
);
21751 print_indents (indent
);
21757 case MSGPACK_OBJECT_BIN
:
21761 case MSGPACK_OBJECT_EXT
:
21768 dump_msgpack (const msgpack_unpacked
*msg
)
21771 dump_msgpack_obj (&msg
->data
, 0);
21775 #endif /* defined HAVE_MSGPACK */
21778 print_amdgpu_note (Elf_Internal_Note
*pnote
)
21780 #if defined HAVE_MSGPACK
21781 /* If msgpack is available, decode and dump the note's content. */
21783 msgpack_unpacked msg
;
21784 msgpack_unpack_return msgpack_ret
;
21786 assert (pnote
->type
== NT_AMDGPU_METADATA
);
21788 msgpack_unpacked_init (&msg
);
21789 msgpack_ret
= msgpack_unpack_next (&msg
, pnote
->descdata
, pnote
->descsz
,
21792 switch (msgpack_ret
)
21794 case MSGPACK_UNPACK_SUCCESS
:
21795 dump_msgpack (&msg
);
21800 error (_("failed to unpack msgpack contents in NT_AMDGPU_METADATA note"));
21805 msgpack_unpacked_destroy (&msg
);
21808 /* msgpack is not available, dump contents as hex. */
21809 print_note_contents_hex (pnote
);
21815 print_qnx_note (Elf_Internal_Note
*pnote
)
21817 switch (pnote
->type
)
21820 if (pnote
->descsz
!= 12)
21821 goto desc_size_fail
;
21823 printf (_(" Stack Size: 0x%" PRIx32
"\n"),
21824 (unsigned) byte_get ((unsigned char *) pnote
->descdata
, 4));
21825 printf (_(" Stack allocated: %" PRIx32
"\n"),
21826 (unsigned) byte_get ((unsigned char *) pnote
->descdata
+ 4, 4));
21827 printf (_(" Executable: %s\n"),
21828 ((unsigned) byte_get ((unsigned char *) pnote
->descdata
+ 8, 1)) ? "no": "yes");
21832 print_note_contents_hex(pnote
);
21837 printf (_(" <corrupt - data size is too small>\n"));
21838 error (_("corrupt QNX note: data size is too small\n"));
21843 /* Note that by the ELF standard, the name field is already null byte
21844 terminated, and namesz includes the terminating null byte.
21845 I.E. the value of namesz for the name "FSF" is 4.
21847 If the value of namesz is zero, there is no name present. */
21850 process_note (Elf_Internal_Note
* pnote
,
21851 Filedata
* filedata
)
21853 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
21856 if (pnote
->namesz
== 0)
21857 /* If there is no note name, then use the default set of
21858 note type strings. */
21859 nt
= get_note_type (filedata
, pnote
->type
);
21861 else if (startswith (pnote
->namedata
, "GNU"))
21862 /* GNU-specific object file notes. */
21863 nt
= get_gnu_elf_note_type (pnote
->type
);
21865 else if (startswith (pnote
->namedata
, "AMDGPU"))
21866 /* AMDGPU-specific object file notes. */
21867 nt
= get_amdgpu_elf_note_type (pnote
->type
);
21869 else if (startswith (pnote
->namedata
, "FreeBSD"))
21870 /* FreeBSD-specific core file notes. */
21871 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
21873 else if (startswith (pnote
->namedata
, "NetBSD-CORE"))
21874 /* NetBSD-specific core file notes. */
21875 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
21877 else if (startswith (pnote
->namedata
, "NetBSD"))
21878 /* NetBSD-specific core file notes. */
21879 return process_netbsd_elf_note (pnote
);
21881 else if (startswith (pnote
->namedata
, "PaX"))
21882 /* NetBSD-specific core file notes. */
21883 return process_netbsd_elf_note (pnote
);
21885 else if (startswith (pnote
->namedata
, "OpenBSD"))
21886 /* OpenBSD-specific core file notes. */
21887 nt
= get_openbsd_elfcore_note_type (filedata
, pnote
->type
);
21889 else if (startswith (pnote
->namedata
, "QNX"))
21890 /* QNX-specific core file notes. */
21891 nt
= get_qnx_elfcore_note_type (filedata
, pnote
->type
);
21893 else if (startswith (pnote
->namedata
, "SPU/"))
21895 /* SPU-specific core file notes. */
21896 nt
= pnote
->namedata
+ 4;
21900 else if (startswith (pnote
->namedata
, "IPF/VMS"))
21901 /* VMS/ia64-specific file notes. */
21902 nt
= get_ia64_vms_note_type (pnote
->type
);
21904 else if (startswith (pnote
->namedata
, "stapsdt"))
21905 nt
= get_stapsdt_note_type (pnote
->type
);
21908 /* Don't recognize this note name; just use the default set of
21909 note type strings. */
21910 nt
= get_note_type (filedata
, pnote
->type
);
21914 if (((startswith (pnote
->namedata
, "GA")
21915 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
21916 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
21917 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
21918 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
21919 print_gnu_build_attribute_name (pnote
);
21921 print_symbol (-20, name
);
21924 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
21926 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
21928 if (startswith (pnote
->namedata
, "IPF/VMS"))
21929 return print_ia64_vms_note (pnote
);
21930 else if (startswith (pnote
->namedata
, "GNU"))
21931 return print_gnu_note (filedata
, pnote
);
21932 else if (startswith (pnote
->namedata
, "stapsdt"))
21933 return print_stapsdt_note (pnote
);
21934 else if (startswith (pnote
->namedata
, "CORE"))
21935 return print_core_note (pnote
);
21936 else if (startswith (pnote
->namedata
, "FDO"))
21937 return print_fdo_note (pnote
);
21938 else if (((startswith (pnote
->namedata
, "GA")
21939 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
21940 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
21941 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
21942 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
21943 return print_gnu_build_attribute_description (pnote
, filedata
);
21944 else if (startswith (pnote
->namedata
, "AMDGPU")
21945 && pnote
->type
== NT_AMDGPU_METADATA
)
21946 return print_amdgpu_note (pnote
);
21947 else if (startswith (pnote
->namedata
, "QNX"))
21948 return print_qnx_note (pnote
);
21950 print_note_contents_hex (pnote
);
21955 process_notes_at (Filedata
* filedata
,
21956 Elf_Internal_Shdr
* section
,
21961 Elf_External_Note
*pnotes
;
21962 Elf_External_Note
*external
;
21971 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
21974 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
21982 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
21985 if (pnotes
== NULL
)
21990 if (filedata
->is_separate
)
21991 printf (_("In linked file '%s': "), filedata
->file_name
);
21995 printf (_("Displaying notes found in: %s\n"), printable_section_name (filedata
, section
));
21997 printf (_("Displaying notes found at file offset 0x%08" PRIx64
21998 " with length 0x%08" PRIx64
":\n"),
22001 /* NB: Some note sections may have alignment value of 0 or 1. gABI
22002 specifies that notes should be aligned to 4 bytes in 32-bit
22003 objects and to 8 bytes in 64-bit objects. As a Linux extension,
22004 we also support 4 byte alignment in 64-bit objects. If section
22005 alignment is less than 4, we treate alignment as 4 bytes. */
22008 else if (align
!= 4 && align
!= 8)
22010 warn (_("Corrupt note: alignment %" PRId64
", expecting 4 or 8\n"),
22016 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
22018 end
= (char *) pnotes
+ length
;
22019 while ((char *) external
< end
)
22021 Elf_Internal_Note inote
;
22024 char * temp
= NULL
;
22025 size_t data_remaining
= end
- (char *) external
;
22027 if (!is_ia64_vms (filedata
))
22029 /* PR binutils/15191
22030 Make sure that there is enough data to read. */
22031 min_notesz
= offsetof (Elf_External_Note
, name
);
22032 if (data_remaining
< min_notesz
)
22034 warn (ngettext ("Corrupt note: only %zd byte remains, "
22035 "not enough for a full note\n",
22036 "Corrupt note: only %zd bytes remain, "
22037 "not enough for a full note\n",
22042 data_remaining
-= min_notesz
;
22044 inote
.type
= BYTE_GET (external
->type
);
22045 inote
.namesz
= BYTE_GET (external
->namesz
);
22046 inote
.namedata
= external
->name
;
22047 inote
.descsz
= BYTE_GET (external
->descsz
);
22048 inote
.descdata
= ((char *) external
22049 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
22050 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
22051 next
= ((char *) external
22052 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
22056 Elf64_External_VMS_Note
*vms_external
;
22058 /* PR binutils/15191
22059 Make sure that there is enough data to read. */
22060 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
22061 if (data_remaining
< min_notesz
)
22063 warn (ngettext ("Corrupt note: only %zd byte remains, "
22064 "not enough for a full note\n",
22065 "Corrupt note: only %zd bytes remain, "
22066 "not enough for a full note\n",
22071 data_remaining
-= min_notesz
;
22073 vms_external
= (Elf64_External_VMS_Note
*) external
;
22074 inote
.type
= BYTE_GET (vms_external
->type
);
22075 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
22076 inote
.namedata
= vms_external
->name
;
22077 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
22078 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
22079 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
22080 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
22083 /* PR 17531: file: 3443835e. */
22084 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
22085 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
22086 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
22087 || (size_t) (next
- inote
.descdata
) < inote
.descsz
22088 || ((size_t) (next
- inote
.descdata
)
22089 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
22091 warn (_("note with invalid namesz and/or descsz found at offset %#tx\n"),
22092 (char *) external
- (char *) pnotes
);
22093 warn (_(" type: %#lx, namesize: %#lx, descsize: %#lx, alignment: %u\n"),
22094 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
22098 external
= (Elf_External_Note
*) next
;
22100 /* Verify that name is null terminated. It appears that at least
22101 one version of Linux (RedHat 6.0) generates corefiles that don't
22102 comply with the ELF spec by failing to include the null byte in
22104 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
22106 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
22108 temp
= (char *) malloc (inote
.namesz
+ 1);
22111 error (_("Out of memory allocating space for inote name\n"));
22116 memcpy (temp
, inote
.namedata
, inote
.namesz
);
22117 inote
.namedata
= temp
;
22119 inote
.namedata
[inote
.namesz
] = 0;
22122 if (! process_note (& inote
, filedata
))
22135 process_corefile_note_segments (Filedata
* filedata
)
22137 Elf_Internal_Phdr
*segment
;
22141 if (! get_program_headers (filedata
))
22144 for (i
= 0, segment
= filedata
->program_headers
;
22145 i
< filedata
->file_header
.e_phnum
;
22148 if (segment
->p_type
== PT_NOTE
)
22149 if (! process_notes_at (filedata
, NULL
, segment
->p_offset
,
22150 segment
->p_filesz
, segment
->p_align
))
22158 process_v850_notes (Filedata
* filedata
, uint64_t offset
, uint64_t length
)
22160 Elf_External_Note
* pnotes
;
22161 Elf_External_Note
* external
;
22168 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
22170 if (pnotes
== NULL
)
22174 end
= (char*) pnotes
+ length
;
22176 printf (_("\nDisplaying contents of Renesas V850 notes section at offset"
22177 " %#" PRIx64
" with length %#" PRIx64
":\n"),
22180 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
22182 Elf_External_Note
* next
;
22183 Elf_Internal_Note inote
;
22185 inote
.type
= BYTE_GET (external
->type
);
22186 inote
.namesz
= BYTE_GET (external
->namesz
);
22187 inote
.namedata
= external
->name
;
22188 inote
.descsz
= BYTE_GET (external
->descsz
);
22189 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
22190 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
22192 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
22194 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
22195 inote
.descdata
= inote
.namedata
;
22199 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
22201 if ( ((char *) next
> end
)
22202 || ((char *) next
< (char *) pnotes
))
22204 warn (_("corrupt descsz found in note at offset %#tx\n"),
22205 (char *) external
- (char *) pnotes
);
22206 warn (_(" type: %#lx, namesize: %#lx, descsize: %#lx\n"),
22207 inote
.type
, inote
.namesz
, inote
.descsz
);
22213 /* Prevent out-of-bounds indexing. */
22214 if ( inote
.namedata
+ inote
.namesz
> end
22215 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
22217 warn (_("corrupt namesz found in note at offset %#zx\n"),
22218 (char *) external
- (char *) pnotes
);
22219 warn (_(" type: %#lx, namesize: %#lx, descsize: %#lx\n"),
22220 inote
.type
, inote
.namesz
, inote
.descsz
);
22224 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
22226 if (! print_v850_note (& inote
))
22229 printf ("<corrupt sizes: namesz: %#lx, descsz: %#lx>\n",
22230 inote
.namesz
, inote
.descsz
);
22240 process_note_sections (Filedata
* filedata
)
22242 Elf_Internal_Shdr
*section
;
22244 unsigned int n
= 0;
22247 for (i
= 0, section
= filedata
->section_headers
;
22248 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
22251 if (section
->sh_type
== SHT_NOTE
)
22253 if (! process_notes_at (filedata
, section
, section
->sh_offset
,
22254 section
->sh_size
, section
->sh_addralign
))
22259 if (( filedata
->file_header
.e_machine
== EM_V800
22260 || filedata
->file_header
.e_machine
== EM_V850
22261 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
22262 && section
->sh_type
== SHT_RENESAS_INFO
)
22264 if (! process_v850_notes (filedata
, section
->sh_offset
,
22272 /* Try processing NOTE segments instead. */
22273 return process_corefile_note_segments (filedata
);
22279 process_notes (Filedata
* filedata
)
22281 /* If we have not been asked to display the notes then do nothing. */
22285 if (filedata
->file_header
.e_type
!= ET_CORE
)
22286 return process_note_sections (filedata
);
22288 /* No program headers means no NOTE segment. */
22289 if (filedata
->file_header
.e_phnum
> 0)
22290 return process_corefile_note_segments (filedata
);
22292 if (filedata
->is_separate
)
22293 printf (_("No notes found in linked file '%s'.\n"),
22294 filedata
->file_name
);
22296 printf (_("No notes found file.\n"));
22301 static unsigned char *
22302 display_public_gnu_attributes (unsigned char * start
,
22303 const unsigned char * const end
)
22305 printf (_(" Unknown GNU attribute: %s\n"), start
);
22307 start
+= strnlen ((char *) start
, end
- start
);
22308 display_raw_attribute (start
, end
);
22310 return (unsigned char *) end
;
22313 static unsigned char *
22314 display_generic_attribute (unsigned char * start
,
22316 const unsigned char * const end
)
22319 return (unsigned char *) end
;
22321 return display_tag_value (tag
, start
, end
);
22325 process_arch_specific (Filedata
* filedata
)
22330 switch (filedata
->file_header
.e_machine
)
22333 case EM_ARC_COMPACT
:
22334 case EM_ARC_COMPACT2
:
22335 case EM_ARC_COMPACT3
:
22336 case EM_ARC_COMPACT3_64
:
22337 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
22338 display_arc_attribute
,
22339 display_generic_attribute
);
22341 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
22342 display_arm_attribute
,
22343 display_generic_attribute
);
22346 case EM_MIPS_RS3_LE
:
22347 return process_mips_specific (filedata
);
22350 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
22351 display_msp430_attribute
,
22352 display_msp430_gnu_attribute
);
22355 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
22356 display_riscv_attribute
,
22357 display_generic_attribute
);
22360 return process_nds32_specific (filedata
);
22363 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22364 display_m68k_gnu_attribute
);
22368 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22369 display_power_gnu_attribute
);
22373 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22374 display_s390_gnu_attribute
);
22377 case EM_SPARC32PLUS
:
22379 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22380 display_sparc_gnu_attribute
);
22383 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
22384 display_tic6x_attribute
,
22385 display_generic_attribute
);
22388 return process_attributes (filedata
, "csky", SHT_CSKY_ATTRIBUTES
,
22389 display_csky_attribute
, NULL
);
22392 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
22393 display_public_gnu_attributes
,
22394 display_generic_attribute
);
22399 get_file_header (Filedata
* filedata
)
22401 /* Read in the identity array. */
22402 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
22405 /* Determine how to read the rest of the header. */
22406 switch (filedata
->file_header
.e_ident
[EI_DATA
])
22411 byte_get
= byte_get_little_endian
;
22412 byte_put
= byte_put_little_endian
;
22415 byte_get
= byte_get_big_endian
;
22416 byte_put
= byte_put_big_endian
;
22420 /* For now we only support 32 bit and 64 bit ELF files. */
22421 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
22423 /* Read in the rest of the header. */
22426 Elf32_External_Ehdr ehdr32
;
22428 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
22431 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
22432 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
22433 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
22434 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
22435 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
22436 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
22437 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
22438 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
22439 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
22440 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
22441 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
22442 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
22443 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
22447 Elf64_External_Ehdr ehdr64
;
22449 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
22452 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
22453 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
22454 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
22455 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
22456 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
22457 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
22458 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
22459 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
22460 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
22461 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
22462 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
22463 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
22464 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
22471 free_filedata (Filedata
*filedata
)
22473 free (filedata
->program_interpreter
);
22474 free (filedata
->program_headers
);
22475 free (filedata
->section_headers
);
22476 free (filedata
->string_table
);
22477 free (filedata
->dump
.dump_sects
);
22478 free (filedata
->dynamic_strings
);
22479 free (filedata
->dynamic_symbols
);
22480 free (filedata
->dynamic_syminfo
);
22481 free (filedata
->dynamic_section
);
22483 while (filedata
->symtab_shndx_list
!= NULL
)
22485 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
22486 free (filedata
->symtab_shndx_list
);
22487 filedata
->symtab_shndx_list
= next
;
22490 free (filedata
->section_headers_groups
);
22492 if (filedata
->section_groups
)
22495 struct group_list
* g
;
22496 struct group_list
* next
;
22498 for (i
= 0; i
< filedata
->group_count
; i
++)
22500 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
22507 free (filedata
->section_groups
);
22509 memset (&filedata
->section_headers
, 0,
22510 sizeof (Filedata
) - offsetof (Filedata
, section_headers
));
22514 close_file (Filedata
* filedata
)
22518 if (filedata
->handle
)
22519 fclose (filedata
->handle
);
22525 close_debug_file (void * data
)
22527 free_filedata ((Filedata
*) data
);
22528 close_file ((Filedata
*) data
);
22532 open_file (const char * pathname
, bool is_separate
)
22534 struct stat statbuf
;
22535 Filedata
* filedata
= NULL
;
22537 if (stat (pathname
, & statbuf
) < 0
22538 || ! S_ISREG (statbuf
.st_mode
))
22541 filedata
= calloc (1, sizeof * filedata
);
22542 if (filedata
== NULL
)
22545 filedata
->handle
= fopen (pathname
, "rb");
22546 if (filedata
->handle
== NULL
)
22549 filedata
->file_size
= statbuf
.st_size
;
22550 filedata
->file_name
= pathname
;
22551 filedata
->is_separate
= is_separate
;
22553 if (! get_file_header (filedata
))
22556 if (!get_section_headers (filedata
, false))
22564 if (filedata
->handle
)
22565 fclose (filedata
->handle
);
22572 open_debug_file (const char * pathname
)
22574 return open_file (pathname
, true);
22578 initialise_dump_sects (Filedata
* filedata
)
22580 /* Initialise the dump_sects array from the cmdline_dump_sects array.
22581 Note we do this even if cmdline_dump_sects is empty because we
22582 must make sure that the dump_sets array is zeroed out before each
22583 object file is processed. */
22584 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
22585 memset (filedata
->dump
.dump_sects
, 0,
22586 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
22588 if (cmdline
.num_dump_sects
> 0)
22590 if (filedata
->dump
.num_dump_sects
== 0)
22591 /* A sneaky way of allocating the dump_sects array. */
22592 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
22594 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
22595 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
22596 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
22601 might_need_separate_debug_info (Filedata
* filedata
)
22603 /* Debuginfo files do not need further separate file loading. */
22604 if (filedata
->file_header
.e_shstrndx
== SHN_UNDEF
)
22607 /* Since do_follow_links might be enabled by default, only treat it as an
22608 indication that separate files should be loaded if setting it was a
22609 deliberate user action. */
22610 if (DEFAULT_FOR_FOLLOW_LINKS
== 0 && do_follow_links
)
22613 if (process_links
|| do_syms
|| do_unwind
22614 || dump_any_debugging
|| do_dump
|| do_debugging
)
22620 /* Process one ELF object file according to the command line options.
22621 This file may actually be stored in an archive. The file is
22622 positioned at the start of the ELF object. Returns TRUE if no
22623 problems were encountered, FALSE otherwise. */
22626 process_object (Filedata
* filedata
)
22628 bool have_separate_files
;
22632 if (! get_file_header (filedata
))
22634 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
22638 /* Initialise per file variables. */
22639 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
22640 filedata
->version_info
[i
] = 0;
22642 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
22643 filedata
->dynamic_info
[i
] = 0;
22644 filedata
->dynamic_info_DT_GNU_HASH
= 0;
22645 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
22647 /* Process the file. */
22649 printf (_("\nFile: %s\n"), filedata
->file_name
);
22651 initialise_dump_sects (filedata
);
22653 /* There may be some extensions in the first section header. Don't
22654 bomb if we can't read it. */
22655 get_section_headers (filedata
, true);
22657 if (! process_file_header (filedata
))
22663 /* Throw away the single section header read above, so that we
22664 re-read the entire set. */
22665 free (filedata
->section_headers
);
22666 filedata
->section_headers
= NULL
;
22668 if (! process_section_headers (filedata
))
22670 /* Without loaded section headers we cannot process lots of things. */
22671 do_unwind
= do_version
= do_dump
= do_arch
= false;
22673 if (! do_using_dynamic
)
22674 do_syms
= do_dyn_syms
= do_reloc
= false;
22677 if (! process_section_groups (filedata
))
22678 /* Without loaded section groups we cannot process unwind. */
22681 process_program_headers (filedata
);
22683 res
= process_dynamic_section (filedata
);
22685 if (! process_relocs (filedata
))
22688 if (! process_unwind (filedata
))
22691 if (! process_symbol_table (filedata
))
22694 if (! process_lto_symbol_tables (filedata
))
22697 if (! process_syminfo (filedata
))
22700 if (! process_version_sections (filedata
))
22703 if (might_need_separate_debug_info (filedata
))
22704 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
22706 have_separate_files
= false;
22708 if (! process_section_contents (filedata
))
22711 if (have_separate_files
)
22715 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
22717 initialise_dump_sects (d
->handle
);
22719 if (process_links
&& ! process_file_header (d
->handle
))
22721 else if (! process_section_headers (d
->handle
))
22723 else if (! process_section_contents (d
->handle
))
22725 else if (process_links
)
22727 if (! process_section_groups (d
->handle
))
22729 process_program_headers (d
->handle
);
22730 if (! process_dynamic_section (d
->handle
))
22732 if (! process_relocs (d
->handle
))
22734 if (! process_unwind (d
->handle
))
22736 if (! process_symbol_table (d
->handle
))
22738 if (! process_lto_symbol_tables (d
->handle
))
22740 if (! process_syminfo (d
->handle
))
22742 if (! process_version_sections (d
->handle
))
22744 if (! process_notes (d
->handle
))
22749 /* The file handles are closed by the call to free_debug_memory() below. */
22752 if (! process_notes (filedata
))
22755 if (! process_gnu_liblist (filedata
))
22758 if (! process_arch_specific (filedata
))
22762 free_filedata (filedata
);
22764 free_debug_memory ();
22769 /* Process an ELF archive.
22770 On entry the file is positioned just after the ARMAG string.
22771 Returns TRUE upon success, FALSE otherwise. */
22774 process_archive (Filedata
* filedata
, bool is_thin_archive
)
22776 struct archive_info arch
;
22777 struct archive_info nested_arch
;
22783 /* The ARCH structure is used to hold information about this archive. */
22784 arch
.file_name
= NULL
;
22786 arch
.index_array
= NULL
;
22787 arch
.sym_table
= NULL
;
22788 arch
.longnames
= NULL
;
22790 /* The NESTED_ARCH structure is used as a single-item cache of information
22791 about a nested archive (when members of a thin archive reside within
22792 another regular archive file). */
22793 nested_arch
.file_name
= NULL
;
22794 nested_arch
.file
= NULL
;
22795 nested_arch
.index_array
= NULL
;
22796 nested_arch
.sym_table
= NULL
;
22797 nested_arch
.longnames
= NULL
;
22799 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
22800 filedata
->file_size
, is_thin_archive
,
22801 do_archive_index
) != 0)
22807 if (do_archive_index
)
22809 if (arch
.sym_table
== NULL
)
22810 error (_("%s: unable to dump the index as none was found\n"),
22811 filedata
->file_name
);
22815 uint64_t current_pos
;
22817 printf (_("Index of archive %s: (%" PRIu64
" entries,"
22818 " %#" PRIx64
" bytes in the symbol table)\n"),
22819 filedata
->file_name
, arch
.index_num
,
22822 current_pos
= ftell (filedata
->handle
);
22824 for (i
= l
= 0; i
< arch
.index_num
; i
++)
22827 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
22830 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
22833 if (member_name
!= NULL
)
22835 char * qualified_name
22836 = make_qualified_name (&arch
, &nested_arch
,
22839 if (qualified_name
!= NULL
)
22841 printf (_("Contents of binary %s at offset "),
22843 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
22845 free (qualified_name
);
22847 free (member_name
);
22851 if (l
>= arch
.sym_size
)
22853 error (_("%s: end of the symbol table reached "
22854 "before the end of the index\n"),
22855 filedata
->file_name
);
22859 /* PR 17531: file: 0b6630b2. */
22860 printf ("\t%.*s\n",
22861 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
22862 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
22865 if (arch
.uses_64bit_indices
)
22870 if (l
< arch
.sym_size
)
22872 error (ngettext ("%s: %" PRId64
" byte remains in the symbol table, "
22873 "but without corresponding entries in "
22874 "the index table\n",
22875 "%s: %" PRId64
" bytes remain in the symbol table, "
22876 "but without corresponding entries in "
22877 "the index table\n",
22878 arch
.sym_size
- l
),
22879 filedata
->file_name
, arch
.sym_size
- l
);
22883 if (fseek64 (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
22885 error (_("%s: failed to seek back to start of object files "
22886 "in the archive\n"),
22887 filedata
->file_name
);
22893 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
22894 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
22895 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
22896 && !do_section_groups
&& !do_dyn_syms
)
22898 ret
= true; /* Archive index only. */
22907 char * qualified_name
;
22909 /* Read the next archive header. */
22910 if (fseek64 (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
22912 error (_("%s: failed to seek to next archive header\n"),
22917 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
22918 if (got
!= sizeof arch
.arhdr
)
22922 /* PR 24049 - we cannot use filedata->file_name as this will
22923 have already been freed. */
22924 error (_("%s: failed to read archive header\n"), arch
.file_name
);
22929 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
22931 error (_("%s: did not find a valid archive header\n"),
22937 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
22939 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
22941 name
= get_archive_member_name (&arch
, &nested_arch
);
22944 error (_("%s: bad archive file name\n"), arch
.file_name
);
22948 namelen
= strlen (name
);
22950 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
22951 if (qualified_name
== NULL
)
22953 error (_("%s: bad archive file name\n"), arch
.file_name
);
22959 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
22961 /* This is a proxy for an external member of a thin archive. */
22962 Filedata
* member_filedata
;
22963 char * member_file_name
= adjust_relative_path
22964 (filedata
->file_name
, name
, namelen
);
22967 if (member_file_name
== NULL
)
22969 free (qualified_name
);
22974 member_filedata
= open_file (member_file_name
, false);
22975 if (member_filedata
== NULL
)
22977 error (_("Input file '%s' is not readable.\n"), member_file_name
);
22978 free (member_file_name
);
22979 free (qualified_name
);
22984 filedata
->archive_file_offset
= arch
.nested_member_origin
;
22985 member_filedata
->file_name
= qualified_name
;
22987 /* The call to process_object() expects the file to be at the beginning. */
22988 rewind (member_filedata
->handle
);
22990 if (! process_object (member_filedata
))
22993 close_file (member_filedata
);
22994 free (member_file_name
);
22996 else if (is_thin_archive
)
22998 Filedata thin_filedata
;
23000 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
23002 /* PR 15140: Allow for corrupt thin archives. */
23003 if (nested_arch
.file
== NULL
)
23005 error (_("%s: contains corrupt thin archive: %s\n"),
23006 qualified_name
, name
);
23007 free (qualified_name
);
23014 /* This is a proxy for a member of a nested archive. */
23015 filedata
->archive_file_offset
23016 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
23018 /* The nested archive file will have been opened and setup by
23019 get_archive_member_name. */
23020 if (fseek64 (nested_arch
.file
, filedata
->archive_file_offset
,
23023 error (_("%s: failed to seek to archive member.\n"),
23024 nested_arch
.file_name
);
23025 free (qualified_name
);
23030 thin_filedata
.handle
= nested_arch
.file
;
23031 thin_filedata
.file_name
= qualified_name
;
23033 if (! process_object (& thin_filedata
))
23039 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
23040 filedata
->file_name
= qualified_name
;
23041 if (! process_object (filedata
))
23043 arch
.next_arhdr_offset
+= (filedata
->archive_file_size
+ 1) & -2;
23044 /* Stop looping with "negative" archive_file_size. */
23045 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
23046 arch
.next_arhdr_offset
= -1ul;
23049 free (qualified_name
);
23053 if (nested_arch
.file
!= NULL
)
23054 fclose (nested_arch
.file
);
23055 release_archive (&nested_arch
);
23056 release_archive (&arch
);
23062 process_file (char * file_name
)
23064 Filedata
* filedata
= NULL
;
23065 struct stat statbuf
;
23066 char armag
[SARMAG
];
23069 if (stat (file_name
, &statbuf
) < 0)
23071 if (errno
== ENOENT
)
23072 error (_("'%s': No such file\n"), file_name
);
23074 error (_("Could not locate '%s'. System error message: %s\n"),
23075 file_name
, strerror (errno
));
23079 if (! S_ISREG (statbuf
.st_mode
))
23081 error (_("'%s' is not an ordinary file\n"), file_name
);
23085 filedata
= calloc (1, sizeof * filedata
);
23086 if (filedata
== NULL
)
23088 error (_("Out of memory allocating file data structure\n"));
23092 filedata
->file_name
= file_name
;
23093 filedata
->handle
= fopen (file_name
, "rb");
23094 if (filedata
->handle
== NULL
)
23096 error (_("Input file '%s' is not readable.\n"), file_name
);
23101 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
23103 error (_("%s: Failed to read file's magic number\n"), file_name
);
23104 fclose (filedata
->handle
);
23109 filedata
->file_size
= statbuf
.st_size
;
23110 filedata
->is_separate
= false;
23112 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
23114 if (! process_archive (filedata
, false))
23117 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
23119 if ( ! process_archive (filedata
, true))
23124 if (do_archive_index
&& !check_all
)
23125 error (_("File %s is not an archive so its index cannot be displayed.\n"),
23128 rewind (filedata
->handle
);
23129 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
23131 if (! process_object (filedata
))
23135 fclose (filedata
->handle
);
23136 free (filedata
->section_headers
);
23137 free (filedata
->program_headers
);
23138 free (filedata
->string_table
);
23139 free (filedata
->dump
.dump_sects
);
23142 free (ba_cache
.strtab
);
23143 ba_cache
.strtab
= NULL
;
23144 free (ba_cache
.symtab
);
23145 ba_cache
.symtab
= NULL
;
23146 ba_cache
.filedata
= NULL
;
23151 #ifdef SUPPORT_DISASSEMBLY
23152 /* Needed by the i386 disassembler. For extra credit, someone could
23153 fix this so that we insert symbolic addresses here, esp for GOT/PLT
23157 print_address (unsigned int addr
, FILE * outfile
)
23159 fprintf (outfile
,"0x%8.8x", addr
);
23162 /* Needed by the i386 disassembler. */
23165 db_task_printsym (unsigned int addr
)
23167 print_address (addr
, stderr
);
23172 main (int argc
, char ** argv
)
23176 #ifdef HAVE_LC_MESSAGES
23177 setlocale (LC_MESSAGES
, "");
23179 setlocale (LC_CTYPE
, "");
23180 bindtextdomain (PACKAGE
, LOCALEDIR
);
23181 textdomain (PACKAGE
);
23183 expandargv (&argc
, &argv
);
23185 parse_args (& cmdline
, argc
, argv
);
23187 if (optind
< (argc
- 1))
23188 /* When displaying information for more than one file,
23189 prefix the information with the file name. */
23191 else if (optind
>= argc
)
23193 /* Ensure that the warning is always displayed. */
23196 warn (_("Nothing to do.\n"));
23201 while (optind
< argc
)
23202 if (! process_file (argv
[optind
++]))
23205 free (cmdline
.dump_sects
);
23207 free (dump_ctf_symtab_name
);
23208 free (dump_ctf_strtab_name
);
23209 free (dump_ctf_parent_name
);
23211 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;