1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2023 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
52 #if defined HAVE_MSGPACK
56 /* Define BFD64 here, even if our default architecture is 32 bit ELF
57 as this will allow us to read in and parse 64bit and 32bit ELF files. */
63 #include "demanguse.h"
66 #include "sframe-api.h"
69 #include "elf/common.h"
70 #include "elf/external.h"
71 #include "elf/internal.h"
74 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
75 we can obtain the H8 reloc numbers. We need these for the
76 get_reloc_size() function. We include h8.h again after defining
77 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
82 /* Undo the effects of #including reloc-macros.h. */
84 #undef START_RELOC_NUMBERS
88 #undef END_RELOC_NUMBERS
89 #undef _RELOC_MACROS_H
91 /* The following headers use the elf/reloc-macros.h file to
92 automatically generate relocation recognition functions
93 such as elf_mips_reloc_type() */
95 #define RELOC_MACROS_GEN_FUNC
97 #include "elf/aarch64.h"
98 #include "elf/alpha.h"
99 #include "elf/amdgpu.h"
103 #include "elf/bfin.h"
104 #include "elf/cr16.h"
105 #include "elf/cris.h"
107 #include "elf/csky.h"
108 #include "elf/d10v.h"
109 #include "elf/d30v.h"
112 #include "elf/epiphany.h"
113 #include "elf/fr30.h"
115 #include "elf/ft32.h"
117 #include "elf/hppa.h"
118 #include "elf/i386.h"
119 #include "elf/i370.h"
120 #include "elf/i860.h"
121 #include "elf/i960.h"
122 #include "elf/ia64.h"
123 #include "elf/ip2k.h"
124 #include "elf/lm32.h"
125 #include "elf/iq2000.h"
126 #include "elf/m32c.h"
127 #include "elf/m32r.h"
128 #include "elf/m68k.h"
129 #include "elf/m68hc11.h"
130 #include "elf/s12z.h"
131 #include "elf/mcore.h"
133 #include "elf/metag.h"
134 #include "elf/microblaze.h"
135 #include "elf/mips.h"
136 #include "elf/mmix.h"
137 #include "elf/mn10200.h"
138 #include "elf/mn10300.h"
139 #include "elf/moxie.h"
141 #include "elf/msp430.h"
142 #include "elf/nds32.h"
144 #include "elf/nios2.h"
145 #include "elf/or1k.h"
148 #include "elf/ppc64.h"
150 #include "elf/riscv.h"
151 #include "elf/rl78.h"
153 #include "elf/s390.h"
154 #include "elf/score.h"
156 #include "elf/sparc.h"
158 #include "elf/tic6x.h"
159 #include "elf/tilegx.h"
160 #include "elf/tilepro.h"
161 #include "elf/v850.h"
163 #include "elf/visium.h"
164 #include "elf/wasm32.h"
165 #include "elf/x86-64.h"
166 #include "elf/xgate.h"
167 #include "elf/xstormy16.h"
168 #include "elf/xtensa.h"
170 #include "elf/loongarch.h"
173 #include "libiberty.h"
174 #include "safe-ctype.h"
175 #include "filenames.h"
178 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
181 typedef struct elf_section_list
183 Elf_Internal_Shdr
* hdr
;
184 struct elf_section_list
* next
;
187 /* Flag bits indicating particular types of dump. */
188 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
189 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
190 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
191 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
192 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
193 #define CTF_DUMP (1 << 5) /* The --ctf command line switch. */
194 #define SFRAME_DUMP (1 << 6) /* The --sframe command line switch. */
196 typedef unsigned char dump_type
;
198 /* A linked list of the section names for which dumps were requested. */
199 struct dump_list_entry
203 struct dump_list_entry
* next
;
206 /* A dynamic array of flags indicating for which sections a dump
207 has been requested via command line switches. */
210 dump_type
* dump_sects
;
211 unsigned int num_dump_sects
;
214 static struct dump_data cmdline
;
216 static struct dump_list_entry
* dump_sects_byname
;
218 char * program_name
= "readelf";
220 static bool show_name
= false;
221 static bool do_dynamic
= false;
222 static bool do_syms
= false;
223 static bool do_dyn_syms
= false;
224 static bool do_lto_syms
= false;
225 static bool do_reloc
= false;
226 static bool do_sections
= false;
227 static bool do_section_groups
= false;
228 static bool do_section_details
= false;
229 static bool do_segments
= false;
230 static bool do_unwind
= false;
231 static bool do_using_dynamic
= false;
232 static bool do_header
= false;
233 static bool do_dump
= false;
234 static bool do_version
= false;
235 static bool do_histogram
= false;
236 static bool do_debugging
= false;
237 static bool do_ctf
= false;
238 static bool do_sframe
= false;
239 static bool do_arch
= false;
240 static bool do_notes
= false;
241 static bool do_archive_index
= false;
242 static bool check_all
= false;
243 static bool is_32bit_elf
= false;
244 static bool decompress_dumps
= false;
245 static bool do_not_show_symbol_truncation
= false;
246 static bool do_demangle
= false; /* Pretty print C++ symbol names. */
247 static bool process_links
= false;
248 static bool dump_any_debugging
= false;
249 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
250 static int sym_base
= 0;
252 static char *dump_ctf_parent_name
;
253 static char *dump_ctf_symtab_name
;
254 static char *dump_ctf_strtab_name
;
258 struct group_list
* next
;
259 unsigned int section_index
;
264 struct group_list
* root
;
265 unsigned int group_index
;
268 typedef struct filedata
270 const char * file_name
;
274 Elf_Internal_Ehdr file_header
;
275 uint64_t archive_file_offset
;
276 uint64_t archive_file_size
;
277 /* Everything below this point is cleared out by free_filedata. */
278 Elf_Internal_Shdr
* section_headers
;
279 Elf_Internal_Phdr
* program_headers
;
281 uint64_t string_table_length
;
282 uint64_t dynamic_addr
;
283 uint64_t dynamic_size
;
284 uint64_t dynamic_nent
;
285 Elf_Internal_Dyn
* dynamic_section
;
286 Elf_Internal_Shdr
* dynamic_strtab_section
;
287 char * dynamic_strings
;
288 uint64_t dynamic_strings_length
;
289 Elf_Internal_Shdr
* dynamic_symtab_section
;
290 uint64_t num_dynamic_syms
;
291 Elf_Internal_Sym
* dynamic_symbols
;
292 uint64_t version_info
[16];
293 unsigned int dynamic_syminfo_nent
;
294 Elf_Internal_Syminfo
* dynamic_syminfo
;
295 uint64_t dynamic_syminfo_offset
;
300 uint64_t ngnubuckets
;
302 uint64_t * gnubuckets
;
303 uint64_t * gnuchains
;
306 char * program_interpreter
;
307 uint64_t dynamic_info
[DT_ENCODING
];
308 uint64_t dynamic_info_DT_GNU_HASH
;
309 uint64_t dynamic_info_DT_MIPS_XHASH
;
310 elf_section_list
* symtab_shndx_list
;
312 struct group
* section_groups
;
313 struct group
** section_headers_groups
;
314 /* A dynamic array of flags indicating for which sections a dump of
315 some kind has been requested. It is reset on a per-object file
316 basis and then initialised from the cmdline_dump_sects array,
317 the results of interpreting the -w switch, and the
318 dump_sects_byname list. */
319 struct dump_data dump
;
322 /* How to print a vma value. */
323 typedef enum print_mode
340 typedef enum unicode_display_type
348 } unicode_display_type
;
350 static unicode_display_type unicode_display
= unicode_default
;
360 /* Versioned symbol info. */
361 enum versioned_symbol_info
369 fseek64 (FILE *stream
, int64_t offset
, int whence
)
371 #if defined (HAVE_FSEEKO64)
378 return fseeko64 (stream
, o
, whence
);
379 #elif defined (HAVE_FSEEKO)
386 return fseeko (stream
, o
, whence
);
394 return fseek (stream
, o
, whence
);
398 static const char * get_symbol_version_string
399 (Filedata
*, bool, const char *, size_t, unsigned,
400 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
404 static inline const char *
405 section_name (const Filedata
*filedata
, const Elf_Internal_Shdr
*hdr
)
407 return filedata
->string_table
+ hdr
->sh_name
;
411 section_name_valid (const Filedata
*filedata
, const Elf_Internal_Shdr
*hdr
)
414 && filedata
->string_table
!= NULL
415 && hdr
->sh_name
< filedata
->string_table_length
);
418 static inline const char *
419 section_name_print (const Filedata
*filedata
, const Elf_Internal_Shdr
*hdr
)
423 if (filedata
->string_table
== NULL
)
424 return _("<no-strings>");
425 if (hdr
->sh_name
>= filedata
->string_table_length
)
426 return _("<corrupt>");
427 return section_name (filedata
, hdr
);
430 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
433 valid_symbol_name (const char *strtab
, size_t strtab_size
, uint64_t offset
)
435 return strtab
!= NULL
&& offset
< strtab_size
;
439 valid_dynamic_name (const Filedata
*filedata
, uint64_t offset
)
441 return valid_symbol_name (filedata
->dynamic_strings
,
442 filedata
->dynamic_strings_length
, offset
);
445 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
446 already been called and verified that the string exists. */
447 static inline const char *
448 get_dynamic_name (const Filedata
*filedata
, size_t offset
)
450 return filedata
->dynamic_strings
+ offset
;
453 #define REMOVE_ARCH_BITS(ADDR) \
456 if (filedata->file_header.e_machine == EM_ARM) \
461 /* Get the correct GNU hash section name. */
462 #define GNU_HASH_SECTION_NAME(filedata) \
463 filedata->dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
465 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
466 OFFSET + the offset of the current archive member, if we are examining an
467 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
468 allocate a buffer using malloc and fill that. In either case return the
469 pointer to the start of the retrieved data or NULL if something went wrong.
470 If something does go wrong and REASON is not NULL then emit an error
471 message using REASON as part of the context. */
482 uint64_t amt
= size
* nmemb
;
484 if (size
== 0 || nmemb
== 0)
487 /* If size_t is smaller than uint64_t, eg because you are building
488 on a 32-bit host, then make sure that when the sizes are cast to
489 size_t no information is lost. */
490 if ((size_t) size
!= size
491 || (size_t) nmemb
!= nmemb
492 || (size_t) amt
!= amt
493 || amt
/ size
!= nmemb
494 || (size_t) amt
+ 1 == 0)
497 error (_("Size overflow prevents reading %" PRIu64
498 " elements of size %" PRIu64
" for %s\n"),
499 nmemb
, size
, reason
);
503 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
504 attempting to allocate memory when the read is bound to fail. */
505 if (filedata
->archive_file_offset
> filedata
->file_size
506 || offset
> filedata
->file_size
- filedata
->archive_file_offset
507 || amt
> filedata
->file_size
- filedata
->archive_file_offset
- offset
)
510 error (_("Reading %" PRIu64
" bytes extends past end of file for %s\n"),
515 if (fseek64 (filedata
->handle
, filedata
->archive_file_offset
+ offset
,
519 error (_("Unable to seek to %#" PRIx64
" for %s\n"),
520 filedata
->archive_file_offset
+ offset
, reason
);
527 /* + 1 so that we can '\0' terminate invalid string table sections. */
528 mvar
= malloc ((size_t) amt
+ 1);
533 error (_("Out of memory allocating %" PRIu64
" bytes for %s\n"),
538 ((char *) mvar
)[amt
] = '\0';
541 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
544 error (_("Unable to read in %" PRIu64
" bytes of %s\n"),
554 /* Print a VMA value in the MODE specified.
555 Returns the number of characters displayed. */
558 print_vma (uint64_t vma
, print_mode mode
)
569 return nc
+ printf ("%16.16" PRIx64
, vma
);
570 return nc
+ printf ("%8.8" PRIx64
, vma
);
574 return printf ("%5" PRId64
, vma
);
580 return nc
+ printf ("%" PRIx64
, vma
);
586 return nc
+ printf ("%05" PRIx64
, vma
);
589 return printf ("%" PRId64
, vma
);
592 return printf ("%" PRIu64
, vma
);
595 return printf ("%5" PRIu64
, vma
);
598 return printf ("%" PRIo64
, vma
);
601 return printf ("%5" PRIo64
, vma
);
604 /* FIXME: Report unrecognised mode ? */
610 /* Display a symbol on stdout. Handles the display of control characters and
611 multibye characters (assuming the host environment supports them).
613 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
615 If truncation will happen and do_not_show_symbol_truncation is FALSE then display
616 abs(WIDTH) - 5 characters followed by "[...]".
618 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
619 padding as necessary.
621 Returns the number of emitted characters. */
624 print_symbol (signed int width
, const char * symbol
)
626 bool extra_padding
= false;
627 bool do_dots
= false;
628 signed int num_printed
= 0;
629 #ifdef HAVE_MBSTATE_T
632 unsigned int width_remaining
;
633 const void * alloced_symbol
= NULL
;
637 /* Keep the width positive. This helps the code below. */
639 extra_padding
= true;
645 /* Set the remaining width to a very large value.
646 This simplifies the code below. */
647 width_remaining
= INT_MAX
;
650 width_remaining
= width
;
651 if (! do_not_show_symbol_truncation
652 && (int) strlen (symbol
) > width
)
654 width_remaining
-= 5;
655 if ((int) width_remaining
< 0)
661 #ifdef HAVE_MBSTATE_T
662 /* Initialise the multibyte conversion state. */
663 memset (& state
, 0, sizeof (state
));
666 if (do_demangle
&& *symbol
)
668 const char * res
= cplus_demangle (symbol
, demangle_flags
);
671 alloced_symbol
= symbol
= res
;
674 while (width_remaining
)
677 const char c
= *symbol
++;
688 else if (ISCNTRL (c
))
690 /* Do not print control characters directly as they can affect terminal
691 settings. Such characters usually appear in the names generated
692 by the assembler for local labels. */
694 if (width_remaining
< 2)
697 printf ("^%c", c
+ 0x40);
698 width_remaining
-= 2;
703 if (width_remaining
< 5)
706 width_remaining
-= 5;
709 else if (unicode_display
!= unicode_locale
710 && unicode_display
!= unicode_default
)
712 /* Display unicode characters as something else. */
713 unsigned char bytes
[4];
726 bytes
[1] = *symbol
++;
728 if ((bytes
[1] & 0xc0) != 0x80)
731 /* Do not consume this character. It may only
732 be the first byte in the sequence that was
737 else if ((bytes
[0] & 0x20) == 0)
744 bytes
[2] = *symbol
++;
746 if ((bytes
[2] & 0xc0) != 0x80)
752 else if ((bytes
[0] & 0x10) == 0)
759 bytes
[3] = *symbol
++;
763 if ((bytes
[3] & 0xc0) != 0x80)
775 if (unicode_display
== unicode_invalid
)
778 if (unicode_display
== unicode_hex
|| ! is_utf8
)
782 if (width_remaining
< (nbytes
* 2) + 2)
785 putchar (is_utf8
? '<' : '{');
787 for (i
= 0; i
< nbytes
; i
++)
788 printf ("%02x", bytes
[i
]);
789 putchar (is_utf8
? '>' : '}');
793 if (unicode_display
== unicode_highlight
&& isatty (1))
794 printf ("\x1B[31;47m"); /* Red. */
799 if (width_remaining
< 6)
801 printf ("\\u%02x%02x",
802 (bytes
[0] & 0x1c) >> 2,
803 ((bytes
[0] & 0x03) << 6) | (bytes
[1] & 0x3f));
806 if (width_remaining
< 6)
808 printf ("\\u%02x%02x",
809 ((bytes
[0] & 0x0f) << 4) | ((bytes
[1] & 0x3c) >> 2),
810 ((bytes
[1] & 0x03) << 6) | (bytes
[2] & 0x3f));
813 if (width_remaining
< 8)
815 printf ("\\u%02x%02x%02x",
816 ((bytes
[0] & 0x07) << 6) | ((bytes
[1] & 0x3c) >> 2),
817 ((bytes
[1] & 0x03) << 6) | ((bytes
[2] & 0x3c) >> 2),
818 ((bytes
[2] & 0x03) << 6) | (bytes
[3] & 0x3f));
826 if (unicode_display
== unicode_highlight
&& isatty (1))
827 printf ("\033[0m"); /* Default colour. */
830 if (bytes
[nbytes
- 1] == 0)
835 #ifdef HAVE_MBSTATE_T
838 /* Let printf do the hard work of displaying multibyte characters. */
839 printf ("%.1s", symbol
- 1);
843 #ifdef HAVE_MBSTATE_T
844 /* Try to find out how many bytes made up the character that was
845 just printed. Advance the symbol pointer past the bytes that
847 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
851 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
857 num_printed
+= printf ("[...]");
859 if (extra_padding
&& num_printed
< width
)
861 /* Fill in the remaining spaces. */
862 printf ("%-*s", width
- num_printed
, " ");
866 free ((void *) alloced_symbol
);
870 /* Returns a pointer to a static buffer containing a printable version of
871 the given section's name. Like print_symbol, except that it does not try
872 to print multibyte characters, it just interprets them as hex values. */
875 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
877 #define MAX_PRINT_SEC_NAME_LEN 256
878 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
879 const char * name
= section_name_print (filedata
, sec
);
880 char * buf
= sec_name_buf
;
882 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
884 while ((c
= * name
++) != 0)
895 else if (ISPRINT (c
))
902 static char hex
[17] = "0123456789ABCDEF";
907 * buf
++ = hex
[(c
& 0xf0) >> 4];
908 * buf
++ = hex
[c
& 0x0f];
922 printable_section_name_from_index (Filedata
*filedata
, size_t ndx
)
924 if (ndx
>= filedata
->file_header
.e_shnum
)
925 return _("<corrupt>");
927 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
930 /* Return a pointer to section NAME, or NULL if no such section exists. */
932 static Elf_Internal_Shdr
*
933 find_section (Filedata
* filedata
, const char * name
)
937 if (filedata
->section_headers
== NULL
)
940 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
941 if (section_name_valid (filedata
, filedata
->section_headers
+ i
)
942 && streq (section_name (filedata
, filedata
->section_headers
+ i
),
944 return filedata
->section_headers
+ i
;
949 /* Return a pointer to a section containing ADDR, or NULL if no such
952 static Elf_Internal_Shdr
*
953 find_section_by_address (Filedata
* filedata
, uint64_t addr
)
957 if (filedata
->section_headers
== NULL
)
960 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
962 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
964 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
971 static Elf_Internal_Shdr
*
972 find_section_by_type (Filedata
* filedata
, unsigned int type
)
976 if (filedata
->section_headers
== NULL
)
979 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
981 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
983 if (sec
->sh_type
== type
)
990 /* Return a pointer to section NAME, or NULL if no such section exists,
991 restricted to the list of sections given in SET. */
993 static Elf_Internal_Shdr
*
994 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
998 if (filedata
->section_headers
== NULL
)
1003 while ((i
= *set
++) > 0)
1005 /* See PR 21156 for a reproducer. */
1006 if (i
>= filedata
->file_header
.e_shnum
)
1007 continue; /* FIXME: Should we issue an error message ? */
1009 if (section_name_valid (filedata
, filedata
->section_headers
+ i
)
1010 && streq (section_name (filedata
, filedata
->section_headers
+ i
),
1012 return filedata
->section_headers
+ i
;
1016 return find_section (filedata
, name
);
1019 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
1020 This OS has so many departures from the ELF standard that we test it at
1024 is_ia64_vms (Filedata
* filedata
)
1026 return filedata
->file_header
.e_machine
== EM_IA_64
1027 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
1030 /* Guess the relocation size commonly used by the specific machines. */
1033 guess_is_rela (unsigned int e_machine
)
1037 /* Targets that use REL relocations. */
1043 case EM_CYGNUS_D10V
:
1046 case EM_MIPS_RS3_LE
:
1047 case EM_CYGNUS_M32R
:
1054 /* Targets that use RELA relocations. */
1058 case EM_ADAPTEVA_EPIPHANY
:
1060 case EM_ALTERA_NIOS2
:
1062 case EM_ARC_COMPACT
:
1063 case EM_ARC_COMPACT2
:
1072 case EM_CYGNUS_D30V
:
1075 case EM_CYGNUS_FR30
:
1084 case EM_LATTICEMICO32
:
1093 case EM_CYGNUS_MN10200
:
1095 case EM_CYGNUS_MN10300
:
1113 case EM_SPARC32PLUS
:
1121 case EM_CYGNUS_V850
:
1131 case EM_MICROBLAZE_OLD
:
1132 case EM_WEBASSEMBLY
:
1153 warn (_("Don't know about relocations on this machine architecture\n"));
1158 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1159 Returns TRUE upon success, FALSE otherwise. If successful then a
1160 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
1161 and the number of relocs loaded is placed in *NRELASP. It is the caller's
1162 responsibility to free the allocated buffer. */
1165 slurp_rela_relocs (Filedata
*filedata
,
1166 uint64_t rel_offset
,
1168 Elf_Internal_Rela
**relasp
,
1171 Elf_Internal_Rela
* relas
;
1177 Elf32_External_Rela
* erelas
;
1179 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
1180 rel_size
, _("32-bit relocation data"));
1184 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
1186 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
1187 sizeof (Elf_Internal_Rela
));
1192 error (_("out of memory parsing relocs\n"));
1196 for (i
= 0; i
< nrelas
; i
++)
1198 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
1199 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
1200 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
1207 Elf64_External_Rela
* erelas
;
1209 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
1210 rel_size
, _("64-bit relocation data"));
1214 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
1216 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
1217 sizeof (Elf_Internal_Rela
));
1222 error (_("out of memory parsing relocs\n"));
1226 for (i
= 0; i
< nrelas
; i
++)
1228 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
1229 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
1230 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
1232 if (filedata
->file_header
.e_machine
== EM_MIPS
1233 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1235 /* In little-endian objects, r_info isn't really a
1236 64-bit little-endian value: it has a 32-bit
1237 little-endian symbol index followed by four
1238 individual byte fields. Reorder INFO
1240 uint64_t inf
= relas
[i
].r_info
;
1241 inf
= (((inf
& 0xffffffff) << 32)
1242 | ((inf
>> 56) & 0xff)
1243 | ((inf
>> 40) & 0xff00)
1244 | ((inf
>> 24) & 0xff0000)
1245 | ((inf
>> 8) & 0xff000000));
1246 relas
[i
].r_info
= inf
;
1258 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1259 Returns TRUE upon success, FALSE otherwise. If successful then a
1260 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1261 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1262 responsibility to free the allocated buffer. */
1265 slurp_rel_relocs (Filedata
*filedata
,
1266 uint64_t rel_offset
,
1268 Elf_Internal_Rela
**relsp
,
1271 Elf_Internal_Rela
* rels
;
1277 Elf32_External_Rel
* erels
;
1279 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1280 rel_size
, _("32-bit relocation data"));
1284 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1286 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1291 error (_("out of memory parsing relocs\n"));
1295 for (i
= 0; i
< nrels
; i
++)
1297 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1298 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1299 rels
[i
].r_addend
= 0;
1306 Elf64_External_Rel
* erels
;
1308 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1309 rel_size
, _("64-bit relocation data"));
1313 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1315 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1320 error (_("out of memory parsing relocs\n"));
1324 for (i
= 0; i
< nrels
; i
++)
1326 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1327 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1328 rels
[i
].r_addend
= 0;
1330 if (filedata
->file_header
.e_machine
== EM_MIPS
1331 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1333 /* In little-endian objects, r_info isn't really a
1334 64-bit little-endian value: it has a 32-bit
1335 little-endian symbol index followed by four
1336 individual byte fields. Reorder INFO
1338 uint64_t inf
= rels
[i
].r_info
;
1339 inf
= (((inf
& 0xffffffff) << 32)
1340 | ((inf
>> 56) & 0xff)
1341 | ((inf
>> 40) & 0xff00)
1342 | ((inf
>> 24) & 0xff0000)
1343 | ((inf
>> 8) & 0xff000000));
1344 rels
[i
].r_info
= inf
;
1357 slurp_relr_relocs (Filedata
*filedata
,
1358 uint64_t relr_offset
,
1364 size_t size
= 0, nentries
, i
;
1365 uint64_t base
= 0, addr
, entry
;
1367 relrs
= get_data (NULL
, filedata
, relr_offset
, 1, relr_size
,
1368 _("RELR relocation data"));
1373 nentries
= relr_size
/ sizeof (Elf32_External_Relr
);
1375 nentries
= relr_size
/ sizeof (Elf64_External_Relr
);
1376 for (i
= 0; i
< nentries
; i
++)
1379 entry
= BYTE_GET (((Elf32_External_Relr
*)relrs
)[i
].r_data
);
1381 entry
= BYTE_GET (((Elf64_External_Relr
*)relrs
)[i
].r_data
);
1382 if ((entry
& 1) == 0)
1385 while ((entry
>>= 1) != 0)
1386 if ((entry
& 1) == 1)
1390 *relrsp
= malloc (size
* sizeof (**relrsp
));
1391 if (*relrsp
== NULL
)
1394 error (_("out of memory parsing relocs\n"));
1399 for (i
= 0; i
< nentries
; i
++)
1401 const uint64_t entry_bytes
= is_32bit_elf
? 4 : 8;
1404 entry
= BYTE_GET (((Elf32_External_Relr
*)relrs
)[i
].r_data
);
1406 entry
= BYTE_GET (((Elf64_External_Relr
*)relrs
)[i
].r_data
);
1407 if ((entry
& 1) == 0)
1409 (*relrsp
)[size
++] = entry
;
1410 base
= entry
+ entry_bytes
;
1414 for (addr
= base
; (entry
>>= 1) != 0; addr
+= entry_bytes
)
1415 if ((entry
& 1) != 0)
1416 (*relrsp
)[size
++] = addr
;
1417 base
+= entry_bytes
* (entry_bytes
* CHAR_BIT
- 1);
1426 /* Returns the reloc type extracted from the reloc info field. */
1429 get_reloc_type (Filedata
* filedata
, uint64_t reloc_info
)
1432 return ELF32_R_TYPE (reloc_info
);
1434 switch (filedata
->file_header
.e_machine
)
1437 /* Note: We assume that reloc_info has already been adjusted for us. */
1438 return ELF64_MIPS_R_TYPE (reloc_info
);
1441 return ELF64_R_TYPE_ID (reloc_info
);
1444 return ELF64_R_TYPE (reloc_info
);
1448 /* Return the symbol index extracted from the reloc info field. */
1451 get_reloc_symindex (uint64_t reloc_info
)
1453 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1457 uses_msp430x_relocs (Filedata
* filedata
)
1460 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1461 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1462 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1463 /* TI compiler uses ELFOSABI_NONE. */
1464 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1467 /* Display the contents of the relocation data found at the specified
1471 dump_relocations (Filedata
*filedata
,
1472 uint64_t rel_offset
,
1474 Elf_Internal_Sym
*symtab
,
1478 relocation_type rel_type
,
1482 Elf_Internal_Rela
* rels
;
1485 if (rel_type
== reltype_unknown
)
1486 rel_type
= guess_is_rela (filedata
->file_header
.e_machine
) ? reltype_rela
: reltype_rel
;
1488 if (rel_type
== reltype_rela
)
1490 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1493 else if (rel_type
== reltype_rel
)
1495 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1498 else if (rel_type
== reltype_relr
)
1502 = is_32bit_elf
? "%08" PRIx64
"\n" : "%016" PRIx64
"\n";
1504 if (!slurp_relr_relocs (filedata
, rel_offset
, rel_size
, &relrs
,
1508 printf (ngettext (" %" PRIu64
" offset\n",
1509 " %" PRIu64
" offsets\n", rel_size
),
1511 for (i
= 0; i
< rel_size
; i
++)
1512 printf (format
, relrs
[i
]);
1519 if (rel_type
== reltype_rela
)
1522 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1524 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1529 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1531 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1536 if (rel_type
== reltype_rela
)
1539 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1541 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1546 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1548 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1552 for (i
= 0; i
< rel_size
; i
++)
1557 uint64_t symtab_index
;
1560 offset
= rels
[i
].r_offset
;
1561 inf
= rels
[i
].r_info
;
1563 type
= get_reloc_type (filedata
, inf
);
1564 symtab_index
= get_reloc_symindex (inf
);
1568 printf ("%8.8lx %8.8lx ",
1569 (unsigned long) offset
& 0xffffffff,
1570 (unsigned long) inf
& 0xffffffff);
1575 ? "%16.16" PRIx64
" %16.16" PRIx64
" "
1576 : "%12.12" PRIx64
" %12.12" PRIx64
" ",
1580 switch (filedata
->file_header
.e_machine
)
1587 rtype
= elf_aarch64_reloc_type (type
);
1591 case EM_CYGNUS_M32R
:
1592 rtype
= elf_m32r_reloc_type (type
);
1597 rtype
= elf_i386_reloc_type (type
);
1602 rtype
= elf_m68hc11_reloc_type (type
);
1606 rtype
= elf_s12z_reloc_type (type
);
1610 rtype
= elf_m68k_reloc_type (type
);
1614 rtype
= elf_i960_reloc_type (type
);
1619 rtype
= elf_avr_reloc_type (type
);
1622 case EM_OLD_SPARCV9
:
1623 case EM_SPARC32PLUS
:
1626 rtype
= elf_sparc_reloc_type (type
);
1630 rtype
= elf_spu_reloc_type (type
);
1634 rtype
= v800_reloc_type (type
);
1637 case EM_CYGNUS_V850
:
1638 rtype
= v850_reloc_type (type
);
1642 case EM_CYGNUS_D10V
:
1643 rtype
= elf_d10v_reloc_type (type
);
1647 case EM_CYGNUS_D30V
:
1648 rtype
= elf_d30v_reloc_type (type
);
1652 rtype
= elf_dlx_reloc_type (type
);
1656 rtype
= elf_sh_reloc_type (type
);
1660 case EM_CYGNUS_MN10300
:
1661 rtype
= elf_mn10300_reloc_type (type
);
1665 case EM_CYGNUS_MN10200
:
1666 rtype
= elf_mn10200_reloc_type (type
);
1670 case EM_CYGNUS_FR30
:
1671 rtype
= elf_fr30_reloc_type (type
);
1675 rtype
= elf_frv_reloc_type (type
);
1679 rtype
= elf_csky_reloc_type (type
);
1683 rtype
= elf_ft32_reloc_type (type
);
1687 rtype
= elf_mcore_reloc_type (type
);
1691 rtype
= elf_mmix_reloc_type (type
);
1695 rtype
= elf_moxie_reloc_type (type
);
1699 if (uses_msp430x_relocs (filedata
))
1701 rtype
= elf_msp430x_reloc_type (type
);
1706 rtype
= elf_msp430_reloc_type (type
);
1710 rtype
= elf_nds32_reloc_type (type
);
1714 rtype
= elf_ppc_reloc_type (type
);
1718 rtype
= elf_ppc64_reloc_type (type
);
1722 case EM_MIPS_RS3_LE
:
1723 rtype
= elf_mips_reloc_type (type
);
1727 rtype
= elf_riscv_reloc_type (type
);
1731 rtype
= elf_alpha_reloc_type (type
);
1735 rtype
= elf_arm_reloc_type (type
);
1739 case EM_ARC_COMPACT
:
1740 case EM_ARC_COMPACT2
:
1741 rtype
= elf_arc_reloc_type (type
);
1745 rtype
= elf_hppa_reloc_type (type
);
1751 rtype
= elf_h8_reloc_type (type
);
1755 rtype
= elf_or1k_reloc_type (type
);
1760 rtype
= elf_pj_reloc_type (type
);
1763 rtype
= elf_ia64_reloc_type (type
);
1767 rtype
= elf_cris_reloc_type (type
);
1771 rtype
= elf_i860_reloc_type (type
);
1777 rtype
= elf_x86_64_reloc_type (type
);
1781 rtype
= i370_reloc_type (type
);
1786 rtype
= elf_s390_reloc_type (type
);
1790 rtype
= elf_score_reloc_type (type
);
1794 rtype
= elf_xstormy16_reloc_type (type
);
1798 rtype
= elf_crx_reloc_type (type
);
1802 rtype
= elf_vax_reloc_type (type
);
1806 rtype
= elf_visium_reloc_type (type
);
1810 rtype
= elf_bpf_reloc_type (type
);
1813 case EM_ADAPTEVA_EPIPHANY
:
1814 rtype
= elf_epiphany_reloc_type (type
);
1819 rtype
= elf_ip2k_reloc_type (type
);
1823 rtype
= elf_iq2000_reloc_type (type
);
1828 rtype
= elf_xtensa_reloc_type (type
);
1831 case EM_LATTICEMICO32
:
1832 rtype
= elf_lm32_reloc_type (type
);
1837 rtype
= elf_m32c_reloc_type (type
);
1841 rtype
= elf_mt_reloc_type (type
);
1845 rtype
= elf_bfin_reloc_type (type
);
1849 rtype
= elf_mep_reloc_type (type
);
1853 rtype
= elf_cr16_reloc_type (type
);
1857 case EM_MICROBLAZE_OLD
:
1858 rtype
= elf_microblaze_reloc_type (type
);
1862 rtype
= elf_rl78_reloc_type (type
);
1866 rtype
= elf_rx_reloc_type (type
);
1870 rtype
= elf_metag_reloc_type (type
);
1874 rtype
= elf_tic6x_reloc_type (type
);
1878 rtype
= elf_tilegx_reloc_type (type
);
1882 rtype
= elf_tilepro_reloc_type (type
);
1885 case EM_WEBASSEMBLY
:
1886 rtype
= elf_wasm32_reloc_type (type
);
1890 rtype
= elf_xgate_reloc_type (type
);
1893 case EM_ALTERA_NIOS2
:
1894 rtype
= elf_nios2_reloc_type (type
);
1898 rtype
= elf_pru_reloc_type (type
);
1902 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
1903 rtype
= elf_nfp3200_reloc_type (type
);
1905 rtype
= elf_nfp_reloc_type (type
);
1909 rtype
= elf_z80_reloc_type (type
);
1913 rtype
= elf_loongarch_reloc_type (type
);
1917 rtype
= elf_amdgpu_reloc_type (type
);
1922 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1924 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1926 if (filedata
->file_header
.e_machine
== EM_ALPHA
1928 && streq (rtype
, "R_ALPHA_LITUSE")
1929 && rel_type
== reltype_rela
)
1931 switch (rels
[i
].r_addend
)
1933 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1934 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1935 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1936 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1937 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1938 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1939 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1940 default: rtype
= NULL
;
1944 printf (" (%s)", rtype
);
1948 printf (_("<unknown addend: %" PRIx64
">"),
1953 else if (symtab_index
)
1955 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1957 error (_(" bad symbol index: %08lx in reloc\n"),
1958 (unsigned long) symtab_index
);
1963 Elf_Internal_Sym
* psym
;
1964 const char * version_string
;
1965 enum versioned_symbol_info sym_info
;
1966 unsigned short vna_other
;
1968 psym
= symtab
+ symtab_index
;
1971 = get_symbol_version_string (filedata
, is_dynsym
,
1980 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1984 unsigned int width
= is_32bit_elf
? 8 : 14;
1986 /* Relocations against GNU_IFUNC symbols do not use the value
1987 of the symbol as the address to relocate against. Instead
1988 they invoke the function named by the symbol and use its
1989 result as the address for relocation.
1991 To indicate this to the user, do not display the value of
1992 the symbol in the "Symbols's Value" field. Instead show
1993 its name followed by () as a hint that the symbol is
1997 || psym
->st_name
== 0
1998 || psym
->st_name
>= strtablen
)
2001 name
= strtab
+ psym
->st_name
;
2003 len
= print_symbol (width
, name
);
2005 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
2007 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
2011 print_vma (psym
->st_value
, LONG_HEX
);
2013 printf (is_32bit_elf
? " " : " ");
2016 if (psym
->st_name
== 0)
2018 const char * sec_name
= "<null>";
2021 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
2023 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
2024 && filedata
->section_headers
!= NULL
)
2025 sec_name
= section_name_print (filedata
,
2026 filedata
->section_headers
2028 else if (psym
->st_shndx
== SHN_ABS
)
2030 else if (psym
->st_shndx
== SHN_COMMON
)
2031 sec_name
= "COMMON";
2032 else if ((filedata
->file_header
.e_machine
== EM_MIPS
2033 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
2034 || (filedata
->file_header
.e_machine
== EM_TI_C6000
2035 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
2036 sec_name
= "SCOMMON";
2037 else if (filedata
->file_header
.e_machine
== EM_MIPS
2038 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
2039 sec_name
= "SUNDEF";
2040 else if ((filedata
->file_header
.e_machine
== EM_X86_64
2041 || filedata
->file_header
.e_machine
== EM_L1OM
2042 || filedata
->file_header
.e_machine
== EM_K1OM
)
2043 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
2044 sec_name
= "LARGE_COMMON";
2045 else if (filedata
->file_header
.e_machine
== EM_IA_64
2046 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
2047 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
2048 sec_name
= "ANSI_COM";
2049 else if (is_ia64_vms (filedata
)
2050 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
2051 sec_name
= "VMS_SYMVEC";
2054 sprintf (name_buf
, "<section 0x%x>",
2055 (unsigned int) psym
->st_shndx
);
2056 sec_name
= name_buf
;
2059 print_symbol (22, sec_name
);
2061 else if (strtab
== NULL
)
2062 printf (_("<string table index: %3ld>"), psym
->st_name
);
2063 else if (psym
->st_name
>= strtablen
)
2065 error (_("<corrupt string table index: %3ld>\n"),
2071 print_symbol (22, strtab
+ psym
->st_name
);
2073 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
2077 if (rel_type
== reltype_rela
)
2079 uint64_t off
= rels
[i
].r_addend
;
2081 if ((int64_t) off
< 0)
2082 printf (" - %" PRIx64
, -off
);
2084 printf (" + %" PRIx64
, off
);
2088 else if (rel_type
== reltype_rela
)
2090 uint64_t off
= rels
[i
].r_addend
;
2092 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
2093 if ((int64_t) off
< 0)
2094 printf ("-%" PRIx64
, -off
);
2096 printf ("%" PRIx64
, off
);
2099 if (filedata
->file_header
.e_machine
== EM_SPARCV9
2101 && streq (rtype
, "R_SPARC_OLO10"))
2102 printf (" + %" PRIx64
, ELF64_R_TYPE_DATA (inf
));
2106 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
2108 uint64_t type2
= ELF64_MIPS_R_TYPE2 (inf
);
2109 uint64_t type3
= ELF64_MIPS_R_TYPE3 (inf
);
2110 const char * rtype2
= elf_mips_reloc_type (type2
);
2111 const char * rtype3
= elf_mips_reloc_type (type3
);
2113 printf (" Type2: ");
2116 printf (_("unrecognized: %-7lx"),
2117 (unsigned long) type2
& 0xffffffff);
2119 printf ("%-17.17s", rtype2
);
2121 printf ("\n Type3: ");
2124 printf (_("unrecognized: %-7lx"),
2125 (unsigned long) type3
& 0xffffffff);
2127 printf ("%-17.17s", rtype3
);
2139 get_aarch64_dynamic_type (unsigned long type
)
2143 case DT_AARCH64_BTI_PLT
: return "AARCH64_BTI_PLT";
2144 case DT_AARCH64_PAC_PLT
: return "AARCH64_PAC_PLT";
2145 case DT_AARCH64_VARIANT_PCS
: return "AARCH64_VARIANT_PCS";
2152 get_mips_dynamic_type (unsigned long type
)
2156 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
2157 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
2158 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
2159 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
2160 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
2161 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
2162 case DT_MIPS_MSYM
: return "MIPS_MSYM";
2163 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2164 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2165 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
2166 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
2167 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
2168 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
2169 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
2170 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
2171 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
2172 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
2173 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
2174 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
2175 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
2176 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
2177 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
2178 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
2179 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
2180 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
2181 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
2182 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
2183 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
2184 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
2185 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
2186 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2187 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
2188 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
2189 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
2190 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
2191 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2192 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
2193 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
2194 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
2195 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
2196 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
2197 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
2198 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
2199 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
2200 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
2201 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
2202 case DT_MIPS_XHASH
: return "MIPS_XHASH";
2209 get_sparc64_dynamic_type (unsigned long type
)
2213 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
2220 get_ppc_dynamic_type (unsigned long type
)
2224 case DT_PPC_GOT
: return "PPC_GOT";
2225 case DT_PPC_OPT
: return "PPC_OPT";
2232 get_ppc64_dynamic_type (unsigned long type
)
2236 case DT_PPC64_GLINK
: return "PPC64_GLINK";
2237 case DT_PPC64_OPD
: return "PPC64_OPD";
2238 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
2239 case DT_PPC64_OPT
: return "PPC64_OPT";
2246 get_parisc_dynamic_type (unsigned long type
)
2250 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
2251 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
2252 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
2253 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
2254 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
2255 case DT_HP_PREINIT
: return "HP_PREINIT";
2256 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
2257 case DT_HP_NEEDED
: return "HP_NEEDED";
2258 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
2259 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
2260 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
2261 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
2262 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
2263 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
2264 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
2265 case DT_HP_FILTERED
: return "HP_FILTERED";
2266 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
2267 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
2268 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
2269 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
2270 case DT_PLT
: return "PLT";
2271 case DT_PLT_SIZE
: return "PLT_SIZE";
2272 case DT_DLT
: return "DLT";
2273 case DT_DLT_SIZE
: return "DLT_SIZE";
2280 get_ia64_dynamic_type (unsigned long type
)
2284 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
2285 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
2286 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
2287 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
2288 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
2289 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
2290 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
2291 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
2292 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
2293 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
2294 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
2295 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
2296 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
2297 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
2298 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
2299 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
2300 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
2301 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
2302 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
2303 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
2304 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
2305 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
2306 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
2307 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
2308 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
2309 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
2310 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
2311 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
2312 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
2313 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
2314 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
2321 get_solaris_section_type (unsigned long type
)
2325 case 0x6fffffee: return "SUNW_ancillary";
2326 case 0x6fffffef: return "SUNW_capchain";
2327 case 0x6ffffff0: return "SUNW_capinfo";
2328 case 0x6ffffff1: return "SUNW_symsort";
2329 case 0x6ffffff2: return "SUNW_tlssort";
2330 case 0x6ffffff3: return "SUNW_LDYNSYM";
2331 case 0x6ffffff4: return "SUNW_dof";
2332 case 0x6ffffff5: return "SUNW_cap";
2333 case 0x6ffffff6: return "SUNW_SIGNATURE";
2334 case 0x6ffffff7: return "SUNW_ANNOTATE";
2335 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2336 case 0x6ffffff9: return "SUNW_DEBUG";
2337 case 0x6ffffffa: return "SUNW_move";
2338 case 0x6ffffffb: return "SUNW_COMDAT";
2339 case 0x6ffffffc: return "SUNW_syminfo";
2340 case 0x6ffffffd: return "SUNW_verdef";
2341 case 0x6ffffffe: return "SUNW_verneed";
2342 case 0x6fffffff: return "SUNW_versym";
2343 case 0x70000000: return "SPARC_GOTDATA";
2344 default: return NULL
;
2349 get_alpha_dynamic_type (unsigned long type
)
2353 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2354 default: return NULL
;
2359 get_score_dynamic_type (unsigned long type
)
2363 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2364 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2365 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2366 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2367 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2368 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2369 default: return NULL
;
2374 get_tic6x_dynamic_type (unsigned long type
)
2378 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2379 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2380 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2381 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2382 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2383 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2384 default: return NULL
;
2389 get_nios2_dynamic_type (unsigned long type
)
2393 case DT_NIOS2_GP
: return "NIOS2_GP";
2394 default: return NULL
;
2399 get_solaris_dynamic_type (unsigned long type
)
2403 case 0x6000000d: return "SUNW_AUXILIARY";
2404 case 0x6000000e: return "SUNW_RTLDINF";
2405 case 0x6000000f: return "SUNW_FILTER";
2406 case 0x60000010: return "SUNW_CAP";
2407 case 0x60000011: return "SUNW_SYMTAB";
2408 case 0x60000012: return "SUNW_SYMSZ";
2409 case 0x60000013: return "SUNW_SORTENT";
2410 case 0x60000014: return "SUNW_SYMSORT";
2411 case 0x60000015: return "SUNW_SYMSORTSZ";
2412 case 0x60000016: return "SUNW_TLSSORT";
2413 case 0x60000017: return "SUNW_TLSSORTSZ";
2414 case 0x60000018: return "SUNW_CAPINFO";
2415 case 0x60000019: return "SUNW_STRPAD";
2416 case 0x6000001a: return "SUNW_CAPCHAIN";
2417 case 0x6000001b: return "SUNW_LDMACH";
2418 case 0x6000001d: return "SUNW_CAPCHAINENT";
2419 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2420 case 0x60000021: return "SUNW_PARENT";
2421 case 0x60000023: return "SUNW_ASLR";
2422 case 0x60000025: return "SUNW_RELAX";
2423 case 0x60000029: return "SUNW_NXHEAP";
2424 case 0x6000002b: return "SUNW_NXSTACK";
2426 case 0x70000001: return "SPARC_REGISTER";
2427 case 0x7ffffffd: return "AUXILIARY";
2428 case 0x7ffffffe: return "USED";
2429 case 0x7fffffff: return "FILTER";
2431 default: return NULL
;
2436 get_riscv_dynamic_type (unsigned long type
)
2440 case DT_RISCV_VARIANT_CC
: return "RISCV_VARIANT_CC";
2447 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2449 static char buff
[64];
2453 case DT_NULL
: return "NULL";
2454 case DT_NEEDED
: return "NEEDED";
2455 case DT_PLTRELSZ
: return "PLTRELSZ";
2456 case DT_PLTGOT
: return "PLTGOT";
2457 case DT_HASH
: return "HASH";
2458 case DT_STRTAB
: return "STRTAB";
2459 case DT_SYMTAB
: return "SYMTAB";
2460 case DT_RELA
: return "RELA";
2461 case DT_RELASZ
: return "RELASZ";
2462 case DT_RELAENT
: return "RELAENT";
2463 case DT_STRSZ
: return "STRSZ";
2464 case DT_SYMENT
: return "SYMENT";
2465 case DT_INIT
: return "INIT";
2466 case DT_FINI
: return "FINI";
2467 case DT_SONAME
: return "SONAME";
2468 case DT_RPATH
: return "RPATH";
2469 case DT_SYMBOLIC
: return "SYMBOLIC";
2470 case DT_REL
: return "REL";
2471 case DT_RELSZ
: return "RELSZ";
2472 case DT_RELENT
: return "RELENT";
2473 case DT_RELR
: return "RELR";
2474 case DT_RELRSZ
: return "RELRSZ";
2475 case DT_RELRENT
: return "RELRENT";
2476 case DT_PLTREL
: return "PLTREL";
2477 case DT_DEBUG
: return "DEBUG";
2478 case DT_TEXTREL
: return "TEXTREL";
2479 case DT_JMPREL
: return "JMPREL";
2480 case DT_BIND_NOW
: return "BIND_NOW";
2481 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2482 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2483 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2484 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2485 case DT_RUNPATH
: return "RUNPATH";
2486 case DT_FLAGS
: return "FLAGS";
2488 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2489 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2490 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2492 case DT_CHECKSUM
: return "CHECKSUM";
2493 case DT_PLTPADSZ
: return "PLTPADSZ";
2494 case DT_MOVEENT
: return "MOVEENT";
2495 case DT_MOVESZ
: return "MOVESZ";
2496 case DT_FEATURE
: return "FEATURE";
2497 case DT_POSFLAG_1
: return "POSFLAG_1";
2498 case DT_SYMINSZ
: return "SYMINSZ";
2499 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2501 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2502 case DT_CONFIG
: return "CONFIG";
2503 case DT_DEPAUDIT
: return "DEPAUDIT";
2504 case DT_AUDIT
: return "AUDIT";
2505 case DT_PLTPAD
: return "PLTPAD";
2506 case DT_MOVETAB
: return "MOVETAB";
2507 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2509 case DT_VERSYM
: return "VERSYM";
2511 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2512 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2513 case DT_RELACOUNT
: return "RELACOUNT";
2514 case DT_RELCOUNT
: return "RELCOUNT";
2515 case DT_FLAGS_1
: return "FLAGS_1";
2516 case DT_VERDEF
: return "VERDEF";
2517 case DT_VERDEFNUM
: return "VERDEFNUM";
2518 case DT_VERNEED
: return "VERNEED";
2519 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2521 case DT_AUXILIARY
: return "AUXILIARY";
2522 case DT_USED
: return "USED";
2523 case DT_FILTER
: return "FILTER";
2525 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2526 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2527 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2528 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2529 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2530 case DT_GNU_HASH
: return "GNU_HASH";
2531 case DT_GNU_FLAGS_1
: return "GNU_FLAGS_1";
2534 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2536 const char * result
;
2538 switch (filedata
->file_header
.e_machine
)
2541 result
= get_aarch64_dynamic_type (type
);
2544 case EM_MIPS_RS3_LE
:
2545 result
= get_mips_dynamic_type (type
);
2548 result
= get_sparc64_dynamic_type (type
);
2551 result
= get_ppc_dynamic_type (type
);
2554 result
= get_ppc64_dynamic_type (type
);
2557 result
= get_ia64_dynamic_type (type
);
2560 result
= get_alpha_dynamic_type (type
);
2563 result
= get_score_dynamic_type (type
);
2566 result
= get_tic6x_dynamic_type (type
);
2568 case EM_ALTERA_NIOS2
:
2569 result
= get_nios2_dynamic_type (type
);
2572 result
= get_riscv_dynamic_type (type
);
2575 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2576 result
= get_solaris_dynamic_type (type
);
2585 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2587 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2588 || (filedata
->file_header
.e_machine
== EM_PARISC
2589 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2591 const char * result
;
2593 switch (filedata
->file_header
.e_machine
)
2596 result
= get_parisc_dynamic_type (type
);
2599 result
= get_ia64_dynamic_type (type
);
2602 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2603 result
= get_solaris_dynamic_type (type
);
2612 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2616 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2622 static bool get_program_headers (Filedata
*);
2623 static bool get_dynamic_section (Filedata
*);
2626 locate_dynamic_section (Filedata
*filedata
)
2628 uint64_t dynamic_addr
= 0;
2629 uint64_t dynamic_size
= 0;
2631 if (filedata
->file_header
.e_phnum
!= 0
2632 && get_program_headers (filedata
))
2634 Elf_Internal_Phdr
*segment
;
2637 for (i
= 0, segment
= filedata
->program_headers
;
2638 i
< filedata
->file_header
.e_phnum
;
2641 if (segment
->p_type
== PT_DYNAMIC
)
2643 dynamic_addr
= segment
->p_offset
;
2644 dynamic_size
= segment
->p_filesz
;
2646 if (filedata
->section_headers
!= NULL
)
2648 Elf_Internal_Shdr
*sec
;
2650 sec
= find_section (filedata
, ".dynamic");
2653 if (sec
->sh_size
== 0
2654 || sec
->sh_type
== SHT_NOBITS
)
2661 dynamic_addr
= sec
->sh_offset
;
2662 dynamic_size
= sec
->sh_size
;
2667 if (dynamic_addr
> filedata
->file_size
2668 || (dynamic_size
> filedata
->file_size
- dynamic_addr
))
2677 filedata
->dynamic_addr
= dynamic_addr
;
2678 filedata
->dynamic_size
= dynamic_size
? dynamic_size
: 1;
2682 is_pie (Filedata
*filedata
)
2684 Elf_Internal_Dyn
*entry
;
2686 if (filedata
->dynamic_size
== 0)
2687 locate_dynamic_section (filedata
);
2688 if (filedata
->dynamic_size
<= 1)
2691 if (!get_dynamic_section (filedata
))
2694 for (entry
= filedata
->dynamic_section
;
2695 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
2698 if (entry
->d_tag
== DT_FLAGS_1
)
2700 if ((entry
->d_un
.d_val
& DF_1_PIE
) != 0)
2709 get_file_type (Filedata
*filedata
)
2711 unsigned e_type
= filedata
->file_header
.e_type
;
2712 static char buff
[64];
2716 case ET_NONE
: return _("NONE (None)");
2717 case ET_REL
: return _("REL (Relocatable file)");
2718 case ET_EXEC
: return _("EXEC (Executable file)");
2720 if (is_pie (filedata
))
2721 return _("DYN (Position-Independent Executable file)");
2723 return _("DYN (Shared object file)");
2724 case ET_CORE
: return _("CORE (Core file)");
2727 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2728 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2729 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2730 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2732 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2738 get_machine_name (unsigned e_machine
)
2740 static char buff
[64]; /* XXX */
2744 /* Please keep this switch table sorted by increasing EM_ value. */
2746 case EM_NONE
: return _("None");
2747 case EM_M32
: return "WE32100";
2748 case EM_SPARC
: return "Sparc";
2749 case EM_386
: return "Intel 80386";
2750 case EM_68K
: return "MC68000";
2751 case EM_88K
: return "MC88000";
2752 case EM_IAMCU
: return "Intel MCU";
2753 case EM_860
: return "Intel 80860";
2754 case EM_MIPS
: return "MIPS R3000";
2755 case EM_S370
: return "IBM System/370";
2757 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2758 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2759 case EM_PARISC
: return "HPPA";
2760 case EM_VPP550
: return "Fujitsu VPP500";
2761 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2762 case EM_960
: return "Intel 80960";
2763 case EM_PPC
: return "PowerPC";
2765 case EM_PPC64
: return "PowerPC64";
2767 case EM_S390
: return "IBM S/390";
2768 case EM_SPU
: return "SPU";
2770 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2771 case EM_FR20
: return "Fujitsu FR20";
2772 case EM_RH32
: return "TRW RH32";
2773 case EM_MCORE
: return "MCORE";
2775 case EM_ARM
: return "ARM";
2776 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2777 case EM_SH
: return "Renesas / SuperH SH";
2778 case EM_SPARCV9
: return "Sparc v9";
2779 case EM_TRICORE
: return "Siemens Tricore";
2780 case EM_ARC
: return "ARC";
2781 case EM_H8_300
: return "Renesas H8/300";
2782 case EM_H8_300H
: return "Renesas H8/300H";
2783 case EM_H8S
: return "Renesas H8S";
2784 case EM_H8_500
: return "Renesas H8/500";
2786 case EM_IA_64
: return "Intel IA-64";
2787 case EM_MIPS_X
: return "Stanford MIPS-X";
2788 case EM_COLDFIRE
: return "Motorola Coldfire";
2789 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2790 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2791 case EM_PCP
: return "Siemens PCP";
2792 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2793 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2794 case EM_STARCORE
: return "Motorola Star*Core processor";
2795 case EM_ME16
: return "Toyota ME16 processor";
2797 case EM_ST100
: return "STMicroelectronics ST100 processor";
2798 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2799 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2800 case EM_PDSP
: return "Sony DSP processor";
2801 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2802 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2803 case EM_FX66
: return "Siemens FX66 microcontroller";
2804 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2805 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2806 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2808 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2809 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2810 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2811 case EM_SVX
: return "Silicon Graphics SVx";
2812 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2813 case EM_VAX
: return "Digital VAX";
2814 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2815 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2816 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2817 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2819 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2820 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2821 case EM_PRISM
: return "Vitesse Prism";
2823 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2824 case EM_CYGNUS_FR30
:
2825 case EM_FR30
: return "Fujitsu FR30";
2826 case EM_CYGNUS_D10V
:
2827 case EM_D10V
: return "d10v";
2828 case EM_CYGNUS_D30V
:
2829 case EM_D30V
: return "d30v";
2830 case EM_CYGNUS_V850
:
2831 case EM_V850
: return "Renesas V850";
2832 case EM_CYGNUS_M32R
:
2833 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2834 case EM_CYGNUS_MN10300
:
2835 case EM_MN10300
: return "mn10300";
2837 case EM_CYGNUS_MN10200
:
2838 case EM_MN10200
: return "mn10200";
2839 case EM_PJ
: return "picoJava";
2840 case EM_OR1K
: return "OpenRISC 1000";
2841 case EM_ARC_COMPACT
: return "ARCompact";
2843 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2844 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2845 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2846 case EM_NS32K
: return "National Semiconductor 32000 series";
2847 case EM_TPC
: return "Tenor Network TPC processor";
2848 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2850 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2852 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2853 case EM_MAX
: return "MAX Processor";
2854 case EM_CR
: return "National Semiconductor CompactRISC";
2855 case EM_F2MC16
: return "Fujitsu F2MC16";
2856 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2857 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2858 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2859 case EM_SEP
: return "Sharp embedded microprocessor";
2860 case EM_ARCA
: return "Arca RISC microprocessor";
2862 case EM_UNICORE
: return "Unicore";
2863 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2864 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2865 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2866 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2867 case EM_XGATE
: return "Motorola XGATE embedded processor";
2869 case EM_XC16X
: return "Infineon Technologies xc16x";
2870 case EM_M16C
: return "Renesas M16C series microprocessors";
2871 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2872 case EM_CE
: return "Freescale Communication Engine RISC core";
2874 case EM_M32C
: return "Renesas M32c";
2876 case EM_TSK3000
: return "Altium TSK3000 core";
2877 case EM_RS08
: return "Freescale RS08 embedded processor";
2878 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2879 case EM_SCORE
: return "SUNPLUS S+Core";
2880 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2881 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2882 case EM_LATTICEMICO32
: return "Lattice Mico32";
2883 case EM_SE_C17
: return "Seiko Epson C17 family";
2885 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2886 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2887 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2888 case EM_TI_PRU
: return "TI PRU I/O processor";
2890 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2891 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2892 case EM_R32C
: return "Renesas R32C series microprocessors";
2893 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2894 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2895 case EM_8051
: return "Intel 8051 and variants";
2896 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2897 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2898 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2899 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2901 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2902 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2903 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2904 case EM_RX
: return "Renesas RX";
2905 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2906 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2907 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2910 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2911 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2912 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2914 case EM_L1OM
: return "Intel L1OM";
2915 case EM_K1OM
: return "Intel K1OM";
2916 case EM_INTEL182
: return "Intel (reserved)";
2917 case EM_AARCH64
: return "AArch64";
2918 case EM_ARM184
: return "ARM (reserved)";
2919 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2920 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2921 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2922 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2924 case EM_CUDA
: return "NVIDIA CUDA architecture";
2925 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2926 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2927 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2928 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2929 case EM_ARC_COMPACT2
: return "ARCv2";
2930 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2931 case EM_RL78
: return "Renesas RL78";
2932 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2933 case EM_78K0R
: return "Renesas 78K0R";
2935 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2936 case EM_BA1
: return "Beyond BA1 CPU architecture";
2937 case EM_BA2
: return "Beyond BA2 CPU architecture";
2938 case EM_XCORE
: return "XMOS xCORE processor family";
2939 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2940 case EM_INTELGT
: return "Intel Graphics Technology";
2942 case EM_KM32
: return "KM211 KM32 32-bit processor";
2943 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2944 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2945 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2946 case EM_KVARC
: return "KM211 KVARC processor";
2947 case EM_CDP
: return "Paneve CDP architecture family";
2948 case EM_COGE
: return "Cognitive Smart Memory Processor";
2949 case EM_COOL
: return "Bluechip Systems CoolEngine";
2950 case EM_NORC
: return "Nanoradio Optimized RISC";
2951 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2953 case EM_Z80
: return "Zilog Z80";
2954 case EM_VISIUM
: return "CDS VISIUMcore processor";
2955 case EM_FT32
: return "FTDI Chip FT32";
2956 case EM_MOXIE
: return "Moxie";
2957 case EM_AMDGPU
: return "AMD GPU";
2958 /* 230 (all reserved) */
2960 case EM_RISCV
: return "RISC-V";
2961 case EM_LANAI
: return "Lanai 32-bit processor";
2962 case EM_CEVA
: return "CEVA Processor Architecture Family";
2963 case EM_CEVA_X2
: return "CEVA X2 Processor Family";
2964 case EM_BPF
: return "Linux BPF";
2965 case EM_GRAPHCORE_IPU
: return "Graphcore Intelligent Processing Unit";
2966 case EM_IMG1
: return "Imagination Technologies";
2968 case EM_NFP
: return "Netronome Flow Processor";
2969 case EM_VE
: return "NEC Vector Engine";
2970 case EM_CSKY
: return "C-SKY";
2971 case EM_ARC_COMPACT3_64
: return "Synopsys ARCv2.3 64-bit";
2972 case EM_MCS6502
: return "MOS Technology MCS 6502 processor";
2973 case EM_ARC_COMPACT3
: return "Synopsys ARCv2.3 32-bit";
2974 case EM_KVX
: return "Kalray VLIW core of the MPPA processor family";
2975 case EM_65816
: return "WDC 65816/65C816";
2976 case EM_LOONGARCH
: return "LoongArch";
2977 case EM_KF32
: return "ChipON KungFu32";
2979 /* Large numbers... */
2980 case EM_MT
: return "Morpho Techologies MT processor";
2981 case EM_ALPHA
: return "Alpha";
2982 case EM_WEBASSEMBLY
: return "Web Assembly";
2983 case EM_DLX
: return "OpenDLX";
2984 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2985 case EM_IQ2000
: return "Vitesse IQ2000";
2987 case EM_NIOS32
: return "Altera Nios";
2988 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2989 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2990 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2991 case EM_S12Z
: return "Freescale S12Z";
2994 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
3000 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
3002 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
3003 other compilers don't specify an architecture type in the e_flags, and
3004 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
3005 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
3008 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
3009 but also sets a specific architecture type in the e_flags field.
3011 However, when decoding the flags we don't worry if we see an
3012 unexpected pairing, for example EM_ARC_COMPACT machine type, with
3013 ARCEM architecture type. */
3015 switch (e_flags
& EF_ARC_MACH_MSK
)
3017 /* We only expect these to occur for EM_ARC_COMPACT2. */
3018 case EF_ARC_CPU_ARCV2EM
:
3019 strcat (buf
, ", ARC EM");
3021 case EF_ARC_CPU_ARCV2HS
:
3022 strcat (buf
, ", ARC HS");
3025 /* We only expect these to occur for EM_ARC_COMPACT. */
3026 case E_ARC_MACH_ARC600
:
3027 strcat (buf
, ", ARC600");
3029 case E_ARC_MACH_ARC601
:
3030 strcat (buf
, ", ARC601");
3032 case E_ARC_MACH_ARC700
:
3033 strcat (buf
, ", ARC700");
3036 /* The only times we should end up here are (a) A corrupt ELF, (b) A
3037 new ELF with new architecture being read by an old version of
3038 readelf, or (c) An ELF built with non-GNU compiler that does not
3039 set the architecture in the e_flags. */
3041 if (e_machine
== EM_ARC_COMPACT
)
3042 strcat (buf
, ", Unknown ARCompact");
3044 strcat (buf
, ", Unknown ARC");
3048 switch (e_flags
& EF_ARC_OSABI_MSK
)
3050 case E_ARC_OSABI_ORIG
:
3051 strcat (buf
, ", (ABI:legacy)");
3053 case E_ARC_OSABI_V2
:
3054 strcat (buf
, ", (ABI:v2)");
3056 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
3057 case E_ARC_OSABI_V3
:
3058 strcat (buf
, ", v3 no-legacy-syscalls ABI");
3060 case E_ARC_OSABI_V4
:
3061 strcat (buf
, ", v4 ABI");
3064 strcat (buf
, ", unrecognised ARC OSABI flag");
3070 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
3073 bool unknown
= false;
3075 eabi
= EF_ARM_EABI_VERSION (e_flags
);
3076 e_flags
&= ~ EF_ARM_EABIMASK
;
3078 /* Handle "generic" ARM flags. */
3079 if (e_flags
& EF_ARM_RELEXEC
)
3081 strcat (buf
, ", relocatable executable");
3082 e_flags
&= ~ EF_ARM_RELEXEC
;
3085 if (e_flags
& EF_ARM_PIC
)
3087 strcat (buf
, ", position independent");
3088 e_flags
&= ~ EF_ARM_PIC
;
3091 /* Now handle EABI specific flags. */
3095 strcat (buf
, ", <unrecognized EABI>");
3100 case EF_ARM_EABI_VER1
:
3101 strcat (buf
, ", Version1 EABI");
3106 /* Process flags one bit at a time. */
3107 flag
= e_flags
& - e_flags
;
3112 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
3113 strcat (buf
, ", sorted symbol tables");
3123 case EF_ARM_EABI_VER2
:
3124 strcat (buf
, ", Version2 EABI");
3129 /* Process flags one bit at a time. */
3130 flag
= e_flags
& - e_flags
;
3135 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
3136 strcat (buf
, ", sorted symbol tables");
3139 case EF_ARM_DYNSYMSUSESEGIDX
:
3140 strcat (buf
, ", dynamic symbols use segment index");
3143 case EF_ARM_MAPSYMSFIRST
:
3144 strcat (buf
, ", mapping symbols precede others");
3154 case EF_ARM_EABI_VER3
:
3155 strcat (buf
, ", Version3 EABI");
3158 case EF_ARM_EABI_VER4
:
3159 strcat (buf
, ", Version4 EABI");
3164 /* Process flags one bit at a time. */
3165 flag
= e_flags
& - e_flags
;
3171 strcat (buf
, ", BE8");
3175 strcat (buf
, ", LE8");
3185 case EF_ARM_EABI_VER5
:
3186 strcat (buf
, ", Version5 EABI");
3191 /* Process flags one bit at a time. */
3192 flag
= e_flags
& - e_flags
;
3198 strcat (buf
, ", BE8");
3202 strcat (buf
, ", LE8");
3205 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
3206 strcat (buf
, ", soft-float ABI");
3209 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
3210 strcat (buf
, ", hard-float ABI");
3220 case EF_ARM_EABI_UNKNOWN
:
3221 strcat (buf
, ", GNU EABI");
3226 /* Process flags one bit at a time. */
3227 flag
= e_flags
& - e_flags
;
3232 case EF_ARM_INTERWORK
:
3233 strcat (buf
, ", interworking enabled");
3236 case EF_ARM_APCS_26
:
3237 strcat (buf
, ", uses APCS/26");
3240 case EF_ARM_APCS_FLOAT
:
3241 strcat (buf
, ", uses APCS/float");
3245 strcat (buf
, ", position independent");
3249 strcat (buf
, ", 8 bit structure alignment");
3252 case EF_ARM_NEW_ABI
:
3253 strcat (buf
, ", uses new ABI");
3256 case EF_ARM_OLD_ABI
:
3257 strcat (buf
, ", uses old ABI");
3260 case EF_ARM_SOFT_FLOAT
:
3261 strcat (buf
, ", software FP");
3264 case EF_ARM_VFP_FLOAT
:
3265 strcat (buf
, ", VFP");
3268 case EF_ARM_MAVERICK_FLOAT
:
3269 strcat (buf
, ", Maverick FP");
3280 strcat (buf
,_(", <unknown>"));
3284 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
3286 --size
; /* Leave space for null terminator. */
3288 switch (e_flags
& EF_AVR_MACH
)
3290 case E_AVR_MACH_AVR1
:
3291 strncat (buf
, ", avr:1", size
);
3293 case E_AVR_MACH_AVR2
:
3294 strncat (buf
, ", avr:2", size
);
3296 case E_AVR_MACH_AVR25
:
3297 strncat (buf
, ", avr:25", size
);
3299 case E_AVR_MACH_AVR3
:
3300 strncat (buf
, ", avr:3", size
);
3302 case E_AVR_MACH_AVR31
:
3303 strncat (buf
, ", avr:31", size
);
3305 case E_AVR_MACH_AVR35
:
3306 strncat (buf
, ", avr:35", size
);
3308 case E_AVR_MACH_AVR4
:
3309 strncat (buf
, ", avr:4", size
);
3311 case E_AVR_MACH_AVR5
:
3312 strncat (buf
, ", avr:5", size
);
3314 case E_AVR_MACH_AVR51
:
3315 strncat (buf
, ", avr:51", size
);
3317 case E_AVR_MACH_AVR6
:
3318 strncat (buf
, ", avr:6", size
);
3320 case E_AVR_MACH_AVRTINY
:
3321 strncat (buf
, ", avr:100", size
);
3323 case E_AVR_MACH_XMEGA1
:
3324 strncat (buf
, ", avr:101", size
);
3326 case E_AVR_MACH_XMEGA2
:
3327 strncat (buf
, ", avr:102", size
);
3329 case E_AVR_MACH_XMEGA3
:
3330 strncat (buf
, ", avr:103", size
);
3332 case E_AVR_MACH_XMEGA4
:
3333 strncat (buf
, ", avr:104", size
);
3335 case E_AVR_MACH_XMEGA5
:
3336 strncat (buf
, ", avr:105", size
);
3338 case E_AVR_MACH_XMEGA6
:
3339 strncat (buf
, ", avr:106", size
);
3341 case E_AVR_MACH_XMEGA7
:
3342 strncat (buf
, ", avr:107", size
);
3345 strncat (buf
, ", avr:<unknown>", size
);
3349 size
-= strlen (buf
);
3350 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
3351 strncat (buf
, ", link-relax", size
);
3355 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
3361 bool has_fpu
= false;
3364 static const char *ABI_STRINGS
[] =
3366 "ABI v0", /* use r5 as return register; only used in N1213HC */
3367 "ABI v1", /* use r0 as return register */
3368 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
3369 "ABI v2fp", /* for FPU */
3373 static const char *VER_STRINGS
[] =
3375 "Andes ELF V1.3 or older",
3379 static const char *ARCH_STRINGS
[] =
3388 abi
= EF_NDS_ABI
& e_flags
;
3389 arch
= EF_NDS_ARCH
& e_flags
;
3390 config
= EF_NDS_INST
& e_flags
;
3391 version
= EF_NDS32_ELF_VERSION
& e_flags
;
3393 memset (buf
, 0, size
);
3400 case E_NDS_ABI_V2FP
:
3401 case E_NDS_ABI_AABI
:
3402 case E_NDS_ABI_V2FP_PLUS
:
3403 /* In case there are holes in the array. */
3404 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
3408 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
3414 case E_NDS32_ELF_VER_1_2
:
3415 case E_NDS32_ELF_VER_1_3
:
3416 case E_NDS32_ELF_VER_1_4
:
3417 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
3421 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
3425 if (E_NDS_ABI_V0
== abi
)
3427 /* OLD ABI; only used in N1213HC, has performance extension 1. */
3428 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
3429 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3430 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
3436 case E_NDS_ARCH_STAR_V1_0
:
3437 case E_NDS_ARCH_STAR_V2_0
:
3438 case E_NDS_ARCH_STAR_V3_0
:
3439 case E_NDS_ARCH_STAR_V3_M
:
3440 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
3444 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
3445 /* ARCH version determines how the e_flags are interpreted.
3446 If it is unknown, we cannot proceed. */
3450 /* Newer ABI; Now handle architecture specific flags. */
3451 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3453 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3454 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
3456 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
3457 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
3459 if (config
& E_NDS32_HAS_DIV_INST
)
3460 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
3462 if (config
& E_NDS32_HAS_16BIT_INST
)
3463 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3467 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3469 if (version
<= E_NDS32_ELF_VER_1_3
)
3470 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
3472 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
3475 if (config
& E_NDS32_HAS_MAC_DX_INST
)
3476 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
3478 if (config
& E_NDS32_HAS_DIV_DX_INST
)
3479 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
3481 if (config
& E_NDS32_HAS_16BIT_INST
)
3483 if (version
<= E_NDS32_ELF_VER_1_3
)
3484 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3486 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3490 if (config
& E_NDS32_HAS_EXT_INST
)
3491 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3493 if (config
& E_NDS32_HAS_EXT2_INST
)
3494 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3496 if (config
& E_NDS32_HAS_FPU_INST
)
3499 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3502 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3505 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3508 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3511 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3516 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3518 case E_NDS32_FPU_REG_8SP_4DP
:
3519 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3521 case E_NDS32_FPU_REG_16SP_8DP
:
3522 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3524 case E_NDS32_FPU_REG_32SP_16DP
:
3525 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3527 case E_NDS32_FPU_REG_32SP_32DP
:
3528 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3533 if (config
& E_NDS32_HAS_AUDIO_INST
)
3534 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3536 if (config
& E_NDS32_HAS_STRING_INST
)
3537 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3539 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3540 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3542 if (config
& E_NDS32_HAS_VIDEO_INST
)
3544 if (version
<= E_NDS32_ELF_VER_1_3
)
3545 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3547 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3550 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3551 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3553 if (config
& E_NDS32_HAS_L2C_INST
)
3554 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3558 decode_AMDGPU_machine_flags (Filedata
*filedata
, unsigned int e_flags
,
3561 unsigned char *e_ident
= filedata
->file_header
.e_ident
;
3562 unsigned char osabi
= e_ident
[EI_OSABI
];
3563 unsigned char abiversion
= e_ident
[EI_ABIVERSION
];
3566 /* HSA OS ABI v2 used a different encoding, but we don't need to support it,
3567 it has been deprecated for a while.
3569 The PAL, MESA3D and NONE OS ABIs are not properly versioned, at the time
3570 of writing, they use the same flags as HSA v3, so the code below uses that
3572 if (osabi
== ELFOSABI_AMDGPU_HSA
&& abiversion
< ELFABIVERSION_AMDGPU_HSA_V3
)
3575 mach
= e_flags
& EF_AMDGPU_MACH
;
3578 #define AMDGPU_CASE(code, string) \
3579 case code: strcat (buf, ", " string); break;
3580 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX600
, "gfx600")
3581 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX601
, "gfx601")
3582 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX700
, "gfx700")
3583 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX701
, "gfx701")
3584 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX702
, "gfx702")
3585 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX703
, "gfx703")
3586 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX704
, "gfx704")
3587 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX801
, "gfx801")
3588 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX802
, "gfx802")
3589 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX803
, "gfx803")
3590 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX810
, "gfx810")
3591 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX900
, "gfx900")
3592 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX902
, "gfx902")
3593 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX904
, "gfx904")
3594 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX906
, "gfx906")
3595 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX908
, "gfx908")
3596 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX909
, "gfx909")
3597 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX90C
, "gfx90c")
3598 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1010
, "gfx1010")
3599 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1011
, "gfx1011")
3600 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1012
, "gfx1012")
3601 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1030
, "gfx1030")
3602 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1031
, "gfx1031")
3603 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1032
, "gfx1032")
3604 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1033
, "gfx1033")
3605 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX602
, "gfx602")
3606 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX705
, "gfx705")
3607 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX805
, "gfx805")
3608 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1035
, "gfx1035")
3609 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1034
, "gfx1034")
3610 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX90A
, "gfx90a")
3611 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX940
, "gfx940")
3612 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1013
, "gfx1013")
3613 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1036
, "gfx1036")
3615 sprintf (buf
, _(", <unknown AMDGPU GPU type: %#x>"), mach
);
3620 buf
+= strlen (buf
);
3621 e_flags
&= ~EF_AMDGPU_MACH
;
3623 if ((osabi
== ELFOSABI_AMDGPU_HSA
3624 && abiversion
== ELFABIVERSION_AMDGPU_HSA_V3
)
3625 || osabi
!= ELFOSABI_AMDGPU_HSA
)
3627 /* For HSA v3 and other OS ABIs. */
3628 if (e_flags
& EF_AMDGPU_FEATURE_XNACK_V3
)
3630 strcat (buf
, ", xnack on");
3631 buf
+= strlen (buf
);
3632 e_flags
&= ~EF_AMDGPU_FEATURE_XNACK_V3
;
3635 if (e_flags
& EF_AMDGPU_FEATURE_SRAMECC_V3
)
3637 strcat (buf
, ", sramecc on");
3638 buf
+= strlen (buf
);
3639 e_flags
&= ~EF_AMDGPU_FEATURE_SRAMECC_V3
;
3647 xnack
= e_flags
& EF_AMDGPU_FEATURE_XNACK_V4
;
3650 case EF_AMDGPU_FEATURE_XNACK_UNSUPPORTED_V4
:
3653 case EF_AMDGPU_FEATURE_XNACK_ANY_V4
:
3654 strcat (buf
, ", xnack any");
3657 case EF_AMDGPU_FEATURE_XNACK_OFF_V4
:
3658 strcat (buf
, ", xnack off");
3661 case EF_AMDGPU_FEATURE_XNACK_ON_V4
:
3662 strcat (buf
, ", xnack on");
3666 sprintf (buf
, _(", <unknown xnack value: %#x>"), xnack
);
3670 buf
+= strlen (buf
);
3671 e_flags
&= ~EF_AMDGPU_FEATURE_XNACK_V4
;
3673 sramecc
= e_flags
& EF_AMDGPU_FEATURE_SRAMECC_V4
;
3676 case EF_AMDGPU_FEATURE_SRAMECC_UNSUPPORTED_V4
:
3679 case EF_AMDGPU_FEATURE_SRAMECC_ANY_V4
:
3680 strcat (buf
, ", sramecc any");
3683 case EF_AMDGPU_FEATURE_SRAMECC_OFF_V4
:
3684 strcat (buf
, ", sramecc off");
3687 case EF_AMDGPU_FEATURE_SRAMECC_ON_V4
:
3688 strcat (buf
, ", sramecc on");
3692 sprintf (buf
, _(", <unknown sramecc value: %#x>"), sramecc
);
3696 buf
+= strlen (buf
);
3697 e_flags
&= ~EF_AMDGPU_FEATURE_SRAMECC_V4
;
3701 sprintf (buf
, _(", unknown flags bits: %#x"), e_flags
);
3705 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3707 static char buf
[1024];
3718 case EM_ARC_COMPACT2
:
3719 case EM_ARC_COMPACT
:
3720 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3724 decode_ARM_machine_flags (e_flags
, buf
);
3728 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3732 if (e_flags
& EF_BFIN_PIC
)
3733 strcat (buf
, ", PIC");
3735 if (e_flags
& EF_BFIN_FDPIC
)
3736 strcat (buf
, ", FDPIC");
3738 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3739 strcat (buf
, ", code in L1");
3741 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3742 strcat (buf
, ", data in L1");
3747 switch (e_flags
& EF_FRV_CPU_MASK
)
3749 case EF_FRV_CPU_GENERIC
:
3753 strcat (buf
, ", fr???");
3756 case EF_FRV_CPU_FR300
:
3757 strcat (buf
, ", fr300");
3760 case EF_FRV_CPU_FR400
:
3761 strcat (buf
, ", fr400");
3763 case EF_FRV_CPU_FR405
:
3764 strcat (buf
, ", fr405");
3767 case EF_FRV_CPU_FR450
:
3768 strcat (buf
, ", fr450");
3771 case EF_FRV_CPU_FR500
:
3772 strcat (buf
, ", fr500");
3774 case EF_FRV_CPU_FR550
:
3775 strcat (buf
, ", fr550");
3778 case EF_FRV_CPU_SIMPLE
:
3779 strcat (buf
, ", simple");
3781 case EF_FRV_CPU_TOMCAT
:
3782 strcat (buf
, ", tomcat");
3788 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3789 strcat (buf
, ", m68000");
3790 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3791 strcat (buf
, ", cpu32");
3792 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3793 strcat (buf
, ", fido_a");
3796 char const * isa
= _("unknown");
3797 char const * mac
= _("unknown mac");
3798 char const * additional
= NULL
;
3800 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3802 case EF_M68K_CF_ISA_A_NODIV
:
3804 additional
= ", nodiv";
3806 case EF_M68K_CF_ISA_A
:
3809 case EF_M68K_CF_ISA_A_PLUS
:
3812 case EF_M68K_CF_ISA_B_NOUSP
:
3814 additional
= ", nousp";
3816 case EF_M68K_CF_ISA_B
:
3819 case EF_M68K_CF_ISA_C
:
3822 case EF_M68K_CF_ISA_C_NODIV
:
3824 additional
= ", nodiv";
3827 strcat (buf
, ", cf, isa ");
3830 strcat (buf
, additional
);
3831 if (e_flags
& EF_M68K_CF_FLOAT
)
3832 strcat (buf
, ", float");
3833 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3838 case EF_M68K_CF_MAC
:
3841 case EF_M68K_CF_EMAC
:
3844 case EF_M68K_CF_EMAC_B
:
3857 decode_AMDGPU_machine_flags (filedata
, e_flags
, buf
);
3861 switch (e_flags
& EF_MEP_CPU_MASK
)
3863 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3864 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3865 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3866 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3867 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3868 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3869 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3872 switch (e_flags
& EF_MEP_COP_MASK
)
3874 case EF_MEP_COP_NONE
: break;
3875 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3876 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3877 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3878 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3879 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3882 if (e_flags
& EF_MEP_LIBRARY
)
3883 strcat (buf
, ", Built for Library");
3885 if (e_flags
& EF_MEP_INDEX_MASK
)
3886 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3887 e_flags
& EF_MEP_INDEX_MASK
);
3889 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3890 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3891 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3895 if (e_flags
& EF_PPC_EMB
)
3896 strcat (buf
, ", emb");
3898 if (e_flags
& EF_PPC_RELOCATABLE
)
3899 strcat (buf
, _(", relocatable"));
3901 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3902 strcat (buf
, _(", relocatable-lib"));
3906 if (e_flags
& EF_PPC64_ABI
)
3908 char abi
[] = ", abiv0";
3910 abi
[6] += e_flags
& EF_PPC64_ABI
;
3916 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3917 strcat (buf
, ", RH850 ABI");
3919 if (e_flags
& EF_V800_850E3
)
3920 strcat (buf
, ", V3 architecture");
3922 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3923 strcat (buf
, ", FPU not used");
3925 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3926 strcat (buf
, ", regmode: COMMON");
3928 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3929 strcat (buf
, ", r4 not used");
3931 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3932 strcat (buf
, ", r30 not used");
3934 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3935 strcat (buf
, ", r5 not used");
3937 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3938 strcat (buf
, ", r2 not used");
3940 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3942 switch (e_flags
& - e_flags
)
3944 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3945 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3946 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3947 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3948 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3949 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3950 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3951 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3952 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3953 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3954 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3955 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3962 case EM_CYGNUS_V850
:
3963 switch (e_flags
& EF_V850_ARCH
)
3965 case E_V850E3V5_ARCH
:
3966 strcat (buf
, ", v850e3v5");
3968 case E_V850E2V3_ARCH
:
3969 strcat (buf
, ", v850e2v3");
3972 strcat (buf
, ", v850e2");
3975 strcat (buf
, ", v850e1");
3978 strcat (buf
, ", v850e");
3981 strcat (buf
, ", v850");
3984 strcat (buf
, _(", unknown v850 architecture variant"));
3990 case EM_CYGNUS_M32R
:
3991 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3992 strcat (buf
, ", m32r");
3996 case EM_MIPS_RS3_LE
:
3997 if (e_flags
& EF_MIPS_NOREORDER
)
3998 strcat (buf
, ", noreorder");
4000 if (e_flags
& EF_MIPS_PIC
)
4001 strcat (buf
, ", pic");
4003 if (e_flags
& EF_MIPS_CPIC
)
4004 strcat (buf
, ", cpic");
4006 if (e_flags
& EF_MIPS_UCODE
)
4007 strcat (buf
, ", ugen_reserved");
4009 if (e_flags
& EF_MIPS_ABI2
)
4010 strcat (buf
, ", abi2");
4012 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
4013 strcat (buf
, ", odk first");
4015 if (e_flags
& EF_MIPS_32BITMODE
)
4016 strcat (buf
, ", 32bitmode");
4018 if (e_flags
& EF_MIPS_NAN2008
)
4019 strcat (buf
, ", nan2008");
4021 if (e_flags
& EF_MIPS_FP64
)
4022 strcat (buf
, ", fp64");
4024 switch ((e_flags
& EF_MIPS_MACH
))
4026 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
4027 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
4028 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
4029 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
4030 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
4031 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
4032 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
4033 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
4034 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
4035 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
4036 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
4037 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
4038 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
4039 case E_MIPS_MACH_GS464
: strcat (buf
, ", gs464"); break;
4040 case E_MIPS_MACH_GS464E
: strcat (buf
, ", gs464e"); break;
4041 case E_MIPS_MACH_GS264E
: strcat (buf
, ", gs264e"); break;
4042 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
4043 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
4044 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
4045 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
4046 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
4048 /* We simply ignore the field in this case to avoid confusion:
4049 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
4052 default: strcat (buf
, _(", unknown CPU")); break;
4055 switch ((e_flags
& EF_MIPS_ABI
))
4057 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
4058 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
4059 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
4060 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
4062 /* We simply ignore the field in this case to avoid confusion:
4063 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
4064 This means it is likely to be an o32 file, but not for
4067 default: strcat (buf
, _(", unknown ABI")); break;
4070 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
4071 strcat (buf
, ", mdmx");
4073 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
4074 strcat (buf
, ", mips16");
4076 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
4077 strcat (buf
, ", micromips");
4079 switch ((e_flags
& EF_MIPS_ARCH
))
4081 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
4082 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
4083 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
4084 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
4085 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
4086 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
4087 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
4088 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
4089 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
4090 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
4091 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
4092 default: strcat (buf
, _(", unknown ISA")); break;
4097 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
4101 switch (EF_NFP_MACH (e_flags
))
4103 case E_NFP_MACH_3200
:
4104 strcat (buf
, ", NFP-32xx");
4106 case E_NFP_MACH_6000
:
4107 strcat (buf
, ", NFP-6xxx");
4113 if (e_flags
& EF_RISCV_RVC
)
4114 strcat (buf
, ", RVC");
4116 if (e_flags
& EF_RISCV_RVE
)
4117 strcat (buf
, ", RVE");
4119 if (e_flags
& EF_RISCV_TSO
)
4120 strcat (buf
, ", TSO");
4122 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
4124 case EF_RISCV_FLOAT_ABI_SOFT
:
4125 strcat (buf
, ", soft-float ABI");
4128 case EF_RISCV_FLOAT_ABI_SINGLE
:
4129 strcat (buf
, ", single-float ABI");
4132 case EF_RISCV_FLOAT_ABI_DOUBLE
:
4133 strcat (buf
, ", double-float ABI");
4136 case EF_RISCV_FLOAT_ABI_QUAD
:
4137 strcat (buf
, ", quad-float ABI");
4143 switch ((e_flags
& EF_SH_MACH_MASK
))
4145 case EF_SH1
: strcat (buf
, ", sh1"); break;
4146 case EF_SH2
: strcat (buf
, ", sh2"); break;
4147 case EF_SH3
: strcat (buf
, ", sh3"); break;
4148 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
4149 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
4150 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
4151 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
4152 case EF_SH4
: strcat (buf
, ", sh4"); break;
4153 case EF_SH5
: strcat (buf
, ", sh5"); break;
4154 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
4155 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
4156 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
4157 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
4158 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
4159 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
4160 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
4161 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
4162 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
4163 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
4164 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
4165 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
4166 default: strcat (buf
, _(", unknown ISA")); break;
4169 if (e_flags
& EF_SH_PIC
)
4170 strcat (buf
, ", pic");
4172 if (e_flags
& EF_SH_FDPIC
)
4173 strcat (buf
, ", fdpic");
4177 if (e_flags
& EF_OR1K_NODELAY
)
4178 strcat (buf
, ", no delay");
4182 if (e_flags
& EF_SPARC_32PLUS
)
4183 strcat (buf
, ", v8+");
4185 if (e_flags
& EF_SPARC_SUN_US1
)
4186 strcat (buf
, ", ultrasparcI");
4188 if (e_flags
& EF_SPARC_SUN_US3
)
4189 strcat (buf
, ", ultrasparcIII");
4191 if (e_flags
& EF_SPARC_HAL_R1
)
4192 strcat (buf
, ", halr1");
4194 if (e_flags
& EF_SPARC_LEDATA
)
4195 strcat (buf
, ", ledata");
4197 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
4198 strcat (buf
, ", tso");
4200 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
4201 strcat (buf
, ", pso");
4203 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
4204 strcat (buf
, ", rmo");
4208 switch (e_flags
& EF_PARISC_ARCH
)
4210 case EFA_PARISC_1_0
:
4211 strcpy (buf
, ", PA-RISC 1.0");
4213 case EFA_PARISC_1_1
:
4214 strcpy (buf
, ", PA-RISC 1.1");
4216 case EFA_PARISC_2_0
:
4217 strcpy (buf
, ", PA-RISC 2.0");
4222 if (e_flags
& EF_PARISC_TRAPNIL
)
4223 strcat (buf
, ", trapnil");
4224 if (e_flags
& EF_PARISC_EXT
)
4225 strcat (buf
, ", ext");
4226 if (e_flags
& EF_PARISC_LSB
)
4227 strcat (buf
, ", lsb");
4228 if (e_flags
& EF_PARISC_WIDE
)
4229 strcat (buf
, ", wide");
4230 if (e_flags
& EF_PARISC_NO_KABP
)
4231 strcat (buf
, ", no kabp");
4232 if (e_flags
& EF_PARISC_LAZYSWAP
)
4233 strcat (buf
, ", lazyswap");
4238 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
4239 strcat (buf
, ", new calling convention");
4241 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
4242 strcat (buf
, ", gnu calling convention");
4246 if ((e_flags
& EF_IA_64_ABI64
))
4247 strcat (buf
, ", 64-bit");
4249 strcat (buf
, ", 32-bit");
4250 if ((e_flags
& EF_IA_64_REDUCEDFP
))
4251 strcat (buf
, ", reduced fp model");
4252 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
4253 strcat (buf
, ", no function descriptors, constant gp");
4254 else if ((e_flags
& EF_IA_64_CONS_GP
))
4255 strcat (buf
, ", constant gp");
4256 if ((e_flags
& EF_IA_64_ABSOLUTE
))
4257 strcat (buf
, ", absolute");
4258 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4260 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
4261 strcat (buf
, ", vms_linkages");
4262 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
4264 case EF_IA_64_VMS_COMCOD_SUCCESS
:
4266 case EF_IA_64_VMS_COMCOD_WARNING
:
4267 strcat (buf
, ", warning");
4269 case EF_IA_64_VMS_COMCOD_ERROR
:
4270 strcat (buf
, ", error");
4272 case EF_IA_64_VMS_COMCOD_ABORT
:
4273 strcat (buf
, ", abort");
4276 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
4277 e_flags
& EF_IA_64_VMS_COMCOD
);
4278 strcat (buf
, ", <unknown>");
4284 if ((e_flags
& EF_VAX_NONPIC
))
4285 strcat (buf
, ", non-PIC");
4286 if ((e_flags
& EF_VAX_DFLOAT
))
4287 strcat (buf
, ", D-Float");
4288 if ((e_flags
& EF_VAX_GFLOAT
))
4289 strcat (buf
, ", G-Float");
4293 if (e_flags
& EF_VISIUM_ARCH_MCM
)
4294 strcat (buf
, ", mcm");
4295 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
4296 strcat (buf
, ", mcm24");
4297 if (e_flags
& EF_VISIUM_ARCH_GR6
)
4298 strcat (buf
, ", gr6");
4302 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
4304 case E_FLAG_RL78_ANY_CPU
: break;
4305 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
4306 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
4307 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
4309 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
4310 strcat (buf
, ", 64-bit doubles");
4314 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
4315 strcat (buf
, ", 64-bit doubles");
4316 if (e_flags
& E_FLAG_RX_DSP
)
4317 strcat (buf
, ", dsp");
4318 if (e_flags
& E_FLAG_RX_PID
)
4319 strcat (buf
, ", pid");
4320 if (e_flags
& E_FLAG_RX_ABI
)
4321 strcat (buf
, ", RX ABI");
4322 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
4323 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
4324 ? ", uses String instructions" : ", bans String instructions");
4325 if (e_flags
& E_FLAG_RX_V2
)
4326 strcat (buf
, ", V2");
4327 if (e_flags
& E_FLAG_RX_V3
)
4328 strcat (buf
, ", V3");
4332 if (e_flags
& EF_S390_HIGH_GPRS
)
4333 strcat (buf
, ", highgprs");
4337 if ((e_flags
& EF_C6000_REL
))
4338 strcat (buf
, ", relocatable module");
4342 strcat (buf
, _(": architecture variant: "));
4343 switch (e_flags
& EF_MSP430_MACH
)
4345 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
4346 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
4347 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
4348 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
4349 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
4350 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
4351 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
4352 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
4353 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
4354 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
4355 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
4356 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
4357 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
4358 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
4359 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
4361 strcat (buf
, _(": unknown")); break;
4364 if (e_flags
& ~ EF_MSP430_MACH
)
4365 strcat (buf
, _(": unknown extra flag bits also present"));
4369 switch (e_flags
& EF_Z80_MACH_MSK
)
4371 case EF_Z80_MACH_Z80
: strcat (buf
, ", Z80"); break;
4372 case EF_Z80_MACH_Z180
: strcat (buf
, ", Z180"); break;
4373 case EF_Z80_MACH_R800
: strcat (buf
, ", R800"); break;
4374 case EF_Z80_MACH_EZ80_Z80
: strcat (buf
, ", EZ80"); break;
4375 case EF_Z80_MACH_EZ80_ADL
: strcat (buf
, ", EZ80, ADL"); break;
4376 case EF_Z80_MACH_GBZ80
: strcat (buf
, ", GBZ80"); break;
4377 case EF_Z80_MACH_Z80N
: strcat (buf
, ", Z80N"); break;
4379 strcat (buf
, _(", unknown")); break;
4383 if (EF_LOONGARCH_IS_SOFT_FLOAT (e_flags
))
4384 strcat (buf
, ", SOFT-FLOAT");
4385 else if (EF_LOONGARCH_IS_SINGLE_FLOAT (e_flags
))
4386 strcat (buf
, ", SINGLE-FLOAT");
4387 else if (EF_LOONGARCH_IS_DOUBLE_FLOAT (e_flags
))
4388 strcat (buf
, ", DOUBLE-FLOAT");
4390 if (EF_LOONGARCH_IS_OBJ_V0 (e_flags
))
4391 strcat (buf
, ", OBJ-v0");
4392 else if (EF_LOONGARCH_IS_OBJ_V1 (e_flags
))
4393 strcat (buf
, ", OBJ-v1");
4403 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
4405 static char buff
[32];
4409 case ELFOSABI_NONE
: return "UNIX - System V";
4410 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
4411 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
4412 case ELFOSABI_GNU
: return "UNIX - GNU";
4413 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
4414 case ELFOSABI_AIX
: return "UNIX - AIX";
4415 case ELFOSABI_IRIX
: return "UNIX - IRIX";
4416 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
4417 case ELFOSABI_TRU64
: return "UNIX - TRU64";
4418 case ELFOSABI_MODESTO
: return "Novell - Modesto";
4419 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
4420 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
4421 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
4422 case ELFOSABI_AROS
: return "AROS";
4423 case ELFOSABI_FENIXOS
: return "FenixOS";
4424 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
4425 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
4428 switch (filedata
->file_header
.e_machine
)
4433 case ELFOSABI_AMDGPU_HSA
: return "AMD HSA";
4434 case ELFOSABI_AMDGPU_PAL
: return "AMD PAL";
4435 case ELFOSABI_AMDGPU_MESA3D
: return "AMD Mesa3D";
4444 case ELFOSABI_ARM
: return "ARM";
4445 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
4456 case ELFOSABI_STANDALONE
: return _("Standalone App");
4465 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
4466 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
4475 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
4481 get_aarch64_segment_type (unsigned long type
)
4485 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
4486 case PT_AARCH64_MEMTAG_MTE
: return "AARCH64_MEMTAG_MTE";
4487 default: return NULL
;
4492 get_arm_segment_type (unsigned long type
)
4496 case PT_ARM_EXIDX
: return "EXIDX";
4497 default: return NULL
;
4502 get_s390_segment_type (unsigned long type
)
4506 case PT_S390_PGSTE
: return "S390_PGSTE";
4507 default: return NULL
;
4512 get_mips_segment_type (unsigned long type
)
4516 case PT_MIPS_REGINFO
: return "REGINFO";
4517 case PT_MIPS_RTPROC
: return "RTPROC";
4518 case PT_MIPS_OPTIONS
: return "OPTIONS";
4519 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
4520 default: return NULL
;
4525 get_parisc_segment_type (unsigned long type
)
4529 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
4530 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
4531 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
4532 default: return NULL
;
4537 get_ia64_segment_type (unsigned long type
)
4541 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
4542 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
4543 default: return NULL
;
4548 get_tic6x_segment_type (unsigned long type
)
4552 case PT_C6000_PHATTR
: return "C6000_PHATTR";
4553 default: return NULL
;
4558 get_riscv_segment_type (unsigned long type
)
4562 case PT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4563 default: return NULL
;
4568 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
4570 if (e_machine
== EM_PARISC
)
4573 case PT_HP_TLS
: return "HP_TLS";
4574 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
4575 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
4576 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
4577 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
4578 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
4579 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
4580 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
4581 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
4582 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
4583 case PT_HP_PARALLEL
: return "HP_PARALLEL";
4584 case PT_HP_FASTBIND
: return "HP_FASTBIND";
4585 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
4586 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
4587 case PT_HP_STACK
: return "HP_STACK";
4588 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
4589 default: return NULL
;
4592 if (e_machine
== EM_IA_64
)
4595 case PT_HP_TLS
: return "HP_TLS";
4596 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
4597 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
4598 case PT_IA_64_HP_STACK
: return "HP_STACK";
4599 default: return NULL
;
4606 get_solaris_segment_type (unsigned long type
)
4610 case 0x6464e550: return "PT_SUNW_UNWIND";
4611 case 0x6474e550: return "PT_SUNW_EH_FRAME";
4612 case 0x6ffffff7: return "PT_LOSUNW";
4613 case 0x6ffffffa: return "PT_SUNWBSS";
4614 case 0x6ffffffb: return "PT_SUNWSTACK";
4615 case 0x6ffffffc: return "PT_SUNWDTRACE";
4616 case 0x6ffffffd: return "PT_SUNWCAP";
4617 case 0x6fffffff: return "PT_HISUNW";
4618 default: return NULL
;
4623 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
4625 static char buff
[32];
4629 case PT_NULL
: return "NULL";
4630 case PT_LOAD
: return "LOAD";
4631 case PT_DYNAMIC
: return "DYNAMIC";
4632 case PT_INTERP
: return "INTERP";
4633 case PT_NOTE
: return "NOTE";
4634 case PT_SHLIB
: return "SHLIB";
4635 case PT_PHDR
: return "PHDR";
4636 case PT_TLS
: return "TLS";
4637 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
4638 case PT_GNU_STACK
: return "GNU_STACK";
4639 case PT_GNU_RELRO
: return "GNU_RELRO";
4640 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
4641 case PT_GNU_SFRAME
: return "GNU_SFRAME";
4643 case PT_OPENBSD_RANDOMIZE
: return "OPENBSD_RANDOMIZE";
4644 case PT_OPENBSD_WXNEEDED
: return "OPENBSD_WXNEEDED";
4645 case PT_OPENBSD_BOOTDATA
: return "OPENBSD_BOOTDATA";
4648 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
4650 const char * result
;
4652 switch (filedata
->file_header
.e_machine
)
4655 result
= get_aarch64_segment_type (p_type
);
4658 result
= get_arm_segment_type (p_type
);
4661 case EM_MIPS_RS3_LE
:
4662 result
= get_mips_segment_type (p_type
);
4665 result
= get_parisc_segment_type (p_type
);
4668 result
= get_ia64_segment_type (p_type
);
4671 result
= get_tic6x_segment_type (p_type
);
4675 result
= get_s390_segment_type (p_type
);
4678 result
= get_riscv_segment_type (p_type
);
4688 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
4690 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
4692 const char * result
= NULL
;
4694 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
4697 case ELFOSABI_FREEBSD
:
4698 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
4700 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
4705 result
= get_hpux_segment_type (p_type
,
4706 filedata
->file_header
.e_machine
);
4708 case ELFOSABI_SOLARIS
:
4709 result
= get_solaris_segment_type (p_type
);
4717 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4720 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4727 get_arc_section_type_name (unsigned int sh_type
)
4731 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4739 get_mips_section_type_name (unsigned int sh_type
)
4743 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4744 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4745 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4746 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4747 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4748 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4749 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4750 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4751 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4752 case SHT_MIPS_RELD
: return "MIPS_RELD";
4753 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4754 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4755 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4756 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4757 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4758 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4759 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4760 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4761 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4762 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4763 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4764 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4765 case SHT_MIPS_LINE
: return "MIPS_LINE";
4766 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4767 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4768 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4769 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4770 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4771 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4772 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4773 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4774 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4775 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4776 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4777 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4778 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4779 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4780 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4781 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4782 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4783 case SHT_MIPS_XHASH
: return "MIPS_XHASH";
4791 get_parisc_section_type_name (unsigned int sh_type
)
4795 case SHT_PARISC_EXT
: return "PARISC_EXT";
4796 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4797 case SHT_PARISC_DOC
: return "PARISC_DOC";
4798 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4799 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4800 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4801 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4802 default: return NULL
;
4807 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4809 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4810 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4811 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4815 case SHT_IA_64_EXT
: return "IA_64_EXT";
4816 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4817 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4818 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4819 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4820 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4821 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4822 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4823 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4824 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4832 get_x86_64_section_type_name (unsigned int sh_type
)
4836 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4837 default: return NULL
;
4842 get_aarch64_section_type_name (unsigned int sh_type
)
4846 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4847 default: return NULL
;
4852 get_arm_section_type_name (unsigned int sh_type
)
4856 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4857 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4858 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4859 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4860 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4861 default: return NULL
;
4866 get_tic6x_section_type_name (unsigned int sh_type
)
4870 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4871 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4872 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4873 case SHT_TI_ICODE
: return "TI_ICODE";
4874 case SHT_TI_XREF
: return "TI_XREF";
4875 case SHT_TI_HANDLER
: return "TI_HANDLER";
4876 case SHT_TI_INITINFO
: return "TI_INITINFO";
4877 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4878 default: return NULL
;
4883 get_msp430_section_type_name (unsigned int sh_type
)
4887 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4888 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4889 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4890 default: return NULL
;
4895 get_nfp_section_type_name (unsigned int sh_type
)
4899 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4900 case SHT_NFP_INITREG
: return "NFP_INITREG";
4901 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4902 default: return NULL
;
4907 get_v850_section_type_name (unsigned int sh_type
)
4911 case SHT_V850_SCOMMON
: return "V850 Small Common";
4912 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4913 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4914 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4915 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4916 default: return NULL
;
4921 get_riscv_section_type_name (unsigned int sh_type
)
4925 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4926 default: return NULL
;
4931 get_csky_section_type_name (unsigned int sh_type
)
4935 case SHT_CSKY_ATTRIBUTES
: return "CSKY_ATTRIBUTES";
4936 default: return NULL
;
4941 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4943 static char buff
[32];
4944 const char * result
;
4948 case SHT_NULL
: return "NULL";
4949 case SHT_PROGBITS
: return "PROGBITS";
4950 case SHT_SYMTAB
: return "SYMTAB";
4951 case SHT_STRTAB
: return "STRTAB";
4952 case SHT_RELA
: return "RELA";
4953 case SHT_RELR
: return "RELR";
4954 case SHT_HASH
: return "HASH";
4955 case SHT_DYNAMIC
: return "DYNAMIC";
4956 case SHT_NOTE
: return "NOTE";
4957 case SHT_NOBITS
: return "NOBITS";
4958 case SHT_REL
: return "REL";
4959 case SHT_SHLIB
: return "SHLIB";
4960 case SHT_DYNSYM
: return "DYNSYM";
4961 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4962 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4963 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4964 case SHT_GNU_HASH
: return "GNU_HASH";
4965 case SHT_GROUP
: return "GROUP";
4966 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4967 case SHT_GNU_verdef
: return "VERDEF";
4968 case SHT_GNU_verneed
: return "VERNEED";
4969 case SHT_GNU_versym
: return "VERSYM";
4970 case 0x6ffffff0: return "VERSYM";
4971 case 0x6ffffffc: return "VERDEF";
4972 case 0x7ffffffd: return "AUXILIARY";
4973 case 0x7fffffff: return "FILTER";
4974 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4977 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4979 switch (filedata
->file_header
.e_machine
)
4982 case EM_ARC_COMPACT
:
4983 case EM_ARC_COMPACT2
:
4984 result
= get_arc_section_type_name (sh_type
);
4987 case EM_MIPS_RS3_LE
:
4988 result
= get_mips_section_type_name (sh_type
);
4991 result
= get_parisc_section_type_name (sh_type
);
4994 result
= get_ia64_section_type_name (filedata
, sh_type
);
4999 result
= get_x86_64_section_type_name (sh_type
);
5002 result
= get_aarch64_section_type_name (sh_type
);
5005 result
= get_arm_section_type_name (sh_type
);
5008 result
= get_tic6x_section_type_name (sh_type
);
5011 result
= get_msp430_section_type_name (sh_type
);
5014 result
= get_nfp_section_type_name (sh_type
);
5018 case EM_CYGNUS_V850
:
5019 result
= get_v850_section_type_name (sh_type
);
5022 result
= get_riscv_section_type_name (sh_type
);
5025 result
= get_csky_section_type_name (sh_type
);
5035 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
5037 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
5039 switch (filedata
->file_header
.e_machine
)
5042 result
= get_ia64_section_type_name (filedata
, sh_type
);
5045 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
5046 result
= get_solaris_section_type (sh_type
);
5051 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
5052 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
5053 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
5054 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
5066 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
5068 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
5070 switch (filedata
->file_header
.e_machine
)
5074 case EM_CYGNUS_V850
:
5075 result
= get_v850_section_type_name (sh_type
);
5085 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
5088 /* This message is probably going to be displayed in a 15
5089 character wide field, so put the hex value first. */
5090 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
5096 enum long_option_values
5098 OPTION_DEBUG_DUMP
= 512,
5109 OPTION_WITH_SYMBOL_VERSIONS
,
5110 OPTION_RECURSE_LIMIT
,
5111 OPTION_NO_RECURSE_LIMIT
,
5112 OPTION_NO_DEMANGLING
,
5116 static struct option options
[] =
5118 /* Note - This table is alpha-sorted on the 'val'
5119 field in order to make adding new options easier. */
5120 {"arch-specific", no_argument
, 0, 'A'},
5121 {"all", no_argument
, 0, 'a'},
5122 {"demangle", optional_argument
, 0, 'C'},
5123 {"archive-index", no_argument
, 0, 'c'},
5124 {"use-dynamic", no_argument
, 0, 'D'},
5125 {"dynamic", no_argument
, 0, 'd'},
5126 {"headers", no_argument
, 0, 'e'},
5127 {"section-groups", no_argument
, 0, 'g'},
5128 {"help", no_argument
, 0, 'H'},
5129 {"file-header", no_argument
, 0, 'h'},
5130 {"histogram", no_argument
, 0, 'I'},
5131 {"lint", no_argument
, 0, 'L'},
5132 {"enable-checks", no_argument
, 0, 'L'},
5133 {"program-headers", no_argument
, 0, 'l'},
5134 {"segments", no_argument
, 0, 'l'},
5135 {"full-section-name",no_argument
, 0, 'N'},
5136 {"notes", no_argument
, 0, 'n'},
5137 {"process-links", no_argument
, 0, 'P'},
5138 {"string-dump", required_argument
, 0, 'p'},
5139 {"relocated-dump", required_argument
, 0, 'R'},
5140 {"relocs", no_argument
, 0, 'r'},
5141 {"section-headers", no_argument
, 0, 'S'},
5142 {"sections", no_argument
, 0, 'S'},
5143 {"symbols", no_argument
, 0, 's'},
5144 {"syms", no_argument
, 0, 's'},
5145 {"silent-truncation",no_argument
, 0, 'T'},
5146 {"section-details", no_argument
, 0, 't'},
5147 {"unicode", required_argument
, NULL
, 'U'},
5148 {"unwind", no_argument
, 0, 'u'},
5149 {"version-info", no_argument
, 0, 'V'},
5150 {"version", no_argument
, 0, 'v'},
5151 {"wide", no_argument
, 0, 'W'},
5152 {"hex-dump", required_argument
, 0, 'x'},
5153 {"decompress", no_argument
, 0, 'z'},
5155 {"no-demangle", no_argument
, 0, OPTION_NO_DEMANGLING
},
5156 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
5157 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
5158 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
5159 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
5160 {"lto-syms", no_argument
, 0, OPTION_LTO_SYMS
},
5161 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
5162 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
5163 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
5164 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
5165 #ifdef ENABLE_LIBCTF
5166 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
5167 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
5168 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
5169 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
5171 {"sframe", optional_argument
, 0, OPTION_SFRAME_DUMP
},
5172 {"sym-base", optional_argument
, 0, OPTION_SYM_BASE
},
5174 {0, no_argument
, 0, 0}
5178 usage (FILE * stream
)
5180 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
5181 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
5182 fprintf (stream
, _(" Options are:\n"));
5183 fprintf (stream
, _("\
5184 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
5185 fprintf (stream
, _("\
5186 -h --file-header Display the ELF file header\n"));
5187 fprintf (stream
, _("\
5188 -l --program-headers Display the program headers\n"));
5189 fprintf (stream
, _("\
5190 --segments An alias for --program-headers\n"));
5191 fprintf (stream
, _("\
5192 -S --section-headers Display the sections' header\n"));
5193 fprintf (stream
, _("\
5194 --sections An alias for --section-headers\n"));
5195 fprintf (stream
, _("\
5196 -g --section-groups Display the section groups\n"));
5197 fprintf (stream
, _("\
5198 -t --section-details Display the section details\n"));
5199 fprintf (stream
, _("\
5200 -e --headers Equivalent to: -h -l -S\n"));
5201 fprintf (stream
, _("\
5202 -s --syms Display the symbol table\n"));
5203 fprintf (stream
, _("\
5204 --symbols An alias for --syms\n"));
5205 fprintf (stream
, _("\
5206 --dyn-syms Display the dynamic symbol table\n"));
5207 fprintf (stream
, _("\
5208 --lto-syms Display LTO symbol tables\n"));
5209 fprintf (stream
, _("\
5210 --sym-base=[0|8|10|16] \n\
5211 Force base for symbol sizes. The options are \n\
5212 mixed (the default), octal, decimal, hexadecimal.\n"));
5213 fprintf (stream
, _("\
5214 -C --demangle[=STYLE] Decode mangled/processed symbol names\n"));
5215 display_demangler_styles (stream
, _("\
5217 fprintf (stream
, _("\
5218 --no-demangle Do not demangle low-level symbol names. (default)\n"));
5219 fprintf (stream
, _("\
5220 --recurse-limit Enable a demangling recursion limit. (default)\n"));
5221 fprintf (stream
, _("\
5222 --no-recurse-limit Disable a demangling recursion limit\n"));
5223 fprintf (stream
, _("\
5224 -U[dlexhi] --unicode=[default|locale|escape|hex|highlight|invalid]\n\
5225 Display unicode characters as determined by the current locale\n\
5226 (default), escape sequences, \"<hex sequences>\", highlighted\n\
5227 escape sequences, or treat them as invalid and display as\n\
5228 \"{hex sequences}\"\n"));
5229 fprintf (stream
, _("\
5230 -n --notes Display the core notes (if present)\n"));
5231 fprintf (stream
, _("\
5232 -r --relocs Display the relocations (if present)\n"));
5233 fprintf (stream
, _("\
5234 -u --unwind Display the unwind info (if present)\n"));
5235 fprintf (stream
, _("\
5236 -d --dynamic Display the dynamic section (if present)\n"));
5237 fprintf (stream
, _("\
5238 -V --version-info Display the version sections (if present)\n"));
5239 fprintf (stream
, _("\
5240 -A --arch-specific Display architecture specific information (if any)\n"));
5241 fprintf (stream
, _("\
5242 -c --archive-index Display the symbol/file index in an archive\n"));
5243 fprintf (stream
, _("\
5244 -D --use-dynamic Use the dynamic section info when displaying symbols\n"));
5245 fprintf (stream
, _("\
5246 -L --lint|--enable-checks\n\
5247 Display warning messages for possible problems\n"));
5248 fprintf (stream
, _("\
5249 -x --hex-dump=<number|name>\n\
5250 Dump the contents of section <number|name> as bytes\n"));
5251 fprintf (stream
, _("\
5252 -p --string-dump=<number|name>\n\
5253 Dump the contents of section <number|name> as strings\n"));
5254 fprintf (stream
, _("\
5255 -R --relocated-dump=<number|name>\n\
5256 Dump the relocated contents of section <number|name>\n"));
5257 fprintf (stream
, _("\
5258 -z --decompress Decompress section before dumping it\n"));
5259 fprintf (stream
, _("\
5260 -w --debug-dump[a/=abbrev, A/=addr, r/=aranges, c/=cu_index, L/=decodedline,\n\
5261 f/=frames, F/=frames-interp, g/=gdb_index, i/=info, o/=loc,\n\
5262 m/=macro, p/=pubnames, t/=pubtypes, R/=Ranges, l/=rawline,\n\
5263 s/=str, O/=str-offsets, u/=trace_abbrev, T/=trace_aranges,\n\
5265 Display the contents of DWARF debug sections\n"));
5266 fprintf (stream
, _("\
5267 -wk --debug-dump=links Display the contents of sections that link to separate\n\
5268 debuginfo files\n"));
5269 fprintf (stream
, _("\
5270 -P --process-links Display the contents of non-debug sections in separate\n\
5271 debuginfo files. (Implies -wK)\n"));
5272 #if DEFAULT_FOR_FOLLOW_LINKS
5273 fprintf (stream
, _("\
5274 -wK --debug-dump=follow-links\n\
5275 Follow links to separate debug info files (default)\n"));
5276 fprintf (stream
, _("\
5277 -wN --debug-dump=no-follow-links\n\
5278 Do not follow links to separate debug info files\n"));
5280 fprintf (stream
, _("\
5281 -wK --debug-dump=follow-links\n\
5282 Follow links to separate debug info files\n"));
5283 fprintf (stream
, _("\
5284 -wN --debug-dump=no-follow-links\n\
5285 Do not follow links to separate debug info files\n\
5288 #if HAVE_LIBDEBUGINFOD
5289 fprintf (stream
, _("\
5290 -wD --debug-dump=use-debuginfod\n\
5291 When following links, also query debuginfod servers (default)\n"));
5292 fprintf (stream
, _("\
5293 -wE --debug-dump=do-not-use-debuginfod\n\
5294 When following links, do not query debuginfod servers\n"));
5296 fprintf (stream
, _("\
5297 --dwarf-depth=N Do not display DIEs at depth N or greater\n"));
5298 fprintf (stream
, _("\
5299 --dwarf-start=N Display DIEs starting at offset N\n"));
5300 #ifdef ENABLE_LIBCTF
5301 fprintf (stream
, _("\
5302 --ctf=<number|name> Display CTF info from section <number|name>\n"));
5303 fprintf (stream
, _("\
5304 --ctf-parent=<name> Use CTF archive member <name> as the CTF parent\n"));
5305 fprintf (stream
, _("\
5306 --ctf-symbols=<number|name>\n\
5307 Use section <number|name> as the CTF external symtab\n"));
5308 fprintf (stream
, _("\
5309 --ctf-strings=<number|name>\n\
5310 Use section <number|name> as the CTF external strtab\n"));
5312 fprintf (stream
, _("\
5313 --sframe[=NAME] Display SFrame info from section NAME, (default '.sframe')\n"));
5315 #ifdef SUPPORT_DISASSEMBLY
5316 fprintf (stream
, _("\
5317 -i --instruction-dump=<number|name>\n\
5318 Disassemble the contents of section <number|name>\n"));
5320 fprintf (stream
, _("\
5321 -I --histogram Display histogram of bucket list lengths\n"));
5322 fprintf (stream
, _("\
5323 -W --wide Allow output width to exceed 80 characters\n"));
5324 fprintf (stream
, _("\
5325 -T --silent-truncation If a symbol name is truncated, do not add [...] suffix\n"));
5326 fprintf (stream
, _("\
5327 @<file> Read options from <file>\n"));
5328 fprintf (stream
, _("\
5329 -H --help Display this information\n"));
5330 fprintf (stream
, _("\
5331 -v --version Display the version number of readelf\n"));
5333 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
5334 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
5336 exit (stream
== stdout
? 0 : 1);
5339 /* Record the fact that the user wants the contents of section number
5340 SECTION to be displayed using the method(s) encoded as flags bits
5341 in TYPE. Note, TYPE can be zero if we are creating the array for
5345 request_dump_bynumber (struct dump_data
*dumpdata
,
5346 unsigned int section
, dump_type type
)
5348 if (section
>= dumpdata
->num_dump_sects
)
5350 dump_type
* new_dump_sects
;
5352 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
5353 sizeof (* new_dump_sects
));
5355 if (new_dump_sects
== NULL
)
5356 error (_("Out of memory allocating dump request table.\n"));
5359 if (dumpdata
->dump_sects
)
5361 /* Copy current flag settings. */
5362 memcpy (new_dump_sects
, dumpdata
->dump_sects
,
5363 dumpdata
->num_dump_sects
* sizeof (* new_dump_sects
));
5365 free (dumpdata
->dump_sects
);
5368 dumpdata
->dump_sects
= new_dump_sects
;
5369 dumpdata
->num_dump_sects
= section
+ 1;
5373 if (dumpdata
->dump_sects
)
5374 dumpdata
->dump_sects
[section
] |= type
;
5377 /* Request a dump by section name. */
5380 request_dump_byname (const char * section
, dump_type type
)
5382 struct dump_list_entry
* new_request
;
5384 new_request
= (struct dump_list_entry
*)
5385 malloc (sizeof (struct dump_list_entry
));
5387 error (_("Out of memory allocating dump request table.\n"));
5389 new_request
->name
= strdup (section
);
5390 if (!new_request
->name
)
5391 error (_("Out of memory allocating dump request table.\n"));
5393 new_request
->type
= type
;
5395 new_request
->next
= dump_sects_byname
;
5396 dump_sects_byname
= new_request
;
5400 request_dump (struct dump_data
*dumpdata
, dump_type type
)
5406 section
= strtoul (optarg
, & cp
, 0);
5408 if (! *cp
&& section
>= 0)
5409 request_dump_bynumber (dumpdata
, section
, type
);
5411 request_dump_byname (optarg
, type
);
5415 parse_args (struct dump_data
*dumpdata
, int argc
, char ** argv
)
5422 while ((c
= getopt_long
5423 (argc
, argv
, "ACDHILNPR:STU:VWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
5441 do_section_groups
= true;
5444 do_histogram
= true;
5450 do_section_groups
= true;
5455 do_section_details
= true;
5466 do_using_dynamic
= true;
5490 do_histogram
= true;
5496 do_archive_index
= true;
5502 process_links
= true;
5503 do_follow_links
= true;
5504 dump_any_debugging
= true;
5507 request_dump (dumpdata
, HEX_DUMP
);
5510 request_dump (dumpdata
, STRING_DUMP
);
5513 request_dump (dumpdata
, RELOC_DUMP
);
5516 decompress_dumps
= true;
5521 do_debugging
= true;
5523 dump_any_debugging
= true;
5524 dwarf_select_sections_all ();
5528 do_debugging
= false;
5529 if (dwarf_select_sections_by_letters (optarg
))
5532 dump_any_debugging
= true;
5536 case OPTION_DEBUG_DUMP
:
5540 do_debugging
= true;
5541 dump_any_debugging
= true;
5542 dwarf_select_sections_all ();
5546 do_debugging
= false;
5547 if (dwarf_select_sections_by_names (optarg
))
5550 dump_any_debugging
= true;
5554 case OPTION_DWARF_DEPTH
:
5558 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
5561 case OPTION_DWARF_START
:
5565 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
5568 case OPTION_DWARF_CHECK
:
5571 case OPTION_CTF_DUMP
:
5573 request_dump (dumpdata
, CTF_DUMP
);
5575 case OPTION_CTF_SYMBOLS
:
5576 free (dump_ctf_symtab_name
);
5577 dump_ctf_symtab_name
= strdup (optarg
);
5579 case OPTION_CTF_STRINGS
:
5580 free (dump_ctf_strtab_name
);
5581 dump_ctf_strtab_name
= strdup (optarg
);
5583 case OPTION_CTF_PARENT
:
5584 free (dump_ctf_parent_name
);
5585 dump_ctf_parent_name
= strdup (optarg
);
5587 case OPTION_SFRAME_DUMP
:
5589 /* Providing section name is optional. request_dump (), however,
5590 thrives on non NULL optarg. Handle it explicitly here. */
5592 request_dump (dumpdata
, SFRAME_DUMP
);
5596 const char *sframe_sec_name
= strdup (".sframe");
5597 request_dump_byname (sframe_sec_name
, SFRAME_DUMP
);
5600 case OPTION_DYN_SYMS
:
5603 case OPTION_LTO_SYMS
:
5606 #ifdef SUPPORT_DISASSEMBLY
5608 request_dump (dumpdata
, DISASS_DUMP
);
5612 print_version (program_name
);
5621 do_not_show_symbol_truncation
= true;
5627 enum demangling_styles style
;
5629 style
= cplus_demangle_name_to_style (optarg
);
5630 if (style
== unknown_demangling
)
5631 error (_("unknown demangling style `%s'"), optarg
);
5633 cplus_demangle_set_style (style
);
5636 case OPTION_NO_DEMANGLING
:
5637 do_demangle
= false;
5639 case OPTION_RECURSE_LIMIT
:
5640 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
5642 case OPTION_NO_RECURSE_LIMIT
:
5643 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
5645 case OPTION_WITH_SYMBOL_VERSIONS
:
5646 /* Ignored for backward compatibility. */
5651 error (_("Missing arg to -U/--unicode")); /* Can this happen ? */
5652 else if (streq (optarg
, "default") || streq (optarg
, "d"))
5653 unicode_display
= unicode_default
;
5654 else if (streq (optarg
, "locale") || streq (optarg
, "l"))
5655 unicode_display
= unicode_locale
;
5656 else if (streq (optarg
, "escape") || streq (optarg
, "e"))
5657 unicode_display
= unicode_escape
;
5658 else if (streq (optarg
, "invalid") || streq (optarg
, "i"))
5659 unicode_display
= unicode_invalid
;
5660 else if (streq (optarg
, "hex") || streq (optarg
, "x"))
5661 unicode_display
= unicode_hex
;
5662 else if (streq (optarg
, "highlight") || streq (optarg
, "h"))
5663 unicode_display
= unicode_highlight
;
5665 error (_("invalid argument to -U/--unicode: %s"), optarg
);
5668 case OPTION_SYM_BASE
:
5672 sym_base
= strtoul (optarg
, NULL
, 0);
5689 /* xgettext:c-format */
5690 error (_("Invalid option '-%c'\n"), c
);
5697 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
5698 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
5699 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
5700 && !do_section_groups
&& !do_archive_index
5701 && !do_dyn_syms
&& !do_lto_syms
)
5706 do_dynamic
= do_syms
= do_reloc
= do_unwind
= do_sections
= true;
5707 do_segments
= do_header
= do_dump
= do_version
= true;
5708 do_histogram
= do_debugging
= do_arch
= do_notes
= true;
5709 do_section_groups
= do_archive_index
= do_dyn_syms
= true;
5718 get_elf_class (unsigned int elf_class
)
5720 static char buff
[32];
5724 case ELFCLASSNONE
: return _("none");
5725 case ELFCLASS32
: return "ELF32";
5726 case ELFCLASS64
: return "ELF64";
5728 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
5734 get_data_encoding (unsigned int encoding
)
5736 static char buff
[32];
5740 case ELFDATANONE
: return _("none");
5741 case ELFDATA2LSB
: return _("2's complement, little endian");
5742 case ELFDATA2MSB
: return _("2's complement, big endian");
5744 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
5750 check_magic_number (Filedata
* filedata
, Elf_Internal_Ehdr
* header
)
5752 if (header
->e_ident
[EI_MAG0
] == ELFMAG0
5753 && header
->e_ident
[EI_MAG1
] == ELFMAG1
5754 && header
->e_ident
[EI_MAG2
] == ELFMAG2
5755 && header
->e_ident
[EI_MAG3
] == ELFMAG3
)
5758 /* Some compilers produce object files that are not in the ELF file format.
5759 As an aid to users of readelf, try to identify these cases and suggest
5762 FIXME: It is not clear if all four bytes are used as constant magic
5763 valus by all compilers. It may be necessary to recode this function if
5764 different tools use different length sequences. */
5768 unsigned char magic
[4];
5769 const char * obj_message
;
5770 const char * ar_message
;
5774 { { 'B', 'C', 0xc0, 0xde },
5775 N_("This is a LLVM bitcode file - try using llvm-bcanalyzer\n"),
5776 N_("This is a LLVM bitcode file - try extracing and then using llvm-bcanalyzer\n")
5778 { { 'g', 'o', ' ', 'o' },
5779 N_("This is a GO binary file - try using 'go tool objdump' or 'go tool nm'\n"),
5785 for (i
= ARRAY_SIZE (known_magic
); i
--;)
5787 if (header
->e_ident
[EI_MAG0
] == known_magic
[i
].magic
[0]
5788 && header
->e_ident
[EI_MAG1
] == known_magic
[i
].magic
[1]
5789 && header
->e_ident
[EI_MAG2
] == known_magic
[i
].magic
[2]
5790 && header
->e_ident
[EI_MAG3
] == known_magic
[i
].magic
[3])
5792 /* Some compiler's analyzer tools do not handle archives,
5793 so we provide two different kinds of error message. */
5794 if (filedata
->archive_file_size
> 0
5795 && known_magic
[i
].ar_message
!= NULL
)
5796 error ("%s", known_magic
[i
].ar_message
);
5798 error ("%s", known_magic
[i
].obj_message
);
5803 error (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
5807 /* Decode the data held in 'filedata->file_header'. */
5810 process_file_header (Filedata
* filedata
)
5812 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
5814 if (! check_magic_number (filedata
, header
))
5817 if (! filedata
->is_separate
)
5818 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
5824 if (filedata
->is_separate
)
5825 printf (_("ELF Header in linked file '%s':\n"), filedata
->file_name
);
5827 printf (_("ELF Header:\n"));
5828 printf (_(" Magic: "));
5829 for (i
= 0; i
< EI_NIDENT
; i
++)
5830 printf ("%2.2x ", header
->e_ident
[i
]);
5832 printf (_(" Class: %s\n"),
5833 get_elf_class (header
->e_ident
[EI_CLASS
]));
5834 printf (_(" Data: %s\n"),
5835 get_data_encoding (header
->e_ident
[EI_DATA
]));
5836 printf (_(" Version: %d%s\n"),
5837 header
->e_ident
[EI_VERSION
],
5838 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
5840 : (header
->e_ident
[EI_VERSION
] != EV_NONE
5843 printf (_(" OS/ABI: %s\n"),
5844 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
5845 printf (_(" ABI Version: %d\n"),
5846 header
->e_ident
[EI_ABIVERSION
]);
5847 printf (_(" Type: %s\n"),
5848 get_file_type (filedata
));
5849 printf (_(" Machine: %s\n"),
5850 get_machine_name (header
->e_machine
));
5851 printf (_(" Version: 0x%lx\n"),
5854 printf (_(" Entry point address: "));
5855 print_vma (header
->e_entry
, PREFIX_HEX
);
5856 printf (_("\n Start of program headers: "));
5857 print_vma (header
->e_phoff
, DEC
);
5858 printf (_(" (bytes into file)\n Start of section headers: "));
5859 print_vma (header
->e_shoff
, DEC
);
5860 printf (_(" (bytes into file)\n"));
5862 printf (_(" Flags: 0x%lx%s\n"),
5864 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
5865 printf (_(" Size of this header: %u (bytes)\n"),
5867 printf (_(" Size of program headers: %u (bytes)\n"),
5868 header
->e_phentsize
);
5869 printf (_(" Number of program headers: %u"),
5871 if (filedata
->section_headers
!= NULL
5872 && header
->e_phnum
== PN_XNUM
5873 && filedata
->section_headers
[0].sh_info
!= 0)
5874 printf (" (%u)", filedata
->section_headers
[0].sh_info
);
5875 putc ('\n', stdout
);
5876 printf (_(" Size of section headers: %u (bytes)\n"),
5877 header
->e_shentsize
);
5878 printf (_(" Number of section headers: %u"),
5880 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
5882 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5883 printf (" (%u)", header
->e_shnum
);
5885 putc ('\n', stdout
);
5886 printf (_(" Section header string table index: %u"),
5887 header
->e_shstrndx
);
5888 if (filedata
->section_headers
!= NULL
5889 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5891 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5892 printf (" (%u)", header
->e_shstrndx
);
5894 if (header
->e_shstrndx
!= SHN_UNDEF
5895 && header
->e_shstrndx
>= header
->e_shnum
)
5897 header
->e_shstrndx
= SHN_UNDEF
;
5898 printf (_(" <corrupt: out of range>"));
5900 putc ('\n', stdout
);
5903 if (filedata
->section_headers
!= NULL
)
5905 if (header
->e_phnum
== PN_XNUM
5906 && filedata
->section_headers
[0].sh_info
!= 0)
5908 /* Throw away any cached read of PN_XNUM headers. */
5909 free (filedata
->program_headers
);
5910 filedata
->program_headers
= NULL
;
5911 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
5913 if (header
->e_shnum
== SHN_UNDEF
)
5914 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5915 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5916 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5917 if (header
->e_shstrndx
>= header
->e_shnum
)
5918 header
->e_shstrndx
= SHN_UNDEF
;
5924 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5925 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
5928 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5930 Elf32_External_Phdr
* phdrs
;
5931 Elf32_External_Phdr
* external
;
5932 Elf_Internal_Phdr
* internal
;
5934 unsigned int size
= filedata
->file_header
.e_phentsize
;
5935 unsigned int num
= filedata
->file_header
.e_phnum
;
5937 /* PR binutils/17531: Cope with unexpected section header sizes. */
5938 if (size
== 0 || num
== 0)
5940 if (size
< sizeof * phdrs
)
5942 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5945 if (size
> sizeof * phdrs
)
5946 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5948 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5949 size
, num
, _("program headers"));
5953 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5954 i
< filedata
->file_header
.e_phnum
;
5955 i
++, internal
++, external
++)
5957 internal
->p_type
= BYTE_GET (external
->p_type
);
5958 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5959 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5960 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5961 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5962 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5963 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5964 internal
->p_align
= BYTE_GET (external
->p_align
);
5971 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5972 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5975 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5977 Elf64_External_Phdr
* phdrs
;
5978 Elf64_External_Phdr
* external
;
5979 Elf_Internal_Phdr
* internal
;
5981 unsigned int size
= filedata
->file_header
.e_phentsize
;
5982 unsigned int num
= filedata
->file_header
.e_phnum
;
5984 /* PR binutils/17531: Cope with unexpected section header sizes. */
5985 if (size
== 0 || num
== 0)
5987 if (size
< sizeof * phdrs
)
5989 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5992 if (size
> sizeof * phdrs
)
5993 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5995 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5996 size
, num
, _("program headers"));
6000 for (i
= 0, internal
= pheaders
, external
= phdrs
;
6001 i
< filedata
->file_header
.e_phnum
;
6002 i
++, internal
++, external
++)
6004 internal
->p_type
= BYTE_GET (external
->p_type
);
6005 internal
->p_flags
= BYTE_GET (external
->p_flags
);
6006 internal
->p_offset
= BYTE_GET (external
->p_offset
);
6007 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
6008 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
6009 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
6010 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
6011 internal
->p_align
= BYTE_GET (external
->p_align
);
6018 /* Returns TRUE if the program headers were read into `program_headers'. */
6021 get_program_headers (Filedata
* filedata
)
6023 Elf_Internal_Phdr
* phdrs
;
6025 /* Check cache of prior read. */
6026 if (filedata
->program_headers
!= NULL
)
6029 /* Be kind to memory checkers by looking for
6030 e_phnum values which we know must be invalid. */
6031 if (filedata
->file_header
.e_phnum
6032 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
6033 >= filedata
->file_size
)
6035 error (_("Too many program headers - %#x - the file is not that big\n"),
6036 filedata
->file_header
.e_phnum
);
6040 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
6041 sizeof (Elf_Internal_Phdr
));
6044 error (_("Out of memory reading %u program headers\n"),
6045 filedata
->file_header
.e_phnum
);
6050 ? get_32bit_program_headers (filedata
, phdrs
)
6051 : get_64bit_program_headers (filedata
, phdrs
))
6053 filedata
->program_headers
= phdrs
;
6061 /* Print program header info and locate dynamic section. */
6064 process_program_headers (Filedata
* filedata
)
6066 Elf_Internal_Phdr
* segment
;
6068 Elf_Internal_Phdr
* previous_load
= NULL
;
6070 if (filedata
->file_header
.e_phnum
== 0)
6072 /* PR binutils/12467. */
6073 if (filedata
->file_header
.e_phoff
!= 0)
6074 warn (_("possibly corrupt ELF header - it has a non-zero program"
6075 " header offset, but no program headers\n"));
6076 else if (do_segments
)
6078 if (filedata
->is_separate
)
6079 printf (_("\nThere are no program headers in linked file '%s'.\n"),
6080 filedata
->file_name
);
6082 printf (_("\nThere are no program headers in this file.\n"));
6087 if (do_segments
&& !do_header
)
6089 if (filedata
->is_separate
)
6090 printf ("\nIn linked file '%s' the ELF file type is %s\n",
6091 filedata
->file_name
, get_file_type (filedata
));
6093 printf (_("\nElf file type is %s\n"), get_file_type (filedata
));
6094 printf (_("Entry point 0x%" PRIx64
"\n"),
6095 filedata
->file_header
.e_entry
);
6096 printf (ngettext ("There is %d program header,"
6097 " starting at offset %" PRIu64
"\n",
6098 "There are %d program headers,"
6099 " starting at offset %" PRIu64
"\n",
6100 filedata
->file_header
.e_phnum
),
6101 filedata
->file_header
.e_phnum
,
6102 filedata
->file_header
.e_phoff
);
6105 if (! get_program_headers (filedata
))
6110 if (filedata
->file_header
.e_phnum
> 1)
6111 printf (_("\nProgram Headers:\n"));
6113 printf (_("\nProgram Headers:\n"));
6117 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
6120 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
6124 (_(" Type Offset VirtAddr PhysAddr\n"));
6126 (_(" FileSiz MemSiz Flags Align\n"));
6130 uint64_t dynamic_addr
= 0;
6131 uint64_t dynamic_size
= 0;
6132 for (i
= 0, segment
= filedata
->program_headers
;
6133 i
< filedata
->file_header
.e_phnum
;
6138 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
6142 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
6143 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
6144 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
6145 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
6146 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
6148 (segment
->p_flags
& PF_R
? 'R' : ' '),
6149 (segment
->p_flags
& PF_W
? 'W' : ' '),
6150 (segment
->p_flags
& PF_X
? 'E' : ' '));
6151 printf ("%#lx", (unsigned long) segment
->p_align
);
6155 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
6156 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
6159 print_vma (segment
->p_offset
, FULL_HEX
);
6163 print_vma (segment
->p_vaddr
, FULL_HEX
);
6165 print_vma (segment
->p_paddr
, FULL_HEX
);
6168 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
6169 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
6172 print_vma (segment
->p_filesz
, FULL_HEX
);
6176 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
6177 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
6180 print_vma (segment
->p_memsz
, FULL_HEX
);
6184 (segment
->p_flags
& PF_R
? 'R' : ' '),
6185 (segment
->p_flags
& PF_W
? 'W' : ' '),
6186 (segment
->p_flags
& PF_X
? 'E' : ' '));
6188 if ((unsigned long) segment
->p_align
== segment
->p_align
)
6189 printf ("%#lx", (unsigned long) segment
->p_align
);
6192 print_vma (segment
->p_align
, PREFIX_HEX
);
6197 print_vma (segment
->p_offset
, FULL_HEX
);
6199 print_vma (segment
->p_vaddr
, FULL_HEX
);
6201 print_vma (segment
->p_paddr
, FULL_HEX
);
6203 print_vma (segment
->p_filesz
, FULL_HEX
);
6205 print_vma (segment
->p_memsz
, FULL_HEX
);
6207 (segment
->p_flags
& PF_R
? 'R' : ' '),
6208 (segment
->p_flags
& PF_W
? 'W' : ' '),
6209 (segment
->p_flags
& PF_X
? 'E' : ' '));
6210 print_vma (segment
->p_align
, PREFIX_HEX
);
6213 putc ('\n', stdout
);
6216 switch (segment
->p_type
)
6219 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
6220 required by the ELF standard, several programs, including the Linux
6221 kernel, make use of non-ordered segments. */
6223 && previous_load
->p_vaddr
> segment
->p_vaddr
)
6224 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
6226 if (segment
->p_memsz
< segment
->p_filesz
)
6227 error (_("the segment's file size is larger than its memory size\n"));
6228 previous_load
= segment
;
6232 /* PR 20815 - Verify that the program header is loaded into memory. */
6233 if (i
> 0 && previous_load
!= NULL
)
6234 error (_("the PHDR segment must occur before any LOAD segment\n"));
6235 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
6239 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
6241 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
6242 if (load
->p_type
== PT_LOAD
6243 && load
->p_offset
<= segment
->p_offset
6244 && (load
->p_offset
+ load
->p_filesz
6245 >= segment
->p_offset
+ segment
->p_filesz
)
6246 && load
->p_vaddr
<= segment
->p_vaddr
6247 && (load
->p_vaddr
+ load
->p_filesz
6248 >= segment
->p_vaddr
+ segment
->p_filesz
))
6251 if (j
== filedata
->file_header
.e_phnum
)
6252 error (_("the PHDR segment is not covered by a LOAD segment\n"));
6258 error (_("more than one dynamic segment\n"));
6260 /* By default, assume that the .dynamic section is the first
6261 section in the DYNAMIC segment. */
6262 dynamic_addr
= segment
->p_offset
;
6263 dynamic_size
= segment
->p_filesz
;
6265 /* Try to locate the .dynamic section. If there is
6266 a section header table, we can easily locate it. */
6267 if (filedata
->section_headers
!= NULL
)
6269 Elf_Internal_Shdr
* sec
;
6271 sec
= find_section (filedata
, ".dynamic");
6272 if (sec
== NULL
|| sec
->sh_size
== 0)
6274 /* A corresponding .dynamic section is expected, but on
6275 IA-64/OpenVMS it is OK for it to be missing. */
6276 if (!is_ia64_vms (filedata
))
6277 error (_("no .dynamic section in the dynamic segment\n"));
6281 if (sec
->sh_type
== SHT_NOBITS
)
6288 dynamic_addr
= sec
->sh_offset
;
6289 dynamic_size
= sec
->sh_size
;
6291 /* The PT_DYNAMIC segment, which is used by the run-time
6292 loader, should exactly match the .dynamic section. */
6294 && (dynamic_addr
!= segment
->p_offset
6295 || dynamic_size
!= segment
->p_filesz
))
6297 the .dynamic section is not the same as the dynamic segment\n"));
6300 /* PR binutils/17512: Avoid corrupt dynamic section info in the
6301 segment. Check this after matching against the section headers
6302 so we don't warn on debuginfo file (which have NOBITS .dynamic
6304 if (dynamic_addr
> filedata
->file_size
6305 || (dynamic_size
> filedata
->file_size
- dynamic_addr
))
6307 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
6314 if (segment
->p_offset
>= filedata
->file_size
6315 || segment
->p_filesz
> filedata
->file_size
- segment
->p_offset
6316 || segment
->p_filesz
- 1 >= (size_t) -2
6317 || fseek64 (filedata
->handle
,
6318 filedata
->archive_file_offset
+ segment
->p_offset
,
6320 error (_("Unable to find program interpreter name\n"));
6323 size_t len
= segment
->p_filesz
;
6324 free (filedata
->program_interpreter
);
6325 filedata
->program_interpreter
= xmalloc (len
+ 1);
6326 len
= fread (filedata
->program_interpreter
, 1, len
,
6328 filedata
->program_interpreter
[len
] = 0;
6331 printf (_(" [Requesting program interpreter: %s]\n"),
6332 filedata
->program_interpreter
);
6339 && filedata
->section_headers
!= NULL
6340 && filedata
->string_table
!= NULL
)
6342 printf (_("\n Section to Segment mapping:\n"));
6343 printf (_(" Segment Sections...\n"));
6345 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
6348 Elf_Internal_Shdr
* section
;
6350 segment
= filedata
->program_headers
+ i
;
6351 section
= filedata
->section_headers
+ 1;
6353 printf (" %2.2d ", i
);
6355 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
6357 if (!ELF_TBSS_SPECIAL (section
, segment
)
6358 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
6359 printf ("%s ", printable_section_name (filedata
, section
));
6366 filedata
->dynamic_addr
= dynamic_addr
;
6367 filedata
->dynamic_size
= dynamic_size
? dynamic_size
: 1;
6371 filedata
->dynamic_addr
= 0;
6372 filedata
->dynamic_size
= 1;
6376 /* Find the file offset corresponding to VMA by using the program headers. */
6379 offset_from_vma (Filedata
* filedata
, uint64_t vma
, uint64_t size
)
6381 Elf_Internal_Phdr
* seg
;
6383 if (! get_program_headers (filedata
))
6385 warn (_("Cannot interpret virtual addresses without program headers.\n"));
6389 for (seg
= filedata
->program_headers
;
6390 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
6393 if (seg
->p_type
!= PT_LOAD
)
6396 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
6397 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
6398 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
6401 warn (_("Virtual address %#" PRIx64
6402 " not located in any PT_LOAD segment.\n"), vma
);
6407 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
6408 If PROBE is true, this is just a probe and we do not generate any error
6409 messages if the load fails. */
6412 get_32bit_section_headers (Filedata
* filedata
, bool probe
)
6414 Elf32_External_Shdr
* shdrs
;
6415 Elf_Internal_Shdr
* internal
;
6417 unsigned int size
= filedata
->file_header
.e_shentsize
;
6418 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
6420 /* PR binutils/17531: Cope with unexpected section header sizes. */
6421 if (size
== 0 || num
== 0)
6424 /* The section header cannot be at the start of the file - that is
6425 where the ELF file header is located. A file with absolutely no
6426 sections in it will use a shoff of 0. */
6427 if (filedata
->file_header
.e_shoff
== 0)
6430 if (size
< sizeof * shdrs
)
6433 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
6436 if (!probe
&& size
> sizeof * shdrs
)
6437 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
6439 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
6441 probe
? NULL
: _("section headers"));
6445 filedata
->section_headers
= (Elf_Internal_Shdr
*)
6446 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
6447 if (filedata
->section_headers
== NULL
)
6450 error (_("Out of memory reading %u section headers\n"), num
);
6455 for (i
= 0, internal
= filedata
->section_headers
;
6459 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
6460 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
6461 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
6462 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
6463 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
6464 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
6465 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
6466 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
6467 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
6468 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
6469 if (!probe
&& internal
->sh_link
> num
)
6470 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
6471 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
6472 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
6479 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
6482 get_64bit_section_headers (Filedata
* filedata
, bool probe
)
6484 Elf64_External_Shdr
* shdrs
;
6485 Elf_Internal_Shdr
* internal
;
6487 unsigned int size
= filedata
->file_header
.e_shentsize
;
6488 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
6490 /* PR binutils/17531: Cope with unexpected section header sizes. */
6491 if (size
== 0 || num
== 0)
6494 /* The section header cannot be at the start of the file - that is
6495 where the ELF file header is located. A file with absolutely no
6496 sections in it will use a shoff of 0. */
6497 if (filedata
->file_header
.e_shoff
== 0)
6500 if (size
< sizeof * shdrs
)
6503 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
6507 if (! probe
&& size
> sizeof * shdrs
)
6508 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
6510 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
6511 filedata
->file_header
.e_shoff
,
6513 probe
? NULL
: _("section headers"));
6517 filedata
->section_headers
= (Elf_Internal_Shdr
*)
6518 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
6519 if (filedata
->section_headers
== NULL
)
6522 error (_("Out of memory reading %u section headers\n"), num
);
6527 for (i
= 0, internal
= filedata
->section_headers
;
6531 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
6532 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
6533 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
6534 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
6535 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
6536 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
6537 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
6538 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
6539 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
6540 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
6541 if (!probe
&& internal
->sh_link
> num
)
6542 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
6543 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
6544 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
6552 get_section_headers (Filedata
*filedata
, bool probe
)
6554 if (filedata
->section_headers
!= NULL
)
6558 return get_32bit_section_headers (filedata
, probe
);
6560 return get_64bit_section_headers (filedata
, probe
);
6563 static Elf_Internal_Sym
*
6564 get_32bit_elf_symbols (Filedata
*filedata
,
6565 Elf_Internal_Shdr
*section
,
6566 uint64_t *num_syms_return
)
6568 uint64_t number
= 0;
6569 Elf32_External_Sym
* esyms
= NULL
;
6570 Elf_External_Sym_Shndx
* shndx
= NULL
;
6571 Elf_Internal_Sym
* isyms
= NULL
;
6572 Elf_Internal_Sym
* psym
;
6574 elf_section_list
* entry
;
6576 if (section
->sh_size
== 0)
6578 if (num_syms_return
!= NULL
)
6579 * num_syms_return
= 0;
6583 /* Run some sanity checks first. */
6584 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
6586 error (_("Section %s has an invalid sh_entsize of %#" PRIx64
"\n"),
6587 printable_section_name (filedata
, section
),
6588 section
->sh_entsize
);
6592 if (section
->sh_size
> filedata
->file_size
)
6594 error (_("Section %s has an invalid sh_size of %#" PRIx64
"\n"),
6595 printable_section_name (filedata
, section
),
6600 number
= section
->sh_size
/ section
->sh_entsize
;
6602 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
6604 error (_("Size (%#" PRIx64
") of section %s "
6605 "is not a multiple of its sh_entsize (%#" PRIx64
")\n"),
6607 printable_section_name (filedata
, section
),
6608 section
->sh_entsize
);
6612 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
6613 section
->sh_size
, _("symbols"));
6618 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
6620 if (entry
->hdr
->sh_link
!= (size_t) (section
- filedata
->section_headers
))
6625 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
6629 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
6630 entry
->hdr
->sh_offset
,
6631 1, entry
->hdr
->sh_size
,
6632 _("symbol table section indices"));
6636 /* PR17531: file: heap-buffer-overflow */
6637 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
6639 error (_("Index section %s has an sh_size of %#" PRIx64
" - expected %#" PRIx64
"\n"),
6640 printable_section_name (filedata
, entry
->hdr
),
6641 entry
->hdr
->sh_size
,
6647 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
6651 error (_("Out of memory reading %" PRIu64
" symbols\n"), number
);
6655 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
6657 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
6658 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
6659 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
6660 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
6661 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
6663 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
6664 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
6665 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
6666 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
6667 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
6674 if (num_syms_return
!= NULL
)
6675 * num_syms_return
= isyms
== NULL
? 0 : number
;
6680 static Elf_Internal_Sym
*
6681 get_64bit_elf_symbols (Filedata
*filedata
,
6682 Elf_Internal_Shdr
*section
,
6683 uint64_t *num_syms_return
)
6685 uint64_t number
= 0;
6686 Elf64_External_Sym
* esyms
= NULL
;
6687 Elf_External_Sym_Shndx
* shndx
= NULL
;
6688 Elf_Internal_Sym
* isyms
= NULL
;
6689 Elf_Internal_Sym
* psym
;
6691 elf_section_list
* entry
;
6693 if (section
->sh_size
== 0)
6695 if (num_syms_return
!= NULL
)
6696 * num_syms_return
= 0;
6700 /* Run some sanity checks first. */
6701 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
6703 error (_("Section %s has an invalid sh_entsize of %#" PRIx64
"\n"),
6704 printable_section_name (filedata
, section
),
6705 section
->sh_entsize
);
6709 if (section
->sh_size
> filedata
->file_size
)
6711 error (_("Section %s has an invalid sh_size of %#" PRIx64
"\n"),
6712 printable_section_name (filedata
, section
),
6717 number
= section
->sh_size
/ section
->sh_entsize
;
6719 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
6721 error (_("Size (%#" PRIx64
") of section %s "
6722 "is not a multiple of its sh_entsize (%#" PRIx64
")\n"),
6724 printable_section_name (filedata
, section
),
6725 section
->sh_entsize
);
6729 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
6730 section
->sh_size
, _("symbols"));
6735 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
6737 if (entry
->hdr
->sh_link
!= (size_t) (section
- filedata
->section_headers
))
6742 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
6746 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
6747 entry
->hdr
->sh_offset
,
6748 1, entry
->hdr
->sh_size
,
6749 _("symbol table section indices"));
6753 /* PR17531: file: heap-buffer-overflow */
6754 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
6756 error (_("Index section %s has an sh_size of %#" PRIx64
" - expected %#" PRIx64
"\n"),
6757 printable_section_name (filedata
, entry
->hdr
),
6758 entry
->hdr
->sh_size
,
6764 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
6768 error (_("Out of memory reading %" PRIu64
" symbols\n"), number
);
6772 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
6774 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
6775 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
6776 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
6777 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
6779 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
6781 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
6782 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
6783 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
6785 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
6786 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
6793 if (num_syms_return
!= NULL
)
6794 * num_syms_return
= isyms
== NULL
? 0 : number
;
6799 static Elf_Internal_Sym
*
6800 get_elf_symbols (Filedata
*filedata
,
6801 Elf_Internal_Shdr
*section
,
6802 uint64_t *num_syms_return
)
6805 return get_32bit_elf_symbols (filedata
, section
, num_syms_return
);
6807 return get_64bit_elf_symbols (filedata
, section
, num_syms_return
);
6811 get_elf_section_flags (Filedata
* filedata
, uint64_t sh_flags
)
6813 static char buff
[1024];
6815 unsigned int field_size
= is_32bit_elf
? 8 : 16;
6817 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
6818 uint64_t os_flags
= 0;
6819 uint64_t proc_flags
= 0;
6820 uint64_t unknown_flags
= 0;
6828 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
6829 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
6830 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
6831 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
6832 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
6833 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
6834 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
6835 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
6836 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
6837 /* 9 */ { STRING_COMMA_LEN ("TLS") },
6838 /* IA-64 specific. */
6839 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
6840 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
6841 /* IA-64 OpenVMS specific. */
6842 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
6843 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
6844 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
6845 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
6846 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
6847 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
6849 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
6850 /* SPARC specific. */
6851 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
6852 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
6854 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
6855 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
6856 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
6858 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
6860 /* 25 */ { STRING_COMMA_LEN ("VLE") },
6862 /* 26 */ { STRING_COMMA_LEN ("GNU_RETAIN") },
6865 if (do_section_details
)
6867 sprintf (buff
, "[%*.*lx]: ",
6868 field_size
, field_size
, (unsigned long) sh_flags
);
6869 p
+= field_size
+ 4;
6876 flag
= sh_flags
& - sh_flags
;
6879 if (do_section_details
)
6883 case SHF_WRITE
: sindex
= 0; break;
6884 case SHF_ALLOC
: sindex
= 1; break;
6885 case SHF_EXECINSTR
: sindex
= 2; break;
6886 case SHF_MERGE
: sindex
= 3; break;
6887 case SHF_STRINGS
: sindex
= 4; break;
6888 case SHF_INFO_LINK
: sindex
= 5; break;
6889 case SHF_LINK_ORDER
: sindex
= 6; break;
6890 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
6891 case SHF_GROUP
: sindex
= 8; break;
6892 case SHF_TLS
: sindex
= 9; break;
6893 case SHF_EXCLUDE
: sindex
= 18; break;
6894 case SHF_COMPRESSED
: sindex
= 20; break;
6898 switch (filedata
->file_header
.e_machine
)
6901 if (flag
== SHF_IA_64_SHORT
)
6903 else if (flag
== SHF_IA_64_NORECOV
)
6905 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
6908 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
6909 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
6910 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
6911 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
6912 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
6913 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
6923 case EM_OLD_SPARCV9
:
6924 case EM_SPARC32PLUS
:
6927 if (flag
== SHF_ORDERED
)
6934 case SHF_ENTRYSECT
: sindex
= 21; break;
6935 case SHF_ARM_PURECODE
: sindex
= 22; break;
6936 case SHF_COMDEF
: sindex
= 23; break;
6941 if (flag
== SHF_PPC_VLE
)
6948 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
6951 case ELFOSABI_FREEBSD
:
6952 if (flag
== SHF_GNU_RETAIN
)
6956 if (flag
== SHF_GNU_MBIND
)
6957 /* We should not recognize SHF_GNU_MBIND for
6958 ELFOSABI_NONE, but binutils as of 2019-07-23 did
6959 not set the EI_OSABI header byte. */
6970 if (p
!= buff
+ field_size
+ 4)
6972 if (size
< (10 + 2))
6974 warn (_("Internal error: not enough buffer room for section flag info"));
6975 return _("<unknown>");
6982 size
-= flags
[sindex
].len
;
6983 p
= stpcpy (p
, flags
[sindex
].str
);
6985 else if (flag
& SHF_MASKOS
)
6987 else if (flag
& SHF_MASKPROC
)
6990 unknown_flags
|= flag
;
6996 case SHF_WRITE
: *p
= 'W'; break;
6997 case SHF_ALLOC
: *p
= 'A'; break;
6998 case SHF_EXECINSTR
: *p
= 'X'; break;
6999 case SHF_MERGE
: *p
= 'M'; break;
7000 case SHF_STRINGS
: *p
= 'S'; break;
7001 case SHF_INFO_LINK
: *p
= 'I'; break;
7002 case SHF_LINK_ORDER
: *p
= 'L'; break;
7003 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
7004 case SHF_GROUP
: *p
= 'G'; break;
7005 case SHF_TLS
: *p
= 'T'; break;
7006 case SHF_EXCLUDE
: *p
= 'E'; break;
7007 case SHF_COMPRESSED
: *p
= 'C'; break;
7010 if ((filedata
->file_header
.e_machine
== EM_X86_64
7011 || filedata
->file_header
.e_machine
== EM_L1OM
7012 || filedata
->file_header
.e_machine
== EM_K1OM
)
7013 && flag
== SHF_X86_64_LARGE
)
7015 else if (filedata
->file_header
.e_machine
== EM_ARM
7016 && flag
== SHF_ARM_PURECODE
)
7018 else if (filedata
->file_header
.e_machine
== EM_PPC
7019 && flag
== SHF_PPC_VLE
)
7021 else if (flag
& SHF_MASKOS
)
7023 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
7026 case ELFOSABI_FREEBSD
:
7027 if (flag
== SHF_GNU_RETAIN
)
7034 if (flag
== SHF_GNU_MBIND
)
7036 /* We should not recognize SHF_GNU_MBIND for
7037 ELFOSABI_NONE, but binutils as of 2019-07-23 did
7038 not set the EI_OSABI header byte. */
7045 sh_flags
&= ~SHF_MASKOS
;
7049 else if (flag
& SHF_MASKPROC
)
7052 sh_flags
&= ~ SHF_MASKPROC
;
7062 if (do_section_details
)
7066 size
-= 5 + field_size
;
7067 if (p
!= buff
+ field_size
+ 4)
7071 warn (_("Internal error: not enough buffer room for section flag info"));
7072 return _("<unknown>");
7078 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
7079 (unsigned long) os_flags
);
7080 p
+= 5 + field_size
;
7084 size
-= 7 + field_size
;
7085 if (p
!= buff
+ field_size
+ 4)
7089 warn (_("Internal error: not enough buffer room for section flag info"));
7090 return _("<unknown>");
7096 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
7097 (unsigned long) proc_flags
);
7098 p
+= 7 + field_size
;
7102 size
-= 10 + field_size
;
7103 if (p
!= buff
+ field_size
+ 4)
7107 warn (_("Internal error: not enough buffer room for section flag info"));
7108 return _("<unknown>");
7114 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
7115 (unsigned long) unknown_flags
);
7116 p
+= 10 + field_size
;
7124 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
7125 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
,
7130 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
7132 if (size
< sizeof (* echdr
))
7134 error (_("Compressed section is too small even for a compression header\n"));
7138 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
7139 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
7140 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
7141 return sizeof (*echdr
);
7145 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
7147 if (size
< sizeof (* echdr
))
7149 error (_("Compressed section is too small even for a compression header\n"));
7153 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
7154 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
7155 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
7156 return sizeof (*echdr
);
7161 process_section_headers (Filedata
* filedata
)
7163 Elf_Internal_Shdr
* section
;
7166 if (filedata
->file_header
.e_shnum
== 0)
7168 /* PR binutils/12467. */
7169 if (filedata
->file_header
.e_shoff
!= 0)
7171 warn (_("possibly corrupt ELF file header - it has a non-zero"
7172 " section header offset, but no section headers\n"));
7175 else if (do_sections
)
7176 printf (_("\nThere are no sections in this file.\n"));
7181 if (do_sections
&& !do_header
)
7183 if (filedata
->is_separate
&& process_links
)
7184 printf (_("In linked file '%s': "), filedata
->file_name
);
7185 if (! filedata
->is_separate
|| process_links
)
7186 printf (ngettext ("There is %d section header, "
7187 "starting at offset %#" PRIx64
":\n",
7188 "There are %d section headers, "
7189 "starting at offset %#" PRIx64
":\n",
7190 filedata
->file_header
.e_shnum
),
7191 filedata
->file_header
.e_shnum
,
7192 filedata
->file_header
.e_shoff
);
7195 if (!get_section_headers (filedata
, false))
7198 /* Read in the string table, so that we have names to display. */
7199 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
7200 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
7202 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
7204 if (section
->sh_size
!= 0)
7206 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
7207 1, section
->sh_size
,
7210 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
7214 /* Scan the sections for the dynamic symbol table
7215 and dynamic string table and debug sections. */
7216 eh_addr_size
= is_32bit_elf
? 4 : 8;
7217 switch (filedata
->file_header
.e_machine
)
7220 case EM_MIPS_RS3_LE
:
7221 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
7222 FDE addresses. However, the ABI also has a semi-official ILP32
7223 variant for which the normal FDE address size rules apply.
7225 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
7226 section, where XX is the size of longs in bits. Unfortunately,
7227 earlier compilers provided no way of distinguishing ILP32 objects
7228 from LP64 objects, so if there's any doubt, we should assume that
7229 the official LP64 form is being used. */
7230 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
7231 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
7237 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
7239 case E_H8_MACH_H8300
:
7240 case E_H8_MACH_H8300HN
:
7241 case E_H8_MACH_H8300SN
:
7242 case E_H8_MACH_H8300SXN
:
7245 case E_H8_MACH_H8300H
:
7246 case E_H8_MACH_H8300S
:
7247 case E_H8_MACH_H8300SX
:
7255 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
7257 case EF_M32C_CPU_M16C
:
7264 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
7267 uint64_t expected_entsize = is_32bit_elf ? size32 : size64; \
7268 if (section->sh_entsize != expected_entsize) \
7270 error (_("Section %d has invalid sh_entsize of %" PRIx64 "\n"), \
7271 i, section->sh_entsize); \
7272 error (_("(Using the expected size of %" PRIx64 " for the rest of this dump)\n"), \
7273 expected_entsize); \
7274 section->sh_entsize = expected_entsize; \
7279 #define CHECK_ENTSIZE(section, i, type) \
7280 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
7281 sizeof (Elf64_External_##type))
7283 for (i
= 0, section
= filedata
->section_headers
;
7284 i
< filedata
->file_header
.e_shnum
;
7287 const char *name
= section_name_print (filedata
, section
);
7289 /* Run some sanity checks on the headers and
7290 possibly fill in some file data as well. */
7291 switch (section
->sh_type
)
7294 if (filedata
->dynamic_symbols
!= NULL
)
7296 error (_("File contains multiple dynamic symbol tables\n"));
7300 CHECK_ENTSIZE (section
, i
, Sym
);
7301 filedata
->dynamic_symbols
7302 = get_elf_symbols (filedata
, section
, &filedata
->num_dynamic_syms
);
7303 filedata
->dynamic_symtab_section
= section
;
7307 if (streq (name
, ".dynstr"))
7309 if (filedata
->dynamic_strings
!= NULL
)
7311 error (_("File contains multiple dynamic string tables\n"));
7315 filedata
->dynamic_strings
7316 = (char *) get_data (NULL
, filedata
, section
->sh_offset
,
7317 1, section
->sh_size
, _("dynamic strings"));
7318 filedata
->dynamic_strings_length
7319 = filedata
->dynamic_strings
== NULL
? 0 : section
->sh_size
;
7320 filedata
->dynamic_strtab_section
= section
;
7324 case SHT_SYMTAB_SHNDX
:
7326 elf_section_list
* entry
= xmalloc (sizeof * entry
);
7328 entry
->hdr
= section
;
7329 entry
->next
= filedata
->symtab_shndx_list
;
7330 filedata
->symtab_shndx_list
= entry
;
7335 CHECK_ENTSIZE (section
, i
, Sym
);
7339 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
7343 CHECK_ENTSIZE (section
, i
, Rel
);
7344 if (do_checks
&& section
->sh_size
== 0)
7345 warn (_("Section '%s': zero-sized relocation section\n"), name
);
7349 CHECK_ENTSIZE (section
, i
, Rela
);
7350 if (do_checks
&& section
->sh_size
== 0)
7351 warn (_("Section '%s': zero-sized relocation section\n"), name
);
7355 CHECK_ENTSIZE (section
, i
, Relr
);
7360 /* Having a zero sized section is not illegal according to the
7361 ELF standard, but it might be an indication that something
7362 is wrong. So issue a warning if we are running in lint mode. */
7363 if (do_checks
&& section
->sh_size
== 0)
7364 warn (_("Section '%s': has a size of zero - is this intended ?\n"), name
);
7371 if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
7372 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
7373 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
7374 || do_debug_str
|| do_debug_str_offsets
|| do_debug_loc
7376 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
7377 && (startswith (name
, ".debug_")
7378 || startswith (name
, ".zdebug_")))
7381 name
+= sizeof (".zdebug_") - 1;
7383 name
+= sizeof (".debug_") - 1;
7386 || (do_debug_info
&& startswith (name
, "info"))
7387 || (do_debug_info
&& startswith (name
, "types"))
7388 || (do_debug_abbrevs
&& startswith (name
, "abbrev"))
7389 || (do_debug_lines
&& strcmp (name
, "line") == 0)
7390 || (do_debug_lines
&& startswith (name
, "line."))
7391 || (do_debug_pubnames
&& startswith (name
, "pubnames"))
7392 || (do_debug_pubtypes
&& startswith (name
, "pubtypes"))
7393 || (do_debug_pubnames
&& startswith (name
, "gnu_pubnames"))
7394 || (do_debug_pubtypes
&& startswith (name
, "gnu_pubtypes"))
7395 || (do_debug_aranges
&& startswith (name
, "aranges"))
7396 || (do_debug_ranges
&& startswith (name
, "ranges"))
7397 || (do_debug_ranges
&& startswith (name
, "rnglists"))
7398 || (do_debug_frames
&& startswith (name
, "frame"))
7399 || (do_debug_macinfo
&& startswith (name
, "macinfo"))
7400 || (do_debug_macinfo
&& startswith (name
, "macro"))
7401 || (do_debug_str
&& startswith (name
, "str"))
7402 || (do_debug_links
&& startswith (name
, "sup"))
7403 || (do_debug_str_offsets
&& startswith (name
, "str_offsets"))
7404 || (do_debug_loc
&& startswith (name
, "loc"))
7405 || (do_debug_loc
&& startswith (name
, "loclists"))
7406 || (do_debug_addr
&& startswith (name
, "addr"))
7407 || (do_debug_cu_index
&& startswith (name
, "cu_index"))
7408 || (do_debug_cu_index
&& startswith (name
, "tu_index"))
7410 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7412 /* Linkonce section to be combined with .debug_info at link time. */
7413 else if ((do_debugging
|| do_debug_info
)
7414 && startswith (name
, ".gnu.linkonce.wi."))
7415 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7416 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
7417 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7418 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
7419 || streq (name
, ".debug_names")))
7420 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7421 /* Trace sections for Itanium VMS. */
7422 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
7423 || do_trace_aranges
)
7424 && startswith (name
, ".trace_"))
7426 name
+= sizeof (".trace_") - 1;
7429 || (do_trace_info
&& streq (name
, "info"))
7430 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
7431 || (do_trace_aranges
&& streq (name
, "aranges"))
7433 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7435 else if ((do_debugging
|| do_debug_links
)
7436 && (startswith (name
, ".gnu_debuglink")
7437 || startswith (name
, ".gnu_debugaltlink")))
7438 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7444 if (filedata
->is_separate
&& ! process_links
)
7447 if (filedata
->is_separate
)
7448 printf (_("\nSection Headers in linked file '%s':\n"), filedata
->file_name
);
7449 else if (filedata
->file_header
.e_shnum
> 1)
7450 printf (_("\nSection Headers:\n"));
7452 printf (_("\nSection Header:\n"));
7456 if (do_section_details
)
7458 printf (_(" [Nr] Name\n"));
7459 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
7463 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
7467 if (do_section_details
)
7469 printf (_(" [Nr] Name\n"));
7470 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
7474 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
7478 if (do_section_details
)
7480 printf (_(" [Nr] Name\n"));
7481 printf (_(" Type Address Offset Link\n"));
7482 printf (_(" Size EntSize Info Align\n"));
7486 printf (_(" [Nr] Name Type Address Offset\n"));
7487 printf (_(" Size EntSize Flags Link Info Align\n"));
7491 if (do_section_details
)
7492 printf (_(" Flags\n"));
7494 for (i
= 0, section
= filedata
->section_headers
;
7495 i
< filedata
->file_header
.e_shnum
;
7498 /* Run some sanity checks on the section header. */
7500 /* Check the sh_link field. */
7501 switch (section
->sh_type
)
7505 if (section
->sh_link
== 0
7506 && (filedata
->file_header
.e_type
== ET_EXEC
7507 || filedata
->file_header
.e_type
== ET_DYN
))
7508 /* A dynamic relocation section where all entries use a
7509 zero symbol index need not specify a symtab section. */
7512 case SHT_SYMTAB_SHNDX
:
7516 case SHT_GNU_versym
:
7517 if (section
->sh_link
== 0
7518 || section
->sh_link
>= filedata
->file_header
.e_shnum
7519 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
7520 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
7521 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
7522 i
, section
->sh_link
);
7528 case SHT_GNU_verneed
:
7529 case SHT_GNU_verdef
:
7530 case SHT_GNU_LIBLIST
:
7531 if (section
->sh_link
== 0
7532 || section
->sh_link
>= filedata
->file_header
.e_shnum
7533 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
7534 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
7535 i
, section
->sh_link
);
7538 case SHT_INIT_ARRAY
:
7539 case SHT_FINI_ARRAY
:
7540 case SHT_PREINIT_ARRAY
:
7541 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
7542 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
7543 i
, section
->sh_link
);
7547 /* FIXME: Add support for target specific section types. */
7548 #if 0 /* Currently we do not check other section types as there are too
7549 many special cases. Stab sections for example have a type
7550 of SHT_PROGBITS but an sh_link field that links to the .stabstr
7552 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
7553 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
7554 i
, section
->sh_link
);
7559 /* Check the sh_info field. */
7560 switch (section
->sh_type
)
7564 if (section
->sh_info
== 0
7565 && (filedata
->file_header
.e_type
== ET_EXEC
7566 || filedata
->file_header
.e_type
== ET_DYN
))
7567 /* Dynamic relocations apply to segments, so they do not
7568 need to specify the section they relocate. */
7570 if (section
->sh_info
== 0
7571 || section
->sh_info
>= filedata
->file_header
.e_shnum
7572 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
7573 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
7574 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
7575 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
7576 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
7577 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
7578 /* FIXME: Are other section types valid ? */
7579 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
7580 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
7581 i
, section
->sh_info
);
7586 case SHT_SYMTAB_SHNDX
:
7587 case SHT_INIT_ARRAY
:
7588 case SHT_FINI_ARRAY
:
7589 case SHT_PREINIT_ARRAY
:
7590 if (section
->sh_info
!= 0)
7591 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
7592 i
, section
->sh_info
);
7598 /* A symbol index - we assume that it is valid. */
7602 /* FIXME: Add support for target specific section types. */
7603 if (section
->sh_type
== SHT_NOBITS
)
7604 /* NOBITS section headers with non-zero sh_info fields can be
7605 created when a binary is stripped of everything but its debug
7606 information. The stripped sections have their headers
7607 preserved but their types set to SHT_NOBITS. So do not check
7608 this type of section. */
7610 else if (section
->sh_flags
& SHF_INFO_LINK
)
7612 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
7613 warn (_("[%2u]: Expected link to another section in info field"), i
);
7615 else if (section
->sh_type
< SHT_LOOS
7616 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
7617 && section
->sh_info
!= 0)
7618 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
7619 i
, section
->sh_info
);
7623 /* Check the sh_size field. */
7624 if (section
->sh_size
> filedata
->file_size
7625 && section
->sh_type
!= SHT_NOBITS
7626 && section
->sh_type
!= SHT_NULL
7627 && section
->sh_type
< SHT_LOOS
)
7628 warn (_("Size of section %u is larger than the entire file!\n"), i
);
7630 printf (" [%2u] ", i
);
7631 if (do_section_details
)
7632 printf ("%s\n ", printable_section_name (filedata
, section
));
7634 print_symbol (-17, section_name_print (filedata
, section
));
7636 printf (do_wide
? " %-15s " : " %-15.15s ",
7637 get_section_type_name (filedata
, section
->sh_type
));
7641 const char * link_too_big
= NULL
;
7643 print_vma (section
->sh_addr
, LONG_HEX
);
7645 printf ( " %6.6lx %6.6lx %2.2lx",
7646 (unsigned long) section
->sh_offset
,
7647 (unsigned long) section
->sh_size
,
7648 (unsigned long) section
->sh_entsize
);
7650 if (do_section_details
)
7651 fputs (" ", stdout
);
7653 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
7655 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
7658 /* The sh_link value is out of range. Normally this indicates
7659 an error but it can have special values in Solaris binaries. */
7660 switch (filedata
->file_header
.e_machine
)
7667 case EM_OLD_SPARCV9
:
7668 case EM_SPARC32PLUS
:
7671 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
7672 link_too_big
= "BEFORE";
7673 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
7674 link_too_big
= "AFTER";
7681 if (do_section_details
)
7683 if (link_too_big
!= NULL
&& * link_too_big
)
7684 printf ("<%s> ", link_too_big
);
7686 printf ("%2u ", section
->sh_link
);
7687 printf ("%3u %2lu\n", section
->sh_info
,
7688 (unsigned long) section
->sh_addralign
);
7691 printf ("%2u %3u %2lu\n",
7694 (unsigned long) section
->sh_addralign
);
7696 if (link_too_big
&& ! * link_too_big
)
7697 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
7698 i
, section
->sh_link
);
7702 print_vma (section
->sh_addr
, LONG_HEX
);
7704 if ((long) section
->sh_offset
== section
->sh_offset
)
7705 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
7709 print_vma (section
->sh_offset
, LONG_HEX
);
7712 if ((unsigned long) section
->sh_size
== section
->sh_size
)
7713 printf (" %6.6lx", (unsigned long) section
->sh_size
);
7717 print_vma (section
->sh_size
, LONG_HEX
);
7720 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
7721 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
7725 print_vma (section
->sh_entsize
, LONG_HEX
);
7728 if (do_section_details
)
7729 fputs (" ", stdout
);
7731 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
7733 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
7735 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
7736 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
7739 print_vma (section
->sh_addralign
, DEC
);
7743 else if (do_section_details
)
7746 print_vma (section
->sh_addr
, LONG_HEX
);
7747 if ((long) section
->sh_offset
== section
->sh_offset
)
7748 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
7752 print_vma (section
->sh_offset
, LONG_HEX
);
7754 printf (" %u\n ", section
->sh_link
);
7755 print_vma (section
->sh_size
, LONG_HEX
);
7757 print_vma (section
->sh_entsize
, LONG_HEX
);
7759 printf (" %-16u %lu\n",
7761 (unsigned long) section
->sh_addralign
);
7766 print_vma (section
->sh_addr
, LONG_HEX
);
7767 if ((long) section
->sh_offset
== section
->sh_offset
)
7768 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
7772 print_vma (section
->sh_offset
, LONG_HEX
);
7775 print_vma (section
->sh_size
, LONG_HEX
);
7777 print_vma (section
->sh_entsize
, LONG_HEX
);
7779 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
7781 printf (" %2u %3u %lu\n",
7784 (unsigned long) section
->sh_addralign
);
7787 if (do_section_details
)
7789 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
7790 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
7792 /* Minimum section size is 12 bytes for 32-bit compression
7793 header + 12 bytes for compressed data header. */
7794 unsigned char buf
[24];
7796 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
7797 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
7798 sizeof (buf
), _("compression header")))
7800 Elf_Internal_Chdr chdr
;
7802 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
7803 printf (_(" [<corrupt>]\n"));
7806 if (chdr
.ch_type
== ch_compress_zlib
)
7808 else if (chdr
.ch_type
== ch_compress_zstd
)
7811 printf (_(" [<unknown>: 0x%x], "),
7813 print_vma (chdr
.ch_size
, LONG_HEX
);
7814 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
7821 if (!do_section_details
)
7823 /* The ordering of the letters shown here matches the ordering of the
7824 corresponding SHF_xxx values, and hence the order in which these
7825 letters will be displayed to the user. */
7826 printf (_("Key to Flags:\n\
7827 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
7828 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
7829 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
7830 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
7833 case ELFOSABI_FREEBSD
:
7834 printf (_("R (retain), "));
7837 printf (_("D (mbind), "));
7842 if (filedata
->file_header
.e_machine
== EM_X86_64
7843 || filedata
->file_header
.e_machine
== EM_L1OM
7844 || filedata
->file_header
.e_machine
== EM_K1OM
)
7845 printf (_("l (large), "));
7846 else if (filedata
->file_header
.e_machine
== EM_ARM
)
7847 printf (_("y (purecode), "));
7848 else if (filedata
->file_header
.e_machine
== EM_PPC
)
7849 printf (_("v (VLE), "));
7850 printf ("p (processor specific)\n");
7857 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
7858 Elf_Internal_Sym
**symtab
, uint64_t *nsyms
,
7859 char **strtab
, uint64_t *strtablen
)
7863 *symtab
= get_elf_symbols (filedata
, symsec
, nsyms
);
7865 if (*symtab
== NULL
)
7868 if (symsec
->sh_link
!= 0)
7870 Elf_Internal_Shdr
*strsec
;
7872 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
7874 error (_("Bad sh_link in symbol table section\n"));
7881 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7883 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7884 1, strsec
->sh_size
, _("string table"));
7885 if (*strtab
== NULL
)
7892 *strtablen
= strsec
->sh_size
;
7898 get_group_flags (unsigned int flags
)
7900 static char buff
[128];
7904 else if (flags
== GRP_COMDAT
)
7907 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
7909 flags
& GRP_MASKOS
? _("<OS specific>") : "",
7910 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
7911 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
7912 ? _("<unknown>") : ""));
7918 process_section_groups (Filedata
* filedata
)
7920 Elf_Internal_Shdr
* section
;
7922 struct group
* group
;
7923 Elf_Internal_Shdr
* symtab_sec
;
7924 Elf_Internal_Shdr
* strtab_sec
;
7925 Elf_Internal_Sym
* symtab
;
7930 /* Don't process section groups unless needed. */
7931 if (!do_unwind
&& !do_section_groups
)
7934 if (filedata
->file_header
.e_shnum
== 0)
7936 if (do_section_groups
)
7938 if (filedata
->is_separate
)
7939 printf (_("\nThere are no sections group in linked file '%s'.\n"),
7940 filedata
->file_name
);
7942 printf (_("\nThere are no section groups in this file.\n"));
7947 if (filedata
->section_headers
== NULL
)
7949 error (_("Section headers are not available!\n"));
7950 /* PR 13622: This can happen with a corrupt ELF header. */
7954 filedata
->section_headers_groups
7955 = (struct group
**) calloc (filedata
->file_header
.e_shnum
,
7956 sizeof (struct group
*));
7958 if (filedata
->section_headers_groups
== NULL
)
7960 error (_("Out of memory reading %u section group headers\n"),
7961 filedata
->file_header
.e_shnum
);
7965 /* Scan the sections for the group section. */
7966 filedata
->group_count
= 0;
7967 for (i
= 0, section
= filedata
->section_headers
;
7968 i
< filedata
->file_header
.e_shnum
;
7970 if (section
->sh_type
== SHT_GROUP
)
7971 filedata
->group_count
++;
7973 if (filedata
->group_count
== 0)
7975 if (do_section_groups
)
7977 if (filedata
->is_separate
)
7978 printf (_("\nThere are no section groups in linked file '%s'.\n"),
7979 filedata
->file_name
);
7981 printf (_("\nThere are no section groups in this file.\n"));
7987 filedata
->section_groups
= (struct group
*) calloc (filedata
->group_count
,
7988 sizeof (struct group
));
7990 if (filedata
->section_groups
== NULL
)
7992 error (_("Out of memory reading %zu groups\n"), filedata
->group_count
);
8003 if (filedata
->is_separate
)
8004 printf (_("Section groups in linked file '%s'\n"), filedata
->file_name
);
8006 for (i
= 0, section
= filedata
->section_headers
, group
= filedata
->section_groups
;
8007 i
< filedata
->file_header
.e_shnum
;
8010 if (section
->sh_type
== SHT_GROUP
)
8012 const char * name
= printable_section_name (filedata
, section
);
8013 const char * group_name
;
8014 unsigned char * start
;
8015 unsigned char * indices
;
8016 unsigned int entry
, j
, size
;
8017 Elf_Internal_Shdr
* sec
;
8018 Elf_Internal_Sym
* sym
;
8020 /* Get the symbol table. */
8021 if (section
->sh_link
>= filedata
->file_header
.e_shnum
8022 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
8025 error (_("Bad sh_link in group section `%s'\n"), name
);
8029 if (symtab_sec
!= sec
)
8033 symtab
= get_elf_symbols (filedata
, symtab_sec
, & num_syms
);
8038 error (_("Corrupt header in group section `%s'\n"), name
);
8042 if (section
->sh_info
>= num_syms
)
8044 error (_("Bad sh_info in group section `%s'\n"), name
);
8048 sym
= symtab
+ section
->sh_info
;
8050 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
8052 if (sym
->st_shndx
== 0
8053 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
8055 error (_("Bad sh_info in group section `%s'\n"), name
);
8059 group_name
= section_name_print (filedata
,
8060 filedata
->section_headers
8069 /* Get the string table. */
8070 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
8078 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
8083 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
8084 1, strtab_sec
->sh_size
,
8086 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
8088 group_name
= sym
->st_name
< strtab_size
8089 ? strtab
+ sym
->st_name
: _("<corrupt>");
8092 /* PR 17531: file: loop. */
8093 if (section
->sh_entsize
> section
->sh_size
)
8095 error (_("Section %s has sh_entsize (%#" PRIx64
")"
8096 " which is larger than its size (%#" PRIx64
")\n"),
8097 printable_section_name (filedata
, section
),
8098 section
->sh_entsize
,
8103 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
8104 1, section
->sh_size
,
8110 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
8111 entry
= byte_get (indices
, 4);
8114 if (do_section_groups
)
8116 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
8117 get_group_flags (entry
), i
, name
, group_name
, size
);
8119 printf (_(" [Index] Name\n"));
8122 group
->group_index
= i
;
8124 for (j
= 0; j
< size
; j
++)
8126 struct group_list
* g
;
8128 entry
= byte_get (indices
, 4);
8131 if (entry
>= filedata
->file_header
.e_shnum
)
8133 static unsigned num_group_errors
= 0;
8135 if (num_group_errors
++ < 10)
8137 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
8138 entry
, i
, filedata
->file_header
.e_shnum
- 1);
8139 if (num_group_errors
== 10)
8140 warn (_("Further error messages about overlarge group section indices suppressed\n"));
8145 if (filedata
->section_headers_groups
[entry
] != NULL
)
8149 static unsigned num_errs
= 0;
8151 if (num_errs
++ < 10)
8153 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
8155 filedata
->section_headers_groups
[entry
]->group_index
);
8157 warn (_("Further error messages about already contained group sections suppressed\n"));
8163 /* Intel C/C++ compiler may put section 0 in a
8164 section group. We just warn it the first time
8165 and ignore it afterwards. */
8166 static bool warned
= false;
8169 error (_("section 0 in group section [%5u]\n"),
8170 filedata
->section_headers_groups
[entry
]->group_index
);
8176 filedata
->section_headers_groups
[entry
] = group
;
8178 if (do_section_groups
)
8180 sec
= filedata
->section_headers
+ entry
;
8181 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
8184 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
8185 g
->section_index
= entry
;
8186 g
->next
= group
->root
;
8201 /* Data used to display dynamic fixups. */
8203 struct ia64_vms_dynfixup
8205 uint64_t needed_ident
; /* Library ident number. */
8206 uint64_t needed
; /* Index in the dstrtab of the library name. */
8207 uint64_t fixup_needed
; /* Index of the library. */
8208 uint64_t fixup_rela_cnt
; /* Number of fixups. */
8209 uint64_t fixup_rela_off
; /* Fixups offset in the dynamic segment. */
8212 /* Data used to display dynamic relocations. */
8214 struct ia64_vms_dynimgrela
8216 uint64_t img_rela_cnt
; /* Number of relocations. */
8217 uint64_t img_rela_off
; /* Reloc offset in the dynamic segment. */
8220 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
8224 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
8225 struct ia64_vms_dynfixup
* fixup
,
8226 const char * strtab
,
8227 unsigned int strtab_sz
)
8229 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
8231 const char * lib_name
;
8233 imfs
= get_data (NULL
, filedata
,
8234 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
8235 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
8236 _("dynamic section image fixups"));
8240 if (fixup
->needed
< strtab_sz
)
8241 lib_name
= strtab
+ fixup
->needed
;
8244 warn (_("corrupt library name index of %#" PRIx64
8245 " found in dynamic entry"), fixup
->needed
);
8249 printf (_("\nImage fixups for needed library #%" PRId64
8250 ": %s - ident: %" PRIx64
"\n"),
8251 fixup
->fixup_needed
, lib_name
, fixup
->needed_ident
);
8253 (_("Seg Offset Type SymVec DataType\n"));
8255 for (i
= 0; i
< (size_t) fixup
->fixup_rela_cnt
; i
++)
8260 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
8261 printf ("%016" PRIx64
" ", BYTE_GET (imfs
[i
].fixup_offset
));
8262 type
= BYTE_GET (imfs
[i
].type
);
8263 rtype
= elf_ia64_reloc_type (type
);
8265 printf ("0x%08x ", type
);
8267 printf ("%-32s ", rtype
);
8268 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
8269 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
8276 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
8279 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
8281 Elf64_External_VMS_IMAGE_RELA
*imrs
;
8284 imrs
= get_data (NULL
, filedata
,
8285 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
8286 sizeof (*imrs
), imgrela
->img_rela_cnt
,
8287 _("dynamic section image relocations"));
8291 printf (_("\nImage relocs\n"));
8293 (_("Seg Offset Type Addend Seg Sym Off\n"));
8295 for (i
= 0; i
< (size_t) imgrela
->img_rela_cnt
; i
++)
8300 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
8301 printf ("%08" PRIx64
" ", BYTE_GET (imrs
[i
].rela_offset
));
8302 type
= BYTE_GET (imrs
[i
].type
);
8303 rtype
= elf_ia64_reloc_type (type
);
8305 printf ("0x%08x ", type
);
8307 printf ("%-31s ", rtype
);
8308 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
8309 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
8310 printf ("%08" PRIx64
"\n", BYTE_GET (imrs
[i
].sym_offset
));
8317 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
8320 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
8322 struct ia64_vms_dynfixup fixup
;
8323 struct ia64_vms_dynimgrela imgrela
;
8324 Elf_Internal_Dyn
*entry
;
8325 uint64_t strtab_off
= 0;
8326 uint64_t strtab_sz
= 0;
8327 char *strtab
= NULL
;
8330 memset (&fixup
, 0, sizeof (fixup
));
8331 memset (&imgrela
, 0, sizeof (imgrela
));
8333 /* Note: the order of the entries is specified by the OpenVMS specs. */
8334 for (entry
= filedata
->dynamic_section
;
8335 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
8338 switch (entry
->d_tag
)
8340 case DT_IA_64_VMS_STRTAB_OFFSET
:
8341 strtab_off
= entry
->d_un
.d_val
;
8344 strtab_sz
= entry
->d_un
.d_val
;
8346 strtab
= get_data (NULL
, filedata
,
8347 filedata
->dynamic_addr
+ strtab_off
,
8348 1, strtab_sz
, _("dynamic string section"));
8353 case DT_IA_64_VMS_NEEDED_IDENT
:
8354 fixup
.needed_ident
= entry
->d_un
.d_val
;
8357 fixup
.needed
= entry
->d_un
.d_val
;
8359 case DT_IA_64_VMS_FIXUP_NEEDED
:
8360 fixup
.fixup_needed
= entry
->d_un
.d_val
;
8362 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
8363 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
8365 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
8366 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
8367 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
8370 case DT_IA_64_VMS_IMG_RELA_CNT
:
8371 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
8373 case DT_IA_64_VMS_IMG_RELA_OFF
:
8374 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
8375 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
8394 relocation_type rel_type
;
8396 dynamic_relocations
[] =
8398 { "REL", DT_REL
, DT_RELSZ
, reltype_rel
},
8399 { "RELA", DT_RELA
, DT_RELASZ
, reltype_rela
},
8400 { "RELR", DT_RELR
, DT_RELRSZ
, reltype_relr
},
8401 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, reltype_unknown
}
8404 /* Process the reloc section. */
8407 process_relocs (Filedata
* filedata
)
8410 uint64_t rel_offset
;
8415 if (do_using_dynamic
)
8417 relocation_type rel_type
;
8419 bool has_dynamic_reloc
;
8422 has_dynamic_reloc
= false;
8424 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
8426 rel_type
= dynamic_relocations
[i
].rel_type
;
8427 name
= dynamic_relocations
[i
].name
;
8428 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
8429 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
8432 has_dynamic_reloc
= true;
8434 if (rel_type
== reltype_unknown
)
8436 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
8437 switch (filedata
->dynamic_info
[DT_PLTREL
])
8440 rel_type
= reltype_rel
;
8443 rel_type
= reltype_rela
;
8450 if (filedata
->is_separate
)
8452 (_("\nIn linked file '%s' section '%s' at offset %#" PRIx64
8453 " contains %" PRId64
" bytes:\n"),
8454 filedata
->file_name
, name
, rel_offset
, rel_size
);
8457 (_("\n'%s' relocation section at offset %#" PRIx64
8458 " contains %" PRId64
" bytes:\n"),
8459 name
, rel_offset
, rel_size
);
8461 dump_relocations (filedata
,
8462 offset_from_vma (filedata
, rel_offset
, rel_size
),
8464 filedata
->dynamic_symbols
,
8465 filedata
->num_dynamic_syms
,
8466 filedata
->dynamic_strings
,
8467 filedata
->dynamic_strings_length
,
8468 rel_type
, true /* is_dynamic */);
8472 if (is_ia64_vms (filedata
))
8473 if (process_ia64_vms_dynamic_relocs (filedata
))
8474 has_dynamic_reloc
= true;
8476 if (! has_dynamic_reloc
)
8478 if (filedata
->is_separate
)
8479 printf (_("\nThere are no dynamic relocations in linked file '%s'.\n"),
8480 filedata
->file_name
);
8482 printf (_("\nThere are no dynamic relocations in this file.\n"));
8487 Elf_Internal_Shdr
* section
;
8491 for (i
= 0, section
= filedata
->section_headers
;
8492 i
< filedata
->file_header
.e_shnum
;
8495 if ( section
->sh_type
!= SHT_RELA
8496 && section
->sh_type
!= SHT_REL
8497 && section
->sh_type
!= SHT_RELR
)
8500 rel_offset
= section
->sh_offset
;
8501 rel_size
= section
->sh_size
;
8505 relocation_type rel_type
;
8508 if (filedata
->is_separate
)
8509 printf (_("\nIn linked file '%s' relocation section "),
8510 filedata
->file_name
);
8512 printf (_("\nRelocation section "));
8514 if (filedata
->string_table
== NULL
)
8515 printf ("%d", section
->sh_name
);
8517 printf ("'%s'", printable_section_name (filedata
, section
));
8519 num_rela
= rel_size
/ section
->sh_entsize
;
8520 printf (ngettext (" at offset %#" PRIx64
8521 " contains %" PRIu64
" entry:\n",
8522 " at offset %#" PRIx64
8523 " contains %" PRId64
" entries:\n",
8525 rel_offset
, num_rela
);
8527 rel_type
= section
->sh_type
== SHT_RELA
? reltype_rela
:
8528 section
->sh_type
== SHT_REL
? reltype_rel
: reltype_relr
;
8530 if (section
->sh_link
!= 0
8531 && section
->sh_link
< filedata
->file_header
.e_shnum
)
8533 Elf_Internal_Shdr
*symsec
;
8534 Elf_Internal_Sym
*symtab
;
8536 uint64_t strtablen
= 0;
8537 char *strtab
= NULL
;
8539 symsec
= filedata
->section_headers
+ section
->sh_link
;
8540 if (symsec
->sh_type
!= SHT_SYMTAB
8541 && symsec
->sh_type
!= SHT_DYNSYM
)
8544 if (!get_symtab (filedata
, symsec
,
8545 &symtab
, &nsyms
, &strtab
, &strtablen
))
8548 dump_relocations (filedata
, rel_offset
, rel_size
,
8549 symtab
, nsyms
, strtab
, strtablen
,
8551 symsec
->sh_type
== SHT_DYNSYM
);
8556 dump_relocations (filedata
, rel_offset
, rel_size
,
8557 NULL
, 0, NULL
, 0, rel_type
, false /* is_dynamic */);
8565 /* Users sometimes forget the -D option, so try to be helpful. */
8566 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
8568 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
8570 if (filedata
->is_separate
)
8571 printf (_("\nThere are no static relocations in linked file '%s'."),
8572 filedata
->file_name
);
8574 printf (_("\nThere are no static relocations in this file."));
8575 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
8580 if (i
== ARRAY_SIZE (dynamic_relocations
))
8582 if (filedata
->is_separate
)
8583 printf (_("\nThere are no relocations in linked file '%s'.\n"),
8584 filedata
->file_name
);
8586 printf (_("\nThere are no relocations in this file.\n"));
8594 /* An absolute address consists of a section and an offset. If the
8595 section is NULL, the offset itself is the address, otherwise, the
8596 address equals to LOAD_ADDRESS(section) + offset. */
8600 unsigned short section
;
8604 /* Find the nearest symbol at or below ADDR. Returns the symbol
8605 name, if found, and the offset from the symbol to ADDR. */
8608 find_symbol_for_address (Filedata
*filedata
,
8609 Elf_Internal_Sym
*symtab
,
8612 uint64_t strtab_size
,
8613 struct absaddr addr
,
8614 const char **symname
,
8617 uint64_t dist
= 0x100000;
8618 Elf_Internal_Sym
* sym
;
8619 Elf_Internal_Sym
* beg
;
8620 Elf_Internal_Sym
* end
;
8621 Elf_Internal_Sym
* best
= NULL
;
8623 REMOVE_ARCH_BITS (addr
.offset
);
8625 end
= symtab
+ nsyms
;
8631 sym
= beg
+ (end
- beg
) / 2;
8633 value
= sym
->st_value
;
8634 REMOVE_ARCH_BITS (value
);
8636 if (sym
->st_name
!= 0
8637 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
8638 && addr
.offset
>= value
8639 && addr
.offset
- value
< dist
)
8642 dist
= addr
.offset
- value
;
8647 if (addr
.offset
< value
)
8655 *symname
= (best
->st_name
>= strtab_size
8656 ? _("<corrupt>") : strtab
+ best
->st_name
);
8662 *offset
= addr
.offset
;
8665 static /* signed */ int
8666 symcmp (const void *p
, const void *q
)
8668 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
8669 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
8671 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
8674 /* Process the unwind section. */
8676 #include "unwind-ia64.h"
8678 struct ia64_unw_table_entry
8680 struct absaddr start
;
8682 struct absaddr info
;
8685 struct ia64_unw_aux_info
8687 struct ia64_unw_table_entry
* table
; /* Unwind table. */
8688 uint64_t table_len
; /* Length of unwind table. */
8689 unsigned char * info
; /* Unwind info. */
8690 uint64_t info_size
; /* Size of unwind info. */
8691 uint64_t info_addr
; /* Starting address of unwind info. */
8692 uint64_t seg_base
; /* Starting address of segment. */
8693 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8694 uint64_t nsyms
; /* Number of symbols. */
8695 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8696 uint64_t nfuns
; /* Number of entries in funtab. */
8697 char * strtab
; /* The string table. */
8698 uint64_t strtab_size
; /* Size of string table. */
8702 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
8704 struct ia64_unw_table_entry
* tp
;
8709 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8710 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8711 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8712 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8714 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8716 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8720 const unsigned char * dp
;
8721 const unsigned char * head
;
8722 const unsigned char * end
;
8723 const char * procname
;
8725 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8726 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
8728 fputs ("\n<", stdout
);
8732 fputs (procname
, stdout
);
8735 printf ("+%" PRIx64
, offset
);
8738 fputs (">: [", stdout
);
8739 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8740 fputc ('-', stdout
);
8741 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8742 printf ("], info at +0x%" PRIx64
"\n",
8743 tp
->info
.offset
- aux
->seg_base
);
8745 /* PR 17531: file: 86232b32. */
8746 if (aux
->info
== NULL
)
8749 offset
= tp
->info
.offset
;
8750 if (tp
->info
.section
)
8752 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
8754 warn (_("Invalid section %u in table entry %td\n"),
8755 tp
->info
.section
, tp
- aux
->table
);
8759 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
8761 offset
-= aux
->info_addr
;
8762 /* PR 17531: file: 0997b4d1. */
8763 if (offset
>= aux
->info_size
8764 || aux
->info_size
- offset
< 8)
8766 warn (_("Invalid offset %" PRIx64
" in table entry %td\n"),
8767 tp
->info
.offset
, tp
- aux
->table
);
8772 head
= aux
->info
+ offset
;
8773 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
8775 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
8776 (unsigned) UNW_VER (stamp
),
8777 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
8778 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
8779 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
8780 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
8782 if (UNW_VER (stamp
) != 1)
8784 printf (_("\tUnknown version.\n"));
8789 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
8790 /* PR 17531: file: 16ceda89. */
8791 if (end
> aux
->info
+ aux
->info_size
)
8792 end
= aux
->info
+ aux
->info_size
;
8793 for (dp
= head
+ 8; dp
< end
;)
8794 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
8803 slurp_ia64_unwind_table (Filedata
* filedata
,
8804 struct ia64_unw_aux_info
* aux
,
8805 Elf_Internal_Shdr
* sec
)
8807 uint64_t size
, nrelas
, i
;
8808 Elf_Internal_Phdr
* seg
;
8809 struct ia64_unw_table_entry
* tep
;
8810 Elf_Internal_Shdr
* relsec
;
8811 Elf_Internal_Rela
* rela
;
8812 Elf_Internal_Rela
* rp
;
8813 unsigned char * table
;
8815 Elf_Internal_Sym
* sym
;
8816 const char * relname
;
8820 /* First, find the starting address of the segment that includes
8823 if (filedata
->file_header
.e_phnum
)
8825 if (! get_program_headers (filedata
))
8828 for (seg
= filedata
->program_headers
;
8829 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8832 if (seg
->p_type
!= PT_LOAD
)
8835 if (sec
->sh_addr
>= seg
->p_vaddr
8836 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8838 aux
->seg_base
= seg
->p_vaddr
;
8844 /* Second, build the unwind table from the contents of the unwind section: */
8845 size
= sec
->sh_size
;
8846 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8851 aux
->table_len
= size
/ (3 * eh_addr_size
);
8852 aux
->table
= (struct ia64_unw_table_entry
*)
8853 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
8856 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
8858 tep
->start
.section
= SHN_UNDEF
;
8859 tep
->end
.section
= SHN_UNDEF
;
8860 tep
->info
.section
= SHN_UNDEF
;
8861 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8862 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8863 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8864 tep
->start
.offset
+= aux
->seg_base
;
8865 tep
->end
.offset
+= aux
->seg_base
;
8866 tep
->info
.offset
+= aux
->seg_base
;
8870 /* Third, apply any relocations to the unwind table: */
8871 for (relsec
= filedata
->section_headers
;
8872 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8875 if (relsec
->sh_type
!= SHT_RELA
8876 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8877 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8880 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8889 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8891 unsigned int sym_ndx
;
8892 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8893 relname
= elf_ia64_reloc_type (r_type
);
8895 /* PR 17531: file: 9fa67536. */
8896 if (relname
== NULL
)
8898 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8902 if (! startswith (relname
, "R_IA64_SEGREL"))
8904 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8908 i
= rp
->r_offset
/ (3 * eh_addr_size
);
8910 /* PR 17531: file: 5bc8d9bf. */
8911 if (i
>= aux
->table_len
)
8913 warn (_("Skipping reloc with overlarge offset: %#" PRIx64
"\n"),
8918 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8919 if (sym_ndx
>= aux
->nsyms
)
8921 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8925 sym
= aux
->symtab
+ sym_ndx
;
8927 switch (rp
->r_offset
/ eh_addr_size
% 3)
8930 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8931 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
8934 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8935 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
8938 aux
->table
[i
].info
.section
= sym
->st_shndx
;
8939 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
8953 ia64_process_unwind (Filedata
* filedata
)
8955 Elf_Internal_Shdr
* sec
;
8956 Elf_Internal_Shdr
* unwsec
= NULL
;
8957 uint64_t i
, unwcount
= 0, unwstart
= 0;
8958 struct ia64_unw_aux_info aux
;
8961 memset (& aux
, 0, sizeof (aux
));
8963 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8965 if (sec
->sh_type
== SHT_SYMTAB
)
8969 error (_("Multiple symbol tables encountered\n"));
8975 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8976 &aux
.strtab
, &aux
.strtab_size
))
8979 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8984 printf (_("\nThere are no unwind sections in this file.\n"));
8986 while (unwcount
-- > 0)
8991 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
8992 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8993 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8998 /* We have already counted the number of SHT_IA64_UNWIND
8999 sections so the loop above should never fail. */
9000 assert (unwsec
!= NULL
);
9003 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
9005 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
9007 /* We need to find which section group it is in. */
9008 struct group_list
* g
;
9010 if (filedata
->section_headers_groups
== NULL
9011 || filedata
->section_headers_groups
[i
] == NULL
)
9012 i
= filedata
->file_header
.e_shnum
;
9015 g
= filedata
->section_headers_groups
[i
]->root
;
9017 for (; g
!= NULL
; g
= g
->next
)
9019 sec
= filedata
->section_headers
+ g
->section_index
;
9021 if (section_name_valid (filedata
, sec
)
9022 && streq (section_name (filedata
, sec
),
9023 ELF_STRING_ia64_unwind_info
))
9028 i
= filedata
->file_header
.e_shnum
;
9031 else if (section_name_valid (filedata
, unwsec
)
9032 && startswith (section_name (filedata
, unwsec
),
9033 ELF_STRING_ia64_unwind_once
))
9035 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
9036 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
9037 suffix
= section_name (filedata
, unwsec
) + len
;
9038 for (i
= 0, sec
= filedata
->section_headers
;
9039 i
< filedata
->file_header
.e_shnum
;
9041 if (section_name_valid (filedata
, sec
)
9042 && startswith (section_name (filedata
, sec
),
9043 ELF_STRING_ia64_unwind_info_once
)
9044 && streq (section_name (filedata
, sec
) + len2
, suffix
))
9049 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
9050 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
9051 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
9052 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
9054 if (section_name_valid (filedata
, unwsec
)
9055 && startswith (section_name (filedata
, unwsec
),
9056 ELF_STRING_ia64_unwind
))
9057 suffix
= section_name (filedata
, unwsec
) + len
;
9058 for (i
= 0, sec
= filedata
->section_headers
;
9059 i
< filedata
->file_header
.e_shnum
;
9061 if (section_name_valid (filedata
, sec
)
9062 && startswith (section_name (filedata
, sec
),
9063 ELF_STRING_ia64_unwind_info
)
9064 && streq (section_name (filedata
, sec
) + len2
, suffix
))
9068 if (i
== filedata
->file_header
.e_shnum
)
9070 printf (_("\nCould not find unwind info section for "));
9072 if (filedata
->string_table
== NULL
)
9073 printf ("%d", unwsec
->sh_name
);
9075 printf ("'%s'", printable_section_name (filedata
, unwsec
));
9079 aux
.info_addr
= sec
->sh_addr
;
9080 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
9083 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
9085 printf (_("\nUnwind section "));
9087 if (filedata
->string_table
== NULL
)
9088 printf ("%d", unwsec
->sh_name
);
9090 printf ("'%s'", printable_section_name (filedata
, unwsec
));
9092 printf (_(" at offset %#" PRIx64
" contains %" PRIu64
" entries:\n"),
9094 unwsec
->sh_size
/ (3 * eh_addr_size
));
9096 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
9097 && aux
.table_len
> 0)
9098 dump_ia64_unwind (filedata
, & aux
);
9100 free ((char *) aux
.table
);
9101 free ((char *) aux
.info
);
9108 free ((char *) aux
.strtab
);
9113 struct hppa_unw_table_entry
9115 struct absaddr start
;
9117 unsigned int Cannot_unwind
:1; /* 0 */
9118 unsigned int Millicode
:1; /* 1 */
9119 unsigned int Millicode_save_sr0
:1; /* 2 */
9120 unsigned int Region_description
:2; /* 3..4 */
9121 unsigned int reserved1
:1; /* 5 */
9122 unsigned int Entry_SR
:1; /* 6 */
9123 unsigned int Entry_FR
:4; /* Number saved 7..10 */
9124 unsigned int Entry_GR
:5; /* Number saved 11..15 */
9125 unsigned int Args_stored
:1; /* 16 */
9126 unsigned int Variable_Frame
:1; /* 17 */
9127 unsigned int Separate_Package_Body
:1; /* 18 */
9128 unsigned int Frame_Extension_Millicode
:1; /* 19 */
9129 unsigned int Stack_Overflow_Check
:1; /* 20 */
9130 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
9131 unsigned int Ada_Region
:1; /* 22 */
9132 unsigned int cxx_info
:1; /* 23 */
9133 unsigned int cxx_try_catch
:1; /* 24 */
9134 unsigned int sched_entry_seq
:1; /* 25 */
9135 unsigned int reserved2
:1; /* 26 */
9136 unsigned int Save_SP
:1; /* 27 */
9137 unsigned int Save_RP
:1; /* 28 */
9138 unsigned int Save_MRP_in_frame
:1; /* 29 */
9139 unsigned int extn_ptr_defined
:1; /* 30 */
9140 unsigned int Cleanup_defined
:1; /* 31 */
9142 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
9143 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
9144 unsigned int Large_frame
:1; /* 2 */
9145 unsigned int Pseudo_SP_Set
:1; /* 3 */
9146 unsigned int reserved4
:1; /* 4 */
9147 unsigned int Total_frame_size
:27; /* 5..31 */
9150 struct hppa_unw_aux_info
9152 struct hppa_unw_table_entry
* table
; /* Unwind table. */
9153 uint64_t table_len
; /* Length of unwind table. */
9154 uint64_t seg_base
; /* Starting address of segment. */
9155 Elf_Internal_Sym
* symtab
; /* The symbol table. */
9156 uint64_t nsyms
; /* Number of symbols. */
9157 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
9158 uint64_t nfuns
; /* Number of entries in funtab. */
9159 char * strtab
; /* The string table. */
9160 uint64_t strtab_size
; /* Size of string table. */
9164 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
9166 struct hppa_unw_table_entry
* tp
;
9170 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9171 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9172 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9173 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9175 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9177 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
9180 const char * procname
;
9182 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
9183 aux
->strtab_size
, tp
->start
, &procname
,
9186 fputs ("\n<", stdout
);
9190 fputs (procname
, stdout
);
9193 printf ("+%" PRIx64
, offset
);
9196 fputs (">: [", stdout
);
9197 print_vma (tp
->start
.offset
, PREFIX_HEX
);
9198 fputc ('-', stdout
);
9199 print_vma (tp
->end
.offset
, PREFIX_HEX
);
9202 #define PF(_m) if (tp->_m) printf (#_m " ");
9203 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
9206 PF(Millicode_save_sr0
);
9207 /* PV(Region_description); */
9213 PF(Separate_Package_Body
);
9214 PF(Frame_Extension_Millicode
);
9215 PF(Stack_Overflow_Check
);
9216 PF(Two_Instruction_SP_Increment
);
9220 PF(sched_entry_seq
);
9223 PF(Save_MRP_in_frame
);
9224 PF(extn_ptr_defined
);
9225 PF(Cleanup_defined
);
9226 PF(MPE_XL_interrupt_marker
);
9227 PF(HP_UX_interrupt_marker
);
9230 PV(Total_frame_size
);
9243 slurp_hppa_unwind_table (Filedata
* filedata
,
9244 struct hppa_unw_aux_info
* aux
,
9245 Elf_Internal_Shdr
* sec
)
9247 uint64_t size
, unw_ent_size
, nentries
, nrelas
, i
;
9248 Elf_Internal_Phdr
* seg
;
9249 struct hppa_unw_table_entry
* tep
;
9250 Elf_Internal_Shdr
* relsec
;
9251 Elf_Internal_Rela
* rela
;
9252 Elf_Internal_Rela
* rp
;
9253 unsigned char * table
;
9255 Elf_Internal_Sym
* sym
;
9256 const char * relname
;
9258 /* First, find the starting address of the segment that includes
9260 if (filedata
->file_header
.e_phnum
)
9262 if (! get_program_headers (filedata
))
9265 for (seg
= filedata
->program_headers
;
9266 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
9269 if (seg
->p_type
!= PT_LOAD
)
9272 if (sec
->sh_addr
>= seg
->p_vaddr
9273 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
9275 aux
->seg_base
= seg
->p_vaddr
;
9281 /* Second, build the unwind table from the contents of the unwind
9283 size
= sec
->sh_size
;
9284 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
9290 nentries
= size
/ unw_ent_size
;
9291 size
= unw_ent_size
* nentries
;
9293 aux
->table_len
= nentries
;
9294 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
9295 xcmalloc (nentries
, sizeof (aux
->table
[0]));
9297 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
9299 unsigned int tmp1
, tmp2
;
9301 tep
->start
.section
= SHN_UNDEF
;
9302 tep
->end
.section
= SHN_UNDEF
;
9304 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
9305 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
9306 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
9307 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
9309 tep
->start
.offset
+= aux
->seg_base
;
9310 tep
->end
.offset
+= aux
->seg_base
;
9312 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
9313 tep
->Millicode
= (tmp1
>> 30) & 0x1;
9314 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
9315 tep
->Region_description
= (tmp1
>> 27) & 0x3;
9316 tep
->reserved1
= (tmp1
>> 26) & 0x1;
9317 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
9318 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
9319 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
9320 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
9321 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
9322 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
9323 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
9324 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
9325 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
9326 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
9327 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
9328 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
9329 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
9330 tep
->reserved2
= (tmp1
>> 5) & 0x1;
9331 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
9332 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
9333 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
9334 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
9335 tep
->Cleanup_defined
= tmp1
& 0x1;
9337 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
9338 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
9339 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
9340 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
9341 tep
->reserved4
= (tmp2
>> 27) & 0x1;
9342 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
9346 /* Third, apply any relocations to the unwind table. */
9347 for (relsec
= filedata
->section_headers
;
9348 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
9351 if (relsec
->sh_type
!= SHT_RELA
9352 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
9353 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
9356 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
9360 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
9362 unsigned int sym_ndx
;
9363 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
9364 relname
= elf_hppa_reloc_type (r_type
);
9366 if (relname
== NULL
)
9368 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
9372 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
9373 if (! startswith (relname
, "R_PARISC_SEGREL"))
9375 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
9379 i
= rp
->r_offset
/ unw_ent_size
;
9380 if (i
>= aux
->table_len
)
9382 warn (_("Skipping reloc with overlarge offset: %#" PRIx64
"\n"),
9387 sym_ndx
= get_reloc_symindex (rp
->r_info
);
9388 if (sym_ndx
>= aux
->nsyms
)
9390 warn (_("Skipping reloc with invalid symbol index: %u\n"),
9394 sym
= aux
->symtab
+ sym_ndx
;
9396 switch ((rp
->r_offset
% unw_ent_size
) / 4)
9399 aux
->table
[i
].start
.section
= sym
->st_shndx
;
9400 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
9403 aux
->table
[i
].end
.section
= sym
->st_shndx
;
9404 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
9418 hppa_process_unwind (Filedata
* filedata
)
9420 struct hppa_unw_aux_info aux
;
9421 Elf_Internal_Shdr
* unwsec
= NULL
;
9422 Elf_Internal_Shdr
* sec
;
9426 if (filedata
->string_table
== NULL
)
9429 memset (& aux
, 0, sizeof (aux
));
9431 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9433 if (sec
->sh_type
== SHT_SYMTAB
)
9437 error (_("Multiple symbol tables encountered\n"));
9443 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9444 &aux
.strtab
, &aux
.strtab_size
))
9447 else if (section_name_valid (filedata
, sec
)
9448 && streq (section_name (filedata
, sec
), ".PARISC.unwind"))
9453 printf (_("\nThere are no unwind sections in this file.\n"));
9455 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9457 if (section_name_valid (filedata
, sec
)
9458 && streq (section_name (filedata
, sec
), ".PARISC.unwind"))
9460 uint64_t num_unwind
= sec
->sh_size
/ 16;
9462 printf (ngettext ("\nUnwind section '%s' at offset %#" PRIx64
" "
9463 "contains %" PRIu64
" entry:\n",
9464 "\nUnwind section '%s' at offset %#" PRIx64
" "
9465 "contains %" PRIu64
" entries:\n",
9467 printable_section_name (filedata
, sec
),
9471 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
9474 if (res
&& aux
.table_len
> 0)
9476 if (! dump_hppa_unwind (filedata
, &aux
))
9480 free ((char *) aux
.table
);
9486 free ((char *) aux
.strtab
);
9493 unsigned char * data
; /* The unwind data. */
9494 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
9495 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
9496 uint64_t nrelas
; /* The number of relocations. */
9497 unsigned int rel_type
; /* REL or RELA ? */
9498 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
9501 struct arm_unw_aux_info
9503 Filedata
* filedata
; /* The file containing the unwind sections. */
9504 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
9505 uint64_t nsyms
; /* Number of symbols. */
9506 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
9507 uint64_t nfuns
; /* Number of these symbols. */
9508 char * strtab
; /* The file's string table. */
9509 uint64_t strtab_size
; /* Size of string table. */
9513 arm_print_vma_and_name (Filedata
* filedata
,
9514 struct arm_unw_aux_info
* aux
,
9516 struct absaddr addr
)
9518 const char *procname
;
9519 uint64_t sym_offset
;
9521 if (addr
.section
== SHN_UNDEF
)
9524 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
9525 aux
->strtab_size
, addr
, &procname
,
9528 print_vma (fn
, PREFIX_HEX
);
9532 fputs (" <", stdout
);
9533 fputs (procname
, stdout
);
9536 printf ("+0x%" PRIx64
, sym_offset
);
9537 fputc ('>', stdout
);
9544 arm_free_section (struct arm_section
*arm_sec
)
9546 free (arm_sec
->data
);
9547 free (arm_sec
->rela
);
9550 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
9551 cached section and install SEC instead.
9552 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
9553 and return its valued in * WORDP, relocating if necessary.
9554 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
9555 relocation's offset in ADDR.
9556 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
9557 into the string table of the symbol associated with the reloc. If no
9558 reloc was applied store -1 there.
9559 5) Return TRUE upon success, FALSE otherwise. */
9562 get_unwind_section_word (Filedata
* filedata
,
9563 struct arm_unw_aux_info
* aux
,
9564 struct arm_section
* arm_sec
,
9565 Elf_Internal_Shdr
* sec
,
9566 uint64_t word_offset
,
9567 unsigned int * wordp
,
9568 struct absaddr
* addr
,
9569 uint64_t * sym_name
)
9571 Elf_Internal_Rela
*rp
;
9572 Elf_Internal_Sym
*sym
;
9573 const char * relname
;
9577 if (sec
== NULL
|| arm_sec
== NULL
)
9580 addr
->section
= SHN_UNDEF
;
9583 if (sym_name
!= NULL
)
9584 *sym_name
= (uint64_t) -1;
9586 /* If necessary, update the section cache. */
9587 if (sec
!= arm_sec
->sec
)
9589 Elf_Internal_Shdr
*relsec
;
9591 arm_free_section (arm_sec
);
9594 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
9595 sec
->sh_size
, _("unwind data"));
9596 arm_sec
->rela
= NULL
;
9597 arm_sec
->nrelas
= 0;
9599 for (relsec
= filedata
->section_headers
;
9600 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
9603 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
9604 || filedata
->section_headers
+ relsec
->sh_info
!= sec
9605 /* PR 15745: Check the section type as well. */
9606 || (relsec
->sh_type
!= SHT_REL
9607 && relsec
->sh_type
!= SHT_RELA
))
9610 arm_sec
->rel_type
= relsec
->sh_type
;
9611 if (relsec
->sh_type
== SHT_REL
)
9613 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
9615 & arm_sec
->rela
, & arm_sec
->nrelas
))
9618 else /* relsec->sh_type == SHT_RELA */
9620 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
9622 & arm_sec
->rela
, & arm_sec
->nrelas
))
9628 arm_sec
->next_rela
= arm_sec
->rela
;
9631 /* If there is no unwind data we can do nothing. */
9632 if (arm_sec
->data
== NULL
)
9635 /* If the offset is invalid then fail. */
9636 if (/* PR 21343 *//* PR 18879 */
9638 || word_offset
> sec
->sh_size
- 4)
9641 /* Get the word at the required offset. */
9642 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
9644 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
9645 if (arm_sec
->rela
== NULL
)
9651 /* Look through the relocs to find the one that applies to the provided offset. */
9653 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
9655 uint64_t prelval
, offset
;
9657 if (rp
->r_offset
> word_offset
&& !wrapped
)
9662 if (rp
->r_offset
> word_offset
)
9665 if (rp
->r_offset
& 3)
9667 warn (_("Skipping unexpected relocation at offset %#" PRIx64
"\n"),
9672 if (rp
->r_offset
< word_offset
)
9675 /* PR 17531: file: 027-161405-0.004 */
9676 if (aux
->symtab
== NULL
)
9679 if (arm_sec
->rel_type
== SHT_REL
)
9681 offset
= word
& 0x7fffffff;
9682 if (offset
& 0x40000000)
9683 offset
|= ~ (uint64_t) 0x7fffffff;
9685 else if (arm_sec
->rel_type
== SHT_RELA
)
9686 offset
= rp
->r_addend
;
9689 error (_("Unknown section relocation type %d encountered\n"),
9694 /* PR 17531 file: 027-1241568-0.004. */
9695 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
9697 error (_("Bad symbol index in unwind relocation "
9698 "(%" PRIu64
" > %" PRIu64
")\n"),
9699 ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
9703 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
9704 offset
+= sym
->st_value
;
9705 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
9707 /* Check that we are processing the expected reloc type. */
9708 if (filedata
->file_header
.e_machine
== EM_ARM
)
9710 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
9711 if (relname
== NULL
)
9713 warn (_("Skipping unknown ARM relocation type: %d\n"),
9714 (int) ELF32_R_TYPE (rp
->r_info
));
9718 if (streq (relname
, "R_ARM_NONE"))
9721 if (! streq (relname
, "R_ARM_PREL31"))
9723 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
9727 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9729 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
9730 if (relname
== NULL
)
9732 warn (_("Skipping unknown C6000 relocation type: %d\n"),
9733 (int) ELF32_R_TYPE (rp
->r_info
));
9737 if (streq (relname
, "R_C6000_NONE"))
9740 if (! streq (relname
, "R_C6000_PREL31"))
9742 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
9750 /* This function currently only supports ARM and TI unwinders. */
9751 warn (_("Only TI and ARM unwinders are currently supported\n"));
9755 word
= (word
& ~ (uint64_t) 0x7fffffff) | (prelval
& 0x7fffffff);
9756 addr
->section
= sym
->st_shndx
;
9757 addr
->offset
= offset
;
9760 * sym_name
= sym
->st_name
;
9765 arm_sec
->next_rela
= rp
;
9770 static const char *tic6x_unwind_regnames
[16] =
9772 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
9773 "A14", "A13", "A12", "A11", "A10",
9774 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
9778 decode_tic6x_unwind_regmask (unsigned int mask
)
9782 for (i
= 12; mask
; mask
>>= 1, i
--)
9786 fputs (tic6x_unwind_regnames
[i
], stdout
);
9788 fputs (", ", stdout
);
9794 if (remaining == 0 && more_words) \
9797 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
9798 data_offset, & word, & addr, NULL)) \
9804 #define GET_OP(OP) \
9809 (OP) = word >> 24; \
9814 printf (_("[Truncated opcode]\n")); \
9817 printf ("0x%02x ", OP)
9820 decode_arm_unwind_bytecode (Filedata
* filedata
,
9821 struct arm_unw_aux_info
* aux
,
9823 unsigned int remaining
,
9824 unsigned int more_words
,
9825 uint64_t data_offset
,
9826 Elf_Internal_Shdr
* data_sec
,
9827 struct arm_section
* data_arm_sec
)
9829 struct absaddr addr
;
9832 /* Decode the unwinding instructions. */
9835 unsigned int op
, op2
;
9844 printf (" 0x%02x ", op
);
9846 if ((op
& 0xc0) == 0x00)
9848 int offset
= ((op
& 0x3f) << 2) + 4;
9850 printf (" vsp = vsp + %d", offset
);
9852 else if ((op
& 0xc0) == 0x40)
9854 int offset
= ((op
& 0x3f) << 2) + 4;
9856 printf (" vsp = vsp - %d", offset
);
9858 else if ((op
& 0xf0) == 0x80)
9861 if (op
== 0x80 && op2
== 0)
9862 printf (_("Refuse to unwind"));
9865 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
9870 for (i
= 0; i
< 12; i
++)
9871 if (mask
& (1 << i
))
9877 printf ("r%d", 4 + i
);
9882 else if ((op
& 0xf0) == 0x90)
9884 if (op
== 0x9d || op
== 0x9f)
9885 printf (_(" [Reserved]"));
9887 printf (" vsp = r%d", op
& 0x0f);
9889 else if ((op
& 0xf0) == 0xa0)
9891 int end
= 4 + (op
& 0x07);
9896 for (i
= 4; i
<= end
; i
++)
9912 else if (op
== 0xb0)
9913 printf (_(" finish"));
9914 else if (op
== 0xb1)
9917 if (op2
== 0 || (op2
& 0xf0) != 0)
9918 printf (_("[Spare]"));
9921 unsigned int mask
= op2
& 0x0f;
9926 for (i
= 0; i
< 12; i
++)
9927 if (mask
& (1 << i
))
9938 else if (op
== 0xb2)
9940 unsigned char buf
[9];
9941 unsigned int i
, len
;
9944 for (i
= 0; i
< sizeof (buf
); i
++)
9947 if ((buf
[i
] & 0x80) == 0)
9950 if (i
== sizeof (buf
))
9952 error (_("corrupt change to vsp\n"));
9957 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
9958 assert (len
== i
+ 1);
9959 offset
= offset
* 4 + 0x204;
9960 printf ("vsp = vsp + %" PRId64
, offset
);
9963 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
9965 unsigned int first
, last
;
9972 printf ("pop {D%d", first
);
9974 printf ("-D%d", first
+ last
);
9977 else if (op
== 0xb4)
9978 printf (_(" pop {ra_auth_code}"));
9979 else if (op
== 0xb5)
9980 printf (_(" vsp as modifier for PAC validation"));
9981 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
9983 unsigned int count
= op
& 0x07;
9987 printf ("-D%d", 8 + count
);
9990 else if (op
>= 0xc0 && op
<= 0xc5)
9992 unsigned int count
= op
& 0x07;
9994 printf (" pop {wR10");
9996 printf ("-wR%d", 10 + count
);
9999 else if (op
== 0xc6)
10001 unsigned int first
, last
;
10006 printf ("pop {wR%d", first
);
10008 printf ("-wR%d", first
+ last
);
10011 else if (op
== 0xc7)
10014 if (op2
== 0 || (op2
& 0xf0) != 0)
10015 printf (_("[Spare]"));
10018 unsigned int mask
= op2
& 0x0f;
10023 for (i
= 0; i
< 4; i
++)
10024 if (mask
& (1 << i
))
10030 printf ("wCGR%d", i
);
10037 printf (_(" [unsupported opcode]"));
10048 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
10049 struct arm_unw_aux_info
* aux
,
10051 unsigned int remaining
,
10052 unsigned int more_words
,
10053 uint64_t data_offset
,
10054 Elf_Internal_Shdr
* data_sec
,
10055 struct arm_section
* data_arm_sec
)
10057 struct absaddr addr
;
10059 /* Decode the unwinding instructions. */
10062 unsigned int op
, op2
;
10065 if (remaining
== 0)
10071 printf (" 0x%02x ", op
);
10073 if ((op
& 0xc0) == 0x00)
10075 int offset
= ((op
& 0x3f) << 3) + 8;
10076 printf (" sp = sp + %d", offset
);
10078 else if ((op
& 0xc0) == 0x80)
10081 if (op
== 0x80 && op2
== 0)
10082 printf (_("Refuse to unwind"));
10085 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
10087 printf ("pop compact {");
10091 decode_tic6x_unwind_regmask (mask
);
10095 else if ((op
& 0xf0) == 0xc0)
10098 unsigned int nregs
;
10103 unsigned int offset
;
10107 /* Scan entire instruction first so that GET_OP output is not
10108 interleaved with disassembly. */
10110 for (i
= 0; nregs
< (op
& 0xf); i
++)
10116 regpos
[nregs
].offset
= i
* 2;
10117 regpos
[nregs
].reg
= reg
;
10124 regpos
[nregs
].offset
= i
* 2 + 1;
10125 regpos
[nregs
].reg
= reg
;
10130 printf (_("pop frame {"));
10133 printf (_("*corrupt* - no registers specified"));
10138 for (i
= i
* 2; i
> 0; i
--)
10140 if (regpos
[reg
].offset
== i
- 1)
10142 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
10149 fputs (name
, stdout
);
10157 else if (op
== 0xd0)
10158 printf (" MOV FP, SP");
10159 else if (op
== 0xd1)
10160 printf (" __c6xabi_pop_rts");
10161 else if (op
== 0xd2)
10163 unsigned char buf
[9];
10164 unsigned int i
, len
;
10167 for (i
= 0; i
< sizeof (buf
); i
++)
10170 if ((buf
[i
] & 0x80) == 0)
10173 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
10174 if (i
== sizeof (buf
))
10176 warn (_("Corrupt stack pointer adjustment detected\n"));
10180 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
10181 assert (len
== i
+ 1);
10182 offset
= offset
* 8 + 0x408;
10183 printf (_("sp = sp + %" PRId64
), offset
);
10185 else if ((op
& 0xf0) == 0xe0)
10187 if ((op
& 0x0f) == 7)
10188 printf (" RETURN");
10190 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
10194 printf (_(" [unsupported opcode]"));
10203 arm_expand_prel31 (Filedata
* filedata
, uint64_t word
, uint64_t where
)
10207 offset
= word
& 0x7fffffff;
10208 if (offset
& 0x40000000)
10209 offset
|= ~ (uint64_t) 0x7fffffff;
10211 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
10214 return offset
+ where
;
10218 decode_arm_unwind (Filedata
* filedata
,
10219 struct arm_unw_aux_info
* aux
,
10221 unsigned int remaining
,
10222 uint64_t data_offset
,
10223 Elf_Internal_Shdr
* data_sec
,
10224 struct arm_section
* data_arm_sec
)
10227 unsigned int more_words
= 0;
10228 struct absaddr addr
;
10229 uint64_t sym_name
= (uint64_t) -1;
10232 if (remaining
== 0)
10234 /* Fetch the first word.
10235 Note - when decoding an object file the address extracted
10236 here will always be 0. So we also pass in the sym_name
10237 parameter so that we can find the symbol associated with
10238 the personality routine. */
10239 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
10240 & word
, & addr
, & sym_name
))
10247 addr
.section
= SHN_UNDEF
;
10251 if ((word
& 0x80000000) == 0)
10253 /* Expand prel31 for personality routine. */
10255 const char *procname
;
10257 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
10258 printf (_(" Personality routine: "));
10260 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
10261 && sym_name
!= (uint64_t) -1 && sym_name
< aux
->strtab_size
)
10263 procname
= aux
->strtab
+ sym_name
;
10264 print_vma (fn
, PREFIX_HEX
);
10267 fputs (" <", stdout
);
10268 fputs (procname
, stdout
);
10269 fputc ('>', stdout
);
10273 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
10274 fputc ('\n', stdout
);
10276 /* The GCC personality routines use the standard compact
10277 encoding, starting with one byte giving the number of
10279 if (procname
!= NULL
10280 && (startswith (procname
, "__gcc_personality_v0")
10281 || startswith (procname
, "__gxx_personality_v0")
10282 || startswith (procname
, "__gcj_personality_v0")
10283 || startswith (procname
, "__gnu_objc_personality_v0")))
10290 printf (_(" [Truncated data]\n"));
10293 more_words
= word
>> 24;
10303 /* ARM EHABI Section 6.3:
10305 An exception-handling table entry for the compact model looks like:
10307 31 30-28 27-24 23-0
10308 -- ----- ----- ----
10309 1 0 index Data for personalityRoutine[index] */
10311 if (filedata
->file_header
.e_machine
== EM_ARM
10312 && (word
& 0x70000000))
10314 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
10318 per_index
= (word
>> 24) & 0x7f;
10319 printf (_(" Compact model index: %d\n"), per_index
);
10320 if (per_index
== 0)
10326 else if (per_index
< 3)
10328 more_words
= (word
>> 16) & 0xff;
10334 switch (filedata
->file_header
.e_machine
)
10339 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
10340 data_offset
, data_sec
, data_arm_sec
))
10345 warn (_("Unknown ARM compact model index encountered\n"));
10346 printf (_(" [reserved]\n"));
10354 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
10355 data_offset
, data_sec
, data_arm_sec
))
10358 else if (per_index
< 5)
10360 if (((word
>> 17) & 0x7f) == 0x7f)
10361 printf (_(" Restore stack from frame pointer\n"));
10363 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
10364 printf (_(" Registers restored: "));
10365 if (per_index
== 4)
10366 printf (" (compact) ");
10367 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
10369 printf (_(" Return register: %s\n"),
10370 tic6x_unwind_regnames
[word
& 0xf]);
10373 printf (_(" [reserved (%d)]\n"), per_index
);
10377 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
10378 filedata
->file_header
.e_machine
);
10382 /* Decode the descriptors. Not implemented. */
10388 dump_arm_unwind (Filedata
* filedata
,
10389 struct arm_unw_aux_info
* aux
,
10390 Elf_Internal_Shdr
* exidx_sec
)
10392 struct arm_section exidx_arm_sec
, extab_arm_sec
;
10393 unsigned int i
, exidx_len
;
10397 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
10398 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
10399 exidx_len
= exidx_sec
->sh_size
/ 8;
10401 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
10402 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
10403 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
10404 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
10405 aux
->nfuns
= nfuns
;
10406 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
10408 for (i
= 0; i
< exidx_len
; i
++)
10410 unsigned int exidx_fn
, exidx_entry
;
10411 struct absaddr fn_addr
, entry_addr
;
10414 fputc ('\n', stdout
);
10416 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
10417 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
10418 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
10419 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
10421 free (aux
->funtab
);
10422 arm_free_section (& exidx_arm_sec
);
10423 arm_free_section (& extab_arm_sec
);
10427 /* ARM EHABI, Section 5:
10428 An index table entry consists of 2 words.
10429 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
10430 if (exidx_fn
& 0x80000000)
10432 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
10436 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
10438 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
10439 fputs (": ", stdout
);
10441 if (exidx_entry
== 1)
10443 print_vma (exidx_entry
, PREFIX_HEX
);
10444 fputs (" [cantunwind]\n", stdout
);
10446 else if (exidx_entry
& 0x80000000)
10448 print_vma (exidx_entry
, PREFIX_HEX
);
10449 fputc ('\n', stdout
);
10450 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
10454 uint64_t table
, table_offset
= 0;
10455 Elf_Internal_Shdr
*table_sec
;
10457 fputs ("@", stdout
);
10458 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
10459 print_vma (table
, PREFIX_HEX
);
10462 /* Locate the matching .ARM.extab. */
10463 if (entry_addr
.section
!= SHN_UNDEF
10464 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
10466 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
10467 table_offset
= entry_addr
.offset
;
10469 if (table_offset
> table_sec
->sh_size
)
10471 warn (_("Unwind entry contains corrupt offset (%#" PRIx64
") into section %s\n"),
10473 printable_section_name (filedata
, table_sec
));
10480 table_sec
= find_section_by_address (filedata
, table
);
10481 if (table_sec
!= NULL
)
10482 table_offset
= table
- table_sec
->sh_addr
;
10485 if (table_sec
== NULL
)
10487 warn (_("Could not locate .ARM.extab section containing %#" PRIx64
".\n"),
10493 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
10501 free (aux
->funtab
);
10502 arm_free_section (&exidx_arm_sec
);
10503 arm_free_section (&extab_arm_sec
);
10508 /* Used for both ARM and C6X unwinding tables. */
10511 arm_process_unwind (Filedata
* filedata
)
10513 struct arm_unw_aux_info aux
;
10514 Elf_Internal_Shdr
*unwsec
= NULL
;
10515 Elf_Internal_Shdr
*sec
;
10517 unsigned int sec_type
;
10520 switch (filedata
->file_header
.e_machine
)
10523 sec_type
= SHT_ARM_EXIDX
;
10527 sec_type
= SHT_C6000_UNWIND
;
10531 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
10532 filedata
->file_header
.e_machine
);
10536 if (filedata
->string_table
== NULL
)
10539 memset (& aux
, 0, sizeof (aux
));
10540 aux
.filedata
= filedata
;
10542 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
10544 if (sec
->sh_type
== SHT_SYMTAB
)
10548 error (_("Multiple symbol tables encountered\n"));
10554 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
10555 &aux
.strtab
, &aux
.strtab_size
))
10558 else if (sec
->sh_type
== sec_type
)
10562 if (unwsec
== NULL
)
10563 printf (_("\nThere are no unwind sections in this file.\n"));
10565 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
10567 if (sec
->sh_type
== sec_type
)
10569 uint64_t num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
10570 printf (ngettext ("\nUnwind section '%s' at offset %#" PRIx64
" "
10571 "contains %" PRIu64
" entry:\n",
10572 "\nUnwind section '%s' at offset %#" PRIx64
" "
10573 "contains %" PRIu64
" entries:\n",
10575 printable_section_name (filedata
, sec
),
10579 if (! dump_arm_unwind (filedata
, &aux
, sec
))
10585 free ((char *) aux
.strtab
);
10591 no_processor_specific_unwind (Filedata
* filedata ATTRIBUTE_UNUSED
)
10593 printf (_("No processor specific unwind information to decode\n"));
10598 process_unwind (Filedata
* filedata
)
10600 struct unwind_handler
10602 unsigned int machtype
;
10603 bool (* handler
)(Filedata
*);
10606 { EM_ARM
, arm_process_unwind
},
10607 { EM_IA_64
, ia64_process_unwind
},
10608 { EM_PARISC
, hppa_process_unwind
},
10609 { EM_TI_C6000
, arm_process_unwind
},
10610 { EM_386
, no_processor_specific_unwind
},
10611 { EM_X86_64
, no_processor_specific_unwind
},
10619 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
10620 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
10621 return handlers
[i
].handler (filedata
);
10623 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
10624 get_machine_name (filedata
->file_header
.e_machine
));
10629 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
10631 switch (entry
->d_tag
)
10633 case DT_AARCH64_BTI_PLT
:
10634 case DT_AARCH64_PAC_PLT
:
10637 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10644 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
10646 switch (entry
->d_tag
)
10648 case DT_MIPS_FLAGS
:
10649 if (entry
->d_un
.d_val
== 0)
10650 printf (_("NONE"));
10653 static const char * opts
[] =
10655 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
10656 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
10657 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
10658 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
10664 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
10665 if (entry
->d_un
.d_val
& (1 << cnt
))
10667 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
10673 case DT_MIPS_IVERSION
:
10674 if (valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
10675 printf (_("Interface Version: %s"),
10676 get_dynamic_name (filedata
, entry
->d_un
.d_val
));
10678 printf (_("Interface Version: <corrupt: %" PRIx64
">"),
10679 entry
->d_un
.d_ptr
);
10682 case DT_MIPS_TIME_STAMP
:
10686 time_t atime
= entry
->d_un
.d_val
;
10688 tmp
= gmtime (&atime
);
10689 /* PR 17531: file: 6accc532. */
10691 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
10693 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
10694 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10695 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10696 printf (_("Time Stamp: %s"), timebuf
);
10700 case DT_MIPS_RLD_VERSION
:
10701 case DT_MIPS_LOCAL_GOTNO
:
10702 case DT_MIPS_CONFLICTNO
:
10703 case DT_MIPS_LIBLISTNO
:
10704 case DT_MIPS_SYMTABNO
:
10705 case DT_MIPS_UNREFEXTNO
:
10706 case DT_MIPS_HIPAGENO
:
10707 case DT_MIPS_DELTA_CLASS_NO
:
10708 case DT_MIPS_DELTA_INSTANCE_NO
:
10709 case DT_MIPS_DELTA_RELOC_NO
:
10710 case DT_MIPS_DELTA_SYM_NO
:
10711 case DT_MIPS_DELTA_CLASSSYM_NO
:
10712 case DT_MIPS_COMPACT_SIZE
:
10713 print_vma (entry
->d_un
.d_val
, DEC
);
10716 case DT_MIPS_XHASH
:
10717 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10718 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10719 /* Falls through. */
10722 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10728 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
10730 switch (entry
->d_tag
)
10732 case DT_HP_DLD_FLAGS
:
10741 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
10742 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
10743 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
10744 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
10745 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
10746 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
10747 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
10748 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
10749 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
10750 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
10751 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
10752 { DT_HP_GST
, "HP_GST" },
10753 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
10754 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
10755 { DT_HP_NODELETE
, "HP_NODELETE" },
10756 { DT_HP_GROUP
, "HP_GROUP" },
10757 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
10761 uint64_t val
= entry
->d_un
.d_val
;
10763 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
10764 if (val
& flags
[cnt
].bit
)
10768 fputs (flags
[cnt
].str
, stdout
);
10770 val
^= flags
[cnt
].bit
;
10773 if (val
!= 0 || first
)
10777 print_vma (val
, HEX
);
10783 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10789 /* VMS vs Unix time offset and factor. */
10791 #define VMS_EPOCH_OFFSET 35067168000000000LL
10792 #define VMS_GRANULARITY_FACTOR 10000000
10794 #define INT64_MIN (-9223372036854775807LL - 1)
10797 /* Display a VMS time in a human readable format. */
10800 print_vms_time (int64_t vmstime
)
10802 struct tm
*tm
= NULL
;
10805 if (vmstime
>= INT64_MIN
+ VMS_EPOCH_OFFSET
)
10807 vmstime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
10809 if (unxtime
== vmstime
)
10810 tm
= gmtime (&unxtime
);
10813 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
10814 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
10815 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
10819 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
10821 switch (entry
->d_tag
)
10823 case DT_IA_64_PLT_RESERVE
:
10824 /* First 3 slots reserved. */
10825 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10827 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
10830 case DT_IA_64_VMS_LINKTIME
:
10831 print_vms_time (entry
->d_un
.d_val
);
10834 case DT_IA_64_VMS_LNKFLAGS
:
10835 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10836 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
10837 printf (" CALL_DEBUG");
10838 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
10839 printf (" NOP0BUFS");
10840 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
10841 printf (" P0IMAGE");
10842 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
10843 printf (" MKTHREADS");
10844 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
10845 printf (" UPCALLS");
10846 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
10847 printf (" IMGSTA");
10848 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
10849 printf (" INITIALIZE");
10850 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
10852 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
10853 printf (" EXE_INIT");
10854 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
10855 printf (" TBK_IN_IMG");
10856 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
10857 printf (" DBG_IN_IMG");
10858 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
10859 printf (" TBK_IN_DSF");
10860 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
10861 printf (" DBG_IN_DSF");
10862 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
10863 printf (" SIGNATURES");
10864 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
10865 printf (" REL_SEG_OFF");
10869 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10876 get_32bit_dynamic_section (Filedata
* filedata
)
10878 Elf32_External_Dyn
* edyn
;
10879 Elf32_External_Dyn
* ext
;
10880 Elf_Internal_Dyn
* entry
;
10882 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
10883 filedata
->dynamic_addr
, 1,
10884 filedata
->dynamic_size
,
10885 _("dynamic section"));
10889 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
10890 might not have the luxury of section headers. Look for the DT_NULL
10891 terminator to determine the number of entries. */
10892 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
10893 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
10896 filedata
->dynamic_nent
++;
10897 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
10901 filedata
->dynamic_section
10902 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
10903 if (filedata
->dynamic_section
== NULL
)
10905 error (_("Out of memory allocating space for %" PRIu64
" dynamic entries\n"),
10906 filedata
->dynamic_nent
);
10911 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10912 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10915 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10916 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10925 get_64bit_dynamic_section (Filedata
* filedata
)
10927 Elf64_External_Dyn
* edyn
;
10928 Elf64_External_Dyn
* ext
;
10929 Elf_Internal_Dyn
* entry
;
10931 /* Read in the data. */
10932 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
10933 filedata
->dynamic_addr
, 1,
10934 filedata
->dynamic_size
,
10935 _("dynamic section"));
10939 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
10940 might not have the luxury of section headers. Look for the DT_NULL
10941 terminator to determine the number of entries. */
10942 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
10943 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
10944 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
10947 filedata
->dynamic_nent
++;
10948 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
10952 filedata
->dynamic_section
10953 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
10954 if (filedata
->dynamic_section
== NULL
)
10956 error (_("Out of memory allocating space for %" PRIu64
" dynamic entries\n"),
10957 filedata
->dynamic_nent
);
10962 /* Convert from external to internal formats. */
10963 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10964 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10967 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10968 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10977 get_dynamic_section (Filedata
*filedata
)
10979 if (filedata
->dynamic_section
)
10983 return get_32bit_dynamic_section (filedata
);
10985 return get_64bit_dynamic_section (filedata
);
10989 print_dynamic_flags (uint64_t flags
)
10997 flag
= flags
& - flags
;
11003 putc (' ', stdout
);
11007 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
11008 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
11009 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
11010 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
11011 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
11012 default: fputs (_("unknown"), stdout
); break;
11019 get_dynamic_data (Filedata
* filedata
, uint64_t number
, unsigned int ent_size
)
11021 unsigned char * e_data
;
11024 /* If size_t is smaller than uint64_t, eg because you are building
11025 on a 32-bit host, then make sure that when number is cast to
11026 size_t no information is lost. */
11027 if ((size_t) number
!= number
11028 || ent_size
* number
/ ent_size
!= number
)
11030 error (_("Size overflow prevents reading %" PRIu64
11031 " elements of size %u\n"),
11036 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
11037 attempting to allocate memory when the read is bound to fail. */
11038 if (ent_size
* number
> filedata
->file_size
)
11040 error (_("Invalid number of dynamic entries: %" PRIu64
"\n"),
11045 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11046 if (e_data
== NULL
)
11048 error (_("Out of memory reading %" PRIu64
" dynamic entries\n"),
11053 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11055 error (_("Unable to read in %" PRIu64
" bytes of dynamic data\n"),
11056 number
* ent_size
);
11061 i_data
= (uint64_t *) cmalloc ((size_t) number
, sizeof (*i_data
));
11062 if (i_data
== NULL
)
11064 error (_("Out of memory allocating space for %" PRIu64
" dynamic entries\n"),
11071 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11079 get_num_dynamic_syms (Filedata
* filedata
)
11081 uint64_t num_of_syms
= 0;
11083 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
11084 return num_of_syms
;
11086 if (filedata
->dynamic_info
[DT_HASH
])
11088 unsigned char nb
[8];
11089 unsigned char nc
[8];
11090 unsigned int hash_ent_size
= 4;
11092 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11093 || filedata
->file_header
.e_machine
== EM_S390
11094 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11095 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11098 if (fseek64 (filedata
->handle
,
11099 (filedata
->archive_file_offset
11100 + offset_from_vma (filedata
,
11101 filedata
->dynamic_info
[DT_HASH
],
11102 sizeof nb
+ sizeof nc
)),
11105 error (_("Unable to seek to start of dynamic information\n"));
11109 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11111 error (_("Failed to read in number of buckets\n"));
11115 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11117 error (_("Failed to read in number of chains\n"));
11121 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
11122 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
11124 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
11126 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
11128 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
11131 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
11132 num_of_syms
= filedata
->nchains
;
11135 if (num_of_syms
== 0)
11137 free (filedata
->buckets
);
11138 filedata
->buckets
= NULL
;
11139 free (filedata
->chains
);
11140 filedata
->chains
= NULL
;
11141 filedata
->nbuckets
= 0;
11145 if (filedata
->dynamic_info_DT_GNU_HASH
)
11147 unsigned char nb
[16];
11148 uint64_t i
, maxchain
= 0xffffffff, bitmaskwords
;
11149 uint64_t buckets_vma
;
11152 if (fseek64 (filedata
->handle
,
11153 (filedata
->archive_file_offset
11154 + offset_from_vma (filedata
,
11155 filedata
->dynamic_info_DT_GNU_HASH
,
11159 error (_("Unable to seek to start of dynamic information\n"));
11163 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11165 error (_("Failed to read in number of buckets\n"));
11169 filedata
->ngnubuckets
= byte_get (nb
, 4);
11170 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
11171 bitmaskwords
= byte_get (nb
+ 8, 4);
11172 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
11174 buckets_vma
+= bitmaskwords
* 4;
11176 buckets_vma
+= bitmaskwords
* 8;
11178 if (fseek64 (filedata
->handle
,
11179 (filedata
->archive_file_offset
11180 + offset_from_vma (filedata
, buckets_vma
, 4)),
11183 error (_("Unable to seek to start of dynamic information\n"));
11187 filedata
->gnubuckets
11188 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
11190 if (filedata
->gnubuckets
== NULL
)
11193 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
11194 if (filedata
->gnubuckets
[i
] != 0)
11196 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
11199 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
11200 maxchain
= filedata
->gnubuckets
[i
];
11203 if (maxchain
== 0xffffffff)
11206 maxchain
-= filedata
->gnusymidx
;
11208 if (fseek64 (filedata
->handle
,
11209 (filedata
->archive_file_offset
11210 + offset_from_vma (filedata
,
11211 buckets_vma
+ 4 * (filedata
->ngnubuckets
11216 error (_("Unable to seek to start of dynamic information\n"));
11222 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11224 error (_("Failed to determine last chain length\n"));
11228 if (maxchain
+ 1 == 0)
11233 while ((byte_get (nb
, 4) & 1) == 0);
11235 if (fseek64 (filedata
->handle
,
11236 (filedata
->archive_file_offset
11237 + offset_from_vma (filedata
, (buckets_vma
11238 + 4 * filedata
->ngnubuckets
),
11242 error (_("Unable to seek to start of dynamic information\n"));
11246 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11247 filedata
->ngnuchains
= maxchain
;
11249 if (filedata
->gnuchains
== NULL
)
11252 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
11254 if (fseek64 (filedata
->handle
,
11255 (filedata
->archive_file_offset
11256 + offset_from_vma (filedata
, (buckets_vma
11257 + 4 * (filedata
->ngnubuckets
11261 error (_("Unable to seek to start of dynamic information\n"));
11265 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
11266 if (filedata
->mipsxlat
== NULL
)
11270 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
11271 if (filedata
->gnubuckets
[hn
] != 0)
11273 uint64_t si
= filedata
->gnubuckets
[hn
];
11274 uint64_t off
= si
- filedata
->gnusymidx
;
11278 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
11280 if (off
< filedata
->ngnuchains
11281 && filedata
->mipsxlat
[off
] >= num_of_syms
)
11282 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
11286 if (si
>= num_of_syms
)
11287 num_of_syms
= si
+ 1;
11291 while (off
< filedata
->ngnuchains
11292 && (filedata
->gnuchains
[off
++] & 1) == 0);
11295 if (num_of_syms
== 0)
11298 free (filedata
->mipsxlat
);
11299 filedata
->mipsxlat
= NULL
;
11300 free (filedata
->gnuchains
);
11301 filedata
->gnuchains
= NULL
;
11302 free (filedata
->gnubuckets
);
11303 filedata
->gnubuckets
= NULL
;
11304 filedata
->ngnubuckets
= 0;
11305 filedata
->ngnuchains
= 0;
11309 return num_of_syms
;
11312 /* Parse and display the contents of the dynamic section. */
11315 process_dynamic_section (Filedata
* filedata
)
11317 Elf_Internal_Dyn
* entry
;
11319 if (filedata
->dynamic_size
<= 1)
11323 if (filedata
->is_separate
)
11324 printf (_("\nThere is no dynamic section in linked file '%s'.\n"),
11325 filedata
->file_name
);
11327 printf (_("\nThere is no dynamic section in this file.\n"));
11333 if (!get_dynamic_section (filedata
))
11336 /* Find the appropriate symbol table. */
11337 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
11339 uint64_t num_of_syms
;
11341 for (entry
= filedata
->dynamic_section
;
11342 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11344 if (entry
->d_tag
== DT_SYMTAB
)
11345 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
11346 else if (entry
->d_tag
== DT_SYMENT
)
11347 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
11348 else if (entry
->d_tag
== DT_HASH
)
11349 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
11350 else if (entry
->d_tag
== DT_GNU_HASH
)
11351 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11352 else if ((filedata
->file_header
.e_machine
== EM_MIPS
11353 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
11354 && entry
->d_tag
== DT_MIPS_XHASH
)
11356 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
11357 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11360 num_of_syms
= get_num_dynamic_syms (filedata
);
11362 if (num_of_syms
!= 0
11363 && filedata
->dynamic_symbols
== NULL
11364 && filedata
->dynamic_info
[DT_SYMTAB
]
11365 && filedata
->dynamic_info
[DT_SYMENT
])
11367 Elf_Internal_Phdr
*seg
;
11368 uint64_t vma
= filedata
->dynamic_info
[DT_SYMTAB
];
11370 if (! get_program_headers (filedata
))
11372 error (_("Cannot interpret virtual addresses "
11373 "without program headers.\n"));
11377 for (seg
= filedata
->program_headers
;
11378 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
11381 if (seg
->p_type
!= PT_LOAD
)
11384 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
11386 /* See PR 21379 for a reproducer. */
11387 error (_("Invalid PT_LOAD entry\n"));
11391 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
11392 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
11394 /* Since we do not know how big the symbol table is,
11395 we default to reading in up to the end of PT_LOAD
11396 segment and processing that. This is overkill, I
11397 know, but it should work. */
11398 Elf_Internal_Shdr section
;
11399 section
.sh_offset
= (vma
- seg
->p_vaddr
11401 section
.sh_size
= (num_of_syms
11402 * filedata
->dynamic_info
[DT_SYMENT
]);
11403 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
11406 && filedata
->dynamic_symtab_section
!= NULL
11407 && ((filedata
->dynamic_symtab_section
->sh_offset
11408 != section
.sh_offset
)
11409 || (filedata
->dynamic_symtab_section
->sh_size
11410 != section
.sh_size
)
11411 || (filedata
->dynamic_symtab_section
->sh_entsize
11412 != section
.sh_entsize
)))
11414 the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
11416 section
.sh_name
= filedata
->string_table_length
;
11417 filedata
->dynamic_symbols
11418 = get_elf_symbols (filedata
, §ion
,
11419 &filedata
->num_dynamic_syms
);
11420 if (filedata
->dynamic_symbols
== NULL
11421 || filedata
->num_dynamic_syms
!= num_of_syms
)
11423 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
11432 /* Similarly find a string table. */
11433 if (filedata
->dynamic_strings
== NULL
)
11434 for (entry
= filedata
->dynamic_section
;
11435 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11438 if (entry
->d_tag
== DT_STRTAB
)
11439 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
11441 if (entry
->d_tag
== DT_STRSZ
)
11442 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
11444 if (filedata
->dynamic_info
[DT_STRTAB
]
11445 && filedata
->dynamic_info
[DT_STRSZ
])
11448 uint64_t str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
11450 offset
= offset_from_vma (filedata
,
11451 filedata
->dynamic_info
[DT_STRTAB
],
11454 && filedata
->dynamic_strtab_section
11455 && ((filedata
->dynamic_strtab_section
->sh_offset
11456 != (file_ptr
) offset
)
11457 || (filedata
->dynamic_strtab_section
->sh_size
11460 the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
11462 filedata
->dynamic_strings
11463 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
11464 _("dynamic string table"));
11465 if (filedata
->dynamic_strings
== NULL
)
11467 error (_("Corrupt DT_STRTAB dynamic entry\n"));
11471 filedata
->dynamic_strings_length
= str_tab_len
;
11476 /* And find the syminfo section if available. */
11477 if (filedata
->dynamic_syminfo
== NULL
)
11479 uint64_t syminsz
= 0;
11481 for (entry
= filedata
->dynamic_section
;
11482 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11485 if (entry
->d_tag
== DT_SYMINENT
)
11487 /* Note: these braces are necessary to avoid a syntax
11488 error from the SunOS4 C compiler. */
11489 /* PR binutils/17531: A corrupt file can trigger this test.
11490 So do not use an assert, instead generate an error message. */
11491 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
11492 error (_("Bad value (%d) for SYMINENT entry\n"),
11493 (int) entry
->d_un
.d_val
);
11495 else if (entry
->d_tag
== DT_SYMINSZ
)
11496 syminsz
= entry
->d_un
.d_val
;
11497 else if (entry
->d_tag
== DT_SYMINFO
)
11498 filedata
->dynamic_syminfo_offset
11499 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
11502 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
11504 Elf_External_Syminfo
* extsyminfo
;
11505 Elf_External_Syminfo
* extsym
;
11506 Elf_Internal_Syminfo
* syminfo
;
11508 /* There is a syminfo section. Read the data. */
11509 extsyminfo
= (Elf_External_Syminfo
*)
11510 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
11511 1, syminsz
, _("symbol information"));
11515 if (filedata
->dynamic_syminfo
!= NULL
)
11517 error (_("Multiple dynamic symbol information sections found\n"));
11518 free (filedata
->dynamic_syminfo
);
11520 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
11521 if (filedata
->dynamic_syminfo
== NULL
)
11523 error (_("Out of memory allocating %" PRIu64
11524 " bytes for dynamic symbol info\n"),
11529 filedata
->dynamic_syminfo_nent
11530 = syminsz
/ sizeof (Elf_External_Syminfo
);
11531 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
11532 syminfo
< (filedata
->dynamic_syminfo
11533 + filedata
->dynamic_syminfo_nent
);
11534 ++syminfo
, ++extsym
)
11536 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
11537 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
11544 if (do_dynamic
&& filedata
->dynamic_addr
)
11546 if (filedata
->is_separate
)
11547 printf (ngettext ("\nIn linked file '%s' the dynamic section at offset %#" PRIx64
" contains %" PRIu64
" entry:\n",
11548 "\nIn linked file '%s' the dynamic section at offset %#" PRIx64
" contains %" PRIu64
" entries:\n",
11549 filedata
->dynamic_nent
),
11550 filedata
->file_name
,
11551 filedata
->dynamic_addr
,
11552 filedata
->dynamic_nent
);
11554 printf (ngettext ("\nDynamic section at offset %#" PRIx64
" contains %" PRIu64
" entry:\n",
11555 "\nDynamic section at offset %#" PRIx64
" contains %" PRIu64
" entries:\n",
11556 filedata
->dynamic_nent
),
11557 filedata
->dynamic_addr
,
11558 filedata
->dynamic_nent
);
11561 printf (_(" Tag Type Name/Value\n"));
11563 for (entry
= filedata
->dynamic_section
;
11564 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11569 const char * dtype
;
11572 print_vma (entry
->d_tag
, FULL_HEX
);
11573 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
11574 printf (" (%s)%*s", dtype
,
11575 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
11578 switch (entry
->d_tag
)
11582 print_dynamic_flags (entry
->d_un
.d_val
);
11592 switch (entry
->d_tag
)
11595 printf (_("Auxiliary library"));
11599 printf (_("Filter library"));
11603 printf (_("Configuration file"));
11607 printf (_("Dependency audit library"));
11611 printf (_("Audit library"));
11615 if (valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
11616 printf (": [%s]\n",
11617 get_dynamic_name (filedata
, entry
->d_un
.d_val
));
11621 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11630 printf (_("Flags:"));
11632 if (entry
->d_un
.d_val
== 0)
11633 printf (_(" None\n"));
11636 uint64_t val
= entry
->d_un
.d_val
;
11638 if (val
& DTF_1_PARINIT
)
11640 printf (" PARINIT");
11641 val
^= DTF_1_PARINIT
;
11643 if (val
& DTF_1_CONFEXP
)
11645 printf (" CONFEXP");
11646 val
^= DTF_1_CONFEXP
;
11649 printf (" %" PRIx64
, val
);
11658 printf (_("Flags:"));
11660 if (entry
->d_un
.d_val
== 0)
11661 printf (_(" None\n"));
11664 uint64_t val
= entry
->d_un
.d_val
;
11666 if (val
& DF_P1_LAZYLOAD
)
11668 printf (" LAZYLOAD");
11669 val
^= DF_P1_LAZYLOAD
;
11671 if (val
& DF_P1_GROUPPERM
)
11673 printf (" GROUPPERM");
11674 val
^= DF_P1_GROUPPERM
;
11677 printf (" %" PRIx64
, val
);
11686 printf (_("Flags:"));
11687 if (entry
->d_un
.d_val
== 0)
11688 printf (_(" None\n"));
11691 uint64_t val
= entry
->d_un
.d_val
;
11693 if (val
& DF_1_NOW
)
11698 if (val
& DF_1_GLOBAL
)
11700 printf (" GLOBAL");
11701 val
^= DF_1_GLOBAL
;
11703 if (val
& DF_1_GROUP
)
11708 if (val
& DF_1_NODELETE
)
11710 printf (" NODELETE");
11711 val
^= DF_1_NODELETE
;
11713 if (val
& DF_1_LOADFLTR
)
11715 printf (" LOADFLTR");
11716 val
^= DF_1_LOADFLTR
;
11718 if (val
& DF_1_INITFIRST
)
11720 printf (" INITFIRST");
11721 val
^= DF_1_INITFIRST
;
11723 if (val
& DF_1_NOOPEN
)
11725 printf (" NOOPEN");
11726 val
^= DF_1_NOOPEN
;
11728 if (val
& DF_1_ORIGIN
)
11730 printf (" ORIGIN");
11731 val
^= DF_1_ORIGIN
;
11733 if (val
& DF_1_DIRECT
)
11735 printf (" DIRECT");
11736 val
^= DF_1_DIRECT
;
11738 if (val
& DF_1_TRANS
)
11743 if (val
& DF_1_INTERPOSE
)
11745 printf (" INTERPOSE");
11746 val
^= DF_1_INTERPOSE
;
11748 if (val
& DF_1_NODEFLIB
)
11750 printf (" NODEFLIB");
11751 val
^= DF_1_NODEFLIB
;
11753 if (val
& DF_1_NODUMP
)
11755 printf (" NODUMP");
11756 val
^= DF_1_NODUMP
;
11758 if (val
& DF_1_CONFALT
)
11760 printf (" CONFALT");
11761 val
^= DF_1_CONFALT
;
11763 if (val
& DF_1_ENDFILTEE
)
11765 printf (" ENDFILTEE");
11766 val
^= DF_1_ENDFILTEE
;
11768 if (val
& DF_1_DISPRELDNE
)
11770 printf (" DISPRELDNE");
11771 val
^= DF_1_DISPRELDNE
;
11773 if (val
& DF_1_DISPRELPND
)
11775 printf (" DISPRELPND");
11776 val
^= DF_1_DISPRELPND
;
11778 if (val
& DF_1_NODIRECT
)
11780 printf (" NODIRECT");
11781 val
^= DF_1_NODIRECT
;
11783 if (val
& DF_1_IGNMULDEF
)
11785 printf (" IGNMULDEF");
11786 val
^= DF_1_IGNMULDEF
;
11788 if (val
& DF_1_NOKSYMS
)
11790 printf (" NOKSYMS");
11791 val
^= DF_1_NOKSYMS
;
11793 if (val
& DF_1_NOHDR
)
11798 if (val
& DF_1_EDITED
)
11800 printf (" EDITED");
11801 val
^= DF_1_EDITED
;
11803 if (val
& DF_1_NORELOC
)
11805 printf (" NORELOC");
11806 val
^= DF_1_NORELOC
;
11808 if (val
& DF_1_SYMINTPOSE
)
11810 printf (" SYMINTPOSE");
11811 val
^= DF_1_SYMINTPOSE
;
11813 if (val
& DF_1_GLOBAUDIT
)
11815 printf (" GLOBAUDIT");
11816 val
^= DF_1_GLOBAUDIT
;
11818 if (val
& DF_1_SINGLETON
)
11820 printf (" SINGLETON");
11821 val
^= DF_1_SINGLETON
;
11823 if (val
& DF_1_STUB
)
11828 if (val
& DF_1_PIE
)
11833 if (val
& DF_1_KMOD
)
11838 if (val
& DF_1_WEAKFILTER
)
11840 printf (" WEAKFILTER");
11841 val
^= DF_1_WEAKFILTER
;
11843 if (val
& DF_1_NOCOMMON
)
11845 printf (" NOCOMMON");
11846 val
^= DF_1_NOCOMMON
;
11849 printf (" %" PRIx64
, val
);
11856 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11858 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
11879 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11885 if (valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
11886 name
= get_dynamic_name (filedata
, entry
->d_un
.d_val
);
11892 switch (entry
->d_tag
)
11895 printf (_("Shared library: [%s]"), name
);
11897 if (filedata
->program_interpreter
11898 && streq (name
, filedata
->program_interpreter
))
11899 printf (_(" program interpreter"));
11903 printf (_("Library soname: [%s]"), name
);
11907 printf (_("Library rpath: [%s]"), name
);
11911 printf (_("Library runpath: [%s]"), name
);
11915 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11920 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11935 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11936 /* Fall through. */
11940 case DT_PREINIT_ARRAYSZ
:
11941 case DT_INIT_ARRAYSZ
:
11942 case DT_FINI_ARRAYSZ
:
11943 case DT_GNU_CONFLICTSZ
:
11944 case DT_GNU_LIBLISTSZ
:
11947 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11948 printf (_(" (bytes)\n"));
11953 case DT_VERNEEDNUM
:
11958 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11967 case DT_INIT_ARRAY
:
11968 case DT_FINI_ARRAY
:
11971 if (entry
->d_tag
== DT_USED
11972 && valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
11975 = get_dynamic_name (filedata
, entry
->d_un
.d_val
);
11979 printf (_("Not needed object: [%s]\n"), name
);
11984 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11990 /* The value of this entry is ignored. */
11995 case DT_GNU_PRELINKED
:
11999 time_t atime
= entry
->d_un
.d_val
;
12001 tmp
= gmtime (&atime
);
12002 /* PR 17533 file: 041-1244816-0.004. */
12004 printf (_("<corrupt time val: %" PRIx64
),
12007 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
12008 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
12009 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
12015 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
12018 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12023 case DT_GNU_FLAGS_1
:
12026 printf (_("Flags:"));
12027 if (entry
->d_un
.d_val
== 0)
12028 printf (_(" None\n"));
12031 uint64_t val
= entry
->d_un
.d_val
;
12033 if (val
& DF_GNU_1_UNIQUE
)
12035 printf (" UNIQUE");
12036 val
^= DF_GNU_1_UNIQUE
;
12039 printf (" %" PRIx64
, val
);
12046 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
12047 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
12048 = entry
->d_un
.d_val
;
12052 switch (filedata
->file_header
.e_machine
)
12055 dynamic_section_aarch64_val (entry
);
12058 case EM_MIPS_RS3_LE
:
12059 dynamic_section_mips_val (filedata
, entry
);
12062 dynamic_section_parisc_val (entry
);
12065 dynamic_section_ia64_val (entry
);
12068 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12080 get_ver_flags (unsigned int flags
)
12082 static char buff
[128];
12089 if (flags
& VER_FLG_BASE
)
12090 strcat (buff
, "BASE");
12092 if (flags
& VER_FLG_WEAK
)
12094 if (flags
& VER_FLG_BASE
)
12095 strcat (buff
, " | ");
12097 strcat (buff
, "WEAK");
12100 if (flags
& VER_FLG_INFO
)
12102 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
12103 strcat (buff
, " | ");
12105 strcat (buff
, "INFO");
12108 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
12110 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
12111 strcat (buff
, " | ");
12113 strcat (buff
, _("<unknown>"));
12119 /* Display the contents of the version sections. */
12122 process_version_sections (Filedata
* filedata
)
12124 Elf_Internal_Shdr
* section
;
12126 bool found
= false;
12131 for (i
= 0, section
= filedata
->section_headers
;
12132 i
< filedata
->file_header
.e_shnum
;
12135 switch (section
->sh_type
)
12137 case SHT_GNU_verdef
:
12139 Elf_External_Verdef
* edefs
;
12146 if (filedata
->is_separate
)
12147 printf (ngettext ("\nIn linked file '%s' the version definition section '%s' contains %u entry:\n",
12148 "\nIn linked file '%s' the version definition section '%s' contains %u entries:\n",
12150 filedata
->file_name
,
12151 printable_section_name (filedata
, section
),
12154 printf (ngettext ("\nVersion definition section '%s' "
12155 "contains %u entry:\n",
12156 "\nVersion definition section '%s' "
12157 "contains %u entries:\n",
12159 printable_section_name (filedata
, section
),
12162 printf (_(" Addr: 0x%016" PRIx64
), section
->sh_addr
);
12163 printf (_(" Offset: 0x%08" PRIx64
" Link: %u (%s)\n"),
12164 section
->sh_offset
, section
->sh_link
,
12165 printable_section_name_from_index (filedata
, section
->sh_link
));
12167 edefs
= (Elf_External_Verdef
*)
12168 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
12169 _("version definition section"));
12172 endbuf
= (char *) edefs
+ section
->sh_size
;
12174 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
12177 Elf_External_Verdef
* edef
;
12178 Elf_Internal_Verdef ent
;
12179 Elf_External_Verdaux
* eaux
;
12180 Elf_Internal_Verdaux aux
;
12184 vstart
= ((char *) edefs
) + idx
;
12185 if (vstart
+ sizeof (*edef
) > endbuf
)
12188 edef
= (Elf_External_Verdef
*) vstart
;
12190 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
12191 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
12192 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
12193 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
12194 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
12195 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
12196 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
12198 printf (_(" %#06zx: Rev: %d Flags: %s"),
12199 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
12201 printf (_(" Index: %d Cnt: %d "),
12202 ent
.vd_ndx
, ent
.vd_cnt
);
12204 /* Check for overflow. */
12205 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
12208 vstart
+= ent
.vd_aux
;
12210 if (vstart
+ sizeof (*eaux
) > endbuf
)
12212 eaux
= (Elf_External_Verdaux
*) vstart
;
12214 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
12215 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
12217 if (valid_dynamic_name (filedata
, aux
.vda_name
))
12218 printf (_("Name: %s\n"),
12219 get_dynamic_name (filedata
, aux
.vda_name
));
12221 printf (_("Name index: %ld\n"), aux
.vda_name
);
12223 isum
= idx
+ ent
.vd_aux
;
12225 for (j
= 1; j
< ent
.vd_cnt
; j
++)
12227 if (aux
.vda_next
< sizeof (*eaux
)
12228 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
12230 warn (_("Invalid vda_next field of %lx\n"),
12235 /* Check for overflow. */
12236 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
12239 isum
+= aux
.vda_next
;
12240 vstart
+= aux
.vda_next
;
12242 if (vstart
+ sizeof (*eaux
) > endbuf
)
12244 eaux
= (Elf_External_Verdaux
*) vstart
;
12246 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
12247 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
12249 if (valid_dynamic_name (filedata
, aux
.vda_name
))
12250 printf (_(" %#06zx: Parent %d: %s\n"),
12252 get_dynamic_name (filedata
, aux
.vda_name
));
12254 printf (_(" %#06zx: Parent %d, name index: %ld\n"),
12255 isum
, j
, aux
.vda_name
);
12258 if (j
< ent
.vd_cnt
)
12259 printf (_(" Version def aux past end of section\n"));
12262 file: id:000001,src:000172+005151,op:splice,rep:2. */
12263 if (ent
.vd_next
< sizeof (*edef
)
12264 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
12266 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
12267 cnt
= section
->sh_info
;
12270 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
12273 idx
+= ent
.vd_next
;
12276 if (cnt
< section
->sh_info
)
12277 printf (_(" Version definition past end of section\n"));
12283 case SHT_GNU_verneed
:
12285 Elf_External_Verneed
* eneed
;
12292 if (filedata
->is_separate
)
12293 printf (ngettext ("\nIn linked file '%s' the version needs section '%s' contains %u entry:\n",
12294 "\nIn linked file '%s' the version needs section '%s' contains %u entries:\n",
12296 filedata
->file_name
,
12297 printable_section_name (filedata
, section
),
12300 printf (ngettext ("\nVersion needs section '%s' "
12301 "contains %u entry:\n",
12302 "\nVersion needs section '%s' "
12303 "contains %u entries:\n",
12305 printable_section_name (filedata
, section
),
12308 printf (_(" Addr: 0x%016" PRIx64
), section
->sh_addr
);
12309 printf (_(" Offset: 0x%08" PRIx64
" Link: %u (%s)\n"),
12310 section
->sh_offset
, section
->sh_link
,
12311 printable_section_name_from_index (filedata
, section
->sh_link
));
12313 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
12314 section
->sh_offset
, 1,
12316 _("Version Needs section"));
12319 endbuf
= (char *) eneed
+ section
->sh_size
;
12321 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
12323 Elf_External_Verneed
* entry
;
12324 Elf_Internal_Verneed ent
;
12329 vstart
= ((char *) eneed
) + idx
;
12330 if (vstart
+ sizeof (*entry
) > endbuf
)
12333 entry
= (Elf_External_Verneed
*) vstart
;
12335 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
12336 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
12337 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
12338 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
12339 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
12341 printf (_(" %#06zx: Version: %d"), idx
, ent
.vn_version
);
12343 if (valid_dynamic_name (filedata
, ent
.vn_file
))
12344 printf (_(" File: %s"),
12345 get_dynamic_name (filedata
, ent
.vn_file
));
12347 printf (_(" File: %lx"), ent
.vn_file
);
12349 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
12351 /* Check for overflow. */
12352 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
12354 vstart
+= ent
.vn_aux
;
12356 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
12358 Elf_External_Vernaux
* eaux
;
12359 Elf_Internal_Vernaux aux
;
12361 if (vstart
+ sizeof (*eaux
) > endbuf
)
12363 eaux
= (Elf_External_Vernaux
*) vstart
;
12365 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
12366 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
12367 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
12368 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
12369 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
12371 if (valid_dynamic_name (filedata
, aux
.vna_name
))
12372 printf (_(" %#06zx: Name: %s"),
12373 isum
, get_dynamic_name (filedata
, aux
.vna_name
));
12375 printf (_(" %#06zx: Name index: %lx"),
12376 isum
, aux
.vna_name
);
12378 printf (_(" Flags: %s Version: %d\n"),
12379 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
12381 if (aux
.vna_next
< sizeof (*eaux
)
12382 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
12384 warn (_("Invalid vna_next field of %lx\n"),
12389 /* Check for overflow. */
12390 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
12392 isum
+= aux
.vna_next
;
12393 vstart
+= aux
.vna_next
;
12396 if (j
< ent
.vn_cnt
)
12397 warn (_("Missing Version Needs auxiliary information\n"));
12399 if (ent
.vn_next
< sizeof (*entry
)
12400 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
12402 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
12403 cnt
= section
->sh_info
;
12406 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
12408 idx
+= ent
.vn_next
;
12411 if (cnt
< section
->sh_info
)
12412 warn (_("Missing Version Needs information\n"));
12418 case SHT_GNU_versym
:
12420 Elf_Internal_Shdr
* link_section
;
12423 unsigned char * edata
;
12424 unsigned short * data
;
12426 Elf_Internal_Sym
* symbols
;
12427 Elf_Internal_Shdr
* string_sec
;
12431 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
12434 link_section
= filedata
->section_headers
+ section
->sh_link
;
12435 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
12437 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
12442 symbols
= get_elf_symbols (filedata
, link_section
, & num_syms
);
12443 if (symbols
== NULL
)
12446 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
12448 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
12449 string_sec
->sh_size
,
12450 _("version string table"));
12457 if (filedata
->is_separate
)
12458 printf (ngettext ("\nIn linked file '%s' the version symbols section '%s' contains %" PRIu64
" entry:\n",
12459 "\nIn linked file '%s' the version symbols section '%s' contains %" PRIu64
" entries:\n",
12461 filedata
->file_name
,
12462 printable_section_name (filedata
, section
),
12465 printf (ngettext ("\nVersion symbols section '%s' "
12466 "contains %" PRIu64
" entry:\n",
12467 "\nVersion symbols section '%s' "
12468 "contains %" PRIu64
" entries:\n",
12470 printable_section_name (filedata
, section
),
12473 printf (_(" Addr: 0x%016" PRIx64
), section
->sh_addr
);
12474 printf (_(" Offset: 0x%08" PRIx64
" Link: %u (%s)\n"),
12475 section
->sh_offset
, section
->sh_link
,
12476 printable_section_name (filedata
, link_section
));
12478 off
= offset_from_vma (filedata
,
12479 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
12480 total
* sizeof (short));
12481 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
12482 sizeof (short), total
,
12483 _("version symbol data"));
12491 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
12493 for (cnt
= total
; cnt
--;)
12494 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
12499 for (cnt
= 0; cnt
< total
; cnt
+= 4)
12503 char *invalid
= _("*invalid*");
12505 printf (" %03x:", cnt
);
12507 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
12508 switch (data
[cnt
+ j
])
12511 fputs (_(" 0 (*local*) "), stdout
);
12515 fputs (_(" 1 (*global*) "), stdout
);
12519 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
12520 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
12522 /* If this index value is greater than the size of the symbols
12523 array, break to avoid an out-of-bounds read. */
12524 if (cnt
+ j
>= num_syms
)
12526 warn (_("invalid index into symbol array\n"));
12531 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
12533 Elf_Internal_Verneed ivn
;
12536 offset
= offset_from_vma
12538 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
12539 sizeof (Elf_External_Verneed
));
12543 Elf_Internal_Vernaux ivna
;
12544 Elf_External_Verneed evn
;
12545 Elf_External_Vernaux evna
;
12548 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
12549 _("version need")) == NULL
)
12552 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
12553 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
12555 a_off
= offset
+ ivn
.vn_aux
;
12559 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
12560 1, _("version need aux (2)")) == NULL
)
12563 ivna
.vna_other
= 0;
12567 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
12568 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
12571 a_off
+= ivna
.vna_next
;
12573 while (ivna
.vna_other
!= data
[cnt
+ j
]
12574 && ivna
.vna_next
!= 0);
12576 if (ivna
.vna_other
== data
[cnt
+ j
])
12578 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
12580 if (ivna
.vna_name
>= string_sec
->sh_size
)
12583 name
= strtab
+ ivna
.vna_name
;
12587 offset
+= ivn
.vn_next
;
12589 while (ivn
.vn_next
);
12592 if (data
[cnt
+ j
] != 0x8001
12593 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
12595 Elf_Internal_Verdef ivd
;
12596 Elf_External_Verdef evd
;
12599 offset
= offset_from_vma
12601 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
12606 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
12607 _("version def")) == NULL
)
12610 /* PR 17531: file: 046-1082287-0.004. */
12611 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
12616 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
12617 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
12620 offset
+= ivd
.vd_next
;
12622 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
12623 && ivd
.vd_next
!= 0);
12625 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
12627 Elf_External_Verdaux evda
;
12628 Elf_Internal_Verdaux ivda
;
12630 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
12632 if (get_data (&evda
, filedata
,
12633 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
12635 _("version def aux")) == NULL
)
12638 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
12640 if (ivda
.vda_name
>= string_sec
->sh_size
)
12642 else if (name
!= NULL
&& name
!= invalid
)
12643 name
= _("*both*");
12645 name
= strtab
+ ivda
.vda_name
;
12649 nn
+= printf ("(%s%-*s",
12651 12 - (int) strlen (name
),
12655 printf ("%*c", 18 - nn
, ' ');
12674 if (filedata
->is_separate
)
12675 printf (_("\nNo version information found in linked file '%s'.\n"),
12676 filedata
->file_name
);
12678 printf (_("\nNo version information found in this file.\n"));
12684 static const char *
12685 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
12687 static char buff
[64];
12691 case STB_LOCAL
: return "LOCAL";
12692 case STB_GLOBAL
: return "GLOBAL";
12693 case STB_WEAK
: return "WEAK";
12695 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
12696 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
12698 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
12700 if (binding
== STB_GNU_UNIQUE
12701 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
12703 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
12706 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
12711 static const char *
12712 get_symbol_type (Filedata
* filedata
, unsigned int type
)
12714 static char buff
[64];
12718 case STT_NOTYPE
: return "NOTYPE";
12719 case STT_OBJECT
: return "OBJECT";
12720 case STT_FUNC
: return "FUNC";
12721 case STT_SECTION
: return "SECTION";
12722 case STT_FILE
: return "FILE";
12723 case STT_COMMON
: return "COMMON";
12724 case STT_TLS
: return "TLS";
12725 case STT_RELC
: return "RELC";
12726 case STT_SRELC
: return "SRELC";
12728 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
12730 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
12731 return "THUMB_FUNC";
12733 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
12736 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
12737 return "PARISC_MILLI";
12739 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
12741 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
12743 if (filedata
->file_header
.e_machine
== EM_PARISC
)
12745 if (type
== STT_HP_OPAQUE
)
12746 return "HP_OPAQUE";
12747 if (type
== STT_HP_STUB
)
12751 if (type
== STT_GNU_IFUNC
12752 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
12753 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
12756 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
12759 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
12764 static const char *
12765 get_symbol_visibility (unsigned int visibility
)
12767 switch (visibility
)
12769 case STV_DEFAULT
: return "DEFAULT";
12770 case STV_INTERNAL
: return "INTERNAL";
12771 case STV_HIDDEN
: return "HIDDEN";
12772 case STV_PROTECTED
: return "PROTECTED";
12774 error (_("Unrecognized visibility value: %u\n"), visibility
);
12775 return _("<unknown>");
12779 static const char *
12780 get_alpha_symbol_other (unsigned int other
)
12784 case STO_ALPHA_NOPV
: return "NOPV";
12785 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
12787 error (_("Unrecognized alpha specific other value: %u\n"), other
);
12788 return _("<unknown>");
12792 static const char *
12793 get_solaris_symbol_visibility (unsigned int visibility
)
12795 switch (visibility
)
12797 case 4: return "EXPORTED";
12798 case 5: return "SINGLETON";
12799 case 6: return "ELIMINATE";
12800 default: return get_symbol_visibility (visibility
);
12804 static const char *
12805 get_aarch64_symbol_other (unsigned int other
)
12807 static char buf
[32];
12809 if (other
& STO_AARCH64_VARIANT_PCS
)
12811 other
&= ~STO_AARCH64_VARIANT_PCS
;
12813 return "VARIANT_PCS";
12814 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
12820 static const char *
12821 get_mips_symbol_other (unsigned int other
)
12825 case STO_OPTIONAL
: return "OPTIONAL";
12826 case STO_MIPS_PLT
: return "MIPS PLT";
12827 case STO_MIPS_PIC
: return "MIPS PIC";
12828 case STO_MICROMIPS
: return "MICROMIPS";
12829 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
12830 case STO_MIPS16
: return "MIPS16";
12831 default: return NULL
;
12835 static const char *
12836 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
12838 if (is_ia64_vms (filedata
))
12840 static char res
[32];
12844 /* Function types is for images and .STB files only. */
12845 switch (filedata
->file_header
.e_type
)
12849 switch (VMS_ST_FUNC_TYPE (other
))
12851 case VMS_SFT_CODE_ADDR
:
12852 strcat (res
, " CA");
12854 case VMS_SFT_SYMV_IDX
:
12855 strcat (res
, " VEC");
12858 strcat (res
, " FD");
12860 case VMS_SFT_RESERVE
:
12861 strcat (res
, " RSV");
12864 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
12865 VMS_ST_FUNC_TYPE (other
));
12866 strcat (res
, " <unknown>");
12873 switch (VMS_ST_LINKAGE (other
))
12875 case VMS_STL_IGNORE
:
12876 strcat (res
, " IGN");
12878 case VMS_STL_RESERVE
:
12879 strcat (res
, " RSV");
12882 strcat (res
, " STD");
12885 strcat (res
, " LNK");
12888 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
12889 VMS_ST_LINKAGE (other
));
12890 strcat (res
, " <unknown>");
12902 static const char *
12903 get_ppc64_symbol_other (unsigned int other
)
12905 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
12908 other
>>= STO_PPC64_LOCAL_BIT
;
12911 static char buf
[64];
12913 other
= ppc64_decode_local_entry (other
);
12914 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
12920 static const char *
12921 get_riscv_symbol_other (unsigned int other
)
12923 static char buf
[32];
12926 if (other
& STO_RISCV_VARIANT_CC
)
12928 strcat (buf
, _(" VARIANT_CC"));
12929 other
&= ~STO_RISCV_VARIANT_CC
;
12933 snprintf (buf
, sizeof buf
, " %x", other
);
12942 static const char *
12943 get_symbol_other (Filedata
* filedata
, unsigned int other
)
12945 const char * result
= NULL
;
12946 static char buff
[64];
12951 switch (filedata
->file_header
.e_machine
)
12954 result
= get_alpha_symbol_other (other
);
12957 result
= get_aarch64_symbol_other (other
);
12960 result
= get_mips_symbol_other (other
);
12963 result
= get_ia64_symbol_other (filedata
, other
);
12966 result
= get_ppc64_symbol_other (other
);
12969 result
= get_riscv_symbol_other (other
);
12979 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
12983 static const char *
12984 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
12986 static char buff
[32];
12990 case SHN_UNDEF
: return "UND";
12991 case SHN_ABS
: return "ABS";
12992 case SHN_COMMON
: return "COM";
12994 if (type
== SHN_IA_64_ANSI_COMMON
12995 && filedata
->file_header
.e_machine
== EM_IA_64
12996 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
12998 else if ((filedata
->file_header
.e_machine
== EM_X86_64
12999 || filedata
->file_header
.e_machine
== EM_L1OM
13000 || filedata
->file_header
.e_machine
== EM_K1OM
)
13001 && type
== SHN_X86_64_LCOMMON
)
13002 return "LARGE_COM";
13003 else if ((type
== SHN_MIPS_SCOMMON
13004 && filedata
->file_header
.e_machine
== EM_MIPS
)
13005 || (type
== SHN_TIC6X_SCOMMON
13006 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
13008 else if (type
== SHN_MIPS_SUNDEFINED
13009 && filedata
->file_header
.e_machine
== EM_MIPS
)
13011 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
13012 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
13013 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
13014 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
13015 else if (type
>= SHN_LORESERVE
)
13016 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
13017 else if (filedata
->file_header
.e_shnum
!= 0
13018 && type
>= filedata
->file_header
.e_shnum
)
13019 sprintf (buff
, _("bad section index[%3d]"), type
);
13021 sprintf (buff
, "%3d", type
);
13028 static const char *
13029 get_symbol_version_string (Filedata
*filedata
,
13031 const char *strtab
,
13032 size_t strtab_size
,
13034 Elf_Internal_Sym
*psym
,
13035 enum versioned_symbol_info
*sym_info
,
13036 unsigned short *vna_other
)
13038 unsigned char data
[2];
13039 unsigned short vers_data
;
13041 unsigned short max_vd_ndx
;
13044 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
13047 offset
= offset_from_vma (filedata
,
13048 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
13049 sizeof data
+ si
* sizeof (vers_data
));
13051 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
13052 sizeof (data
), 1, _("version data")) == NULL
)
13055 vers_data
= byte_get (data
, 2);
13057 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
13060 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
13063 /* Usually we'd only see verdef for defined symbols, and verneed for
13064 undefined symbols. However, symbols defined by the linker in
13065 .dynbss for variables copied from a shared library in order to
13066 avoid text relocations are defined yet have verneed. We could
13067 use a heuristic to detect the special case, for example, check
13068 for verneed first on symbols defined in SHT_NOBITS sections, but
13069 it is simpler and more reliable to just look for both verdef and
13070 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
13072 if (psym
->st_shndx
!= SHN_UNDEF
13073 && vers_data
!= 0x8001
13074 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
13076 Elf_Internal_Verdef ivd
;
13077 Elf_Internal_Verdaux ivda
;
13078 Elf_External_Verdaux evda
;
13081 off
= offset_from_vma (filedata
,
13082 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
13083 sizeof (Elf_External_Verdef
));
13087 Elf_External_Verdef evd
;
13089 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
13090 _("version def")) == NULL
)
13099 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
13100 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
13101 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
13102 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
13105 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
13106 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
13108 off
+= ivd
.vd_next
;
13110 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
13112 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
13114 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
13117 off
-= ivd
.vd_next
;
13120 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
13121 _("version def aux")) != NULL
)
13123 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
13125 if (psym
->st_name
!= ivda
.vda_name
)
13126 return (ivda
.vda_name
< strtab_size
13127 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
13132 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
13134 Elf_External_Verneed evn
;
13135 Elf_Internal_Verneed ivn
;
13136 Elf_Internal_Vernaux ivna
;
13138 offset
= offset_from_vma (filedata
,
13139 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
13145 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
13146 _("version need")) == NULL
)
13149 ivna
.vna_other
= 0;
13154 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
13155 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
13157 vna_off
= offset
+ ivn
.vn_aux
;
13161 Elf_External_Vernaux evna
;
13163 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
13164 _("version need aux (3)")) == NULL
)
13167 ivna
.vna_other
= 0;
13172 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
13173 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
13174 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
13177 vna_off
+= ivna
.vna_next
;
13179 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
13181 if (ivna
.vna_other
== vers_data
)
13184 offset
+= ivn
.vn_next
;
13186 while (ivn
.vn_next
!= 0);
13188 if (ivna
.vna_other
== vers_data
)
13190 *sym_info
= symbol_undefined
;
13191 *vna_other
= ivna
.vna_other
;
13192 return (ivna
.vna_name
< strtab_size
13193 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
13195 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
13196 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
13197 return _("<corrupt>");
13202 /* Display a symbol size on stdout. Format is based on --sym-base setting. */
13204 static unsigned int
13205 print_dynamic_symbol_size (uint64_t vma
, int base
)
13210 return print_vma (vma
, OCTAL_5
);
13213 return print_vma (vma
, UNSIGNED_5
);
13216 return print_vma (vma
, PREFIX_HEX_5
);
13220 return print_vma (vma
, DEC_5
);
13225 print_dynamic_symbol (Filedata
*filedata
, uint64_t si
,
13226 Elf_Internal_Sym
*symtab
,
13227 Elf_Internal_Shdr
*section
,
13228 char *strtab
, size_t strtab_size
)
13230 const char *version_string
;
13231 enum versioned_symbol_info sym_info
;
13232 unsigned short vna_other
;
13235 Elf_Internal_Sym
*psym
= symtab
+ si
;
13237 printf ("%6" PRId64
": ", si
);
13238 print_vma (psym
->st_value
, LONG_HEX
);
13240 print_dynamic_symbol_size (psym
->st_size
, sym_base
);
13241 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
13242 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
13243 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
13244 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
13247 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
13249 printf (" %-7s", get_symbol_visibility (vis
));
13250 /* Check to see if any other bits in the st_other field are set.
13251 Note - displaying this information disrupts the layout of the
13252 table being generated, but for the moment this case is very rare. */
13253 if (psym
->st_other
^ vis
)
13254 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
13256 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
13258 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
13259 && psym
->st_shndx
< filedata
->file_header
.e_shnum
13260 && filedata
->section_headers
!= NULL
13261 && psym
->st_name
== 0)
13264 = section_name_valid (filedata
,
13265 filedata
->section_headers
+ psym
->st_shndx
);
13267 section_name_print (filedata
,
13268 filedata
->section_headers
+ psym
->st_shndx
)
13273 is_valid
= valid_symbol_name (strtab
, strtab_size
, psym
->st_name
);
13274 sstr
= is_valid
? strtab
+ psym
->st_name
: _("<corrupt>");
13278 = get_symbol_version_string (filedata
,
13280 || section
->sh_type
== SHT_DYNSYM
),
13281 strtab
, strtab_size
, si
,
13282 psym
, &sym_info
, &vna_other
);
13284 int len_avail
= 21;
13285 if (! do_wide
&& version_string
!= NULL
)
13289 len_avail
-= 1 + strlen (version_string
);
13291 if (sym_info
== symbol_undefined
)
13292 len_avail
-= sprintf (buffer
," (%d)", vna_other
);
13293 else if (sym_info
!= symbol_hidden
)
13297 print_symbol (len_avail
, sstr
);
13299 if (version_string
)
13301 if (sym_info
== symbol_undefined
)
13302 printf ("@%s (%d)", version_string
, vna_other
);
13304 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
13310 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
13312 && si
>= section
->sh_info
13313 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
13314 && filedata
->file_header
.e_machine
!= EM_MIPS
13315 /* Solaris binaries have been found to violate this requirement as
13316 well. Not sure if this is a bug or an ABI requirement. */
13317 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
13318 warn (_("local symbol %" PRIu64
" found at index >= %s's sh_info value of %u\n"),
13319 si
, printable_section_name (filedata
, section
), section
->sh_info
);
13322 static const char *
13323 get_lto_kind (unsigned int kind
)
13327 case 0: return "DEF";
13328 case 1: return "WEAKDEF";
13329 case 2: return "UNDEF";
13330 case 3: return "WEAKUNDEF";
13331 case 4: return "COMMON";
13336 static char buffer
[30];
13337 error (_("Unknown LTO symbol definition encountered: %u\n"), kind
);
13338 sprintf (buffer
, "<unknown: %u>", kind
);
13342 static const char *
13343 get_lto_visibility (unsigned int visibility
)
13345 switch (visibility
)
13347 case 0: return "DEFAULT";
13348 case 1: return "PROTECTED";
13349 case 2: return "INTERNAL";
13350 case 3: return "HIDDEN";
13355 static char buffer
[30];
13356 error (_("Unknown LTO symbol visibility encountered: %u\n"), visibility
);
13357 sprintf (buffer
, "<unknown: %u>", visibility
);
13361 static const char *
13362 get_lto_sym_type (unsigned int sym_type
)
13366 case 0: return "UNKNOWN";
13367 case 1: return "FUNCTION";
13368 case 2: return "VARIABLE";
13373 static char buffer
[30];
13374 error (_("Unknown LTO symbol type encountered: %u\n"), sym_type
);
13375 sprintf (buffer
, "<unknown: %u>", sym_type
);
13379 /* Display an LTO format symbol table.
13380 FIXME: The format of LTO symbol tables is not formalized.
13381 So this code could need changing in the future. */
13384 display_lto_symtab (Filedata
* filedata
,
13385 Elf_Internal_Shdr
* section
)
13387 if (section
->sh_size
== 0)
13389 if (filedata
->is_separate
)
13390 printf (_("\nThe LTO Symbol table section '%s' in linked file '%s' is empty!\n"),
13391 printable_section_name (filedata
, section
),
13392 filedata
->file_name
);
13394 printf (_("\nLTO Symbol table '%s' is empty!\n"),
13395 printable_section_name (filedata
, section
));
13400 if (section
->sh_size
> filedata
->file_size
)
13402 error (_("Section %s has an invalid sh_size of %#" PRIx64
"\n"),
13403 printable_section_name (filedata
, section
),
13408 void * alloced_data
= get_data (NULL
, filedata
, section
->sh_offset
,
13409 section
->sh_size
, 1, _("LTO symbols"));
13410 if (alloced_data
== NULL
)
13413 /* Look for extended data for the symbol table. */
13414 Elf_Internal_Shdr
* ext
;
13415 void * ext_data_orig
= NULL
;
13416 char * ext_data
= NULL
;
13417 char * ext_data_end
= NULL
;
13418 char * ext_name
= NULL
;
13420 if (asprintf (& ext_name
, ".gnu.lto_.ext_symtab.%s",
13421 (section_name (filedata
, section
)
13422 + sizeof (".gnu.lto_.symtab.") - 1)) > 0
13423 && ext_name
!= NULL
/* Paranoia. */
13424 && (ext
= find_section (filedata
, ext_name
)) != NULL
)
13426 if (ext
->sh_size
< 3)
13427 error (_("LTO Symbol extension table '%s' is empty!\n"),
13428 printable_section_name (filedata
, ext
));
13431 ext_data_orig
= ext_data
= get_data (NULL
, filedata
, ext
->sh_offset
,
13433 _("LTO ext symbol data"));
13434 if (ext_data
!= NULL
)
13436 ext_data_end
= ext_data
+ ext
->sh_size
;
13437 if (* ext_data
++ != 1)
13438 error (_("Unexpected version number in symbol extension table\n"));
13443 const unsigned char * data
= (const unsigned char *) alloced_data
;
13444 const unsigned char * end
= data
+ section
->sh_size
;
13446 if (filedata
->is_separate
)
13447 printf (_("\nIn linked file '%s': "), filedata
->file_name
);
13451 if (ext_data_orig
!= NULL
)
13454 printf (_("LTO Symbol table '%s' and extension table '%s' contain:\n"),
13455 printable_section_name (filedata
, section
),
13456 printable_section_name (filedata
, ext
));
13459 printf (_("LTO Symbol table '%s'\n"),
13460 printable_section_name (filedata
, section
));
13461 printf (_(" and extension table '%s' contain:\n"),
13462 printable_section_name (filedata
, ext
));
13466 printf (_("LTO Symbol table '%s' contains:\n"),
13467 printable_section_name (filedata
, section
));
13469 /* FIXME: Add a wide version. */
13470 if (ext_data_orig
!= NULL
)
13471 printf (_(" Comdat_Key Kind Visibility Size Slot Type Section Name\n"));
13473 printf (_(" Comdat_Key Kind Visibility Size Slot Name\n"));
13475 /* FIXME: We do not handle style prefixes. */
13479 const unsigned char * sym_name
= data
;
13480 data
+= strnlen ((const char *) sym_name
, end
- data
) + 1;
13484 const unsigned char * comdat_key
= data
;
13485 data
+= strnlen ((const char *) comdat_key
, end
- data
) + 1;
13489 if (data
+ 2 + 8 + 4 > end
)
13492 unsigned int kind
= *data
++;
13493 unsigned int visibility
= *data
++;
13495 uint64_t size
= byte_get (data
, 8);
13498 uint64_t slot
= byte_get (data
, 4);
13501 if (ext_data
!= NULL
)
13503 if (ext_data
< (ext_data_end
- 1))
13505 unsigned int sym_type
= * ext_data
++;
13506 unsigned int sec_kind
= * ext_data
++;
13508 printf (" %10s %10s %11s %08" PRIx64
" %08" PRIx64
" %9s %08x _",
13509 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
13510 get_lto_kind (kind
),
13511 get_lto_visibility (visibility
),
13514 get_lto_sym_type (sym_type
),
13516 print_symbol (6, (const char *) sym_name
);
13520 error (_("Ran out of LTO symbol extension data\n"));
13522 /* FIXME: return FAIL result ? */
13527 printf (" %10s %10s %11s %08" PRIx64
" %08" PRIx64
" _",
13528 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
13529 get_lto_kind (kind
),
13530 get_lto_visibility (visibility
),
13533 print_symbol (21, (const char *) sym_name
);
13538 if (ext_data
!= NULL
&& ext_data
< ext_data_end
)
13540 error (_("Data remains in the LTO symbol extension table\n"));
13544 free (alloced_data
);
13545 free (ext_data_orig
);
13550 error (_("Buffer overrun encountered whilst decoding LTO symbol table\n"));
13551 free (alloced_data
);
13552 free (ext_data_orig
);
13557 /* Display LTO symbol tables. */
13560 process_lto_symbol_tables (Filedata
* filedata
)
13562 Elf_Internal_Shdr
* section
;
13569 if (filedata
->section_headers
== NULL
)
13572 for (i
= 0, section
= filedata
->section_headers
;
13573 i
< filedata
->file_header
.e_shnum
;
13575 if (section_name_valid (filedata
, section
)
13576 && startswith (section_name (filedata
, section
), ".gnu.lto_.symtab."))
13577 res
&= display_lto_symtab (filedata
, section
);
13582 /* Dump the symbol table. */
13585 process_symbol_table (Filedata
* filedata
)
13587 Elf_Internal_Shdr
* section
;
13589 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
13592 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
13594 && do_using_dynamic
13595 && filedata
->dynamic_strings
!= NULL
13596 && filedata
->dynamic_symbols
!= NULL
)
13600 if (filedata
->is_separate
)
13602 printf (ngettext ("\nIn linked file '%s' the dynamic symbol table"
13603 " contains %" PRIu64
" entry:\n",
13604 "\nIn linked file '%s' the dynamic symbol table"
13605 " contains %" PRIu64
" entries:\n",
13606 filedata
->num_dynamic_syms
),
13607 filedata
->file_name
,
13608 filedata
->num_dynamic_syms
);
13612 printf (ngettext ("\nSymbol table for image contains %" PRIu64
13614 "\nSymbol table for image contains %" PRIu64
13616 filedata
->num_dynamic_syms
),
13617 filedata
->num_dynamic_syms
);
13620 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
13622 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
13624 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
13625 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
13626 filedata
->dynamic_strings
,
13627 filedata
->dynamic_strings_length
);
13629 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
13630 && filedata
->section_headers
!= NULL
)
13634 for (i
= 0, section
= filedata
->section_headers
;
13635 i
< filedata
->file_header
.e_shnum
;
13638 char * strtab
= NULL
;
13639 uint64_t strtab_size
= 0;
13640 Elf_Internal_Sym
* symtab
;
13641 uint64_t si
, num_syms
;
13643 if ((section
->sh_type
!= SHT_SYMTAB
13644 && section
->sh_type
!= SHT_DYNSYM
)
13646 && section
->sh_type
== SHT_SYMTAB
))
13649 if (section
->sh_entsize
== 0)
13651 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
13652 printable_section_name (filedata
, section
));
13656 num_syms
= section
->sh_size
/ section
->sh_entsize
;
13658 if (filedata
->is_separate
)
13659 printf (ngettext ("\nIn linked file '%s' symbol section '%s'"
13660 " contains %" PRIu64
" entry:\n",
13661 "\nIn linked file '%s' symbol section '%s'"
13662 " contains %" PRIu64
" entries:\n",
13664 filedata
->file_name
,
13665 printable_section_name (filedata
, section
),
13668 printf (ngettext ("\nSymbol table '%s' contains %" PRIu64
13670 "\nSymbol table '%s' contains %" PRIu64
13673 printable_section_name (filedata
, section
),
13677 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
13679 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
13681 symtab
= get_elf_symbols (filedata
, section
, & num_syms
);
13682 if (symtab
== NULL
)
13685 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
13687 strtab
= filedata
->string_table
;
13688 strtab_size
= filedata
->string_table_length
;
13690 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
13692 Elf_Internal_Shdr
* string_sec
;
13694 string_sec
= filedata
->section_headers
+ section
->sh_link
;
13696 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
13697 1, string_sec
->sh_size
,
13698 _("string table"));
13699 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
13702 for (si
= 0; si
< num_syms
; si
++)
13703 print_dynamic_symbol (filedata
, si
, symtab
, section
,
13704 strtab
, strtab_size
);
13707 if (strtab
!= filedata
->string_table
)
13713 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
13715 if (do_histogram
&& filedata
->buckets
!= NULL
)
13721 uint64_t maxlength
= 0;
13722 uint64_t nzero_counts
= 0;
13723 uint64_t nsyms
= 0;
13726 printf (ngettext ("\nHistogram for bucket list length "
13727 "(total of %" PRIu64
" bucket):\n",
13728 "\nHistogram for bucket list length "
13729 "(total of %" PRIu64
" buckets):\n",
13730 filedata
->nbuckets
),
13731 filedata
->nbuckets
);
13733 lengths
= calloc (filedata
->nbuckets
, sizeof (*lengths
));
13734 if (lengths
== NULL
)
13736 error (_("Out of memory allocating space for histogram buckets\n"));
13739 visited
= xcmalloc (filedata
->nchains
, 1);
13740 memset (visited
, 0, filedata
->nchains
);
13742 printf (_(" Length Number %% of total Coverage\n"));
13743 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
13745 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
13748 if (maxlength
< ++lengths
[hn
])
13750 if (si
>= filedata
->nchains
|| visited
[si
])
13752 error (_("histogram chain is corrupt\n"));
13760 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
13761 if (counts
== NULL
)
13764 error (_("Out of memory allocating space for histogram counts\n"));
13768 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
13769 ++counts
[lengths
[hn
]];
13771 if (filedata
->nbuckets
> 0)
13774 printf (" 0 %-10" PRIu64
" (%5.1f%%)\n",
13775 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
13776 for (i
= 1; i
<= maxlength
; ++i
)
13778 nzero_counts
+= counts
[i
] * i
;
13779 printf ("%7" PRIu64
" %-10" PRIu64
" (%5.1f%%) %5.1f%%\n",
13780 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
13781 (nzero_counts
* 100.0) / nsyms
);
13789 free (filedata
->buckets
);
13790 filedata
->buckets
= NULL
;
13791 filedata
->nbuckets
= 0;
13792 free (filedata
->chains
);
13793 filedata
->chains
= NULL
;
13795 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
13800 uint64_t maxlength
= 0;
13801 uint64_t nzero_counts
= 0;
13802 uint64_t nsyms
= 0;
13804 printf (ngettext ("\nHistogram for `%s' bucket list length "
13805 "(total of %" PRIu64
" bucket):\n",
13806 "\nHistogram for `%s' bucket list length "
13807 "(total of %" PRIu64
" buckets):\n",
13808 filedata
->ngnubuckets
),
13809 GNU_HASH_SECTION_NAME (filedata
),
13810 filedata
->ngnubuckets
);
13812 lengths
= calloc (filedata
->ngnubuckets
, sizeof (*lengths
));
13813 if (lengths
== NULL
)
13815 error (_("Out of memory allocating space for gnu histogram buckets\n"));
13819 printf (_(" Length Number %% of total Coverage\n"));
13821 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
13822 if (filedata
->gnubuckets
[hn
] != 0)
13824 uint64_t off
, length
= 1;
13826 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
13827 /* PR 17531 file: 010-77222-0.004. */
13828 off
< filedata
->ngnuchains
13829 && (filedata
->gnuchains
[off
] & 1) == 0;
13832 lengths
[hn
] = length
;
13833 if (length
> maxlength
)
13834 maxlength
= length
;
13838 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
13839 if (counts
== NULL
)
13842 error (_("Out of memory allocating space for gnu histogram counts\n"));
13846 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
13847 ++counts
[lengths
[hn
]];
13849 if (filedata
->ngnubuckets
> 0)
13852 printf (" 0 %-10" PRIu64
" (%5.1f%%)\n",
13853 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
13854 for (j
= 1; j
<= maxlength
; ++j
)
13856 nzero_counts
+= counts
[j
] * j
;
13857 printf ("%7" PRIu64
" %-10" PRIu64
" (%5.1f%%) %5.1f%%\n",
13858 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
13859 (nzero_counts
* 100.0) / nsyms
);
13866 free (filedata
->gnubuckets
);
13867 filedata
->gnubuckets
= NULL
;
13868 filedata
->ngnubuckets
= 0;
13869 free (filedata
->gnuchains
);
13870 filedata
->gnuchains
= NULL
;
13871 filedata
->ngnuchains
= 0;
13872 free (filedata
->mipsxlat
);
13873 filedata
->mipsxlat
= NULL
;
13877 free (filedata
->gnubuckets
);
13878 filedata
->gnubuckets
= NULL
;
13879 filedata
->ngnubuckets
= 0;
13880 free (filedata
->gnuchains
);
13881 filedata
->gnuchains
= NULL
;
13882 filedata
->ngnuchains
= 0;
13883 free (filedata
->mipsxlat
);
13884 filedata
->mipsxlat
= NULL
;
13885 free (filedata
->buckets
);
13886 filedata
->buckets
= NULL
;
13887 filedata
->nbuckets
= 0;
13888 free (filedata
->chains
);
13889 filedata
->chains
= NULL
;
13894 process_syminfo (Filedata
* filedata
)
13898 if (filedata
->dynamic_syminfo
== NULL
13900 /* No syminfo, this is ok. */
13903 /* There better should be a dynamic symbol section. */
13904 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
13907 if (filedata
->is_separate
)
13908 printf (ngettext ("\nIn linked file '%s: the dynamic info segment at offset %#" PRIx64
" contains %d entry:\n",
13909 "\nIn linked file '%s: the dynamic info segment at offset %#" PRIx64
" contains %d entries:\n",
13910 filedata
->dynamic_syminfo_nent
),
13911 filedata
->file_name
,
13912 filedata
->dynamic_syminfo_offset
,
13913 filedata
->dynamic_syminfo_nent
);
13915 printf (ngettext ("\nDynamic info segment at offset %#" PRIx64
13916 " contains %d entry:\n",
13917 "\nDynamic info segment at offset %#" PRIx64
13918 " contains %d entries:\n",
13919 filedata
->dynamic_syminfo_nent
),
13920 filedata
->dynamic_syminfo_offset
,
13921 filedata
->dynamic_syminfo_nent
);
13923 printf (_(" Num: Name BoundTo Flags\n"));
13924 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
13926 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
13928 printf ("%4d: ", i
);
13929 if (i
>= filedata
->num_dynamic_syms
)
13930 printf (_("<corrupt index>"));
13931 else if (valid_dynamic_name (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
13932 print_symbol (30, get_dynamic_name (filedata
,
13933 filedata
->dynamic_symbols
[i
].st_name
));
13935 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
13938 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
13940 case SYMINFO_BT_SELF
:
13941 fputs ("SELF ", stdout
);
13943 case SYMINFO_BT_PARENT
:
13944 fputs ("PARENT ", stdout
);
13947 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
13948 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
13949 && valid_dynamic_name (filedata
,
13950 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
13952 print_symbol (10, get_dynamic_name (filedata
,
13953 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
13957 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
13961 if (flags
& SYMINFO_FLG_DIRECT
)
13962 printf (" DIRECT");
13963 if (flags
& SYMINFO_FLG_PASSTHRU
)
13964 printf (" PASSTHRU");
13965 if (flags
& SYMINFO_FLG_COPY
)
13967 if (flags
& SYMINFO_FLG_LAZYLOAD
)
13968 printf (" LAZYLOAD");
13976 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
13977 is contained by the region START .. END. The types of ADDR, START
13978 and END should all be the same. Note both ADDR + NELEM and END
13979 point to just beyond the end of the regions that are being tested. */
13980 #define IN_RANGE(START,END,ADDR,NELEM) \
13981 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
13983 /* Check to see if the given reloc needs to be handled in a target specific
13984 manner. If so then process the reloc and return TRUE otherwise return
13987 If called with reloc == NULL, then this is a signal that reloc processing
13988 for the current section has finished, and any saved state should be
13992 target_specific_reloc_handling (Filedata
*filedata
,
13993 Elf_Internal_Rela
*reloc
,
13994 unsigned char *start
,
13995 unsigned char *end
,
13996 Elf_Internal_Sym
*symtab
,
13999 unsigned int reloc_type
= 0;
14000 uint64_t sym_index
= 0;
14004 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
14005 sym_index
= get_reloc_symindex (reloc
->r_info
);
14008 switch (filedata
->file_header
.e_machine
)
14011 case EM_MSP430_OLD
:
14013 static Elf_Internal_Sym
* saved_sym
= NULL
;
14021 switch (reloc_type
)
14023 case 10: /* R_MSP430_SYM_DIFF */
14024 case 12: /* R_MSP430_GNU_SUB_ULEB128 */
14025 if (uses_msp430x_relocs (filedata
))
14027 /* Fall through. */
14028 case 21: /* R_MSP430X_SYM_DIFF */
14029 case 23: /* R_MSP430X_GNU_SUB_ULEB128 */
14031 if (sym_index
>= num_syms
)
14032 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index"
14033 " %" PRIu64
"\n"), sym_index
);
14035 saved_sym
= symtab
+ sym_index
;
14038 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
14039 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
14040 goto handle_sym_diff
;
14042 case 5: /* R_MSP430_16_BYTE */
14043 case 9: /* R_MSP430_8 */
14044 case 11: /* R_MSP430_GNU_SET_ULEB128 */
14045 if (uses_msp430x_relocs (filedata
))
14047 goto handle_sym_diff
;
14049 case 2: /* R_MSP430_ABS16 */
14050 case 15: /* R_MSP430X_ABS16 */
14051 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
14052 if (! uses_msp430x_relocs (filedata
))
14054 goto handle_sym_diff
;
14057 if (saved_sym
!= NULL
)
14060 unsigned int reloc_size
= 0;
14062 switch (reloc_type
)
14064 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
14067 case 11: /* R_MSP430_GNU_SET_ULEB128 */
14068 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
14069 if (reloc
->r_offset
< (size_t) (end
- start
))
14070 read_leb128 (start
+ reloc
->r_offset
, end
, false,
14071 &reloc_size
, &leb_ret
);
14078 if (leb_ret
!= 0 || reloc_size
== 0 || reloc_size
> 8)
14079 error (_("MSP430 ULEB128 field at %#" PRIx64
14080 " contains invalid ULEB128 value\n"),
14082 else if (sym_index
>= num_syms
)
14083 error (_("MSP430 reloc contains invalid symbol index "
14088 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
14089 - saved_sym
->st_value
);
14091 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
14092 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
14095 error (_("MSP430 sym diff reloc contains invalid offset: "
14106 if (saved_sym
!= NULL
)
14107 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
14114 case EM_CYGNUS_MN10300
:
14116 static Elf_Internal_Sym
* saved_sym
= NULL
;
14124 switch (reloc_type
)
14126 case 34: /* R_MN10300_ALIGN */
14128 case 33: /* R_MN10300_SYM_DIFF */
14129 if (sym_index
>= num_syms
)
14130 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index "
14134 saved_sym
= symtab
+ sym_index
;
14137 case 1: /* R_MN10300_32 */
14138 case 2: /* R_MN10300_16 */
14139 if (saved_sym
!= NULL
)
14141 int reloc_size
= reloc_type
== 1 ? 4 : 2;
14144 if (sym_index
>= num_syms
)
14145 error (_("MN10300 reloc contains invalid symbol index "
14150 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
14151 - saved_sym
->st_value
);
14153 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
14154 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
14156 error (_("MN10300 sym diff reloc contains invalid offset:"
14157 " %#" PRIx64
"\n"),
14166 if (saved_sym
!= NULL
)
14167 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
14175 static uint64_t saved_sym1
= 0;
14176 static uint64_t saved_sym2
= 0;
14177 static uint64_t value
;
14181 saved_sym1
= saved_sym2
= 0;
14185 switch (reloc_type
)
14187 case 0x80: /* R_RL78_SYM. */
14188 saved_sym1
= saved_sym2
;
14189 if (sym_index
>= num_syms
)
14190 error (_("RL78_SYM reloc contains invalid symbol index "
14191 "%" PRIu64
"\n"), sym_index
);
14194 saved_sym2
= symtab
[sym_index
].st_value
;
14195 saved_sym2
+= reloc
->r_addend
;
14199 case 0x83: /* R_RL78_OPsub. */
14200 value
= saved_sym1
- saved_sym2
;
14201 saved_sym2
= saved_sym1
= 0;
14205 case 0x41: /* R_RL78_ABS32. */
14206 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
14207 byte_put (start
+ reloc
->r_offset
, value
, 4);
14209 error (_("RL78 sym diff reloc contains invalid offset: "
14215 case 0x43: /* R_RL78_ABS16. */
14216 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
14217 byte_put (start
+ reloc
->r_offset
, value
, 2);
14219 error (_("RL78 sym diff reloc contains invalid offset: "
14235 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
14236 DWARF debug sections. This is a target specific test. Note - we do not
14237 go through the whole including-target-headers-multiple-times route, (as
14238 we have already done with <elf/h8.h>) because this would become very
14239 messy and even then this function would have to contain target specific
14240 information (the names of the relocs instead of their numeric values).
14241 FIXME: This is not the correct way to solve this problem. The proper way
14242 is to have target specific reloc sizing and typing functions created by
14243 the reloc-macros.h header, in the same way that it already creates the
14244 reloc naming functions. */
14247 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14249 /* Please keep this table alpha-sorted for ease of visual lookup. */
14250 switch (filedata
->file_header
.e_machine
)
14254 return reloc_type
== 1; /* R_386_32. */
14256 return reloc_type
== 1; /* R_68K_32. */
14258 return reloc_type
== 1; /* R_860_32. */
14260 return reloc_type
== 2; /* R_960_32. */
14262 return (reloc_type
== 258
14263 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
14265 return reloc_type
== 11; /* R_BPF_DATA_32 */
14266 case EM_ADAPTEVA_EPIPHANY
:
14267 return reloc_type
== 3;
14269 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
14271 return reloc_type
== 1; /* R_ARC_32. */
14272 case EM_ARC_COMPACT
:
14273 case EM_ARC_COMPACT2
:
14274 return reloc_type
== 4; /* R_ARC_32. */
14276 return reloc_type
== 2; /* R_ARM_ABS32 */
14279 return reloc_type
== 1;
14281 return reloc_type
== 0x12; /* R_byte4_data. */
14283 return reloc_type
== 3; /* R_CRIS_32. */
14285 return reloc_type
== 3; /* R_CR16_NUM32. */
14287 return reloc_type
== 15; /* R_CRX_NUM32. */
14289 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
14290 case EM_CYGNUS_FRV
:
14291 return reloc_type
== 1;
14292 case EM_CYGNUS_D10V
:
14294 return reloc_type
== 6; /* R_D10V_32. */
14295 case EM_CYGNUS_D30V
:
14297 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
14299 return reloc_type
== 3; /* R_DLX_RELOC_32. */
14300 case EM_CYGNUS_FR30
:
14302 return reloc_type
== 3; /* R_FR30_32. */
14304 return reloc_type
== 1; /* R_FT32_32. */
14308 return reloc_type
== 1; /* R_H8_DIR32. */
14310 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
14311 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
14312 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
14313 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
14316 return reloc_type
== 2; /* R_IP2K_32. */
14318 return reloc_type
== 2; /* R_IQ2000_32. */
14319 case EM_LATTICEMICO32
:
14320 return reloc_type
== 3; /* R_LM32_32. */
14322 return reloc_type
== 1; /* R_LARCH_32. */
14325 return reloc_type
== 3; /* R_M32C_32. */
14327 return reloc_type
== 34; /* R_M32R_32_RELA. */
14330 return reloc_type
== 6; /* R_M68HC11_32. */
14332 return reloc_type
== 7 || /* R_S12Z_EXT32 */
14333 reloc_type
== 6; /* R_S12Z_CW32. */
14335 return reloc_type
== 1; /* R_MCORE_ADDR32. */
14336 case EM_CYGNUS_MEP
:
14337 return reloc_type
== 4; /* R_MEP_32. */
14339 return reloc_type
== 2; /* R_METAG_ADDR32. */
14340 case EM_MICROBLAZE
:
14341 return reloc_type
== 1; /* R_MICROBLAZE_32. */
14343 return reloc_type
== 2; /* R_MIPS_32. */
14345 return reloc_type
== 4; /* R_MMIX_32. */
14346 case EM_CYGNUS_MN10200
:
14348 return reloc_type
== 1; /* R_MN10200_32. */
14349 case EM_CYGNUS_MN10300
:
14351 return reloc_type
== 1; /* R_MN10300_32. */
14353 return reloc_type
== 1; /* R_MOXIE_32. */
14354 case EM_MSP430_OLD
:
14356 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
14358 return reloc_type
== 2; /* R_MT_32. */
14360 return reloc_type
== 20; /* R_NDS32_32_RELA. */
14361 case EM_ALTERA_NIOS2
:
14362 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
14364 return reloc_type
== 1; /* R_NIOS_32. */
14366 return reloc_type
== 1; /* R_OR1K_32. */
14368 return (reloc_type
== 1 /* R_PARISC_DIR32. */
14369 || reloc_type
== 2 /* R_PARISC_DIR21L. */
14370 || reloc_type
== 41); /* R_PARISC_SECREL32. */
14373 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
14375 return reloc_type
== 1; /* R_PPC64_ADDR32. */
14377 return reloc_type
== 1; /* R_PPC_ADDR32. */
14379 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
14381 return reloc_type
== 1; /* R_RISCV_32. */
14383 return reloc_type
== 1; /* R_RL78_DIR32. */
14385 return reloc_type
== 1; /* R_RX_DIR32. */
14387 return reloc_type
== 1; /* R_I370_ADDR31. */
14390 return reloc_type
== 4; /* R_S390_32. */
14392 return reloc_type
== 8; /* R_SCORE_ABS32. */
14394 return reloc_type
== 1; /* R_SH_DIR32. */
14395 case EM_SPARC32PLUS
:
14398 return reloc_type
== 3 /* R_SPARC_32. */
14399 || reloc_type
== 23; /* R_SPARC_UA32. */
14401 return reloc_type
== 6; /* R_SPU_ADDR32 */
14403 return reloc_type
== 1; /* R_C6000_ABS32. */
14405 return reloc_type
== 2; /* R_TILEGX_32. */
14407 return reloc_type
== 1; /* R_TILEPRO_32. */
14408 case EM_CYGNUS_V850
:
14410 return reloc_type
== 6; /* R_V850_ABS32. */
14412 return reloc_type
== 0x33; /* R_V810_WORD. */
14414 return reloc_type
== 1; /* R_VAX_32. */
14416 return reloc_type
== 3; /* R_VISIUM_32. */
14417 case EM_WEBASSEMBLY
:
14418 return reloc_type
== 1; /* R_WASM32_32. */
14422 return reloc_type
== 10; /* R_X86_64_32. */
14424 return reloc_type
== 4; /* R_XGATE_32. */
14426 return reloc_type
== 1; /* R_XSTROMY16_32. */
14427 case EM_XTENSA_OLD
:
14429 return reloc_type
== 1; /* R_XTENSA_32. */
14431 return reloc_type
== 6; /* R_Z80_32. */
14434 static unsigned int prev_warn
= 0;
14436 /* Avoid repeating the same warning multiple times. */
14437 if (prev_warn
!= filedata
->file_header
.e_machine
)
14438 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
14439 filedata
->file_header
.e_machine
);
14440 prev_warn
= filedata
->file_header
.e_machine
;
14446 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14447 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
14450 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14452 switch (filedata
->file_header
.e_machine
)
14453 /* Please keep this table alpha-sorted for ease of visual lookup. */
14457 return reloc_type
== 2; /* R_386_PC32. */
14459 return reloc_type
== 4; /* R_68K_PC32. */
14461 return reloc_type
== 261; /* R_AARCH64_PREL32 */
14462 case EM_ADAPTEVA_EPIPHANY
:
14463 return reloc_type
== 6;
14465 return reloc_type
== 10; /* R_ALPHA_SREL32. */
14466 case EM_ARC_COMPACT
:
14467 case EM_ARC_COMPACT2
:
14468 return reloc_type
== 49; /* R_ARC_32_PCREL. */
14470 return reloc_type
== 3; /* R_ARM_REL32 */
14473 return reloc_type
== 36; /* R_AVR_32_PCREL. */
14475 return reloc_type
== 99; /* R_LARCH_32_PCREL. */
14476 case EM_MICROBLAZE
:
14477 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
14479 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
14481 return reloc_type
== 9; /* R_PARISC_PCREL32. */
14483 return reloc_type
== 26; /* R_PPC_REL32. */
14485 return reloc_type
== 26; /* R_PPC64_REL32. */
14487 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
14490 return reloc_type
== 5; /* R_390_PC32. */
14492 return reloc_type
== 2; /* R_SH_REL32. */
14493 case EM_SPARC32PLUS
:
14496 return reloc_type
== 6; /* R_SPARC_DISP32. */
14498 return reloc_type
== 13; /* R_SPU_REL32. */
14500 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
14502 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
14504 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
14508 return reloc_type
== 2; /* R_X86_64_PC32. */
14510 return reloc_type
== 4; /* R_VAX_PCREL32. */
14511 case EM_XTENSA_OLD
:
14513 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
14515 /* Do not abort or issue an error message here. Not all targets use
14516 pc-relative 32-bit relocs in their DWARF debug information and we
14517 have already tested for target coverage in is_32bit_abs_reloc. A
14518 more helpful warning message will be generated by apply_relocations
14519 anyway, so just return. */
14524 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14525 a 64-bit absolute RELA relocation used in DWARF debug sections. */
14528 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14530 switch (filedata
->file_header
.e_machine
)
14533 return reloc_type
== 257; /* R_AARCH64_ABS64. */
14535 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
14537 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
14538 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
14540 return reloc_type
== 2; /* R_LARCH_64 */
14542 return reloc_type
== 80; /* R_PARISC_DIR64. */
14544 return reloc_type
== 38; /* R_PPC64_ADDR64. */
14546 return reloc_type
== 2; /* R_RISCV_64. */
14547 case EM_SPARC32PLUS
:
14550 return reloc_type
== 32 /* R_SPARC_64. */
14551 || reloc_type
== 54; /* R_SPARC_UA64. */
14555 return reloc_type
== 1; /* R_X86_64_64. */
14558 return reloc_type
== 22; /* R_S390_64. */
14560 return reloc_type
== 1; /* R_TILEGX_64. */
14562 return reloc_type
== 18; /* R_MIPS_64. */
14568 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
14569 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
14572 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14574 switch (filedata
->file_header
.e_machine
)
14577 return reloc_type
== 260; /* R_AARCH64_PREL64. */
14579 return reloc_type
== 11; /* R_ALPHA_SREL64. */
14581 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
14582 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
14584 return reloc_type
== 72; /* R_PARISC_PCREL64. */
14586 return reloc_type
== 44; /* R_PPC64_REL64. */
14587 case EM_SPARC32PLUS
:
14590 return reloc_type
== 46; /* R_SPARC_DISP64. */
14594 return reloc_type
== 24; /* R_X86_64_PC64. */
14597 return reloc_type
== 23; /* R_S390_PC64. */
14599 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
14605 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14606 a 24-bit absolute RELA relocation used in DWARF debug sections. */
14609 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14611 switch (filedata
->file_header
.e_machine
)
14613 case EM_CYGNUS_MN10200
:
14615 return reloc_type
== 4; /* R_MN10200_24. */
14617 return reloc_type
== 5; /* R_FT32_20. */
14619 return reloc_type
== 5; /* R_Z80_24. */
14625 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14626 a 16-bit absolute RELA relocation used in DWARF debug sections. */
14629 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14631 /* Please keep this table alpha-sorted for ease of visual lookup. */
14632 switch (filedata
->file_header
.e_machine
)
14635 case EM_ARC_COMPACT
:
14636 case EM_ARC_COMPACT2
:
14637 return reloc_type
== 2; /* R_ARC_16. */
14638 case EM_ADAPTEVA_EPIPHANY
:
14639 return reloc_type
== 5;
14642 return reloc_type
== 4; /* R_AVR_16. */
14643 case EM_CYGNUS_D10V
:
14645 return reloc_type
== 3; /* R_D10V_16. */
14647 return reloc_type
== 2; /* R_FT32_16. */
14651 return reloc_type
== R_H8_DIR16
;
14654 return reloc_type
== 1; /* R_IP2K_16. */
14657 return reloc_type
== 1; /* R_M32C_16 */
14658 case EM_CYGNUS_MN10200
:
14660 return reloc_type
== 2; /* R_MN10200_16. */
14661 case EM_CYGNUS_MN10300
:
14663 return reloc_type
== 2; /* R_MN10300_16. */
14665 if (uses_msp430x_relocs (filedata
))
14666 return reloc_type
== 2; /* R_MSP430_ABS16. */
14667 /* Fall through. */
14668 case EM_MSP430_OLD
:
14669 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
14671 return reloc_type
== 19; /* R_NDS32_16_RELA. */
14672 case EM_ALTERA_NIOS2
:
14673 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
14675 return reloc_type
== 9; /* R_NIOS_16. */
14677 return reloc_type
== 2; /* R_OR1K_16. */
14679 return reloc_type
== 55; /* R_RISCV_SET16. */
14681 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
14683 return reloc_type
== 2; /* R_C6000_ABS16. */
14685 return reloc_type
== 2; /* R_VISIUM_16. */
14687 return reloc_type
== 3; /* R_XGATE_16. */
14689 return reloc_type
== 4; /* R_Z80_16. */
14695 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14696 a 8-bit absolute RELA relocation used in DWARF debug sections. */
14699 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14701 switch (filedata
->file_header
.e_machine
)
14704 return reloc_type
== 54; /* R_RISCV_SET8. */
14706 return reloc_type
== 1; /* R_Z80_8. */
14712 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14713 a 6-bit absolute RELA relocation used in DWARF debug sections. */
14716 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14718 switch (filedata
->file_header
.e_machine
)
14721 return reloc_type
== 53; /* R_RISCV_SET6. */
14727 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14728 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
14731 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14733 /* Please keep this table alpha-sorted for ease of visual lookup. */
14734 switch (filedata
->file_header
.e_machine
)
14737 return reloc_type
== 35; /* R_RISCV_ADD32. */
14743 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14744 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
14747 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14749 /* Please keep this table alpha-sorted for ease of visual lookup. */
14750 switch (filedata
->file_header
.e_machine
)
14753 return reloc_type
== 39; /* R_RISCV_SUB32. */
14759 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14760 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
14763 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14765 /* Please keep this table alpha-sorted for ease of visual lookup. */
14766 switch (filedata
->file_header
.e_machine
)
14769 return reloc_type
== 36; /* R_RISCV_ADD64. */
14775 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14776 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
14779 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14781 /* Please keep this table alpha-sorted for ease of visual lookup. */
14782 switch (filedata
->file_header
.e_machine
)
14785 return reloc_type
== 40; /* R_RISCV_SUB64. */
14791 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14792 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
14795 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14797 /* Please keep this table alpha-sorted for ease of visual lookup. */
14798 switch (filedata
->file_header
.e_machine
)
14801 return reloc_type
== 34; /* R_RISCV_ADD16. */
14807 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14808 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
14811 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14813 /* Please keep this table alpha-sorted for ease of visual lookup. */
14814 switch (filedata
->file_header
.e_machine
)
14817 return reloc_type
== 38; /* R_RISCV_SUB16. */
14823 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14824 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
14827 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14829 /* Please keep this table alpha-sorted for ease of visual lookup. */
14830 switch (filedata
->file_header
.e_machine
)
14833 return reloc_type
== 33; /* R_RISCV_ADD8. */
14839 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14840 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
14843 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14845 /* Please keep this table alpha-sorted for ease of visual lookup. */
14846 switch (filedata
->file_header
.e_machine
)
14849 return reloc_type
== 37; /* R_RISCV_SUB8. */
14855 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14856 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
14859 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14861 switch (filedata
->file_header
.e_machine
)
14864 return reloc_type
== 52; /* R_RISCV_SUB6. */
14870 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
14871 relocation entries (possibly formerly used for SHT_GROUP sections). */
14874 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14876 switch (filedata
->file_header
.e_machine
)
14878 case EM_386
: /* R_386_NONE. */
14879 case EM_68K
: /* R_68K_NONE. */
14880 case EM_ADAPTEVA_EPIPHANY
:
14881 case EM_ALPHA
: /* R_ALPHA_NONE. */
14882 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
14883 case EM_ARC
: /* R_ARC_NONE. */
14884 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
14885 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
14886 case EM_ARM
: /* R_ARM_NONE. */
14887 case EM_CRIS
: /* R_CRIS_NONE. */
14888 case EM_FT32
: /* R_FT32_NONE. */
14889 case EM_IA_64
: /* R_IA64_NONE. */
14890 case EM_K1OM
: /* R_X86_64_NONE. */
14891 case EM_L1OM
: /* R_X86_64_NONE. */
14892 case EM_M32R
: /* R_M32R_NONE. */
14893 case EM_MIPS
: /* R_MIPS_NONE. */
14894 case EM_MN10300
: /* R_MN10300_NONE. */
14895 case EM_MOXIE
: /* R_MOXIE_NONE. */
14896 case EM_NIOS32
: /* R_NIOS_NONE. */
14897 case EM_OR1K
: /* R_OR1K_NONE. */
14898 case EM_PARISC
: /* R_PARISC_NONE. */
14899 case EM_PPC64
: /* R_PPC64_NONE. */
14900 case EM_PPC
: /* R_PPC_NONE. */
14901 case EM_RISCV
: /* R_RISCV_NONE. */
14902 case EM_S390
: /* R_390_NONE. */
14904 case EM_SH
: /* R_SH_NONE. */
14905 case EM_SPARC32PLUS
:
14906 case EM_SPARC
: /* R_SPARC_NONE. */
14908 case EM_TILEGX
: /* R_TILEGX_NONE. */
14909 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
14910 case EM_TI_C6000
:/* R_C6000_NONE. */
14911 case EM_X86_64
: /* R_X86_64_NONE. */
14912 case EM_Z80
: /* R_Z80_NONE. */
14913 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
14914 return reloc_type
== 0;
14917 return reloc_type
== 0 || reloc_type
== 256;
14920 return (reloc_type
== 0 /* R_AVR_NONE. */
14921 || reloc_type
== 30 /* R_AVR_DIFF8. */
14922 || reloc_type
== 31 /* R_AVR_DIFF16. */
14923 || reloc_type
== 32 /* R_AVR_DIFF32. */);
14925 return reloc_type
== 3; /* R_METAG_NONE. */
14927 return (reloc_type
== 0 /* R_NDS32_NONE. */
14928 || reloc_type
== 205 /* R_NDS32_DIFF8. */
14929 || reloc_type
== 206 /* R_NDS32_DIFF16. */
14930 || reloc_type
== 207 /* R_NDS32_DIFF32. */
14931 || reloc_type
== 208 /* R_NDS32_DIFF_ULEB128. */);
14933 return (reloc_type
== 0 /* R_PRU_NONE. */
14934 || reloc_type
== 65 /* R_PRU_DIFF8. */
14935 || reloc_type
== 66 /* R_PRU_DIFF16. */
14936 || reloc_type
== 67 /* R_PRU_DIFF32. */);
14937 case EM_XTENSA_OLD
:
14939 return (reloc_type
== 0 /* R_XTENSA_NONE. */
14940 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
14941 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
14942 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
14943 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
14944 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
14945 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
14946 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
14947 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
14948 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
14953 /* Returns TRUE if there is a relocation against
14954 section NAME at OFFSET bytes. */
14957 reloc_at (struct dwarf_section
* dsec
, uint64_t offset
)
14959 Elf_Internal_Rela
* relocs
;
14960 Elf_Internal_Rela
* rp
;
14962 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
14965 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
14967 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
14968 if (rp
->r_offset
== offset
)
14974 /* Apply relocations to a section.
14975 Returns TRUE upon success, FALSE otherwise.
14976 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
14977 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
14978 will be set to the number of relocs loaded.
14980 Note: So far support has been added only for those relocations
14981 which can be found in debug sections. FIXME: Add support for
14982 more relocations ? */
14985 apply_relocations (Filedata
*filedata
,
14986 const Elf_Internal_Shdr
*section
,
14987 unsigned char *start
,
14989 void **relocs_return
,
14990 uint64_t *num_relocs_return
)
14992 Elf_Internal_Shdr
* relsec
;
14993 unsigned char * end
= start
+ size
;
14995 if (relocs_return
!= NULL
)
14997 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
14998 * num_relocs_return
= 0;
15001 if (filedata
->file_header
.e_type
!= ET_REL
)
15002 /* No relocs to apply. */
15005 /* Find the reloc section associated with the section. */
15006 for (relsec
= filedata
->section_headers
;
15007 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
15011 uint64_t num_relocs
;
15012 Elf_Internal_Rela
* relocs
;
15013 Elf_Internal_Rela
* rp
;
15014 Elf_Internal_Shdr
* symsec
;
15015 Elf_Internal_Sym
* symtab
;
15017 Elf_Internal_Sym
* sym
;
15019 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
15020 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
15021 || filedata
->section_headers
+ relsec
->sh_info
!= section
15022 || relsec
->sh_size
== 0
15023 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
15026 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
15027 if (symsec
->sh_type
!= SHT_SYMTAB
15028 && symsec
->sh_type
!= SHT_DYNSYM
)
15031 is_rela
= relsec
->sh_type
== SHT_RELA
;
15035 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
15036 relsec
->sh_size
, & relocs
, & num_relocs
))
15041 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
15042 relsec
->sh_size
, & relocs
, & num_relocs
))
15046 /* SH uses RELA but uses in place value instead of the addend field. */
15047 if (filedata
->file_header
.e_machine
== EM_SH
)
15050 symtab
= get_elf_symbols (filedata
, symsec
, & num_syms
);
15052 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
15055 unsigned int reloc_type
;
15056 unsigned int reloc_size
;
15057 bool reloc_inplace
= false;
15058 bool reloc_subtract
= false;
15059 unsigned char *rloc
;
15060 uint64_t sym_index
;
15062 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
15064 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
15066 else if (is_none_reloc (filedata
, reloc_type
))
15068 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
15069 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
15071 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
15072 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
15074 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
15076 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
15078 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
15079 || is_6bit_abs_reloc (filedata
, reloc_type
))
15081 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
15083 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
15086 reloc_inplace
= true;
15088 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
15090 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
15093 reloc_inplace
= true;
15095 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
15097 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
15100 reloc_inplace
= true;
15102 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
15104 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
15107 reloc_inplace
= true;
15109 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
15113 reloc_inplace
= true;
15117 static unsigned int prev_reloc
= 0;
15119 if (reloc_type
!= prev_reloc
)
15120 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
15121 reloc_type
, printable_section_name (filedata
, section
));
15122 prev_reloc
= reloc_type
;
15126 rloc
= start
+ rp
->r_offset
;
15127 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
15129 warn (_("skipping invalid relocation offset %#" PRIx64
15130 " in section %s\n"),
15132 printable_section_name (filedata
, section
));
15136 sym_index
= get_reloc_symindex (rp
->r_info
);
15137 if (sym_index
>= num_syms
)
15139 warn (_("skipping invalid relocation symbol index %#" PRIx64
15140 " in section %s\n"),
15141 sym_index
, printable_section_name (filedata
, section
));
15144 sym
= symtab
+ sym_index
;
15146 /* If the reloc has a symbol associated with it,
15147 make sure that it is of an appropriate type.
15149 Relocations against symbols without type can happen.
15150 Gcc -feliminate-dwarf2-dups may generate symbols
15151 without type for debug info.
15153 Icc generates relocations against function symbols
15154 instead of local labels.
15156 Relocations against object symbols can happen, eg when
15157 referencing a global array. For an example of this see
15158 the _clz.o binary in libgcc.a. */
15160 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
15161 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
15163 warn (_("skipping unexpected symbol type %s in section %s relocation %tu\n"),
15164 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
15165 printable_section_name (filedata
, relsec
),
15172 addend
+= rp
->r_addend
;
15173 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
15174 partial_inplace. */
15176 || (filedata
->file_header
.e_machine
== EM_XTENSA
15177 && reloc_type
== 1)
15178 || ((filedata
->file_header
.e_machine
== EM_PJ
15179 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
15180 && reloc_type
== 1)
15181 || ((filedata
->file_header
.e_machine
== EM_D30V
15182 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
15183 && reloc_type
== 12)
15186 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
15187 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
15189 addend
+= byte_get (rloc
, reloc_size
);
15192 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
15193 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
15195 /* On HPPA, all pc-relative relocations are biased by 8. */
15196 if (filedata
->file_header
.e_machine
== EM_PARISC
)
15198 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
15201 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
15202 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
15204 if (reloc_subtract
)
15205 addend
-= sym
->st_value
;
15207 addend
+= sym
->st_value
;
15208 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
15209 byte_put (rloc
, addend
, reloc_size
);
15211 else if (reloc_subtract
)
15212 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
15214 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
15218 /* Let the target specific reloc processing code know that
15219 we have finished with these relocs. */
15220 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
15224 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
15225 * num_relocs_return
= num_relocs
;
15236 #ifdef SUPPORT_DISASSEMBLY
15238 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15240 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
15242 /* FIXME: XXX -- to be done --- XXX */
15248 /* Reads in the contents of SECTION from FILE, returning a pointer
15249 to a malloc'ed buffer or NULL if something went wrong. */
15252 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15254 uint64_t num_bytes
= section
->sh_size
;
15256 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
15258 printf (_("Section '%s' has no data to dump.\n"),
15259 printable_section_name (filedata
, section
));
15263 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
15264 _("section contents"));
15267 /* Uncompresses a section that was compressed using zlib/zstd, in place. */
15270 uncompress_section_contents (bool is_zstd
, unsigned char **buffer
,
15271 uint64_t uncompressed_size
, uint64_t *size
)
15273 uint64_t compressed_size
= *size
;
15274 unsigned char *compressed_buffer
= *buffer
;
15275 unsigned char *uncompressed_buffer
= xmalloc (uncompressed_size
);
15282 size_t ret
= ZSTD_decompress (uncompressed_buffer
, uncompressed_size
,
15283 compressed_buffer
, compressed_size
);
15284 if (ZSTD_isError (ret
))
15290 /* It is possible the section consists of several compressed
15291 buffers concatenated together, so we uncompress in a loop. */
15292 /* PR 18313: The state field in the z_stream structure is supposed
15293 to be invisible to the user (ie us), but some compilers will
15294 still complain about it being used without initialisation. So
15295 we first zero the entire z_stream structure and then set the fields
15297 memset (&strm
, 0, sizeof strm
);
15298 strm
.avail_in
= compressed_size
;
15299 strm
.next_in
= (Bytef
*)compressed_buffer
;
15300 strm
.avail_out
= uncompressed_size
;
15302 rc
= inflateInit (&strm
);
15303 while (strm
.avail_in
> 0)
15307 strm
.next_out
= ((Bytef
*)uncompressed_buffer
15308 + (uncompressed_size
- strm
.avail_out
));
15309 rc
= inflate (&strm
, Z_FINISH
);
15310 if (rc
!= Z_STREAM_END
)
15312 rc
= inflateReset (&strm
);
15314 if (inflateEnd (&strm
) != Z_OK
|| rc
!= Z_OK
|| strm
.avail_out
!= 0)
15318 *buffer
= uncompressed_buffer
;
15319 *size
= uncompressed_size
;
15323 free (uncompressed_buffer
);
15324 /* Indicate decompression failure. */
15330 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15332 Elf_Internal_Shdr
*relsec
;
15333 uint64_t num_bytes
;
15334 unsigned char *data
;
15335 unsigned char *end
;
15336 unsigned char *real_start
;
15337 unsigned char *start
;
15338 bool some_strings_shown
;
15340 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
15342 /* PR 21820: Do not fail if the section was empty. */
15343 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
15345 num_bytes
= section
->sh_size
;
15347 if (filedata
->is_separate
)
15348 printf (_("\nString dump of section '%s' in linked file %s:\n"),
15349 printable_section_name (filedata
, section
),
15350 filedata
->file_name
);
15352 printf (_("\nString dump of section '%s':\n"),
15353 printable_section_name (filedata
, section
));
15355 if (decompress_dumps
)
15357 uint64_t new_size
= num_bytes
;
15358 uint64_t uncompressed_size
= 0;
15359 bool is_zstd
= false;
15361 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
15363 Elf_Internal_Chdr chdr
;
15364 unsigned int compression_header_size
15365 = get_compression_header (& chdr
, (unsigned char *) start
,
15367 if (compression_header_size
== 0)
15368 /* An error message will have already been generated
15369 by get_compression_header. */
15372 if (chdr
.ch_type
== ch_compress_zlib
)
15375 else if (chdr
.ch_type
== ch_compress_zstd
)
15380 warn (_("section '%s' has unsupported compress type: %d\n"),
15381 printable_section_name (filedata
, section
), chdr
.ch_type
);
15384 uncompressed_size
= chdr
.ch_size
;
15385 start
+= compression_header_size
;
15386 new_size
-= compression_header_size
;
15388 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
15390 /* Read the zlib header. In this case, it should be "ZLIB"
15391 followed by the uncompressed section size, 8 bytes in
15392 big-endian order. */
15393 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
15394 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
15395 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
15396 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
15397 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
15398 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
15399 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
15400 uncompressed_size
+= start
[11];
15405 if (uncompressed_size
)
15407 if (uncompress_section_contents (is_zstd
, &start
, uncompressed_size
,
15409 num_bytes
= new_size
;
15412 error (_("Unable to decompress section %s\n"),
15413 printable_section_name (filedata
, section
));
15418 start
= real_start
;
15421 /* If the section being dumped has relocations against it the user might
15422 be expecting these relocations to have been applied. Check for this
15423 case and issue a warning message in order to avoid confusion.
15424 FIXME: Maybe we ought to have an option that dumps a section with
15425 relocs applied ? */
15426 for (relsec
= filedata
->section_headers
;
15427 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
15430 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
15431 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
15432 || filedata
->section_headers
+ relsec
->sh_info
!= section
15433 || relsec
->sh_size
== 0
15434 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
15437 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
15442 end
= start
+ num_bytes
;
15443 some_strings_shown
= false;
15445 #ifdef HAVE_MBSTATE_T
15447 /* Initialise the multibyte conversion state. */
15448 memset (& state
, 0, sizeof (state
));
15451 bool continuing
= false;
15455 while (!ISPRINT (* data
))
15456 if (++ data
>= end
)
15461 size_t maxlen
= end
- data
;
15466 continuing
= false;
15470 printf (" [%6tx] ", data
- start
);
15484 /* PR 25543: Treat new-lines as string-ending characters. */
15493 /* Do not print control characters directly as they can affect terminal
15494 settings. Such characters usually appear in the names generated
15495 by the assembler for local labels. */
15498 printf ("^%c", c
+ 0x40);
15500 else if (ISPRINT (c
))
15507 #ifdef HAVE_MBSTATE_T
15510 /* Let printf do the hard work of displaying multibyte characters. */
15511 printf ("%.1s", data
- 1);
15512 #ifdef HAVE_MBSTATE_T
15513 /* Try to find out how many bytes made up the character that was
15514 just printed. Advance the symbol pointer past the bytes that
15516 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
15520 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
15530 printf (_("<corrupt>\n"));
15533 some_strings_shown
= true;
15537 if (! some_strings_shown
)
15538 printf (_(" No strings found in this section."));
15551 dump_section_as_bytes (Elf_Internal_Shdr
*section
,
15552 Filedata
*filedata
,
15555 Elf_Internal_Shdr
*relsec
;
15557 uint64_t section_size
;
15559 unsigned char *data
;
15560 unsigned char *real_start
;
15561 unsigned char *start
;
15563 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
15565 /* PR 21820: Do not fail if the section was empty. */
15566 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
15568 section_size
= section
->sh_size
;
15570 if (filedata
->is_separate
)
15571 printf (_("\nHex dump of section '%s' in linked file %s:\n"),
15572 printable_section_name (filedata
, section
),
15573 filedata
->file_name
);
15575 printf (_("\nHex dump of section '%s':\n"),
15576 printable_section_name (filedata
, section
));
15578 if (decompress_dumps
)
15580 uint64_t new_size
= section_size
;
15581 uint64_t uncompressed_size
= 0;
15582 bool is_zstd
= false;
15584 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
15586 Elf_Internal_Chdr chdr
;
15587 unsigned int compression_header_size
15588 = get_compression_header (& chdr
, start
, section_size
);
15590 if (compression_header_size
== 0)
15591 /* An error message will have already been generated
15592 by get_compression_header. */
15595 if (chdr
.ch_type
== ch_compress_zlib
)
15598 else if (chdr
.ch_type
== ch_compress_zstd
)
15603 warn (_("section '%s' has unsupported compress type: %d\n"),
15604 printable_section_name (filedata
, section
), chdr
.ch_type
);
15607 uncompressed_size
= chdr
.ch_size
;
15608 start
+= compression_header_size
;
15609 new_size
-= compression_header_size
;
15611 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
15613 /* Read the zlib header. In this case, it should be "ZLIB"
15614 followed by the uncompressed section size, 8 bytes in
15615 big-endian order. */
15616 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
15617 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
15618 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
15619 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
15620 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
15621 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
15622 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
15623 uncompressed_size
+= start
[11];
15628 if (uncompressed_size
)
15630 if (uncompress_section_contents (is_zstd
, &start
, uncompressed_size
,
15633 section_size
= new_size
;
15637 error (_("Unable to decompress section %s\n"),
15638 printable_section_name (filedata
, section
));
15639 /* FIXME: Print the section anyway ? */
15644 start
= real_start
;
15649 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
15654 /* If the section being dumped has relocations against it the user might
15655 be expecting these relocations to have been applied. Check for this
15656 case and issue a warning message in order to avoid confusion.
15657 FIXME: Maybe we ought to have an option that dumps a section with
15658 relocs applied ? */
15659 for (relsec
= filedata
->section_headers
;
15660 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
15663 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
15664 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
15665 || filedata
->section_headers
+ relsec
->sh_info
!= section
15666 || relsec
->sh_size
== 0
15667 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
15670 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
15675 addr
= section
->sh_addr
;
15676 bytes
= section_size
;
15685 lbytes
= (bytes
> 16 ? 16 : bytes
);
15687 printf (" 0x%8.8" PRIx64
" ", addr
);
15689 for (j
= 0; j
< 16; j
++)
15692 printf ("%2.2x", data
[j
]);
15700 for (j
= 0; j
< lbytes
; j
++)
15703 if (k
>= ' ' && k
< 0x7f)
15726 #ifdef ENABLE_LIBCTF
15727 static ctf_sect_t
*
15728 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
15730 buf
->cts_name
= section_name_print (filedata
, shdr
);
15731 buf
->cts_size
= shdr
->sh_size
;
15732 buf
->cts_entsize
= shdr
->sh_entsize
;
15737 /* Formatting callback function passed to ctf_dump. Returns either the pointer
15738 it is passed, or a pointer to newly-allocated storage, in which case
15739 dump_ctf() will free it when it no longer needs it. */
15742 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
15743 char *s
, void *arg
)
15745 const char *blanks
= arg
;
15748 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
15753 /* Dump CTF errors/warnings. */
15755 dump_ctf_errs (ctf_dict_t
*fp
)
15757 ctf_next_t
*it
= NULL
;
15762 /* Dump accumulated errors and warnings. */
15763 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
15765 error (_("%s: %s"), is_warning
? _("warning"): _("error"),
15769 if (err
!= ECTF_NEXT_END
)
15770 error (_("CTF error: cannot get CTF errors: `%s'"), ctf_errmsg (err
));
15773 /* Dump one CTF archive member. */
15776 dump_ctf_archive_member (ctf_dict_t
*ctf
, const char *name
, ctf_dict_t
*parent
,
15779 const char *things
[] = {"Header", "Labels", "Data objects",
15780 "Function objects", "Variables", "Types", "Strings",
15782 const char **thing
;
15785 /* Don't print out the name of the default-named archive member if it appears
15786 first in the list. The name .ctf appears everywhere, even for things that
15787 aren't really archives, so printing it out is liable to be confusing; also,
15788 the common case by far is for only one archive member to exist, and hiding
15789 it in that case seems worthwhile. */
15791 if (strcmp (name
, ".ctf") != 0 || member
!= 0)
15792 printf (_("\nCTF archive member: %s:\n"), name
);
15794 if (ctf_parent_name (ctf
) != NULL
)
15795 ctf_import (ctf
, parent
);
15797 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
15799 ctf_dump_state_t
*s
= NULL
;
15802 printf ("\n %s:\n", *thing
);
15803 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
15804 (void *) " ")) != NULL
)
15806 printf ("%s\n", item
);
15810 if (ctf_errno (ctf
))
15812 error (_("Iteration failed: %s, %s\n"), *thing
,
15813 ctf_errmsg (ctf_errno (ctf
)));
15818 dump_ctf_errs (ctf
);
15822 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15824 Elf_Internal_Shdr
* symtab_sec
= NULL
;
15825 Elf_Internal_Shdr
* strtab_sec
= NULL
;
15826 void * data
= NULL
;
15827 void * symdata
= NULL
;
15828 void * strdata
= NULL
;
15829 ctf_sect_t ctfsect
, symsect
, strsect
;
15830 ctf_sect_t
* symsectp
= NULL
;
15831 ctf_sect_t
* strsectp
= NULL
;
15832 ctf_archive_t
* ctfa
= NULL
;
15833 ctf_dict_t
* parent
= NULL
;
15836 ctf_next_t
*i
= NULL
;
15842 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
15843 data
= get_section_contents (section
, filedata
);
15844 ctfsect
.cts_data
= data
;
15846 if (!dump_ctf_symtab_name
)
15847 dump_ctf_symtab_name
= strdup (".dynsym");
15849 if (!dump_ctf_strtab_name
)
15850 dump_ctf_strtab_name
= strdup (".dynstr");
15852 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
15854 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
15856 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
15859 if ((symdata
= (void *) get_data (NULL
, filedata
,
15860 symtab_sec
->sh_offset
, 1,
15861 symtab_sec
->sh_size
,
15862 _("symbols"))) == NULL
)
15864 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
15865 symsect
.cts_data
= symdata
;
15868 if (dump_ctf_strtab_name
&& dump_ctf_strtab_name
[0] != 0)
15870 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
15872 error (_("No string table section named %s\n"),
15873 dump_ctf_strtab_name
);
15876 if ((strdata
= (void *) get_data (NULL
, filedata
,
15877 strtab_sec
->sh_offset
, 1,
15878 strtab_sec
->sh_size
,
15879 _("strings"))) == NULL
)
15881 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
15882 strsect
.cts_data
= strdata
;
15885 /* Load the CTF file and dump it. It may be a raw CTF section, or an archive:
15886 libctf papers over the difference, so we can pretend it is always an
15889 if ((ctfa
= ctf_arc_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
15891 dump_ctf_errs (NULL
);
15892 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15896 ctf_arc_symsect_endianness (ctfa
, filedata
->file_header
.e_ident
[EI_DATA
]
15899 /* Preload the parent dict, since it will need to be imported into every
15901 if ((parent
= ctf_dict_open (ctfa
, dump_ctf_parent_name
, &err
)) == NULL
)
15903 dump_ctf_errs (NULL
);
15904 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15910 if (filedata
->is_separate
)
15911 printf (_("\nDump of CTF section '%s' in linked file %s:\n"),
15912 printable_section_name (filedata
, section
),
15913 filedata
->file_name
);
15915 printf (_("\nDump of CTF section '%s':\n"),
15916 printable_section_name (filedata
, section
));
15918 while ((fp
= ctf_archive_next (ctfa
, &i
, &name
, 0, &err
)) != NULL
)
15919 dump_ctf_archive_member (fp
, name
, parent
, member
++);
15920 if (err
!= ECTF_NEXT_END
)
15922 dump_ctf_errs (NULL
);
15923 error (_("CTF member open failure: %s\n"), ctf_errmsg (err
));
15928 ctf_dict_close (parent
);
15938 dump_section_as_sframe (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15940 void * data
= NULL
;
15941 sframe_decoder_ctx
*sfd_ctx
= NULL
;
15942 const char *print_name
= printable_section_name (filedata
, section
);
15948 if (strcmp (print_name
, "") == 0)
15950 error (_("Section name must be provided \n"));
15955 data
= get_section_contents (section
, filedata
);
15956 sf_size
= section
->sh_size
;
15957 /* Decode the contents of the section. */
15958 sfd_ctx
= sframe_decode ((const char*)data
, sf_size
, &err
);
15962 error (_("SFrame decode failure: %s\n"), sframe_errmsg (err
));
15966 printf (_("Contents of the SFrame section %s:"), print_name
);
15967 /* Dump the contents as text. */
15968 dump_sframe (sfd_ctx
, section
->sh_addr
);
15976 load_specific_debug_section (enum dwarf_section_display_enum debug
,
15977 const Elf_Internal_Shdr
* sec
,
15980 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15982 Filedata
* filedata
= (Filedata
*) data
;
15984 if (section
->start
!= NULL
)
15986 /* If it is already loaded, do nothing. */
15987 if (streq (section
->filename
, filedata
->file_name
))
15989 free (section
->start
);
15992 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
15993 section
->address
= sec
->sh_addr
;
15994 section
->filename
= filedata
->file_name
;
15995 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
15997 sec
->sh_size
, buf
);
15998 if (section
->start
== NULL
)
16002 unsigned char *start
= section
->start
;
16003 uint64_t size
= sec
->sh_size
;
16004 uint64_t uncompressed_size
= 0;
16005 bool is_zstd
= false;
16007 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
16009 Elf_Internal_Chdr chdr
;
16010 unsigned int compression_header_size
;
16012 if (size
< (is_32bit_elf
16013 ? sizeof (Elf32_External_Chdr
)
16014 : sizeof (Elf64_External_Chdr
)))
16016 warn (_("compressed section %s is too small to contain a compression header\n"),
16021 compression_header_size
= get_compression_header (&chdr
, start
, size
);
16022 if (compression_header_size
== 0)
16023 /* An error message will have already been generated
16024 by get_compression_header. */
16027 if (chdr
.ch_type
== ch_compress_zlib
)
16030 else if (chdr
.ch_type
== ch_compress_zstd
)
16035 warn (_("section '%s' has unsupported compress type: %d\n"),
16036 section
->name
, chdr
.ch_type
);
16039 uncompressed_size
= chdr
.ch_size
;
16040 start
+= compression_header_size
;
16041 size
-= compression_header_size
;
16043 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
16045 /* Read the zlib header. In this case, it should be "ZLIB"
16046 followed by the uncompressed section size, 8 bytes in
16047 big-endian order. */
16048 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
16049 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
16050 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
16051 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
16052 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
16053 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
16054 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
16055 uncompressed_size
+= start
[11];
16060 if (uncompressed_size
)
16062 if (uncompress_section_contents (is_zstd
, &start
, uncompressed_size
,
16065 /* Free the compressed buffer, update the section buffer
16066 and the section size if uncompress is successful. */
16067 free (section
->start
);
16068 section
->start
= start
;
16072 error (_("Unable to decompress section %s\n"),
16073 printable_section_name (filedata
, sec
));
16078 section
->size
= size
;
16081 if (section
->start
== NULL
)
16084 if (debug_displays
[debug
].relocate
)
16086 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
16087 & section
->reloc_info
, & section
->num_relocs
))
16092 section
->reloc_info
= NULL
;
16093 section
->num_relocs
= 0;
16099 #if HAVE_LIBDEBUGINFOD
16100 /* Return a hex string representation of the build-id. */
16102 get_build_id (void * data
)
16104 Filedata
* filedata
= (Filedata
*) data
;
16105 Elf_Internal_Shdr
* shdr
;
16108 /* Iterate through notes to find note.gnu.build-id.
16109 FIXME: Only the first note in any note section is examined. */
16110 for (i
= 0, shdr
= filedata
->section_headers
;
16111 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
16114 if (shdr
->sh_type
!= SHT_NOTE
)
16119 size_t data_remaining
;
16121 Elf_External_Note
* enote
;
16122 Elf_Internal_Note inote
;
16124 uint64_t offset
= shdr
->sh_offset
;
16125 uint64_t align
= shdr
->sh_addralign
;
16126 uint64_t length
= shdr
->sh_size
;
16128 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
16134 else if (align
!= 4 && align
!= 8)
16140 end
= (char *) enote
+ length
;
16141 data_remaining
= end
- (char *) enote
;
16143 if (!is_ia64_vms (filedata
))
16145 min_notesz
= offsetof (Elf_External_Note
, name
);
16146 if (data_remaining
< min_notesz
)
16149 malformed note encountered in section %s whilst scanning for build-id note\n"),
16150 printable_section_name (filedata
, shdr
));
16154 data_remaining
-= min_notesz
;
16156 inote
.type
= BYTE_GET (enote
->type
);
16157 inote
.namesz
= BYTE_GET (enote
->namesz
);
16158 inote
.namedata
= enote
->name
;
16159 inote
.descsz
= BYTE_GET (enote
->descsz
);
16160 inote
.descdata
= ((char *) enote
16161 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
16162 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
16163 next
= ((char *) enote
16164 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
16168 Elf64_External_VMS_Note
*vms_enote
;
16170 /* PR binutils/15191
16171 Make sure that there is enough data to read. */
16172 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
16173 if (data_remaining
< min_notesz
)
16176 malformed note encountered in section %s whilst scanning for build-id note\n"),
16177 printable_section_name (filedata
, shdr
));
16181 data_remaining
-= min_notesz
;
16183 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
16184 inote
.type
= BYTE_GET (vms_enote
->type
);
16185 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
16186 inote
.namedata
= vms_enote
->name
;
16187 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
16188 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
16189 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
16190 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
16193 /* Skip malformed notes. */
16194 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
16195 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
16196 || (size_t) (next
- inote
.descdata
) < inote
.descsz
16197 || ((size_t) (next
- inote
.descdata
)
16198 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
16201 malformed note encountered in section %s whilst scanning for build-id note\n"),
16202 printable_section_name (filedata
, shdr
));
16207 /* Check if this is the build-id note. If so then convert the build-id
16208 bytes to a hex string. */
16209 if (inote
.namesz
> 0
16210 && startswith (inote
.namedata
, "GNU")
16211 && inote
.type
== NT_GNU_BUILD_ID
)
16216 build_id
= malloc (inote
.descsz
* 2 + 1);
16217 if (build_id
== NULL
)
16223 for (j
= 0; j
< inote
.descsz
; ++j
)
16224 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
16225 build_id
[inote
.descsz
* 2] = '\0';
16228 return (unsigned char *) build_id
;
16235 #endif /* HAVE_LIBDEBUGINFOD */
16237 /* If this is not NULL, load_debug_section will only look for sections
16238 within the list of sections given here. */
16239 static unsigned int * section_subset
= NULL
;
16242 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
16244 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
16245 Elf_Internal_Shdr
* sec
;
16246 Filedata
* filedata
= (Filedata
*) data
;
16248 if (!dump_any_debugging
)
16251 /* Without section headers we cannot find any sections. */
16252 if (filedata
->section_headers
== NULL
)
16255 if (filedata
->string_table
== NULL
16256 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
16257 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
16259 Elf_Internal_Shdr
* strs
;
16261 /* Read in the string table, so that we have section names to scan. */
16262 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
16264 if (strs
!= NULL
&& strs
->sh_size
!= 0)
16266 filedata
->string_table
16267 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
16268 1, strs
->sh_size
, _("string table"));
16270 filedata
->string_table_length
16271 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
16275 /* Locate the debug section. */
16276 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
16278 section
->name
= section
->uncompressed_name
;
16281 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
16283 section
->name
= section
->compressed_name
;
16288 /* If we're loading from a subset of sections, and we've loaded
16289 a section matching this name before, it's likely that it's a
16291 if (section_subset
!= NULL
)
16292 free_debug_section (debug
);
16294 return load_specific_debug_section (debug
, sec
, data
);
16298 free_debug_section (enum dwarf_section_display_enum debug
)
16300 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
16302 if (section
->start
== NULL
)
16305 free ((char *) section
->start
);
16306 section
->start
= NULL
;
16307 section
->address
= 0;
16310 free (section
->reloc_info
);
16311 section
->reloc_info
= NULL
;
16312 section
->num_relocs
= 0;
16316 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
16318 const char *name
= (section_name_valid (filedata
, section
)
16319 ? section_name (filedata
, section
) : "");
16320 const char *print_name
= printable_section_name (filedata
, section
);
16322 bool result
= true;
16325 length
= section
->sh_size
;
16328 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
16331 if (section
->sh_type
== SHT_NOBITS
)
16333 /* There is no point in dumping the contents of a debugging section
16334 which has the NOBITS type - the bits in the file will be random.
16335 This can happen when a file containing a .eh_frame section is
16336 stripped with the --only-keep-debug command line option. */
16337 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
16342 if (startswith (name
, ".gnu.linkonce.wi."))
16343 name
= ".debug_info";
16345 /* See if we know how to display the contents of this section. */
16346 for (i
= 0; i
< max
; i
++)
16348 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
16349 struct dwarf_section_display
* display
= debug_displays
+ i
;
16350 struct dwarf_section
* sec
= & display
->section
;
16352 if (streq (sec
->uncompressed_name
, name
)
16353 || (id
== line
&& startswith (name
, ".debug_line."))
16354 || streq (sec
->compressed_name
, name
))
16356 bool secondary
= (section
!= find_section (filedata
, name
));
16359 free_debug_section (id
);
16361 if (i
== line
&& startswith (name
, ".debug_line."))
16363 else if (streq (sec
->uncompressed_name
, name
))
16364 sec
->name
= sec
->uncompressed_name
;
16366 sec
->name
= sec
->compressed_name
;
16368 if (load_specific_debug_section (id
, section
, filedata
))
16370 /* If this debug section is part of a CU/TU set in a .dwp file,
16371 restrict load_debug_section to the sections in that set. */
16372 section_subset
= find_cu_tu_set (filedata
, shndx
);
16374 result
&= display
->display (sec
, filedata
);
16376 section_subset
= NULL
;
16378 if (secondary
|| (id
!= info
&& id
!= abbrev
&& id
!= debug_addr
))
16379 free_debug_section (id
);
16387 printf (_("Unrecognized debug section: %s\n"), print_name
);
16394 /* Set DUMP_SECTS for all sections where dumps were requested
16395 based on section name. */
16398 initialise_dumps_byname (Filedata
* filedata
)
16400 struct dump_list_entry
* cur
;
16402 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
16407 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
16408 if (section_name_valid (filedata
, filedata
->section_headers
+ i
)
16409 && streq (section_name (filedata
, filedata
->section_headers
+ i
),
16412 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
16416 if (!any
&& !filedata
->is_separate
)
16417 warn (_("Section '%s' was not dumped because it does not exist\n"),
16423 process_section_contents (Filedata
* filedata
)
16425 Elf_Internal_Shdr
* section
;
16432 initialise_dumps_byname (filedata
);
16434 for (i
= 0, section
= filedata
->section_headers
;
16435 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
16438 dump_type dump
= filedata
->dump
.dump_sects
[i
];
16440 if (filedata
->is_separate
&& ! process_links
)
16441 dump
&= DEBUG_DUMP
;
16443 #ifdef SUPPORT_DISASSEMBLY
16444 if (dump
& DISASS_DUMP
)
16446 if (! disassemble_section (section
, filedata
))
16450 if (dump
& HEX_DUMP
)
16452 if (! dump_section_as_bytes (section
, filedata
, false))
16456 if (dump
& RELOC_DUMP
)
16458 if (! dump_section_as_bytes (section
, filedata
, true))
16462 if (dump
& STRING_DUMP
)
16464 if (! dump_section_as_strings (section
, filedata
))
16468 if (dump
& DEBUG_DUMP
)
16470 if (! display_debug_section (i
, section
, filedata
))
16474 #ifdef ENABLE_LIBCTF
16475 if (dump
& CTF_DUMP
)
16477 if (! dump_section_as_ctf (section
, filedata
))
16481 if (dump
& SFRAME_DUMP
)
16483 if (! dump_section_as_sframe (section
, filedata
))
16488 if (! filedata
->is_separate
)
16490 /* Check to see if the user requested a
16491 dump of a section that does not exist. */
16492 for (; i
< filedata
->dump
.num_dump_sects
; i
++)
16493 if (filedata
->dump
.dump_sects
[i
])
16495 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
16504 process_mips_fpe_exception (int mask
)
16510 if (mask
& OEX_FPU_INEX
)
16511 fputs ("INEX", stdout
), first
= false;
16512 if (mask
& OEX_FPU_UFLO
)
16513 printf ("%sUFLO", first
? "" : "|"), first
= false;
16514 if (mask
& OEX_FPU_OFLO
)
16515 printf ("%sOFLO", first
? "" : "|"), first
= false;
16516 if (mask
& OEX_FPU_DIV0
)
16517 printf ("%sDIV0", first
? "" : "|"), first
= false;
16518 if (mask
& OEX_FPU_INVAL
)
16519 printf ("%sINVAL", first
? "" : "|");
16522 fputs ("0", stdout
);
16525 /* Display's the value of TAG at location P. If TAG is
16526 greater than 0 it is assumed to be an unknown tag, and
16527 a message is printed to this effect. Otherwise it is
16528 assumed that a message has already been printed.
16530 If the bottom bit of TAG is set it assumed to have a
16531 string value, otherwise it is assumed to have an integer
16534 Returns an updated P pointing to the first unread byte
16535 beyond the end of TAG's value.
16537 Reads at or beyond END will not be made. */
16539 static unsigned char *
16540 display_tag_value (signed int tag
,
16542 const unsigned char * const end
)
16547 printf (" Tag_unknown_%d: ", tag
);
16551 warn (_("<corrupt tag>\n"));
16555 /* PR 17531 file: 027-19978-0.004. */
16556 size_t maxlen
= (end
- p
) - 1;
16561 print_symbol ((int) maxlen
, (const char *) p
);
16562 p
+= strnlen ((char *) p
, maxlen
) + 1;
16566 printf (_("<corrupt string tag>"));
16567 p
= (unsigned char *) end
;
16573 READ_ULEB (val
, p
, end
);
16574 printf ("%" PRId64
" (0x%" PRIx64
")\n", val
, val
);
16581 /* ARC ABI attributes section. */
16583 static unsigned char *
16584 display_arc_attribute (unsigned char * p
,
16585 const unsigned char * const end
)
16590 READ_ULEB (tag
, p
, end
);
16594 case Tag_ARC_PCS_config
:
16595 READ_ULEB (val
, p
, end
);
16596 printf (" Tag_ARC_PCS_config: ");
16600 printf (_("Absent/Non standard\n"));
16603 printf (_("Bare metal/mwdt\n"));
16606 printf (_("Bare metal/newlib\n"));
16609 printf (_("Linux/uclibc\n"));
16612 printf (_("Linux/glibc\n"));
16615 printf (_("Unknown\n"));
16620 case Tag_ARC_CPU_base
:
16621 READ_ULEB (val
, p
, end
);
16622 printf (" Tag_ARC_CPU_base: ");
16627 printf (_("Absent\n"));
16629 case TAG_CPU_ARC6xx
:
16630 printf ("ARC6xx\n");
16632 case TAG_CPU_ARC7xx
:
16633 printf ("ARC7xx\n");
16635 case TAG_CPU_ARCEM
:
16636 printf ("ARCEM\n");
16638 case TAG_CPU_ARCHS
:
16639 printf ("ARCHS\n");
16644 case Tag_ARC_CPU_variation
:
16645 READ_ULEB (val
, p
, end
);
16646 printf (" Tag_ARC_CPU_variation: ");
16650 if (val
> 0 && val
< 16)
16651 printf ("Core%d\n", val
);
16653 printf ("Unknown\n");
16657 printf (_("Absent\n"));
16662 case Tag_ARC_CPU_name
:
16663 printf (" Tag_ARC_CPU_name: ");
16664 p
= display_tag_value (-1, p
, end
);
16667 case Tag_ARC_ABI_rf16
:
16668 READ_ULEB (val
, p
, end
);
16669 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
16672 case Tag_ARC_ABI_osver
:
16673 READ_ULEB (val
, p
, end
);
16674 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
16677 case Tag_ARC_ABI_pic
:
16678 case Tag_ARC_ABI_sda
:
16679 READ_ULEB (val
, p
, end
);
16680 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
16681 : " Tag_ARC_ABI_pic: ");
16685 printf (_("Absent\n"));
16694 printf (_("Unknown\n"));
16699 case Tag_ARC_ABI_tls
:
16700 READ_ULEB (val
, p
, end
);
16701 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
16704 case Tag_ARC_ABI_enumsize
:
16705 READ_ULEB (val
, p
, end
);
16706 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
16710 case Tag_ARC_ABI_exceptions
:
16711 READ_ULEB (val
, p
, end
);
16712 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
16716 case Tag_ARC_ABI_double_size
:
16717 READ_ULEB (val
, p
, end
);
16718 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
16721 case Tag_ARC_ISA_config
:
16722 printf (" Tag_ARC_ISA_config: ");
16723 p
= display_tag_value (-1, p
, end
);
16726 case Tag_ARC_ISA_apex
:
16727 printf (" Tag_ARC_ISA_apex: ");
16728 p
= display_tag_value (-1, p
, end
);
16731 case Tag_ARC_ISA_mpy_option
:
16732 READ_ULEB (val
, p
, end
);
16733 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
16736 case Tag_ARC_ATR_version
:
16737 READ_ULEB (val
, p
, end
);
16738 printf (" Tag_ARC_ATR_version: %d\n", val
);
16742 return display_tag_value (tag
& 1, p
, end
);
16748 /* ARM EABI attributes section. */
16753 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
16755 const char *const *table
;
16756 } arm_attr_public_tag
;
16758 static const char *const arm_attr_tag_CPU_arch
[] =
16759 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
16760 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
16761 "v8-M.mainline", "v8.1-A", "v8.2-A", "v8.3-A",
16762 "v8.1-M.mainline", "v9"};
16763 static const char *const arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
16764 static const char *const arm_attr_tag_THUMB_ISA_use
[] =
16765 {"No", "Thumb-1", "Thumb-2", "Yes"};
16766 static const char *const arm_attr_tag_FP_arch
[] =
16767 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
16768 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
16769 static const char *const arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
16770 static const char *const arm_attr_tag_Advanced_SIMD_arch
[] =
16771 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
16772 "NEON for ARMv8.1"};
16773 static const char *const arm_attr_tag_PCS_config
[] =
16774 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
16775 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
16776 static const char *const arm_attr_tag_ABI_PCS_R9_use
[] =
16777 {"V6", "SB", "TLS", "Unused"};
16778 static const char *const arm_attr_tag_ABI_PCS_RW_data
[] =
16779 {"Absolute", "PC-relative", "SB-relative", "None"};
16780 static const char *const arm_attr_tag_ABI_PCS_RO_data
[] =
16781 {"Absolute", "PC-relative", "None"};
16782 static const char *const arm_attr_tag_ABI_PCS_GOT_use
[] =
16783 {"None", "direct", "GOT-indirect"};
16784 static const char *const arm_attr_tag_ABI_PCS_wchar_t
[] =
16785 {"None", "??? 1", "2", "??? 3", "4"};
16786 static const char *const arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
16787 static const char *const arm_attr_tag_ABI_FP_denormal
[] =
16788 {"Unused", "Needed", "Sign only"};
16789 static const char *const arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
16790 static const char *const arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
16791 static const char *const arm_attr_tag_ABI_FP_number_model
[] =
16792 {"Unused", "Finite", "RTABI", "IEEE 754"};
16793 static const char *const arm_attr_tag_ABI_enum_size
[] =
16794 {"Unused", "small", "int", "forced to int"};
16795 static const char *const arm_attr_tag_ABI_HardFP_use
[] =
16796 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
16797 static const char *const arm_attr_tag_ABI_VFP_args
[] =
16798 {"AAPCS", "VFP registers", "custom", "compatible"};
16799 static const char *const arm_attr_tag_ABI_WMMX_args
[] =
16800 {"AAPCS", "WMMX registers", "custom"};
16801 static const char *const arm_attr_tag_ABI_optimization_goals
[] =
16802 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
16803 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
16804 static const char *const arm_attr_tag_ABI_FP_optimization_goals
[] =
16805 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
16806 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
16807 static const char *const arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
16808 static const char *const arm_attr_tag_FP_HP_extension
[] =
16809 {"Not Allowed", "Allowed"};
16810 static const char *const arm_attr_tag_ABI_FP_16bit_format
[] =
16811 {"None", "IEEE 754", "Alternative Format"};
16812 static const char *const arm_attr_tag_DSP_extension
[] =
16813 {"Follow architecture", "Allowed"};
16814 static const char *const arm_attr_tag_MPextension_use
[] =
16815 {"Not Allowed", "Allowed"};
16816 static const char *const arm_attr_tag_DIV_use
[] =
16817 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
16818 "Allowed in v7-A with integer division extension"};
16819 static const char *const arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
16820 static const char *const arm_attr_tag_Virtualization_use
[] =
16821 {"Not Allowed", "TrustZone", "Virtualization Extensions",
16822 "TrustZone and Virtualization Extensions"};
16823 static const char *const arm_attr_tag_MPextension_use_legacy
[] =
16824 {"Not Allowed", "Allowed"};
16826 static const char *const arm_attr_tag_MVE_arch
[] =
16827 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
16829 static const char * arm_attr_tag_PAC_extension
[] =
16830 {"No PAC/AUT instructions",
16831 "PAC/AUT instructions permitted in the NOP space",
16832 "PAC/AUT instructions permitted in the NOP and in the non-NOP space"};
16834 static const char * arm_attr_tag_BTI_extension
[] =
16835 {"BTI instructions not permitted",
16836 "BTI instructions permitted in the NOP space",
16837 "BTI instructions permitted in the NOP and in the non-NOP space"};
16839 static const char * arm_attr_tag_BTI_use
[] =
16840 {"Compiled without branch target enforcement",
16841 "Compiled with branch target enforcement"};
16843 static const char * arm_attr_tag_PACRET_use
[] =
16844 {"Compiled without return address signing and authentication",
16845 "Compiled with return address signing and authentication"};
16847 #define LOOKUP(id, name) \
16848 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
16849 static arm_attr_public_tag arm_attr_public_tags
[] =
16851 {4, "CPU_raw_name", 1, NULL
},
16852 {5, "CPU_name", 1, NULL
},
16853 LOOKUP(6, CPU_arch
),
16854 {7, "CPU_arch_profile", 0, NULL
},
16855 LOOKUP(8, ARM_ISA_use
),
16856 LOOKUP(9, THUMB_ISA_use
),
16857 LOOKUP(10, FP_arch
),
16858 LOOKUP(11, WMMX_arch
),
16859 LOOKUP(12, Advanced_SIMD_arch
),
16860 LOOKUP(13, PCS_config
),
16861 LOOKUP(14, ABI_PCS_R9_use
),
16862 LOOKUP(15, ABI_PCS_RW_data
),
16863 LOOKUP(16, ABI_PCS_RO_data
),
16864 LOOKUP(17, ABI_PCS_GOT_use
),
16865 LOOKUP(18, ABI_PCS_wchar_t
),
16866 LOOKUP(19, ABI_FP_rounding
),
16867 LOOKUP(20, ABI_FP_denormal
),
16868 LOOKUP(21, ABI_FP_exceptions
),
16869 LOOKUP(22, ABI_FP_user_exceptions
),
16870 LOOKUP(23, ABI_FP_number_model
),
16871 {24, "ABI_align_needed", 0, NULL
},
16872 {25, "ABI_align_preserved", 0, NULL
},
16873 LOOKUP(26, ABI_enum_size
),
16874 LOOKUP(27, ABI_HardFP_use
),
16875 LOOKUP(28, ABI_VFP_args
),
16876 LOOKUP(29, ABI_WMMX_args
),
16877 LOOKUP(30, ABI_optimization_goals
),
16878 LOOKUP(31, ABI_FP_optimization_goals
),
16879 {32, "compatibility", 0, NULL
},
16880 LOOKUP(34, CPU_unaligned_access
),
16881 LOOKUP(36, FP_HP_extension
),
16882 LOOKUP(38, ABI_FP_16bit_format
),
16883 LOOKUP(42, MPextension_use
),
16884 LOOKUP(44, DIV_use
),
16885 LOOKUP(46, DSP_extension
),
16886 LOOKUP(48, MVE_arch
),
16887 LOOKUP(50, PAC_extension
),
16888 LOOKUP(52, BTI_extension
),
16889 LOOKUP(74, BTI_use
),
16890 LOOKUP(76, PACRET_use
),
16891 {64, "nodefaults", 0, NULL
},
16892 {65, "also_compatible_with", 0, NULL
},
16893 LOOKUP(66, T2EE_use
),
16894 {67, "conformance", 1, NULL
},
16895 LOOKUP(68, Virtualization_use
),
16896 LOOKUP(70, MPextension_use_legacy
)
16900 static unsigned char *
16901 display_arm_attribute (unsigned char * p
,
16902 const unsigned char * const end
)
16906 arm_attr_public_tag
* attr
;
16910 READ_ULEB (tag
, p
, end
);
16912 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
16914 if (arm_attr_public_tags
[i
].tag
== tag
)
16916 attr
= &arm_attr_public_tags
[i
];
16923 printf (" Tag_%s: ", attr
->name
);
16924 switch (attr
->type
)
16929 case 7: /* Tag_CPU_arch_profile. */
16930 READ_ULEB (val
, p
, end
);
16933 case 0: printf (_("None\n")); break;
16934 case 'A': printf (_("Application\n")); break;
16935 case 'R': printf (_("Realtime\n")); break;
16936 case 'M': printf (_("Microcontroller\n")); break;
16937 case 'S': printf (_("Application or Realtime\n")); break;
16938 default: printf ("??? (%d)\n", val
); break;
16942 case 24: /* Tag_align_needed. */
16943 READ_ULEB (val
, p
, end
);
16946 case 0: printf (_("None\n")); break;
16947 case 1: printf (_("8-byte\n")); break;
16948 case 2: printf (_("4-byte\n")); break;
16949 case 3: printf ("??? 3\n"); break;
16952 printf (_("8-byte and up to %d-byte extended\n"),
16955 printf ("??? (%d)\n", val
);
16960 case 25: /* Tag_align_preserved. */
16961 READ_ULEB (val
, p
, end
);
16964 case 0: printf (_("None\n")); break;
16965 case 1: printf (_("8-byte, except leaf SP\n")); break;
16966 case 2: printf (_("8-byte\n")); break;
16967 case 3: printf ("??? 3\n"); break;
16970 printf (_("8-byte and up to %d-byte extended\n"),
16973 printf ("??? (%d)\n", val
);
16978 case 32: /* Tag_compatibility. */
16980 READ_ULEB (val
, p
, end
);
16981 printf (_("flag = %d, vendor = "), val
);
16984 size_t maxlen
= (end
- p
) - 1;
16986 print_symbol ((int) maxlen
, (const char *) p
);
16987 p
+= strnlen ((char *) p
, maxlen
) + 1;
16991 printf (_("<corrupt>"));
16992 p
= (unsigned char *) end
;
16998 case 64: /* Tag_nodefaults. */
16999 /* PR 17531: file: 001-505008-0.01. */
17002 printf (_("True\n"));
17005 case 65: /* Tag_also_compatible_with. */
17006 READ_ULEB (val
, p
, end
);
17007 if (val
== 6 /* Tag_CPU_arch. */)
17009 READ_ULEB (val
, p
, end
);
17010 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
17011 printf ("??? (%d)\n", val
);
17013 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
17017 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
17022 printf (_("<unknown: %d>\n"), tag
);
17028 return display_tag_value (-1, p
, end
);
17030 return display_tag_value (0, p
, end
);
17033 assert (attr
->type
& 0x80);
17034 READ_ULEB (val
, p
, end
);
17035 type
= attr
->type
& 0x7f;
17037 printf ("??? (%d)\n", val
);
17039 printf ("%s\n", attr
->table
[val
]);
17044 return display_tag_value (tag
, p
, end
);
17047 static unsigned char *
17048 display_gnu_attribute (unsigned char * p
,
17049 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
17050 const unsigned char * const end
)
17055 READ_ULEB (tag
, p
, end
);
17057 /* Tag_compatibility is the only generic GNU attribute defined at
17061 READ_ULEB (val
, p
, end
);
17063 printf (_("flag = %d, vendor = "), val
);
17066 printf (_("<corrupt>\n"));
17067 warn (_("corrupt vendor attribute\n"));
17073 size_t maxlen
= (end
- p
) - 1;
17075 print_symbol ((int) maxlen
, (const char *) p
);
17076 p
+= strnlen ((char *) p
, maxlen
) + 1;
17080 printf (_("<corrupt>"));
17081 p
= (unsigned char *) end
;
17088 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
17089 return display_proc_gnu_attribute (p
, tag
, end
);
17091 return display_tag_value (tag
, p
, end
);
17094 static unsigned char *
17095 display_m68k_gnu_attribute (unsigned char * p
,
17097 const unsigned char * const end
)
17101 if (tag
== Tag_GNU_M68K_ABI_FP
)
17103 printf (" Tag_GNU_M68K_ABI_FP: ");
17106 printf (_("<corrupt>\n"));
17109 READ_ULEB (val
, p
, end
);
17112 printf ("(%#x), ", val
);
17117 printf (_("unspecified hard/soft float\n"));
17120 printf (_("hard float\n"));
17123 printf (_("soft float\n"));
17129 return display_tag_value (tag
& 1, p
, end
);
17132 static unsigned char *
17133 display_power_gnu_attribute (unsigned char * p
,
17135 const unsigned char * const end
)
17139 if (tag
== Tag_GNU_Power_ABI_FP
)
17141 printf (" Tag_GNU_Power_ABI_FP: ");
17144 printf (_("<corrupt>\n"));
17147 READ_ULEB (val
, p
, end
);
17150 printf ("(%#x), ", val
);
17155 printf (_("unspecified hard/soft float, "));
17158 printf (_("hard float, "));
17161 printf (_("soft float, "));
17164 printf (_("single-precision hard float, "));
17171 printf (_("unspecified long double\n"));
17174 printf (_("128-bit IBM long double\n"));
17177 printf (_("64-bit long double\n"));
17180 printf (_("128-bit IEEE long double\n"));
17186 if (tag
== Tag_GNU_Power_ABI_Vector
)
17188 printf (" Tag_GNU_Power_ABI_Vector: ");
17191 printf (_("<corrupt>\n"));
17194 READ_ULEB (val
, p
, end
);
17197 printf ("(%#x), ", val
);
17202 printf (_("unspecified\n"));
17205 printf (_("generic\n"));
17208 printf ("AltiVec\n");
17217 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
17219 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
17222 printf (_("<corrupt>\n"));
17225 READ_ULEB (val
, p
, end
);
17228 printf ("(%#x), ", val
);
17233 printf (_("unspecified\n"));
17236 printf ("r3/r4\n");
17239 printf (_("memory\n"));
17248 return display_tag_value (tag
& 1, p
, end
);
17251 static unsigned char *
17252 display_s390_gnu_attribute (unsigned char * p
,
17254 const unsigned char * const end
)
17258 if (tag
== Tag_GNU_S390_ABI_Vector
)
17260 printf (" Tag_GNU_S390_ABI_Vector: ");
17261 READ_ULEB (val
, p
, end
);
17266 printf (_("any\n"));
17269 printf (_("software\n"));
17272 printf (_("hardware\n"));
17275 printf ("??? (%d)\n", val
);
17281 return display_tag_value (tag
& 1, p
, end
);
17285 display_sparc_hwcaps (unsigned int mask
)
17291 if (mask
& ELF_SPARC_HWCAP_MUL32
)
17292 fputs ("mul32", stdout
), first
= false;
17293 if (mask
& ELF_SPARC_HWCAP_DIV32
)
17294 printf ("%sdiv32", first
? "" : "|"), first
= false;
17295 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
17296 printf ("%sfsmuld", first
? "" : "|"), first
= false;
17297 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
17298 printf ("%sv8plus", first
? "" : "|"), first
= false;
17299 if (mask
& ELF_SPARC_HWCAP_POPC
)
17300 printf ("%spopc", first
? "" : "|"), first
= false;
17301 if (mask
& ELF_SPARC_HWCAP_VIS
)
17302 printf ("%svis", first
? "" : "|"), first
= false;
17303 if (mask
& ELF_SPARC_HWCAP_VIS2
)
17304 printf ("%svis2", first
? "" : "|"), first
= false;
17305 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
17306 printf ("%sASIBlkInit", first
? "" : "|"), first
= false;
17307 if (mask
& ELF_SPARC_HWCAP_FMAF
)
17308 printf ("%sfmaf", first
? "" : "|"), first
= false;
17309 if (mask
& ELF_SPARC_HWCAP_VIS3
)
17310 printf ("%svis3", first
? "" : "|"), first
= false;
17311 if (mask
& ELF_SPARC_HWCAP_HPC
)
17312 printf ("%shpc", first
? "" : "|"), first
= false;
17313 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
17314 printf ("%srandom", first
? "" : "|"), first
= false;
17315 if (mask
& ELF_SPARC_HWCAP_TRANS
)
17316 printf ("%strans", first
? "" : "|"), first
= false;
17317 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
17318 printf ("%sfjfmau", first
? "" : "|"), first
= false;
17319 if (mask
& ELF_SPARC_HWCAP_IMA
)
17320 printf ("%sima", first
? "" : "|"), first
= false;
17321 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
17322 printf ("%scspare", first
? "" : "|"), first
= false;
17325 fputc ('0', stdout
);
17326 fputc ('\n', stdout
);
17330 display_sparc_hwcaps2 (unsigned int mask
)
17336 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
17337 fputs ("fjathplus", stdout
), first
= false;
17338 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
17339 printf ("%svis3b", first
? "" : "|"), first
= false;
17340 if (mask
& ELF_SPARC_HWCAP2_ADP
)
17341 printf ("%sadp", first
? "" : "|"), first
= false;
17342 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
17343 printf ("%ssparc5", first
? "" : "|"), first
= false;
17344 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
17345 printf ("%smwait", first
? "" : "|"), first
= false;
17346 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
17347 printf ("%sxmpmul", first
? "" : "|"), first
= false;
17348 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
17349 printf ("%sxmont2", first
? "" : "|"), first
= false;
17350 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
17351 printf ("%snsec", first
? "" : "|"), first
= false;
17352 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
17353 printf ("%sfjathhpc", first
? "" : "|"), first
= false;
17354 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
17355 printf ("%sfjdes", first
? "" : "|"), first
= false;
17356 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
17357 printf ("%sfjaes", first
? "" : "|"), first
= false;
17360 fputc ('0', stdout
);
17361 fputc ('\n', stdout
);
17364 static unsigned char *
17365 display_sparc_gnu_attribute (unsigned char * p
,
17367 const unsigned char * const end
)
17371 if (tag
== Tag_GNU_Sparc_HWCAPS
)
17373 READ_ULEB (val
, p
, end
);
17374 printf (" Tag_GNU_Sparc_HWCAPS: ");
17375 display_sparc_hwcaps (val
);
17378 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
17380 READ_ULEB (val
, p
, end
);
17381 printf (" Tag_GNU_Sparc_HWCAPS2: ");
17382 display_sparc_hwcaps2 (val
);
17386 return display_tag_value (tag
, p
, end
);
17390 print_mips_fp_abi_value (unsigned int val
)
17394 case Val_GNU_MIPS_ABI_FP_ANY
:
17395 printf (_("Hard or soft float\n"));
17397 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
17398 printf (_("Hard float (double precision)\n"));
17400 case Val_GNU_MIPS_ABI_FP_SINGLE
:
17401 printf (_("Hard float (single precision)\n"));
17403 case Val_GNU_MIPS_ABI_FP_SOFT
:
17404 printf (_("Soft float\n"));
17406 case Val_GNU_MIPS_ABI_FP_OLD_64
:
17407 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
17409 case Val_GNU_MIPS_ABI_FP_XX
:
17410 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
17412 case Val_GNU_MIPS_ABI_FP_64
:
17413 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
17415 case Val_GNU_MIPS_ABI_FP_64A
:
17416 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
17418 case Val_GNU_MIPS_ABI_FP_NAN2008
:
17419 printf (_("NaN 2008 compatibility\n"));
17422 printf ("??? (%d)\n", val
);
17427 static unsigned char *
17428 display_mips_gnu_attribute (unsigned char * p
,
17430 const unsigned char * const end
)
17432 if (tag
== Tag_GNU_MIPS_ABI_FP
)
17436 printf (" Tag_GNU_MIPS_ABI_FP: ");
17437 READ_ULEB (val
, p
, end
);
17438 print_mips_fp_abi_value (val
);
17442 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
17446 printf (" Tag_GNU_MIPS_ABI_MSA: ");
17447 READ_ULEB (val
, p
, end
);
17451 case Val_GNU_MIPS_ABI_MSA_ANY
:
17452 printf (_("Any MSA or not\n"));
17454 case Val_GNU_MIPS_ABI_MSA_128
:
17455 printf (_("128-bit MSA\n"));
17458 printf ("??? (%d)\n", val
);
17464 return display_tag_value (tag
& 1, p
, end
);
17467 static unsigned char *
17468 display_tic6x_attribute (unsigned char * p
,
17469 const unsigned char * const end
)
17474 READ_ULEB (tag
, p
, end
);
17479 printf (" Tag_ISA: ");
17480 READ_ULEB (val
, p
, end
);
17484 case C6XABI_Tag_ISA_none
:
17485 printf (_("None\n"));
17487 case C6XABI_Tag_ISA_C62X
:
17490 case C6XABI_Tag_ISA_C67X
:
17493 case C6XABI_Tag_ISA_C67XP
:
17494 printf ("C67x+\n");
17496 case C6XABI_Tag_ISA_C64X
:
17499 case C6XABI_Tag_ISA_C64XP
:
17500 printf ("C64x+\n");
17502 case C6XABI_Tag_ISA_C674X
:
17503 printf ("C674x\n");
17506 printf ("??? (%d)\n", val
);
17511 case Tag_ABI_wchar_t
:
17512 printf (" Tag_ABI_wchar_t: ");
17513 READ_ULEB (val
, p
, end
);
17517 printf (_("Not used\n"));
17520 printf (_("2 bytes\n"));
17523 printf (_("4 bytes\n"));
17526 printf ("??? (%d)\n", val
);
17531 case Tag_ABI_stack_align_needed
:
17532 printf (" Tag_ABI_stack_align_needed: ");
17533 READ_ULEB (val
, p
, end
);
17537 printf (_("8-byte\n"));
17540 printf (_("16-byte\n"));
17543 printf ("??? (%d)\n", val
);
17548 case Tag_ABI_stack_align_preserved
:
17549 READ_ULEB (val
, p
, end
);
17550 printf (" Tag_ABI_stack_align_preserved: ");
17554 printf (_("8-byte\n"));
17557 printf (_("16-byte\n"));
17560 printf ("??? (%d)\n", val
);
17566 READ_ULEB (val
, p
, end
);
17567 printf (" Tag_ABI_DSBT: ");
17571 printf (_("DSBT addressing not used\n"));
17574 printf (_("DSBT addressing used\n"));
17577 printf ("??? (%d)\n", val
);
17583 READ_ULEB (val
, p
, end
);
17584 printf (" Tag_ABI_PID: ");
17588 printf (_("Data addressing position-dependent\n"));
17591 printf (_("Data addressing position-independent, GOT near DP\n"));
17594 printf (_("Data addressing position-independent, GOT far from DP\n"));
17597 printf ("??? (%d)\n", val
);
17603 READ_ULEB (val
, p
, end
);
17604 printf (" Tag_ABI_PIC: ");
17608 printf (_("Code addressing position-dependent\n"));
17611 printf (_("Code addressing position-independent\n"));
17614 printf ("??? (%d)\n", val
);
17619 case Tag_ABI_array_object_alignment
:
17620 READ_ULEB (val
, p
, end
);
17621 printf (" Tag_ABI_array_object_alignment: ");
17625 printf (_("8-byte\n"));
17628 printf (_("4-byte\n"));
17631 printf (_("16-byte\n"));
17634 printf ("??? (%d)\n", val
);
17639 case Tag_ABI_array_object_align_expected
:
17640 READ_ULEB (val
, p
, end
);
17641 printf (" Tag_ABI_array_object_align_expected: ");
17645 printf (_("8-byte\n"));
17648 printf (_("4-byte\n"));
17651 printf (_("16-byte\n"));
17654 printf ("??? (%d)\n", val
);
17659 case Tag_ABI_compatibility
:
17661 READ_ULEB (val
, p
, end
);
17662 printf (" Tag_ABI_compatibility: ");
17663 printf (_("flag = %d, vendor = "), val
);
17666 size_t maxlen
= (end
- p
) - 1;
17668 print_symbol ((int) maxlen
, (const char *) p
);
17669 p
+= strnlen ((char *) p
, maxlen
) + 1;
17673 printf (_("<corrupt>"));
17674 p
= (unsigned char *) end
;
17680 case Tag_ABI_conformance
:
17682 printf (" Tag_ABI_conformance: \"");
17685 size_t maxlen
= (end
- p
) - 1;
17687 print_symbol ((int) maxlen
, (const char *) p
);
17688 p
+= strnlen ((char *) p
, maxlen
) + 1;
17692 printf (_("<corrupt>"));
17693 p
= (unsigned char *) end
;
17700 return display_tag_value (tag
, p
, end
);
17704 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
17707 size_t bytes
= end
- p
;
17714 int lbytes
= (bytes
> 16 ? 16 : bytes
);
17716 printf (" 0x%8.8" PRIx64
" ", addr
);
17718 for (j
= 0; j
< 16; j
++)
17721 printf ("%2.2x", p
[j
]);
17729 for (j
= 0; j
< lbytes
; j
++)
17732 if (k
>= ' ' && k
< 0x7f)
17748 static unsigned char *
17749 display_msp430_attribute (unsigned char * p
,
17750 const unsigned char * const end
)
17755 READ_ULEB (tag
, p
, end
);
17759 case OFBA_MSPABI_Tag_ISA
:
17760 printf (" Tag_ISA: ");
17761 READ_ULEB (val
, p
, end
);
17764 case 0: printf (_("None\n")); break;
17765 case 1: printf (_("MSP430\n")); break;
17766 case 2: printf (_("MSP430X\n")); break;
17767 default: printf ("??? (%" PRId64
")\n", val
); break;
17771 case OFBA_MSPABI_Tag_Code_Model
:
17772 printf (" Tag_Code_Model: ");
17773 READ_ULEB (val
, p
, end
);
17776 case 0: printf (_("None\n")); break;
17777 case 1: printf (_("Small\n")); break;
17778 case 2: printf (_("Large\n")); break;
17779 default: printf ("??? (%" PRId64
")\n", val
); break;
17783 case OFBA_MSPABI_Tag_Data_Model
:
17784 printf (" Tag_Data_Model: ");
17785 READ_ULEB (val
, p
, end
);
17788 case 0: printf (_("None\n")); break;
17789 case 1: printf (_("Small\n")); break;
17790 case 2: printf (_("Large\n")); break;
17791 case 3: printf (_("Restricted Large\n")); break;
17792 default: printf ("??? (%" PRId64
")\n", val
); break;
17797 printf (_(" <unknown tag %" PRId64
">: "), tag
);
17804 size_t maxlen
= (end
- p
) - 1;
17806 print_symbol ((int) maxlen
, (const char *) p
);
17807 p
+= strnlen ((char *) p
, maxlen
) + 1;
17811 printf (_("<corrupt>"));
17812 p
= (unsigned char *) end
;
17818 READ_ULEB (val
, p
, end
);
17819 printf ("%" PRId64
" (0x%" PRIx64
")\n", val
, val
);
17828 static unsigned char *
17829 display_msp430_gnu_attribute (unsigned char * p
,
17831 const unsigned char * const end
)
17833 if (tag
== Tag_GNU_MSP430_Data_Region
)
17837 printf (" Tag_GNU_MSP430_Data_Region: ");
17838 READ_ULEB (val
, p
, end
);
17842 case Val_GNU_MSP430_Data_Region_Any
:
17843 printf (_("Any Region\n"));
17845 case Val_GNU_MSP430_Data_Region_Lower
:
17846 printf (_("Lower Region Only\n"));
17849 printf ("??? (%" PRIu64
")\n", val
);
17853 return display_tag_value (tag
& 1, p
, end
);
17856 struct riscv_attr_tag_t
{
17861 static struct riscv_attr_tag_t riscv_attr_tag
[] =
17863 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
17866 T(priv_spec_minor
),
17867 T(priv_spec_revision
),
17868 T(unaligned_access
),
17873 static unsigned char *
17874 display_riscv_attribute (unsigned char *p
,
17875 const unsigned char * const end
)
17879 struct riscv_attr_tag_t
*attr
= NULL
;
17882 READ_ULEB (tag
, p
, end
);
17884 /* Find the name of attribute. */
17885 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
17887 if (riscv_attr_tag
[i
].tag
== tag
)
17889 attr
= &riscv_attr_tag
[i
];
17895 printf (" %s: ", attr
->name
);
17897 return display_tag_value (tag
, p
, end
);
17901 case Tag_RISCV_priv_spec
:
17902 case Tag_RISCV_priv_spec_minor
:
17903 case Tag_RISCV_priv_spec_revision
:
17904 READ_ULEB (val
, p
, end
);
17905 printf ("%" PRIu64
"\n", val
);
17907 case Tag_RISCV_unaligned_access
:
17908 READ_ULEB (val
, p
, end
);
17912 printf (_("No unaligned access\n"));
17915 printf (_("Unaligned access\n"));
17919 case Tag_RISCV_stack_align
:
17920 READ_ULEB (val
, p
, end
);
17921 printf (_("%" PRIu64
"-bytes\n"), val
);
17923 case Tag_RISCV_arch
:
17924 p
= display_tag_value (-1, p
, end
);
17927 return display_tag_value (tag
, p
, end
);
17933 static unsigned char *
17934 display_csky_attribute (unsigned char * p
,
17935 const unsigned char * const end
)
17939 READ_ULEB (tag
, p
, end
);
17941 if (tag
>= Tag_CSKY_MAX
)
17943 return display_tag_value (-1, p
, end
);
17948 case Tag_CSKY_ARCH_NAME
:
17949 printf (" Tag_CSKY_ARCH_NAME:\t\t");
17950 return display_tag_value (-1, p
, end
);
17951 case Tag_CSKY_CPU_NAME
:
17952 printf (" Tag_CSKY_CPU_NAME:\t\t");
17953 return display_tag_value (-1, p
, end
);
17955 case Tag_CSKY_ISA_FLAGS
:
17956 printf (" Tag_CSKY_ISA_FLAGS:\t\t");
17957 return display_tag_value (0, p
, end
);
17958 case Tag_CSKY_ISA_EXT_FLAGS
:
17959 printf (" Tag_CSKY_ISA_EXT_FLAGS:\t");
17960 return display_tag_value (0, p
, end
);
17962 case Tag_CSKY_DSP_VERSION
:
17963 printf (" Tag_CSKY_DSP_VERSION:\t\t");
17964 READ_ULEB (val
, p
, end
);
17965 if (val
== VAL_CSKY_DSP_VERSION_EXTENSION
)
17966 printf ("DSP Extension\n");
17967 else if (val
== VAL_CSKY_DSP_VERSION_2
)
17968 printf ("DSP 2.0\n");
17971 case Tag_CSKY_VDSP_VERSION
:
17972 printf (" Tag_CSKY_VDSP_VERSION:\t");
17973 READ_ULEB (val
, p
, end
);
17974 printf ("VDSP Version %" PRId64
"\n", val
);
17977 case Tag_CSKY_FPU_VERSION
:
17978 printf (" Tag_CSKY_FPU_VERSION:\t\t");
17979 READ_ULEB (val
, p
, end
);
17980 if (val
== VAL_CSKY_FPU_VERSION_1
)
17981 printf ("ABIV1 FPU Version 1\n");
17982 else if (val
== VAL_CSKY_FPU_VERSION_2
)
17983 printf ("FPU Version 2\n");
17986 case Tag_CSKY_FPU_ABI
:
17987 printf (" Tag_CSKY_FPU_ABI:\t\t");
17988 READ_ULEB (val
, p
, end
);
17989 if (val
== VAL_CSKY_FPU_ABI_HARD
)
17991 else if (val
== VAL_CSKY_FPU_ABI_SOFTFP
)
17992 printf ("SoftFP\n");
17993 else if (val
== VAL_CSKY_FPU_ABI_SOFT
)
17996 case Tag_CSKY_FPU_ROUNDING
:
17997 READ_ULEB (val
, p
, end
);
18000 printf (" Tag_CSKY_FPU_ROUNDING:\t");
18001 printf ("Needed\n");
18004 case Tag_CSKY_FPU_DENORMAL
:
18005 READ_ULEB (val
, p
, end
);
18008 printf (" Tag_CSKY_FPU_DENORMAL:\t");
18009 printf ("Needed\n");
18012 case Tag_CSKY_FPU_Exception
:
18013 READ_ULEB (val
, p
, end
);
18016 printf (" Tag_CSKY_FPU_Exception:\t");
18017 printf ("Needed\n");
18020 case Tag_CSKY_FPU_NUMBER_MODULE
:
18021 printf (" Tag_CSKY_FPU_NUMBER_MODULE:\t");
18022 return display_tag_value (-1, p
, end
);
18023 case Tag_CSKY_FPU_HARDFP
:
18024 printf (" Tag_CSKY_FPU_HARDFP:\t\t");
18025 READ_ULEB (val
, p
, end
);
18026 if (val
& VAL_CSKY_FPU_HARDFP_HALF
)
18028 if (val
& VAL_CSKY_FPU_HARDFP_SINGLE
)
18029 printf (" Single");
18030 if (val
& VAL_CSKY_FPU_HARDFP_DOUBLE
)
18031 printf (" Double");
18035 return display_tag_value (tag
, p
, end
);
18041 process_attributes (Filedata
* filedata
,
18042 const char * public_name
,
18043 unsigned int proc_type
,
18044 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
18045 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
18047 Elf_Internal_Shdr
* sect
;
18051 /* Find the section header so that we get the size. */
18052 for (i
= 0, sect
= filedata
->section_headers
;
18053 i
< filedata
->file_header
.e_shnum
;
18056 unsigned char * contents
;
18059 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
18062 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
18063 sect
->sh_size
, _("attributes"));
18064 if (contents
== NULL
)
18071 /* The first character is the version of the attributes.
18072 Currently only version 1, (aka 'A') is recognised here. */
18075 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
18080 uint64_t section_len
;
18082 section_len
= sect
->sh_size
- 1;
18085 while (section_len
> 0)
18088 unsigned int namelen
;
18089 bool public_section
;
18092 if (section_len
<= 4)
18094 error (_("Tag section ends prematurely\n"));
18098 attr_len
= byte_get (p
, 4);
18101 if (attr_len
> section_len
)
18103 error (_("Bad attribute length (%u > %u)\n"),
18104 (unsigned) attr_len
, (unsigned) section_len
);
18105 attr_len
= section_len
;
18108 /* PR 17531: file: 001-101425-0.004 */
18109 else if (attr_len
< 5)
18111 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
18116 section_len
-= attr_len
;
18119 namelen
= strnlen ((char *) p
, attr_len
) + 1;
18120 if (namelen
== 0 || namelen
>= attr_len
)
18122 error (_("Corrupt attribute section name\n"));
18127 printf (_("Attribute Section: "));
18128 print_symbol (INT_MAX
, (const char *) p
);
18131 if (public_name
&& streq ((char *) p
, public_name
))
18132 public_section
= true;
18134 public_section
= false;
18136 if (streq ((char *) p
, "gnu"))
18137 gnu_section
= true;
18139 gnu_section
= false;
18142 attr_len
-= namelen
;
18144 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
18149 unsigned char * end
;
18151 /* PR binutils/17531: Safe handling of corrupt files. */
18154 error (_("Unused bytes at end of section\n"));
18161 size
= byte_get (p
, 4);
18162 if (size
> attr_len
)
18164 error (_("Bad subsection length (%u > %u)\n"),
18165 (unsigned) size
, (unsigned) attr_len
);
18169 /* PR binutils/17531: Safe handling of corrupt files. */
18172 error (_("Bad subsection length (%u < 6)\n"),
18180 end
= p
+ size
- 1;
18181 assert (end
<= contents
+ sect
->sh_size
);
18187 printf (_("File Attributes\n"));
18190 printf (_("Section Attributes:"));
18193 printf (_("Symbol Attributes:"));
18194 /* Fall through. */
18198 READ_ULEB (val
, p
, end
);
18201 printf (" %d", val
);
18206 printf (_("Unknown tag: %d\n"), tag
);
18207 public_section
= false;
18211 if (public_section
&& display_pub_attribute
!= NULL
)
18214 p
= display_pub_attribute (p
, end
);
18217 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
18220 p
= display_gnu_attribute (p
,
18221 display_proc_gnu_attribute
,
18227 printf (_(" Unknown attribute:\n"));
18228 display_raw_attribute (p
, end
);
18243 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
18244 Print the Address, Access and Initial fields of an entry at VMA ADDR
18245 and return the VMA of the next entry, or -1 if there was a problem.
18246 Does not read from DATA_END or beyond. */
18249 print_mips_got_entry (unsigned char * data
, uint64_t pltgot
, uint64_t addr
,
18250 unsigned char * data_end
)
18253 print_vma (addr
, LONG_HEX
);
18255 if (addr
< pltgot
+ 0xfff0)
18256 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
18258 printf ("%10s", "");
18261 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
18265 unsigned char * from
= data
+ addr
- pltgot
;
18267 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
18269 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
18270 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
18271 return (uint64_t) -1;
18275 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
18276 print_vma (entry
, LONG_HEX
);
18279 return addr
+ (is_32bit_elf
? 4 : 8);
18282 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
18283 PLTGOT. Print the Address and Initial fields of an entry at VMA
18284 ADDR and return the VMA of the next entry. */
18287 print_mips_pltgot_entry (unsigned char * data
, uint64_t pltgot
, uint64_t addr
)
18290 print_vma (addr
, LONG_HEX
);
18293 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
18298 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
18299 print_vma (entry
, LONG_HEX
);
18301 return addr
+ (is_32bit_elf
? 4 : 8);
18305 print_mips_ases (unsigned int mask
)
18307 if (mask
& AFL_ASE_DSP
)
18308 fputs ("\n\tDSP ASE", stdout
);
18309 if (mask
& AFL_ASE_DSPR2
)
18310 fputs ("\n\tDSP R2 ASE", stdout
);
18311 if (mask
& AFL_ASE_DSPR3
)
18312 fputs ("\n\tDSP R3 ASE", stdout
);
18313 if (mask
& AFL_ASE_EVA
)
18314 fputs ("\n\tEnhanced VA Scheme", stdout
);
18315 if (mask
& AFL_ASE_MCU
)
18316 fputs ("\n\tMCU (MicroController) ASE", stdout
);
18317 if (mask
& AFL_ASE_MDMX
)
18318 fputs ("\n\tMDMX ASE", stdout
);
18319 if (mask
& AFL_ASE_MIPS3D
)
18320 fputs ("\n\tMIPS-3D ASE", stdout
);
18321 if (mask
& AFL_ASE_MT
)
18322 fputs ("\n\tMT ASE", stdout
);
18323 if (mask
& AFL_ASE_SMARTMIPS
)
18324 fputs ("\n\tSmartMIPS ASE", stdout
);
18325 if (mask
& AFL_ASE_VIRT
)
18326 fputs ("\n\tVZ ASE", stdout
);
18327 if (mask
& AFL_ASE_MSA
)
18328 fputs ("\n\tMSA ASE", stdout
);
18329 if (mask
& AFL_ASE_MIPS16
)
18330 fputs ("\n\tMIPS16 ASE", stdout
);
18331 if (mask
& AFL_ASE_MICROMIPS
)
18332 fputs ("\n\tMICROMIPS ASE", stdout
);
18333 if (mask
& AFL_ASE_XPA
)
18334 fputs ("\n\tXPA ASE", stdout
);
18335 if (mask
& AFL_ASE_MIPS16E2
)
18336 fputs ("\n\tMIPS16e2 ASE", stdout
);
18337 if (mask
& AFL_ASE_CRC
)
18338 fputs ("\n\tCRC ASE", stdout
);
18339 if (mask
& AFL_ASE_GINV
)
18340 fputs ("\n\tGINV ASE", stdout
);
18341 if (mask
& AFL_ASE_LOONGSON_MMI
)
18342 fputs ("\n\tLoongson MMI ASE", stdout
);
18343 if (mask
& AFL_ASE_LOONGSON_CAM
)
18344 fputs ("\n\tLoongson CAM ASE", stdout
);
18345 if (mask
& AFL_ASE_LOONGSON_EXT
)
18346 fputs ("\n\tLoongson EXT ASE", stdout
);
18347 if (mask
& AFL_ASE_LOONGSON_EXT2
)
18348 fputs ("\n\tLoongson EXT2 ASE", stdout
);
18350 fprintf (stdout
, "\n\t%s", _("None"));
18351 else if ((mask
& ~AFL_ASE_MASK
) != 0)
18352 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
18356 print_mips_isa_ext (unsigned int isa_ext
)
18361 fputs (_("None"), stdout
);
18364 fputs ("RMI XLR", stdout
);
18366 case AFL_EXT_OCTEON3
:
18367 fputs ("Cavium Networks Octeon3", stdout
);
18369 case AFL_EXT_OCTEON2
:
18370 fputs ("Cavium Networks Octeon2", stdout
);
18372 case AFL_EXT_OCTEONP
:
18373 fputs ("Cavium Networks OcteonP", stdout
);
18375 case AFL_EXT_OCTEON
:
18376 fputs ("Cavium Networks Octeon", stdout
);
18379 fputs ("Toshiba R5900", stdout
);
18382 fputs ("MIPS R4650", stdout
);
18385 fputs ("LSI R4010", stdout
);
18388 fputs ("NEC VR4100", stdout
);
18391 fputs ("Toshiba R3900", stdout
);
18393 case AFL_EXT_10000
:
18394 fputs ("MIPS R10000", stdout
);
18397 fputs ("Broadcom SB-1", stdout
);
18400 fputs ("NEC VR4111/VR4181", stdout
);
18403 fputs ("NEC VR4120", stdout
);
18406 fputs ("NEC VR5400", stdout
);
18409 fputs ("NEC VR5500", stdout
);
18411 case AFL_EXT_LOONGSON_2E
:
18412 fputs ("ST Microelectronics Loongson 2E", stdout
);
18414 case AFL_EXT_LOONGSON_2F
:
18415 fputs ("ST Microelectronics Loongson 2F", stdout
);
18417 case AFL_EXT_INTERAPTIV_MR2
:
18418 fputs ("Imagination interAptiv MR2", stdout
);
18421 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
18426 get_mips_reg_size (int reg_size
)
18428 return (reg_size
== AFL_REG_NONE
) ? 0
18429 : (reg_size
== AFL_REG_32
) ? 32
18430 : (reg_size
== AFL_REG_64
) ? 64
18431 : (reg_size
== AFL_REG_128
) ? 128
18436 process_mips_specific (Filedata
* filedata
)
18438 Elf_Internal_Dyn
* entry
;
18439 Elf_Internal_Shdr
*sect
= NULL
;
18440 size_t liblist_offset
= 0;
18441 size_t liblistno
= 0;
18442 size_t conflictsno
= 0;
18443 size_t options_offset
= 0;
18444 size_t conflicts_offset
= 0;
18445 size_t pltrelsz
= 0;
18447 uint64_t pltgot
= 0;
18448 uint64_t mips_pltgot
= 0;
18449 uint64_t jmprel
= 0;
18450 uint64_t local_gotno
= 0;
18451 uint64_t gotsym
= 0;
18452 uint64_t symtabno
= 0;
18455 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18456 display_mips_gnu_attribute
))
18459 sect
= find_section (filedata
, ".MIPS.abiflags");
18463 Elf_External_ABIFlags_v0
*abiflags_ext
;
18464 Elf_Internal_ABIFlags_v0 abiflags_in
;
18466 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
18468 error (_("Corrupt MIPS ABI Flags section.\n"));
18473 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
18474 sect
->sh_size
, _("MIPS ABI Flags section"));
18477 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
18478 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
18479 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
18480 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
18481 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
18482 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
18483 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
18484 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
18485 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
18486 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
18487 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
18489 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
18490 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
18491 if (abiflags_in
.isa_rev
> 1)
18492 printf ("r%d", abiflags_in
.isa_rev
);
18493 printf ("\nGPR size: %d",
18494 get_mips_reg_size (abiflags_in
.gpr_size
));
18495 printf ("\nCPR1 size: %d",
18496 get_mips_reg_size (abiflags_in
.cpr1_size
));
18497 printf ("\nCPR2 size: %d",
18498 get_mips_reg_size (abiflags_in
.cpr2_size
));
18499 fputs ("\nFP ABI: ", stdout
);
18500 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
18501 fputs ("ISA Extension: ", stdout
);
18502 print_mips_isa_ext (abiflags_in
.isa_ext
);
18503 fputs ("\nASEs:", stdout
);
18504 print_mips_ases (abiflags_in
.ases
);
18505 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
18506 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
18507 fputc ('\n', stdout
);
18508 free (abiflags_ext
);
18513 /* We have a lot of special sections. Thanks SGI! */
18514 if (filedata
->dynamic_section
== NULL
)
18516 /* No dynamic information available. See if there is static GOT. */
18517 sect
= find_section (filedata
, ".got");
18520 unsigned char *data_end
;
18521 unsigned char *data
;
18525 pltgot
= sect
->sh_addr
;
18528 addr_size
= (is_32bit_elf
? 4 : 8);
18529 end
= pltgot
+ sect
->sh_size
;
18531 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
18533 _("Global Offset Table data"));
18534 /* PR 12855: Null data is handled gracefully throughout. */
18535 data_end
= data
+ (end
- pltgot
);
18537 printf (_("\nStatic GOT:\n"));
18538 printf (_(" Canonical gp value: "));
18539 print_vma (ent
+ 0x7ff0, LONG_HEX
);
18542 /* In a dynamic binary GOT[0] is reserved for the dynamic
18543 loader to store the lazy resolver pointer, however in
18544 a static binary it may well have been omitted and GOT
18545 reduced to a table of addresses.
18546 PR 21344: Check for the entry being fully available
18547 before fetching it. */
18549 && data
+ ent
- pltgot
+ addr_size
<= data_end
18550 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
18552 printf (_(" Reserved entries:\n"));
18553 printf (_(" %*s %10s %*s\n"),
18554 addr_size
* 2, _("Address"), _("Access"),
18555 addr_size
* 2, _("Value"));
18556 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18558 if (ent
== (uint64_t) -1)
18559 goto sgot_print_fail
;
18561 /* Check for the MSB of GOT[1] being set, identifying a
18562 GNU object. This entry will be used by some runtime
18563 loaders, to store the module pointer. Otherwise this
18564 is an ordinary local entry.
18565 PR 21344: Check for the entry being fully available
18566 before fetching it. */
18568 && data
+ ent
- pltgot
+ addr_size
<= data_end
18569 && (byte_get (data
+ ent
- pltgot
, addr_size
)
18570 >> (addr_size
* 8 - 1)) != 0)
18572 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18574 if (ent
== (uint64_t) -1)
18575 goto sgot_print_fail
;
18580 if (data
!= NULL
&& ent
< end
)
18582 printf (_(" Local entries:\n"));
18583 printf (" %*s %10s %*s\n",
18584 addr_size
* 2, _("Address"), _("Access"),
18585 addr_size
* 2, _("Value"));
18588 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18590 if (ent
== (uint64_t) -1)
18591 goto sgot_print_fail
;
18602 for (entry
= filedata
->dynamic_section
;
18603 /* PR 17531 file: 012-50589-0.004. */
18604 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
18605 && entry
->d_tag
!= DT_NULL
);
18607 switch (entry
->d_tag
)
18609 case DT_MIPS_LIBLIST
:
18611 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
18612 liblistno
* sizeof (Elf32_External_Lib
));
18614 case DT_MIPS_LIBLISTNO
:
18615 liblistno
= entry
->d_un
.d_val
;
18617 case DT_MIPS_OPTIONS
:
18618 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
18620 case DT_MIPS_CONFLICT
:
18622 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
18623 conflictsno
* sizeof (Elf32_External_Conflict
));
18625 case DT_MIPS_CONFLICTNO
:
18626 conflictsno
= entry
->d_un
.d_val
;
18629 pltgot
= entry
->d_un
.d_ptr
;
18631 case DT_MIPS_LOCAL_GOTNO
:
18632 local_gotno
= entry
->d_un
.d_val
;
18634 case DT_MIPS_GOTSYM
:
18635 gotsym
= entry
->d_un
.d_val
;
18637 case DT_MIPS_SYMTABNO
:
18638 symtabno
= entry
->d_un
.d_val
;
18640 case DT_MIPS_PLTGOT
:
18641 mips_pltgot
= entry
->d_un
.d_ptr
;
18644 pltrel
= entry
->d_un
.d_val
;
18647 pltrelsz
= entry
->d_un
.d_val
;
18650 jmprel
= entry
->d_un
.d_ptr
;
18656 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
18658 Elf32_External_Lib
* elib
;
18661 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
18662 sizeof (Elf32_External_Lib
),
18664 _("liblist section data"));
18667 printf (ngettext ("\nSection '.liblist' contains %zu entry:\n",
18668 "\nSection '.liblist' contains %zu entries:\n",
18671 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
18674 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
18681 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
18682 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
18683 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
18684 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
18685 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
18687 tmp
= gmtime (&atime
);
18688 snprintf (timebuf
, sizeof (timebuf
),
18689 "%04u-%02u-%02uT%02u:%02u:%02u",
18690 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
18691 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
18693 printf ("%3zu: ", cnt
);
18694 if (valid_dynamic_name (filedata
, liblist
.l_name
))
18695 print_symbol (20, get_dynamic_name (filedata
, liblist
.l_name
));
18697 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
18698 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
18699 liblist
.l_version
);
18701 if (liblist
.l_flags
== 0)
18705 static const struct
18712 { " EXACT_MATCH", LL_EXACT_MATCH
},
18713 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
18714 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
18715 { " EXPORTS", LL_EXPORTS
},
18716 { " DELAY_LOAD", LL_DELAY_LOAD
},
18717 { " DELTA", LL_DELTA
}
18719 int flags
= liblist
.l_flags
;
18722 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
18723 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
18725 fputs (l_flags_vals
[fcnt
].name
, stdout
);
18726 flags
^= l_flags_vals
[fcnt
].bit
;
18729 printf (" %#x", (unsigned int) flags
);
18741 if (options_offset
!= 0)
18743 Elf_External_Options
* eopt
;
18747 /* Find the section header so that we get the size. */
18748 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
18749 /* PR 17533 file: 012-277276-0.004. */
18752 error (_("No MIPS_OPTIONS header found\n"));
18756 if (sect
->sh_size
< sizeof (* eopt
))
18758 error (_("The MIPS options section is too small.\n"));
18762 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
18763 sect
->sh_size
, _("options"));
18766 Elf_Internal_Options option
;
18769 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
18771 Elf_External_Options
* eoption
;
18772 unsigned int optsize
;
18774 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
18776 optsize
= BYTE_GET (eoption
->size
);
18778 /* PR 17531: file: ffa0fa3b. */
18779 if (optsize
< sizeof (* eopt
)
18780 || optsize
> sect
->sh_size
- offset
)
18782 error (_("Invalid size (%u) for MIPS option\n"),
18791 printf (ngettext ("\nSection '%s' contains %d entry:\n",
18792 "\nSection '%s' contains %d entries:\n",
18794 printable_section_name (filedata
, sect
), cnt
);
18800 Elf_External_Options
* eoption
;
18802 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
18804 option
.kind
= BYTE_GET (eoption
->kind
);
18805 option
.size
= BYTE_GET (eoption
->size
);
18806 option
.section
= BYTE_GET (eoption
->section
);
18807 option
.info
= BYTE_GET (eoption
->info
);
18809 switch (option
.kind
)
18812 /* This shouldn't happen. */
18813 printf (" NULL %" PRId16
" %" PRIx32
,
18814 option
.section
, option
.info
);
18818 printf (" REGINFO ");
18819 if (filedata
->file_header
.e_machine
== EM_MIPS
)
18821 Elf32_External_RegInfo
* ereg
;
18822 Elf32_RegInfo reginfo
;
18825 if (option
.size
< (sizeof (Elf_External_Options
)
18826 + sizeof (Elf32_External_RegInfo
)))
18828 printf (_("<corrupt>\n"));
18829 error (_("Truncated MIPS REGINFO option\n"));
18834 ereg
= (Elf32_External_RegInfo
*) (eoption
+ 1);
18836 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
18837 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
18838 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
18839 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
18840 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
18841 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
18843 printf ("GPR %08" PRIx32
" GP 0x%" PRIx32
"\n",
18844 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
18846 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
18847 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
18848 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
18849 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
18854 Elf64_External_RegInfo
* ereg
;
18855 Elf64_Internal_RegInfo reginfo
;
18857 if (option
.size
< (sizeof (Elf_External_Options
)
18858 + sizeof (Elf64_External_RegInfo
)))
18860 printf (_("<corrupt>\n"));
18861 error (_("Truncated MIPS REGINFO option\n"));
18866 ereg
= (Elf64_External_RegInfo
*) (eoption
+ 1);
18867 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
18868 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
18869 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
18870 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
18871 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
18872 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
18874 printf ("GPR %08" PRIx32
" GP 0x%" PRIx64
"\n",
18875 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
18877 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
18878 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
18879 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
18880 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
18882 offset
+= option
.size
;
18885 case ODK_EXCEPTIONS
:
18886 fputs (" EXCEPTIONS fpe_min(", stdout
);
18887 process_mips_fpe_exception (option
.info
& OEX_FPU_MIN
);
18888 fputs (") fpe_max(", stdout
);
18889 process_mips_fpe_exception ((option
.info
& OEX_FPU_MAX
) >> 8);
18890 fputs (")", stdout
);
18892 if (option
.info
& OEX_PAGE0
)
18893 fputs (" PAGE0", stdout
);
18894 if (option
.info
& OEX_SMM
)
18895 fputs (" SMM", stdout
);
18896 if (option
.info
& OEX_FPDBUG
)
18897 fputs (" FPDBUG", stdout
);
18898 if (option
.info
& OEX_DISMISS
)
18899 fputs (" DISMISS", stdout
);
18903 fputs (" PAD ", stdout
);
18904 if (option
.info
& OPAD_PREFIX
)
18905 fputs (" PREFIX", stdout
);
18906 if (option
.info
& OPAD_POSTFIX
)
18907 fputs (" POSTFIX", stdout
);
18908 if (option
.info
& OPAD_SYMBOL
)
18909 fputs (" SYMBOL", stdout
);
18913 fputs (" HWPATCH ", stdout
);
18914 if (option
.info
& OHW_R4KEOP
)
18915 fputs (" R4KEOP", stdout
);
18916 if (option
.info
& OHW_R8KPFETCH
)
18917 fputs (" R8KPFETCH", stdout
);
18918 if (option
.info
& OHW_R5KEOP
)
18919 fputs (" R5KEOP", stdout
);
18920 if (option
.info
& OHW_R5KCVTL
)
18921 fputs (" R5KCVTL", stdout
);
18925 fputs (" FILL ", stdout
);
18926 /* XXX Print content of info word? */
18930 fputs (" TAGS ", stdout
);
18931 /* XXX Print content of info word? */
18935 fputs (" HWAND ", stdout
);
18936 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
18937 fputs (" R4KEOP_CHECKED", stdout
);
18938 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
18939 fputs (" R4KEOP_CLEAN", stdout
);
18943 fputs (" HWOR ", stdout
);
18944 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
18945 fputs (" R4KEOP_CHECKED", stdout
);
18946 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
18947 fputs (" R4KEOP_CLEAN", stdout
);
18951 printf (" GP_GROUP %#06x self-contained %#06x",
18952 option
.info
& OGP_GROUP
,
18953 (option
.info
& OGP_SELF
) >> 16);
18957 printf (" IDENT %#06x self-contained %#06x",
18958 option
.info
& OGP_GROUP
,
18959 (option
.info
& OGP_SELF
) >> 16);
18963 /* This shouldn't happen. */
18964 printf (" %3d ??? %" PRId16
" %" PRIx32
,
18965 option
.kind
, option
.section
, option
.info
);
18969 len
= sizeof (* eopt
);
18970 while (len
< option
.size
)
18972 unsigned char datum
= *((unsigned char *) eoption
+ len
);
18974 if (ISPRINT (datum
))
18975 printf ("%c", datum
);
18977 printf ("\\%03o", datum
);
18980 fputs ("\n", stdout
);
18982 offset
+= option
.size
;
18990 if (conflicts_offset
!= 0 && conflictsno
!= 0)
18992 Elf32_Conflict
* iconf
;
18995 if (filedata
->dynamic_symbols
== NULL
)
18997 error (_("conflict list found without a dynamic symbol table\n"));
19001 /* PR 21345 - print a slightly more helpful error message
19002 if we are sure that the cmalloc will fail. */
19003 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
19005 error (_("Overlarge number of conflicts detected: %zx\n"),
19010 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
19013 error (_("Out of memory allocating space for dynamic conflicts\n"));
19019 Elf32_External_Conflict
* econf32
;
19021 econf32
= (Elf32_External_Conflict
*)
19022 get_data (NULL
, filedata
, conflicts_offset
,
19023 sizeof (*econf32
), conflictsno
, _("conflict"));
19030 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
19031 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
19037 Elf64_External_Conflict
* econf64
;
19039 econf64
= (Elf64_External_Conflict
*)
19040 get_data (NULL
, filedata
, conflicts_offset
,
19041 sizeof (*econf64
), conflictsno
, _("conflict"));
19048 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
19049 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
19054 printf (ngettext ("\nSection '.conflict' contains %zu entry:\n",
19055 "\nSection '.conflict' contains %zu entries:\n",
19058 puts (_(" Num: Index Value Name"));
19060 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
19062 printf ("%5zu: %8lu ", cnt
, iconf
[cnt
]);
19064 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
19065 printf (_("<corrupt symbol index>"));
19068 Elf_Internal_Sym
* psym
;
19070 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
19071 print_vma (psym
->st_value
, FULL_HEX
);
19073 if (valid_dynamic_name (filedata
, psym
->st_name
))
19074 print_symbol (25, get_dynamic_name (filedata
, psym
->st_name
));
19076 printf (_("<corrupt: %14ld>"), psym
->st_name
);
19084 if (pltgot
!= 0 && local_gotno
!= 0)
19086 uint64_t ent
, local_end
, global_end
;
19088 unsigned char * data
;
19089 unsigned char * data_end
;
19093 addr_size
= (is_32bit_elf
? 4 : 8);
19094 local_end
= pltgot
+ local_gotno
* addr_size
;
19096 /* PR binutils/17533 file: 012-111227-0.004 */
19097 if (symtabno
< gotsym
)
19099 error (_("The GOT symbol offset (%" PRIu64
19100 ") is greater than the symbol table size (%" PRIu64
")\n"),
19105 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
19106 /* PR 17531: file: 54c91a34. */
19107 if (global_end
< local_end
)
19109 error (_("Too many GOT symbols: %" PRIu64
"\n"), symtabno
);
19113 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
19114 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
19115 global_end
- pltgot
, 1,
19116 _("Global Offset Table data"));
19117 /* PR 12855: Null data is handled gracefully throughout. */
19118 data_end
= data
+ (global_end
- pltgot
);
19120 printf (_("\nPrimary GOT:\n"));
19121 printf (_(" Canonical gp value: "));
19122 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
19125 printf (_(" Reserved entries:\n"));
19126 printf (_(" %*s %10s %*s Purpose\n"),
19127 addr_size
* 2, _("Address"), _("Access"),
19128 addr_size
* 2, _("Initial"));
19129 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19130 printf (_(" Lazy resolver\n"));
19131 if (ent
== (uint64_t) -1)
19132 goto got_print_fail
;
19134 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
19135 This entry will be used by some runtime loaders, to store the
19136 module pointer. Otherwise this is an ordinary local entry.
19137 PR 21344: Check for the entry being fully available before
19140 && data
+ ent
- pltgot
+ addr_size
<= data_end
19141 && (byte_get (data
+ ent
- pltgot
, addr_size
)
19142 >> (addr_size
* 8 - 1)) != 0)
19144 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19145 printf (_(" Module pointer (GNU extension)\n"));
19146 if (ent
== (uint64_t) -1)
19147 goto got_print_fail
;
19151 if (data
!= NULL
&& ent
< local_end
)
19153 printf (_(" Local entries:\n"));
19154 printf (" %*s %10s %*s\n",
19155 addr_size
* 2, _("Address"), _("Access"),
19156 addr_size
* 2, _("Initial"));
19157 while (ent
< local_end
)
19159 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19161 if (ent
== (uint64_t) -1)
19162 goto got_print_fail
;
19167 if (data
!= NULL
&& gotsym
< symtabno
)
19171 printf (_(" Global entries:\n"));
19172 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
19173 addr_size
* 2, _("Address"),
19175 addr_size
* 2, _("Initial"),
19176 addr_size
* 2, _("Sym.Val."),
19178 /* Note for translators: "Ndx" = abbreviated form of "Index". */
19179 _("Ndx"), _("Name"));
19181 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
19183 for (i
= gotsym
; i
< symtabno
; i
++)
19185 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19188 if (filedata
->dynamic_symbols
== NULL
)
19189 printf (_("<no dynamic symbols>"));
19190 else if (i
< filedata
->num_dynamic_syms
)
19192 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
19194 print_vma (psym
->st_value
, LONG_HEX
);
19195 printf (" %-7s %3s ",
19196 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
19197 get_symbol_index_type (filedata
, psym
->st_shndx
));
19199 if (valid_dynamic_name (filedata
, psym
->st_name
))
19200 print_symbol (sym_width
,
19201 get_dynamic_name (filedata
, psym
->st_name
));
19203 printf (_("<corrupt: %14ld>"), psym
->st_name
);
19206 printf (_("<symbol index %zu exceeds number of dynamic symbols>"),
19210 if (ent
== (uint64_t) -1)
19220 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
19223 uint64_t offset
, rel_offset
;
19225 unsigned char * data
;
19226 int addr_size
, sym_width
;
19227 Elf_Internal_Rela
* rels
;
19229 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
19230 if (pltrel
== DT_RELA
)
19232 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
19237 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
19242 addr_size
= (is_32bit_elf
? 4 : 8);
19243 end
= mips_pltgot
+ (2 + count
) * addr_size
;
19245 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
19246 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
19247 1, _("Procedure Linkage Table data"));
19254 printf ("\nPLT GOT:\n\n");
19255 printf (_(" Reserved entries:\n"));
19256 printf (_(" %*s %*s Purpose\n"),
19257 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
19258 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
19259 printf (_(" PLT lazy resolver\n"));
19260 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
19261 printf (_(" Module pointer\n"));
19264 printf (_(" Entries:\n"));
19265 printf (" %*s %*s %*s %-7s %3s %s\n",
19266 addr_size
* 2, _("Address"),
19267 addr_size
* 2, _("Initial"),
19268 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
19269 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
19270 for (i
= 0; i
< count
; i
++)
19272 uint64_t idx
= get_reloc_symindex (rels
[i
].r_info
);
19274 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
19277 if (idx
>= filedata
->num_dynamic_syms
)
19278 printf (_("<corrupt symbol index: %" PRIu64
">"), idx
);
19281 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
19283 print_vma (psym
->st_value
, LONG_HEX
);
19284 printf (" %-7s %3s ",
19285 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
19286 get_symbol_index_type (filedata
, psym
->st_shndx
));
19287 if (valid_dynamic_name (filedata
, psym
->st_name
))
19288 print_symbol (sym_width
,
19289 get_dynamic_name (filedata
, psym
->st_name
));
19291 printf (_("<corrupt: %14ld>"), psym
->st_name
);
19305 process_nds32_specific (Filedata
* filedata
)
19307 Elf_Internal_Shdr
*sect
= NULL
;
19309 sect
= find_section (filedata
, ".nds32_e_flags");
19310 if (sect
!= NULL
&& sect
->sh_size
>= 4)
19312 unsigned char *buf
;
19315 printf ("\nNDS32 elf flags section:\n");
19316 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
19317 _("NDS32 elf flags section"));
19322 flag
= byte_get (buf
, 4);
19324 switch (flag
& 0x3)
19327 printf ("(VEC_SIZE):\tNo entry.\n");
19330 printf ("(VEC_SIZE):\t4 bytes\n");
19333 printf ("(VEC_SIZE):\t16 bytes\n");
19336 printf ("(VEC_SIZE):\treserved\n");
19345 process_gnu_liblist (Filedata
* filedata
)
19347 Elf_Internal_Shdr
* section
;
19348 Elf_Internal_Shdr
* string_sec
;
19349 Elf32_External_Lib
* elib
;
19351 size_t strtab_size
;
19353 uint64_t num_liblist
;
19360 for (i
= 0, section
= filedata
->section_headers
;
19361 i
< filedata
->file_header
.e_shnum
;
19364 switch (section
->sh_type
)
19366 case SHT_GNU_LIBLIST
:
19367 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
19370 elib
= (Elf32_External_Lib
*)
19371 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
19372 _("liblist section data"));
19380 string_sec
= filedata
->section_headers
+ section
->sh_link
;
19381 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
19382 string_sec
->sh_size
,
19383 _("liblist string table"));
19385 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
19392 strtab_size
= string_sec
->sh_size
;
19394 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
19395 printf (ngettext ("\nLibrary list section '%s' contains %" PRIu64
19397 "\nLibrary list section '%s' contains %" PRIu64
19400 printable_section_name (filedata
, section
),
19403 puts (_(" Library Time Stamp Checksum Version Flags"));
19405 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
19413 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
19414 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
19415 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
19416 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
19417 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
19419 tmp
= gmtime (&atime
);
19420 snprintf (timebuf
, sizeof (timebuf
),
19421 "%04u-%02u-%02uT%02u:%02u:%02u",
19422 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
19423 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
19425 printf ("%3zu: ", cnt
);
19427 printf ("%-20s", liblist
.l_name
< strtab_size
19428 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
19430 printf ("%-20.20s", liblist
.l_name
< strtab_size
19431 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
19432 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
19433 liblist
.l_version
, liblist
.l_flags
);
19444 static const char *
19445 get_note_type (Filedata
* filedata
, unsigned e_type
)
19447 static char buff
[64];
19449 if (filedata
->file_header
.e_type
== ET_CORE
)
19453 return _("NT_AUXV (auxiliary vector)");
19455 return _("NT_PRSTATUS (prstatus structure)");
19457 return _("NT_FPREGSET (floating point registers)");
19459 return _("NT_PRPSINFO (prpsinfo structure)");
19460 case NT_TASKSTRUCT
:
19461 return _("NT_TASKSTRUCT (task structure)");
19463 return _("NT_GDB_TDESC (GDB XML target description)");
19465 return _("NT_PRXFPREG (user_xfpregs structure)");
19467 return _("NT_PPC_VMX (ppc Altivec registers)");
19469 return _("NT_PPC_VSX (ppc VSX registers)");
19471 return _("NT_PPC_TAR (ppc TAR register)");
19473 return _("NT_PPC_PPR (ppc PPR register)");
19475 return _("NT_PPC_DSCR (ppc DSCR register)");
19477 return _("NT_PPC_EBB (ppc EBB registers)");
19479 return _("NT_PPC_PMU (ppc PMU registers)");
19480 case NT_PPC_TM_CGPR
:
19481 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
19482 case NT_PPC_TM_CFPR
:
19483 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
19484 case NT_PPC_TM_CVMX
:
19485 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
19486 case NT_PPC_TM_CVSX
:
19487 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
19488 case NT_PPC_TM_SPR
:
19489 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
19490 case NT_PPC_TM_CTAR
:
19491 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
19492 case NT_PPC_TM_CPPR
:
19493 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
19494 case NT_PPC_TM_CDSCR
:
19495 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
19497 return _("NT_386_TLS (x86 TLS information)");
19498 case NT_386_IOPERM
:
19499 return _("NT_386_IOPERM (x86 I/O permissions)");
19500 case NT_X86_XSTATE
:
19501 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
19503 return _("NT_X86_CET (x86 CET state)");
19504 case NT_S390_HIGH_GPRS
:
19505 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
19506 case NT_S390_TIMER
:
19507 return _("NT_S390_TIMER (s390 timer register)");
19508 case NT_S390_TODCMP
:
19509 return _("NT_S390_TODCMP (s390 TOD comparator register)");
19510 case NT_S390_TODPREG
:
19511 return _("NT_S390_TODPREG (s390 TOD programmable register)");
19513 return _("NT_S390_CTRS (s390 control registers)");
19514 case NT_S390_PREFIX
:
19515 return _("NT_S390_PREFIX (s390 prefix register)");
19516 case NT_S390_LAST_BREAK
:
19517 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
19518 case NT_S390_SYSTEM_CALL
:
19519 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
19521 return _("NT_S390_TDB (s390 transaction diagnostic block)");
19522 case NT_S390_VXRS_LOW
:
19523 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
19524 case NT_S390_VXRS_HIGH
:
19525 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
19526 case NT_S390_GS_CB
:
19527 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
19528 case NT_S390_GS_BC
:
19529 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
19531 return _("NT_ARM_VFP (arm VFP registers)");
19533 return _("NT_ARM_TLS (AArch TLS registers)");
19534 case NT_ARM_HW_BREAK
:
19535 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
19536 case NT_ARM_HW_WATCH
:
19537 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
19538 case NT_ARM_SYSTEM_CALL
:
19539 return _("NT_ARM_SYSTEM_CALL (AArch system call number)");
19541 return _("NT_ARM_SVE (AArch SVE registers)");
19542 case NT_ARM_PAC_MASK
:
19543 return _("NT_ARM_PAC_MASK (AArch pointer authentication code masks)");
19544 case NT_ARM_PACA_KEYS
:
19545 return _("NT_ARM_PACA_KEYS (ARM pointer authentication address keys)");
19546 case NT_ARM_PACG_KEYS
:
19547 return _("NT_ARM_PACG_KEYS (ARM pointer authentication generic keys)");
19548 case NT_ARM_TAGGED_ADDR_CTRL
:
19549 return _("NT_ARM_TAGGED_ADDR_CTRL (AArch tagged address control)");
19551 return _("NT_ARM_SSVE (AArch64 streaming SVE registers)");
19553 return _("NT_ARM_ZA (AArch64 SME ZA register)");
19554 case NT_ARM_PAC_ENABLED_KEYS
:
19555 return _("NT_ARM_PAC_ENABLED_KEYS (AArch64 pointer authentication enabled keys)");
19557 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
19559 return _("NT_RISCV_CSR (RISC-V control and status registers)");
19561 return _("NT_PSTATUS (pstatus structure)");
19563 return _("NT_FPREGS (floating point registers)");
19565 return _("NT_PSINFO (psinfo structure)");
19567 return _("NT_LWPSTATUS (lwpstatus_t structure)");
19569 return _("NT_LWPSINFO (lwpsinfo_t structure)");
19570 case NT_WIN32PSTATUS
:
19571 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
19573 return _("NT_SIGINFO (siginfo_t data)");
19575 return _("NT_FILE (mapped files)");
19583 return _("NT_VERSION (version)");
19585 return _("NT_ARCH (architecture)");
19586 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
19588 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
19590 case NT_GO_BUILDID
:
19591 return _("GO BUILDID");
19592 case FDO_PACKAGING_METADATA
:
19593 return _("FDO_PACKAGING_METADATA");
19598 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19603 print_core_note (Elf_Internal_Note
*pnote
)
19605 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
19606 uint64_t count
, page_size
;
19607 unsigned char *descdata
, *filenames
, *descend
;
19609 if (pnote
->type
!= NT_FILE
)
19618 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
19619 /* Still "successful". */
19623 if (pnote
->descsz
< 2 * addr_size
)
19625 error (_(" Malformed note - too short for header\n"));
19629 descdata
= (unsigned char *) pnote
->descdata
;
19630 descend
= descdata
+ pnote
->descsz
;
19632 if (descdata
[pnote
->descsz
- 1] != '\0')
19634 error (_(" Malformed note - does not end with \\0\n"));
19638 count
= byte_get (descdata
, addr_size
);
19639 descdata
+= addr_size
;
19641 page_size
= byte_get (descdata
, addr_size
);
19642 descdata
+= addr_size
;
19644 if (count
> ((uint64_t) -1 - 2 * addr_size
) / (3 * addr_size
)
19645 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
19647 error (_(" Malformed note - too short for supplied file count\n"));
19651 printf (_(" Page size: "));
19652 print_vma (page_size
, DEC
);
19655 printf (_(" %*s%*s%*s\n"),
19656 (int) (2 + 2 * addr_size
), _("Start"),
19657 (int) (4 + 2 * addr_size
), _("End"),
19658 (int) (4 + 2 * addr_size
), _("Page Offset"));
19659 filenames
= descdata
+ count
* 3 * addr_size
;
19660 while (count
-- > 0)
19662 uint64_t start
, end
, file_ofs
;
19664 if (filenames
== descend
)
19666 error (_(" Malformed note - filenames end too early\n"));
19670 start
= byte_get (descdata
, addr_size
);
19671 descdata
+= addr_size
;
19672 end
= byte_get (descdata
, addr_size
);
19673 descdata
+= addr_size
;
19674 file_ofs
= byte_get (descdata
, addr_size
);
19675 descdata
+= addr_size
;
19678 print_vma (start
, FULL_HEX
);
19680 print_vma (end
, FULL_HEX
);
19682 print_vma (file_ofs
, FULL_HEX
);
19683 printf ("\n %s\n", filenames
);
19685 filenames
+= 1 + strlen ((char *) filenames
);
19691 static const char *
19692 get_gnu_elf_note_type (unsigned e_type
)
19694 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
19697 case NT_GNU_ABI_TAG
:
19698 return _("NT_GNU_ABI_TAG (ABI version tag)");
19700 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
19701 case NT_GNU_BUILD_ID
:
19702 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
19703 case NT_GNU_GOLD_VERSION
:
19704 return _("NT_GNU_GOLD_VERSION (gold version)");
19705 case NT_GNU_PROPERTY_TYPE_0
:
19706 return _("NT_GNU_PROPERTY_TYPE_0");
19707 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
19708 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
19709 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
19710 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
19713 static char buff
[64];
19715 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19722 decode_x86_compat_isa (unsigned int bitmask
)
19726 unsigned int bit
= bitmask
& (- bitmask
);
19731 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
19734 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
19737 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
19740 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
19743 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
19746 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
19749 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
19752 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
19755 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
19758 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
19761 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
19764 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
19765 printf ("AVX512F");
19767 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
19768 printf ("AVX512CD");
19770 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
19771 printf ("AVX512ER");
19773 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
19774 printf ("AVX512PF");
19776 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
19777 printf ("AVX512VL");
19779 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
19780 printf ("AVX512DQ");
19782 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
19783 printf ("AVX512BW");
19786 printf (_("<unknown: %x>"), bit
);
19795 decode_x86_compat_2_isa (unsigned int bitmask
)
19799 printf (_("<None>"));
19805 unsigned int bit
= bitmask
& (- bitmask
);
19810 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_CMOV
:
19813 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE
:
19816 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE2
:
19819 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE3
:
19822 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSSE3
:
19825 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_1
:
19828 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_2
:
19831 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX
:
19834 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX2
:
19837 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_FMA
:
19840 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512F
:
19841 printf ("AVX512F");
19843 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512CD
:
19844 printf ("AVX512CD");
19846 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512ER
:
19847 printf ("AVX512ER");
19849 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512PF
:
19850 printf ("AVX512PF");
19852 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512VL
:
19853 printf ("AVX512VL");
19855 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512DQ
:
19856 printf ("AVX512DQ");
19858 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512BW
:
19859 printf ("AVX512BW");
19861 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4FMAPS
:
19862 printf ("AVX512_4FMAPS");
19864 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4VNNIW
:
19865 printf ("AVX512_4VNNIW");
19867 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BITALG
:
19868 printf ("AVX512_BITALG");
19870 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_IFMA
:
19871 printf ("AVX512_IFMA");
19873 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI
:
19874 printf ("AVX512_VBMI");
19876 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI2
:
19877 printf ("AVX512_VBMI2");
19879 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VNNI
:
19880 printf ("AVX512_VNNI");
19882 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BF16
:
19883 printf ("AVX512_BF16");
19886 printf (_("<unknown: %x>"), bit
);
19894 static const char *
19895 get_amdgpu_elf_note_type (unsigned int e_type
)
19899 case NT_AMDGPU_METADATA
:
19900 return _("NT_AMDGPU_METADATA (code object metadata)");
19903 static char buf
[64];
19904 snprintf (buf
, sizeof (buf
), _("Unknown note type: (0x%08x)"), e_type
);
19911 decode_x86_isa (unsigned int bitmask
)
19915 unsigned int bit
= bitmask
& (- bitmask
);
19920 case GNU_PROPERTY_X86_ISA_1_BASELINE
:
19921 printf ("x86-64-baseline");
19923 case GNU_PROPERTY_X86_ISA_1_V2
:
19924 printf ("x86-64-v2");
19926 case GNU_PROPERTY_X86_ISA_1_V3
:
19927 printf ("x86-64-v3");
19929 case GNU_PROPERTY_X86_ISA_1_V4
:
19930 printf ("x86-64-v4");
19933 printf (_("<unknown: %x>"), bit
);
19942 decode_x86_feature_1 (unsigned int bitmask
)
19946 printf (_("<None>"));
19952 unsigned int bit
= bitmask
& (- bitmask
);
19957 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
19960 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
19963 case GNU_PROPERTY_X86_FEATURE_1_LAM_U48
:
19964 printf ("LAM_U48");
19966 case GNU_PROPERTY_X86_FEATURE_1_LAM_U57
:
19967 printf ("LAM_U57");
19970 printf (_("<unknown: %x>"), bit
);
19979 decode_x86_feature_2 (unsigned int bitmask
)
19983 printf (_("<None>"));
19989 unsigned int bit
= bitmask
& (- bitmask
);
19994 case GNU_PROPERTY_X86_FEATURE_2_X86
:
19997 case GNU_PROPERTY_X86_FEATURE_2_X87
:
20000 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
20003 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
20006 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
20009 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
20012 case GNU_PROPERTY_X86_FEATURE_2_TMM
:
20015 case GNU_PROPERTY_X86_FEATURE_2_MASK
:
20018 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
20021 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
20024 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
20025 printf ("XSAVEOPT");
20027 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
20031 printf (_("<unknown: %x>"), bit
);
20040 decode_aarch64_feature_1_and (unsigned int bitmask
)
20044 unsigned int bit
= bitmask
& (- bitmask
);
20049 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
20053 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
20058 printf (_("<unknown: %x>"), bit
);
20067 decode_1_needed (unsigned int bitmask
)
20071 unsigned int bit
= bitmask
& (- bitmask
);
20076 case GNU_PROPERTY_1_NEEDED_INDIRECT_EXTERN_ACCESS
:
20077 printf ("indirect external access");
20080 printf (_("<unknown: %x>"), bit
);
20089 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
20091 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
20092 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
20093 unsigned int size
= is_32bit_elf
? 4 : 8;
20095 printf (_(" Properties: "));
20097 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
20099 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
20103 while (ptr
< ptr_end
)
20107 unsigned int datasz
;
20109 if ((size_t) (ptr_end
- ptr
) < 8)
20111 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
20115 type
= byte_get (ptr
, 4);
20116 datasz
= byte_get (ptr
+ 4, 4);
20120 if (datasz
> (size_t) (ptr_end
- ptr
))
20122 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
20127 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
20129 if (filedata
->file_header
.e_machine
== EM_X86_64
20130 || filedata
->file_header
.e_machine
== EM_IAMCU
20131 || filedata
->file_header
.e_machine
== EM_386
)
20133 unsigned int bitmask
;
20136 bitmask
= byte_get (ptr
, 4);
20142 case GNU_PROPERTY_X86_ISA_1_USED
:
20144 printf (_("x86 ISA used: <corrupt length: %#x> "),
20148 printf ("x86 ISA used: ");
20149 decode_x86_isa (bitmask
);
20153 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
20155 printf (_("x86 ISA needed: <corrupt length: %#x> "),
20159 printf ("x86 ISA needed: ");
20160 decode_x86_isa (bitmask
);
20164 case GNU_PROPERTY_X86_FEATURE_1_AND
:
20166 printf (_("x86 feature: <corrupt length: %#x> "),
20170 printf ("x86 feature: ");
20171 decode_x86_feature_1 (bitmask
);
20175 case GNU_PROPERTY_X86_FEATURE_2_USED
:
20177 printf (_("x86 feature used: <corrupt length: %#x> "),
20181 printf ("x86 feature used: ");
20182 decode_x86_feature_2 (bitmask
);
20186 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
20188 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
20191 printf ("x86 feature needed: ");
20192 decode_x86_feature_2 (bitmask
);
20196 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
20198 printf (_("x86 ISA used: <corrupt length: %#x> "),
20202 printf ("x86 ISA used: ");
20203 decode_x86_compat_isa (bitmask
);
20207 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
20209 printf (_("x86 ISA needed: <corrupt length: %#x> "),
20213 printf ("x86 ISA needed: ");
20214 decode_x86_compat_isa (bitmask
);
20218 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_USED
:
20220 printf (_("x86 ISA used: <corrupt length: %#x> "),
20224 printf ("x86 ISA used: ");
20225 decode_x86_compat_2_isa (bitmask
);
20229 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_NEEDED
:
20231 printf (_("x86 ISA needed: <corrupt length: %#x> "),
20235 printf ("x86 ISA needed: ");
20236 decode_x86_compat_2_isa (bitmask
);
20244 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
20246 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
20248 printf ("AArch64 feature: ");
20250 printf (_("<corrupt length: %#x> "), datasz
);
20252 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
20261 case GNU_PROPERTY_STACK_SIZE
:
20262 printf (_("stack size: "));
20263 if (datasz
!= size
)
20264 printf (_("<corrupt length: %#x> "), datasz
);
20266 printf ("%#" PRIx64
, byte_get (ptr
, size
));
20269 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
20270 printf ("no copy on protected ");
20272 printf (_("<corrupt length: %#x> "), datasz
);
20276 if ((type
>= GNU_PROPERTY_UINT32_AND_LO
20277 && type
<= GNU_PROPERTY_UINT32_AND_HI
)
20278 || (type
>= GNU_PROPERTY_UINT32_OR_LO
20279 && type
<= GNU_PROPERTY_UINT32_OR_HI
))
20283 case GNU_PROPERTY_1_NEEDED
:
20285 printf (_("1_needed: <corrupt length: %#x> "),
20289 unsigned int bitmask
= byte_get (ptr
, 4);
20290 printf ("1_needed: ");
20291 decode_1_needed (bitmask
);
20298 if (type
<= GNU_PROPERTY_UINT32_AND_HI
)
20299 printf (_("UINT32_AND (%#x): "), type
);
20301 printf (_("UINT32_OR (%#x): "), type
);
20303 printf (_("<corrupt length: %#x> "), datasz
);
20305 printf ("%#x", (unsigned int) byte_get (ptr
, 4));
20312 if (type
< GNU_PROPERTY_LOPROC
)
20313 printf (_("<unknown type %#x data: "), type
);
20314 else if (type
< GNU_PROPERTY_LOUSER
)
20315 printf (_("<processor-specific type %#x data: "), type
);
20317 printf (_("<application-specific type %#x data: "), type
);
20318 for (j
= 0; j
< datasz
; ++j
)
20319 printf ("%02x ", ptr
[j
] & 0xff);
20323 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
20324 if (ptr
== ptr_end
)
20337 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
20339 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
20340 switch (pnote
->type
)
20342 case NT_GNU_BUILD_ID
:
20346 printf (_(" Build ID: "));
20347 for (i
= 0; i
< pnote
->descsz
; ++i
)
20348 printf ("%02x", pnote
->descdata
[i
] & 0xff);
20353 case NT_GNU_ABI_TAG
:
20355 unsigned int os
, major
, minor
, subminor
;
20356 const char *osname
;
20358 /* PR 17531: file: 030-599401-0.004. */
20359 if (pnote
->descsz
< 16)
20361 printf (_(" <corrupt GNU_ABI_TAG>\n"));
20365 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20366 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
20367 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
20368 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
20372 case GNU_ABI_TAG_LINUX
:
20375 case GNU_ABI_TAG_HURD
:
20378 case GNU_ABI_TAG_SOLARIS
:
20379 osname
= "Solaris";
20381 case GNU_ABI_TAG_FREEBSD
:
20382 osname
= "FreeBSD";
20384 case GNU_ABI_TAG_NETBSD
:
20387 case GNU_ABI_TAG_SYLLABLE
:
20388 osname
= "Syllable";
20390 case GNU_ABI_TAG_NACL
:
20394 osname
= "Unknown";
20398 printf (_(" OS: %s, ABI: %d.%d.%d\n"), osname
,
20399 major
, minor
, subminor
);
20403 case NT_GNU_GOLD_VERSION
:
20407 printf (_(" Version: "));
20408 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
20409 printf ("%c", pnote
->descdata
[i
]);
20416 unsigned int num_entries
, mask
;
20418 /* Hardware capabilities information. Word 0 is the number of entries.
20419 Word 1 is a bitmask of enabled entries. The rest of the descriptor
20420 is a series of entries, where each entry is a single byte followed
20421 by a nul terminated string. The byte gives the bit number to test
20422 if enabled in the bitmask. */
20423 printf (_(" Hardware Capabilities: "));
20424 if (pnote
->descsz
< 8)
20426 error (_("<corrupt GNU_HWCAP>\n"));
20429 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20430 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
20431 printf (_("num entries: %d, enabled mask: %x\n"), num_entries
, mask
);
20432 /* FIXME: Add code to display the entries... */
20436 case NT_GNU_PROPERTY_TYPE_0
:
20437 print_gnu_property_note (filedata
, pnote
);
20441 /* Handle unrecognised types. An error message should have already been
20442 created by get_gnu_elf_note_type(), so all that we need to do is to
20443 display the data. */
20447 printf (_(" Description data: "));
20448 for (i
= 0; i
< pnote
->descsz
; ++i
)
20449 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
20458 static const char *
20459 get_v850_elf_note_type (enum v850_notes n_type
)
20461 static char buff
[64];
20465 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
20466 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
20467 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
20468 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
20469 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
20470 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
20472 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
20478 print_v850_note (Elf_Internal_Note
* pnote
)
20482 if (pnote
->descsz
!= 4)
20485 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
20489 printf (_("not set\n"));
20493 switch (pnote
->type
)
20495 case V850_NOTE_ALIGNMENT
:
20498 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return true;
20499 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return true;
20503 case V850_NOTE_DATA_SIZE
:
20506 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return true;
20507 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return true;
20511 case V850_NOTE_FPU_INFO
:
20514 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return true;
20515 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return true;
20519 case V850_NOTE_MMU_INFO
:
20520 case V850_NOTE_CACHE_INFO
:
20521 case V850_NOTE_SIMD_INFO
:
20522 if (val
== EF_RH850_SIMD
)
20524 printf (_("yes\n"));
20530 /* An 'unknown note type' message will already have been displayed. */
20534 printf (_("unknown value: %x\n"), val
);
20539 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
20541 unsigned int version
;
20543 switch (pnote
->type
)
20545 case NT_NETBSD_IDENT
:
20546 if (pnote
->descsz
< 1)
20548 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
20549 if ((version
/ 10000) % 100)
20550 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
20551 version
, version
/ 100000000, (version
/ 1000000) % 100,
20552 (version
/ 10000) % 100 > 26 ? "Z" : "",
20553 'A' + (version
/ 10000) % 26);
20555 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
20556 version
, version
/ 100000000, (version
/ 1000000) % 100,
20557 (version
/ 100) % 100);
20560 case NT_NETBSD_MARCH
:
20561 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
20565 case NT_NETBSD_PAX
:
20566 if (pnote
->descsz
< 1)
20568 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
20569 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
20570 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
20571 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
20572 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
20573 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
20574 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
20575 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
20579 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
20580 pnote
->descsz
, pnote
->type
);
20584 static const char *
20585 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
20589 case NT_FREEBSD_THRMISC
:
20590 return _("NT_THRMISC (thrmisc structure)");
20591 case NT_FREEBSD_PROCSTAT_PROC
:
20592 return _("NT_PROCSTAT_PROC (proc data)");
20593 case NT_FREEBSD_PROCSTAT_FILES
:
20594 return _("NT_PROCSTAT_FILES (files data)");
20595 case NT_FREEBSD_PROCSTAT_VMMAP
:
20596 return _("NT_PROCSTAT_VMMAP (vmmap data)");
20597 case NT_FREEBSD_PROCSTAT_GROUPS
:
20598 return _("NT_PROCSTAT_GROUPS (groups data)");
20599 case NT_FREEBSD_PROCSTAT_UMASK
:
20600 return _("NT_PROCSTAT_UMASK (umask data)");
20601 case NT_FREEBSD_PROCSTAT_RLIMIT
:
20602 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
20603 case NT_FREEBSD_PROCSTAT_OSREL
:
20604 return _("NT_PROCSTAT_OSREL (osreldate data)");
20605 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
20606 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
20607 case NT_FREEBSD_PROCSTAT_AUXV
:
20608 return _("NT_PROCSTAT_AUXV (auxv data)");
20609 case NT_FREEBSD_PTLWPINFO
:
20610 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
20611 case NT_FREEBSD_X86_SEGBASES
:
20612 return _("NT_X86_SEGBASES (x86 segment base registers)");
20614 return get_note_type (filedata
, e_type
);
20617 static const char *
20618 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
20620 static char buff
[64];
20624 case NT_NETBSDCORE_PROCINFO
:
20625 /* NetBSD core "procinfo" structure. */
20626 return _("NetBSD procinfo structure");
20628 case NT_NETBSDCORE_AUXV
:
20629 return _("NetBSD ELF auxiliary vector data");
20631 case NT_NETBSDCORE_LWPSTATUS
:
20632 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
20635 /* As of Jan 2020 there are no other machine-independent notes
20636 defined for NetBSD core files. If the note type is less
20637 than the start of the machine-dependent note types, we don't
20640 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
20642 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
20648 switch (filedata
->file_header
.e_machine
)
20650 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
20651 and PT_GETFPREGS == mach+2. */
20656 case EM_SPARC32PLUS
:
20660 case NT_NETBSDCORE_FIRSTMACH
+ 0:
20661 return _("PT_GETREGS (reg structure)");
20662 case NT_NETBSDCORE_FIRSTMACH
+ 2:
20663 return _("PT_GETFPREGS (fpreg structure)");
20669 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
20670 There's also old PT___GETREGS40 == mach + 1 for old reg
20671 structure which lacks GBR. */
20675 case NT_NETBSDCORE_FIRSTMACH
+ 1:
20676 return _("PT___GETREGS40 (old reg structure)");
20677 case NT_NETBSDCORE_FIRSTMACH
+ 3:
20678 return _("PT_GETREGS (reg structure)");
20679 case NT_NETBSDCORE_FIRSTMACH
+ 5:
20680 return _("PT_GETFPREGS (fpreg structure)");
20686 /* On all other arch's, PT_GETREGS == mach+1 and
20687 PT_GETFPREGS == mach+3. */
20691 case NT_NETBSDCORE_FIRSTMACH
+ 1:
20692 return _("PT_GETREGS (reg structure)");
20693 case NT_NETBSDCORE_FIRSTMACH
+ 3:
20694 return _("PT_GETFPREGS (fpreg structure)");
20700 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
20701 e_type
- NT_NETBSDCORE_FIRSTMACH
);
20705 static const char *
20706 get_openbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
20710 case NT_OPENBSD_PROCINFO
:
20711 return _("OpenBSD procinfo structure");
20712 case NT_OPENBSD_AUXV
:
20713 return _("OpenBSD ELF auxiliary vector data");
20714 case NT_OPENBSD_REGS
:
20715 return _("OpenBSD regular registers");
20716 case NT_OPENBSD_FPREGS
:
20717 return _("OpenBSD floating point registers");
20718 case NT_OPENBSD_WCOOKIE
:
20719 return _("OpenBSD window cookie");
20722 return get_note_type (filedata
, e_type
);
20725 static const char *
20726 get_stapsdt_note_type (unsigned e_type
)
20728 static char buff
[64];
20733 return _("NT_STAPSDT (SystemTap probe descriptors)");
20739 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
20744 print_stapsdt_note (Elf_Internal_Note
*pnote
)
20746 size_t len
, maxlen
;
20747 size_t addr_size
= is_32bit_elf
? 4 : 8;
20748 char *data
= pnote
->descdata
;
20749 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
20750 uint64_t pc
, base_addr
, semaphore
;
20751 char *provider
, *probe
, *arg_fmt
;
20753 if (pnote
->descsz
< (addr_size
* 3))
20754 goto stapdt_note_too_small
;
20756 pc
= byte_get ((unsigned char *) data
, addr_size
);
20759 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
20762 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
20765 if (data
>= data_end
)
20766 goto stapdt_note_too_small
;
20767 maxlen
= data_end
- data
;
20768 len
= strnlen (data
, maxlen
);
20775 goto stapdt_note_too_small
;
20777 if (data
>= data_end
)
20778 goto stapdt_note_too_small
;
20779 maxlen
= data_end
- data
;
20780 len
= strnlen (data
, maxlen
);
20787 goto stapdt_note_too_small
;
20789 if (data
>= data_end
)
20790 goto stapdt_note_too_small
;
20791 maxlen
= data_end
- data
;
20792 len
= strnlen (data
, maxlen
);
20799 goto stapdt_note_too_small
;
20801 printf (_(" Provider: %s\n"), provider
);
20802 printf (_(" Name: %s\n"), probe
);
20803 printf (_(" Location: "));
20804 print_vma (pc
, FULL_HEX
);
20805 printf (_(", Base: "));
20806 print_vma (base_addr
, FULL_HEX
);
20807 printf (_(", Semaphore: "));
20808 print_vma (semaphore
, FULL_HEX
);
20810 printf (_(" Arguments: %s\n"), arg_fmt
);
20812 return data
== data_end
;
20814 stapdt_note_too_small
:
20815 printf (_(" <corrupt - note is too small>\n"));
20816 error (_("corrupt stapdt note - the data size is too small\n"));
20821 print_fdo_note (Elf_Internal_Note
* pnote
)
20823 if (pnote
->descsz
> 0 && pnote
->type
== FDO_PACKAGING_METADATA
)
20825 printf (_(" Packaging Metadata: %.*s\n"), (int) pnote
->descsz
, pnote
->descdata
);
20831 static const char *
20832 get_ia64_vms_note_type (unsigned e_type
)
20834 static char buff
[64];
20839 return _("NT_VMS_MHD (module header)");
20841 return _("NT_VMS_LNM (language name)");
20843 return _("NT_VMS_SRC (source files)");
20845 return "NT_VMS_TITLE";
20847 return _("NT_VMS_EIDC (consistency check)");
20848 case NT_VMS_FPMODE
:
20849 return _("NT_VMS_FPMODE (FP mode)");
20850 case NT_VMS_LINKTIME
:
20851 return "NT_VMS_LINKTIME";
20852 case NT_VMS_IMGNAM
:
20853 return _("NT_VMS_IMGNAM (image name)");
20855 return _("NT_VMS_IMGID (image id)");
20856 case NT_VMS_LINKID
:
20857 return _("NT_VMS_LINKID (link id)");
20858 case NT_VMS_IMGBID
:
20859 return _("NT_VMS_IMGBID (build id)");
20860 case NT_VMS_GSTNAM
:
20861 return _("NT_VMS_GSTNAM (sym table name)");
20862 case NT_VMS_ORIG_DYN
:
20863 return "NT_VMS_ORIG_DYN";
20864 case NT_VMS_PATCHTIME
:
20865 return "NT_VMS_PATCHTIME";
20867 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
20873 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
20875 unsigned int maxlen
= pnote
->descsz
;
20877 if (maxlen
< 2 || maxlen
!= pnote
->descsz
)
20878 goto desc_size_fail
;
20880 switch (pnote
->type
)
20884 goto desc_size_fail
;
20886 size_t l
= strnlen (pnote
->descdata
+ 34, maxlen
- 34);
20888 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
20889 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
20890 if (l
+ 34 < maxlen
)
20892 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
20893 if (l
+ 35 < maxlen
)
20894 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
20896 printf (_(" Module version : <missing>\n"));
20900 printf (_(" Module name : <missing>\n"));
20901 printf (_(" Module version : <missing>\n"));
20906 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
20909 case NT_VMS_FPMODE
:
20910 printf (_(" Floating Point mode: "));
20912 goto desc_size_fail
;
20913 /* FIXME: Generate an error if descsz > 8 ? */
20915 printf ("0x%016" PRIx64
"\n",
20916 byte_get ((unsigned char *) pnote
->descdata
, 8));
20919 case NT_VMS_LINKTIME
:
20920 printf (_(" Link time: "));
20922 goto desc_size_fail
;
20923 /* FIXME: Generate an error if descsz > 8 ? */
20925 print_vms_time (byte_get ((unsigned char *) pnote
->descdata
, 8));
20929 case NT_VMS_PATCHTIME
:
20930 printf (_(" Patch time: "));
20932 goto desc_size_fail
;
20933 /* FIXME: Generate an error if descsz > 8 ? */
20935 print_vms_time (byte_get ((unsigned char *) pnote
->descdata
, 8));
20939 case NT_VMS_ORIG_DYN
:
20941 goto desc_size_fail
;
20943 printf (_(" Major id: %u, minor id: %u\n"),
20944 (unsigned) byte_get ((unsigned char *) pnote
->descdata
, 4),
20945 (unsigned) byte_get ((unsigned char *) pnote
->descdata
+ 4, 4));
20946 printf (_(" Last modified : "));
20947 print_vms_time (byte_get ((unsigned char *) pnote
->descdata
+ 8, 8));
20948 printf (_("\n Link flags : "));
20949 printf ("0x%016" PRIx64
"\n",
20950 byte_get ((unsigned char *) pnote
->descdata
+ 16, 8));
20951 printf (_(" Header flags: 0x%08x\n"),
20952 (unsigned) byte_get ((unsigned char *) pnote
->descdata
+ 24, 4));
20953 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
20956 case NT_VMS_IMGNAM
:
20957 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
20960 case NT_VMS_GSTNAM
:
20961 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
20965 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
20968 case NT_VMS_LINKID
:
20969 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
20979 printf (_(" <corrupt - data size is too small>\n"));
20980 error (_("corrupt IA64 note: data size is too small\n"));
20984 struct build_attr_cache
{
20985 Filedata
*filedata
;
20987 uint64_t strtablen
;
20988 Elf_Internal_Sym
*symtab
;
20992 /* Find the symbol associated with a build attribute that is attached
20993 to address OFFSET. If PNAME is non-NULL then store the name of
20994 the symbol (if found) in the provided pointer, Returns NULL if a
20995 symbol could not be found. */
20997 static Elf_Internal_Sym
*
20998 get_symbol_for_build_attribute (Filedata
*filedata
,
21001 const char **pname
)
21003 Elf_Internal_Sym
*saved_sym
= NULL
;
21004 Elf_Internal_Sym
*sym
;
21006 if (filedata
->section_headers
!= NULL
21007 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
21009 Elf_Internal_Shdr
* symsec
;
21011 free (ba_cache
.strtab
);
21012 ba_cache
.strtab
= NULL
;
21013 free (ba_cache
.symtab
);
21014 ba_cache
.symtab
= NULL
;
21016 /* Load the symbol and string sections. */
21017 for (symsec
= filedata
->section_headers
;
21018 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
21021 if (symsec
->sh_type
== SHT_SYMTAB
21022 && get_symtab (filedata
, symsec
,
21023 &ba_cache
.symtab
, &ba_cache
.nsyms
,
21024 &ba_cache
.strtab
, &ba_cache
.strtablen
))
21027 ba_cache
.filedata
= filedata
;
21030 if (ba_cache
.symtab
== NULL
)
21033 /* Find a symbol whose value matches offset. */
21034 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
21035 if (sym
->st_value
== offset
)
21037 if (sym
->st_name
>= ba_cache
.strtablen
)
21038 /* Huh ? This should not happen. */
21041 if (ba_cache
.strtab
[sym
->st_name
] == 0)
21044 /* The AArch64, ARM and RISC-V architectures define mapping symbols
21045 (eg $d, $x, $t) which we want to ignore. */
21046 if (ba_cache
.strtab
[sym
->st_name
] == '$'
21047 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
21048 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
21053 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
21054 and FILE or OBJECT symbols over NOTYPE symbols. We skip
21055 FUNC symbols entirely. */
21056 switch (ELF_ST_TYPE (sym
->st_info
))
21063 /* If the symbol has a size associated
21064 with it then we can stop searching. */
21065 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
21070 /* Ignore function symbols. */
21077 switch (ELF_ST_BIND (sym
->st_info
))
21080 if (saved_sym
== NULL
21081 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
21086 if (saved_sym
== NULL
)
21096 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
21104 if (saved_sym
&& pname
)
21105 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
21110 /* Returns true iff addr1 and addr2 are in the same section. */
21113 same_section (Filedata
* filedata
, uint64_t addr1
, uint64_t addr2
)
21115 Elf_Internal_Shdr
* a1
;
21116 Elf_Internal_Shdr
* a2
;
21118 a1
= find_section_by_address (filedata
, addr1
);
21119 a2
= find_section_by_address (filedata
, addr2
);
21121 return a1
== a2
&& a1
!= NULL
;
21125 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
21126 Filedata
* filedata
)
21128 static uint64_t global_offset
= 0;
21129 static uint64_t global_end
= 0;
21130 static uint64_t func_offset
= 0;
21131 static uint64_t func_end
= 0;
21133 Elf_Internal_Sym
*sym
;
21137 bool is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
21139 switch (pnote
->descsz
)
21142 /* A zero-length description means that the range of
21143 the previous note of the same type should be used. */
21146 if (global_end
> global_offset
)
21147 printf (_(" Applies to region from %#" PRIx64
21148 " to %#" PRIx64
"\n"), global_offset
, global_end
);
21150 printf (_(" Applies to region from %#" PRIx64
21151 "\n"), global_offset
);
21155 if (func_end
> func_offset
)
21156 printf (_(" Applies to region from %#" PRIx64
21157 " to %#" PRIx64
"\n"), func_offset
, func_end
);
21159 printf (_(" Applies to region from %#" PRIx64
21160 "\n"), func_offset
);
21165 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
21170 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
21171 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
21175 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
21176 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
21180 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
21181 printf (_(" <invalid descsz>"));
21186 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
21187 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
21188 in order to avoid them being confused with the start address of the
21189 first function in the file... */
21190 if (sym
== NULL
&& is_open_attr
)
21191 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
21194 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
21195 end
= start
+ sym
->st_size
;
21199 /* FIXME: Need to properly allow for section alignment.
21200 16 is just the alignment used on x86_64. */
21202 && start
> BFD_ALIGN (global_end
, 16)
21203 /* Build notes are not guaranteed to be organised in order of
21204 increasing address, but we should find the all of the notes
21205 for one section in the same place. */
21206 && same_section (filedata
, start
, global_end
))
21207 warn (_("Gap in build notes detected from %#" PRIx64
21208 " to %#" PRIx64
"\n"),
21209 global_end
+ 1, start
- 1);
21211 printf (_(" Applies to region from %#" PRIx64
), start
);
21212 global_offset
= start
;
21216 printf (_(" to %#" PRIx64
), end
);
21222 printf (_(" Applies to region from %#" PRIx64
), start
);
21223 func_offset
= start
;
21227 printf (_(" to %#" PRIx64
), end
);
21233 printf (_(" (%s)"), name
);
21240 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
21242 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
21243 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
21244 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
21246 char name_attribute
;
21247 const char * expected_types
;
21248 const char * name
= pnote
->namedata
;
21252 if (name
== NULL
|| pnote
->namesz
< 2)
21254 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
21255 print_symbol (-20, _(" <corrupt name>"));
21264 /* Version 2 of the spec adds a "GA" prefix to the name field. */
21265 if (name
[0] == 'G' && name
[1] == 'A')
21267 if (pnote
->namesz
< 4)
21269 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
21270 print_symbol (-20, _(" <corrupt name>"));
21279 switch ((name_type
= * name
))
21281 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
21282 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
21283 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
21284 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
21285 printf ("%c", * name
);
21289 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
21290 print_symbol (-20, _("<unknown name type>"));
21297 switch ((name_attribute
= * name
))
21299 case GNU_BUILD_ATTRIBUTE_VERSION
:
21300 text
= _("<version>");
21301 expected_types
= string_expected
;
21304 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
21305 text
= _("<stack prot>");
21306 expected_types
= "!+*";
21309 case GNU_BUILD_ATTRIBUTE_RELRO
:
21310 text
= _("<relro>");
21311 expected_types
= bool_expected
;
21314 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
21315 text
= _("<stack size>");
21316 expected_types
= number_expected
;
21319 case GNU_BUILD_ATTRIBUTE_TOOL
:
21320 text
= _("<tool>");
21321 expected_types
= string_expected
;
21324 case GNU_BUILD_ATTRIBUTE_ABI
:
21326 expected_types
= "$*";
21329 case GNU_BUILD_ATTRIBUTE_PIC
:
21331 expected_types
= number_expected
;
21334 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
21335 text
= _("<short enum>");
21336 expected_types
= bool_expected
;
21340 if (ISPRINT (* name
))
21342 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
21344 if (len
> left
&& ! do_wide
)
21346 printf ("%.*s:", len
, name
);
21352 static char tmpbuf
[128];
21354 error (_("unrecognised byte in name field: %d\n"), * name
);
21355 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
21359 expected_types
= "*$!+";
21364 left
-= printf ("%s", text
);
21366 if (strchr (expected_types
, name_type
) == NULL
)
21367 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
21369 if ((size_t) (name
- pnote
->namedata
) > pnote
->namesz
)
21371 error (_("corrupt name field: namesz: %lu but parsing gets to %td\n"),
21373 name
- pnote
->namedata
);
21377 if (left
< 1 && ! do_wide
)
21382 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
21384 unsigned int bytes
;
21386 unsigned int shift
= 0;
21387 char *decoded
= NULL
;
21389 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
21391 /* The -1 is because the name field is always 0 terminated, and we
21392 want to be able to ensure that the shift in the while loop below
21393 will not overflow. */
21396 if (bytes
> sizeof (val
))
21398 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
21400 bytes
= sizeof (val
);
21402 /* We do not bother to warn if bytes == 0 as this can
21403 happen with some early versions of the gcc plugin. */
21407 uint64_t byte
= *name
++ & 0xff;
21409 val
|= byte
<< shift
;
21413 switch (name_attribute
)
21415 case GNU_BUILD_ATTRIBUTE_PIC
:
21418 case 0: decoded
= "static"; break;
21419 case 1: decoded
= "pic"; break;
21420 case 2: decoded
= "PIC"; break;
21421 case 3: decoded
= "pie"; break;
21422 case 4: decoded
= "PIE"; break;
21426 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
21429 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
21430 case 0: decoded
= "off"; break;
21431 case 1: decoded
= "on"; break;
21432 case 2: decoded
= "all"; break;
21433 case 3: decoded
= "strong"; break;
21434 case 4: decoded
= "explicit"; break;
21442 if (decoded
!= NULL
)
21444 print_symbol (-left
, decoded
);
21455 left
-= printf ("0x%" PRIx64
, val
);
21457 left
-= printf ("0x%-.*" PRIx64
, left
, val
);
21461 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
21462 left
-= print_symbol (- left
, name
);
21464 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
21465 left
-= print_symbol (- left
, "true");
21467 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
21468 left
-= print_symbol (- left
, "false");
21472 if (do_wide
&& left
> 0)
21473 printf ("%-*s", left
, " ");
21478 /* Print the contents of PNOTE as hex. */
21481 print_note_contents_hex (Elf_Internal_Note
*pnote
)
21487 printf (_(" description data: "));
21488 for (i
= 0; i
< pnote
->descsz
; i
++)
21489 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
21498 #if defined HAVE_MSGPACK
21501 print_indents (int n
)
21505 for (int i
= 0; i
< n
; i
++)
21509 /* Print OBJ in human-readable form. */
21512 dump_msgpack_obj (const msgpack_object
*obj
, int indent
)
21516 case MSGPACK_OBJECT_NIL
:
21520 case MSGPACK_OBJECT_BOOLEAN
:
21521 printf ("%s", obj
->via
.boolean
? "true" : "false");
21524 case MSGPACK_OBJECT_POSITIVE_INTEGER
:
21525 printf ("%" PRIu64
, obj
->via
.u64
);
21528 case MSGPACK_OBJECT_NEGATIVE_INTEGER
:
21529 printf ("%" PRIi64
, obj
->via
.i64
);
21532 case MSGPACK_OBJECT_FLOAT32
:
21533 case MSGPACK_OBJECT_FLOAT64
:
21534 printf ("%f", obj
->via
.f64
);
21537 case MSGPACK_OBJECT_STR
:
21538 printf ("\"%.*s\"", obj
->via
.str
.size
, obj
->via
.str
.ptr
);
21541 case MSGPACK_OBJECT_ARRAY
:
21543 const msgpack_object_array
*array
= &obj
->via
.array
;
21548 for (uint32_t i
= 0; i
< array
->size
; ++i
)
21550 const msgpack_object
*item
= &array
->ptr
[i
];
21552 print_indents (indent
);
21553 dump_msgpack_obj (item
, indent
);
21558 print_indents (indent
);
21564 case MSGPACK_OBJECT_MAP
:
21566 const msgpack_object_map
*map
= &obj
->via
.map
;
21571 for (uint32_t i
= 0; i
< map
->size
; ++i
)
21573 const msgpack_object_kv
*kv
= &map
->ptr
[i
];
21574 const msgpack_object
*key
= &kv
->key
;
21575 const msgpack_object
*val
= &kv
->val
;
21577 print_indents (indent
);
21578 dump_msgpack_obj (key
, indent
);
21580 dump_msgpack_obj (val
, indent
);
21586 print_indents (indent
);
21592 case MSGPACK_OBJECT_BIN
:
21596 case MSGPACK_OBJECT_EXT
:
21603 dump_msgpack (const msgpack_unpacked
*msg
)
21606 dump_msgpack_obj (&msg
->data
, 0);
21610 #endif /* defined HAVE_MSGPACK */
21613 print_amdgpu_note (Elf_Internal_Note
*pnote
)
21615 #if defined HAVE_MSGPACK
21616 /* If msgpack is available, decode and dump the note's content. */
21618 msgpack_unpacked msg
;
21619 msgpack_unpack_return msgpack_ret
;
21621 assert (pnote
->type
== NT_AMDGPU_METADATA
);
21623 msgpack_unpacked_init (&msg
);
21624 msgpack_ret
= msgpack_unpack_next (&msg
, pnote
->descdata
, pnote
->descsz
,
21627 switch (msgpack_ret
)
21629 case MSGPACK_UNPACK_SUCCESS
:
21630 dump_msgpack (&msg
);
21635 error (_("failed to unpack msgpack contents in NT_AMDGPU_METADATA note"));
21640 msgpack_unpacked_destroy (&msg
);
21643 /* msgpack is not available, dump contents as hex. */
21644 print_note_contents_hex (pnote
);
21649 /* Note that by the ELF standard, the name field is already null byte
21650 terminated, and namesz includes the terminating null byte.
21651 I.E. the value of namesz for the name "FSF" is 4.
21653 If the value of namesz is zero, there is no name present. */
21656 process_note (Elf_Internal_Note
* pnote
,
21657 Filedata
* filedata
)
21659 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
21662 if (pnote
->namesz
== 0)
21663 /* If there is no note name, then use the default set of
21664 note type strings. */
21665 nt
= get_note_type (filedata
, pnote
->type
);
21667 else if (startswith (pnote
->namedata
, "GNU"))
21668 /* GNU-specific object file notes. */
21669 nt
= get_gnu_elf_note_type (pnote
->type
);
21671 else if (startswith (pnote
->namedata
, "AMDGPU"))
21672 /* AMDGPU-specific object file notes. */
21673 nt
= get_amdgpu_elf_note_type (pnote
->type
);
21675 else if (startswith (pnote
->namedata
, "FreeBSD"))
21676 /* FreeBSD-specific core file notes. */
21677 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
21679 else if (startswith (pnote
->namedata
, "NetBSD-CORE"))
21680 /* NetBSD-specific core file notes. */
21681 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
21683 else if (startswith (pnote
->namedata
, "NetBSD"))
21684 /* NetBSD-specific core file notes. */
21685 return process_netbsd_elf_note (pnote
);
21687 else if (startswith (pnote
->namedata
, "PaX"))
21688 /* NetBSD-specific core file notes. */
21689 return process_netbsd_elf_note (pnote
);
21691 else if (startswith (pnote
->namedata
, "OpenBSD"))
21692 /* OpenBSD-specific core file notes. */
21693 nt
= get_openbsd_elfcore_note_type (filedata
, pnote
->type
);
21695 else if (startswith (pnote
->namedata
, "SPU/"))
21697 /* SPU-specific core file notes. */
21698 nt
= pnote
->namedata
+ 4;
21702 else if (startswith (pnote
->namedata
, "IPF/VMS"))
21703 /* VMS/ia64-specific file notes. */
21704 nt
= get_ia64_vms_note_type (pnote
->type
);
21706 else if (startswith (pnote
->namedata
, "stapsdt"))
21707 nt
= get_stapsdt_note_type (pnote
->type
);
21710 /* Don't recognize this note name; just use the default set of
21711 note type strings. */
21712 nt
= get_note_type (filedata
, pnote
->type
);
21716 if (((startswith (pnote
->namedata
, "GA")
21717 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
21718 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
21719 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
21720 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
21721 print_gnu_build_attribute_name (pnote
);
21723 print_symbol (-20, name
);
21726 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
21728 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
21730 if (startswith (pnote
->namedata
, "IPF/VMS"))
21731 return print_ia64_vms_note (pnote
);
21732 else if (startswith (pnote
->namedata
, "GNU"))
21733 return print_gnu_note (filedata
, pnote
);
21734 else if (startswith (pnote
->namedata
, "stapsdt"))
21735 return print_stapsdt_note (pnote
);
21736 else if (startswith (pnote
->namedata
, "CORE"))
21737 return print_core_note (pnote
);
21738 else if (startswith (pnote
->namedata
, "FDO"))
21739 return print_fdo_note (pnote
);
21740 else if (((startswith (pnote
->namedata
, "GA")
21741 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
21742 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
21743 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
21744 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
21745 return print_gnu_build_attribute_description (pnote
, filedata
);
21746 else if (startswith (pnote
->namedata
, "AMDGPU")
21747 && pnote
->type
== NT_AMDGPU_METADATA
)
21748 return print_amdgpu_note (pnote
);
21750 print_note_contents_hex (pnote
);
21755 process_notes_at (Filedata
* filedata
,
21756 Elf_Internal_Shdr
* section
,
21761 Elf_External_Note
*pnotes
;
21762 Elf_External_Note
*external
;
21771 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
21774 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
21782 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
21785 if (pnotes
== NULL
)
21790 if (filedata
->is_separate
)
21791 printf (_("In linked file '%s': "), filedata
->file_name
);
21795 printf (_("Displaying notes found in: %s\n"), printable_section_name (filedata
, section
));
21797 printf (_("Displaying notes found at file offset 0x%08" PRIx64
21798 " with length 0x%08" PRIx64
":\n"),
21801 /* NB: Some note sections may have alignment value of 0 or 1. gABI
21802 specifies that notes should be aligned to 4 bytes in 32-bit
21803 objects and to 8 bytes in 64-bit objects. As a Linux extension,
21804 we also support 4 byte alignment in 64-bit objects. If section
21805 alignment is less than 4, we treate alignment as 4 bytes. */
21808 else if (align
!= 4 && align
!= 8)
21810 warn (_("Corrupt note: alignment %" PRId64
", expecting 4 or 8\n"),
21816 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
21818 end
= (char *) pnotes
+ length
;
21819 while ((char *) external
< end
)
21821 Elf_Internal_Note inote
;
21824 char * temp
= NULL
;
21825 size_t data_remaining
= end
- (char *) external
;
21827 if (!is_ia64_vms (filedata
))
21829 /* PR binutils/15191
21830 Make sure that there is enough data to read. */
21831 min_notesz
= offsetof (Elf_External_Note
, name
);
21832 if (data_remaining
< min_notesz
)
21834 warn (ngettext ("Corrupt note: only %zd byte remains, "
21835 "not enough for a full note\n",
21836 "Corrupt note: only %zd bytes remain, "
21837 "not enough for a full note\n",
21842 data_remaining
-= min_notesz
;
21844 inote
.type
= BYTE_GET (external
->type
);
21845 inote
.namesz
= BYTE_GET (external
->namesz
);
21846 inote
.namedata
= external
->name
;
21847 inote
.descsz
= BYTE_GET (external
->descsz
);
21848 inote
.descdata
= ((char *) external
21849 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
21850 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
21851 next
= ((char *) external
21852 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
21856 Elf64_External_VMS_Note
*vms_external
;
21858 /* PR binutils/15191
21859 Make sure that there is enough data to read. */
21860 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
21861 if (data_remaining
< min_notesz
)
21863 warn (ngettext ("Corrupt note: only %zd byte remains, "
21864 "not enough for a full note\n",
21865 "Corrupt note: only %zd bytes remain, "
21866 "not enough for a full note\n",
21871 data_remaining
-= min_notesz
;
21873 vms_external
= (Elf64_External_VMS_Note
*) external
;
21874 inote
.type
= BYTE_GET (vms_external
->type
);
21875 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
21876 inote
.namedata
= vms_external
->name
;
21877 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
21878 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
21879 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
21880 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
21883 /* PR 17531: file: 3443835e. */
21884 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
21885 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
21886 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
21887 || (size_t) (next
- inote
.descdata
) < inote
.descsz
21888 || ((size_t) (next
- inote
.descdata
)
21889 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
21891 warn (_("note with invalid namesz and/or descsz found at offset %#tx\n"),
21892 (char *) external
- (char *) pnotes
);
21893 warn (_(" type: %#lx, namesize: %#lx, descsize: %#lx, alignment: %u\n"),
21894 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
21898 external
= (Elf_External_Note
*) next
;
21900 /* Verify that name is null terminated. It appears that at least
21901 one version of Linux (RedHat 6.0) generates corefiles that don't
21902 comply with the ELF spec by failing to include the null byte in
21904 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
21906 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
21908 temp
= (char *) malloc (inote
.namesz
+ 1);
21911 error (_("Out of memory allocating space for inote name\n"));
21916 memcpy (temp
, inote
.namedata
, inote
.namesz
);
21917 inote
.namedata
= temp
;
21919 inote
.namedata
[inote
.namesz
] = 0;
21922 if (! process_note (& inote
, filedata
))
21935 process_corefile_note_segments (Filedata
* filedata
)
21937 Elf_Internal_Phdr
*segment
;
21941 if (! get_program_headers (filedata
))
21944 for (i
= 0, segment
= filedata
->program_headers
;
21945 i
< filedata
->file_header
.e_phnum
;
21948 if (segment
->p_type
== PT_NOTE
)
21949 if (! process_notes_at (filedata
, NULL
, segment
->p_offset
,
21950 segment
->p_filesz
, segment
->p_align
))
21958 process_v850_notes (Filedata
* filedata
, uint64_t offset
, uint64_t length
)
21960 Elf_External_Note
* pnotes
;
21961 Elf_External_Note
* external
;
21968 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
21970 if (pnotes
== NULL
)
21974 end
= (char*) pnotes
+ length
;
21976 printf (_("\nDisplaying contents of Renesas V850 notes section at offset"
21977 " %#" PRIx64
" with length %#" PRIx64
":\n"),
21980 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
21982 Elf_External_Note
* next
;
21983 Elf_Internal_Note inote
;
21985 inote
.type
= BYTE_GET (external
->type
);
21986 inote
.namesz
= BYTE_GET (external
->namesz
);
21987 inote
.namedata
= external
->name
;
21988 inote
.descsz
= BYTE_GET (external
->descsz
);
21989 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
21990 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
21992 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
21994 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
21995 inote
.descdata
= inote
.namedata
;
21999 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
22001 if ( ((char *) next
> end
)
22002 || ((char *) next
< (char *) pnotes
))
22004 warn (_("corrupt descsz found in note at offset %#tx\n"),
22005 (char *) external
- (char *) pnotes
);
22006 warn (_(" type: %#lx, namesize: %#lx, descsize: %#lx\n"),
22007 inote
.type
, inote
.namesz
, inote
.descsz
);
22013 /* Prevent out-of-bounds indexing. */
22014 if ( inote
.namedata
+ inote
.namesz
> end
22015 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
22017 warn (_("corrupt namesz found in note at offset %#zx\n"),
22018 (char *) external
- (char *) pnotes
);
22019 warn (_(" type: %#lx, namesize: %#lx, descsize: %#lx\n"),
22020 inote
.type
, inote
.namesz
, inote
.descsz
);
22024 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
22026 if (! print_v850_note (& inote
))
22029 printf ("<corrupt sizes: namesz: %#lx, descsz: %#lx>\n",
22030 inote
.namesz
, inote
.descsz
);
22040 process_note_sections (Filedata
* filedata
)
22042 Elf_Internal_Shdr
*section
;
22044 unsigned int n
= 0;
22047 for (i
= 0, section
= filedata
->section_headers
;
22048 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
22051 if (section
->sh_type
== SHT_NOTE
)
22053 if (! process_notes_at (filedata
, section
, section
->sh_offset
,
22054 section
->sh_size
, section
->sh_addralign
))
22059 if (( filedata
->file_header
.e_machine
== EM_V800
22060 || filedata
->file_header
.e_machine
== EM_V850
22061 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
22062 && section
->sh_type
== SHT_RENESAS_INFO
)
22064 if (! process_v850_notes (filedata
, section
->sh_offset
,
22072 /* Try processing NOTE segments instead. */
22073 return process_corefile_note_segments (filedata
);
22079 process_notes (Filedata
* filedata
)
22081 /* If we have not been asked to display the notes then do nothing. */
22085 if (filedata
->file_header
.e_type
!= ET_CORE
)
22086 return process_note_sections (filedata
);
22088 /* No program headers means no NOTE segment. */
22089 if (filedata
->file_header
.e_phnum
> 0)
22090 return process_corefile_note_segments (filedata
);
22092 if (filedata
->is_separate
)
22093 printf (_("No notes found in linked file '%s'.\n"),
22094 filedata
->file_name
);
22096 printf (_("No notes found file.\n"));
22101 static unsigned char *
22102 display_public_gnu_attributes (unsigned char * start
,
22103 const unsigned char * const end
)
22105 printf (_(" Unknown GNU attribute: %s\n"), start
);
22107 start
+= strnlen ((char *) start
, end
- start
);
22108 display_raw_attribute (start
, end
);
22110 return (unsigned char *) end
;
22113 static unsigned char *
22114 display_generic_attribute (unsigned char * start
,
22116 const unsigned char * const end
)
22119 return (unsigned char *) end
;
22121 return display_tag_value (tag
, start
, end
);
22125 process_arch_specific (Filedata
* filedata
)
22130 switch (filedata
->file_header
.e_machine
)
22133 case EM_ARC_COMPACT
:
22134 case EM_ARC_COMPACT2
:
22135 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
22136 display_arc_attribute
,
22137 display_generic_attribute
);
22139 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
22140 display_arm_attribute
,
22141 display_generic_attribute
);
22144 case EM_MIPS_RS3_LE
:
22145 return process_mips_specific (filedata
);
22148 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
22149 display_msp430_attribute
,
22150 display_msp430_gnu_attribute
);
22153 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
22154 display_riscv_attribute
,
22155 display_generic_attribute
);
22158 return process_nds32_specific (filedata
);
22161 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22162 display_m68k_gnu_attribute
);
22166 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22167 display_power_gnu_attribute
);
22171 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22172 display_s390_gnu_attribute
);
22175 case EM_SPARC32PLUS
:
22177 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22178 display_sparc_gnu_attribute
);
22181 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
22182 display_tic6x_attribute
,
22183 display_generic_attribute
);
22186 return process_attributes (filedata
, "csky", SHT_CSKY_ATTRIBUTES
,
22187 display_csky_attribute
, NULL
);
22190 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
22191 display_public_gnu_attributes
,
22192 display_generic_attribute
);
22197 get_file_header (Filedata
* filedata
)
22199 /* Read in the identity array. */
22200 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
22203 /* Determine how to read the rest of the header. */
22204 switch (filedata
->file_header
.e_ident
[EI_DATA
])
22209 byte_get
= byte_get_little_endian
;
22210 byte_put
= byte_put_little_endian
;
22213 byte_get
= byte_get_big_endian
;
22214 byte_put
= byte_put_big_endian
;
22218 /* For now we only support 32 bit and 64 bit ELF files. */
22219 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
22221 /* Read in the rest of the header. */
22224 Elf32_External_Ehdr ehdr32
;
22226 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
22229 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
22230 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
22231 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
22232 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
22233 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
22234 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
22235 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
22236 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
22237 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
22238 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
22239 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
22240 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
22241 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
22245 Elf64_External_Ehdr ehdr64
;
22247 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
22250 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
22251 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
22252 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
22253 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
22254 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
22255 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
22256 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
22257 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
22258 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
22259 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
22260 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
22261 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
22262 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
22269 free_filedata (Filedata
*filedata
)
22271 free (filedata
->program_interpreter
);
22272 free (filedata
->program_headers
);
22273 free (filedata
->section_headers
);
22274 free (filedata
->string_table
);
22275 free (filedata
->dump
.dump_sects
);
22276 free (filedata
->dynamic_strings
);
22277 free (filedata
->dynamic_symbols
);
22278 free (filedata
->dynamic_syminfo
);
22279 free (filedata
->dynamic_section
);
22281 while (filedata
->symtab_shndx_list
!= NULL
)
22283 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
22284 free (filedata
->symtab_shndx_list
);
22285 filedata
->symtab_shndx_list
= next
;
22288 free (filedata
->section_headers_groups
);
22290 if (filedata
->section_groups
)
22293 struct group_list
* g
;
22294 struct group_list
* next
;
22296 for (i
= 0; i
< filedata
->group_count
; i
++)
22298 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
22305 free (filedata
->section_groups
);
22307 memset (&filedata
->section_headers
, 0,
22308 sizeof (Filedata
) - offsetof (Filedata
, section_headers
));
22312 close_file (Filedata
* filedata
)
22316 if (filedata
->handle
)
22317 fclose (filedata
->handle
);
22323 close_debug_file (void * data
)
22325 free_filedata ((Filedata
*) data
);
22326 close_file ((Filedata
*) data
);
22330 open_file (const char * pathname
, bool is_separate
)
22332 struct stat statbuf
;
22333 Filedata
* filedata
= NULL
;
22335 if (stat (pathname
, & statbuf
) < 0
22336 || ! S_ISREG (statbuf
.st_mode
))
22339 filedata
= calloc (1, sizeof * filedata
);
22340 if (filedata
== NULL
)
22343 filedata
->handle
= fopen (pathname
, "rb");
22344 if (filedata
->handle
== NULL
)
22347 filedata
->file_size
= statbuf
.st_size
;
22348 filedata
->file_name
= pathname
;
22349 filedata
->is_separate
= is_separate
;
22351 if (! get_file_header (filedata
))
22354 if (!get_section_headers (filedata
, false))
22362 if (filedata
->handle
)
22363 fclose (filedata
->handle
);
22370 open_debug_file (const char * pathname
)
22372 return open_file (pathname
, true);
22376 initialise_dump_sects (Filedata
* filedata
)
22378 /* Initialise the dump_sects array from the cmdline_dump_sects array.
22379 Note we do this even if cmdline_dump_sects is empty because we
22380 must make sure that the dump_sets array is zeroed out before each
22381 object file is processed. */
22382 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
22383 memset (filedata
->dump
.dump_sects
, 0,
22384 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
22386 if (cmdline
.num_dump_sects
> 0)
22388 if (filedata
->dump
.num_dump_sects
== 0)
22389 /* A sneaky way of allocating the dump_sects array. */
22390 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
22392 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
22393 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
22394 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
22399 might_need_separate_debug_info (Filedata
* filedata
)
22401 /* Debuginfo files do not need further separate file loading. */
22402 if (filedata
->file_header
.e_shstrndx
== SHN_UNDEF
)
22405 /* Since do_follow_links might be enabled by default, only treat it as an
22406 indication that separate files should be loaded if setting it was a
22407 deliberate user action. */
22408 if (DEFAULT_FOR_FOLLOW_LINKS
== 0 && do_follow_links
)
22411 if (process_links
|| do_syms
|| do_unwind
22412 || dump_any_debugging
|| do_dump
|| do_debugging
)
22418 /* Process one ELF object file according to the command line options.
22419 This file may actually be stored in an archive. The file is
22420 positioned at the start of the ELF object. Returns TRUE if no
22421 problems were encountered, FALSE otherwise. */
22424 process_object (Filedata
* filedata
)
22426 bool have_separate_files
;
22430 if (! get_file_header (filedata
))
22432 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
22436 /* Initialise per file variables. */
22437 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
22438 filedata
->version_info
[i
] = 0;
22440 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
22441 filedata
->dynamic_info
[i
] = 0;
22442 filedata
->dynamic_info_DT_GNU_HASH
= 0;
22443 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
22445 /* Process the file. */
22447 printf (_("\nFile: %s\n"), filedata
->file_name
);
22449 initialise_dump_sects (filedata
);
22451 /* There may be some extensions in the first section header. Don't
22452 bomb if we can't read it. */
22453 get_section_headers (filedata
, true);
22455 if (! process_file_header (filedata
))
22461 /* Throw away the single section header read above, so that we
22462 re-read the entire set. */
22463 free (filedata
->section_headers
);
22464 filedata
->section_headers
= NULL
;
22466 if (! process_section_headers (filedata
))
22468 /* Without loaded section headers we cannot process lots of things. */
22469 do_unwind
= do_version
= do_dump
= do_arch
= false;
22471 if (! do_using_dynamic
)
22472 do_syms
= do_dyn_syms
= do_reloc
= false;
22475 if (! process_section_groups (filedata
))
22476 /* Without loaded section groups we cannot process unwind. */
22479 process_program_headers (filedata
);
22481 res
= process_dynamic_section (filedata
);
22483 if (! process_relocs (filedata
))
22486 if (! process_unwind (filedata
))
22489 if (! process_symbol_table (filedata
))
22492 if (! process_lto_symbol_tables (filedata
))
22495 if (! process_syminfo (filedata
))
22498 if (! process_version_sections (filedata
))
22501 if (might_need_separate_debug_info (filedata
))
22502 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
22504 have_separate_files
= false;
22506 if (! process_section_contents (filedata
))
22509 if (have_separate_files
)
22513 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
22515 initialise_dump_sects (d
->handle
);
22517 if (process_links
&& ! process_file_header (d
->handle
))
22519 else if (! process_section_headers (d
->handle
))
22521 else if (! process_section_contents (d
->handle
))
22523 else if (process_links
)
22525 if (! process_section_groups (d
->handle
))
22527 process_program_headers (d
->handle
);
22528 if (! process_dynamic_section (d
->handle
))
22530 if (! process_relocs (d
->handle
))
22532 if (! process_unwind (d
->handle
))
22534 if (! process_symbol_table (d
->handle
))
22536 if (! process_lto_symbol_tables (d
->handle
))
22538 if (! process_syminfo (d
->handle
))
22540 if (! process_version_sections (d
->handle
))
22542 if (! process_notes (d
->handle
))
22547 /* The file handles are closed by the call to free_debug_memory() below. */
22550 if (! process_notes (filedata
))
22553 if (! process_gnu_liblist (filedata
))
22556 if (! process_arch_specific (filedata
))
22560 free_filedata (filedata
);
22562 free_debug_memory ();
22567 /* Process an ELF archive.
22568 On entry the file is positioned just after the ARMAG string.
22569 Returns TRUE upon success, FALSE otherwise. */
22572 process_archive (Filedata
* filedata
, bool is_thin_archive
)
22574 struct archive_info arch
;
22575 struct archive_info nested_arch
;
22581 /* The ARCH structure is used to hold information about this archive. */
22582 arch
.file_name
= NULL
;
22584 arch
.index_array
= NULL
;
22585 arch
.sym_table
= NULL
;
22586 arch
.longnames
= NULL
;
22588 /* The NESTED_ARCH structure is used as a single-item cache of information
22589 about a nested archive (when members of a thin archive reside within
22590 another regular archive file). */
22591 nested_arch
.file_name
= NULL
;
22592 nested_arch
.file
= NULL
;
22593 nested_arch
.index_array
= NULL
;
22594 nested_arch
.sym_table
= NULL
;
22595 nested_arch
.longnames
= NULL
;
22597 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
22598 filedata
->file_size
, is_thin_archive
,
22599 do_archive_index
) != 0)
22605 if (do_archive_index
)
22607 if (arch
.sym_table
== NULL
)
22608 error (_("%s: unable to dump the index as none was found\n"),
22609 filedata
->file_name
);
22613 uint64_t current_pos
;
22615 printf (_("Index of archive %s: (%" PRIu64
" entries,"
22616 " %#" PRIx64
" bytes in the symbol table)\n"),
22617 filedata
->file_name
, arch
.index_num
,
22620 current_pos
= ftell (filedata
->handle
);
22622 for (i
= l
= 0; i
< arch
.index_num
; i
++)
22625 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
22628 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
22631 if (member_name
!= NULL
)
22633 char * qualified_name
22634 = make_qualified_name (&arch
, &nested_arch
,
22637 if (qualified_name
!= NULL
)
22639 printf (_("Contents of binary %s at offset "),
22641 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
22643 free (qualified_name
);
22645 free (member_name
);
22649 if (l
>= arch
.sym_size
)
22651 error (_("%s: end of the symbol table reached "
22652 "before the end of the index\n"),
22653 filedata
->file_name
);
22657 /* PR 17531: file: 0b6630b2. */
22658 printf ("\t%.*s\n",
22659 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
22660 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
22663 if (arch
.uses_64bit_indices
)
22668 if (l
< arch
.sym_size
)
22670 error (ngettext ("%s: %" PRId64
" byte remains in the symbol table, "
22671 "but without corresponding entries in "
22672 "the index table\n",
22673 "%s: %" PRId64
" bytes remain in the symbol table, "
22674 "but without corresponding entries in "
22675 "the index table\n",
22676 arch
.sym_size
- l
),
22677 filedata
->file_name
, arch
.sym_size
- l
);
22681 if (fseek64 (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
22683 error (_("%s: failed to seek back to start of object files "
22684 "in the archive\n"),
22685 filedata
->file_name
);
22691 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
22692 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
22693 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
22694 && !do_section_groups
&& !do_dyn_syms
)
22696 ret
= true; /* Archive index only. */
22705 char * qualified_name
;
22707 /* Read the next archive header. */
22708 if (fseek64 (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
22710 error (_("%s: failed to seek to next archive header\n"),
22715 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
22716 if (got
!= sizeof arch
.arhdr
)
22720 /* PR 24049 - we cannot use filedata->file_name as this will
22721 have already been freed. */
22722 error (_("%s: failed to read archive header\n"), arch
.file_name
);
22727 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
22729 error (_("%s: did not find a valid archive header\n"),
22735 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
22737 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
22739 name
= get_archive_member_name (&arch
, &nested_arch
);
22742 error (_("%s: bad archive file name\n"), arch
.file_name
);
22746 namelen
= strlen (name
);
22748 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
22749 if (qualified_name
== NULL
)
22751 error (_("%s: bad archive file name\n"), arch
.file_name
);
22757 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
22759 /* This is a proxy for an external member of a thin archive. */
22760 Filedata
* member_filedata
;
22761 char * member_file_name
= adjust_relative_path
22762 (filedata
->file_name
, name
, namelen
);
22765 if (member_file_name
== NULL
)
22767 free (qualified_name
);
22772 member_filedata
= open_file (member_file_name
, false);
22773 if (member_filedata
== NULL
)
22775 error (_("Input file '%s' is not readable.\n"), member_file_name
);
22776 free (member_file_name
);
22777 free (qualified_name
);
22782 filedata
->archive_file_offset
= arch
.nested_member_origin
;
22783 member_filedata
->file_name
= qualified_name
;
22785 /* The call to process_object() expects the file to be at the beginning. */
22786 rewind (member_filedata
->handle
);
22788 if (! process_object (member_filedata
))
22791 close_file (member_filedata
);
22792 free (member_file_name
);
22794 else if (is_thin_archive
)
22796 Filedata thin_filedata
;
22798 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
22800 /* PR 15140: Allow for corrupt thin archives. */
22801 if (nested_arch
.file
== NULL
)
22803 error (_("%s: contains corrupt thin archive: %s\n"),
22804 qualified_name
, name
);
22805 free (qualified_name
);
22812 /* This is a proxy for a member of a nested archive. */
22813 filedata
->archive_file_offset
22814 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
22816 /* The nested archive file will have been opened and setup by
22817 get_archive_member_name. */
22818 if (fseek64 (nested_arch
.file
, filedata
->archive_file_offset
,
22821 error (_("%s: failed to seek to archive member.\n"),
22822 nested_arch
.file_name
);
22823 free (qualified_name
);
22828 thin_filedata
.handle
= nested_arch
.file
;
22829 thin_filedata
.file_name
= qualified_name
;
22831 if (! process_object (& thin_filedata
))
22837 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
22838 filedata
->file_name
= qualified_name
;
22839 if (! process_object (filedata
))
22841 arch
.next_arhdr_offset
+= (filedata
->archive_file_size
+ 1) & -2;
22842 /* Stop looping with "negative" archive_file_size. */
22843 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
22844 arch
.next_arhdr_offset
= -1ul;
22847 free (qualified_name
);
22851 if (nested_arch
.file
!= NULL
)
22852 fclose (nested_arch
.file
);
22853 release_archive (&nested_arch
);
22854 release_archive (&arch
);
22860 process_file (char * file_name
)
22862 Filedata
* filedata
= NULL
;
22863 struct stat statbuf
;
22864 char armag
[SARMAG
];
22867 if (stat (file_name
, &statbuf
) < 0)
22869 if (errno
== ENOENT
)
22870 error (_("'%s': No such file\n"), file_name
);
22872 error (_("Could not locate '%s'. System error message: %s\n"),
22873 file_name
, strerror (errno
));
22877 if (! S_ISREG (statbuf
.st_mode
))
22879 error (_("'%s' is not an ordinary file\n"), file_name
);
22883 filedata
= calloc (1, sizeof * filedata
);
22884 if (filedata
== NULL
)
22886 error (_("Out of memory allocating file data structure\n"));
22890 filedata
->file_name
= file_name
;
22891 filedata
->handle
= fopen (file_name
, "rb");
22892 if (filedata
->handle
== NULL
)
22894 error (_("Input file '%s' is not readable.\n"), file_name
);
22899 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
22901 error (_("%s: Failed to read file's magic number\n"), file_name
);
22902 fclose (filedata
->handle
);
22907 filedata
->file_size
= statbuf
.st_size
;
22908 filedata
->is_separate
= false;
22910 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
22912 if (! process_archive (filedata
, false))
22915 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
22917 if ( ! process_archive (filedata
, true))
22922 if (do_archive_index
&& !check_all
)
22923 error (_("File %s is not an archive so its index cannot be displayed.\n"),
22926 rewind (filedata
->handle
);
22927 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
22929 if (! process_object (filedata
))
22933 fclose (filedata
->handle
);
22934 free (filedata
->section_headers
);
22935 free (filedata
->program_headers
);
22936 free (filedata
->string_table
);
22937 free (filedata
->dump
.dump_sects
);
22940 free (ba_cache
.strtab
);
22941 ba_cache
.strtab
= NULL
;
22942 free (ba_cache
.symtab
);
22943 ba_cache
.symtab
= NULL
;
22944 ba_cache
.filedata
= NULL
;
22949 #ifdef SUPPORT_DISASSEMBLY
22950 /* Needed by the i386 disassembler. For extra credit, someone could
22951 fix this so that we insert symbolic addresses here, esp for GOT/PLT
22955 print_address (unsigned int addr
, FILE * outfile
)
22957 fprintf (outfile
,"0x%8.8x", addr
);
22960 /* Needed by the i386 disassembler. */
22963 db_task_printsym (unsigned int addr
)
22965 print_address (addr
, stderr
);
22970 main (int argc
, char ** argv
)
22974 #ifdef HAVE_LC_MESSAGES
22975 setlocale (LC_MESSAGES
, "");
22977 setlocale (LC_CTYPE
, "");
22978 bindtextdomain (PACKAGE
, LOCALEDIR
);
22979 textdomain (PACKAGE
);
22981 expandargv (&argc
, &argv
);
22983 parse_args (& cmdline
, argc
, argv
);
22985 if (optind
< (argc
- 1))
22986 /* When displaying information for more than one file,
22987 prefix the information with the file name. */
22989 else if (optind
>= argc
)
22991 /* Ensure that the warning is always displayed. */
22994 warn (_("Nothing to do.\n"));
22999 while (optind
< argc
)
23000 if (! process_file (argv
[optind
++]))
23003 free (cmdline
.dump_sects
);
23005 free (dump_ctf_symtab_name
);
23006 free (dump_ctf_strtab_name
);
23007 free (dump_ctf_parent_name
);
23009 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;