1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2022 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"
68 #include "elf/common.h"
69 #include "elf/external.h"
70 #include "elf/internal.h"
73 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
74 we can obtain the H8 reloc numbers. We need these for the
75 get_reloc_size() function. We include h8.h again after defining
76 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
81 /* Undo the effects of #including reloc-macros.h. */
83 #undef START_RELOC_NUMBERS
87 #undef END_RELOC_NUMBERS
88 #undef _RELOC_MACROS_H
90 /* The following headers use the elf/reloc-macros.h file to
91 automatically generate relocation recognition functions
92 such as elf_mips_reloc_type() */
94 #define RELOC_MACROS_GEN_FUNC
96 #include "elf/aarch64.h"
97 #include "elf/alpha.h"
98 #include "elf/amdgpu.h"
102 #include "elf/bfin.h"
103 #include "elf/cr16.h"
104 #include "elf/cris.h"
106 #include "elf/csky.h"
107 #include "elf/d10v.h"
108 #include "elf/d30v.h"
111 #include "elf/epiphany.h"
112 #include "elf/fr30.h"
114 #include "elf/ft32.h"
116 #include "elf/hppa.h"
117 #include "elf/i386.h"
118 #include "elf/i370.h"
119 #include "elf/i860.h"
120 #include "elf/i960.h"
121 #include "elf/ia64.h"
122 #include "elf/ip2k.h"
123 #include "elf/lm32.h"
124 #include "elf/iq2000.h"
125 #include "elf/m32c.h"
126 #include "elf/m32r.h"
127 #include "elf/m68k.h"
128 #include "elf/m68hc11.h"
129 #include "elf/s12z.h"
130 #include "elf/mcore.h"
132 #include "elf/metag.h"
133 #include "elf/microblaze.h"
134 #include "elf/mips.h"
135 #include "elf/mmix.h"
136 #include "elf/mn10200.h"
137 #include "elf/mn10300.h"
138 #include "elf/moxie.h"
140 #include "elf/msp430.h"
141 #include "elf/nds32.h"
143 #include "elf/nios2.h"
144 #include "elf/or1k.h"
147 #include "elf/ppc64.h"
149 #include "elf/riscv.h"
150 #include "elf/rl78.h"
152 #include "elf/s390.h"
153 #include "elf/score.h"
155 #include "elf/sparc.h"
157 #include "elf/tic6x.h"
158 #include "elf/tilegx.h"
159 #include "elf/tilepro.h"
160 #include "elf/v850.h"
162 #include "elf/visium.h"
163 #include "elf/wasm32.h"
164 #include "elf/x86-64.h"
165 #include "elf/xgate.h"
166 #include "elf/xstormy16.h"
167 #include "elf/xtensa.h"
169 #include "elf/loongarch.h"
172 #include "libiberty.h"
173 #include "safe-ctype.h"
174 #include "filenames.h"
177 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
180 typedef struct elf_section_list
182 Elf_Internal_Shdr
* hdr
;
183 struct elf_section_list
* next
;
186 /* Flag bits indicating particular types of dump. */
187 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
188 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
189 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
190 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
191 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
192 #define CTF_DUMP (1 << 5) /* The --ctf command line switch. */
194 typedef unsigned char dump_type
;
196 /* A linked list of the section names for which dumps were requested. */
197 struct dump_list_entry
201 struct dump_list_entry
* next
;
204 /* A dynamic array of flags indicating for which sections a dump
205 has been requested via command line switches. */
208 dump_type
* dump_sects
;
209 unsigned int num_dump_sects
;
212 static struct dump_data cmdline
;
214 static struct dump_list_entry
* dump_sects_byname
;
216 char * program_name
= "readelf";
218 static bool show_name
= false;
219 static bool do_dynamic
= false;
220 static bool do_syms
= false;
221 static bool do_dyn_syms
= false;
222 static bool do_lto_syms
= false;
223 static bool do_reloc
= false;
224 static bool do_sections
= false;
225 static bool do_section_groups
= false;
226 static bool do_section_details
= false;
227 static bool do_segments
= false;
228 static bool do_unwind
= false;
229 static bool do_using_dynamic
= false;
230 static bool do_header
= false;
231 static bool do_dump
= false;
232 static bool do_version
= false;
233 static bool do_histogram
= false;
234 static bool do_debugging
= false;
235 static bool do_ctf
= false;
236 static bool do_arch
= false;
237 static bool do_notes
= false;
238 static bool do_archive_index
= false;
239 static bool check_all
= false;
240 static bool is_32bit_elf
= false;
241 static bool decompress_dumps
= false;
242 static bool do_not_show_symbol_truncation
= false;
243 static bool do_demangle
= false; /* Pretty print C++ symbol names. */
244 static bool process_links
= false;
245 static bool dump_any_debugging
= false;
246 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
247 static int sym_base
= 0;
249 static char *dump_ctf_parent_name
;
250 static char *dump_ctf_symtab_name
;
251 static char *dump_ctf_strtab_name
;
255 struct group_list
* next
;
256 unsigned int section_index
;
261 struct group_list
* root
;
262 unsigned int group_index
;
265 typedef struct filedata
267 const char * file_name
;
271 Elf_Internal_Ehdr file_header
;
272 unsigned long archive_file_offset
;
273 unsigned long archive_file_size
;
274 /* Everything below this point is cleared out by free_filedata. */
275 Elf_Internal_Shdr
* section_headers
;
276 Elf_Internal_Phdr
* program_headers
;
278 unsigned long string_table_length
;
279 unsigned long dynamic_addr
;
280 uint64_t dynamic_size
;
282 Elf_Internal_Dyn
* dynamic_section
;
283 Elf_Internal_Shdr
* dynamic_strtab_section
;
284 char * dynamic_strings
;
285 unsigned long dynamic_strings_length
;
286 Elf_Internal_Shdr
* dynamic_symtab_section
;
287 unsigned long num_dynamic_syms
;
288 Elf_Internal_Sym
* dynamic_symbols
;
289 uint64_t version_info
[16];
290 unsigned int dynamic_syminfo_nent
;
291 Elf_Internal_Syminfo
* dynamic_syminfo
;
292 unsigned long dynamic_syminfo_offset
;
297 uint64_t ngnubuckets
;
299 uint64_t * gnubuckets
;
300 uint64_t * gnuchains
;
303 char * program_interpreter
;
304 uint64_t dynamic_info
[DT_ENCODING
];
305 uint64_t dynamic_info_DT_GNU_HASH
;
306 uint64_t dynamic_info_DT_MIPS_XHASH
;
307 elf_section_list
* symtab_shndx_list
;
309 struct group
* section_groups
;
310 struct group
** section_headers_groups
;
311 /* A dynamic array of flags indicating for which sections a dump of
312 some kind has been requested. It is reset on a per-object file
313 basis and then initialised from the cmdline_dump_sects array,
314 the results of interpreting the -w switch, and the
315 dump_sects_byname list. */
316 struct dump_data dump
;
319 /* How to print a vma value. */
320 typedef enum print_mode
337 typedef enum unicode_display_type
345 } unicode_display_type
;
347 static unicode_display_type unicode_display
= unicode_default
;
357 /* Versioned symbol info. */
358 enum versioned_symbol_info
365 static const char * get_symbol_version_string
366 (Filedata
*, bool, const char *, unsigned long, unsigned,
367 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
371 static inline const char *
372 section_name (const Filedata
*filedata
, const Elf_Internal_Shdr
*hdr
)
374 return filedata
->string_table
+ hdr
->sh_name
;
378 section_name_valid (const Filedata
*filedata
, const Elf_Internal_Shdr
*hdr
)
381 && filedata
->string_table
!= NULL
382 && hdr
->sh_name
< filedata
->string_table_length
);
385 static inline const char *
386 section_name_print (const Filedata
*filedata
, const Elf_Internal_Shdr
*hdr
)
390 if (filedata
->string_table
== NULL
)
391 return _("<no-strings>");
392 if (hdr
->sh_name
>= filedata
->string_table_length
)
393 return _("<corrupt>");
394 return section_name (filedata
, hdr
);
397 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
400 valid_symbol_name (const char *strtab
, size_t strtab_size
, uint64_t offset
)
402 return strtab
!= NULL
&& offset
< strtab_size
;
406 valid_dynamic_name (const Filedata
*filedata
, uint64_t offset
)
408 return valid_symbol_name (filedata
->dynamic_strings
,
409 filedata
->dynamic_strings_length
, offset
);
412 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
413 already been called and verified that the string exists. */
414 static inline const char *
415 get_dynamic_name (const Filedata
*filedata
, size_t offset
)
417 return filedata
->dynamic_strings
+ offset
;
420 #define REMOVE_ARCH_BITS(ADDR) \
423 if (filedata->file_header.e_machine == EM_ARM) \
428 /* Get the correct GNU hash section name. */
429 #define GNU_HASH_SECTION_NAME(filedata) \
430 filedata->dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
432 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
433 OFFSET + the offset of the current archive member, if we are examining an
434 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
435 allocate a buffer using malloc and fill that. In either case return the
436 pointer to the start of the retrieved data or NULL if something went wrong.
437 If something does go wrong and REASON is not NULL then emit an error
438 message using REASON as part of the context. */
443 unsigned long offset
,
449 uint64_t amt
= size
* nmemb
;
451 if (size
== 0 || nmemb
== 0)
454 /* If size_t is smaller than uint64_t, eg because you are building
455 on a 32-bit host, then make sure that when the sizes are cast to
456 size_t no information is lost. */
457 if ((size_t) size
!= size
458 || (size_t) nmemb
!= nmemb
459 || (size_t) amt
!= amt
460 || amt
/ size
!= nmemb
461 || (size_t) amt
+ 1 == 0)
464 error (_("Size overflow prevents reading %" PRIu64
465 " elements of size %" PRIu64
" for %s\n"),
466 nmemb
, size
, reason
);
470 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
471 attempting to allocate memory when the read is bound to fail. */
472 if (filedata
->archive_file_offset
> filedata
->file_size
473 || offset
> filedata
->file_size
- filedata
->archive_file_offset
474 || amt
> filedata
->file_size
- filedata
->archive_file_offset
- offset
)
477 error (_("Reading %" PRIu64
" bytes extends past end of file for %s\n"),
482 if (fseek (filedata
->handle
, filedata
->archive_file_offset
+ offset
,
486 error (_("Unable to seek to 0x%lx for %s\n"),
487 filedata
->archive_file_offset
+ offset
, reason
);
494 /* + 1 so that we can '\0' terminate invalid string table sections. */
495 mvar
= malloc ((size_t) amt
+ 1);
500 error (_("Out of memory allocating %" PRIu64
" bytes for %s\n"),
505 ((char *) mvar
)[amt
] = '\0';
508 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
511 error (_("Unable to read in %" PRIu64
" bytes of %s\n"),
521 /* Print a VMA value in the MODE specified.
522 Returns the number of characters displayed. */
525 print_vma (uint64_t vma
, print_mode mode
)
536 return nc
+ printf ("%16.16" PRIx64
, vma
);
537 return nc
+ printf ("%8.8" PRIx64
, vma
);
541 return printf ("%5" PRId64
, vma
);
547 return nc
+ printf ("%" PRIx64
, vma
);
553 return nc
+ printf ("%05" PRIx64
, vma
);
556 return printf ("%" PRId64
, vma
);
559 return printf ("%" PRIu64
, vma
);
562 return printf ("%5" PRIu64
, vma
);
565 return printf ("%" PRIo64
, vma
);
568 return printf ("%5" PRIo64
, vma
);
571 /* FIXME: Report unrecognised mode ? */
577 /* Display a symbol on stdout. Handles the display of control characters and
578 multibye characters (assuming the host environment supports them).
580 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
582 If truncation will happen and do_not_show_symbol_truncation is FALSE then display
583 abs(WIDTH) - 5 characters followed by "[...]".
585 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
586 padding as necessary.
588 Returns the number of emitted characters. */
591 print_symbol (signed int width
, const char * symbol
)
593 bool extra_padding
= false;
594 bool do_dots
= false;
595 signed int num_printed
= 0;
596 #ifdef HAVE_MBSTATE_T
599 unsigned int width_remaining
;
600 const void * alloced_symbol
= NULL
;
604 /* Keep the width positive. This helps the code below. */
606 extra_padding
= true;
612 /* Set the remaining width to a very large value.
613 This simplifies the code below. */
614 width_remaining
= INT_MAX
;
617 width_remaining
= width
;
618 if (! do_not_show_symbol_truncation
619 && (int) strlen (symbol
) > width
)
621 width_remaining
-= 5;
622 if ((int) width_remaining
< 0)
628 #ifdef HAVE_MBSTATE_T
629 /* Initialise the multibyte conversion state. */
630 memset (& state
, 0, sizeof (state
));
633 if (do_demangle
&& *symbol
)
635 const char * res
= cplus_demangle (symbol
, demangle_flags
);
638 alloced_symbol
= symbol
= res
;
641 while (width_remaining
)
644 const char c
= *symbol
++;
655 else if (ISCNTRL (c
))
657 /* Do not print control characters directly as they can affect terminal
658 settings. Such characters usually appear in the names generated
659 by the assembler for local labels. */
661 if (width_remaining
< 2)
664 printf ("^%c", c
+ 0x40);
665 width_remaining
-= 2;
670 if (width_remaining
< 5)
673 width_remaining
-= 5;
676 else if (unicode_display
!= unicode_locale
677 && unicode_display
!= unicode_default
)
679 /* Display unicode characters as something else. */
680 unsigned char bytes
[4];
693 bytes
[1] = *symbol
++;
695 if ((bytes
[1] & 0xc0) != 0x80)
698 /* Do not consume this character. It may only
699 be the first byte in the sequence that was
704 else if ((bytes
[0] & 0x20) == 0)
711 bytes
[2] = *symbol
++;
713 if ((bytes
[2] & 0xc0) != 0x80)
719 else if ((bytes
[0] & 0x10) == 0)
726 bytes
[3] = *symbol
++;
730 if ((bytes
[3] & 0xc0) != 0x80)
742 if (unicode_display
== unicode_invalid
)
745 if (unicode_display
== unicode_hex
|| ! is_utf8
)
749 if (width_remaining
< (nbytes
* 2) + 2)
752 putchar (is_utf8
? '<' : '{');
754 for (i
= 0; i
< nbytes
; i
++)
755 printf ("%02x", bytes
[i
]);
756 putchar (is_utf8
? '>' : '}');
760 if (unicode_display
== unicode_highlight
&& isatty (1))
761 printf ("\x1B[31;47m"); /* Red. */
766 if (width_remaining
< 6)
768 printf ("\\u%02x%02x",
769 (bytes
[0] & 0x1c) >> 2,
770 ((bytes
[0] & 0x03) << 6) | (bytes
[1] & 0x3f));
773 if (width_remaining
< 6)
775 printf ("\\u%02x%02x",
776 ((bytes
[0] & 0x0f) << 4) | ((bytes
[1] & 0x3c) >> 2),
777 ((bytes
[1] & 0x03) << 6) | (bytes
[2] & 0x3f));
780 if (width_remaining
< 8)
782 printf ("\\u%02x%02x%02x",
783 ((bytes
[0] & 0x07) << 6) | ((bytes
[1] & 0x3c) >> 2),
784 ((bytes
[1] & 0x03) << 6) | ((bytes
[2] & 0x3c) >> 2),
785 ((bytes
[2] & 0x03) << 6) | (bytes
[3] & 0x3f));
793 if (unicode_display
== unicode_highlight
&& isatty (1))
794 printf ("\033[0m"); /* Default colour. */
797 if (bytes
[nbytes
- 1] == 0)
802 #ifdef HAVE_MBSTATE_T
805 /* Let printf do the hard work of displaying multibyte characters. */
806 printf ("%.1s", symbol
- 1);
810 #ifdef HAVE_MBSTATE_T
811 /* Try to find out how many bytes made up the character that was
812 just printed. Advance the symbol pointer past the bytes that
814 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
818 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
824 num_printed
+= printf ("[...]");
826 if (extra_padding
&& num_printed
< width
)
828 /* Fill in the remaining spaces. */
829 printf ("%-*s", width
- num_printed
, " ");
833 free ((void *) alloced_symbol
);
837 /* Returns a pointer to a static buffer containing a printable version of
838 the given section's name. Like print_symbol, except that it does not try
839 to print multibyte characters, it just interprets them as hex values. */
842 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
844 #define MAX_PRINT_SEC_NAME_LEN 256
845 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
846 const char * name
= section_name_print (filedata
, sec
);
847 char * buf
= sec_name_buf
;
849 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
851 while ((c
= * name
++) != 0)
862 else if (ISPRINT (c
))
869 static char hex
[17] = "0123456789ABCDEF";
874 * buf
++ = hex
[(c
& 0xf0) >> 4];
875 * buf
++ = hex
[c
& 0x0f];
889 printable_section_name_from_index (Filedata
* filedata
, unsigned long ndx
)
891 if (ndx
>= filedata
->file_header
.e_shnum
)
892 return _("<corrupt>");
894 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
897 /* Return a pointer to section NAME, or NULL if no such section exists. */
899 static Elf_Internal_Shdr
*
900 find_section (Filedata
* filedata
, const char * name
)
904 if (filedata
->section_headers
== NULL
)
907 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
908 if (section_name_valid (filedata
, filedata
->section_headers
+ i
)
909 && streq (section_name (filedata
, filedata
->section_headers
+ i
),
911 return filedata
->section_headers
+ i
;
916 /* Return a pointer to a section containing ADDR, or NULL if no such
919 static Elf_Internal_Shdr
*
920 find_section_by_address (Filedata
* filedata
, uint64_t addr
)
924 if (filedata
->section_headers
== NULL
)
927 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
929 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
931 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
938 static Elf_Internal_Shdr
*
939 find_section_by_type (Filedata
* filedata
, unsigned int type
)
943 if (filedata
->section_headers
== NULL
)
946 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
948 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
950 if (sec
->sh_type
== type
)
957 /* Return a pointer to section NAME, or NULL if no such section exists,
958 restricted to the list of sections given in SET. */
960 static Elf_Internal_Shdr
*
961 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
965 if (filedata
->section_headers
== NULL
)
970 while ((i
= *set
++) > 0)
972 /* See PR 21156 for a reproducer. */
973 if (i
>= filedata
->file_header
.e_shnum
)
974 continue; /* FIXME: Should we issue an error message ? */
976 if (section_name_valid (filedata
, filedata
->section_headers
+ i
)
977 && streq (section_name (filedata
, filedata
->section_headers
+ i
),
979 return filedata
->section_headers
+ i
;
983 return find_section (filedata
, name
);
986 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
987 This OS has so many departures from the ELF standard that we test it at
991 is_ia64_vms (Filedata
* filedata
)
993 return filedata
->file_header
.e_machine
== EM_IA_64
994 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
997 /* Guess the relocation size commonly used by the specific machines. */
1000 guess_is_rela (unsigned int e_machine
)
1004 /* Targets that use REL relocations. */
1010 case EM_CYGNUS_D10V
:
1013 case EM_MIPS_RS3_LE
:
1014 case EM_CYGNUS_M32R
:
1021 /* Targets that use RELA relocations. */
1025 case EM_ADAPTEVA_EPIPHANY
:
1027 case EM_ALTERA_NIOS2
:
1029 case EM_ARC_COMPACT
:
1030 case EM_ARC_COMPACT2
:
1039 case EM_CYGNUS_D30V
:
1042 case EM_CYGNUS_FR30
:
1051 case EM_LATTICEMICO32
:
1060 case EM_CYGNUS_MN10200
:
1062 case EM_CYGNUS_MN10300
:
1080 case EM_SPARC32PLUS
:
1088 case EM_CYGNUS_V850
:
1098 case EM_MICROBLAZE_OLD
:
1099 case EM_WEBASSEMBLY
:
1120 warn (_("Don't know about relocations on this machine architecture\n"));
1125 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1126 Returns TRUE upon success, FALSE otherwise. If successful then a
1127 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
1128 and the number of relocs loaded is placed in *NRELASP. It is the caller's
1129 responsibility to free the allocated buffer. */
1132 slurp_rela_relocs (Filedata
* filedata
,
1133 unsigned long rel_offset
,
1134 unsigned long rel_size
,
1135 Elf_Internal_Rela
** relasp
,
1136 unsigned long * nrelasp
)
1138 Elf_Internal_Rela
* relas
;
1144 Elf32_External_Rela
* erelas
;
1146 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
1147 rel_size
, _("32-bit relocation data"));
1151 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
1153 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
1154 sizeof (Elf_Internal_Rela
));
1159 error (_("out of memory parsing relocs\n"));
1163 for (i
= 0; i
< nrelas
; i
++)
1165 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
1166 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
1167 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
1174 Elf64_External_Rela
* erelas
;
1176 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
1177 rel_size
, _("64-bit relocation data"));
1181 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
1183 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
1184 sizeof (Elf_Internal_Rela
));
1189 error (_("out of memory parsing relocs\n"));
1193 for (i
= 0; i
< nrelas
; i
++)
1195 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
1196 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
1197 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
1199 if (filedata
->file_header
.e_machine
== EM_MIPS
1200 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1202 /* In little-endian objects, r_info isn't really a
1203 64-bit little-endian value: it has a 32-bit
1204 little-endian symbol index followed by four
1205 individual byte fields. Reorder INFO
1207 uint64_t inf
= relas
[i
].r_info
;
1208 inf
= (((inf
& 0xffffffff) << 32)
1209 | ((inf
>> 56) & 0xff)
1210 | ((inf
>> 40) & 0xff00)
1211 | ((inf
>> 24) & 0xff0000)
1212 | ((inf
>> 8) & 0xff000000));
1213 relas
[i
].r_info
= inf
;
1225 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1226 Returns TRUE upon success, FALSE otherwise. If successful then a
1227 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1228 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1229 responsibility to free the allocated buffer. */
1232 slurp_rel_relocs (Filedata
* filedata
,
1233 unsigned long rel_offset
,
1234 unsigned long rel_size
,
1235 Elf_Internal_Rela
** relsp
,
1236 unsigned long * nrelsp
)
1238 Elf_Internal_Rela
* rels
;
1244 Elf32_External_Rel
* erels
;
1246 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1247 rel_size
, _("32-bit relocation data"));
1251 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1253 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1258 error (_("out of memory parsing relocs\n"));
1262 for (i
= 0; i
< nrels
; i
++)
1264 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1265 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1266 rels
[i
].r_addend
= 0;
1273 Elf64_External_Rel
* erels
;
1275 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1276 rel_size
, _("64-bit relocation data"));
1280 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1282 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1287 error (_("out of memory parsing relocs\n"));
1291 for (i
= 0; i
< nrels
; i
++)
1293 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1294 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1295 rels
[i
].r_addend
= 0;
1297 if (filedata
->file_header
.e_machine
== EM_MIPS
1298 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1300 /* In little-endian objects, r_info isn't really a
1301 64-bit little-endian value: it has a 32-bit
1302 little-endian symbol index followed by four
1303 individual byte fields. Reorder INFO
1305 uint64_t inf
= rels
[i
].r_info
;
1306 inf
= (((inf
& 0xffffffff) << 32)
1307 | ((inf
>> 56) & 0xff)
1308 | ((inf
>> 40) & 0xff00)
1309 | ((inf
>> 24) & 0xff0000)
1310 | ((inf
>> 8) & 0xff000000));
1311 rels
[i
].r_info
= inf
;
1324 slurp_relr_relocs (Filedata
* filedata
,
1325 unsigned long relr_offset
,
1326 unsigned long relr_size
,
1328 unsigned long * nrelrsp
)
1331 size_t size
= 0, nentries
, i
;
1332 uint64_t base
= 0, addr
, entry
;
1334 relrs
= get_data (NULL
, filedata
, relr_offset
, 1, relr_size
,
1335 _("RELR relocation data"));
1340 nentries
= relr_size
/ sizeof (Elf32_External_Relr
);
1342 nentries
= relr_size
/ sizeof (Elf64_External_Relr
);
1343 for (i
= 0; i
< nentries
; i
++)
1346 entry
= BYTE_GET (((Elf32_External_Relr
*)relrs
)[i
].r_data
);
1348 entry
= BYTE_GET (((Elf64_External_Relr
*)relrs
)[i
].r_data
);
1349 if ((entry
& 1) == 0)
1352 while ((entry
>>= 1) != 0)
1353 if ((entry
& 1) == 1)
1357 *relrsp
= malloc (size
* sizeof (**relrsp
));
1358 if (*relrsp
== NULL
)
1361 error (_("out of memory parsing relocs\n"));
1366 for (i
= 0; i
< nentries
; i
++)
1368 const uint64_t entry_bytes
= is_32bit_elf
? 4 : 8;
1371 entry
= BYTE_GET (((Elf32_External_Relr
*)relrs
)[i
].r_data
);
1373 entry
= BYTE_GET (((Elf64_External_Relr
*)relrs
)[i
].r_data
);
1374 if ((entry
& 1) == 0)
1376 (*relrsp
)[size
++] = entry
;
1377 base
= entry
+ entry_bytes
;
1381 for (addr
= base
; (entry
>>= 1) != 0; addr
+= entry_bytes
)
1382 if ((entry
& 1) != 0)
1383 (*relrsp
)[size
++] = addr
;
1384 base
+= entry_bytes
* (entry_bytes
* CHAR_BIT
- 1);
1393 /* Returns the reloc type extracted from the reloc info field. */
1396 get_reloc_type (Filedata
* filedata
, uint64_t reloc_info
)
1399 return ELF32_R_TYPE (reloc_info
);
1401 switch (filedata
->file_header
.e_machine
)
1404 /* Note: We assume that reloc_info has already been adjusted for us. */
1405 return ELF64_MIPS_R_TYPE (reloc_info
);
1408 return ELF64_R_TYPE_ID (reloc_info
);
1411 return ELF64_R_TYPE (reloc_info
);
1415 /* Return the symbol index extracted from the reloc info field. */
1418 get_reloc_symindex (uint64_t reloc_info
)
1420 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1424 uses_msp430x_relocs (Filedata
* filedata
)
1427 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1428 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1429 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1430 /* TI compiler uses ELFOSABI_NONE. */
1431 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1434 /* Display the contents of the relocation data found at the specified
1438 dump_relocations (Filedata
* filedata
,
1439 unsigned long rel_offset
,
1440 unsigned long rel_size
,
1441 Elf_Internal_Sym
* symtab
,
1442 unsigned long nsyms
,
1444 unsigned long strtablen
,
1445 relocation_type rel_type
,
1449 Elf_Internal_Rela
* rels
;
1452 if (rel_type
== reltype_unknown
)
1453 rel_type
= guess_is_rela (filedata
->file_header
.e_machine
) ? reltype_rela
: reltype_rel
;
1455 if (rel_type
== reltype_rela
)
1457 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1460 else if (rel_type
== reltype_rel
)
1462 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1465 else if (rel_type
== reltype_relr
)
1469 = is_32bit_elf
? "%08" PRIx64
"\n" : "%016" PRIx64
"\n";
1471 if (!slurp_relr_relocs (filedata
, rel_offset
, rel_size
, &relrs
,
1475 printf (ngettext (" %lu offset\n", " %lu offsets\n", rel_size
),
1477 for (i
= 0; i
< rel_size
; i
++)
1478 printf (format
, relrs
[i
]);
1485 if (rel_type
== reltype_rela
)
1488 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1490 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1495 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1497 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1502 if (rel_type
== reltype_rela
)
1505 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1507 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1512 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1514 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1518 for (i
= 0; i
< rel_size
; i
++)
1523 uint64_t symtab_index
;
1526 offset
= rels
[i
].r_offset
;
1527 inf
= rels
[i
].r_info
;
1529 type
= get_reloc_type (filedata
, inf
);
1530 symtab_index
= get_reloc_symindex (inf
);
1534 printf ("%8.8lx %8.8lx ",
1535 (unsigned long) offset
& 0xffffffff,
1536 (unsigned long) inf
& 0xffffffff);
1541 ? "%16.16" PRIx64
" %16.16" PRIx64
" "
1542 : "%12.12" PRIx64
" %12.12" PRIx64
" ",
1546 switch (filedata
->file_header
.e_machine
)
1553 rtype
= elf_aarch64_reloc_type (type
);
1557 case EM_CYGNUS_M32R
:
1558 rtype
= elf_m32r_reloc_type (type
);
1563 rtype
= elf_i386_reloc_type (type
);
1568 rtype
= elf_m68hc11_reloc_type (type
);
1572 rtype
= elf_s12z_reloc_type (type
);
1576 rtype
= elf_m68k_reloc_type (type
);
1580 rtype
= elf_i960_reloc_type (type
);
1585 rtype
= elf_avr_reloc_type (type
);
1588 case EM_OLD_SPARCV9
:
1589 case EM_SPARC32PLUS
:
1592 rtype
= elf_sparc_reloc_type (type
);
1596 rtype
= elf_spu_reloc_type (type
);
1600 rtype
= v800_reloc_type (type
);
1603 case EM_CYGNUS_V850
:
1604 rtype
= v850_reloc_type (type
);
1608 case EM_CYGNUS_D10V
:
1609 rtype
= elf_d10v_reloc_type (type
);
1613 case EM_CYGNUS_D30V
:
1614 rtype
= elf_d30v_reloc_type (type
);
1618 rtype
= elf_dlx_reloc_type (type
);
1622 rtype
= elf_sh_reloc_type (type
);
1626 case EM_CYGNUS_MN10300
:
1627 rtype
= elf_mn10300_reloc_type (type
);
1631 case EM_CYGNUS_MN10200
:
1632 rtype
= elf_mn10200_reloc_type (type
);
1636 case EM_CYGNUS_FR30
:
1637 rtype
= elf_fr30_reloc_type (type
);
1641 rtype
= elf_frv_reloc_type (type
);
1645 rtype
= elf_csky_reloc_type (type
);
1649 rtype
= elf_ft32_reloc_type (type
);
1653 rtype
= elf_mcore_reloc_type (type
);
1657 rtype
= elf_mmix_reloc_type (type
);
1661 rtype
= elf_moxie_reloc_type (type
);
1665 if (uses_msp430x_relocs (filedata
))
1667 rtype
= elf_msp430x_reloc_type (type
);
1672 rtype
= elf_msp430_reloc_type (type
);
1676 rtype
= elf_nds32_reloc_type (type
);
1680 rtype
= elf_ppc_reloc_type (type
);
1684 rtype
= elf_ppc64_reloc_type (type
);
1688 case EM_MIPS_RS3_LE
:
1689 rtype
= elf_mips_reloc_type (type
);
1693 rtype
= elf_riscv_reloc_type (type
);
1697 rtype
= elf_alpha_reloc_type (type
);
1701 rtype
= elf_arm_reloc_type (type
);
1705 case EM_ARC_COMPACT
:
1706 case EM_ARC_COMPACT2
:
1707 rtype
= elf_arc_reloc_type (type
);
1711 rtype
= elf_hppa_reloc_type (type
);
1717 rtype
= elf_h8_reloc_type (type
);
1721 rtype
= elf_or1k_reloc_type (type
);
1726 rtype
= elf_pj_reloc_type (type
);
1729 rtype
= elf_ia64_reloc_type (type
);
1733 rtype
= elf_cris_reloc_type (type
);
1737 rtype
= elf_i860_reloc_type (type
);
1743 rtype
= elf_x86_64_reloc_type (type
);
1747 rtype
= i370_reloc_type (type
);
1752 rtype
= elf_s390_reloc_type (type
);
1756 rtype
= elf_score_reloc_type (type
);
1760 rtype
= elf_xstormy16_reloc_type (type
);
1764 rtype
= elf_crx_reloc_type (type
);
1768 rtype
= elf_vax_reloc_type (type
);
1772 rtype
= elf_visium_reloc_type (type
);
1776 rtype
= elf_bpf_reloc_type (type
);
1779 case EM_ADAPTEVA_EPIPHANY
:
1780 rtype
= elf_epiphany_reloc_type (type
);
1785 rtype
= elf_ip2k_reloc_type (type
);
1789 rtype
= elf_iq2000_reloc_type (type
);
1794 rtype
= elf_xtensa_reloc_type (type
);
1797 case EM_LATTICEMICO32
:
1798 rtype
= elf_lm32_reloc_type (type
);
1803 rtype
= elf_m32c_reloc_type (type
);
1807 rtype
= elf_mt_reloc_type (type
);
1811 rtype
= elf_bfin_reloc_type (type
);
1815 rtype
= elf_mep_reloc_type (type
);
1819 rtype
= elf_cr16_reloc_type (type
);
1823 case EM_MICROBLAZE_OLD
:
1824 rtype
= elf_microblaze_reloc_type (type
);
1828 rtype
= elf_rl78_reloc_type (type
);
1832 rtype
= elf_rx_reloc_type (type
);
1836 rtype
= elf_metag_reloc_type (type
);
1840 rtype
= elf_tic6x_reloc_type (type
);
1844 rtype
= elf_tilegx_reloc_type (type
);
1848 rtype
= elf_tilepro_reloc_type (type
);
1851 case EM_WEBASSEMBLY
:
1852 rtype
= elf_wasm32_reloc_type (type
);
1856 rtype
= elf_xgate_reloc_type (type
);
1859 case EM_ALTERA_NIOS2
:
1860 rtype
= elf_nios2_reloc_type (type
);
1864 rtype
= elf_pru_reloc_type (type
);
1868 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
1869 rtype
= elf_nfp3200_reloc_type (type
);
1871 rtype
= elf_nfp_reloc_type (type
);
1875 rtype
= elf_z80_reloc_type (type
);
1879 rtype
= elf_loongarch_reloc_type (type
);
1883 rtype
= elf_amdgpu_reloc_type (type
);
1888 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1890 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1892 if (filedata
->file_header
.e_machine
== EM_ALPHA
1894 && streq (rtype
, "R_ALPHA_LITUSE")
1895 && rel_type
== reltype_rela
)
1897 switch (rels
[i
].r_addend
)
1899 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1900 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1901 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1902 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1903 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1904 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1905 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1906 default: rtype
= NULL
;
1910 printf (" (%s)", rtype
);
1914 printf (_("<unknown addend: %lx>"),
1915 (unsigned long) rels
[i
].r_addend
);
1919 else if (symtab_index
)
1921 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1923 error (_(" bad symbol index: %08lx in reloc\n"),
1924 (unsigned long) symtab_index
);
1929 Elf_Internal_Sym
* psym
;
1930 const char * version_string
;
1931 enum versioned_symbol_info sym_info
;
1932 unsigned short vna_other
;
1934 psym
= symtab
+ symtab_index
;
1937 = get_symbol_version_string (filedata
, is_dynsym
,
1946 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1950 unsigned int width
= is_32bit_elf
? 8 : 14;
1952 /* Relocations against GNU_IFUNC symbols do not use the value
1953 of the symbol as the address to relocate against. Instead
1954 they invoke the function named by the symbol and use its
1955 result as the address for relocation.
1957 To indicate this to the user, do not display the value of
1958 the symbol in the "Symbols's Value" field. Instead show
1959 its name followed by () as a hint that the symbol is
1963 || psym
->st_name
== 0
1964 || psym
->st_name
>= strtablen
)
1967 name
= strtab
+ psym
->st_name
;
1969 len
= print_symbol (width
, name
);
1971 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1973 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1977 print_vma (psym
->st_value
, LONG_HEX
);
1979 printf (is_32bit_elf
? " " : " ");
1982 if (psym
->st_name
== 0)
1984 const char * sec_name
= "<null>";
1987 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1989 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
1990 && filedata
->section_headers
!= NULL
)
1991 sec_name
= section_name_print (filedata
,
1992 filedata
->section_headers
1994 else if (psym
->st_shndx
== SHN_ABS
)
1996 else if (psym
->st_shndx
== SHN_COMMON
)
1997 sec_name
= "COMMON";
1998 else if ((filedata
->file_header
.e_machine
== EM_MIPS
1999 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
2000 || (filedata
->file_header
.e_machine
== EM_TI_C6000
2001 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
2002 sec_name
= "SCOMMON";
2003 else if (filedata
->file_header
.e_machine
== EM_MIPS
2004 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
2005 sec_name
= "SUNDEF";
2006 else if ((filedata
->file_header
.e_machine
== EM_X86_64
2007 || filedata
->file_header
.e_machine
== EM_L1OM
2008 || filedata
->file_header
.e_machine
== EM_K1OM
)
2009 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
2010 sec_name
= "LARGE_COMMON";
2011 else if (filedata
->file_header
.e_machine
== EM_IA_64
2012 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
2013 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
2014 sec_name
= "ANSI_COM";
2015 else if (is_ia64_vms (filedata
)
2016 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
2017 sec_name
= "VMS_SYMVEC";
2020 sprintf (name_buf
, "<section 0x%x>",
2021 (unsigned int) psym
->st_shndx
);
2022 sec_name
= name_buf
;
2025 print_symbol (22, sec_name
);
2027 else if (strtab
== NULL
)
2028 printf (_("<string table index: %3ld>"), psym
->st_name
);
2029 else if (psym
->st_name
>= strtablen
)
2031 error (_("<corrupt string table index: %3ld>\n"),
2037 print_symbol (22, strtab
+ psym
->st_name
);
2039 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
2043 if (rel_type
== reltype_rela
)
2045 uint64_t off
= rels
[i
].r_addend
;
2047 if ((int64_t) off
< 0)
2048 printf (" - %" PRIx64
, -off
);
2050 printf (" + %" PRIx64
, off
);
2054 else if (rel_type
== reltype_rela
)
2056 uint64_t off
= rels
[i
].r_addend
;
2058 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
2059 if ((int64_t) off
< 0)
2060 printf ("-%" PRIx64
, -off
);
2062 printf ("%" PRIx64
, off
);
2065 if (filedata
->file_header
.e_machine
== EM_SPARCV9
2067 && streq (rtype
, "R_SPARC_OLO10"))
2068 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
2072 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
2074 uint64_t type2
= ELF64_MIPS_R_TYPE2 (inf
);
2075 uint64_t type3
= ELF64_MIPS_R_TYPE3 (inf
);
2076 const char * rtype2
= elf_mips_reloc_type (type2
);
2077 const char * rtype3
= elf_mips_reloc_type (type3
);
2079 printf (" Type2: ");
2082 printf (_("unrecognized: %-7lx"),
2083 (unsigned long) type2
& 0xffffffff);
2085 printf ("%-17.17s", rtype2
);
2087 printf ("\n Type3: ");
2090 printf (_("unrecognized: %-7lx"),
2091 (unsigned long) type3
& 0xffffffff);
2093 printf ("%-17.17s", rtype3
);
2105 get_aarch64_dynamic_type (unsigned long type
)
2109 case DT_AARCH64_BTI_PLT
: return "AARCH64_BTI_PLT";
2110 case DT_AARCH64_PAC_PLT
: return "AARCH64_PAC_PLT";
2111 case DT_AARCH64_VARIANT_PCS
: return "AARCH64_VARIANT_PCS";
2118 get_mips_dynamic_type (unsigned long type
)
2122 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
2123 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
2124 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
2125 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
2126 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
2127 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
2128 case DT_MIPS_MSYM
: return "MIPS_MSYM";
2129 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2130 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2131 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
2132 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
2133 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
2134 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
2135 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
2136 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
2137 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
2138 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
2139 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
2140 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
2141 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
2142 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
2143 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
2144 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
2145 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
2146 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
2147 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
2148 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
2149 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
2150 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
2151 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
2152 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2153 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
2154 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
2155 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
2156 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
2157 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2158 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
2159 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
2160 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
2161 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
2162 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
2163 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
2164 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
2165 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
2166 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
2167 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
2168 case DT_MIPS_XHASH
: return "MIPS_XHASH";
2175 get_sparc64_dynamic_type (unsigned long type
)
2179 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
2186 get_ppc_dynamic_type (unsigned long type
)
2190 case DT_PPC_GOT
: return "PPC_GOT";
2191 case DT_PPC_OPT
: return "PPC_OPT";
2198 get_ppc64_dynamic_type (unsigned long type
)
2202 case DT_PPC64_GLINK
: return "PPC64_GLINK";
2203 case DT_PPC64_OPD
: return "PPC64_OPD";
2204 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
2205 case DT_PPC64_OPT
: return "PPC64_OPT";
2212 get_parisc_dynamic_type (unsigned long type
)
2216 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
2217 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
2218 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
2219 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
2220 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
2221 case DT_HP_PREINIT
: return "HP_PREINIT";
2222 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
2223 case DT_HP_NEEDED
: return "HP_NEEDED";
2224 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
2225 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
2226 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
2227 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
2228 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
2229 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
2230 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
2231 case DT_HP_FILTERED
: return "HP_FILTERED";
2232 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
2233 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
2234 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
2235 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
2236 case DT_PLT
: return "PLT";
2237 case DT_PLT_SIZE
: return "PLT_SIZE";
2238 case DT_DLT
: return "DLT";
2239 case DT_DLT_SIZE
: return "DLT_SIZE";
2246 get_ia64_dynamic_type (unsigned long type
)
2250 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
2251 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
2252 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
2253 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
2254 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
2255 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
2256 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
2257 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
2258 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
2259 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
2260 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
2261 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
2262 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
2263 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
2264 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
2265 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
2266 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
2267 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
2268 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
2269 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
2270 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
2271 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
2272 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
2273 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
2274 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
2275 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
2276 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
2277 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
2278 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
2279 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
2280 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
2287 get_solaris_section_type (unsigned long type
)
2291 case 0x6fffffee: return "SUNW_ancillary";
2292 case 0x6fffffef: return "SUNW_capchain";
2293 case 0x6ffffff0: return "SUNW_capinfo";
2294 case 0x6ffffff1: return "SUNW_symsort";
2295 case 0x6ffffff2: return "SUNW_tlssort";
2296 case 0x6ffffff3: return "SUNW_LDYNSYM";
2297 case 0x6ffffff4: return "SUNW_dof";
2298 case 0x6ffffff5: return "SUNW_cap";
2299 case 0x6ffffff6: return "SUNW_SIGNATURE";
2300 case 0x6ffffff7: return "SUNW_ANNOTATE";
2301 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2302 case 0x6ffffff9: return "SUNW_DEBUG";
2303 case 0x6ffffffa: return "SUNW_move";
2304 case 0x6ffffffb: return "SUNW_COMDAT";
2305 case 0x6ffffffc: return "SUNW_syminfo";
2306 case 0x6ffffffd: return "SUNW_verdef";
2307 case 0x6ffffffe: return "SUNW_verneed";
2308 case 0x6fffffff: return "SUNW_versym";
2309 case 0x70000000: return "SPARC_GOTDATA";
2310 default: return NULL
;
2315 get_alpha_dynamic_type (unsigned long type
)
2319 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2320 default: return NULL
;
2325 get_score_dynamic_type (unsigned long type
)
2329 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2330 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2331 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2332 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2333 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2334 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2335 default: return NULL
;
2340 get_tic6x_dynamic_type (unsigned long type
)
2344 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2345 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2346 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2347 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2348 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2349 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2350 default: return NULL
;
2355 get_nios2_dynamic_type (unsigned long type
)
2359 case DT_NIOS2_GP
: return "NIOS2_GP";
2360 default: return NULL
;
2365 get_solaris_dynamic_type (unsigned long type
)
2369 case 0x6000000d: return "SUNW_AUXILIARY";
2370 case 0x6000000e: return "SUNW_RTLDINF";
2371 case 0x6000000f: return "SUNW_FILTER";
2372 case 0x60000010: return "SUNW_CAP";
2373 case 0x60000011: return "SUNW_SYMTAB";
2374 case 0x60000012: return "SUNW_SYMSZ";
2375 case 0x60000013: return "SUNW_SORTENT";
2376 case 0x60000014: return "SUNW_SYMSORT";
2377 case 0x60000015: return "SUNW_SYMSORTSZ";
2378 case 0x60000016: return "SUNW_TLSSORT";
2379 case 0x60000017: return "SUNW_TLSSORTSZ";
2380 case 0x60000018: return "SUNW_CAPINFO";
2381 case 0x60000019: return "SUNW_STRPAD";
2382 case 0x6000001a: return "SUNW_CAPCHAIN";
2383 case 0x6000001b: return "SUNW_LDMACH";
2384 case 0x6000001d: return "SUNW_CAPCHAINENT";
2385 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2386 case 0x60000021: return "SUNW_PARENT";
2387 case 0x60000023: return "SUNW_ASLR";
2388 case 0x60000025: return "SUNW_RELAX";
2389 case 0x60000029: return "SUNW_NXHEAP";
2390 case 0x6000002b: return "SUNW_NXSTACK";
2392 case 0x70000001: return "SPARC_REGISTER";
2393 case 0x7ffffffd: return "AUXILIARY";
2394 case 0x7ffffffe: return "USED";
2395 case 0x7fffffff: return "FILTER";
2397 default: return NULL
;
2402 get_riscv_dynamic_type (unsigned long type
)
2406 case DT_RISCV_VARIANT_CC
: return "RISCV_VARIANT_CC";
2413 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2415 static char buff
[64];
2419 case DT_NULL
: return "NULL";
2420 case DT_NEEDED
: return "NEEDED";
2421 case DT_PLTRELSZ
: return "PLTRELSZ";
2422 case DT_PLTGOT
: return "PLTGOT";
2423 case DT_HASH
: return "HASH";
2424 case DT_STRTAB
: return "STRTAB";
2425 case DT_SYMTAB
: return "SYMTAB";
2426 case DT_RELA
: return "RELA";
2427 case DT_RELASZ
: return "RELASZ";
2428 case DT_RELAENT
: return "RELAENT";
2429 case DT_STRSZ
: return "STRSZ";
2430 case DT_SYMENT
: return "SYMENT";
2431 case DT_INIT
: return "INIT";
2432 case DT_FINI
: return "FINI";
2433 case DT_SONAME
: return "SONAME";
2434 case DT_RPATH
: return "RPATH";
2435 case DT_SYMBOLIC
: return "SYMBOLIC";
2436 case DT_REL
: return "REL";
2437 case DT_RELSZ
: return "RELSZ";
2438 case DT_RELENT
: return "RELENT";
2439 case DT_RELR
: return "RELR";
2440 case DT_RELRSZ
: return "RELRSZ";
2441 case DT_RELRENT
: return "RELRENT";
2442 case DT_PLTREL
: return "PLTREL";
2443 case DT_DEBUG
: return "DEBUG";
2444 case DT_TEXTREL
: return "TEXTREL";
2445 case DT_JMPREL
: return "JMPREL";
2446 case DT_BIND_NOW
: return "BIND_NOW";
2447 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2448 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2449 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2450 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2451 case DT_RUNPATH
: return "RUNPATH";
2452 case DT_FLAGS
: return "FLAGS";
2454 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2455 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2456 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2458 case DT_CHECKSUM
: return "CHECKSUM";
2459 case DT_PLTPADSZ
: return "PLTPADSZ";
2460 case DT_MOVEENT
: return "MOVEENT";
2461 case DT_MOVESZ
: return "MOVESZ";
2462 case DT_FEATURE
: return "FEATURE";
2463 case DT_POSFLAG_1
: return "POSFLAG_1";
2464 case DT_SYMINSZ
: return "SYMINSZ";
2465 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2467 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2468 case DT_CONFIG
: return "CONFIG";
2469 case DT_DEPAUDIT
: return "DEPAUDIT";
2470 case DT_AUDIT
: return "AUDIT";
2471 case DT_PLTPAD
: return "PLTPAD";
2472 case DT_MOVETAB
: return "MOVETAB";
2473 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2475 case DT_VERSYM
: return "VERSYM";
2477 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2478 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2479 case DT_RELACOUNT
: return "RELACOUNT";
2480 case DT_RELCOUNT
: return "RELCOUNT";
2481 case DT_FLAGS_1
: return "FLAGS_1";
2482 case DT_VERDEF
: return "VERDEF";
2483 case DT_VERDEFNUM
: return "VERDEFNUM";
2484 case DT_VERNEED
: return "VERNEED";
2485 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2487 case DT_AUXILIARY
: return "AUXILIARY";
2488 case DT_USED
: return "USED";
2489 case DT_FILTER
: return "FILTER";
2491 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2492 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2493 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2494 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2495 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2496 case DT_GNU_HASH
: return "GNU_HASH";
2497 case DT_GNU_FLAGS_1
: return "GNU_FLAGS_1";
2500 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2502 const char * result
;
2504 switch (filedata
->file_header
.e_machine
)
2507 result
= get_aarch64_dynamic_type (type
);
2510 case EM_MIPS_RS3_LE
:
2511 result
= get_mips_dynamic_type (type
);
2514 result
= get_sparc64_dynamic_type (type
);
2517 result
= get_ppc_dynamic_type (type
);
2520 result
= get_ppc64_dynamic_type (type
);
2523 result
= get_ia64_dynamic_type (type
);
2526 result
= get_alpha_dynamic_type (type
);
2529 result
= get_score_dynamic_type (type
);
2532 result
= get_tic6x_dynamic_type (type
);
2534 case EM_ALTERA_NIOS2
:
2535 result
= get_nios2_dynamic_type (type
);
2538 result
= get_riscv_dynamic_type (type
);
2541 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2542 result
= get_solaris_dynamic_type (type
);
2551 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2553 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2554 || (filedata
->file_header
.e_machine
== EM_PARISC
2555 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2557 const char * result
;
2559 switch (filedata
->file_header
.e_machine
)
2562 result
= get_parisc_dynamic_type (type
);
2565 result
= get_ia64_dynamic_type (type
);
2568 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2569 result
= get_solaris_dynamic_type (type
);
2578 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2582 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2588 static bool get_program_headers (Filedata
*);
2589 static bool get_dynamic_section (Filedata
*);
2592 locate_dynamic_section (Filedata
*filedata
)
2594 unsigned long dynamic_addr
= 0;
2595 uint64_t dynamic_size
= 0;
2597 if (filedata
->file_header
.e_phnum
!= 0
2598 && get_program_headers (filedata
))
2600 Elf_Internal_Phdr
*segment
;
2603 for (i
= 0, segment
= filedata
->program_headers
;
2604 i
< filedata
->file_header
.e_phnum
;
2607 if (segment
->p_type
== PT_DYNAMIC
)
2609 dynamic_addr
= segment
->p_offset
;
2610 dynamic_size
= segment
->p_filesz
;
2612 if (filedata
->section_headers
!= NULL
)
2614 Elf_Internal_Shdr
*sec
;
2616 sec
= find_section (filedata
, ".dynamic");
2619 if (sec
->sh_size
== 0
2620 || sec
->sh_type
== SHT_NOBITS
)
2627 dynamic_addr
= sec
->sh_offset
;
2628 dynamic_size
= sec
->sh_size
;
2633 if (dynamic_addr
> filedata
->file_size
2634 || (dynamic_size
> filedata
->file_size
- dynamic_addr
))
2643 filedata
->dynamic_addr
= dynamic_addr
;
2644 filedata
->dynamic_size
= dynamic_size
? dynamic_size
: 1;
2648 is_pie (Filedata
*filedata
)
2650 Elf_Internal_Dyn
*entry
;
2652 if (filedata
->dynamic_size
== 0)
2653 locate_dynamic_section (filedata
);
2654 if (filedata
->dynamic_size
<= 1)
2657 if (!get_dynamic_section (filedata
))
2660 for (entry
= filedata
->dynamic_section
;
2661 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
2664 if (entry
->d_tag
== DT_FLAGS_1
)
2666 if ((entry
->d_un
.d_val
& DF_1_PIE
) != 0)
2675 get_file_type (Filedata
*filedata
)
2677 unsigned e_type
= filedata
->file_header
.e_type
;
2678 static char buff
[64];
2682 case ET_NONE
: return _("NONE (None)");
2683 case ET_REL
: return _("REL (Relocatable file)");
2684 case ET_EXEC
: return _("EXEC (Executable file)");
2686 if (is_pie (filedata
))
2687 return _("DYN (Position-Independent Executable file)");
2689 return _("DYN (Shared object file)");
2690 case ET_CORE
: return _("CORE (Core file)");
2693 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2694 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2695 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2696 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2698 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2704 get_machine_name (unsigned e_machine
)
2706 static char buff
[64]; /* XXX */
2710 /* Please keep this switch table sorted by increasing EM_ value. */
2712 case EM_NONE
: return _("None");
2713 case EM_M32
: return "WE32100";
2714 case EM_SPARC
: return "Sparc";
2715 case EM_386
: return "Intel 80386";
2716 case EM_68K
: return "MC68000";
2717 case EM_88K
: return "MC88000";
2718 case EM_IAMCU
: return "Intel MCU";
2719 case EM_860
: return "Intel 80860";
2720 case EM_MIPS
: return "MIPS R3000";
2721 case EM_S370
: return "IBM System/370";
2723 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2724 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2725 case EM_PARISC
: return "HPPA";
2726 case EM_VPP550
: return "Fujitsu VPP500";
2727 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2728 case EM_960
: return "Intel 80960";
2729 case EM_PPC
: return "PowerPC";
2731 case EM_PPC64
: return "PowerPC64";
2733 case EM_S390
: return "IBM S/390";
2734 case EM_SPU
: return "SPU";
2736 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2737 case EM_FR20
: return "Fujitsu FR20";
2738 case EM_RH32
: return "TRW RH32";
2739 case EM_MCORE
: return "MCORE";
2741 case EM_ARM
: return "ARM";
2742 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2743 case EM_SH
: return "Renesas / SuperH SH";
2744 case EM_SPARCV9
: return "Sparc v9";
2745 case EM_TRICORE
: return "Siemens Tricore";
2746 case EM_ARC
: return "ARC";
2747 case EM_H8_300
: return "Renesas H8/300";
2748 case EM_H8_300H
: return "Renesas H8/300H";
2749 case EM_H8S
: return "Renesas H8S";
2750 case EM_H8_500
: return "Renesas H8/500";
2752 case EM_IA_64
: return "Intel IA-64";
2753 case EM_MIPS_X
: return "Stanford MIPS-X";
2754 case EM_COLDFIRE
: return "Motorola Coldfire";
2755 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2756 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2757 case EM_PCP
: return "Siemens PCP";
2758 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2759 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2760 case EM_STARCORE
: return "Motorola Star*Core processor";
2761 case EM_ME16
: return "Toyota ME16 processor";
2763 case EM_ST100
: return "STMicroelectronics ST100 processor";
2764 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2765 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2766 case EM_PDSP
: return "Sony DSP processor";
2767 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2768 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2769 case EM_FX66
: return "Siemens FX66 microcontroller";
2770 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2771 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2772 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2774 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2775 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2776 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2777 case EM_SVX
: return "Silicon Graphics SVx";
2778 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2779 case EM_VAX
: return "Digital VAX";
2780 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2781 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2782 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2783 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2785 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2786 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2787 case EM_PRISM
: return "Vitesse Prism";
2789 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2790 case EM_CYGNUS_FR30
:
2791 case EM_FR30
: return "Fujitsu FR30";
2792 case EM_CYGNUS_D10V
:
2793 case EM_D10V
: return "d10v";
2794 case EM_CYGNUS_D30V
:
2795 case EM_D30V
: return "d30v";
2796 case EM_CYGNUS_V850
:
2797 case EM_V850
: return "Renesas V850";
2798 case EM_CYGNUS_M32R
:
2799 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2800 case EM_CYGNUS_MN10300
:
2801 case EM_MN10300
: return "mn10300";
2803 case EM_CYGNUS_MN10200
:
2804 case EM_MN10200
: return "mn10200";
2805 case EM_PJ
: return "picoJava";
2806 case EM_OR1K
: return "OpenRISC 1000";
2807 case EM_ARC_COMPACT
: return "ARCompact";
2809 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2810 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2811 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2812 case EM_NS32K
: return "National Semiconductor 32000 series";
2813 case EM_TPC
: return "Tenor Network TPC processor";
2814 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2816 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2818 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2819 case EM_MAX
: return "MAX Processor";
2820 case EM_CR
: return "National Semiconductor CompactRISC";
2821 case EM_F2MC16
: return "Fujitsu F2MC16";
2822 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2823 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2824 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2825 case EM_SEP
: return "Sharp embedded microprocessor";
2826 case EM_ARCA
: return "Arca RISC microprocessor";
2828 case EM_UNICORE
: return "Unicore";
2829 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2830 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2831 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2832 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2833 case EM_XGATE
: return "Motorola XGATE embedded processor";
2835 case EM_XC16X
: return "Infineon Technologies xc16x";
2836 case EM_M16C
: return "Renesas M16C series microprocessors";
2837 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2838 case EM_CE
: return "Freescale Communication Engine RISC core";
2840 case EM_M32C
: return "Renesas M32c";
2842 case EM_TSK3000
: return "Altium TSK3000 core";
2843 case EM_RS08
: return "Freescale RS08 embedded processor";
2844 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2845 case EM_SCORE
: return "SUNPLUS S+Core";
2846 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2847 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2848 case EM_LATTICEMICO32
: return "Lattice Mico32";
2849 case EM_SE_C17
: return "Seiko Epson C17 family";
2851 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2852 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2853 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2854 case EM_TI_PRU
: return "TI PRU I/O processor";
2856 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2857 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2858 case EM_R32C
: return "Renesas R32C series microprocessors";
2859 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2860 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2861 case EM_8051
: return "Intel 8051 and variants";
2862 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2863 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2864 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2865 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2867 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2868 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2869 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2870 case EM_RX
: return "Renesas RX";
2871 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2872 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2873 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2876 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2877 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2878 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2880 case EM_L1OM
: return "Intel L1OM";
2881 case EM_K1OM
: return "Intel K1OM";
2882 case EM_INTEL182
: return "Intel (reserved)";
2883 case EM_AARCH64
: return "AArch64";
2884 case EM_ARM184
: return "ARM (reserved)";
2885 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2886 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2887 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2888 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2890 case EM_CUDA
: return "NVIDIA CUDA architecture";
2891 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2892 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2893 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2894 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2895 case EM_ARC_COMPACT2
: return "ARCv2";
2896 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2897 case EM_RL78
: return "Renesas RL78";
2898 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2899 case EM_78K0R
: return "Renesas 78K0R";
2901 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2902 case EM_BA1
: return "Beyond BA1 CPU architecture";
2903 case EM_BA2
: return "Beyond BA2 CPU architecture";
2904 case EM_XCORE
: return "XMOS xCORE processor family";
2905 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2906 case EM_INTELGT
: return "Intel Graphics Technology";
2908 case EM_KM32
: return "KM211 KM32 32-bit processor";
2909 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2910 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2911 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2912 case EM_KVARC
: return "KM211 KVARC processor";
2913 case EM_CDP
: return "Paneve CDP architecture family";
2914 case EM_COGE
: return "Cognitive Smart Memory Processor";
2915 case EM_COOL
: return "Bluechip Systems CoolEngine";
2916 case EM_NORC
: return "Nanoradio Optimized RISC";
2917 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2919 case EM_Z80
: return "Zilog Z80";
2920 case EM_VISIUM
: return "CDS VISIUMcore processor";
2921 case EM_FT32
: return "FTDI Chip FT32";
2922 case EM_MOXIE
: return "Moxie";
2923 case EM_AMDGPU
: return "AMD GPU";
2924 /* 230 (all reserved) */
2926 case EM_RISCV
: return "RISC-V";
2927 case EM_LANAI
: return "Lanai 32-bit processor";
2928 case EM_CEVA
: return "CEVA Processor Architecture Family";
2929 case EM_CEVA_X2
: return "CEVA X2 Processor Family";
2930 case EM_BPF
: return "Linux BPF";
2931 case EM_GRAPHCORE_IPU
: return "Graphcore Intelligent Processing Unit";
2932 case EM_IMG1
: return "Imagination Technologies";
2934 case EM_NFP
: return "Netronome Flow Processor";
2935 case EM_VE
: return "NEC Vector Engine";
2936 case EM_CSKY
: return "C-SKY";
2937 case EM_ARC_COMPACT3_64
: return "Synopsys ARCv2.3 64-bit";
2938 case EM_MCS6502
: return "MOS Technology MCS 6502 processor";
2939 case EM_ARC_COMPACT3
: return "Synopsys ARCv2.3 32-bit";
2940 case EM_KVX
: return "Kalray VLIW core of the MPPA processor family";
2941 case EM_65816
: return "WDC 65816/65C816";
2942 case EM_LOONGARCH
: return "LoongArch";
2943 case EM_KF32
: return "ChipON KungFu32";
2945 /* Large numbers... */
2946 case EM_MT
: return "Morpho Techologies MT processor";
2947 case EM_ALPHA
: return "Alpha";
2948 case EM_WEBASSEMBLY
: return "Web Assembly";
2949 case EM_DLX
: return "OpenDLX";
2950 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2951 case EM_IQ2000
: return "Vitesse IQ2000";
2953 case EM_NIOS32
: return "Altera Nios";
2954 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2955 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2956 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2957 case EM_S12Z
: return "Freescale S12Z";
2960 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2966 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2968 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2969 other compilers don't specify an architecture type in the e_flags, and
2970 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2971 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2974 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2975 but also sets a specific architecture type in the e_flags field.
2977 However, when decoding the flags we don't worry if we see an
2978 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2979 ARCEM architecture type. */
2981 switch (e_flags
& EF_ARC_MACH_MSK
)
2983 /* We only expect these to occur for EM_ARC_COMPACT2. */
2984 case EF_ARC_CPU_ARCV2EM
:
2985 strcat (buf
, ", ARC EM");
2987 case EF_ARC_CPU_ARCV2HS
:
2988 strcat (buf
, ", ARC HS");
2991 /* We only expect these to occur for EM_ARC_COMPACT. */
2992 case E_ARC_MACH_ARC600
:
2993 strcat (buf
, ", ARC600");
2995 case E_ARC_MACH_ARC601
:
2996 strcat (buf
, ", ARC601");
2998 case E_ARC_MACH_ARC700
:
2999 strcat (buf
, ", ARC700");
3002 /* The only times we should end up here are (a) A corrupt ELF, (b) A
3003 new ELF with new architecture being read by an old version of
3004 readelf, or (c) An ELF built with non-GNU compiler that does not
3005 set the architecture in the e_flags. */
3007 if (e_machine
== EM_ARC_COMPACT
)
3008 strcat (buf
, ", Unknown ARCompact");
3010 strcat (buf
, ", Unknown ARC");
3014 switch (e_flags
& EF_ARC_OSABI_MSK
)
3016 case E_ARC_OSABI_ORIG
:
3017 strcat (buf
, ", (ABI:legacy)");
3019 case E_ARC_OSABI_V2
:
3020 strcat (buf
, ", (ABI:v2)");
3022 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
3023 case E_ARC_OSABI_V3
:
3024 strcat (buf
, ", v3 no-legacy-syscalls ABI");
3026 case E_ARC_OSABI_V4
:
3027 strcat (buf
, ", v4 ABI");
3030 strcat (buf
, ", unrecognised ARC OSABI flag");
3036 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
3039 bool unknown
= false;
3041 eabi
= EF_ARM_EABI_VERSION (e_flags
);
3042 e_flags
&= ~ EF_ARM_EABIMASK
;
3044 /* Handle "generic" ARM flags. */
3045 if (e_flags
& EF_ARM_RELEXEC
)
3047 strcat (buf
, ", relocatable executable");
3048 e_flags
&= ~ EF_ARM_RELEXEC
;
3051 if (e_flags
& EF_ARM_PIC
)
3053 strcat (buf
, ", position independent");
3054 e_flags
&= ~ EF_ARM_PIC
;
3057 /* Now handle EABI specific flags. */
3061 strcat (buf
, ", <unrecognized EABI>");
3066 case EF_ARM_EABI_VER1
:
3067 strcat (buf
, ", Version1 EABI");
3072 /* Process flags one bit at a time. */
3073 flag
= e_flags
& - e_flags
;
3078 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
3079 strcat (buf
, ", sorted symbol tables");
3089 case EF_ARM_EABI_VER2
:
3090 strcat (buf
, ", Version2 EABI");
3095 /* Process flags one bit at a time. */
3096 flag
= e_flags
& - e_flags
;
3101 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
3102 strcat (buf
, ", sorted symbol tables");
3105 case EF_ARM_DYNSYMSUSESEGIDX
:
3106 strcat (buf
, ", dynamic symbols use segment index");
3109 case EF_ARM_MAPSYMSFIRST
:
3110 strcat (buf
, ", mapping symbols precede others");
3120 case EF_ARM_EABI_VER3
:
3121 strcat (buf
, ", Version3 EABI");
3124 case EF_ARM_EABI_VER4
:
3125 strcat (buf
, ", Version4 EABI");
3130 /* Process flags one bit at a time. */
3131 flag
= e_flags
& - e_flags
;
3137 strcat (buf
, ", BE8");
3141 strcat (buf
, ", LE8");
3151 case EF_ARM_EABI_VER5
:
3152 strcat (buf
, ", Version5 EABI");
3157 /* Process flags one bit at a time. */
3158 flag
= e_flags
& - e_flags
;
3164 strcat (buf
, ", BE8");
3168 strcat (buf
, ", LE8");
3171 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
3172 strcat (buf
, ", soft-float ABI");
3175 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
3176 strcat (buf
, ", hard-float ABI");
3186 case EF_ARM_EABI_UNKNOWN
:
3187 strcat (buf
, ", GNU EABI");
3192 /* Process flags one bit at a time. */
3193 flag
= e_flags
& - e_flags
;
3198 case EF_ARM_INTERWORK
:
3199 strcat (buf
, ", interworking enabled");
3202 case EF_ARM_APCS_26
:
3203 strcat (buf
, ", uses APCS/26");
3206 case EF_ARM_APCS_FLOAT
:
3207 strcat (buf
, ", uses APCS/float");
3211 strcat (buf
, ", position independent");
3215 strcat (buf
, ", 8 bit structure alignment");
3218 case EF_ARM_NEW_ABI
:
3219 strcat (buf
, ", uses new ABI");
3222 case EF_ARM_OLD_ABI
:
3223 strcat (buf
, ", uses old ABI");
3226 case EF_ARM_SOFT_FLOAT
:
3227 strcat (buf
, ", software FP");
3230 case EF_ARM_VFP_FLOAT
:
3231 strcat (buf
, ", VFP");
3234 case EF_ARM_MAVERICK_FLOAT
:
3235 strcat (buf
, ", Maverick FP");
3246 strcat (buf
,_(", <unknown>"));
3250 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
3252 --size
; /* Leave space for null terminator. */
3254 switch (e_flags
& EF_AVR_MACH
)
3256 case E_AVR_MACH_AVR1
:
3257 strncat (buf
, ", avr:1", size
);
3259 case E_AVR_MACH_AVR2
:
3260 strncat (buf
, ", avr:2", size
);
3262 case E_AVR_MACH_AVR25
:
3263 strncat (buf
, ", avr:25", size
);
3265 case E_AVR_MACH_AVR3
:
3266 strncat (buf
, ", avr:3", size
);
3268 case E_AVR_MACH_AVR31
:
3269 strncat (buf
, ", avr:31", size
);
3271 case E_AVR_MACH_AVR35
:
3272 strncat (buf
, ", avr:35", size
);
3274 case E_AVR_MACH_AVR4
:
3275 strncat (buf
, ", avr:4", size
);
3277 case E_AVR_MACH_AVR5
:
3278 strncat (buf
, ", avr:5", size
);
3280 case E_AVR_MACH_AVR51
:
3281 strncat (buf
, ", avr:51", size
);
3283 case E_AVR_MACH_AVR6
:
3284 strncat (buf
, ", avr:6", size
);
3286 case E_AVR_MACH_AVRTINY
:
3287 strncat (buf
, ", avr:100", size
);
3289 case E_AVR_MACH_XMEGA1
:
3290 strncat (buf
, ", avr:101", size
);
3292 case E_AVR_MACH_XMEGA2
:
3293 strncat (buf
, ", avr:102", size
);
3295 case E_AVR_MACH_XMEGA3
:
3296 strncat (buf
, ", avr:103", size
);
3298 case E_AVR_MACH_XMEGA4
:
3299 strncat (buf
, ", avr:104", size
);
3301 case E_AVR_MACH_XMEGA5
:
3302 strncat (buf
, ", avr:105", size
);
3304 case E_AVR_MACH_XMEGA6
:
3305 strncat (buf
, ", avr:106", size
);
3307 case E_AVR_MACH_XMEGA7
:
3308 strncat (buf
, ", avr:107", size
);
3311 strncat (buf
, ", avr:<unknown>", size
);
3315 size
-= strlen (buf
);
3316 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
3317 strncat (buf
, ", link-relax", size
);
3321 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
3327 bool has_fpu
= false;
3330 static const char *ABI_STRINGS
[] =
3332 "ABI v0", /* use r5 as return register; only used in N1213HC */
3333 "ABI v1", /* use r0 as return register */
3334 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
3335 "ABI v2fp", /* for FPU */
3339 static const char *VER_STRINGS
[] =
3341 "Andes ELF V1.3 or older",
3345 static const char *ARCH_STRINGS
[] =
3354 abi
= EF_NDS_ABI
& e_flags
;
3355 arch
= EF_NDS_ARCH
& e_flags
;
3356 config
= EF_NDS_INST
& e_flags
;
3357 version
= EF_NDS32_ELF_VERSION
& e_flags
;
3359 memset (buf
, 0, size
);
3366 case E_NDS_ABI_V2FP
:
3367 case E_NDS_ABI_AABI
:
3368 case E_NDS_ABI_V2FP_PLUS
:
3369 /* In case there are holes in the array. */
3370 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
3374 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
3380 case E_NDS32_ELF_VER_1_2
:
3381 case E_NDS32_ELF_VER_1_3
:
3382 case E_NDS32_ELF_VER_1_4
:
3383 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
3387 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
3391 if (E_NDS_ABI_V0
== abi
)
3393 /* OLD ABI; only used in N1213HC, has performance extension 1. */
3394 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
3395 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3396 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
3402 case E_NDS_ARCH_STAR_V1_0
:
3403 case E_NDS_ARCH_STAR_V2_0
:
3404 case E_NDS_ARCH_STAR_V3_0
:
3405 case E_NDS_ARCH_STAR_V3_M
:
3406 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
3410 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
3411 /* ARCH version determines how the e_flags are interpreted.
3412 If it is unknown, we cannot proceed. */
3416 /* Newer ABI; Now handle architecture specific flags. */
3417 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3419 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3420 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
3422 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
3423 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
3425 if (config
& E_NDS32_HAS_DIV_INST
)
3426 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
3428 if (config
& E_NDS32_HAS_16BIT_INST
)
3429 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3433 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3435 if (version
<= E_NDS32_ELF_VER_1_3
)
3436 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
3438 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
3441 if (config
& E_NDS32_HAS_MAC_DX_INST
)
3442 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
3444 if (config
& E_NDS32_HAS_DIV_DX_INST
)
3445 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
3447 if (config
& E_NDS32_HAS_16BIT_INST
)
3449 if (version
<= E_NDS32_ELF_VER_1_3
)
3450 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3452 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3456 if (config
& E_NDS32_HAS_EXT_INST
)
3457 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3459 if (config
& E_NDS32_HAS_EXT2_INST
)
3460 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3462 if (config
& E_NDS32_HAS_FPU_INST
)
3465 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3468 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3471 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3474 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3477 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3482 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3484 case E_NDS32_FPU_REG_8SP_4DP
:
3485 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3487 case E_NDS32_FPU_REG_16SP_8DP
:
3488 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3490 case E_NDS32_FPU_REG_32SP_16DP
:
3491 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3493 case E_NDS32_FPU_REG_32SP_32DP
:
3494 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3499 if (config
& E_NDS32_HAS_AUDIO_INST
)
3500 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3502 if (config
& E_NDS32_HAS_STRING_INST
)
3503 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3505 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3506 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3508 if (config
& E_NDS32_HAS_VIDEO_INST
)
3510 if (version
<= E_NDS32_ELF_VER_1_3
)
3511 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3513 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3516 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3517 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3519 if (config
& E_NDS32_HAS_L2C_INST
)
3520 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3524 decode_AMDGPU_machine_flags (Filedata
*filedata
, unsigned int e_flags
,
3527 unsigned char *e_ident
= filedata
->file_header
.e_ident
;
3528 unsigned char osabi
= e_ident
[EI_OSABI
];
3529 unsigned char abiversion
= e_ident
[EI_ABIVERSION
];
3532 /* HSA OS ABI v2 used a different encoding, but we don't need to support it,
3533 it has been deprecated for a while.
3535 The PAL, MESA3D and NONE OS ABIs are not properly versioned, at the time
3536 of writing, they use the same flags as HSA v3, so the code below uses that
3538 if (osabi
== ELFOSABI_AMDGPU_HSA
&& abiversion
< ELFABIVERSION_AMDGPU_HSA_V3
)
3541 mach
= e_flags
& EF_AMDGPU_MACH
;
3544 #define AMDGPU_CASE(code, string) \
3545 case code: strcat (buf, ", " string); break;
3546 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX600
, "gfx600")
3547 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX601
, "gfx601")
3548 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX700
, "gfx700")
3549 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX701
, "gfx701")
3550 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX702
, "gfx702")
3551 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX703
, "gfx703")
3552 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX704
, "gfx704")
3553 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX801
, "gfx801")
3554 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX802
, "gfx802")
3555 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX803
, "gfx803")
3556 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX810
, "gfx810")
3557 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX900
, "gfx900")
3558 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX902
, "gfx902")
3559 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX904
, "gfx904")
3560 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX906
, "gfx906")
3561 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX908
, "gfx908")
3562 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX909
, "gfx909")
3563 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX90C
, "gfx90c")
3564 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1010
, "gfx1010")
3565 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1011
, "gfx1011")
3566 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1012
, "gfx1012")
3567 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1030
, "gfx1030")
3568 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1031
, "gfx1031")
3569 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1032
, "gfx1032")
3570 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1033
, "gfx1033")
3571 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX602
, "gfx602")
3572 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX705
, "gfx705")
3573 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX805
, "gfx805")
3574 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1035
, "gfx1035")
3575 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1034
, "gfx1034")
3576 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX90A
, "gfx90a")
3577 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX940
, "gfx940")
3578 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1013
, "gfx1013")
3579 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1036
, "gfx1036")
3581 sprintf (buf
, _(", <unknown AMDGPU GPU type: %#x>"), mach
);
3586 buf
+= strlen (buf
);
3587 e_flags
&= ~EF_AMDGPU_MACH
;
3589 if ((osabi
== ELFOSABI_AMDGPU_HSA
3590 && abiversion
== ELFABIVERSION_AMDGPU_HSA_V3
)
3591 || osabi
!= ELFOSABI_AMDGPU_HSA
)
3593 /* For HSA v3 and other OS ABIs. */
3594 if (e_flags
& EF_AMDGPU_FEATURE_XNACK_V3
)
3596 strcat (buf
, ", xnack on");
3597 buf
+= strlen (buf
);
3598 e_flags
&= ~EF_AMDGPU_FEATURE_XNACK_V3
;
3601 if (e_flags
& EF_AMDGPU_FEATURE_SRAMECC_V3
)
3603 strcat (buf
, ", sramecc on");
3604 buf
+= strlen (buf
);
3605 e_flags
&= ~EF_AMDGPU_FEATURE_SRAMECC_V3
;
3613 xnack
= e_flags
& EF_AMDGPU_FEATURE_XNACK_V4
;
3616 case EF_AMDGPU_FEATURE_XNACK_UNSUPPORTED_V4
:
3619 case EF_AMDGPU_FEATURE_XNACK_ANY_V4
:
3620 strcat (buf
, ", xnack any");
3623 case EF_AMDGPU_FEATURE_XNACK_OFF_V4
:
3624 strcat (buf
, ", xnack off");
3627 case EF_AMDGPU_FEATURE_XNACK_ON_V4
:
3628 strcat (buf
, ", xnack on");
3632 sprintf (buf
, _(", <unknown xnack value: %#x>"), xnack
);
3636 buf
+= strlen (buf
);
3637 e_flags
&= ~EF_AMDGPU_FEATURE_XNACK_V4
;
3639 sramecc
= e_flags
& EF_AMDGPU_FEATURE_SRAMECC_V4
;
3642 case EF_AMDGPU_FEATURE_SRAMECC_UNSUPPORTED_V4
:
3645 case EF_AMDGPU_FEATURE_SRAMECC_ANY_V4
:
3646 strcat (buf
, ", sramecc any");
3649 case EF_AMDGPU_FEATURE_SRAMECC_OFF_V4
:
3650 strcat (buf
, ", sramecc off");
3653 case EF_AMDGPU_FEATURE_SRAMECC_ON_V4
:
3654 strcat (buf
, ", sramecc on");
3658 sprintf (buf
, _(", <unknown sramecc value: %#x>"), sramecc
);
3662 buf
+= strlen (buf
);
3663 e_flags
&= ~EF_AMDGPU_FEATURE_SRAMECC_V4
;
3667 sprintf (buf
, _(", unknown flags bits: %#x"), e_flags
);
3671 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3673 static char buf
[1024];
3684 case EM_ARC_COMPACT2
:
3685 case EM_ARC_COMPACT
:
3686 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3690 decode_ARM_machine_flags (e_flags
, buf
);
3694 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3698 if (e_flags
& EF_BFIN_PIC
)
3699 strcat (buf
, ", PIC");
3701 if (e_flags
& EF_BFIN_FDPIC
)
3702 strcat (buf
, ", FDPIC");
3704 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3705 strcat (buf
, ", code in L1");
3707 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3708 strcat (buf
, ", data in L1");
3713 switch (e_flags
& EF_FRV_CPU_MASK
)
3715 case EF_FRV_CPU_GENERIC
:
3719 strcat (buf
, ", fr???");
3722 case EF_FRV_CPU_FR300
:
3723 strcat (buf
, ", fr300");
3726 case EF_FRV_CPU_FR400
:
3727 strcat (buf
, ", fr400");
3729 case EF_FRV_CPU_FR405
:
3730 strcat (buf
, ", fr405");
3733 case EF_FRV_CPU_FR450
:
3734 strcat (buf
, ", fr450");
3737 case EF_FRV_CPU_FR500
:
3738 strcat (buf
, ", fr500");
3740 case EF_FRV_CPU_FR550
:
3741 strcat (buf
, ", fr550");
3744 case EF_FRV_CPU_SIMPLE
:
3745 strcat (buf
, ", simple");
3747 case EF_FRV_CPU_TOMCAT
:
3748 strcat (buf
, ", tomcat");
3754 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3755 strcat (buf
, ", m68000");
3756 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3757 strcat (buf
, ", cpu32");
3758 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3759 strcat (buf
, ", fido_a");
3762 char const * isa
= _("unknown");
3763 char const * mac
= _("unknown mac");
3764 char const * additional
= NULL
;
3766 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3768 case EF_M68K_CF_ISA_A_NODIV
:
3770 additional
= ", nodiv";
3772 case EF_M68K_CF_ISA_A
:
3775 case EF_M68K_CF_ISA_A_PLUS
:
3778 case EF_M68K_CF_ISA_B_NOUSP
:
3780 additional
= ", nousp";
3782 case EF_M68K_CF_ISA_B
:
3785 case EF_M68K_CF_ISA_C
:
3788 case EF_M68K_CF_ISA_C_NODIV
:
3790 additional
= ", nodiv";
3793 strcat (buf
, ", cf, isa ");
3796 strcat (buf
, additional
);
3797 if (e_flags
& EF_M68K_CF_FLOAT
)
3798 strcat (buf
, ", float");
3799 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3804 case EF_M68K_CF_MAC
:
3807 case EF_M68K_CF_EMAC
:
3810 case EF_M68K_CF_EMAC_B
:
3823 decode_AMDGPU_machine_flags (filedata
, e_flags
, buf
);
3827 switch (e_flags
& EF_MEP_CPU_MASK
)
3829 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3830 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3831 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3832 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3833 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3834 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3835 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3838 switch (e_flags
& EF_MEP_COP_MASK
)
3840 case EF_MEP_COP_NONE
: break;
3841 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3842 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3843 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3844 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3845 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3848 if (e_flags
& EF_MEP_LIBRARY
)
3849 strcat (buf
, ", Built for Library");
3851 if (e_flags
& EF_MEP_INDEX_MASK
)
3852 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3853 e_flags
& EF_MEP_INDEX_MASK
);
3855 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3856 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3857 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3861 if (e_flags
& EF_PPC_EMB
)
3862 strcat (buf
, ", emb");
3864 if (e_flags
& EF_PPC_RELOCATABLE
)
3865 strcat (buf
, _(", relocatable"));
3867 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3868 strcat (buf
, _(", relocatable-lib"));
3872 if (e_flags
& EF_PPC64_ABI
)
3874 char abi
[] = ", abiv0";
3876 abi
[6] += e_flags
& EF_PPC64_ABI
;
3882 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3883 strcat (buf
, ", RH850 ABI");
3885 if (e_flags
& EF_V800_850E3
)
3886 strcat (buf
, ", V3 architecture");
3888 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3889 strcat (buf
, ", FPU not used");
3891 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3892 strcat (buf
, ", regmode: COMMON");
3894 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3895 strcat (buf
, ", r4 not used");
3897 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3898 strcat (buf
, ", r30 not used");
3900 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3901 strcat (buf
, ", r5 not used");
3903 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3904 strcat (buf
, ", r2 not used");
3906 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3908 switch (e_flags
& - e_flags
)
3910 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3911 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3912 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3913 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3914 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3915 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3916 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3917 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3918 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3919 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3920 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3921 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3928 case EM_CYGNUS_V850
:
3929 switch (e_flags
& EF_V850_ARCH
)
3931 case E_V850E3V5_ARCH
:
3932 strcat (buf
, ", v850e3v5");
3934 case E_V850E2V3_ARCH
:
3935 strcat (buf
, ", v850e2v3");
3938 strcat (buf
, ", v850e2");
3941 strcat (buf
, ", v850e1");
3944 strcat (buf
, ", v850e");
3947 strcat (buf
, ", v850");
3950 strcat (buf
, _(", unknown v850 architecture variant"));
3956 case EM_CYGNUS_M32R
:
3957 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3958 strcat (buf
, ", m32r");
3962 case EM_MIPS_RS3_LE
:
3963 if (e_flags
& EF_MIPS_NOREORDER
)
3964 strcat (buf
, ", noreorder");
3966 if (e_flags
& EF_MIPS_PIC
)
3967 strcat (buf
, ", pic");
3969 if (e_flags
& EF_MIPS_CPIC
)
3970 strcat (buf
, ", cpic");
3972 if (e_flags
& EF_MIPS_UCODE
)
3973 strcat (buf
, ", ugen_reserved");
3975 if (e_flags
& EF_MIPS_ABI2
)
3976 strcat (buf
, ", abi2");
3978 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3979 strcat (buf
, ", odk first");
3981 if (e_flags
& EF_MIPS_32BITMODE
)
3982 strcat (buf
, ", 32bitmode");
3984 if (e_flags
& EF_MIPS_NAN2008
)
3985 strcat (buf
, ", nan2008");
3987 if (e_flags
& EF_MIPS_FP64
)
3988 strcat (buf
, ", fp64");
3990 switch ((e_flags
& EF_MIPS_MACH
))
3992 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3993 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3994 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3995 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3996 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3997 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3998 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3999 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
4000 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
4001 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
4002 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
4003 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
4004 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
4005 case E_MIPS_MACH_GS464
: strcat (buf
, ", gs464"); break;
4006 case E_MIPS_MACH_GS464E
: strcat (buf
, ", gs464e"); break;
4007 case E_MIPS_MACH_GS264E
: strcat (buf
, ", gs264e"); break;
4008 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
4009 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
4010 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
4011 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
4012 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
4014 /* We simply ignore the field in this case to avoid confusion:
4015 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
4018 default: strcat (buf
, _(", unknown CPU")); break;
4021 switch ((e_flags
& EF_MIPS_ABI
))
4023 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
4024 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
4025 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
4026 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
4028 /* We simply ignore the field in this case to avoid confusion:
4029 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
4030 This means it is likely to be an o32 file, but not for
4033 default: strcat (buf
, _(", unknown ABI")); break;
4036 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
4037 strcat (buf
, ", mdmx");
4039 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
4040 strcat (buf
, ", mips16");
4042 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
4043 strcat (buf
, ", micromips");
4045 switch ((e_flags
& EF_MIPS_ARCH
))
4047 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
4048 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
4049 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
4050 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
4051 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
4052 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
4053 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
4054 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
4055 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
4056 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
4057 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
4058 default: strcat (buf
, _(", unknown ISA")); break;
4063 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
4067 switch (EF_NFP_MACH (e_flags
))
4069 case E_NFP_MACH_3200
:
4070 strcat (buf
, ", NFP-32xx");
4072 case E_NFP_MACH_6000
:
4073 strcat (buf
, ", NFP-6xxx");
4079 if (e_flags
& EF_RISCV_RVC
)
4080 strcat (buf
, ", RVC");
4082 if (e_flags
& EF_RISCV_RVE
)
4083 strcat (buf
, ", RVE");
4085 if (e_flags
& EF_RISCV_TSO
)
4086 strcat (buf
, ", TSO");
4088 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
4090 case EF_RISCV_FLOAT_ABI_SOFT
:
4091 strcat (buf
, ", soft-float ABI");
4094 case EF_RISCV_FLOAT_ABI_SINGLE
:
4095 strcat (buf
, ", single-float ABI");
4098 case EF_RISCV_FLOAT_ABI_DOUBLE
:
4099 strcat (buf
, ", double-float ABI");
4102 case EF_RISCV_FLOAT_ABI_QUAD
:
4103 strcat (buf
, ", quad-float ABI");
4109 switch ((e_flags
& EF_SH_MACH_MASK
))
4111 case EF_SH1
: strcat (buf
, ", sh1"); break;
4112 case EF_SH2
: strcat (buf
, ", sh2"); break;
4113 case EF_SH3
: strcat (buf
, ", sh3"); break;
4114 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
4115 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
4116 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
4117 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
4118 case EF_SH4
: strcat (buf
, ", sh4"); break;
4119 case EF_SH5
: strcat (buf
, ", sh5"); break;
4120 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
4121 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
4122 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
4123 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
4124 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
4125 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
4126 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
4127 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
4128 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
4129 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
4130 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
4131 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
4132 default: strcat (buf
, _(", unknown ISA")); break;
4135 if (e_flags
& EF_SH_PIC
)
4136 strcat (buf
, ", pic");
4138 if (e_flags
& EF_SH_FDPIC
)
4139 strcat (buf
, ", fdpic");
4143 if (e_flags
& EF_OR1K_NODELAY
)
4144 strcat (buf
, ", no delay");
4148 if (e_flags
& EF_SPARC_32PLUS
)
4149 strcat (buf
, ", v8+");
4151 if (e_flags
& EF_SPARC_SUN_US1
)
4152 strcat (buf
, ", ultrasparcI");
4154 if (e_flags
& EF_SPARC_SUN_US3
)
4155 strcat (buf
, ", ultrasparcIII");
4157 if (e_flags
& EF_SPARC_HAL_R1
)
4158 strcat (buf
, ", halr1");
4160 if (e_flags
& EF_SPARC_LEDATA
)
4161 strcat (buf
, ", ledata");
4163 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
4164 strcat (buf
, ", tso");
4166 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
4167 strcat (buf
, ", pso");
4169 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
4170 strcat (buf
, ", rmo");
4174 switch (e_flags
& EF_PARISC_ARCH
)
4176 case EFA_PARISC_1_0
:
4177 strcpy (buf
, ", PA-RISC 1.0");
4179 case EFA_PARISC_1_1
:
4180 strcpy (buf
, ", PA-RISC 1.1");
4182 case EFA_PARISC_2_0
:
4183 strcpy (buf
, ", PA-RISC 2.0");
4188 if (e_flags
& EF_PARISC_TRAPNIL
)
4189 strcat (buf
, ", trapnil");
4190 if (e_flags
& EF_PARISC_EXT
)
4191 strcat (buf
, ", ext");
4192 if (e_flags
& EF_PARISC_LSB
)
4193 strcat (buf
, ", lsb");
4194 if (e_flags
& EF_PARISC_WIDE
)
4195 strcat (buf
, ", wide");
4196 if (e_flags
& EF_PARISC_NO_KABP
)
4197 strcat (buf
, ", no kabp");
4198 if (e_flags
& EF_PARISC_LAZYSWAP
)
4199 strcat (buf
, ", lazyswap");
4204 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
4205 strcat (buf
, ", new calling convention");
4207 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
4208 strcat (buf
, ", gnu calling convention");
4212 if ((e_flags
& EF_IA_64_ABI64
))
4213 strcat (buf
, ", 64-bit");
4215 strcat (buf
, ", 32-bit");
4216 if ((e_flags
& EF_IA_64_REDUCEDFP
))
4217 strcat (buf
, ", reduced fp model");
4218 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
4219 strcat (buf
, ", no function descriptors, constant gp");
4220 else if ((e_flags
& EF_IA_64_CONS_GP
))
4221 strcat (buf
, ", constant gp");
4222 if ((e_flags
& EF_IA_64_ABSOLUTE
))
4223 strcat (buf
, ", absolute");
4224 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4226 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
4227 strcat (buf
, ", vms_linkages");
4228 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
4230 case EF_IA_64_VMS_COMCOD_SUCCESS
:
4232 case EF_IA_64_VMS_COMCOD_WARNING
:
4233 strcat (buf
, ", warning");
4235 case EF_IA_64_VMS_COMCOD_ERROR
:
4236 strcat (buf
, ", error");
4238 case EF_IA_64_VMS_COMCOD_ABORT
:
4239 strcat (buf
, ", abort");
4242 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
4243 e_flags
& EF_IA_64_VMS_COMCOD
);
4244 strcat (buf
, ", <unknown>");
4250 if ((e_flags
& EF_VAX_NONPIC
))
4251 strcat (buf
, ", non-PIC");
4252 if ((e_flags
& EF_VAX_DFLOAT
))
4253 strcat (buf
, ", D-Float");
4254 if ((e_flags
& EF_VAX_GFLOAT
))
4255 strcat (buf
, ", G-Float");
4259 if (e_flags
& EF_VISIUM_ARCH_MCM
)
4260 strcat (buf
, ", mcm");
4261 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
4262 strcat (buf
, ", mcm24");
4263 if (e_flags
& EF_VISIUM_ARCH_GR6
)
4264 strcat (buf
, ", gr6");
4268 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
4270 case E_FLAG_RL78_ANY_CPU
: break;
4271 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
4272 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
4273 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
4275 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
4276 strcat (buf
, ", 64-bit doubles");
4280 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
4281 strcat (buf
, ", 64-bit doubles");
4282 if (e_flags
& E_FLAG_RX_DSP
)
4283 strcat (buf
, ", dsp");
4284 if (e_flags
& E_FLAG_RX_PID
)
4285 strcat (buf
, ", pid");
4286 if (e_flags
& E_FLAG_RX_ABI
)
4287 strcat (buf
, ", RX ABI");
4288 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
4289 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
4290 ? ", uses String instructions" : ", bans String instructions");
4291 if (e_flags
& E_FLAG_RX_V2
)
4292 strcat (buf
, ", V2");
4293 if (e_flags
& E_FLAG_RX_V3
)
4294 strcat (buf
, ", V3");
4298 if (e_flags
& EF_S390_HIGH_GPRS
)
4299 strcat (buf
, ", highgprs");
4303 if ((e_flags
& EF_C6000_REL
))
4304 strcat (buf
, ", relocatable module");
4308 strcat (buf
, _(": architecture variant: "));
4309 switch (e_flags
& EF_MSP430_MACH
)
4311 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
4312 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
4313 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
4314 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
4315 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
4316 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
4317 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
4318 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
4319 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
4320 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
4321 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
4322 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
4323 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
4324 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
4325 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
4327 strcat (buf
, _(": unknown")); break;
4330 if (e_flags
& ~ EF_MSP430_MACH
)
4331 strcat (buf
, _(": unknown extra flag bits also present"));
4335 switch (e_flags
& EF_Z80_MACH_MSK
)
4337 case EF_Z80_MACH_Z80
: strcat (buf
, ", Z80"); break;
4338 case EF_Z80_MACH_Z180
: strcat (buf
, ", Z180"); break;
4339 case EF_Z80_MACH_R800
: strcat (buf
, ", R800"); break;
4340 case EF_Z80_MACH_EZ80_Z80
: strcat (buf
, ", EZ80"); break;
4341 case EF_Z80_MACH_EZ80_ADL
: strcat (buf
, ", EZ80, ADL"); break;
4342 case EF_Z80_MACH_GBZ80
: strcat (buf
, ", GBZ80"); break;
4343 case EF_Z80_MACH_Z80N
: strcat (buf
, ", Z80N"); break;
4345 strcat (buf
, _(", unknown")); break;
4349 if (EF_LOONGARCH_IS_SOFT_FLOAT (e_flags
))
4350 strcat (buf
, ", SOFT-FLOAT");
4351 else if (EF_LOONGARCH_IS_SINGLE_FLOAT (e_flags
))
4352 strcat (buf
, ", SINGLE-FLOAT");
4353 else if (EF_LOONGARCH_IS_DOUBLE_FLOAT (e_flags
))
4354 strcat (buf
, ", DOUBLE-FLOAT");
4356 if (EF_LOONGARCH_IS_OBJ_V0 (e_flags
))
4357 strcat (buf
, ", OBJ-v0");
4358 else if (EF_LOONGARCH_IS_OBJ_V1 (e_flags
))
4359 strcat (buf
, ", OBJ-v1");
4369 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
4371 static char buff
[32];
4375 case ELFOSABI_NONE
: return "UNIX - System V";
4376 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
4377 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
4378 case ELFOSABI_GNU
: return "UNIX - GNU";
4379 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
4380 case ELFOSABI_AIX
: return "UNIX - AIX";
4381 case ELFOSABI_IRIX
: return "UNIX - IRIX";
4382 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
4383 case ELFOSABI_TRU64
: return "UNIX - TRU64";
4384 case ELFOSABI_MODESTO
: return "Novell - Modesto";
4385 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
4386 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
4387 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
4388 case ELFOSABI_AROS
: return "AROS";
4389 case ELFOSABI_FENIXOS
: return "FenixOS";
4390 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
4391 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
4394 switch (filedata
->file_header
.e_machine
)
4399 case ELFOSABI_AMDGPU_HSA
: return "AMD HSA";
4400 case ELFOSABI_AMDGPU_PAL
: return "AMD PAL";
4401 case ELFOSABI_AMDGPU_MESA3D
: return "AMD Mesa3D";
4410 case ELFOSABI_ARM
: return "ARM";
4411 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
4422 case ELFOSABI_STANDALONE
: return _("Standalone App");
4431 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
4432 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
4441 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
4447 get_aarch64_segment_type (unsigned long type
)
4451 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
4452 case PT_AARCH64_MEMTAG_MTE
: return "AARCH64_MEMTAG_MTE";
4453 default: return NULL
;
4458 get_arm_segment_type (unsigned long type
)
4462 case PT_ARM_EXIDX
: return "EXIDX";
4463 default: return NULL
;
4468 get_s390_segment_type (unsigned long type
)
4472 case PT_S390_PGSTE
: return "S390_PGSTE";
4473 default: return NULL
;
4478 get_mips_segment_type (unsigned long type
)
4482 case PT_MIPS_REGINFO
: return "REGINFO";
4483 case PT_MIPS_RTPROC
: return "RTPROC";
4484 case PT_MIPS_OPTIONS
: return "OPTIONS";
4485 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
4486 default: return NULL
;
4491 get_parisc_segment_type (unsigned long type
)
4495 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
4496 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
4497 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
4498 default: return NULL
;
4503 get_ia64_segment_type (unsigned long type
)
4507 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
4508 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
4509 default: return NULL
;
4514 get_tic6x_segment_type (unsigned long type
)
4518 case PT_C6000_PHATTR
: return "C6000_PHATTR";
4519 default: return NULL
;
4524 get_riscv_segment_type (unsigned long type
)
4528 case PT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4529 default: return NULL
;
4534 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
4536 if (e_machine
== EM_PARISC
)
4539 case PT_HP_TLS
: return "HP_TLS";
4540 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
4541 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
4542 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
4543 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
4544 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
4545 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
4546 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
4547 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
4548 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
4549 case PT_HP_PARALLEL
: return "HP_PARALLEL";
4550 case PT_HP_FASTBIND
: return "HP_FASTBIND";
4551 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
4552 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
4553 case PT_HP_STACK
: return "HP_STACK";
4554 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
4555 default: return NULL
;
4558 if (e_machine
== EM_IA_64
)
4561 case PT_HP_TLS
: return "HP_TLS";
4562 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
4563 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
4564 case PT_IA_64_HP_STACK
: return "HP_STACK";
4565 default: return NULL
;
4572 get_solaris_segment_type (unsigned long type
)
4576 case 0x6464e550: return "PT_SUNW_UNWIND";
4577 case 0x6474e550: return "PT_SUNW_EH_FRAME";
4578 case 0x6ffffff7: return "PT_LOSUNW";
4579 case 0x6ffffffa: return "PT_SUNWBSS";
4580 case 0x6ffffffb: return "PT_SUNWSTACK";
4581 case 0x6ffffffc: return "PT_SUNWDTRACE";
4582 case 0x6ffffffd: return "PT_SUNWCAP";
4583 case 0x6fffffff: return "PT_HISUNW";
4584 default: return NULL
;
4589 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
4591 static char buff
[32];
4595 case PT_NULL
: return "NULL";
4596 case PT_LOAD
: return "LOAD";
4597 case PT_DYNAMIC
: return "DYNAMIC";
4598 case PT_INTERP
: return "INTERP";
4599 case PT_NOTE
: return "NOTE";
4600 case PT_SHLIB
: return "SHLIB";
4601 case PT_PHDR
: return "PHDR";
4602 case PT_TLS
: return "TLS";
4603 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
4604 case PT_GNU_STACK
: return "GNU_STACK";
4605 case PT_GNU_RELRO
: return "GNU_RELRO";
4606 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
4608 case PT_OPENBSD_RANDOMIZE
: return "OPENBSD_RANDOMIZE";
4609 case PT_OPENBSD_WXNEEDED
: return "OPENBSD_WXNEEDED";
4610 case PT_OPENBSD_BOOTDATA
: return "OPENBSD_BOOTDATA";
4613 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
4615 const char * result
;
4617 switch (filedata
->file_header
.e_machine
)
4620 result
= get_aarch64_segment_type (p_type
);
4623 result
= get_arm_segment_type (p_type
);
4626 case EM_MIPS_RS3_LE
:
4627 result
= get_mips_segment_type (p_type
);
4630 result
= get_parisc_segment_type (p_type
);
4633 result
= get_ia64_segment_type (p_type
);
4636 result
= get_tic6x_segment_type (p_type
);
4640 result
= get_s390_segment_type (p_type
);
4643 result
= get_riscv_segment_type (p_type
);
4653 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
4655 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
4657 const char * result
= NULL
;
4659 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
4662 case ELFOSABI_FREEBSD
:
4663 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
4665 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
4670 result
= get_hpux_segment_type (p_type
,
4671 filedata
->file_header
.e_machine
);
4673 case ELFOSABI_SOLARIS
:
4674 result
= get_solaris_segment_type (p_type
);
4682 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4685 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4692 get_arc_section_type_name (unsigned int sh_type
)
4696 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4704 get_mips_section_type_name (unsigned int sh_type
)
4708 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4709 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4710 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4711 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4712 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4713 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4714 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4715 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4716 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4717 case SHT_MIPS_RELD
: return "MIPS_RELD";
4718 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4719 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4720 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4721 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4722 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4723 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4724 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4725 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4726 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4727 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4728 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4729 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4730 case SHT_MIPS_LINE
: return "MIPS_LINE";
4731 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4732 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4733 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4734 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4735 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4736 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4737 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4738 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4739 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4740 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4741 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4742 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4743 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4744 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4745 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4746 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4747 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4748 case SHT_MIPS_XHASH
: return "MIPS_XHASH";
4756 get_parisc_section_type_name (unsigned int sh_type
)
4760 case SHT_PARISC_EXT
: return "PARISC_EXT";
4761 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4762 case SHT_PARISC_DOC
: return "PARISC_DOC";
4763 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4764 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4765 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4766 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4767 default: return NULL
;
4772 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4774 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4775 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4776 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4780 case SHT_IA_64_EXT
: return "IA_64_EXT";
4781 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4782 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4783 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4784 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4785 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4786 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4787 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4788 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4789 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4797 get_x86_64_section_type_name (unsigned int sh_type
)
4801 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4802 default: return NULL
;
4807 get_aarch64_section_type_name (unsigned int sh_type
)
4811 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4812 default: return NULL
;
4817 get_arm_section_type_name (unsigned int sh_type
)
4821 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4822 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4823 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4824 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4825 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4826 default: return NULL
;
4831 get_tic6x_section_type_name (unsigned int sh_type
)
4835 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4836 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4837 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4838 case SHT_TI_ICODE
: return "TI_ICODE";
4839 case SHT_TI_XREF
: return "TI_XREF";
4840 case SHT_TI_HANDLER
: return "TI_HANDLER";
4841 case SHT_TI_INITINFO
: return "TI_INITINFO";
4842 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4843 default: return NULL
;
4848 get_msp430_section_type_name (unsigned int sh_type
)
4852 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4853 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4854 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4855 default: return NULL
;
4860 get_nfp_section_type_name (unsigned int sh_type
)
4864 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4865 case SHT_NFP_INITREG
: return "NFP_INITREG";
4866 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4867 default: return NULL
;
4872 get_v850_section_type_name (unsigned int sh_type
)
4876 case SHT_V850_SCOMMON
: return "V850 Small Common";
4877 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4878 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4879 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4880 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4881 default: return NULL
;
4886 get_riscv_section_type_name (unsigned int sh_type
)
4890 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4891 default: return NULL
;
4896 get_csky_section_type_name (unsigned int sh_type
)
4900 case SHT_CSKY_ATTRIBUTES
: return "CSKY_ATTRIBUTES";
4901 default: return NULL
;
4906 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4908 static char buff
[32];
4909 const char * result
;
4913 case SHT_NULL
: return "NULL";
4914 case SHT_PROGBITS
: return "PROGBITS";
4915 case SHT_SYMTAB
: return "SYMTAB";
4916 case SHT_STRTAB
: return "STRTAB";
4917 case SHT_RELA
: return "RELA";
4918 case SHT_RELR
: return "RELR";
4919 case SHT_HASH
: return "HASH";
4920 case SHT_DYNAMIC
: return "DYNAMIC";
4921 case SHT_NOTE
: return "NOTE";
4922 case SHT_NOBITS
: return "NOBITS";
4923 case SHT_REL
: return "REL";
4924 case SHT_SHLIB
: return "SHLIB";
4925 case SHT_DYNSYM
: return "DYNSYM";
4926 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4927 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4928 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4929 case SHT_GNU_HASH
: return "GNU_HASH";
4930 case SHT_GROUP
: return "GROUP";
4931 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4932 case SHT_GNU_verdef
: return "VERDEF";
4933 case SHT_GNU_verneed
: return "VERNEED";
4934 case SHT_GNU_versym
: return "VERSYM";
4935 case 0x6ffffff0: return "VERSYM";
4936 case 0x6ffffffc: return "VERDEF";
4937 case 0x7ffffffd: return "AUXILIARY";
4938 case 0x7fffffff: return "FILTER";
4939 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4942 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4944 switch (filedata
->file_header
.e_machine
)
4947 case EM_ARC_COMPACT
:
4948 case EM_ARC_COMPACT2
:
4949 result
= get_arc_section_type_name (sh_type
);
4952 case EM_MIPS_RS3_LE
:
4953 result
= get_mips_section_type_name (sh_type
);
4956 result
= get_parisc_section_type_name (sh_type
);
4959 result
= get_ia64_section_type_name (filedata
, sh_type
);
4964 result
= get_x86_64_section_type_name (sh_type
);
4967 result
= get_aarch64_section_type_name (sh_type
);
4970 result
= get_arm_section_type_name (sh_type
);
4973 result
= get_tic6x_section_type_name (sh_type
);
4976 result
= get_msp430_section_type_name (sh_type
);
4979 result
= get_nfp_section_type_name (sh_type
);
4983 case EM_CYGNUS_V850
:
4984 result
= get_v850_section_type_name (sh_type
);
4987 result
= get_riscv_section_type_name (sh_type
);
4990 result
= get_csky_section_type_name (sh_type
);
5000 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
5002 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
5004 switch (filedata
->file_header
.e_machine
)
5007 result
= get_ia64_section_type_name (filedata
, sh_type
);
5010 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
5011 result
= get_solaris_section_type (sh_type
);
5016 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
5017 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
5018 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
5019 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
5031 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
5033 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
5035 switch (filedata
->file_header
.e_machine
)
5039 case EM_CYGNUS_V850
:
5040 result
= get_v850_section_type_name (sh_type
);
5050 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
5053 /* This message is probably going to be displayed in a 15
5054 character wide field, so put the hex value first. */
5055 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
5061 enum long_option_values
5063 OPTION_DEBUG_DUMP
= 512,
5073 OPTION_WITH_SYMBOL_VERSIONS
,
5074 OPTION_RECURSE_LIMIT
,
5075 OPTION_NO_RECURSE_LIMIT
,
5076 OPTION_NO_DEMANGLING
,
5080 static struct option options
[] =
5082 /* Note - This table is alpha-sorted on the 'val'
5083 field in order to make adding new options easier. */
5084 {"arch-specific", no_argument
, 0, 'A'},
5085 {"all", no_argument
, 0, 'a'},
5086 {"demangle", optional_argument
, 0, 'C'},
5087 {"archive-index", no_argument
, 0, 'c'},
5088 {"use-dynamic", no_argument
, 0, 'D'},
5089 {"dynamic", no_argument
, 0, 'd'},
5090 {"headers", no_argument
, 0, 'e'},
5091 {"section-groups", no_argument
, 0, 'g'},
5092 {"help", no_argument
, 0, 'H'},
5093 {"file-header", no_argument
, 0, 'h'},
5094 {"histogram", no_argument
, 0, 'I'},
5095 {"lint", no_argument
, 0, 'L'},
5096 {"enable-checks", no_argument
, 0, 'L'},
5097 {"program-headers", no_argument
, 0, 'l'},
5098 {"segments", no_argument
, 0, 'l'},
5099 {"full-section-name",no_argument
, 0, 'N'},
5100 {"notes", no_argument
, 0, 'n'},
5101 {"process-links", no_argument
, 0, 'P'},
5102 {"string-dump", required_argument
, 0, 'p'},
5103 {"relocated-dump", required_argument
, 0, 'R'},
5104 {"relocs", no_argument
, 0, 'r'},
5105 {"section-headers", no_argument
, 0, 'S'},
5106 {"sections", no_argument
, 0, 'S'},
5107 {"symbols", no_argument
, 0, 's'},
5108 {"syms", no_argument
, 0, 's'},
5109 {"silent-truncation",no_argument
, 0, 'T'},
5110 {"section-details", no_argument
, 0, 't'},
5111 {"unicode", required_argument
, NULL
, 'U'},
5112 {"unwind", no_argument
, 0, 'u'},
5113 {"version-info", no_argument
, 0, 'V'},
5114 {"version", no_argument
, 0, 'v'},
5115 {"wide", no_argument
, 0, 'W'},
5116 {"hex-dump", required_argument
, 0, 'x'},
5117 {"decompress", no_argument
, 0, 'z'},
5119 {"no-demangle", no_argument
, 0, OPTION_NO_DEMANGLING
},
5120 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
5121 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
5122 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
5123 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
5124 {"lto-syms", no_argument
, 0, OPTION_LTO_SYMS
},
5125 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
5126 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
5127 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
5128 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
5129 #ifdef ENABLE_LIBCTF
5130 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
5131 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
5132 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
5133 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
5135 {"sym-base", optional_argument
, 0, OPTION_SYM_BASE
},
5137 {0, no_argument
, 0, 0}
5141 usage (FILE * stream
)
5143 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
5144 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
5145 fprintf (stream
, _(" Options are:\n"));
5146 fprintf (stream
, _("\
5147 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
5148 fprintf (stream
, _("\
5149 -h --file-header Display the ELF file header\n"));
5150 fprintf (stream
, _("\
5151 -l --program-headers Display the program headers\n"));
5152 fprintf (stream
, _("\
5153 --segments An alias for --program-headers\n"));
5154 fprintf (stream
, _("\
5155 -S --section-headers Display the sections' header\n"));
5156 fprintf (stream
, _("\
5157 --sections An alias for --section-headers\n"));
5158 fprintf (stream
, _("\
5159 -g --section-groups Display the section groups\n"));
5160 fprintf (stream
, _("\
5161 -t --section-details Display the section details\n"));
5162 fprintf (stream
, _("\
5163 -e --headers Equivalent to: -h -l -S\n"));
5164 fprintf (stream
, _("\
5165 -s --syms Display the symbol table\n"));
5166 fprintf (stream
, _("\
5167 --symbols An alias for --syms\n"));
5168 fprintf (stream
, _("\
5169 --dyn-syms Display the dynamic symbol table\n"));
5170 fprintf (stream
, _("\
5171 --lto-syms Display LTO symbol tables\n"));
5172 fprintf (stream
, _("\
5173 --sym-base=[0|8|10|16] \n\
5174 Force base for symbol sizes. The options are \n\
5175 mixed (the default), octal, decimal, hexadecimal.\n"));
5176 fprintf (stream
, _("\
5177 -C --demangle[=STYLE] Decode mangled/processed symbol names\n"));
5178 display_demangler_styles (stream
, _("\
5180 fprintf (stream
, _("\
5181 --no-demangle Do not demangle low-level symbol names. (default)\n"));
5182 fprintf (stream
, _("\
5183 --recurse-limit Enable a demangling recursion limit. (default)\n"));
5184 fprintf (stream
, _("\
5185 --no-recurse-limit Disable a demangling recursion limit\n"));
5186 fprintf (stream
, _("\
5187 -U[dlexhi] --unicode=[default|locale|escape|hex|highlight|invalid]\n\
5188 Display unicode characters as determined by the current locale\n\
5189 (default), escape sequences, \"<hex sequences>\", highlighted\n\
5190 escape sequences, or treat them as invalid and display as\n\
5191 \"{hex sequences}\"\n"));
5192 fprintf (stream
, _("\
5193 -n --notes Display the core notes (if present)\n"));
5194 fprintf (stream
, _("\
5195 -r --relocs Display the relocations (if present)\n"));
5196 fprintf (stream
, _("\
5197 -u --unwind Display the unwind info (if present)\n"));
5198 fprintf (stream
, _("\
5199 -d --dynamic Display the dynamic section (if present)\n"));
5200 fprintf (stream
, _("\
5201 -V --version-info Display the version sections (if present)\n"));
5202 fprintf (stream
, _("\
5203 -A --arch-specific Display architecture specific information (if any)\n"));
5204 fprintf (stream
, _("\
5205 -c --archive-index Display the symbol/file index in an archive\n"));
5206 fprintf (stream
, _("\
5207 -D --use-dynamic Use the dynamic section info when displaying symbols\n"));
5208 fprintf (stream
, _("\
5209 -L --lint|--enable-checks\n\
5210 Display warning messages for possible problems\n"));
5211 fprintf (stream
, _("\
5212 -x --hex-dump=<number|name>\n\
5213 Dump the contents of section <number|name> as bytes\n"));
5214 fprintf (stream
, _("\
5215 -p --string-dump=<number|name>\n\
5216 Dump the contents of section <number|name> as strings\n"));
5217 fprintf (stream
, _("\
5218 -R --relocated-dump=<number|name>\n\
5219 Dump the relocated contents of section <number|name>\n"));
5220 fprintf (stream
, _("\
5221 -z --decompress Decompress section before dumping it\n"));
5222 fprintf (stream
, _("\
5223 -w --debug-dump[a/=abbrev, A/=addr, r/=aranges, c/=cu_index, L/=decodedline,\n\
5224 f/=frames, F/=frames-interp, g/=gdb_index, i/=info, o/=loc,\n\
5225 m/=macro, p/=pubnames, t/=pubtypes, R/=Ranges, l/=rawline,\n\
5226 s/=str, O/=str-offsets, u/=trace_abbrev, T/=trace_aranges,\n\
5228 Display the contents of DWARF debug sections\n"));
5229 fprintf (stream
, _("\
5230 -wk --debug-dump=links Display the contents of sections that link to separate\n\
5231 debuginfo files\n"));
5232 fprintf (stream
, _("\
5233 -P --process-links Display the contents of non-debug sections in separate\n\
5234 debuginfo files. (Implies -wK)\n"));
5235 #if DEFAULT_FOR_FOLLOW_LINKS
5236 fprintf (stream
, _("\
5237 -wK --debug-dump=follow-links\n\
5238 Follow links to separate debug info files (default)\n"));
5239 fprintf (stream
, _("\
5240 -wN --debug-dump=no-follow-links\n\
5241 Do not follow links to separate debug info files\n"));
5243 fprintf (stream
, _("\
5244 -wK --debug-dump=follow-links\n\
5245 Follow links to separate debug info files\n"));
5246 fprintf (stream
, _("\
5247 -wN --debug-dump=no-follow-links\n\
5248 Do not follow links to separate debug info files\n\
5251 #if HAVE_LIBDEBUGINFOD
5252 fprintf (stream
, _("\
5253 -wD --debug-dump=use-debuginfod\n\
5254 When following links, also query debuginfod servers (default)\n"));
5255 fprintf (stream
, _("\
5256 -wE --debug-dump=do-not-use-debuginfod\n\
5257 When following links, do not query debuginfod servers\n"));
5259 fprintf (stream
, _("\
5260 --dwarf-depth=N Do not display DIEs at depth N or greater\n"));
5261 fprintf (stream
, _("\
5262 --dwarf-start=N Display DIEs starting at offset N\n"));
5263 #ifdef ENABLE_LIBCTF
5264 fprintf (stream
, _("\
5265 --ctf=<number|name> Display CTF info from section <number|name>\n"));
5266 fprintf (stream
, _("\
5267 --ctf-parent=<name> Use CTF archive member <name> as the CTF parent\n"));
5268 fprintf (stream
, _("\
5269 --ctf-symbols=<number|name>\n\
5270 Use section <number|name> as the CTF external symtab\n"));
5271 fprintf (stream
, _("\
5272 --ctf-strings=<number|name>\n\
5273 Use section <number|name> as the CTF external strtab\n"));
5276 #ifdef SUPPORT_DISASSEMBLY
5277 fprintf (stream
, _("\
5278 -i --instruction-dump=<number|name>\n\
5279 Disassemble the contents of section <number|name>\n"));
5281 fprintf (stream
, _("\
5282 -I --histogram Display histogram of bucket list lengths\n"));
5283 fprintf (stream
, _("\
5284 -W --wide Allow output width to exceed 80 characters\n"));
5285 fprintf (stream
, _("\
5286 -T --silent-truncation If a symbol name is truncated, do not add [...] suffix\n"));
5287 fprintf (stream
, _("\
5288 @<file> Read options from <file>\n"));
5289 fprintf (stream
, _("\
5290 -H --help Display this information\n"));
5291 fprintf (stream
, _("\
5292 -v --version Display the version number of readelf\n"));
5294 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
5295 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
5297 exit (stream
== stdout
? 0 : 1);
5300 /* Record the fact that the user wants the contents of section number
5301 SECTION to be displayed using the method(s) encoded as flags bits
5302 in TYPE. Note, TYPE can be zero if we are creating the array for
5306 request_dump_bynumber (struct dump_data
*dumpdata
,
5307 unsigned int section
, dump_type type
)
5309 if (section
>= dumpdata
->num_dump_sects
)
5311 dump_type
* new_dump_sects
;
5313 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
5314 sizeof (* new_dump_sects
));
5316 if (new_dump_sects
== NULL
)
5317 error (_("Out of memory allocating dump request table.\n"));
5320 if (dumpdata
->dump_sects
)
5322 /* Copy current flag settings. */
5323 memcpy (new_dump_sects
, dumpdata
->dump_sects
,
5324 dumpdata
->num_dump_sects
* sizeof (* new_dump_sects
));
5326 free (dumpdata
->dump_sects
);
5329 dumpdata
->dump_sects
= new_dump_sects
;
5330 dumpdata
->num_dump_sects
= section
+ 1;
5334 if (dumpdata
->dump_sects
)
5335 dumpdata
->dump_sects
[section
] |= type
;
5338 /* Request a dump by section name. */
5341 request_dump_byname (const char * section
, dump_type type
)
5343 struct dump_list_entry
* new_request
;
5345 new_request
= (struct dump_list_entry
*)
5346 malloc (sizeof (struct dump_list_entry
));
5348 error (_("Out of memory allocating dump request table.\n"));
5350 new_request
->name
= strdup (section
);
5351 if (!new_request
->name
)
5352 error (_("Out of memory allocating dump request table.\n"));
5354 new_request
->type
= type
;
5356 new_request
->next
= dump_sects_byname
;
5357 dump_sects_byname
= new_request
;
5361 request_dump (struct dump_data
*dumpdata
, dump_type type
)
5367 section
= strtoul (optarg
, & cp
, 0);
5369 if (! *cp
&& section
>= 0)
5370 request_dump_bynumber (dumpdata
, section
, type
);
5372 request_dump_byname (optarg
, type
);
5376 parse_args (struct dump_data
*dumpdata
, int argc
, char ** argv
)
5383 while ((c
= getopt_long
5384 (argc
, argv
, "ACDHILNPR:STU:VWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
5402 do_section_groups
= true;
5405 do_histogram
= true;
5411 do_section_groups
= true;
5416 do_section_details
= true;
5427 do_using_dynamic
= true;
5451 do_histogram
= true;
5457 do_archive_index
= true;
5463 process_links
= true;
5464 do_follow_links
= true;
5465 dump_any_debugging
= true;
5468 request_dump (dumpdata
, HEX_DUMP
);
5471 request_dump (dumpdata
, STRING_DUMP
);
5474 request_dump (dumpdata
, RELOC_DUMP
);
5477 decompress_dumps
= true;
5482 do_debugging
= true;
5484 dump_any_debugging
= true;
5485 dwarf_select_sections_all ();
5489 do_debugging
= false;
5490 if (dwarf_select_sections_by_letters (optarg
))
5493 dump_any_debugging
= true;
5497 case OPTION_DEBUG_DUMP
:
5501 do_debugging
= true;
5502 dump_any_debugging
= true;
5503 dwarf_select_sections_all ();
5507 do_debugging
= false;
5508 if (dwarf_select_sections_by_names (optarg
))
5511 dump_any_debugging
= true;
5515 case OPTION_DWARF_DEPTH
:
5519 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
5522 case OPTION_DWARF_START
:
5526 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
5529 case OPTION_DWARF_CHECK
:
5532 case OPTION_CTF_DUMP
:
5534 request_dump (dumpdata
, CTF_DUMP
);
5536 case OPTION_CTF_SYMBOLS
:
5537 free (dump_ctf_symtab_name
);
5538 dump_ctf_symtab_name
= strdup (optarg
);
5540 case OPTION_CTF_STRINGS
:
5541 free (dump_ctf_strtab_name
);
5542 dump_ctf_strtab_name
= strdup (optarg
);
5544 case OPTION_CTF_PARENT
:
5545 free (dump_ctf_parent_name
);
5546 dump_ctf_parent_name
= strdup (optarg
);
5548 case OPTION_DYN_SYMS
:
5551 case OPTION_LTO_SYMS
:
5554 #ifdef SUPPORT_DISASSEMBLY
5556 request_dump (dumpdata
, DISASS_DUMP
);
5560 print_version (program_name
);
5569 do_not_show_symbol_truncation
= true;
5575 enum demangling_styles style
;
5577 style
= cplus_demangle_name_to_style (optarg
);
5578 if (style
== unknown_demangling
)
5579 error (_("unknown demangling style `%s'"), optarg
);
5581 cplus_demangle_set_style (style
);
5584 case OPTION_NO_DEMANGLING
:
5585 do_demangle
= false;
5587 case OPTION_RECURSE_LIMIT
:
5588 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
5590 case OPTION_NO_RECURSE_LIMIT
:
5591 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
5593 case OPTION_WITH_SYMBOL_VERSIONS
:
5594 /* Ignored for backward compatibility. */
5599 error (_("Missing arg to -U/--unicode")); /* Can this happen ? */
5600 else if (streq (optarg
, "default") || streq (optarg
, "d"))
5601 unicode_display
= unicode_default
;
5602 else if (streq (optarg
, "locale") || streq (optarg
, "l"))
5603 unicode_display
= unicode_locale
;
5604 else if (streq (optarg
, "escape") || streq (optarg
, "e"))
5605 unicode_display
= unicode_escape
;
5606 else if (streq (optarg
, "invalid") || streq (optarg
, "i"))
5607 unicode_display
= unicode_invalid
;
5608 else if (streq (optarg
, "hex") || streq (optarg
, "x"))
5609 unicode_display
= unicode_hex
;
5610 else if (streq (optarg
, "highlight") || streq (optarg
, "h"))
5611 unicode_display
= unicode_highlight
;
5613 error (_("invalid argument to -U/--unicode: %s"), optarg
);
5616 case OPTION_SYM_BASE
:
5620 sym_base
= strtoul (optarg
, NULL
, 0);
5637 /* xgettext:c-format */
5638 error (_("Invalid option '-%c'\n"), c
);
5645 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
5646 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
5647 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
5648 && !do_section_groups
&& !do_archive_index
5649 && !do_dyn_syms
&& !do_lto_syms
)
5654 do_dynamic
= do_syms
= do_reloc
= do_unwind
= do_sections
= true;
5655 do_segments
= do_header
= do_dump
= do_version
= true;
5656 do_histogram
= do_debugging
= do_arch
= do_notes
= true;
5657 do_section_groups
= do_archive_index
= do_dyn_syms
= true;
5666 get_elf_class (unsigned int elf_class
)
5668 static char buff
[32];
5672 case ELFCLASSNONE
: return _("none");
5673 case ELFCLASS32
: return "ELF32";
5674 case ELFCLASS64
: return "ELF64";
5676 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
5682 get_data_encoding (unsigned int encoding
)
5684 static char buff
[32];
5688 case ELFDATANONE
: return _("none");
5689 case ELFDATA2LSB
: return _("2's complement, little endian");
5690 case ELFDATA2MSB
: return _("2's complement, big endian");
5692 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
5698 check_magic_number (Filedata
* filedata
, Elf_Internal_Ehdr
* header
)
5700 if (header
->e_ident
[EI_MAG0
] == ELFMAG0
5701 && header
->e_ident
[EI_MAG1
] == ELFMAG1
5702 && header
->e_ident
[EI_MAG2
] == ELFMAG2
5703 && header
->e_ident
[EI_MAG3
] == ELFMAG3
)
5706 /* Some compilers produce object files that are not in the ELF file format.
5707 As an aid to users of readelf, try to identify these cases and suggest
5710 FIXME: It is not clear if all four bytes are used as constant magic
5711 valus by all compilers. It may be necessary to recode this function if
5712 different tools use different length sequences. */
5716 unsigned char magic
[4];
5717 const char * obj_message
;
5718 const char * ar_message
;
5722 { { 'B', 'C', 0xc0, 0xde },
5723 N_("This is a LLVM bitcode file - try using llvm-bcanalyzer\n"),
5724 N_("This is a LLVM bitcode file - try extracing and then using llvm-bcanalyzer\n")
5726 { { 'g', 'o', ' ', 'o' },
5727 N_("This is a GO binary file - try using 'go tool objdump' or 'go tool nm'\n"),
5733 for (i
= ARRAY_SIZE (known_magic
); i
--;)
5735 if (header
->e_ident
[EI_MAG0
] == known_magic
[i
].magic
[0]
5736 && header
->e_ident
[EI_MAG1
] == known_magic
[i
].magic
[1]
5737 && header
->e_ident
[EI_MAG2
] == known_magic
[i
].magic
[2]
5738 && header
->e_ident
[EI_MAG3
] == known_magic
[i
].magic
[3])
5740 /* Some compiler's analyzer tools do not handle archives,
5741 so we provide two different kinds of error message. */
5742 if (filedata
->archive_file_size
> 0
5743 && known_magic
[i
].ar_message
!= NULL
)
5744 error ("%s", known_magic
[i
].ar_message
);
5746 error ("%s", known_magic
[i
].obj_message
);
5751 error (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
5755 /* Decode the data held in 'filedata->file_header'. */
5758 process_file_header (Filedata
* filedata
)
5760 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
5762 if (! check_magic_number (filedata
, header
))
5765 if (! filedata
->is_separate
)
5766 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
5772 if (filedata
->is_separate
)
5773 printf (_("ELF Header in linked file '%s':\n"), filedata
->file_name
);
5775 printf (_("ELF Header:\n"));
5776 printf (_(" Magic: "));
5777 for (i
= 0; i
< EI_NIDENT
; i
++)
5778 printf ("%2.2x ", header
->e_ident
[i
]);
5780 printf (_(" Class: %s\n"),
5781 get_elf_class (header
->e_ident
[EI_CLASS
]));
5782 printf (_(" Data: %s\n"),
5783 get_data_encoding (header
->e_ident
[EI_DATA
]));
5784 printf (_(" Version: %d%s\n"),
5785 header
->e_ident
[EI_VERSION
],
5786 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
5788 : (header
->e_ident
[EI_VERSION
] != EV_NONE
5791 printf (_(" OS/ABI: %s\n"),
5792 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
5793 printf (_(" ABI Version: %d\n"),
5794 header
->e_ident
[EI_ABIVERSION
]);
5795 printf (_(" Type: %s\n"),
5796 get_file_type (filedata
));
5797 printf (_(" Machine: %s\n"),
5798 get_machine_name (header
->e_machine
));
5799 printf (_(" Version: 0x%lx\n"),
5802 printf (_(" Entry point address: "));
5803 print_vma (header
->e_entry
, PREFIX_HEX
);
5804 printf (_("\n Start of program headers: "));
5805 print_vma (header
->e_phoff
, DEC
);
5806 printf (_(" (bytes into file)\n Start of section headers: "));
5807 print_vma (header
->e_shoff
, DEC
);
5808 printf (_(" (bytes into file)\n"));
5810 printf (_(" Flags: 0x%lx%s\n"),
5812 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
5813 printf (_(" Size of this header: %u (bytes)\n"),
5815 printf (_(" Size of program headers: %u (bytes)\n"),
5816 header
->e_phentsize
);
5817 printf (_(" Number of program headers: %u"),
5819 if (filedata
->section_headers
!= NULL
5820 && header
->e_phnum
== PN_XNUM
5821 && filedata
->section_headers
[0].sh_info
!= 0)
5822 printf (" (%u)", filedata
->section_headers
[0].sh_info
);
5823 putc ('\n', stdout
);
5824 printf (_(" Size of section headers: %u (bytes)\n"),
5825 header
->e_shentsize
);
5826 printf (_(" Number of section headers: %u"),
5828 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
5830 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5831 printf (" (%u)", header
->e_shnum
);
5833 putc ('\n', stdout
);
5834 printf (_(" Section header string table index: %u"),
5835 header
->e_shstrndx
);
5836 if (filedata
->section_headers
!= NULL
5837 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5839 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5840 printf (" (%u)", header
->e_shstrndx
);
5842 if (header
->e_shstrndx
!= SHN_UNDEF
5843 && header
->e_shstrndx
>= header
->e_shnum
)
5845 header
->e_shstrndx
= SHN_UNDEF
;
5846 printf (_(" <corrupt: out of range>"));
5848 putc ('\n', stdout
);
5851 if (filedata
->section_headers
!= NULL
)
5853 if (header
->e_phnum
== PN_XNUM
5854 && filedata
->section_headers
[0].sh_info
!= 0)
5856 /* Throw away any cached read of PN_XNUM headers. */
5857 free (filedata
->program_headers
);
5858 filedata
->program_headers
= NULL
;
5859 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
5861 if (header
->e_shnum
== SHN_UNDEF
)
5862 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5863 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5864 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5865 if (header
->e_shstrndx
>= header
->e_shnum
)
5866 header
->e_shstrndx
= SHN_UNDEF
;
5872 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5873 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
5876 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5878 Elf32_External_Phdr
* phdrs
;
5879 Elf32_External_Phdr
* external
;
5880 Elf_Internal_Phdr
* internal
;
5882 unsigned int size
= filedata
->file_header
.e_phentsize
;
5883 unsigned int num
= filedata
->file_header
.e_phnum
;
5885 /* PR binutils/17531: Cope with unexpected section header sizes. */
5886 if (size
== 0 || num
== 0)
5888 if (size
< sizeof * phdrs
)
5890 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5893 if (size
> sizeof * phdrs
)
5894 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5896 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5897 size
, num
, _("program headers"));
5901 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5902 i
< filedata
->file_header
.e_phnum
;
5903 i
++, internal
++, external
++)
5905 internal
->p_type
= BYTE_GET (external
->p_type
);
5906 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5907 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5908 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5909 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5910 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5911 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5912 internal
->p_align
= BYTE_GET (external
->p_align
);
5919 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5920 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5923 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5925 Elf64_External_Phdr
* phdrs
;
5926 Elf64_External_Phdr
* external
;
5927 Elf_Internal_Phdr
* internal
;
5929 unsigned int size
= filedata
->file_header
.e_phentsize
;
5930 unsigned int num
= filedata
->file_header
.e_phnum
;
5932 /* PR binutils/17531: Cope with unexpected section header sizes. */
5933 if (size
== 0 || num
== 0)
5935 if (size
< sizeof * phdrs
)
5937 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5940 if (size
> sizeof * phdrs
)
5941 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5943 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5944 size
, num
, _("program headers"));
5948 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5949 i
< filedata
->file_header
.e_phnum
;
5950 i
++, internal
++, external
++)
5952 internal
->p_type
= BYTE_GET (external
->p_type
);
5953 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5954 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5955 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5956 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5957 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5958 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5959 internal
->p_align
= BYTE_GET (external
->p_align
);
5966 /* Returns TRUE if the program headers were read into `program_headers'. */
5969 get_program_headers (Filedata
* filedata
)
5971 Elf_Internal_Phdr
* phdrs
;
5973 /* Check cache of prior read. */
5974 if (filedata
->program_headers
!= NULL
)
5977 /* Be kind to memory checkers by looking for
5978 e_phnum values which we know must be invalid. */
5979 if (filedata
->file_header
.e_phnum
5980 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5981 >= filedata
->file_size
)
5983 error (_("Too many program headers - %#x - the file is not that big\n"),
5984 filedata
->file_header
.e_phnum
);
5988 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5989 sizeof (Elf_Internal_Phdr
));
5992 error (_("Out of memory reading %u program headers\n"),
5993 filedata
->file_header
.e_phnum
);
5998 ? get_32bit_program_headers (filedata
, phdrs
)
5999 : get_64bit_program_headers (filedata
, phdrs
))
6001 filedata
->program_headers
= phdrs
;
6009 /* Print program header info and locate dynamic section. */
6012 process_program_headers (Filedata
* filedata
)
6014 Elf_Internal_Phdr
* segment
;
6016 Elf_Internal_Phdr
* previous_load
= NULL
;
6018 if (filedata
->file_header
.e_phnum
== 0)
6020 /* PR binutils/12467. */
6021 if (filedata
->file_header
.e_phoff
!= 0)
6022 warn (_("possibly corrupt ELF header - it has a non-zero program"
6023 " header offset, but no program headers\n"));
6024 else if (do_segments
)
6026 if (filedata
->is_separate
)
6027 printf (_("\nThere are no program headers in linked file '%s'.\n"),
6028 filedata
->file_name
);
6030 printf (_("\nThere are no program headers in this file.\n"));
6035 if (do_segments
&& !do_header
)
6037 if (filedata
->is_separate
)
6038 printf ("\nIn linked file '%s' the ELF file type is %s\n",
6039 filedata
->file_name
, get_file_type (filedata
));
6041 printf (_("\nElf file type is %s\n"), get_file_type (filedata
));
6042 printf (_("Entry point 0x%" PRIx64
"\n"),
6043 filedata
->file_header
.e_entry
);
6044 printf (ngettext ("There is %d program header,"
6045 " starting at offset %" PRIu64
"\n",
6046 "There are %d program headers,"
6047 " starting at offset %" PRIu64
"\n",
6048 filedata
->file_header
.e_phnum
),
6049 filedata
->file_header
.e_phnum
,
6050 filedata
->file_header
.e_phoff
);
6053 if (! get_program_headers (filedata
))
6058 if (filedata
->file_header
.e_phnum
> 1)
6059 printf (_("\nProgram Headers:\n"));
6061 printf (_("\nProgram Headers:\n"));
6065 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
6068 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
6072 (_(" Type Offset VirtAddr PhysAddr\n"));
6074 (_(" FileSiz MemSiz Flags Align\n"));
6078 unsigned long dynamic_addr
= 0;
6079 uint64_t dynamic_size
= 0;
6080 for (i
= 0, segment
= filedata
->program_headers
;
6081 i
< filedata
->file_header
.e_phnum
;
6086 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
6090 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
6091 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
6092 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
6093 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
6094 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
6096 (segment
->p_flags
& PF_R
? 'R' : ' '),
6097 (segment
->p_flags
& PF_W
? 'W' : ' '),
6098 (segment
->p_flags
& PF_X
? 'E' : ' '));
6099 printf ("%#lx", (unsigned long) segment
->p_align
);
6103 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
6104 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
6107 print_vma (segment
->p_offset
, FULL_HEX
);
6111 print_vma (segment
->p_vaddr
, FULL_HEX
);
6113 print_vma (segment
->p_paddr
, FULL_HEX
);
6116 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
6117 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
6120 print_vma (segment
->p_filesz
, FULL_HEX
);
6124 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
6125 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
6128 print_vma (segment
->p_memsz
, FULL_HEX
);
6132 (segment
->p_flags
& PF_R
? 'R' : ' '),
6133 (segment
->p_flags
& PF_W
? 'W' : ' '),
6134 (segment
->p_flags
& PF_X
? 'E' : ' '));
6136 if ((unsigned long) segment
->p_align
== segment
->p_align
)
6137 printf ("%#lx", (unsigned long) segment
->p_align
);
6140 print_vma (segment
->p_align
, PREFIX_HEX
);
6145 print_vma (segment
->p_offset
, FULL_HEX
);
6147 print_vma (segment
->p_vaddr
, FULL_HEX
);
6149 print_vma (segment
->p_paddr
, FULL_HEX
);
6151 print_vma (segment
->p_filesz
, FULL_HEX
);
6153 print_vma (segment
->p_memsz
, FULL_HEX
);
6155 (segment
->p_flags
& PF_R
? 'R' : ' '),
6156 (segment
->p_flags
& PF_W
? 'W' : ' '),
6157 (segment
->p_flags
& PF_X
? 'E' : ' '));
6158 print_vma (segment
->p_align
, PREFIX_HEX
);
6161 putc ('\n', stdout
);
6164 switch (segment
->p_type
)
6167 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
6168 required by the ELF standard, several programs, including the Linux
6169 kernel, make use of non-ordered segments. */
6171 && previous_load
->p_vaddr
> segment
->p_vaddr
)
6172 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
6174 if (segment
->p_memsz
< segment
->p_filesz
)
6175 error (_("the segment's file size is larger than its memory size\n"));
6176 previous_load
= segment
;
6180 /* PR 20815 - Verify that the program header is loaded into memory. */
6181 if (i
> 0 && previous_load
!= NULL
)
6182 error (_("the PHDR segment must occur before any LOAD segment\n"));
6183 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
6187 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
6189 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
6190 if (load
->p_type
== PT_LOAD
6191 && load
->p_offset
<= segment
->p_offset
6192 && (load
->p_offset
+ load
->p_filesz
6193 >= segment
->p_offset
+ segment
->p_filesz
)
6194 && load
->p_vaddr
<= segment
->p_vaddr
6195 && (load
->p_vaddr
+ load
->p_filesz
6196 >= segment
->p_vaddr
+ segment
->p_filesz
))
6199 if (j
== filedata
->file_header
.e_phnum
)
6200 error (_("the PHDR segment is not covered by a LOAD segment\n"));
6206 error (_("more than one dynamic segment\n"));
6208 /* By default, assume that the .dynamic section is the first
6209 section in the DYNAMIC segment. */
6210 dynamic_addr
= segment
->p_offset
;
6211 dynamic_size
= segment
->p_filesz
;
6213 /* Try to locate the .dynamic section. If there is
6214 a section header table, we can easily locate it. */
6215 if (filedata
->section_headers
!= NULL
)
6217 Elf_Internal_Shdr
* sec
;
6219 sec
= find_section (filedata
, ".dynamic");
6220 if (sec
== NULL
|| sec
->sh_size
== 0)
6222 /* A corresponding .dynamic section is expected, but on
6223 IA-64/OpenVMS it is OK for it to be missing. */
6224 if (!is_ia64_vms (filedata
))
6225 error (_("no .dynamic section in the dynamic segment\n"));
6229 if (sec
->sh_type
== SHT_NOBITS
)
6236 dynamic_addr
= sec
->sh_offset
;
6237 dynamic_size
= sec
->sh_size
;
6239 /* The PT_DYNAMIC segment, which is used by the run-time
6240 loader, should exactly match the .dynamic section. */
6242 && (dynamic_addr
!= segment
->p_offset
6243 || dynamic_size
!= segment
->p_filesz
))
6245 the .dynamic section is not the same as the dynamic segment\n"));
6248 /* PR binutils/17512: Avoid corrupt dynamic section info in the
6249 segment. Check this after matching against the section headers
6250 so we don't warn on debuginfo file (which have NOBITS .dynamic
6252 if (dynamic_addr
> filedata
->file_size
6253 || (dynamic_size
> filedata
->file_size
- dynamic_addr
))
6255 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
6262 if (segment
->p_offset
>= filedata
->file_size
6263 || segment
->p_filesz
> filedata
->file_size
- segment
->p_offset
6264 || segment
->p_filesz
- 1 >= (size_t) -2
6265 || fseek (filedata
->handle
,
6266 filedata
->archive_file_offset
+ (long) segment
->p_offset
,
6268 error (_("Unable to find program interpreter name\n"));
6271 size_t len
= segment
->p_filesz
;
6272 free (filedata
->program_interpreter
);
6273 filedata
->program_interpreter
= xmalloc (len
+ 1);
6274 len
= fread (filedata
->program_interpreter
, 1, len
,
6276 filedata
->program_interpreter
[len
] = 0;
6279 printf (_(" [Requesting program interpreter: %s]\n"),
6280 filedata
->program_interpreter
);
6287 && filedata
->section_headers
!= NULL
6288 && filedata
->string_table
!= NULL
)
6290 printf (_("\n Section to Segment mapping:\n"));
6291 printf (_(" Segment Sections...\n"));
6293 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
6296 Elf_Internal_Shdr
* section
;
6298 segment
= filedata
->program_headers
+ i
;
6299 section
= filedata
->section_headers
+ 1;
6301 printf (" %2.2d ", i
);
6303 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
6305 if (!ELF_TBSS_SPECIAL (section
, segment
)
6306 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
6307 printf ("%s ", printable_section_name (filedata
, section
));
6314 filedata
->dynamic_addr
= dynamic_addr
;
6315 filedata
->dynamic_size
= dynamic_size
? dynamic_size
: 1;
6319 filedata
->dynamic_addr
= 0;
6320 filedata
->dynamic_size
= 1;
6324 /* Find the file offset corresponding to VMA by using the program headers. */
6327 offset_from_vma (Filedata
* filedata
, uint64_t vma
, uint64_t size
)
6329 Elf_Internal_Phdr
* seg
;
6331 if (! get_program_headers (filedata
))
6333 warn (_("Cannot interpret virtual addresses without program headers.\n"));
6337 for (seg
= filedata
->program_headers
;
6338 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
6341 if (seg
->p_type
!= PT_LOAD
)
6344 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
6345 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
6346 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
6349 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
6350 (unsigned long) vma
);
6355 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
6356 If PROBE is true, this is just a probe and we do not generate any error
6357 messages if the load fails. */
6360 get_32bit_section_headers (Filedata
* filedata
, bool probe
)
6362 Elf32_External_Shdr
* shdrs
;
6363 Elf_Internal_Shdr
* internal
;
6365 unsigned int size
= filedata
->file_header
.e_shentsize
;
6366 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
6368 /* PR binutils/17531: Cope with unexpected section header sizes. */
6369 if (size
== 0 || num
== 0)
6372 /* The section header cannot be at the start of the file - that is
6373 where the ELF file header is located. A file with absolutely no
6374 sections in it will use a shoff of 0. */
6375 if (filedata
->file_header
.e_shoff
== 0)
6378 if (size
< sizeof * shdrs
)
6381 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
6384 if (!probe
&& size
> sizeof * shdrs
)
6385 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
6387 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
6389 probe
? NULL
: _("section headers"));
6393 filedata
->section_headers
= (Elf_Internal_Shdr
*)
6394 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
6395 if (filedata
->section_headers
== NULL
)
6398 error (_("Out of memory reading %u section headers\n"), num
);
6403 for (i
= 0, internal
= filedata
->section_headers
;
6407 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
6408 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
6409 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
6410 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
6411 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
6412 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
6413 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
6414 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
6415 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
6416 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
6417 if (!probe
&& internal
->sh_link
> num
)
6418 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
6419 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
6420 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
6427 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
6430 get_64bit_section_headers (Filedata
* filedata
, bool probe
)
6432 Elf64_External_Shdr
* shdrs
;
6433 Elf_Internal_Shdr
* internal
;
6435 unsigned int size
= filedata
->file_header
.e_shentsize
;
6436 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
6438 /* PR binutils/17531: Cope with unexpected section header sizes. */
6439 if (size
== 0 || num
== 0)
6442 /* The section header cannot be at the start of the file - that is
6443 where the ELF file header is located. A file with absolutely no
6444 sections in it will use a shoff of 0. */
6445 if (filedata
->file_header
.e_shoff
== 0)
6448 if (size
< sizeof * shdrs
)
6451 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
6455 if (! probe
&& size
> sizeof * shdrs
)
6456 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
6458 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
6459 filedata
->file_header
.e_shoff
,
6461 probe
? NULL
: _("section headers"));
6465 filedata
->section_headers
= (Elf_Internal_Shdr
*)
6466 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
6467 if (filedata
->section_headers
== NULL
)
6470 error (_("Out of memory reading %u section headers\n"), num
);
6475 for (i
= 0, internal
= filedata
->section_headers
;
6479 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
6480 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
6481 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
6482 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
6483 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
6484 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
6485 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
6486 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
6487 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
6488 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
6489 if (!probe
&& internal
->sh_link
> num
)
6490 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
6491 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
6492 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
6500 get_section_headers (Filedata
*filedata
, bool probe
)
6502 if (filedata
->section_headers
!= NULL
)
6506 return get_32bit_section_headers (filedata
, probe
);
6508 return get_64bit_section_headers (filedata
, probe
);
6511 static Elf_Internal_Sym
*
6512 get_32bit_elf_symbols (Filedata
* filedata
,
6513 Elf_Internal_Shdr
* section
,
6514 unsigned long * num_syms_return
)
6516 unsigned long number
= 0;
6517 Elf32_External_Sym
* esyms
= NULL
;
6518 Elf_External_Sym_Shndx
* shndx
= NULL
;
6519 Elf_Internal_Sym
* isyms
= NULL
;
6520 Elf_Internal_Sym
* psym
;
6522 elf_section_list
* entry
;
6524 if (section
->sh_size
== 0)
6526 if (num_syms_return
!= NULL
)
6527 * num_syms_return
= 0;
6531 /* Run some sanity checks first. */
6532 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
6534 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
6535 printable_section_name (filedata
, section
),
6536 (unsigned long) section
->sh_entsize
);
6540 if (section
->sh_size
> filedata
->file_size
)
6542 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
6543 printable_section_name (filedata
, section
),
6544 (unsigned long) section
->sh_size
);
6548 number
= section
->sh_size
/ section
->sh_entsize
;
6550 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
6552 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
6553 (unsigned long) section
->sh_size
,
6554 printable_section_name (filedata
, section
),
6555 (unsigned long) section
->sh_entsize
);
6559 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
6560 section
->sh_size
, _("symbols"));
6565 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
6567 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
6572 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
6576 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
6577 entry
->hdr
->sh_offset
,
6578 1, entry
->hdr
->sh_size
,
6579 _("symbol table section indices"));
6583 /* PR17531: file: heap-buffer-overflow */
6584 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
6586 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
6587 printable_section_name (filedata
, entry
->hdr
),
6588 (unsigned long) entry
->hdr
->sh_size
,
6589 (unsigned long) section
->sh_size
);
6594 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
6598 error (_("Out of memory reading %lu symbols\n"),
6599 (unsigned long) number
);
6603 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
6605 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
6606 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
6607 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
6608 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
6609 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
6611 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
6612 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
6613 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
6614 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
6615 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
6622 if (num_syms_return
!= NULL
)
6623 * num_syms_return
= isyms
== NULL
? 0 : number
;
6628 static Elf_Internal_Sym
*
6629 get_64bit_elf_symbols (Filedata
* filedata
,
6630 Elf_Internal_Shdr
* section
,
6631 unsigned long * num_syms_return
)
6633 unsigned long number
= 0;
6634 Elf64_External_Sym
* esyms
= NULL
;
6635 Elf_External_Sym_Shndx
* shndx
= NULL
;
6636 Elf_Internal_Sym
* isyms
= NULL
;
6637 Elf_Internal_Sym
* psym
;
6639 elf_section_list
* entry
;
6641 if (section
->sh_size
== 0)
6643 if (num_syms_return
!= NULL
)
6644 * num_syms_return
= 0;
6648 /* Run some sanity checks first. */
6649 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
6651 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
6652 printable_section_name (filedata
, section
),
6653 (unsigned long) section
->sh_entsize
);
6657 if (section
->sh_size
> filedata
->file_size
)
6659 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
6660 printable_section_name (filedata
, section
),
6661 (unsigned long) section
->sh_size
);
6665 number
= section
->sh_size
/ section
->sh_entsize
;
6667 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
6669 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
6670 (unsigned long) section
->sh_size
,
6671 printable_section_name (filedata
, section
),
6672 (unsigned long) section
->sh_entsize
);
6676 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
6677 section
->sh_size
, _("symbols"));
6682 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
6684 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
6689 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
6693 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
6694 entry
->hdr
->sh_offset
,
6695 1, entry
->hdr
->sh_size
,
6696 _("symbol table section indices"));
6700 /* PR17531: file: heap-buffer-overflow */
6701 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
6703 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
6704 printable_section_name (filedata
, entry
->hdr
),
6705 (unsigned long) entry
->hdr
->sh_size
,
6706 (unsigned long) section
->sh_size
);
6711 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
6715 error (_("Out of memory reading %lu symbols\n"),
6716 (unsigned long) number
);
6720 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
6722 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
6723 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
6724 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
6725 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
6727 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
6729 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
6730 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
6731 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
6733 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
6734 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
6741 if (num_syms_return
!= NULL
)
6742 * num_syms_return
= isyms
== NULL
? 0 : number
;
6747 static Elf_Internal_Sym
*
6748 get_elf_symbols (Filedata
*filedata
,
6749 Elf_Internal_Shdr
*section
,
6750 unsigned long *num_syms_return
)
6753 return get_32bit_elf_symbols (filedata
, section
, num_syms_return
);
6755 return get_64bit_elf_symbols (filedata
, section
, num_syms_return
);
6759 get_elf_section_flags (Filedata
* filedata
, uint64_t sh_flags
)
6761 static char buff
[1024];
6763 unsigned int field_size
= is_32bit_elf
? 8 : 16;
6765 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
6766 uint64_t os_flags
= 0;
6767 uint64_t proc_flags
= 0;
6768 uint64_t unknown_flags
= 0;
6776 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
6777 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
6778 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
6779 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
6780 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
6781 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
6782 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
6783 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
6784 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
6785 /* 9 */ { STRING_COMMA_LEN ("TLS") },
6786 /* IA-64 specific. */
6787 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
6788 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
6789 /* IA-64 OpenVMS specific. */
6790 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
6791 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
6792 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
6793 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
6794 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
6795 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
6797 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
6798 /* SPARC specific. */
6799 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
6800 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
6802 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
6803 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
6804 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
6806 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
6808 /* 25 */ { STRING_COMMA_LEN ("VLE") },
6810 /* 26 */ { STRING_COMMA_LEN ("GNU_RETAIN") },
6813 if (do_section_details
)
6815 sprintf (buff
, "[%*.*lx]: ",
6816 field_size
, field_size
, (unsigned long) sh_flags
);
6817 p
+= field_size
+ 4;
6824 flag
= sh_flags
& - sh_flags
;
6827 if (do_section_details
)
6831 case SHF_WRITE
: sindex
= 0; break;
6832 case SHF_ALLOC
: sindex
= 1; break;
6833 case SHF_EXECINSTR
: sindex
= 2; break;
6834 case SHF_MERGE
: sindex
= 3; break;
6835 case SHF_STRINGS
: sindex
= 4; break;
6836 case SHF_INFO_LINK
: sindex
= 5; break;
6837 case SHF_LINK_ORDER
: sindex
= 6; break;
6838 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
6839 case SHF_GROUP
: sindex
= 8; break;
6840 case SHF_TLS
: sindex
= 9; break;
6841 case SHF_EXCLUDE
: sindex
= 18; break;
6842 case SHF_COMPRESSED
: sindex
= 20; break;
6846 switch (filedata
->file_header
.e_machine
)
6849 if (flag
== SHF_IA_64_SHORT
)
6851 else if (flag
== SHF_IA_64_NORECOV
)
6853 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
6856 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
6857 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
6858 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
6859 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
6860 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
6861 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
6871 case EM_OLD_SPARCV9
:
6872 case EM_SPARC32PLUS
:
6875 if (flag
== SHF_ORDERED
)
6882 case SHF_ENTRYSECT
: sindex
= 21; break;
6883 case SHF_ARM_PURECODE
: sindex
= 22; break;
6884 case SHF_COMDEF
: sindex
= 23; break;
6889 if (flag
== SHF_PPC_VLE
)
6896 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
6899 case ELFOSABI_FREEBSD
:
6900 if (flag
== SHF_GNU_RETAIN
)
6904 if (flag
== SHF_GNU_MBIND
)
6905 /* We should not recognize SHF_GNU_MBIND for
6906 ELFOSABI_NONE, but binutils as of 2019-07-23 did
6907 not set the EI_OSABI header byte. */
6918 if (p
!= buff
+ field_size
+ 4)
6920 if (size
< (10 + 2))
6922 warn (_("Internal error: not enough buffer room for section flag info"));
6923 return _("<unknown>");
6930 size
-= flags
[sindex
].len
;
6931 p
= stpcpy (p
, flags
[sindex
].str
);
6933 else if (flag
& SHF_MASKOS
)
6935 else if (flag
& SHF_MASKPROC
)
6938 unknown_flags
|= flag
;
6944 case SHF_WRITE
: *p
= 'W'; break;
6945 case SHF_ALLOC
: *p
= 'A'; break;
6946 case SHF_EXECINSTR
: *p
= 'X'; break;
6947 case SHF_MERGE
: *p
= 'M'; break;
6948 case SHF_STRINGS
: *p
= 'S'; break;
6949 case SHF_INFO_LINK
: *p
= 'I'; break;
6950 case SHF_LINK_ORDER
: *p
= 'L'; break;
6951 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
6952 case SHF_GROUP
: *p
= 'G'; break;
6953 case SHF_TLS
: *p
= 'T'; break;
6954 case SHF_EXCLUDE
: *p
= 'E'; break;
6955 case SHF_COMPRESSED
: *p
= 'C'; break;
6958 if ((filedata
->file_header
.e_machine
== EM_X86_64
6959 || filedata
->file_header
.e_machine
== EM_L1OM
6960 || filedata
->file_header
.e_machine
== EM_K1OM
)
6961 && flag
== SHF_X86_64_LARGE
)
6963 else if (filedata
->file_header
.e_machine
== EM_ARM
6964 && flag
== SHF_ARM_PURECODE
)
6966 else if (filedata
->file_header
.e_machine
== EM_PPC
6967 && flag
== SHF_PPC_VLE
)
6969 else if (flag
& SHF_MASKOS
)
6971 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
6974 case ELFOSABI_FREEBSD
:
6975 if (flag
== SHF_GNU_RETAIN
)
6982 if (flag
== SHF_GNU_MBIND
)
6984 /* We should not recognize SHF_GNU_MBIND for
6985 ELFOSABI_NONE, but binutils as of 2019-07-23 did
6986 not set the EI_OSABI header byte. */
6993 sh_flags
&= ~SHF_MASKOS
;
6997 else if (flag
& SHF_MASKPROC
)
7000 sh_flags
&= ~ SHF_MASKPROC
;
7010 if (do_section_details
)
7014 size
-= 5 + field_size
;
7015 if (p
!= buff
+ field_size
+ 4)
7019 warn (_("Internal error: not enough buffer room for section flag info"));
7020 return _("<unknown>");
7026 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
7027 (unsigned long) os_flags
);
7028 p
+= 5 + field_size
;
7032 size
-= 7 + field_size
;
7033 if (p
!= buff
+ field_size
+ 4)
7037 warn (_("Internal error: not enough buffer room for section flag info"));
7038 return _("<unknown>");
7044 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
7045 (unsigned long) proc_flags
);
7046 p
+= 7 + field_size
;
7050 size
-= 10 + field_size
;
7051 if (p
!= buff
+ field_size
+ 4)
7055 warn (_("Internal error: not enough buffer room for section flag info"));
7056 return _("<unknown>");
7062 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
7063 (unsigned long) unknown_flags
);
7064 p
+= 10 + field_size
;
7072 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
7073 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
,
7078 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
7080 if (size
< sizeof (* echdr
))
7082 error (_("Compressed section is too small even for a compression header\n"));
7086 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
7087 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
7088 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
7089 return sizeof (*echdr
);
7093 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
7095 if (size
< sizeof (* echdr
))
7097 error (_("Compressed section is too small even for a compression header\n"));
7101 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
7102 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
7103 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
7104 return sizeof (*echdr
);
7109 process_section_headers (Filedata
* filedata
)
7111 Elf_Internal_Shdr
* section
;
7114 if (filedata
->file_header
.e_shnum
== 0)
7116 /* PR binutils/12467. */
7117 if (filedata
->file_header
.e_shoff
!= 0)
7119 warn (_("possibly corrupt ELF file header - it has a non-zero"
7120 " section header offset, but no section headers\n"));
7123 else if (do_sections
)
7124 printf (_("\nThere are no sections in this file.\n"));
7129 if (do_sections
&& !do_header
)
7131 if (filedata
->is_separate
&& process_links
)
7132 printf (_("In linked file '%s': "), filedata
->file_name
);
7133 if (! filedata
->is_separate
|| process_links
)
7134 printf (ngettext ("There is %d section header, "
7135 "starting at offset 0x%lx:\n",
7136 "There are %d section headers, "
7137 "starting at offset 0x%lx:\n",
7138 filedata
->file_header
.e_shnum
),
7139 filedata
->file_header
.e_shnum
,
7140 (unsigned long) filedata
->file_header
.e_shoff
);
7143 if (!get_section_headers (filedata
, false))
7146 /* Read in the string table, so that we have names to display. */
7147 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
7148 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
7150 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
7152 if (section
->sh_size
!= 0)
7154 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
7155 1, section
->sh_size
,
7158 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
7162 /* Scan the sections for the dynamic symbol table
7163 and dynamic string table and debug sections. */
7164 eh_addr_size
= is_32bit_elf
? 4 : 8;
7165 switch (filedata
->file_header
.e_machine
)
7168 case EM_MIPS_RS3_LE
:
7169 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
7170 FDE addresses. However, the ABI also has a semi-official ILP32
7171 variant for which the normal FDE address size rules apply.
7173 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
7174 section, where XX is the size of longs in bits. Unfortunately,
7175 earlier compilers provided no way of distinguishing ILP32 objects
7176 from LP64 objects, so if there's any doubt, we should assume that
7177 the official LP64 form is being used. */
7178 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
7179 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
7185 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
7187 case E_H8_MACH_H8300
:
7188 case E_H8_MACH_H8300HN
:
7189 case E_H8_MACH_H8300SN
:
7190 case E_H8_MACH_H8300SXN
:
7193 case E_H8_MACH_H8300H
:
7194 case E_H8_MACH_H8300S
:
7195 case E_H8_MACH_H8300SX
:
7203 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
7205 case EF_M32C_CPU_M16C
:
7212 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
7215 uint64_t expected_entsize = is_32bit_elf ? size32 : size64; \
7216 if (section->sh_entsize != expected_entsize) \
7218 error (_("Section %d has invalid sh_entsize of %" PRIx64 "\n"), \
7219 i, section->sh_entsize); \
7220 error (_("(Using the expected size of %" PRIx64 " for the rest of this dump)\n"), \
7221 expected_entsize); \
7222 section->sh_entsize = expected_entsize; \
7227 #define CHECK_ENTSIZE(section, i, type) \
7228 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
7229 sizeof (Elf64_External_##type))
7231 for (i
= 0, section
= filedata
->section_headers
;
7232 i
< filedata
->file_header
.e_shnum
;
7235 const char *name
= section_name_print (filedata
, section
);
7237 /* Run some sanity checks on the headers and
7238 possibly fill in some file data as well. */
7239 switch (section
->sh_type
)
7242 if (filedata
->dynamic_symbols
!= NULL
)
7244 error (_("File contains multiple dynamic symbol tables\n"));
7248 CHECK_ENTSIZE (section
, i
, Sym
);
7249 filedata
->dynamic_symbols
7250 = get_elf_symbols (filedata
, section
, &filedata
->num_dynamic_syms
);
7251 filedata
->dynamic_symtab_section
= section
;
7255 if (streq (name
, ".dynstr"))
7257 if (filedata
->dynamic_strings
!= NULL
)
7259 error (_("File contains multiple dynamic string tables\n"));
7263 filedata
->dynamic_strings
7264 = (char *) get_data (NULL
, filedata
, section
->sh_offset
,
7265 1, section
->sh_size
, _("dynamic strings"));
7266 filedata
->dynamic_strings_length
7267 = filedata
->dynamic_strings
== NULL
? 0 : section
->sh_size
;
7268 filedata
->dynamic_strtab_section
= section
;
7272 case SHT_SYMTAB_SHNDX
:
7274 elf_section_list
* entry
= xmalloc (sizeof * entry
);
7276 entry
->hdr
= section
;
7277 entry
->next
= filedata
->symtab_shndx_list
;
7278 filedata
->symtab_shndx_list
= entry
;
7283 CHECK_ENTSIZE (section
, i
, Sym
);
7287 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
7291 CHECK_ENTSIZE (section
, i
, Rel
);
7292 if (do_checks
&& section
->sh_size
== 0)
7293 warn (_("Section '%s': zero-sized relocation section\n"), name
);
7297 CHECK_ENTSIZE (section
, i
, Rela
);
7298 if (do_checks
&& section
->sh_size
== 0)
7299 warn (_("Section '%s': zero-sized relocation section\n"), name
);
7303 CHECK_ENTSIZE (section
, i
, Relr
);
7308 /* Having a zero sized section is not illegal according to the
7309 ELF standard, but it might be an indication that something
7310 is wrong. So issue a warning if we are running in lint mode. */
7311 if (do_checks
&& section
->sh_size
== 0)
7312 warn (_("Section '%s': has a size of zero - is this intended ?\n"), name
);
7319 if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
7320 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
7321 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
7322 || do_debug_str
|| do_debug_str_offsets
|| do_debug_loc
7324 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
7325 && (startswith (name
, ".debug_")
7326 || startswith (name
, ".zdebug_")))
7329 name
+= sizeof (".zdebug_") - 1;
7331 name
+= sizeof (".debug_") - 1;
7334 || (do_debug_info
&& startswith (name
, "info"))
7335 || (do_debug_info
&& startswith (name
, "types"))
7336 || (do_debug_abbrevs
&& startswith (name
, "abbrev"))
7337 || (do_debug_lines
&& strcmp (name
, "line") == 0)
7338 || (do_debug_lines
&& startswith (name
, "line."))
7339 || (do_debug_pubnames
&& startswith (name
, "pubnames"))
7340 || (do_debug_pubtypes
&& startswith (name
, "pubtypes"))
7341 || (do_debug_pubnames
&& startswith (name
, "gnu_pubnames"))
7342 || (do_debug_pubtypes
&& startswith (name
, "gnu_pubtypes"))
7343 || (do_debug_aranges
&& startswith (name
, "aranges"))
7344 || (do_debug_ranges
&& startswith (name
, "ranges"))
7345 || (do_debug_ranges
&& startswith (name
, "rnglists"))
7346 || (do_debug_frames
&& startswith (name
, "frame"))
7347 || (do_debug_macinfo
&& startswith (name
, "macinfo"))
7348 || (do_debug_macinfo
&& startswith (name
, "macro"))
7349 || (do_debug_str
&& startswith (name
, "str"))
7350 || (do_debug_links
&& startswith (name
, "sup"))
7351 || (do_debug_str_offsets
&& startswith (name
, "str_offsets"))
7352 || (do_debug_loc
&& startswith (name
, "loc"))
7353 || (do_debug_loc
&& startswith (name
, "loclists"))
7354 || (do_debug_addr
&& startswith (name
, "addr"))
7355 || (do_debug_cu_index
&& startswith (name
, "cu_index"))
7356 || (do_debug_cu_index
&& startswith (name
, "tu_index"))
7358 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7360 /* Linkonce section to be combined with .debug_info at link time. */
7361 else if ((do_debugging
|| do_debug_info
)
7362 && startswith (name
, ".gnu.linkonce.wi."))
7363 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7364 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
7365 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7366 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
7367 || streq (name
, ".debug_names")))
7368 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7369 /* Trace sections for Itanium VMS. */
7370 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
7371 || do_trace_aranges
)
7372 && startswith (name
, ".trace_"))
7374 name
+= sizeof (".trace_") - 1;
7377 || (do_trace_info
&& streq (name
, "info"))
7378 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
7379 || (do_trace_aranges
&& streq (name
, "aranges"))
7381 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7383 else if ((do_debugging
|| do_debug_links
)
7384 && (startswith (name
, ".gnu_debuglink")
7385 || startswith (name
, ".gnu_debugaltlink")))
7386 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7392 if (filedata
->is_separate
&& ! process_links
)
7395 if (filedata
->is_separate
)
7396 printf (_("\nSection Headers in linked file '%s':\n"), filedata
->file_name
);
7397 else if (filedata
->file_header
.e_shnum
> 1)
7398 printf (_("\nSection Headers:\n"));
7400 printf (_("\nSection Header:\n"));
7404 if (do_section_details
)
7406 printf (_(" [Nr] Name\n"));
7407 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
7411 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
7415 if (do_section_details
)
7417 printf (_(" [Nr] Name\n"));
7418 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
7422 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
7426 if (do_section_details
)
7428 printf (_(" [Nr] Name\n"));
7429 printf (_(" Type Address Offset Link\n"));
7430 printf (_(" Size EntSize Info Align\n"));
7434 printf (_(" [Nr] Name Type Address Offset\n"));
7435 printf (_(" Size EntSize Flags Link Info Align\n"));
7439 if (do_section_details
)
7440 printf (_(" Flags\n"));
7442 for (i
= 0, section
= filedata
->section_headers
;
7443 i
< filedata
->file_header
.e_shnum
;
7446 /* Run some sanity checks on the section header. */
7448 /* Check the sh_link field. */
7449 switch (section
->sh_type
)
7453 if (section
->sh_link
== 0
7454 && (filedata
->file_header
.e_type
== ET_EXEC
7455 || filedata
->file_header
.e_type
== ET_DYN
))
7456 /* A dynamic relocation section where all entries use a
7457 zero symbol index need not specify a symtab section. */
7460 case SHT_SYMTAB_SHNDX
:
7464 case SHT_GNU_versym
:
7465 if (section
->sh_link
== 0
7466 || section
->sh_link
>= filedata
->file_header
.e_shnum
7467 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
7468 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
7469 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
7470 i
, section
->sh_link
);
7476 case SHT_GNU_verneed
:
7477 case SHT_GNU_verdef
:
7478 case SHT_GNU_LIBLIST
:
7479 if (section
->sh_link
== 0
7480 || section
->sh_link
>= filedata
->file_header
.e_shnum
7481 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
7482 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
7483 i
, section
->sh_link
);
7486 case SHT_INIT_ARRAY
:
7487 case SHT_FINI_ARRAY
:
7488 case SHT_PREINIT_ARRAY
:
7489 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
7490 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
7491 i
, section
->sh_link
);
7495 /* FIXME: Add support for target specific section types. */
7496 #if 0 /* Currently we do not check other section types as there are too
7497 many special cases. Stab sections for example have a type
7498 of SHT_PROGBITS but an sh_link field that links to the .stabstr
7500 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
7501 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
7502 i
, section
->sh_link
);
7507 /* Check the sh_info field. */
7508 switch (section
->sh_type
)
7512 if (section
->sh_info
== 0
7513 && (filedata
->file_header
.e_type
== ET_EXEC
7514 || filedata
->file_header
.e_type
== ET_DYN
))
7515 /* Dynamic relocations apply to segments, so they do not
7516 need to specify the section they relocate. */
7518 if (section
->sh_info
== 0
7519 || section
->sh_info
>= filedata
->file_header
.e_shnum
7520 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
7521 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
7522 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
7523 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
7524 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
7525 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
7526 /* FIXME: Are other section types valid ? */
7527 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
7528 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
7529 i
, section
->sh_info
);
7534 case SHT_SYMTAB_SHNDX
:
7535 case SHT_INIT_ARRAY
:
7536 case SHT_FINI_ARRAY
:
7537 case SHT_PREINIT_ARRAY
:
7538 if (section
->sh_info
!= 0)
7539 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
7540 i
, section
->sh_info
);
7546 /* A symbol index - we assume that it is valid. */
7550 /* FIXME: Add support for target specific section types. */
7551 if (section
->sh_type
== SHT_NOBITS
)
7552 /* NOBITS section headers with non-zero sh_info fields can be
7553 created when a binary is stripped of everything but its debug
7554 information. The stripped sections have their headers
7555 preserved but their types set to SHT_NOBITS. So do not check
7556 this type of section. */
7558 else if (section
->sh_flags
& SHF_INFO_LINK
)
7560 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
7561 warn (_("[%2u]: Expected link to another section in info field"), i
);
7563 else if (section
->sh_type
< SHT_LOOS
7564 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
7565 && section
->sh_info
!= 0)
7566 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
7567 i
, section
->sh_info
);
7571 /* Check the sh_size field. */
7572 if (section
->sh_size
> filedata
->file_size
7573 && section
->sh_type
!= SHT_NOBITS
7574 && section
->sh_type
!= SHT_NULL
7575 && section
->sh_type
< SHT_LOOS
)
7576 warn (_("Size of section %u is larger than the entire file!\n"), i
);
7578 printf (" [%2u] ", i
);
7579 if (do_section_details
)
7580 printf ("%s\n ", printable_section_name (filedata
, section
));
7582 print_symbol (-17, section_name_print (filedata
, section
));
7584 printf (do_wide
? " %-15s " : " %-15.15s ",
7585 get_section_type_name (filedata
, section
->sh_type
));
7589 const char * link_too_big
= NULL
;
7591 print_vma (section
->sh_addr
, LONG_HEX
);
7593 printf ( " %6.6lx %6.6lx %2.2lx",
7594 (unsigned long) section
->sh_offset
,
7595 (unsigned long) section
->sh_size
,
7596 (unsigned long) section
->sh_entsize
);
7598 if (do_section_details
)
7599 fputs (" ", stdout
);
7601 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
7603 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
7606 /* The sh_link value is out of range. Normally this indicates
7607 an error but it can have special values in Solaris binaries. */
7608 switch (filedata
->file_header
.e_machine
)
7615 case EM_OLD_SPARCV9
:
7616 case EM_SPARC32PLUS
:
7619 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
7620 link_too_big
= "BEFORE";
7621 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
7622 link_too_big
= "AFTER";
7629 if (do_section_details
)
7631 if (link_too_big
!= NULL
&& * link_too_big
)
7632 printf ("<%s> ", link_too_big
);
7634 printf ("%2u ", section
->sh_link
);
7635 printf ("%3u %2lu\n", section
->sh_info
,
7636 (unsigned long) section
->sh_addralign
);
7639 printf ("%2u %3u %2lu\n",
7642 (unsigned long) section
->sh_addralign
);
7644 if (link_too_big
&& ! * link_too_big
)
7645 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
7646 i
, section
->sh_link
);
7650 print_vma (section
->sh_addr
, LONG_HEX
);
7652 if ((long) section
->sh_offset
== section
->sh_offset
)
7653 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
7657 print_vma (section
->sh_offset
, LONG_HEX
);
7660 if ((unsigned long) section
->sh_size
== section
->sh_size
)
7661 printf (" %6.6lx", (unsigned long) section
->sh_size
);
7665 print_vma (section
->sh_size
, LONG_HEX
);
7668 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
7669 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
7673 print_vma (section
->sh_entsize
, LONG_HEX
);
7676 if (do_section_details
)
7677 fputs (" ", stdout
);
7679 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
7681 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
7683 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
7684 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
7687 print_vma (section
->sh_addralign
, DEC
);
7691 else if (do_section_details
)
7694 print_vma (section
->sh_addr
, LONG_HEX
);
7695 if ((long) section
->sh_offset
== section
->sh_offset
)
7696 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
7700 print_vma (section
->sh_offset
, LONG_HEX
);
7702 printf (" %u\n ", section
->sh_link
);
7703 print_vma (section
->sh_size
, LONG_HEX
);
7705 print_vma (section
->sh_entsize
, LONG_HEX
);
7707 printf (" %-16u %lu\n",
7709 (unsigned long) section
->sh_addralign
);
7714 print_vma (section
->sh_addr
, LONG_HEX
);
7715 if ((long) section
->sh_offset
== section
->sh_offset
)
7716 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
7720 print_vma (section
->sh_offset
, LONG_HEX
);
7723 print_vma (section
->sh_size
, LONG_HEX
);
7725 print_vma (section
->sh_entsize
, LONG_HEX
);
7727 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
7729 printf (" %2u %3u %lu\n",
7732 (unsigned long) section
->sh_addralign
);
7735 if (do_section_details
)
7737 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
7738 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
7740 /* Minimum section size is 12 bytes for 32-bit compression
7741 header + 12 bytes for compressed data header. */
7742 unsigned char buf
[24];
7744 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
7745 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
7746 sizeof (buf
), _("compression header")))
7748 Elf_Internal_Chdr chdr
;
7750 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
7751 printf (_(" [<corrupt>]\n"));
7754 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
7756 else if (chdr
.ch_type
== ELFCOMPRESS_ZSTD
)
7759 printf (_(" [<unknown>: 0x%x], "),
7761 print_vma (chdr
.ch_size
, LONG_HEX
);
7762 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
7769 if (!do_section_details
)
7771 /* The ordering of the letters shown here matches the ordering of the
7772 corresponding SHF_xxx values, and hence the order in which these
7773 letters will be displayed to the user. */
7774 printf (_("Key to Flags:\n\
7775 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
7776 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
7777 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
7778 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
7781 case ELFOSABI_FREEBSD
:
7782 printf (_("R (retain), "));
7785 printf (_("D (mbind), "));
7790 if (filedata
->file_header
.e_machine
== EM_X86_64
7791 || filedata
->file_header
.e_machine
== EM_L1OM
7792 || filedata
->file_header
.e_machine
== EM_K1OM
)
7793 printf (_("l (large), "));
7794 else if (filedata
->file_header
.e_machine
== EM_ARM
)
7795 printf (_("y (purecode), "));
7796 else if (filedata
->file_header
.e_machine
== EM_PPC
)
7797 printf (_("v (VLE), "));
7798 printf ("p (processor specific)\n");
7805 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
7806 Elf_Internal_Sym
**symtab
, unsigned long *nsyms
,
7807 char **strtab
, unsigned long *strtablen
)
7811 *symtab
= get_elf_symbols (filedata
, symsec
, nsyms
);
7813 if (*symtab
== NULL
)
7816 if (symsec
->sh_link
!= 0)
7818 Elf_Internal_Shdr
*strsec
;
7820 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
7822 error (_("Bad sh_link in symbol table section\n"));
7829 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7831 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7832 1, strsec
->sh_size
, _("string table"));
7833 if (*strtab
== NULL
)
7840 *strtablen
= strsec
->sh_size
;
7846 get_group_flags (unsigned int flags
)
7848 static char buff
[128];
7852 else if (flags
== GRP_COMDAT
)
7855 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
7857 flags
& GRP_MASKOS
? _("<OS specific>") : "",
7858 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
7859 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
7860 ? _("<unknown>") : ""));
7866 process_section_groups (Filedata
* filedata
)
7868 Elf_Internal_Shdr
* section
;
7870 struct group
* group
;
7871 Elf_Internal_Shdr
* symtab_sec
;
7872 Elf_Internal_Shdr
* strtab_sec
;
7873 Elf_Internal_Sym
* symtab
;
7874 unsigned long num_syms
;
7878 /* Don't process section groups unless needed. */
7879 if (!do_unwind
&& !do_section_groups
)
7882 if (filedata
->file_header
.e_shnum
== 0)
7884 if (do_section_groups
)
7886 if (filedata
->is_separate
)
7887 printf (_("\nThere are no sections group in linked file '%s'.\n"),
7888 filedata
->file_name
);
7890 printf (_("\nThere are no section groups in this file.\n"));
7895 if (filedata
->section_headers
== NULL
)
7897 error (_("Section headers are not available!\n"));
7898 /* PR 13622: This can happen with a corrupt ELF header. */
7902 filedata
->section_headers_groups
7903 = (struct group
**) calloc (filedata
->file_header
.e_shnum
,
7904 sizeof (struct group
*));
7906 if (filedata
->section_headers_groups
== NULL
)
7908 error (_("Out of memory reading %u section group headers\n"),
7909 filedata
->file_header
.e_shnum
);
7913 /* Scan the sections for the group section. */
7914 filedata
->group_count
= 0;
7915 for (i
= 0, section
= filedata
->section_headers
;
7916 i
< filedata
->file_header
.e_shnum
;
7918 if (section
->sh_type
== SHT_GROUP
)
7919 filedata
->group_count
++;
7921 if (filedata
->group_count
== 0)
7923 if (do_section_groups
)
7925 if (filedata
->is_separate
)
7926 printf (_("\nThere are no section groups in linked file '%s'.\n"),
7927 filedata
->file_name
);
7929 printf (_("\nThere are no section groups in this file.\n"));
7935 filedata
->section_groups
= (struct group
*) calloc (filedata
->group_count
,
7936 sizeof (struct group
));
7938 if (filedata
->section_groups
== NULL
)
7940 error (_("Out of memory reading %lu groups\n"),
7941 (unsigned long) filedata
->group_count
);
7952 if (filedata
->is_separate
)
7953 printf (_("Section groups in linked file '%s'\n"), filedata
->file_name
);
7955 for (i
= 0, section
= filedata
->section_headers
, group
= filedata
->section_groups
;
7956 i
< filedata
->file_header
.e_shnum
;
7959 if (section
->sh_type
== SHT_GROUP
)
7961 const char * name
= printable_section_name (filedata
, section
);
7962 const char * group_name
;
7963 unsigned char * start
;
7964 unsigned char * indices
;
7965 unsigned int entry
, j
, size
;
7966 Elf_Internal_Shdr
* sec
;
7967 Elf_Internal_Sym
* sym
;
7969 /* Get the symbol table. */
7970 if (section
->sh_link
>= filedata
->file_header
.e_shnum
7971 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
7974 error (_("Bad sh_link in group section `%s'\n"), name
);
7978 if (symtab_sec
!= sec
)
7982 symtab
= get_elf_symbols (filedata
, symtab_sec
, & num_syms
);
7987 error (_("Corrupt header in group section `%s'\n"), name
);
7991 if (section
->sh_info
>= num_syms
)
7993 error (_("Bad sh_info in group section `%s'\n"), name
);
7997 sym
= symtab
+ section
->sh_info
;
7999 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
8001 if (sym
->st_shndx
== 0
8002 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
8004 error (_("Bad sh_info in group section `%s'\n"), name
);
8008 group_name
= section_name_print (filedata
,
8009 filedata
->section_headers
8018 /* Get the string table. */
8019 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
8027 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
8032 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
8033 1, strtab_sec
->sh_size
,
8035 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
8037 group_name
= sym
->st_name
< strtab_size
8038 ? strtab
+ sym
->st_name
: _("<corrupt>");
8041 /* PR 17531: file: loop. */
8042 if (section
->sh_entsize
> section
->sh_size
)
8044 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
8045 printable_section_name (filedata
, section
),
8046 (unsigned long) section
->sh_entsize
,
8047 (unsigned long) section
->sh_size
);
8051 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
8052 1, section
->sh_size
,
8058 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
8059 entry
= byte_get (indices
, 4);
8062 if (do_section_groups
)
8064 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
8065 get_group_flags (entry
), i
, name
, group_name
, size
);
8067 printf (_(" [Index] Name\n"));
8070 group
->group_index
= i
;
8072 for (j
= 0; j
< size
; j
++)
8074 struct group_list
* g
;
8076 entry
= byte_get (indices
, 4);
8079 if (entry
>= filedata
->file_header
.e_shnum
)
8081 static unsigned num_group_errors
= 0;
8083 if (num_group_errors
++ < 10)
8085 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
8086 entry
, i
, filedata
->file_header
.e_shnum
- 1);
8087 if (num_group_errors
== 10)
8088 warn (_("Further error messages about overlarge group section indices suppressed\n"));
8093 if (filedata
->section_headers_groups
[entry
] != NULL
)
8097 static unsigned num_errs
= 0;
8099 if (num_errs
++ < 10)
8101 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
8103 filedata
->section_headers_groups
[entry
]->group_index
);
8105 warn (_("Further error messages about already contained group sections suppressed\n"));
8111 /* Intel C/C++ compiler may put section 0 in a
8112 section group. We just warn it the first time
8113 and ignore it afterwards. */
8114 static bool warned
= false;
8117 error (_("section 0 in group section [%5u]\n"),
8118 filedata
->section_headers_groups
[entry
]->group_index
);
8124 filedata
->section_headers_groups
[entry
] = group
;
8126 if (do_section_groups
)
8128 sec
= filedata
->section_headers
+ entry
;
8129 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
8132 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
8133 g
->section_index
= entry
;
8134 g
->next
= group
->root
;
8149 /* Data used to display dynamic fixups. */
8151 struct ia64_vms_dynfixup
8153 uint64_t needed_ident
; /* Library ident number. */
8154 uint64_t needed
; /* Index in the dstrtab of the library name. */
8155 uint64_t fixup_needed
; /* Index of the library. */
8156 uint64_t fixup_rela_cnt
; /* Number of fixups. */
8157 uint64_t fixup_rela_off
; /* Fixups offset in the dynamic segment. */
8160 /* Data used to display dynamic relocations. */
8162 struct ia64_vms_dynimgrela
8164 uint64_t img_rela_cnt
; /* Number of relocations. */
8165 uint64_t img_rela_off
; /* Reloc offset in the dynamic segment. */
8168 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
8172 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
8173 struct ia64_vms_dynfixup
* fixup
,
8174 const char * strtab
,
8175 unsigned int strtab_sz
)
8177 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
8179 const char * lib_name
;
8181 imfs
= get_data (NULL
, filedata
,
8182 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
8183 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
8184 _("dynamic section image fixups"));
8188 if (fixup
->needed
< strtab_sz
)
8189 lib_name
= strtab
+ fixup
->needed
;
8192 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
8193 (unsigned long) fixup
->needed
);
8197 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
8198 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
8200 (_("Seg Offset Type SymVec DataType\n"));
8202 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
8207 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
8208 printf ("%016" PRIx64
" ", BYTE_GET (imfs
[i
].fixup_offset
));
8209 type
= BYTE_GET (imfs
[i
].type
);
8210 rtype
= elf_ia64_reloc_type (type
);
8212 printf ("0x%08x ", type
);
8214 printf ("%-32s ", rtype
);
8215 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
8216 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
8223 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
8226 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
8228 Elf64_External_VMS_IMAGE_RELA
*imrs
;
8231 imrs
= get_data (NULL
, filedata
,
8232 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
8233 sizeof (*imrs
), imgrela
->img_rela_cnt
,
8234 _("dynamic section image relocations"));
8238 printf (_("\nImage relocs\n"));
8240 (_("Seg Offset Type Addend Seg Sym Off\n"));
8242 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
8247 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
8248 printf ("%08" PRIx64
" ", BYTE_GET (imrs
[i
].rela_offset
));
8249 type
= BYTE_GET (imrs
[i
].type
);
8250 rtype
= elf_ia64_reloc_type (type
);
8252 printf ("0x%08x ", type
);
8254 printf ("%-31s ", rtype
);
8255 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
8256 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
8257 printf ("%08" PRIx64
"\n", BYTE_GET (imrs
[i
].sym_offset
));
8264 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
8267 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
8269 struct ia64_vms_dynfixup fixup
;
8270 struct ia64_vms_dynimgrela imgrela
;
8271 Elf_Internal_Dyn
*entry
;
8272 uint64_t strtab_off
= 0;
8273 uint64_t strtab_sz
= 0;
8274 char *strtab
= NULL
;
8277 memset (&fixup
, 0, sizeof (fixup
));
8278 memset (&imgrela
, 0, sizeof (imgrela
));
8280 /* Note: the order of the entries is specified by the OpenVMS specs. */
8281 for (entry
= filedata
->dynamic_section
;
8282 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
8285 switch (entry
->d_tag
)
8287 case DT_IA_64_VMS_STRTAB_OFFSET
:
8288 strtab_off
= entry
->d_un
.d_val
;
8291 strtab_sz
= entry
->d_un
.d_val
;
8293 strtab
= get_data (NULL
, filedata
,
8294 filedata
->dynamic_addr
+ strtab_off
,
8295 1, strtab_sz
, _("dynamic string section"));
8300 case DT_IA_64_VMS_NEEDED_IDENT
:
8301 fixup
.needed_ident
= entry
->d_un
.d_val
;
8304 fixup
.needed
= entry
->d_un
.d_val
;
8306 case DT_IA_64_VMS_FIXUP_NEEDED
:
8307 fixup
.fixup_needed
= entry
->d_un
.d_val
;
8309 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
8310 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
8312 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
8313 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
8314 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
8317 case DT_IA_64_VMS_IMG_RELA_CNT
:
8318 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
8320 case DT_IA_64_VMS_IMG_RELA_OFF
:
8321 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
8322 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
8341 relocation_type rel_type
;
8343 dynamic_relocations
[] =
8345 { "REL", DT_REL
, DT_RELSZ
, reltype_rel
},
8346 { "RELA", DT_RELA
, DT_RELASZ
, reltype_rela
},
8347 { "RELR", DT_RELR
, DT_RELRSZ
, reltype_relr
},
8348 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, reltype_unknown
}
8351 /* Process the reloc section. */
8354 process_relocs (Filedata
* filedata
)
8356 unsigned long rel_size
;
8357 unsigned long rel_offset
;
8362 if (do_using_dynamic
)
8364 relocation_type rel_type
;
8366 bool has_dynamic_reloc
;
8369 has_dynamic_reloc
= false;
8371 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
8373 rel_type
= dynamic_relocations
[i
].rel_type
;
8374 name
= dynamic_relocations
[i
].name
;
8375 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
8376 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
8379 has_dynamic_reloc
= true;
8381 if (rel_type
== reltype_unknown
)
8383 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
8384 switch (filedata
->dynamic_info
[DT_PLTREL
])
8387 rel_type
= reltype_rel
;
8390 rel_type
= reltype_rela
;
8397 if (filedata
->is_separate
)
8399 (_("\nIn linked file '%s' section '%s' at offset 0x%lx contains %ld bytes:\n"),
8400 filedata
->file_name
, name
, rel_offset
, rel_size
);
8403 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
8404 name
, rel_offset
, rel_size
);
8406 dump_relocations (filedata
,
8407 offset_from_vma (filedata
, rel_offset
, rel_size
),
8409 filedata
->dynamic_symbols
,
8410 filedata
->num_dynamic_syms
,
8411 filedata
->dynamic_strings
,
8412 filedata
->dynamic_strings_length
,
8413 rel_type
, true /* is_dynamic */);
8417 if (is_ia64_vms (filedata
))
8418 if (process_ia64_vms_dynamic_relocs (filedata
))
8419 has_dynamic_reloc
= true;
8421 if (! has_dynamic_reloc
)
8423 if (filedata
->is_separate
)
8424 printf (_("\nThere are no dynamic relocations in linked file '%s'.\n"),
8425 filedata
->file_name
);
8427 printf (_("\nThere are no dynamic relocations in this file.\n"));
8432 Elf_Internal_Shdr
* section
;
8436 for (i
= 0, section
= filedata
->section_headers
;
8437 i
< filedata
->file_header
.e_shnum
;
8440 if ( section
->sh_type
!= SHT_RELA
8441 && section
->sh_type
!= SHT_REL
8442 && section
->sh_type
!= SHT_RELR
)
8445 rel_offset
= section
->sh_offset
;
8446 rel_size
= section
->sh_size
;
8450 relocation_type rel_type
;
8451 unsigned long num_rela
;
8453 if (filedata
->is_separate
)
8454 printf (_("\nIn linked file '%s' relocation section "),
8455 filedata
->file_name
);
8457 printf (_("\nRelocation section "));
8459 if (filedata
->string_table
== NULL
)
8460 printf ("%d", section
->sh_name
);
8462 printf ("'%s'", printable_section_name (filedata
, section
));
8464 num_rela
= rel_size
/ section
->sh_entsize
;
8465 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
8466 " at offset 0x%lx contains %lu entries:\n",
8468 rel_offset
, num_rela
);
8470 rel_type
= section
->sh_type
== SHT_RELA
? reltype_rela
:
8471 section
->sh_type
== SHT_REL
? reltype_rel
: reltype_relr
;
8473 if (section
->sh_link
!= 0
8474 && section
->sh_link
< filedata
->file_header
.e_shnum
)
8476 Elf_Internal_Shdr
* symsec
;
8477 Elf_Internal_Sym
* symtab
;
8478 unsigned long nsyms
;
8479 unsigned long strtablen
= 0;
8480 char * strtab
= NULL
;
8482 symsec
= filedata
->section_headers
+ section
->sh_link
;
8483 if (symsec
->sh_type
!= SHT_SYMTAB
8484 && symsec
->sh_type
!= SHT_DYNSYM
)
8487 if (!get_symtab (filedata
, symsec
,
8488 &symtab
, &nsyms
, &strtab
, &strtablen
))
8491 dump_relocations (filedata
, rel_offset
, rel_size
,
8492 symtab
, nsyms
, strtab
, strtablen
,
8494 symsec
->sh_type
== SHT_DYNSYM
);
8499 dump_relocations (filedata
, rel_offset
, rel_size
,
8500 NULL
, 0, NULL
, 0, rel_type
, false /* is_dynamic */);
8508 /* Users sometimes forget the -D option, so try to be helpful. */
8509 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
8511 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
8513 if (filedata
->is_separate
)
8514 printf (_("\nThere are no static relocations in linked file '%s'."),
8515 filedata
->file_name
);
8517 printf (_("\nThere are no static relocations in this file."));
8518 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
8523 if (i
== ARRAY_SIZE (dynamic_relocations
))
8525 if (filedata
->is_separate
)
8526 printf (_("\nThere are no relocations in linked file '%s'.\n"),
8527 filedata
->file_name
);
8529 printf (_("\nThere are no relocations in this file.\n"));
8537 /* An absolute address consists of a section and an offset. If the
8538 section is NULL, the offset itself is the address, otherwise, the
8539 address equals to LOAD_ADDRESS(section) + offset. */
8543 unsigned short section
;
8547 /* Find the nearest symbol at or below ADDR. Returns the symbol
8548 name, if found, and the offset from the symbol to ADDR. */
8551 find_symbol_for_address (Filedata
* filedata
,
8552 Elf_Internal_Sym
* symtab
,
8553 unsigned long nsyms
,
8554 const char * strtab
,
8555 unsigned long strtab_size
,
8556 struct absaddr addr
,
8557 const char ** symname
,
8560 uint64_t dist
= 0x100000;
8561 Elf_Internal_Sym
* sym
;
8562 Elf_Internal_Sym
* beg
;
8563 Elf_Internal_Sym
* end
;
8564 Elf_Internal_Sym
* best
= NULL
;
8566 REMOVE_ARCH_BITS (addr
.offset
);
8568 end
= symtab
+ nsyms
;
8574 sym
= beg
+ (end
- beg
) / 2;
8576 value
= sym
->st_value
;
8577 REMOVE_ARCH_BITS (value
);
8579 if (sym
->st_name
!= 0
8580 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
8581 && addr
.offset
>= value
8582 && addr
.offset
- value
< dist
)
8585 dist
= addr
.offset
- value
;
8590 if (addr
.offset
< value
)
8598 *symname
= (best
->st_name
>= strtab_size
8599 ? _("<corrupt>") : strtab
+ best
->st_name
);
8605 *offset
= addr
.offset
;
8608 static /* signed */ int
8609 symcmp (const void *p
, const void *q
)
8611 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
8612 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
8614 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
8617 /* Process the unwind section. */
8619 #include "unwind-ia64.h"
8621 struct ia64_unw_table_entry
8623 struct absaddr start
;
8625 struct absaddr info
;
8628 struct ia64_unw_aux_info
8630 struct ia64_unw_table_entry
* table
; /* Unwind table. */
8631 unsigned long table_len
; /* Length of unwind table. */
8632 unsigned char * info
; /* Unwind info. */
8633 unsigned long info_size
; /* Size of unwind info. */
8634 uint64_t info_addr
; /* Starting address of unwind info. */
8635 uint64_t seg_base
; /* Starting address of segment. */
8636 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8637 unsigned long nsyms
; /* Number of symbols. */
8638 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8639 unsigned long nfuns
; /* Number of entries in funtab. */
8640 char * strtab
; /* The string table. */
8641 unsigned long strtab_size
; /* Size of string table. */
8645 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
8647 struct ia64_unw_table_entry
* tp
;
8648 unsigned long j
, nfuns
;
8652 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8653 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8654 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8655 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8657 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8659 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8663 const unsigned char * dp
;
8664 const unsigned char * head
;
8665 const unsigned char * end
;
8666 const char * procname
;
8668 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8669 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
8671 fputs ("\n<", stdout
);
8675 fputs (procname
, stdout
);
8678 printf ("+%lx", (unsigned long) offset
);
8681 fputs (">: [", stdout
);
8682 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8683 fputc ('-', stdout
);
8684 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8685 printf ("], info at +0x%lx\n",
8686 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
8688 /* PR 17531: file: 86232b32. */
8689 if (aux
->info
== NULL
)
8692 offset
= tp
->info
.offset
;
8693 if (tp
->info
.section
)
8695 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
8697 warn (_("Invalid section %u in table entry %ld\n"),
8698 tp
->info
.section
, (long) (tp
- aux
->table
));
8702 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
8704 offset
-= aux
->info_addr
;
8705 /* PR 17531: file: 0997b4d1. */
8706 if (offset
>= aux
->info_size
8707 || aux
->info_size
- offset
< 8)
8709 warn (_("Invalid offset %lx in table entry %ld\n"),
8710 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
8715 head
= aux
->info
+ offset
;
8716 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
8718 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
8719 (unsigned) UNW_VER (stamp
),
8720 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
8721 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
8722 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
8723 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
8725 if (UNW_VER (stamp
) != 1)
8727 printf (_("\tUnknown version.\n"));
8732 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
8733 /* PR 17531: file: 16ceda89. */
8734 if (end
> aux
->info
+ aux
->info_size
)
8735 end
= aux
->info
+ aux
->info_size
;
8736 for (dp
= head
+ 8; dp
< end
;)
8737 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
8746 slurp_ia64_unwind_table (Filedata
* filedata
,
8747 struct ia64_unw_aux_info
* aux
,
8748 Elf_Internal_Shdr
* sec
)
8750 unsigned long size
, nrelas
, i
;
8751 Elf_Internal_Phdr
* seg
;
8752 struct ia64_unw_table_entry
* tep
;
8753 Elf_Internal_Shdr
* relsec
;
8754 Elf_Internal_Rela
* rela
;
8755 Elf_Internal_Rela
* rp
;
8756 unsigned char * table
;
8758 Elf_Internal_Sym
* sym
;
8759 const char * relname
;
8763 /* First, find the starting address of the segment that includes
8766 if (filedata
->file_header
.e_phnum
)
8768 if (! get_program_headers (filedata
))
8771 for (seg
= filedata
->program_headers
;
8772 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8775 if (seg
->p_type
!= PT_LOAD
)
8778 if (sec
->sh_addr
>= seg
->p_vaddr
8779 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8781 aux
->seg_base
= seg
->p_vaddr
;
8787 /* Second, build the unwind table from the contents of the unwind section: */
8788 size
= sec
->sh_size
;
8789 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8794 aux
->table_len
= size
/ (3 * eh_addr_size
);
8795 aux
->table
= (struct ia64_unw_table_entry
*)
8796 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
8799 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
8801 tep
->start
.section
= SHN_UNDEF
;
8802 tep
->end
.section
= SHN_UNDEF
;
8803 tep
->info
.section
= SHN_UNDEF
;
8804 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8805 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8806 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8807 tep
->start
.offset
+= aux
->seg_base
;
8808 tep
->end
.offset
+= aux
->seg_base
;
8809 tep
->info
.offset
+= aux
->seg_base
;
8813 /* Third, apply any relocations to the unwind table: */
8814 for (relsec
= filedata
->section_headers
;
8815 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8818 if (relsec
->sh_type
!= SHT_RELA
8819 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8820 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8823 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8832 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8834 unsigned int sym_ndx
;
8835 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8836 relname
= elf_ia64_reloc_type (r_type
);
8838 /* PR 17531: file: 9fa67536. */
8839 if (relname
== NULL
)
8841 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8845 if (! startswith (relname
, "R_IA64_SEGREL"))
8847 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8851 i
= rp
->r_offset
/ (3 * eh_addr_size
);
8853 /* PR 17531: file: 5bc8d9bf. */
8854 if (i
>= aux
->table_len
)
8856 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8860 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8861 if (sym_ndx
>= aux
->nsyms
)
8863 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8867 sym
= aux
->symtab
+ sym_ndx
;
8869 switch (rp
->r_offset
/ eh_addr_size
% 3)
8872 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8873 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
8876 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8877 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
8880 aux
->table
[i
].info
.section
= sym
->st_shndx
;
8881 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
8895 ia64_process_unwind (Filedata
* filedata
)
8897 Elf_Internal_Shdr
* sec
;
8898 Elf_Internal_Shdr
* unwsec
= NULL
;
8899 unsigned long i
, unwcount
= 0, unwstart
= 0;
8900 struct ia64_unw_aux_info aux
;
8903 memset (& aux
, 0, sizeof (aux
));
8905 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8907 if (sec
->sh_type
== SHT_SYMTAB
)
8911 error (_("Multiple symbol tables encountered\n"));
8917 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8918 &aux
.strtab
, &aux
.strtab_size
))
8921 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8926 printf (_("\nThere are no unwind sections in this file.\n"));
8928 while (unwcount
-- > 0)
8933 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
8934 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8935 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8940 /* We have already counted the number of SHT_IA64_UNWIND
8941 sections so the loop above should never fail. */
8942 assert (unwsec
!= NULL
);
8945 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
8947 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
8949 /* We need to find which section group it is in. */
8950 struct group_list
* g
;
8952 if (filedata
->section_headers_groups
== NULL
8953 || filedata
->section_headers_groups
[i
] == NULL
)
8954 i
= filedata
->file_header
.e_shnum
;
8957 g
= filedata
->section_headers_groups
[i
]->root
;
8959 for (; g
!= NULL
; g
= g
->next
)
8961 sec
= filedata
->section_headers
+ g
->section_index
;
8963 if (section_name_valid (filedata
, sec
)
8964 && streq (section_name (filedata
, sec
),
8965 ELF_STRING_ia64_unwind_info
))
8970 i
= filedata
->file_header
.e_shnum
;
8973 else if (section_name_valid (filedata
, unwsec
)
8974 && startswith (section_name (filedata
, unwsec
),
8975 ELF_STRING_ia64_unwind_once
))
8977 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
8978 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
8979 suffix
= section_name (filedata
, unwsec
) + len
;
8980 for (i
= 0, sec
= filedata
->section_headers
;
8981 i
< filedata
->file_header
.e_shnum
;
8983 if (section_name_valid (filedata
, sec
)
8984 && startswith (section_name (filedata
, sec
),
8985 ELF_STRING_ia64_unwind_info_once
)
8986 && streq (section_name (filedata
, sec
) + len2
, suffix
))
8991 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
8992 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
8993 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
8994 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
8996 if (section_name_valid (filedata
, unwsec
)
8997 && startswith (section_name (filedata
, unwsec
),
8998 ELF_STRING_ia64_unwind
))
8999 suffix
= section_name (filedata
, unwsec
) + len
;
9000 for (i
= 0, sec
= filedata
->section_headers
;
9001 i
< filedata
->file_header
.e_shnum
;
9003 if (section_name_valid (filedata
, sec
)
9004 && startswith (section_name (filedata
, sec
),
9005 ELF_STRING_ia64_unwind_info
)
9006 && streq (section_name (filedata
, sec
) + len2
, suffix
))
9010 if (i
== filedata
->file_header
.e_shnum
)
9012 printf (_("\nCould not find unwind info section for "));
9014 if (filedata
->string_table
== NULL
)
9015 printf ("%d", unwsec
->sh_name
);
9017 printf ("'%s'", printable_section_name (filedata
, unwsec
));
9021 aux
.info_addr
= sec
->sh_addr
;
9022 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
9025 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
9027 printf (_("\nUnwind section "));
9029 if (filedata
->string_table
== NULL
)
9030 printf ("%d", unwsec
->sh_name
);
9032 printf ("'%s'", printable_section_name (filedata
, unwsec
));
9034 printf (_(" at offset 0x%lx contains %lu entries:\n"),
9035 (unsigned long) unwsec
->sh_offset
,
9036 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
9038 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
9039 && aux
.table_len
> 0)
9040 dump_ia64_unwind (filedata
, & aux
);
9042 free ((char *) aux
.table
);
9043 free ((char *) aux
.info
);
9050 free ((char *) aux
.strtab
);
9055 struct hppa_unw_table_entry
9057 struct absaddr start
;
9059 unsigned int Cannot_unwind
:1; /* 0 */
9060 unsigned int Millicode
:1; /* 1 */
9061 unsigned int Millicode_save_sr0
:1; /* 2 */
9062 unsigned int Region_description
:2; /* 3..4 */
9063 unsigned int reserved1
:1; /* 5 */
9064 unsigned int Entry_SR
:1; /* 6 */
9065 unsigned int Entry_FR
:4; /* Number saved 7..10 */
9066 unsigned int Entry_GR
:5; /* Number saved 11..15 */
9067 unsigned int Args_stored
:1; /* 16 */
9068 unsigned int Variable_Frame
:1; /* 17 */
9069 unsigned int Separate_Package_Body
:1; /* 18 */
9070 unsigned int Frame_Extension_Millicode
:1; /* 19 */
9071 unsigned int Stack_Overflow_Check
:1; /* 20 */
9072 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
9073 unsigned int Ada_Region
:1; /* 22 */
9074 unsigned int cxx_info
:1; /* 23 */
9075 unsigned int cxx_try_catch
:1; /* 24 */
9076 unsigned int sched_entry_seq
:1; /* 25 */
9077 unsigned int reserved2
:1; /* 26 */
9078 unsigned int Save_SP
:1; /* 27 */
9079 unsigned int Save_RP
:1; /* 28 */
9080 unsigned int Save_MRP_in_frame
:1; /* 29 */
9081 unsigned int extn_ptr_defined
:1; /* 30 */
9082 unsigned int Cleanup_defined
:1; /* 31 */
9084 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
9085 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
9086 unsigned int Large_frame
:1; /* 2 */
9087 unsigned int Pseudo_SP_Set
:1; /* 3 */
9088 unsigned int reserved4
:1; /* 4 */
9089 unsigned int Total_frame_size
:27; /* 5..31 */
9092 struct hppa_unw_aux_info
9094 struct hppa_unw_table_entry
* table
; /* Unwind table. */
9095 unsigned long table_len
; /* Length of unwind table. */
9096 uint64_t seg_base
; /* Starting address of segment. */
9097 Elf_Internal_Sym
* symtab
; /* The symbol table. */
9098 unsigned long nsyms
; /* Number of symbols. */
9099 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
9100 unsigned long nfuns
; /* Number of entries in funtab. */
9101 char * strtab
; /* The string table. */
9102 unsigned long strtab_size
; /* Size of string table. */
9106 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
9108 struct hppa_unw_table_entry
* tp
;
9109 unsigned long j
, nfuns
;
9112 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9113 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9114 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9115 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9117 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9119 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
9122 const char * procname
;
9124 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
9125 aux
->strtab_size
, tp
->start
, &procname
,
9128 fputs ("\n<", stdout
);
9132 fputs (procname
, stdout
);
9135 printf ("+%lx", (unsigned long) offset
);
9138 fputs (">: [", stdout
);
9139 print_vma (tp
->start
.offset
, PREFIX_HEX
);
9140 fputc ('-', stdout
);
9141 print_vma (tp
->end
.offset
, PREFIX_HEX
);
9144 #define PF(_m) if (tp->_m) printf (#_m " ");
9145 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
9148 PF(Millicode_save_sr0
);
9149 /* PV(Region_description); */
9155 PF(Separate_Package_Body
);
9156 PF(Frame_Extension_Millicode
);
9157 PF(Stack_Overflow_Check
);
9158 PF(Two_Instruction_SP_Increment
);
9162 PF(sched_entry_seq
);
9165 PF(Save_MRP_in_frame
);
9166 PF(extn_ptr_defined
);
9167 PF(Cleanup_defined
);
9168 PF(MPE_XL_interrupt_marker
);
9169 PF(HP_UX_interrupt_marker
);
9172 PV(Total_frame_size
);
9185 slurp_hppa_unwind_table (Filedata
* filedata
,
9186 struct hppa_unw_aux_info
* aux
,
9187 Elf_Internal_Shdr
* sec
)
9189 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
9190 Elf_Internal_Phdr
* seg
;
9191 struct hppa_unw_table_entry
* tep
;
9192 Elf_Internal_Shdr
* relsec
;
9193 Elf_Internal_Rela
* rela
;
9194 Elf_Internal_Rela
* rp
;
9195 unsigned char * table
;
9197 Elf_Internal_Sym
* sym
;
9198 const char * relname
;
9200 /* First, find the starting address of the segment that includes
9202 if (filedata
->file_header
.e_phnum
)
9204 if (! get_program_headers (filedata
))
9207 for (seg
= filedata
->program_headers
;
9208 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
9211 if (seg
->p_type
!= PT_LOAD
)
9214 if (sec
->sh_addr
>= seg
->p_vaddr
9215 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
9217 aux
->seg_base
= seg
->p_vaddr
;
9223 /* Second, build the unwind table from the contents of the unwind
9225 size
= sec
->sh_size
;
9226 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
9232 nentries
= size
/ unw_ent_size
;
9233 size
= unw_ent_size
* nentries
;
9235 aux
->table_len
= nentries
;
9236 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
9237 xcmalloc (nentries
, sizeof (aux
->table
[0]));
9239 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
9241 unsigned int tmp1
, tmp2
;
9243 tep
->start
.section
= SHN_UNDEF
;
9244 tep
->end
.section
= SHN_UNDEF
;
9246 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
9247 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
9248 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
9249 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
9251 tep
->start
.offset
+= aux
->seg_base
;
9252 tep
->end
.offset
+= aux
->seg_base
;
9254 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
9255 tep
->Millicode
= (tmp1
>> 30) & 0x1;
9256 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
9257 tep
->Region_description
= (tmp1
>> 27) & 0x3;
9258 tep
->reserved1
= (tmp1
>> 26) & 0x1;
9259 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
9260 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
9261 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
9262 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
9263 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
9264 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
9265 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
9266 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
9267 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
9268 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
9269 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
9270 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
9271 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
9272 tep
->reserved2
= (tmp1
>> 5) & 0x1;
9273 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
9274 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
9275 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
9276 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
9277 tep
->Cleanup_defined
= tmp1
& 0x1;
9279 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
9280 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
9281 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
9282 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
9283 tep
->reserved4
= (tmp2
>> 27) & 0x1;
9284 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
9288 /* Third, apply any relocations to the unwind table. */
9289 for (relsec
= filedata
->section_headers
;
9290 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
9293 if (relsec
->sh_type
!= SHT_RELA
9294 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
9295 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
9298 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
9302 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
9304 unsigned int sym_ndx
;
9305 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
9306 relname
= elf_hppa_reloc_type (r_type
);
9308 if (relname
== NULL
)
9310 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
9314 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
9315 if (! startswith (relname
, "R_PARISC_SEGREL"))
9317 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
9321 i
= rp
->r_offset
/ unw_ent_size
;
9322 if (i
>= aux
->table_len
)
9324 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
9328 sym_ndx
= get_reloc_symindex (rp
->r_info
);
9329 if (sym_ndx
>= aux
->nsyms
)
9331 warn (_("Skipping reloc with invalid symbol index: %u\n"),
9335 sym
= aux
->symtab
+ sym_ndx
;
9337 switch ((rp
->r_offset
% unw_ent_size
) / 4)
9340 aux
->table
[i
].start
.section
= sym
->st_shndx
;
9341 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
9344 aux
->table
[i
].end
.section
= sym
->st_shndx
;
9345 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
9359 hppa_process_unwind (Filedata
* filedata
)
9361 struct hppa_unw_aux_info aux
;
9362 Elf_Internal_Shdr
* unwsec
= NULL
;
9363 Elf_Internal_Shdr
* sec
;
9367 if (filedata
->string_table
== NULL
)
9370 memset (& aux
, 0, sizeof (aux
));
9372 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9374 if (sec
->sh_type
== SHT_SYMTAB
)
9378 error (_("Multiple symbol tables encountered\n"));
9384 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9385 &aux
.strtab
, &aux
.strtab_size
))
9388 else if (section_name_valid (filedata
, sec
)
9389 && streq (section_name (filedata
, sec
), ".PARISC.unwind"))
9394 printf (_("\nThere are no unwind sections in this file.\n"));
9396 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9398 if (section_name_valid (filedata
, sec
)
9399 && streq (section_name (filedata
, sec
), ".PARISC.unwind"))
9401 unsigned long num_unwind
= sec
->sh_size
/ 16;
9403 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9404 "contains %lu entry:\n",
9405 "\nUnwind section '%s' at offset 0x%lx "
9406 "contains %lu entries:\n",
9408 printable_section_name (filedata
, sec
),
9409 (unsigned long) sec
->sh_offset
,
9412 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
9415 if (res
&& aux
.table_len
> 0)
9417 if (! dump_hppa_unwind (filedata
, &aux
))
9421 free ((char *) aux
.table
);
9427 free ((char *) aux
.strtab
);
9434 unsigned char * data
; /* The unwind data. */
9435 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
9436 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
9437 unsigned long nrelas
; /* The number of relocations. */
9438 unsigned int rel_type
; /* REL or RELA ? */
9439 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
9442 struct arm_unw_aux_info
9444 Filedata
* filedata
; /* The file containing the unwind sections. */
9445 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
9446 unsigned long nsyms
; /* Number of symbols. */
9447 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
9448 unsigned long nfuns
; /* Number of these symbols. */
9449 char * strtab
; /* The file's string table. */
9450 unsigned long strtab_size
; /* Size of string table. */
9454 arm_print_vma_and_name (Filedata
* filedata
,
9455 struct arm_unw_aux_info
* aux
,
9457 struct absaddr addr
)
9459 const char *procname
;
9460 uint64_t sym_offset
;
9462 if (addr
.section
== SHN_UNDEF
)
9465 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
9466 aux
->strtab_size
, addr
, &procname
,
9469 print_vma (fn
, PREFIX_HEX
);
9473 fputs (" <", stdout
);
9474 fputs (procname
, stdout
);
9477 printf ("+0x%lx", (unsigned long) sym_offset
);
9478 fputc ('>', stdout
);
9485 arm_free_section (struct arm_section
*arm_sec
)
9487 free (arm_sec
->data
);
9488 free (arm_sec
->rela
);
9491 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
9492 cached section and install SEC instead.
9493 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
9494 and return its valued in * WORDP, relocating if necessary.
9495 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
9496 relocation's offset in ADDR.
9497 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
9498 into the string table of the symbol associated with the reloc. If no
9499 reloc was applied store -1 there.
9500 5) Return TRUE upon success, FALSE otherwise. */
9503 get_unwind_section_word (Filedata
* filedata
,
9504 struct arm_unw_aux_info
* aux
,
9505 struct arm_section
* arm_sec
,
9506 Elf_Internal_Shdr
* sec
,
9507 uint64_t word_offset
,
9508 unsigned int * wordp
,
9509 struct absaddr
* addr
,
9510 uint64_t * sym_name
)
9512 Elf_Internal_Rela
*rp
;
9513 Elf_Internal_Sym
*sym
;
9514 const char * relname
;
9518 if (sec
== NULL
|| arm_sec
== NULL
)
9521 addr
->section
= SHN_UNDEF
;
9524 if (sym_name
!= NULL
)
9525 *sym_name
= (uint64_t) -1;
9527 /* If necessary, update the section cache. */
9528 if (sec
!= arm_sec
->sec
)
9530 Elf_Internal_Shdr
*relsec
;
9532 arm_free_section (arm_sec
);
9535 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
9536 sec
->sh_size
, _("unwind data"));
9537 arm_sec
->rela
= NULL
;
9538 arm_sec
->nrelas
= 0;
9540 for (relsec
= filedata
->section_headers
;
9541 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
9544 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
9545 || filedata
->section_headers
+ relsec
->sh_info
!= sec
9546 /* PR 15745: Check the section type as well. */
9547 || (relsec
->sh_type
!= SHT_REL
9548 && relsec
->sh_type
!= SHT_RELA
))
9551 arm_sec
->rel_type
= relsec
->sh_type
;
9552 if (relsec
->sh_type
== SHT_REL
)
9554 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
9556 & arm_sec
->rela
, & arm_sec
->nrelas
))
9559 else /* relsec->sh_type == SHT_RELA */
9561 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
9563 & arm_sec
->rela
, & arm_sec
->nrelas
))
9569 arm_sec
->next_rela
= arm_sec
->rela
;
9572 /* If there is no unwind data we can do nothing. */
9573 if (arm_sec
->data
== NULL
)
9576 /* If the offset is invalid then fail. */
9577 if (/* PR 21343 *//* PR 18879 */
9579 || word_offset
> sec
->sh_size
- 4)
9582 /* Get the word at the required offset. */
9583 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
9585 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
9586 if (arm_sec
->rela
== NULL
)
9592 /* Look through the relocs to find the one that applies to the provided offset. */
9594 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
9596 uint64_t prelval
, offset
;
9598 if (rp
->r_offset
> word_offset
&& !wrapped
)
9603 if (rp
->r_offset
> word_offset
)
9606 if (rp
->r_offset
& 3)
9608 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
9609 (unsigned long) rp
->r_offset
);
9613 if (rp
->r_offset
< word_offset
)
9616 /* PR 17531: file: 027-161405-0.004 */
9617 if (aux
->symtab
== NULL
)
9620 if (arm_sec
->rel_type
== SHT_REL
)
9622 offset
= word
& 0x7fffffff;
9623 if (offset
& 0x40000000)
9624 offset
|= ~ (uint64_t) 0x7fffffff;
9626 else if (arm_sec
->rel_type
== SHT_RELA
)
9627 offset
= rp
->r_addend
;
9630 error (_("Unknown section relocation type %d encountered\n"),
9635 /* PR 17531 file: 027-1241568-0.004. */
9636 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
9638 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
9639 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
9643 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
9644 offset
+= sym
->st_value
;
9645 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
9647 /* Check that we are processing the expected reloc type. */
9648 if (filedata
->file_header
.e_machine
== EM_ARM
)
9650 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
9651 if (relname
== NULL
)
9653 warn (_("Skipping unknown ARM relocation type: %d\n"),
9654 (int) ELF32_R_TYPE (rp
->r_info
));
9658 if (streq (relname
, "R_ARM_NONE"))
9661 if (! streq (relname
, "R_ARM_PREL31"))
9663 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
9667 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9669 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
9670 if (relname
== NULL
)
9672 warn (_("Skipping unknown C6000 relocation type: %d\n"),
9673 (int) ELF32_R_TYPE (rp
->r_info
));
9677 if (streq (relname
, "R_C6000_NONE"))
9680 if (! streq (relname
, "R_C6000_PREL31"))
9682 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
9690 /* This function currently only supports ARM and TI unwinders. */
9691 warn (_("Only TI and ARM unwinders are currently supported\n"));
9695 word
= (word
& ~ (uint64_t) 0x7fffffff) | (prelval
& 0x7fffffff);
9696 addr
->section
= sym
->st_shndx
;
9697 addr
->offset
= offset
;
9700 * sym_name
= sym
->st_name
;
9705 arm_sec
->next_rela
= rp
;
9710 static const char *tic6x_unwind_regnames
[16] =
9712 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
9713 "A14", "A13", "A12", "A11", "A10",
9714 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
9718 decode_tic6x_unwind_regmask (unsigned int mask
)
9722 for (i
= 12; mask
; mask
>>= 1, i
--)
9726 fputs (tic6x_unwind_regnames
[i
], stdout
);
9728 fputs (", ", stdout
);
9734 if (remaining == 0 && more_words) \
9737 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
9738 data_offset, & word, & addr, NULL)) \
9744 #define GET_OP(OP) \
9749 (OP) = word >> 24; \
9754 printf (_("[Truncated opcode]\n")); \
9757 printf ("0x%02x ", OP)
9760 decode_arm_unwind_bytecode (Filedata
* filedata
,
9761 struct arm_unw_aux_info
* aux
,
9763 unsigned int remaining
,
9764 unsigned int more_words
,
9765 uint64_t data_offset
,
9766 Elf_Internal_Shdr
* data_sec
,
9767 struct arm_section
* data_arm_sec
)
9769 struct absaddr addr
;
9772 /* Decode the unwinding instructions. */
9775 unsigned int op
, op2
;
9784 printf (" 0x%02x ", op
);
9786 if ((op
& 0xc0) == 0x00)
9788 int offset
= ((op
& 0x3f) << 2) + 4;
9790 printf (" vsp = vsp + %d", offset
);
9792 else if ((op
& 0xc0) == 0x40)
9794 int offset
= ((op
& 0x3f) << 2) + 4;
9796 printf (" vsp = vsp - %d", offset
);
9798 else if ((op
& 0xf0) == 0x80)
9801 if (op
== 0x80 && op2
== 0)
9802 printf (_("Refuse to unwind"));
9805 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
9810 for (i
= 0; i
< 12; i
++)
9811 if (mask
& (1 << i
))
9817 printf ("r%d", 4 + i
);
9822 else if ((op
& 0xf0) == 0x90)
9824 if (op
== 0x9d || op
== 0x9f)
9825 printf (_(" [Reserved]"));
9827 printf (" vsp = r%d", op
& 0x0f);
9829 else if ((op
& 0xf0) == 0xa0)
9831 int end
= 4 + (op
& 0x07);
9836 for (i
= 4; i
<= end
; i
++)
9852 else if (op
== 0xb0)
9853 printf (_(" finish"));
9854 else if (op
== 0xb1)
9857 if (op2
== 0 || (op2
& 0xf0) != 0)
9858 printf (_("[Spare]"));
9861 unsigned int mask
= op2
& 0x0f;
9866 for (i
= 0; i
< 12; i
++)
9867 if (mask
& (1 << i
))
9878 else if (op
== 0xb2)
9880 unsigned char buf
[9];
9881 unsigned int i
, len
;
9882 unsigned long offset
;
9884 for (i
= 0; i
< sizeof (buf
); i
++)
9887 if ((buf
[i
] & 0x80) == 0)
9890 if (i
== sizeof (buf
))
9892 error (_("corrupt change to vsp\n"));
9897 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
9898 assert (len
== i
+ 1);
9899 offset
= offset
* 4 + 0x204;
9900 printf ("vsp = vsp + %ld", offset
);
9903 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
9905 unsigned int first
, last
;
9912 printf ("pop {D%d", first
);
9914 printf ("-D%d", first
+ last
);
9917 else if (op
== 0xb4)
9918 printf (_(" pop {ra_auth_code}"));
9919 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
9921 unsigned int count
= op
& 0x07;
9925 printf ("-D%d", 8 + count
);
9928 else if (op
>= 0xc0 && op
<= 0xc5)
9930 unsigned int count
= op
& 0x07;
9932 printf (" pop {wR10");
9934 printf ("-wR%d", 10 + count
);
9937 else if (op
== 0xc6)
9939 unsigned int first
, last
;
9944 printf ("pop {wR%d", first
);
9946 printf ("-wR%d", first
+ last
);
9949 else if (op
== 0xc7)
9952 if (op2
== 0 || (op2
& 0xf0) != 0)
9953 printf (_("[Spare]"));
9956 unsigned int mask
= op2
& 0x0f;
9961 for (i
= 0; i
< 4; i
++)
9962 if (mask
& (1 << i
))
9968 printf ("wCGR%d", i
);
9975 printf (_(" [unsupported opcode]"));
9986 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
9987 struct arm_unw_aux_info
* aux
,
9989 unsigned int remaining
,
9990 unsigned int more_words
,
9991 uint64_t data_offset
,
9992 Elf_Internal_Shdr
* data_sec
,
9993 struct arm_section
* data_arm_sec
)
9995 struct absaddr addr
;
9997 /* Decode the unwinding instructions. */
10000 unsigned int op
, op2
;
10003 if (remaining
== 0)
10009 printf (" 0x%02x ", op
);
10011 if ((op
& 0xc0) == 0x00)
10013 int offset
= ((op
& 0x3f) << 3) + 8;
10014 printf (" sp = sp + %d", offset
);
10016 else if ((op
& 0xc0) == 0x80)
10019 if (op
== 0x80 && op2
== 0)
10020 printf (_("Refuse to unwind"));
10023 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
10025 printf ("pop compact {");
10029 decode_tic6x_unwind_regmask (mask
);
10033 else if ((op
& 0xf0) == 0xc0)
10036 unsigned int nregs
;
10041 unsigned int offset
;
10045 /* Scan entire instruction first so that GET_OP output is not
10046 interleaved with disassembly. */
10048 for (i
= 0; nregs
< (op
& 0xf); i
++)
10054 regpos
[nregs
].offset
= i
* 2;
10055 regpos
[nregs
].reg
= reg
;
10062 regpos
[nregs
].offset
= i
* 2 + 1;
10063 regpos
[nregs
].reg
= reg
;
10068 printf (_("pop frame {"));
10071 printf (_("*corrupt* - no registers specified"));
10076 for (i
= i
* 2; i
> 0; i
--)
10078 if (regpos
[reg
].offset
== i
- 1)
10080 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
10087 fputs (name
, stdout
);
10095 else if (op
== 0xd0)
10096 printf (" MOV FP, SP");
10097 else if (op
== 0xd1)
10098 printf (" __c6xabi_pop_rts");
10099 else if (op
== 0xd2)
10101 unsigned char buf
[9];
10102 unsigned int i
, len
;
10103 unsigned long offset
;
10105 for (i
= 0; i
< sizeof (buf
); i
++)
10108 if ((buf
[i
] & 0x80) == 0)
10111 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
10112 if (i
== sizeof (buf
))
10114 warn (_("Corrupt stack pointer adjustment detected\n"));
10118 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
10119 assert (len
== i
+ 1);
10120 offset
= offset
* 8 + 0x408;
10121 printf (_("sp = sp + %ld"), offset
);
10123 else if ((op
& 0xf0) == 0xe0)
10125 if ((op
& 0x0f) == 7)
10126 printf (" RETURN");
10128 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
10132 printf (_(" [unsupported opcode]"));
10141 arm_expand_prel31 (Filedata
* filedata
, uint64_t word
, uint64_t where
)
10145 offset
= word
& 0x7fffffff;
10146 if (offset
& 0x40000000)
10147 offset
|= ~ (uint64_t) 0x7fffffff;
10149 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
10152 return offset
+ where
;
10156 decode_arm_unwind (Filedata
* filedata
,
10157 struct arm_unw_aux_info
* aux
,
10159 unsigned int remaining
,
10160 uint64_t data_offset
,
10161 Elf_Internal_Shdr
* data_sec
,
10162 struct arm_section
* data_arm_sec
)
10165 unsigned int more_words
= 0;
10166 struct absaddr addr
;
10167 uint64_t sym_name
= (uint64_t) -1;
10170 if (remaining
== 0)
10172 /* Fetch the first word.
10173 Note - when decoding an object file the address extracted
10174 here will always be 0. So we also pass in the sym_name
10175 parameter so that we can find the symbol associated with
10176 the personality routine. */
10177 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
10178 & word
, & addr
, & sym_name
))
10185 addr
.section
= SHN_UNDEF
;
10189 if ((word
& 0x80000000) == 0)
10191 /* Expand prel31 for personality routine. */
10193 const char *procname
;
10195 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
10196 printf (_(" Personality routine: "));
10198 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
10199 && sym_name
!= (uint64_t) -1 && sym_name
< aux
->strtab_size
)
10201 procname
= aux
->strtab
+ sym_name
;
10202 print_vma (fn
, PREFIX_HEX
);
10205 fputs (" <", stdout
);
10206 fputs (procname
, stdout
);
10207 fputc ('>', stdout
);
10211 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
10212 fputc ('\n', stdout
);
10214 /* The GCC personality routines use the standard compact
10215 encoding, starting with one byte giving the number of
10217 if (procname
!= NULL
10218 && (startswith (procname
, "__gcc_personality_v0")
10219 || startswith (procname
, "__gxx_personality_v0")
10220 || startswith (procname
, "__gcj_personality_v0")
10221 || startswith (procname
, "__gnu_objc_personality_v0")))
10228 printf (_(" [Truncated data]\n"));
10231 more_words
= word
>> 24;
10241 /* ARM EHABI Section 6.3:
10243 An exception-handling table entry for the compact model looks like:
10245 31 30-28 27-24 23-0
10246 -- ----- ----- ----
10247 1 0 index Data for personalityRoutine[index] */
10249 if (filedata
->file_header
.e_machine
== EM_ARM
10250 && (word
& 0x70000000))
10252 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
10256 per_index
= (word
>> 24) & 0x7f;
10257 printf (_(" Compact model index: %d\n"), per_index
);
10258 if (per_index
== 0)
10264 else if (per_index
< 3)
10266 more_words
= (word
>> 16) & 0xff;
10272 switch (filedata
->file_header
.e_machine
)
10277 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
10278 data_offset
, data_sec
, data_arm_sec
))
10283 warn (_("Unknown ARM compact model index encountered\n"));
10284 printf (_(" [reserved]\n"));
10292 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
10293 data_offset
, data_sec
, data_arm_sec
))
10296 else if (per_index
< 5)
10298 if (((word
>> 17) & 0x7f) == 0x7f)
10299 printf (_(" Restore stack from frame pointer\n"));
10301 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
10302 printf (_(" Registers restored: "));
10303 if (per_index
== 4)
10304 printf (" (compact) ");
10305 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
10307 printf (_(" Return register: %s\n"),
10308 tic6x_unwind_regnames
[word
& 0xf]);
10311 printf (_(" [reserved (%d)]\n"), per_index
);
10315 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
10316 filedata
->file_header
.e_machine
);
10320 /* Decode the descriptors. Not implemented. */
10326 dump_arm_unwind (Filedata
* filedata
,
10327 struct arm_unw_aux_info
* aux
,
10328 Elf_Internal_Shdr
* exidx_sec
)
10330 struct arm_section exidx_arm_sec
, extab_arm_sec
;
10331 unsigned int i
, exidx_len
;
10332 unsigned long j
, nfuns
;
10335 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
10336 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
10337 exidx_len
= exidx_sec
->sh_size
/ 8;
10339 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
10340 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
10341 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
10342 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
10343 aux
->nfuns
= nfuns
;
10344 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
10346 for (i
= 0; i
< exidx_len
; i
++)
10348 unsigned int exidx_fn
, exidx_entry
;
10349 struct absaddr fn_addr
, entry_addr
;
10352 fputc ('\n', stdout
);
10354 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
10355 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
10356 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
10357 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
10359 free (aux
->funtab
);
10360 arm_free_section (& exidx_arm_sec
);
10361 arm_free_section (& extab_arm_sec
);
10365 /* ARM EHABI, Section 5:
10366 An index table entry consists of 2 words.
10367 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
10368 if (exidx_fn
& 0x80000000)
10370 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
10374 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
10376 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
10377 fputs (": ", stdout
);
10379 if (exidx_entry
== 1)
10381 print_vma (exidx_entry
, PREFIX_HEX
);
10382 fputs (" [cantunwind]\n", stdout
);
10384 else if (exidx_entry
& 0x80000000)
10386 print_vma (exidx_entry
, PREFIX_HEX
);
10387 fputc ('\n', stdout
);
10388 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
10392 uint64_t table
, table_offset
= 0;
10393 Elf_Internal_Shdr
*table_sec
;
10395 fputs ("@", stdout
);
10396 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
10397 print_vma (table
, PREFIX_HEX
);
10400 /* Locate the matching .ARM.extab. */
10401 if (entry_addr
.section
!= SHN_UNDEF
10402 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
10404 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
10405 table_offset
= entry_addr
.offset
;
10407 if (table_offset
> table_sec
->sh_size
)
10409 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
10410 (unsigned long) table_offset
,
10411 printable_section_name (filedata
, table_sec
));
10418 table_sec
= find_section_by_address (filedata
, table
);
10419 if (table_sec
!= NULL
)
10420 table_offset
= table
- table_sec
->sh_addr
;
10423 if (table_sec
== NULL
)
10425 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
10426 (unsigned long) table
);
10431 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
10439 free (aux
->funtab
);
10440 arm_free_section (&exidx_arm_sec
);
10441 arm_free_section (&extab_arm_sec
);
10446 /* Used for both ARM and C6X unwinding tables. */
10449 arm_process_unwind (Filedata
* filedata
)
10451 struct arm_unw_aux_info aux
;
10452 Elf_Internal_Shdr
*unwsec
= NULL
;
10453 Elf_Internal_Shdr
*sec
;
10455 unsigned int sec_type
;
10458 switch (filedata
->file_header
.e_machine
)
10461 sec_type
= SHT_ARM_EXIDX
;
10465 sec_type
= SHT_C6000_UNWIND
;
10469 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
10470 filedata
->file_header
.e_machine
);
10474 if (filedata
->string_table
== NULL
)
10477 memset (& aux
, 0, sizeof (aux
));
10478 aux
.filedata
= filedata
;
10480 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
10482 if (sec
->sh_type
== SHT_SYMTAB
)
10486 error (_("Multiple symbol tables encountered\n"));
10492 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
10493 &aux
.strtab
, &aux
.strtab_size
))
10496 else if (sec
->sh_type
== sec_type
)
10500 if (unwsec
== NULL
)
10501 printf (_("\nThere are no unwind sections in this file.\n"));
10503 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
10505 if (sec
->sh_type
== sec_type
)
10507 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
10508 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
10509 "contains %lu entry:\n",
10510 "\nUnwind section '%s' at offset 0x%lx "
10511 "contains %lu entries:\n",
10513 printable_section_name (filedata
, sec
),
10514 (unsigned long) sec
->sh_offset
,
10517 if (! dump_arm_unwind (filedata
, &aux
, sec
))
10523 free ((char *) aux
.strtab
);
10529 no_processor_specific_unwind (Filedata
* filedata ATTRIBUTE_UNUSED
)
10531 printf (_("No processor specific unwind information to decode\n"));
10536 process_unwind (Filedata
* filedata
)
10538 struct unwind_handler
10540 unsigned int machtype
;
10541 bool (* handler
)(Filedata
*);
10544 { EM_ARM
, arm_process_unwind
},
10545 { EM_IA_64
, ia64_process_unwind
},
10546 { EM_PARISC
, hppa_process_unwind
},
10547 { EM_TI_C6000
, arm_process_unwind
},
10548 { EM_386
, no_processor_specific_unwind
},
10549 { EM_X86_64
, no_processor_specific_unwind
},
10557 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
10558 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
10559 return handlers
[i
].handler (filedata
);
10561 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
10562 get_machine_name (filedata
->file_header
.e_machine
));
10567 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
10569 switch (entry
->d_tag
)
10571 case DT_AARCH64_BTI_PLT
:
10572 case DT_AARCH64_PAC_PLT
:
10575 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10582 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
10584 switch (entry
->d_tag
)
10586 case DT_MIPS_FLAGS
:
10587 if (entry
->d_un
.d_val
== 0)
10588 printf (_("NONE"));
10591 static const char * opts
[] =
10593 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
10594 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
10595 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
10596 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
10602 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
10603 if (entry
->d_un
.d_val
& (1 << cnt
))
10605 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
10611 case DT_MIPS_IVERSION
:
10612 if (valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
10613 printf (_("Interface Version: %s"),
10614 get_dynamic_name (filedata
, entry
->d_un
.d_val
));
10616 printf (_("Interface Version: <corrupt: %" PRIx64
">"),
10617 entry
->d_un
.d_ptr
);
10620 case DT_MIPS_TIME_STAMP
:
10624 time_t atime
= entry
->d_un
.d_val
;
10626 tmp
= gmtime (&atime
);
10627 /* PR 17531: file: 6accc532. */
10629 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
10631 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
10632 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10633 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10634 printf (_("Time Stamp: %s"), timebuf
);
10638 case DT_MIPS_RLD_VERSION
:
10639 case DT_MIPS_LOCAL_GOTNO
:
10640 case DT_MIPS_CONFLICTNO
:
10641 case DT_MIPS_LIBLISTNO
:
10642 case DT_MIPS_SYMTABNO
:
10643 case DT_MIPS_UNREFEXTNO
:
10644 case DT_MIPS_HIPAGENO
:
10645 case DT_MIPS_DELTA_CLASS_NO
:
10646 case DT_MIPS_DELTA_INSTANCE_NO
:
10647 case DT_MIPS_DELTA_RELOC_NO
:
10648 case DT_MIPS_DELTA_SYM_NO
:
10649 case DT_MIPS_DELTA_CLASSSYM_NO
:
10650 case DT_MIPS_COMPACT_SIZE
:
10651 print_vma (entry
->d_un
.d_val
, DEC
);
10654 case DT_MIPS_XHASH
:
10655 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10656 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10657 /* Falls through. */
10660 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10666 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
10668 switch (entry
->d_tag
)
10670 case DT_HP_DLD_FLAGS
:
10679 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
10680 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
10681 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
10682 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
10683 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
10684 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
10685 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
10686 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
10687 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
10688 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
10689 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
10690 { DT_HP_GST
, "HP_GST" },
10691 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
10692 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
10693 { DT_HP_NODELETE
, "HP_NODELETE" },
10694 { DT_HP_GROUP
, "HP_GROUP" },
10695 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
10699 uint64_t val
= entry
->d_un
.d_val
;
10701 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
10702 if (val
& flags
[cnt
].bit
)
10706 fputs (flags
[cnt
].str
, stdout
);
10708 val
^= flags
[cnt
].bit
;
10711 if (val
!= 0 || first
)
10715 print_vma (val
, HEX
);
10721 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10727 /* VMS vs Unix time offset and factor. */
10729 #define VMS_EPOCH_OFFSET 35067168000000000LL
10730 #define VMS_GRANULARITY_FACTOR 10000000
10732 #define INT64_MIN (-9223372036854775807LL - 1)
10735 /* Display a VMS time in a human readable format. */
10738 print_vms_time (int64_t vmstime
)
10740 struct tm
*tm
= NULL
;
10743 if (vmstime
>= INT64_MIN
+ VMS_EPOCH_OFFSET
)
10745 vmstime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
10747 if (unxtime
== vmstime
)
10748 tm
= gmtime (&unxtime
);
10751 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
10752 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
10753 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
10757 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
10759 switch (entry
->d_tag
)
10761 case DT_IA_64_PLT_RESERVE
:
10762 /* First 3 slots reserved. */
10763 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10765 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
10768 case DT_IA_64_VMS_LINKTIME
:
10769 print_vms_time (entry
->d_un
.d_val
);
10772 case DT_IA_64_VMS_LNKFLAGS
:
10773 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10774 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
10775 printf (" CALL_DEBUG");
10776 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
10777 printf (" NOP0BUFS");
10778 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
10779 printf (" P0IMAGE");
10780 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
10781 printf (" MKTHREADS");
10782 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
10783 printf (" UPCALLS");
10784 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
10785 printf (" IMGSTA");
10786 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
10787 printf (" INITIALIZE");
10788 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
10790 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
10791 printf (" EXE_INIT");
10792 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
10793 printf (" TBK_IN_IMG");
10794 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
10795 printf (" DBG_IN_IMG");
10796 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
10797 printf (" TBK_IN_DSF");
10798 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
10799 printf (" DBG_IN_DSF");
10800 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
10801 printf (" SIGNATURES");
10802 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
10803 printf (" REL_SEG_OFF");
10807 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10814 get_32bit_dynamic_section (Filedata
* filedata
)
10816 Elf32_External_Dyn
* edyn
;
10817 Elf32_External_Dyn
* ext
;
10818 Elf_Internal_Dyn
* entry
;
10820 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
10821 filedata
->dynamic_addr
, 1,
10822 filedata
->dynamic_size
,
10823 _("dynamic section"));
10827 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
10828 might not have the luxury of section headers. Look for the DT_NULL
10829 terminator to determine the number of entries. */
10830 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
10831 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
10834 filedata
->dynamic_nent
++;
10835 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
10839 filedata
->dynamic_section
10840 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
10841 if (filedata
->dynamic_section
== NULL
)
10843 error (_("Out of memory allocating space for %lu dynamic entries\n"),
10844 (unsigned long) filedata
->dynamic_nent
);
10849 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10850 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10853 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10854 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10863 get_64bit_dynamic_section (Filedata
* filedata
)
10865 Elf64_External_Dyn
* edyn
;
10866 Elf64_External_Dyn
* ext
;
10867 Elf_Internal_Dyn
* entry
;
10869 /* Read in the data. */
10870 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
10871 filedata
->dynamic_addr
, 1,
10872 filedata
->dynamic_size
,
10873 _("dynamic section"));
10877 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
10878 might not have the luxury of section headers. Look for the DT_NULL
10879 terminator to determine the number of entries. */
10880 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
10881 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
10882 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
10885 filedata
->dynamic_nent
++;
10886 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
10890 filedata
->dynamic_section
10891 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
10892 if (filedata
->dynamic_section
== NULL
)
10894 error (_("Out of memory allocating space for %lu dynamic entries\n"),
10895 (unsigned long) filedata
->dynamic_nent
);
10900 /* Convert from external to internal formats. */
10901 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10902 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10905 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10906 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10915 get_dynamic_section (Filedata
*filedata
)
10917 if (filedata
->dynamic_section
)
10921 return get_32bit_dynamic_section (filedata
);
10923 return get_64bit_dynamic_section (filedata
);
10927 print_dynamic_flags (uint64_t flags
)
10935 flag
= flags
& - flags
;
10941 putc (' ', stdout
);
10945 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
10946 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
10947 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
10948 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
10949 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
10950 default: fputs (_("unknown"), stdout
); break;
10957 get_dynamic_data (Filedata
* filedata
, uint64_t number
, unsigned int ent_size
)
10959 unsigned char * e_data
;
10962 /* If size_t is smaller than uint64_t, eg because you are building
10963 on a 32-bit host, then make sure that when number is cast to
10964 size_t no information is lost. */
10965 if ((size_t) number
!= number
10966 || ent_size
* number
/ ent_size
!= number
)
10968 error (_("Size overflow prevents reading %" PRIu64
10969 " elements of size %u\n"),
10974 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
10975 attempting to allocate memory when the read is bound to fail. */
10976 if (ent_size
* number
> filedata
->file_size
)
10978 error (_("Invalid number of dynamic entries: %" PRIu64
"\n"),
10983 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10984 if (e_data
== NULL
)
10986 error (_("Out of memory reading %" PRIu64
" dynamic entries\n"),
10991 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
10993 error (_("Unable to read in %" PRIu64
" bytes of dynamic data\n"),
10994 number
* ent_size
);
10999 i_data
= (uint64_t *) cmalloc ((size_t) number
, sizeof (*i_data
));
11000 if (i_data
== NULL
)
11002 error (_("Out of memory allocating space for %" PRIu64
" dynamic entries\n"),
11009 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11016 static unsigned long
11017 get_num_dynamic_syms (Filedata
* filedata
)
11019 unsigned long num_of_syms
= 0;
11021 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
11022 return num_of_syms
;
11024 if (filedata
->dynamic_info
[DT_HASH
])
11026 unsigned char nb
[8];
11027 unsigned char nc
[8];
11028 unsigned int hash_ent_size
= 4;
11030 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11031 || filedata
->file_header
.e_machine
== EM_S390
11032 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11033 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11036 if (fseek (filedata
->handle
,
11037 (filedata
->archive_file_offset
11038 + offset_from_vma (filedata
, filedata
->dynamic_info
[DT_HASH
],
11039 sizeof nb
+ sizeof nc
)),
11042 error (_("Unable to seek to start of dynamic information\n"));
11046 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11048 error (_("Failed to read in number of buckets\n"));
11052 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11054 error (_("Failed to read in number of chains\n"));
11058 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
11059 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
11061 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
11063 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
11065 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
11068 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
11069 num_of_syms
= filedata
->nchains
;
11072 if (num_of_syms
== 0)
11074 free (filedata
->buckets
);
11075 filedata
->buckets
= NULL
;
11076 free (filedata
->chains
);
11077 filedata
->chains
= NULL
;
11078 filedata
->nbuckets
= 0;
11082 if (filedata
->dynamic_info_DT_GNU_HASH
)
11084 unsigned char nb
[16];
11085 uint64_t i
, maxchain
= 0xffffffff, bitmaskwords
;
11086 uint64_t buckets_vma
;
11089 if (fseek (filedata
->handle
,
11090 (filedata
->archive_file_offset
11091 + offset_from_vma (filedata
,
11092 filedata
->dynamic_info_DT_GNU_HASH
,
11096 error (_("Unable to seek to start of dynamic information\n"));
11100 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11102 error (_("Failed to read in number of buckets\n"));
11106 filedata
->ngnubuckets
= byte_get (nb
, 4);
11107 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
11108 bitmaskwords
= byte_get (nb
+ 8, 4);
11109 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
11111 buckets_vma
+= bitmaskwords
* 4;
11113 buckets_vma
+= bitmaskwords
* 8;
11115 if (fseek (filedata
->handle
,
11116 (filedata
->archive_file_offset
11117 + offset_from_vma (filedata
, buckets_vma
, 4)),
11120 error (_("Unable to seek to start of dynamic information\n"));
11124 filedata
->gnubuckets
11125 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
11127 if (filedata
->gnubuckets
== NULL
)
11130 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
11131 if (filedata
->gnubuckets
[i
] != 0)
11133 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
11136 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
11137 maxchain
= filedata
->gnubuckets
[i
];
11140 if (maxchain
== 0xffffffff)
11143 maxchain
-= filedata
->gnusymidx
;
11145 if (fseek (filedata
->handle
,
11146 (filedata
->archive_file_offset
11147 + offset_from_vma (filedata
,
11148 buckets_vma
+ 4 * (filedata
->ngnubuckets
11153 error (_("Unable to seek to start of dynamic information\n"));
11159 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11161 error (_("Failed to determine last chain length\n"));
11165 if (maxchain
+ 1 == 0)
11170 while ((byte_get (nb
, 4) & 1) == 0);
11172 if (fseek (filedata
->handle
,
11173 (filedata
->archive_file_offset
11174 + offset_from_vma (filedata
, (buckets_vma
11175 + 4 * filedata
->ngnubuckets
),
11179 error (_("Unable to seek to start of dynamic information\n"));
11183 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11184 filedata
->ngnuchains
= maxchain
;
11186 if (filedata
->gnuchains
== NULL
)
11189 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
11191 if (fseek (filedata
->handle
,
11192 (filedata
->archive_file_offset
11193 + offset_from_vma (filedata
, (buckets_vma
11194 + 4 * (filedata
->ngnubuckets
11198 error (_("Unable to seek to start of dynamic information\n"));
11202 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
11203 if (filedata
->mipsxlat
== NULL
)
11207 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
11208 if (filedata
->gnubuckets
[hn
] != 0)
11210 uint64_t si
= filedata
->gnubuckets
[hn
];
11211 uint64_t off
= si
- filedata
->gnusymidx
;
11215 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
11217 if (off
< filedata
->ngnuchains
11218 && filedata
->mipsxlat
[off
] >= num_of_syms
)
11219 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
11223 if (si
>= num_of_syms
)
11224 num_of_syms
= si
+ 1;
11228 while (off
< filedata
->ngnuchains
11229 && (filedata
->gnuchains
[off
++] & 1) == 0);
11232 if (num_of_syms
== 0)
11235 free (filedata
->mipsxlat
);
11236 filedata
->mipsxlat
= NULL
;
11237 free (filedata
->gnuchains
);
11238 filedata
->gnuchains
= NULL
;
11239 free (filedata
->gnubuckets
);
11240 filedata
->gnubuckets
= NULL
;
11241 filedata
->ngnubuckets
= 0;
11242 filedata
->ngnuchains
= 0;
11246 return num_of_syms
;
11249 /* Parse and display the contents of the dynamic section. */
11252 process_dynamic_section (Filedata
* filedata
)
11254 Elf_Internal_Dyn
* entry
;
11256 if (filedata
->dynamic_size
<= 1)
11260 if (filedata
->is_separate
)
11261 printf (_("\nThere is no dynamic section in linked file '%s'.\n"),
11262 filedata
->file_name
);
11264 printf (_("\nThere is no dynamic section in this file.\n"));
11270 if (!get_dynamic_section (filedata
))
11273 /* Find the appropriate symbol table. */
11274 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
11276 unsigned long num_of_syms
;
11278 for (entry
= filedata
->dynamic_section
;
11279 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11281 if (entry
->d_tag
== DT_SYMTAB
)
11282 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
11283 else if (entry
->d_tag
== DT_SYMENT
)
11284 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
11285 else if (entry
->d_tag
== DT_HASH
)
11286 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
11287 else if (entry
->d_tag
== DT_GNU_HASH
)
11288 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11289 else if ((filedata
->file_header
.e_machine
== EM_MIPS
11290 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
11291 && entry
->d_tag
== DT_MIPS_XHASH
)
11293 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
11294 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11297 num_of_syms
= get_num_dynamic_syms (filedata
);
11299 if (num_of_syms
!= 0
11300 && filedata
->dynamic_symbols
== NULL
11301 && filedata
->dynamic_info
[DT_SYMTAB
]
11302 && filedata
->dynamic_info
[DT_SYMENT
])
11304 Elf_Internal_Phdr
*seg
;
11305 uint64_t vma
= filedata
->dynamic_info
[DT_SYMTAB
];
11307 if (! get_program_headers (filedata
))
11309 error (_("Cannot interpret virtual addresses "
11310 "without program headers.\n"));
11314 for (seg
= filedata
->program_headers
;
11315 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
11318 if (seg
->p_type
!= PT_LOAD
)
11321 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
11323 /* See PR 21379 for a reproducer. */
11324 error (_("Invalid PT_LOAD entry\n"));
11328 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
11329 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
11331 /* Since we do not know how big the symbol table is,
11332 we default to reading in up to the end of PT_LOAD
11333 segment and processing that. This is overkill, I
11334 know, but it should work. */
11335 Elf_Internal_Shdr section
;
11336 section
.sh_offset
= (vma
- seg
->p_vaddr
11338 section
.sh_size
= (num_of_syms
11339 * filedata
->dynamic_info
[DT_SYMENT
]);
11340 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
11343 && filedata
->dynamic_symtab_section
!= NULL
11344 && ((filedata
->dynamic_symtab_section
->sh_offset
11345 != section
.sh_offset
)
11346 || (filedata
->dynamic_symtab_section
->sh_size
11347 != section
.sh_size
)
11348 || (filedata
->dynamic_symtab_section
->sh_entsize
11349 != section
.sh_entsize
)))
11351 the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
11353 section
.sh_name
= filedata
->string_table_length
;
11354 filedata
->dynamic_symbols
11355 = get_elf_symbols (filedata
, §ion
,
11356 &filedata
->num_dynamic_syms
);
11357 if (filedata
->dynamic_symbols
== NULL
11358 || filedata
->num_dynamic_syms
!= num_of_syms
)
11360 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
11369 /* Similarly find a string table. */
11370 if (filedata
->dynamic_strings
== NULL
)
11371 for (entry
= filedata
->dynamic_section
;
11372 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11375 if (entry
->d_tag
== DT_STRTAB
)
11376 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
11378 if (entry
->d_tag
== DT_STRSZ
)
11379 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
11381 if (filedata
->dynamic_info
[DT_STRTAB
]
11382 && filedata
->dynamic_info
[DT_STRSZ
])
11384 unsigned long offset
;
11385 uint64_t str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
11387 offset
= offset_from_vma (filedata
,
11388 filedata
->dynamic_info
[DT_STRTAB
],
11391 && filedata
->dynamic_strtab_section
11392 && ((filedata
->dynamic_strtab_section
->sh_offset
11393 != (file_ptr
) offset
)
11394 || (filedata
->dynamic_strtab_section
->sh_size
11397 the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
11399 filedata
->dynamic_strings
11400 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
11401 _("dynamic string table"));
11402 if (filedata
->dynamic_strings
== NULL
)
11404 error (_("Corrupt DT_STRTAB dynamic entry\n"));
11408 filedata
->dynamic_strings_length
= str_tab_len
;
11413 /* And find the syminfo section if available. */
11414 if (filedata
->dynamic_syminfo
== NULL
)
11416 unsigned long syminsz
= 0;
11418 for (entry
= filedata
->dynamic_section
;
11419 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11422 if (entry
->d_tag
== DT_SYMINENT
)
11424 /* Note: these braces are necessary to avoid a syntax
11425 error from the SunOS4 C compiler. */
11426 /* PR binutils/17531: A corrupt file can trigger this test.
11427 So do not use an assert, instead generate an error message. */
11428 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
11429 error (_("Bad value (%d) for SYMINENT entry\n"),
11430 (int) entry
->d_un
.d_val
);
11432 else if (entry
->d_tag
== DT_SYMINSZ
)
11433 syminsz
= entry
->d_un
.d_val
;
11434 else if (entry
->d_tag
== DT_SYMINFO
)
11435 filedata
->dynamic_syminfo_offset
11436 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
11439 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
11441 Elf_External_Syminfo
* extsyminfo
;
11442 Elf_External_Syminfo
* extsym
;
11443 Elf_Internal_Syminfo
* syminfo
;
11445 /* There is a syminfo section. Read the data. */
11446 extsyminfo
= (Elf_External_Syminfo
*)
11447 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
11448 1, syminsz
, _("symbol information"));
11452 if (filedata
->dynamic_syminfo
!= NULL
)
11454 error (_("Multiple dynamic symbol information sections found\n"));
11455 free (filedata
->dynamic_syminfo
);
11457 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
11458 if (filedata
->dynamic_syminfo
== NULL
)
11460 error (_("Out of memory allocating %lu bytes "
11461 "for dynamic symbol info\n"),
11462 (unsigned long) syminsz
);
11466 filedata
->dynamic_syminfo_nent
11467 = syminsz
/ sizeof (Elf_External_Syminfo
);
11468 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
11469 syminfo
< (filedata
->dynamic_syminfo
11470 + filedata
->dynamic_syminfo_nent
);
11471 ++syminfo
, ++extsym
)
11473 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
11474 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
11481 if (do_dynamic
&& filedata
->dynamic_addr
)
11483 if (filedata
->is_separate
)
11484 printf (ngettext ("\nIn linked file '%s' the dynamic section at offset 0x%lx contains %lu entry:\n",
11485 "\nIn linked file '%s' the dynamic section at offset 0x%lx contains %lu entries:\n",
11486 (unsigned long) filedata
->dynamic_nent
),
11487 filedata
->file_name
,
11488 filedata
->dynamic_addr
,
11489 (unsigned long) filedata
->dynamic_nent
);
11491 printf (ngettext ("\nDynamic section at offset 0x%lx contains %lu entry:\n",
11492 "\nDynamic section at offset 0x%lx contains %lu entries:\n",
11493 (unsigned long) filedata
->dynamic_nent
),
11494 filedata
->dynamic_addr
,
11495 (unsigned long) filedata
->dynamic_nent
);
11498 printf (_(" Tag Type Name/Value\n"));
11500 for (entry
= filedata
->dynamic_section
;
11501 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11506 const char * dtype
;
11509 print_vma (entry
->d_tag
, FULL_HEX
);
11510 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
11511 printf (" (%s)%*s", dtype
,
11512 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
11515 switch (entry
->d_tag
)
11519 print_dynamic_flags (entry
->d_un
.d_val
);
11529 switch (entry
->d_tag
)
11532 printf (_("Auxiliary library"));
11536 printf (_("Filter library"));
11540 printf (_("Configuration file"));
11544 printf (_("Dependency audit library"));
11548 printf (_("Audit library"));
11552 if (valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
11553 printf (": [%s]\n",
11554 get_dynamic_name (filedata
, entry
->d_un
.d_val
));
11558 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11567 printf (_("Flags:"));
11569 if (entry
->d_un
.d_val
== 0)
11570 printf (_(" None\n"));
11573 unsigned long int val
= entry
->d_un
.d_val
;
11575 if (val
& DTF_1_PARINIT
)
11577 printf (" PARINIT");
11578 val
^= DTF_1_PARINIT
;
11580 if (val
& DTF_1_CONFEXP
)
11582 printf (" CONFEXP");
11583 val
^= DTF_1_CONFEXP
;
11586 printf (" %lx", val
);
11595 printf (_("Flags:"));
11597 if (entry
->d_un
.d_val
== 0)
11598 printf (_(" None\n"));
11601 unsigned long int val
= entry
->d_un
.d_val
;
11603 if (val
& DF_P1_LAZYLOAD
)
11605 printf (" LAZYLOAD");
11606 val
^= DF_P1_LAZYLOAD
;
11608 if (val
& DF_P1_GROUPPERM
)
11610 printf (" GROUPPERM");
11611 val
^= DF_P1_GROUPPERM
;
11614 printf (" %lx", val
);
11623 printf (_("Flags:"));
11624 if (entry
->d_un
.d_val
== 0)
11625 printf (_(" None\n"));
11628 unsigned long int val
= entry
->d_un
.d_val
;
11630 if (val
& DF_1_NOW
)
11635 if (val
& DF_1_GLOBAL
)
11637 printf (" GLOBAL");
11638 val
^= DF_1_GLOBAL
;
11640 if (val
& DF_1_GROUP
)
11645 if (val
& DF_1_NODELETE
)
11647 printf (" NODELETE");
11648 val
^= DF_1_NODELETE
;
11650 if (val
& DF_1_LOADFLTR
)
11652 printf (" LOADFLTR");
11653 val
^= DF_1_LOADFLTR
;
11655 if (val
& DF_1_INITFIRST
)
11657 printf (" INITFIRST");
11658 val
^= DF_1_INITFIRST
;
11660 if (val
& DF_1_NOOPEN
)
11662 printf (" NOOPEN");
11663 val
^= DF_1_NOOPEN
;
11665 if (val
& DF_1_ORIGIN
)
11667 printf (" ORIGIN");
11668 val
^= DF_1_ORIGIN
;
11670 if (val
& DF_1_DIRECT
)
11672 printf (" DIRECT");
11673 val
^= DF_1_DIRECT
;
11675 if (val
& DF_1_TRANS
)
11680 if (val
& DF_1_INTERPOSE
)
11682 printf (" INTERPOSE");
11683 val
^= DF_1_INTERPOSE
;
11685 if (val
& DF_1_NODEFLIB
)
11687 printf (" NODEFLIB");
11688 val
^= DF_1_NODEFLIB
;
11690 if (val
& DF_1_NODUMP
)
11692 printf (" NODUMP");
11693 val
^= DF_1_NODUMP
;
11695 if (val
& DF_1_CONFALT
)
11697 printf (" CONFALT");
11698 val
^= DF_1_CONFALT
;
11700 if (val
& DF_1_ENDFILTEE
)
11702 printf (" ENDFILTEE");
11703 val
^= DF_1_ENDFILTEE
;
11705 if (val
& DF_1_DISPRELDNE
)
11707 printf (" DISPRELDNE");
11708 val
^= DF_1_DISPRELDNE
;
11710 if (val
& DF_1_DISPRELPND
)
11712 printf (" DISPRELPND");
11713 val
^= DF_1_DISPRELPND
;
11715 if (val
& DF_1_NODIRECT
)
11717 printf (" NODIRECT");
11718 val
^= DF_1_NODIRECT
;
11720 if (val
& DF_1_IGNMULDEF
)
11722 printf (" IGNMULDEF");
11723 val
^= DF_1_IGNMULDEF
;
11725 if (val
& DF_1_NOKSYMS
)
11727 printf (" NOKSYMS");
11728 val
^= DF_1_NOKSYMS
;
11730 if (val
& DF_1_NOHDR
)
11735 if (val
& DF_1_EDITED
)
11737 printf (" EDITED");
11738 val
^= DF_1_EDITED
;
11740 if (val
& DF_1_NORELOC
)
11742 printf (" NORELOC");
11743 val
^= DF_1_NORELOC
;
11745 if (val
& DF_1_SYMINTPOSE
)
11747 printf (" SYMINTPOSE");
11748 val
^= DF_1_SYMINTPOSE
;
11750 if (val
& DF_1_GLOBAUDIT
)
11752 printf (" GLOBAUDIT");
11753 val
^= DF_1_GLOBAUDIT
;
11755 if (val
& DF_1_SINGLETON
)
11757 printf (" SINGLETON");
11758 val
^= DF_1_SINGLETON
;
11760 if (val
& DF_1_STUB
)
11765 if (val
& DF_1_PIE
)
11770 if (val
& DF_1_KMOD
)
11775 if (val
& DF_1_WEAKFILTER
)
11777 printf (" WEAKFILTER");
11778 val
^= DF_1_WEAKFILTER
;
11780 if (val
& DF_1_NOCOMMON
)
11782 printf (" NOCOMMON");
11783 val
^= DF_1_NOCOMMON
;
11786 printf (" %lx", val
);
11793 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11795 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
11816 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11822 if (valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
11823 name
= get_dynamic_name (filedata
, entry
->d_un
.d_val
);
11829 switch (entry
->d_tag
)
11832 printf (_("Shared library: [%s]"), name
);
11834 if (filedata
->program_interpreter
11835 && streq (name
, filedata
->program_interpreter
))
11836 printf (_(" program interpreter"));
11840 printf (_("Library soname: [%s]"), name
);
11844 printf (_("Library rpath: [%s]"), name
);
11848 printf (_("Library runpath: [%s]"), name
);
11852 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11857 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11872 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11873 /* Fall through. */
11877 case DT_PREINIT_ARRAYSZ
:
11878 case DT_INIT_ARRAYSZ
:
11879 case DT_FINI_ARRAYSZ
:
11880 case DT_GNU_CONFLICTSZ
:
11881 case DT_GNU_LIBLISTSZ
:
11884 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11885 printf (_(" (bytes)\n"));
11890 case DT_VERNEEDNUM
:
11895 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11904 case DT_INIT_ARRAY
:
11905 case DT_FINI_ARRAY
:
11908 if (entry
->d_tag
== DT_USED
11909 && valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
11912 = get_dynamic_name (filedata
, entry
->d_un
.d_val
);
11916 printf (_("Not needed object: [%s]\n"), name
);
11921 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11927 /* The value of this entry is ignored. */
11932 case DT_GNU_PRELINKED
:
11936 time_t atime
= entry
->d_un
.d_val
;
11938 tmp
= gmtime (&atime
);
11939 /* PR 17533 file: 041-1244816-0.004. */
11941 printf (_("<corrupt time val: %lx"),
11942 (unsigned long) atime
);
11944 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
11945 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11946 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11952 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11955 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11960 case DT_GNU_FLAGS_1
:
11963 printf (_("Flags:"));
11964 if (entry
->d_un
.d_val
== 0)
11965 printf (_(" None\n"));
11968 unsigned long int val
= entry
->d_un
.d_val
;
11970 if (val
& DF_GNU_1_UNIQUE
)
11972 printf (" UNIQUE");
11973 val
^= DF_GNU_1_UNIQUE
;
11976 printf (" %lx", val
);
11983 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
11984 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
11985 = entry
->d_un
.d_val
;
11989 switch (filedata
->file_header
.e_machine
)
11992 dynamic_section_aarch64_val (entry
);
11995 case EM_MIPS_RS3_LE
:
11996 dynamic_section_mips_val (filedata
, entry
);
11999 dynamic_section_parisc_val (entry
);
12002 dynamic_section_ia64_val (entry
);
12005 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12017 get_ver_flags (unsigned int flags
)
12019 static char buff
[128];
12026 if (flags
& VER_FLG_BASE
)
12027 strcat (buff
, "BASE");
12029 if (flags
& VER_FLG_WEAK
)
12031 if (flags
& VER_FLG_BASE
)
12032 strcat (buff
, " | ");
12034 strcat (buff
, "WEAK");
12037 if (flags
& VER_FLG_INFO
)
12039 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
12040 strcat (buff
, " | ");
12042 strcat (buff
, "INFO");
12045 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
12047 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
12048 strcat (buff
, " | ");
12050 strcat (buff
, _("<unknown>"));
12056 /* Display the contents of the version sections. */
12059 process_version_sections (Filedata
* filedata
)
12061 Elf_Internal_Shdr
* section
;
12063 bool found
= false;
12068 for (i
= 0, section
= filedata
->section_headers
;
12069 i
< filedata
->file_header
.e_shnum
;
12072 switch (section
->sh_type
)
12074 case SHT_GNU_verdef
:
12076 Elf_External_Verdef
* edefs
;
12083 if (filedata
->is_separate
)
12084 printf (ngettext ("\nIn linked file '%s' the version definition section '%s' contains %u entry:\n",
12085 "\nIn linked file '%s' the version definition section '%s' contains %u entries:\n",
12087 filedata
->file_name
,
12088 printable_section_name (filedata
, section
),
12091 printf (ngettext ("\nVersion definition section '%s' "
12092 "contains %u entry:\n",
12093 "\nVersion definition section '%s' "
12094 "contains %u entries:\n",
12096 printable_section_name (filedata
, section
),
12099 printf (_(" Addr: 0x%016" PRIx64
), section
->sh_addr
);
12100 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
12101 (unsigned long) section
->sh_offset
, section
->sh_link
,
12102 printable_section_name_from_index (filedata
, section
->sh_link
));
12104 edefs
= (Elf_External_Verdef
*)
12105 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
12106 _("version definition section"));
12109 endbuf
= (char *) edefs
+ section
->sh_size
;
12111 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
12114 Elf_External_Verdef
* edef
;
12115 Elf_Internal_Verdef ent
;
12116 Elf_External_Verdaux
* eaux
;
12117 Elf_Internal_Verdaux aux
;
12118 unsigned long isum
;
12121 vstart
= ((char *) edefs
) + idx
;
12122 if (vstart
+ sizeof (*edef
) > endbuf
)
12125 edef
= (Elf_External_Verdef
*) vstart
;
12127 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
12128 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
12129 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
12130 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
12131 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
12132 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
12133 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
12135 printf (_(" %#06lx: Rev: %d Flags: %s"),
12136 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
12138 printf (_(" Index: %d Cnt: %d "),
12139 ent
.vd_ndx
, ent
.vd_cnt
);
12141 /* Check for overflow. */
12142 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
12145 vstart
+= ent
.vd_aux
;
12147 if (vstart
+ sizeof (*eaux
) > endbuf
)
12149 eaux
= (Elf_External_Verdaux
*) vstart
;
12151 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
12152 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
12154 if (valid_dynamic_name (filedata
, aux
.vda_name
))
12155 printf (_("Name: %s\n"),
12156 get_dynamic_name (filedata
, aux
.vda_name
));
12158 printf (_("Name index: %ld\n"), aux
.vda_name
);
12160 isum
= idx
+ ent
.vd_aux
;
12162 for (j
= 1; j
< ent
.vd_cnt
; j
++)
12164 if (aux
.vda_next
< sizeof (*eaux
)
12165 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
12167 warn (_("Invalid vda_next field of %lx\n"),
12172 /* Check for overflow. */
12173 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
12176 isum
+= aux
.vda_next
;
12177 vstart
+= aux
.vda_next
;
12179 if (vstart
+ sizeof (*eaux
) > endbuf
)
12181 eaux
= (Elf_External_Verdaux
*) vstart
;
12183 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
12184 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
12186 if (valid_dynamic_name (filedata
, aux
.vda_name
))
12187 printf (_(" %#06lx: Parent %d: %s\n"),
12189 get_dynamic_name (filedata
, aux
.vda_name
));
12191 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
12192 isum
, j
, aux
.vda_name
);
12195 if (j
< ent
.vd_cnt
)
12196 printf (_(" Version def aux past end of section\n"));
12199 file: id:000001,src:000172+005151,op:splice,rep:2. */
12200 if (ent
.vd_next
< sizeof (*edef
)
12201 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
12203 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
12204 cnt
= section
->sh_info
;
12207 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
12210 idx
+= ent
.vd_next
;
12213 if (cnt
< section
->sh_info
)
12214 printf (_(" Version definition past end of section\n"));
12220 case SHT_GNU_verneed
:
12222 Elf_External_Verneed
* eneed
;
12229 if (filedata
->is_separate
)
12230 printf (ngettext ("\nIn linked file '%s' the version needs section '%s' contains %u entry:\n",
12231 "\nIn linked file '%s' the version needs section '%s' contains %u entries:\n",
12233 filedata
->file_name
,
12234 printable_section_name (filedata
, section
),
12237 printf (ngettext ("\nVersion needs section '%s' "
12238 "contains %u entry:\n",
12239 "\nVersion needs section '%s' "
12240 "contains %u entries:\n",
12242 printable_section_name (filedata
, section
),
12245 printf (_(" Addr: 0x%016" PRIx64
), section
->sh_addr
);
12246 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
12247 (unsigned long) section
->sh_offset
, section
->sh_link
,
12248 printable_section_name_from_index (filedata
, section
->sh_link
));
12250 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
12251 section
->sh_offset
, 1,
12253 _("Version Needs section"));
12256 endbuf
= (char *) eneed
+ section
->sh_size
;
12258 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
12260 Elf_External_Verneed
* entry
;
12261 Elf_Internal_Verneed ent
;
12262 unsigned long isum
;
12266 vstart
= ((char *) eneed
) + idx
;
12267 if (vstart
+ sizeof (*entry
) > endbuf
)
12270 entry
= (Elf_External_Verneed
*) vstart
;
12272 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
12273 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
12274 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
12275 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
12276 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
12278 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
12280 if (valid_dynamic_name (filedata
, ent
.vn_file
))
12281 printf (_(" File: %s"),
12282 get_dynamic_name (filedata
, ent
.vn_file
));
12284 printf (_(" File: %lx"), ent
.vn_file
);
12286 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
12288 /* Check for overflow. */
12289 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
12291 vstart
+= ent
.vn_aux
;
12293 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
12295 Elf_External_Vernaux
* eaux
;
12296 Elf_Internal_Vernaux aux
;
12298 if (vstart
+ sizeof (*eaux
) > endbuf
)
12300 eaux
= (Elf_External_Vernaux
*) vstart
;
12302 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
12303 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
12304 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
12305 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
12306 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
12308 if (valid_dynamic_name (filedata
, aux
.vna_name
))
12309 printf (_(" %#06lx: Name: %s"),
12310 isum
, get_dynamic_name (filedata
, aux
.vna_name
));
12312 printf (_(" %#06lx: Name index: %lx"),
12313 isum
, aux
.vna_name
);
12315 printf (_(" Flags: %s Version: %d\n"),
12316 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
12318 if (aux
.vna_next
< sizeof (*eaux
)
12319 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
12321 warn (_("Invalid vna_next field of %lx\n"),
12326 /* Check for overflow. */
12327 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
12329 isum
+= aux
.vna_next
;
12330 vstart
+= aux
.vna_next
;
12333 if (j
< ent
.vn_cnt
)
12334 warn (_("Missing Version Needs auxiliary information\n"));
12336 if (ent
.vn_next
< sizeof (*entry
)
12337 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
12339 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
12340 cnt
= section
->sh_info
;
12343 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
12345 idx
+= ent
.vn_next
;
12348 if (cnt
< section
->sh_info
)
12349 warn (_("Missing Version Needs information\n"));
12355 case SHT_GNU_versym
:
12357 Elf_Internal_Shdr
* link_section
;
12360 unsigned char * edata
;
12361 unsigned short * data
;
12363 Elf_Internal_Sym
* symbols
;
12364 Elf_Internal_Shdr
* string_sec
;
12365 unsigned long num_syms
;
12368 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
12371 link_section
= filedata
->section_headers
+ section
->sh_link
;
12372 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
12374 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
12379 symbols
= get_elf_symbols (filedata
, link_section
, & num_syms
);
12380 if (symbols
== NULL
)
12383 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
12385 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
12386 string_sec
->sh_size
,
12387 _("version string table"));
12394 if (filedata
->is_separate
)
12395 printf (ngettext ("\nIn linked file '%s' the version symbols section '%s' contains %lu entry:\n",
12396 "\nIn linked file '%s' the version symbols section '%s' contains %lu entries:\n",
12398 filedata
->file_name
,
12399 printable_section_name (filedata
, section
),
12400 (unsigned long) total
);
12402 printf (ngettext ("\nVersion symbols section '%s' "
12403 "contains %lu entry:\n",
12404 "\nVersion symbols section '%s' "
12405 "contains %lu entries:\n",
12407 printable_section_name (filedata
, section
),
12408 (unsigned long) total
);
12410 printf (_(" Addr: 0x%016" PRIx64
), section
->sh_addr
);
12411 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
12412 (unsigned long) section
->sh_offset
, section
->sh_link
,
12413 printable_section_name (filedata
, link_section
));
12415 off
= offset_from_vma (filedata
,
12416 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
12417 total
* sizeof (short));
12418 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
12419 sizeof (short), total
,
12420 _("version symbol data"));
12428 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
12430 for (cnt
= total
; cnt
--;)
12431 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
12436 for (cnt
= 0; cnt
< total
; cnt
+= 4)
12440 char *invalid
= _("*invalid*");
12442 printf (" %03x:", cnt
);
12444 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
12445 switch (data
[cnt
+ j
])
12448 fputs (_(" 0 (*local*) "), stdout
);
12452 fputs (_(" 1 (*global*) "), stdout
);
12456 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
12457 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
12459 /* If this index value is greater than the size of the symbols
12460 array, break to avoid an out-of-bounds read. */
12461 if ((unsigned long)(cnt
+ j
) >= num_syms
)
12463 warn (_("invalid index into symbol array\n"));
12468 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
12470 Elf_Internal_Verneed ivn
;
12471 unsigned long offset
;
12473 offset
= offset_from_vma
12475 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
12476 sizeof (Elf_External_Verneed
));
12480 Elf_Internal_Vernaux ivna
;
12481 Elf_External_Verneed evn
;
12482 Elf_External_Vernaux evna
;
12483 unsigned long a_off
;
12485 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
12486 _("version need")) == NULL
)
12489 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
12490 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
12492 a_off
= offset
+ ivn
.vn_aux
;
12496 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
12497 1, _("version need aux (2)")) == NULL
)
12500 ivna
.vna_other
= 0;
12504 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
12505 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
12508 a_off
+= ivna
.vna_next
;
12510 while (ivna
.vna_other
!= data
[cnt
+ j
]
12511 && ivna
.vna_next
!= 0);
12513 if (ivna
.vna_other
== data
[cnt
+ j
])
12515 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
12517 if (ivna
.vna_name
>= string_sec
->sh_size
)
12520 name
= strtab
+ ivna
.vna_name
;
12524 offset
+= ivn
.vn_next
;
12526 while (ivn
.vn_next
);
12529 if (data
[cnt
+ j
] != 0x8001
12530 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
12532 Elf_Internal_Verdef ivd
;
12533 Elf_External_Verdef evd
;
12534 unsigned long offset
;
12536 offset
= offset_from_vma
12538 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
12543 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
12544 _("version def")) == NULL
)
12547 /* PR 17531: file: 046-1082287-0.004. */
12548 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
12553 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
12554 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
12557 offset
+= ivd
.vd_next
;
12559 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
12560 && ivd
.vd_next
!= 0);
12562 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
12564 Elf_External_Verdaux evda
;
12565 Elf_Internal_Verdaux ivda
;
12567 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
12569 if (get_data (&evda
, filedata
,
12570 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
12572 _("version def aux")) == NULL
)
12575 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
12577 if (ivda
.vda_name
>= string_sec
->sh_size
)
12579 else if (name
!= NULL
&& name
!= invalid
)
12580 name
= _("*both*");
12582 name
= strtab
+ ivda
.vda_name
;
12586 nn
+= printf ("(%s%-*s",
12588 12 - (int) strlen (name
),
12592 printf ("%*c", 18 - nn
, ' ');
12611 if (filedata
->is_separate
)
12612 printf (_("\nNo version information found in linked file '%s'.\n"),
12613 filedata
->file_name
);
12615 printf (_("\nNo version information found in this file.\n"));
12621 static const char *
12622 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
12624 static char buff
[64];
12628 case STB_LOCAL
: return "LOCAL";
12629 case STB_GLOBAL
: return "GLOBAL";
12630 case STB_WEAK
: return "WEAK";
12632 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
12633 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
12635 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
12637 if (binding
== STB_GNU_UNIQUE
12638 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
12640 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
12643 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
12648 static const char *
12649 get_symbol_type (Filedata
* filedata
, unsigned int type
)
12651 static char buff
[64];
12655 case STT_NOTYPE
: return "NOTYPE";
12656 case STT_OBJECT
: return "OBJECT";
12657 case STT_FUNC
: return "FUNC";
12658 case STT_SECTION
: return "SECTION";
12659 case STT_FILE
: return "FILE";
12660 case STT_COMMON
: return "COMMON";
12661 case STT_TLS
: return "TLS";
12662 case STT_RELC
: return "RELC";
12663 case STT_SRELC
: return "SRELC";
12665 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
12667 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
12668 return "THUMB_FUNC";
12670 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
12673 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
12674 return "PARISC_MILLI";
12676 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
12678 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
12680 if (filedata
->file_header
.e_machine
== EM_PARISC
)
12682 if (type
== STT_HP_OPAQUE
)
12683 return "HP_OPAQUE";
12684 if (type
== STT_HP_STUB
)
12688 if (type
== STT_GNU_IFUNC
12689 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
12690 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
12693 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
12696 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
12701 static const char *
12702 get_symbol_visibility (unsigned int visibility
)
12704 switch (visibility
)
12706 case STV_DEFAULT
: return "DEFAULT";
12707 case STV_INTERNAL
: return "INTERNAL";
12708 case STV_HIDDEN
: return "HIDDEN";
12709 case STV_PROTECTED
: return "PROTECTED";
12711 error (_("Unrecognized visibility value: %u\n"), visibility
);
12712 return _("<unknown>");
12716 static const char *
12717 get_alpha_symbol_other (unsigned int other
)
12721 case STO_ALPHA_NOPV
: return "NOPV";
12722 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
12724 error (_("Unrecognized alpha specific other value: %u\n"), other
);
12725 return _("<unknown>");
12729 static const char *
12730 get_solaris_symbol_visibility (unsigned int visibility
)
12732 switch (visibility
)
12734 case 4: return "EXPORTED";
12735 case 5: return "SINGLETON";
12736 case 6: return "ELIMINATE";
12737 default: return get_symbol_visibility (visibility
);
12741 static const char *
12742 get_aarch64_symbol_other (unsigned int other
)
12744 static char buf
[32];
12746 if (other
& STO_AARCH64_VARIANT_PCS
)
12748 other
&= ~STO_AARCH64_VARIANT_PCS
;
12750 return "VARIANT_PCS";
12751 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
12757 static const char *
12758 get_mips_symbol_other (unsigned int other
)
12762 case STO_OPTIONAL
: return "OPTIONAL";
12763 case STO_MIPS_PLT
: return "MIPS PLT";
12764 case STO_MIPS_PIC
: return "MIPS PIC";
12765 case STO_MICROMIPS
: return "MICROMIPS";
12766 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
12767 case STO_MIPS16
: return "MIPS16";
12768 default: return NULL
;
12772 static const char *
12773 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
12775 if (is_ia64_vms (filedata
))
12777 static char res
[32];
12781 /* Function types is for images and .STB files only. */
12782 switch (filedata
->file_header
.e_type
)
12786 switch (VMS_ST_FUNC_TYPE (other
))
12788 case VMS_SFT_CODE_ADDR
:
12789 strcat (res
, " CA");
12791 case VMS_SFT_SYMV_IDX
:
12792 strcat (res
, " VEC");
12795 strcat (res
, " FD");
12797 case VMS_SFT_RESERVE
:
12798 strcat (res
, " RSV");
12801 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
12802 VMS_ST_FUNC_TYPE (other
));
12803 strcat (res
, " <unknown>");
12810 switch (VMS_ST_LINKAGE (other
))
12812 case VMS_STL_IGNORE
:
12813 strcat (res
, " IGN");
12815 case VMS_STL_RESERVE
:
12816 strcat (res
, " RSV");
12819 strcat (res
, " STD");
12822 strcat (res
, " LNK");
12825 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
12826 VMS_ST_LINKAGE (other
));
12827 strcat (res
, " <unknown>");
12839 static const char *
12840 get_ppc64_symbol_other (unsigned int other
)
12842 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
12845 other
>>= STO_PPC64_LOCAL_BIT
;
12848 static char buf
[64];
12850 other
= ppc64_decode_local_entry (other
);
12851 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
12857 static const char *
12858 get_riscv_symbol_other (unsigned int other
)
12860 static char buf
[32];
12863 if (other
& STO_RISCV_VARIANT_CC
)
12865 strcat (buf
, _(" VARIANT_CC"));
12866 other
&= ~STO_RISCV_VARIANT_CC
;
12870 snprintf (buf
, sizeof buf
, " %x", other
);
12879 static const char *
12880 get_symbol_other (Filedata
* filedata
, unsigned int other
)
12882 const char * result
= NULL
;
12883 static char buff
[64];
12888 switch (filedata
->file_header
.e_machine
)
12891 result
= get_alpha_symbol_other (other
);
12894 result
= get_aarch64_symbol_other (other
);
12897 result
= get_mips_symbol_other (other
);
12900 result
= get_ia64_symbol_other (filedata
, other
);
12903 result
= get_ppc64_symbol_other (other
);
12906 result
= get_riscv_symbol_other (other
);
12916 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
12920 static const char *
12921 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
12923 static char buff
[32];
12927 case SHN_UNDEF
: return "UND";
12928 case SHN_ABS
: return "ABS";
12929 case SHN_COMMON
: return "COM";
12931 if (type
== SHN_IA_64_ANSI_COMMON
12932 && filedata
->file_header
.e_machine
== EM_IA_64
12933 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
12935 else if ((filedata
->file_header
.e_machine
== EM_X86_64
12936 || filedata
->file_header
.e_machine
== EM_L1OM
12937 || filedata
->file_header
.e_machine
== EM_K1OM
)
12938 && type
== SHN_X86_64_LCOMMON
)
12939 return "LARGE_COM";
12940 else if ((type
== SHN_MIPS_SCOMMON
12941 && filedata
->file_header
.e_machine
== EM_MIPS
)
12942 || (type
== SHN_TIC6X_SCOMMON
12943 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
12945 else if (type
== SHN_MIPS_SUNDEFINED
12946 && filedata
->file_header
.e_machine
== EM_MIPS
)
12948 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
12949 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
12950 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
12951 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
12952 else if (type
>= SHN_LORESERVE
)
12953 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
12954 else if (filedata
->file_header
.e_shnum
!= 0
12955 && type
>= filedata
->file_header
.e_shnum
)
12956 sprintf (buff
, _("bad section index[%3d]"), type
);
12958 sprintf (buff
, "%3d", type
);
12965 static const char *
12966 get_symbol_version_string (Filedata
* filedata
,
12968 const char * strtab
,
12969 unsigned long int strtab_size
,
12971 Elf_Internal_Sym
* psym
,
12972 enum versioned_symbol_info
* sym_info
,
12973 unsigned short * vna_other
)
12975 unsigned char data
[2];
12976 unsigned short vers_data
;
12977 unsigned long offset
;
12978 unsigned short max_vd_ndx
;
12981 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
12984 offset
= offset_from_vma (filedata
,
12985 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
12986 sizeof data
+ si
* sizeof (vers_data
));
12988 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
12989 sizeof (data
), 1, _("version data")) == NULL
)
12992 vers_data
= byte_get (data
, 2);
12994 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
12997 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
13000 /* Usually we'd only see verdef for defined symbols, and verneed for
13001 undefined symbols. However, symbols defined by the linker in
13002 .dynbss for variables copied from a shared library in order to
13003 avoid text relocations are defined yet have verneed. We could
13004 use a heuristic to detect the special case, for example, check
13005 for verneed first on symbols defined in SHT_NOBITS sections, but
13006 it is simpler and more reliable to just look for both verdef and
13007 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
13009 if (psym
->st_shndx
!= SHN_UNDEF
13010 && vers_data
!= 0x8001
13011 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
13013 Elf_Internal_Verdef ivd
;
13014 Elf_Internal_Verdaux ivda
;
13015 Elf_External_Verdaux evda
;
13018 off
= offset_from_vma (filedata
,
13019 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
13020 sizeof (Elf_External_Verdef
));
13024 Elf_External_Verdef evd
;
13026 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
13027 _("version def")) == NULL
)
13036 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
13037 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
13038 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
13039 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
13042 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
13043 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
13045 off
+= ivd
.vd_next
;
13047 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
13049 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
13051 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
13054 off
-= ivd
.vd_next
;
13057 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
13058 _("version def aux")) != NULL
)
13060 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
13062 if (psym
->st_name
!= ivda
.vda_name
)
13063 return (ivda
.vda_name
< strtab_size
13064 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
13069 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
13071 Elf_External_Verneed evn
;
13072 Elf_Internal_Verneed ivn
;
13073 Elf_Internal_Vernaux ivna
;
13075 offset
= offset_from_vma (filedata
,
13076 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
13080 unsigned long vna_off
;
13082 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
13083 _("version need")) == NULL
)
13086 ivna
.vna_other
= 0;
13091 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
13092 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
13094 vna_off
= offset
+ ivn
.vn_aux
;
13098 Elf_External_Vernaux evna
;
13100 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
13101 _("version need aux (3)")) == NULL
)
13104 ivna
.vna_other
= 0;
13109 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
13110 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
13111 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
13114 vna_off
+= ivna
.vna_next
;
13116 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
13118 if (ivna
.vna_other
== vers_data
)
13121 offset
+= ivn
.vn_next
;
13123 while (ivn
.vn_next
!= 0);
13125 if (ivna
.vna_other
== vers_data
)
13127 *sym_info
= symbol_undefined
;
13128 *vna_other
= ivna
.vna_other
;
13129 return (ivna
.vna_name
< strtab_size
13130 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
13132 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
13133 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
13134 return _("<corrupt>");
13139 /* Display a symbol size on stdout. Format is based on --sym-base setting. */
13141 static unsigned int
13142 print_dynamic_symbol_size (uint64_t vma
, int base
)
13147 return print_vma (vma
, OCTAL_5
);
13150 return print_vma (vma
, UNSIGNED_5
);
13153 return print_vma (vma
, PREFIX_HEX_5
);
13157 return print_vma (vma
, DEC_5
);
13162 print_dynamic_symbol (Filedata
*filedata
, unsigned long si
,
13163 Elf_Internal_Sym
*symtab
,
13164 Elf_Internal_Shdr
*section
,
13165 char *strtab
, size_t strtab_size
)
13167 const char *version_string
;
13168 enum versioned_symbol_info sym_info
;
13169 unsigned short vna_other
;
13172 Elf_Internal_Sym
*psym
= symtab
+ si
;
13174 printf ("%6ld: ", si
);
13175 print_vma (psym
->st_value
, LONG_HEX
);
13177 print_dynamic_symbol_size (psym
->st_size
, sym_base
);
13178 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
13179 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
13180 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
13181 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
13184 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
13186 printf (" %-7s", get_symbol_visibility (vis
));
13187 /* Check to see if any other bits in the st_other field are set.
13188 Note - displaying this information disrupts the layout of the
13189 table being generated, but for the moment this case is very rare. */
13190 if (psym
->st_other
^ vis
)
13191 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
13193 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
13195 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
13196 && psym
->st_shndx
< filedata
->file_header
.e_shnum
13197 && filedata
->section_headers
!= NULL
13198 && psym
->st_name
== 0)
13201 = section_name_valid (filedata
,
13202 filedata
->section_headers
+ psym
->st_shndx
);
13204 section_name_print (filedata
,
13205 filedata
->section_headers
+ psym
->st_shndx
)
13210 is_valid
= valid_symbol_name (strtab
, strtab_size
, psym
->st_name
);
13211 sstr
= is_valid
? strtab
+ psym
->st_name
: _("<corrupt>");
13215 = get_symbol_version_string (filedata
,
13217 || section
->sh_type
== SHT_DYNSYM
),
13218 strtab
, strtab_size
, si
,
13219 psym
, &sym_info
, &vna_other
);
13221 int len_avail
= 21;
13222 if (! do_wide
&& version_string
!= NULL
)
13226 len_avail
-= 1 + strlen (version_string
);
13228 if (sym_info
== symbol_undefined
)
13229 len_avail
-= sprintf (buffer
," (%d)", vna_other
);
13230 else if (sym_info
!= symbol_hidden
)
13234 print_symbol (len_avail
, sstr
);
13236 if (version_string
)
13238 if (sym_info
== symbol_undefined
)
13239 printf ("@%s (%d)", version_string
, vna_other
);
13241 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
13247 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
13249 && si
>= section
->sh_info
13250 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
13251 && filedata
->file_header
.e_machine
!= EM_MIPS
13252 /* Solaris binaries have been found to violate this requirement as
13253 well. Not sure if this is a bug or an ABI requirement. */
13254 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
13255 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
13256 si
, printable_section_name (filedata
, section
), section
->sh_info
);
13259 static const char *
13260 get_lto_kind (unsigned int kind
)
13264 case 0: return "DEF";
13265 case 1: return "WEAKDEF";
13266 case 2: return "UNDEF";
13267 case 3: return "WEAKUNDEF";
13268 case 4: return "COMMON";
13273 static char buffer
[30];
13274 error (_("Unknown LTO symbol definition encountered: %u\n"), kind
);
13275 sprintf (buffer
, "<unknown: %u>", kind
);
13279 static const char *
13280 get_lto_visibility (unsigned int visibility
)
13282 switch (visibility
)
13284 case 0: return "DEFAULT";
13285 case 1: return "PROTECTED";
13286 case 2: return "INTERNAL";
13287 case 3: return "HIDDEN";
13292 static char buffer
[30];
13293 error (_("Unknown LTO symbol visibility encountered: %u\n"), visibility
);
13294 sprintf (buffer
, "<unknown: %u>", visibility
);
13298 static const char *
13299 get_lto_sym_type (unsigned int sym_type
)
13303 case 0: return "UNKNOWN";
13304 case 1: return "FUNCTION";
13305 case 2: return "VARIABLE";
13310 static char buffer
[30];
13311 error (_("Unknown LTO symbol type encountered: %u\n"), sym_type
);
13312 sprintf (buffer
, "<unknown: %u>", sym_type
);
13316 /* Display an LTO format symbol table.
13317 FIXME: The format of LTO symbol tables is not formalized.
13318 So this code could need changing in the future. */
13321 display_lto_symtab (Filedata
* filedata
,
13322 Elf_Internal_Shdr
* section
)
13324 if (section
->sh_size
== 0)
13326 if (filedata
->is_separate
)
13327 printf (_("\nThe LTO Symbol table section '%s' in linked file '%s' is empty!\n"),
13328 printable_section_name (filedata
, section
),
13329 filedata
->file_name
);
13331 printf (_("\nLTO Symbol table '%s' is empty!\n"),
13332 printable_section_name (filedata
, section
));
13337 if (section
->sh_size
> filedata
->file_size
)
13339 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
13340 printable_section_name (filedata
, section
),
13341 (unsigned long) section
->sh_size
);
13345 void * alloced_data
= get_data (NULL
, filedata
, section
->sh_offset
,
13346 section
->sh_size
, 1, _("LTO symbols"));
13347 if (alloced_data
== NULL
)
13350 /* Look for extended data for the symbol table. */
13351 Elf_Internal_Shdr
* ext
;
13352 void * ext_data_orig
= NULL
;
13353 char * ext_data
= NULL
;
13354 char * ext_data_end
= NULL
;
13355 char * ext_name
= NULL
;
13357 if (asprintf (& ext_name
, ".gnu.lto_.ext_symtab.%s",
13358 (section_name (filedata
, section
)
13359 + sizeof (".gnu.lto_.symtab.") - 1)) > 0
13360 && ext_name
!= NULL
/* Paranoia. */
13361 && (ext
= find_section (filedata
, ext_name
)) != NULL
)
13363 if (ext
->sh_size
< 3)
13364 error (_("LTO Symbol extension table '%s' is empty!\n"),
13365 printable_section_name (filedata
, ext
));
13368 ext_data_orig
= ext_data
= get_data (NULL
, filedata
, ext
->sh_offset
,
13370 _("LTO ext symbol data"));
13371 if (ext_data
!= NULL
)
13373 ext_data_end
= ext_data
+ ext
->sh_size
;
13374 if (* ext_data
++ != 1)
13375 error (_("Unexpected version number in symbol extension table\n"));
13380 const unsigned char * data
= (const unsigned char *) alloced_data
;
13381 const unsigned char * end
= data
+ section
->sh_size
;
13383 if (filedata
->is_separate
)
13384 printf (_("\nIn linked file '%s': "), filedata
->file_name
);
13388 if (ext_data_orig
!= NULL
)
13391 printf (_("LTO Symbol table '%s' and extension table '%s' contain:\n"),
13392 printable_section_name (filedata
, section
),
13393 printable_section_name (filedata
, ext
));
13396 printf (_("LTO Symbol table '%s'\n"),
13397 printable_section_name (filedata
, section
));
13398 printf (_(" and extension table '%s' contain:\n"),
13399 printable_section_name (filedata
, ext
));
13403 printf (_("LTO Symbol table '%s' contains:\n"),
13404 printable_section_name (filedata
, section
));
13406 /* FIXME: Add a wide version. */
13407 if (ext_data_orig
!= NULL
)
13408 printf (_(" Comdat_Key Kind Visibility Size Slot Type Section Name\n"));
13410 printf (_(" Comdat_Key Kind Visibility Size Slot Name\n"));
13412 /* FIXME: We do not handle style prefixes. */
13416 const unsigned char * sym_name
= data
;
13417 data
+= strnlen ((const char *) sym_name
, end
- data
) + 1;
13421 const unsigned char * comdat_key
= data
;
13422 data
+= strnlen ((const char *) comdat_key
, end
- data
) + 1;
13426 if (data
+ 2 + 8 + 4 > end
)
13429 unsigned int kind
= *data
++;
13430 unsigned int visibility
= *data
++;
13432 uint64_t size
= byte_get (data
, 8);
13435 uint64_t slot
= byte_get (data
, 4);
13438 if (ext_data
!= NULL
)
13440 if (ext_data
< (ext_data_end
- 1))
13442 unsigned int sym_type
= * ext_data
++;
13443 unsigned int sec_kind
= * ext_data
++;
13445 printf (" %10s %10s %11s %08" PRIx64
" %08" PRIx64
" %9s %08x _",
13446 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
13447 get_lto_kind (kind
),
13448 get_lto_visibility (visibility
),
13451 get_lto_sym_type (sym_type
),
13453 print_symbol (6, (const char *) sym_name
);
13457 error (_("Ran out of LTO symbol extension data\n"));
13459 /* FIXME: return FAIL result ? */
13464 printf (" %10s %10s %11s %08" PRIx64
" %08" PRIx64
" _",
13465 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
13466 get_lto_kind (kind
),
13467 get_lto_visibility (visibility
),
13470 print_symbol (21, (const char *) sym_name
);
13475 if (ext_data
!= NULL
&& ext_data
< ext_data_end
)
13477 error (_("Data remains in the LTO symbol extension table\n"));
13481 free (alloced_data
);
13482 free (ext_data_orig
);
13487 error (_("Buffer overrun encountered whilst decoding LTO symbol table\n"));
13488 free (alloced_data
);
13489 free (ext_data_orig
);
13494 /* Display LTO symbol tables. */
13497 process_lto_symbol_tables (Filedata
* filedata
)
13499 Elf_Internal_Shdr
* section
;
13506 if (filedata
->section_headers
== NULL
)
13509 for (i
= 0, section
= filedata
->section_headers
;
13510 i
< filedata
->file_header
.e_shnum
;
13512 if (section_name_valid (filedata
, section
)
13513 && startswith (section_name (filedata
, section
), ".gnu.lto_.symtab."))
13514 res
&= display_lto_symtab (filedata
, section
);
13519 /* Dump the symbol table. */
13522 process_symbol_table (Filedata
* filedata
)
13524 Elf_Internal_Shdr
* section
;
13526 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
13529 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
13531 && do_using_dynamic
13532 && filedata
->dynamic_strings
!= NULL
13533 && filedata
->dynamic_symbols
!= NULL
)
13537 if (filedata
->is_separate
)
13539 printf (ngettext ("\nIn linked file '%s' the dynamic symbol table contains %lu entry:\n",
13540 "\nIn linked file '%s' the dynamic symbol table contains %lu entries:\n",
13541 filedata
->num_dynamic_syms
),
13542 filedata
->file_name
,
13543 filedata
->num_dynamic_syms
);
13547 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
13548 "\nSymbol table for image contains %lu entries:\n",
13549 filedata
->num_dynamic_syms
),
13550 filedata
->num_dynamic_syms
);
13553 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
13555 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
13557 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
13558 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
13559 filedata
->dynamic_strings
,
13560 filedata
->dynamic_strings_length
);
13562 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
13563 && filedata
->section_headers
!= NULL
)
13567 for (i
= 0, section
= filedata
->section_headers
;
13568 i
< filedata
->file_header
.e_shnum
;
13571 char * strtab
= NULL
;
13572 unsigned long int strtab_size
= 0;
13573 Elf_Internal_Sym
* symtab
;
13574 unsigned long si
, num_syms
;
13576 if ((section
->sh_type
!= SHT_SYMTAB
13577 && section
->sh_type
!= SHT_DYNSYM
)
13579 && section
->sh_type
== SHT_SYMTAB
))
13582 if (section
->sh_entsize
== 0)
13584 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
13585 printable_section_name (filedata
, section
));
13589 num_syms
= section
->sh_size
/ section
->sh_entsize
;
13591 if (filedata
->is_separate
)
13592 printf (ngettext ("\nIn linked file '%s' symbol section '%s' contains %lu entry:\n",
13593 "\nIn linked file '%s' symbol section '%s' contains %lu entries:\n",
13595 filedata
->file_name
,
13596 printable_section_name (filedata
, section
),
13599 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
13600 "\nSymbol table '%s' contains %lu entries:\n",
13602 printable_section_name (filedata
, section
),
13606 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
13608 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
13610 symtab
= get_elf_symbols (filedata
, section
, & num_syms
);
13611 if (symtab
== NULL
)
13614 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
13616 strtab
= filedata
->string_table
;
13617 strtab_size
= filedata
->string_table_length
;
13619 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
13621 Elf_Internal_Shdr
* string_sec
;
13623 string_sec
= filedata
->section_headers
+ section
->sh_link
;
13625 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
13626 1, string_sec
->sh_size
,
13627 _("string table"));
13628 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
13631 for (si
= 0; si
< num_syms
; si
++)
13632 print_dynamic_symbol (filedata
, si
, symtab
, section
,
13633 strtab
, strtab_size
);
13636 if (strtab
!= filedata
->string_table
)
13642 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
13644 if (do_histogram
&& filedata
->buckets
!= NULL
)
13646 unsigned long * lengths
;
13647 unsigned long * counts
;
13650 unsigned long maxlength
= 0;
13651 unsigned long nzero_counts
= 0;
13652 unsigned long nsyms
= 0;
13655 printf (ngettext ("\nHistogram for bucket list length "
13656 "(total of %lu bucket):\n",
13657 "\nHistogram for bucket list length "
13658 "(total of %lu buckets):\n",
13659 (unsigned long) filedata
->nbuckets
),
13660 (unsigned long) filedata
->nbuckets
);
13662 lengths
= (unsigned long *) calloc (filedata
->nbuckets
,
13663 sizeof (*lengths
));
13664 if (lengths
== NULL
)
13666 error (_("Out of memory allocating space for histogram buckets\n"));
13669 visited
= xcmalloc (filedata
->nchains
, 1);
13670 memset (visited
, 0, filedata
->nchains
);
13672 printf (_(" Length Number %% of total Coverage\n"));
13673 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
13675 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
13678 if (maxlength
< ++lengths
[hn
])
13680 if (si
>= filedata
->nchains
|| visited
[si
])
13682 error (_("histogram chain is corrupt\n"));
13690 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
13691 if (counts
== NULL
)
13694 error (_("Out of memory allocating space for histogram counts\n"));
13698 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
13699 ++counts
[lengths
[hn
]];
13701 if (filedata
->nbuckets
> 0)
13704 printf (" 0 %-10lu (%5.1f%%)\n",
13705 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
13706 for (i
= 1; i
<= maxlength
; ++i
)
13708 nzero_counts
+= counts
[i
] * i
;
13709 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
13710 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
13711 (nzero_counts
* 100.0) / nsyms
);
13719 free (filedata
->buckets
);
13720 filedata
->buckets
= NULL
;
13721 filedata
->nbuckets
= 0;
13722 free (filedata
->chains
);
13723 filedata
->chains
= NULL
;
13725 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
13727 unsigned long * lengths
;
13728 unsigned long * counts
;
13730 unsigned long maxlength
= 0;
13731 unsigned long nzero_counts
= 0;
13732 unsigned long nsyms
= 0;
13734 printf (ngettext ("\nHistogram for `%s' bucket list length "
13735 "(total of %lu bucket):\n",
13736 "\nHistogram for `%s' bucket list length "
13737 "(total of %lu buckets):\n",
13738 (unsigned long) filedata
->ngnubuckets
),
13739 GNU_HASH_SECTION_NAME (filedata
),
13740 (unsigned long) filedata
->ngnubuckets
);
13742 lengths
= (unsigned long *) calloc (filedata
->ngnubuckets
,
13743 sizeof (*lengths
));
13744 if (lengths
== NULL
)
13746 error (_("Out of memory allocating space for gnu histogram buckets\n"));
13750 printf (_(" Length Number %% of total Coverage\n"));
13752 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
13753 if (filedata
->gnubuckets
[hn
] != 0)
13755 uint64_t off
, length
= 1;
13757 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
13758 /* PR 17531 file: 010-77222-0.004. */
13759 off
< filedata
->ngnuchains
13760 && (filedata
->gnuchains
[off
] & 1) == 0;
13763 lengths
[hn
] = length
;
13764 if (length
> maxlength
)
13765 maxlength
= length
;
13769 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
13770 if (counts
== NULL
)
13773 error (_("Out of memory allocating space for gnu histogram counts\n"));
13777 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
13778 ++counts
[lengths
[hn
]];
13780 if (filedata
->ngnubuckets
> 0)
13783 printf (" 0 %-10lu (%5.1f%%)\n",
13784 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
13785 for (j
= 1; j
<= maxlength
; ++j
)
13787 nzero_counts
+= counts
[j
] * j
;
13788 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
13789 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
13790 (nzero_counts
* 100.0) / nsyms
);
13797 free (filedata
->gnubuckets
);
13798 filedata
->gnubuckets
= NULL
;
13799 filedata
->ngnubuckets
= 0;
13800 free (filedata
->gnuchains
);
13801 filedata
->gnuchains
= NULL
;
13802 filedata
->ngnuchains
= 0;
13803 free (filedata
->mipsxlat
);
13804 filedata
->mipsxlat
= NULL
;
13808 free (filedata
->gnubuckets
);
13809 filedata
->gnubuckets
= NULL
;
13810 filedata
->ngnubuckets
= 0;
13811 free (filedata
->gnuchains
);
13812 filedata
->gnuchains
= NULL
;
13813 filedata
->ngnuchains
= 0;
13814 free (filedata
->mipsxlat
);
13815 filedata
->mipsxlat
= NULL
;
13816 free (filedata
->buckets
);
13817 filedata
->buckets
= NULL
;
13818 filedata
->nbuckets
= 0;
13819 free (filedata
->chains
);
13820 filedata
->chains
= NULL
;
13825 process_syminfo (Filedata
* filedata
)
13829 if (filedata
->dynamic_syminfo
== NULL
13831 /* No syminfo, this is ok. */
13834 /* There better should be a dynamic symbol section. */
13835 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
13838 if (filedata
->is_separate
)
13839 printf (ngettext ("\nIn linked file '%s: the dynamic info segment at offset 0x%lx contains %d entry:\n",
13840 "\nIn linked file '%s: the dynamic info segment at offset 0x%lx contains %d entries:\n",
13841 filedata
->dynamic_syminfo_nent
),
13842 filedata
->file_name
,
13843 filedata
->dynamic_syminfo_offset
,
13844 filedata
->dynamic_syminfo_nent
);
13846 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
13847 "contains %d entry:\n",
13848 "\nDynamic info segment at offset 0x%lx "
13849 "contains %d entries:\n",
13850 filedata
->dynamic_syminfo_nent
),
13851 filedata
->dynamic_syminfo_offset
,
13852 filedata
->dynamic_syminfo_nent
);
13854 printf (_(" Num: Name BoundTo Flags\n"));
13855 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
13857 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
13859 printf ("%4d: ", i
);
13860 if (i
>= filedata
->num_dynamic_syms
)
13861 printf (_("<corrupt index>"));
13862 else if (valid_dynamic_name (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
13863 print_symbol (30, get_dynamic_name (filedata
,
13864 filedata
->dynamic_symbols
[i
].st_name
));
13866 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
13869 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
13871 case SYMINFO_BT_SELF
:
13872 fputs ("SELF ", stdout
);
13874 case SYMINFO_BT_PARENT
:
13875 fputs ("PARENT ", stdout
);
13878 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
13879 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
13880 && valid_dynamic_name (filedata
,
13881 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
13883 print_symbol (10, get_dynamic_name (filedata
,
13884 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
13888 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
13892 if (flags
& SYMINFO_FLG_DIRECT
)
13893 printf (" DIRECT");
13894 if (flags
& SYMINFO_FLG_PASSTHRU
)
13895 printf (" PASSTHRU");
13896 if (flags
& SYMINFO_FLG_COPY
)
13898 if (flags
& SYMINFO_FLG_LAZYLOAD
)
13899 printf (" LAZYLOAD");
13907 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
13908 is contained by the region START .. END. The types of ADDR, START
13909 and END should all be the same. Note both ADDR + NELEM and END
13910 point to just beyond the end of the regions that are being tested. */
13911 #define IN_RANGE(START,END,ADDR,NELEM) \
13912 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
13914 /* Check to see if the given reloc needs to be handled in a target specific
13915 manner. If so then process the reloc and return TRUE otherwise return
13918 If called with reloc == NULL, then this is a signal that reloc processing
13919 for the current section has finished, and any saved state should be
13923 target_specific_reloc_handling (Filedata
* filedata
,
13924 Elf_Internal_Rela
* reloc
,
13925 unsigned char * start
,
13926 unsigned char * end
,
13927 Elf_Internal_Sym
* symtab
,
13928 unsigned long num_syms
)
13930 unsigned int reloc_type
= 0;
13931 unsigned long sym_index
= 0;
13935 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
13936 sym_index
= get_reloc_symindex (reloc
->r_info
);
13939 switch (filedata
->file_header
.e_machine
)
13942 case EM_MSP430_OLD
:
13944 static Elf_Internal_Sym
* saved_sym
= NULL
;
13952 switch (reloc_type
)
13954 case 10: /* R_MSP430_SYM_DIFF */
13955 case 12: /* R_MSP430_GNU_SUB_ULEB128 */
13956 if (uses_msp430x_relocs (filedata
))
13958 /* Fall through. */
13959 case 21: /* R_MSP430X_SYM_DIFF */
13960 case 23: /* R_MSP430X_GNU_SUB_ULEB128 */
13962 if (sym_index
>= num_syms
)
13963 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
13966 saved_sym
= symtab
+ sym_index
;
13969 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
13970 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
13971 goto handle_sym_diff
;
13973 case 5: /* R_MSP430_16_BYTE */
13974 case 9: /* R_MSP430_8 */
13975 case 11: /* R_MSP430_GNU_SET_ULEB128 */
13976 if (uses_msp430x_relocs (filedata
))
13978 goto handle_sym_diff
;
13980 case 2: /* R_MSP430_ABS16 */
13981 case 15: /* R_MSP430X_ABS16 */
13982 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
13983 if (! uses_msp430x_relocs (filedata
))
13985 goto handle_sym_diff
;
13988 if (saved_sym
!= NULL
)
13991 unsigned int reloc_size
= 0;
13993 switch (reloc_type
)
13995 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
13998 case 11: /* R_MSP430_GNU_SET_ULEB128 */
13999 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
14000 if (reloc
->r_offset
< (size_t) (end
- start
))
14001 read_leb128 (start
+ reloc
->r_offset
, end
, false,
14002 &reloc_size
, &leb_ret
);
14009 if (leb_ret
!= 0 || reloc_size
== 0 || reloc_size
> 8)
14010 error (_("MSP430 ULEB128 field at 0x%lx contains invalid "
14011 "ULEB128 value\n"),
14012 (long) reloc
->r_offset
);
14013 else if (sym_index
>= num_syms
)
14014 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
14018 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
14019 - saved_sym
->st_value
);
14021 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
14022 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
14025 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
14026 (long) reloc
->r_offset
);
14035 if (saved_sym
!= NULL
)
14036 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
14043 case EM_CYGNUS_MN10300
:
14045 static Elf_Internal_Sym
* saved_sym
= NULL
;
14053 switch (reloc_type
)
14055 case 34: /* R_MN10300_ALIGN */
14057 case 33: /* R_MN10300_SYM_DIFF */
14058 if (sym_index
>= num_syms
)
14059 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
14062 saved_sym
= symtab
+ sym_index
;
14065 case 1: /* R_MN10300_32 */
14066 case 2: /* R_MN10300_16 */
14067 if (saved_sym
!= NULL
)
14069 int reloc_size
= reloc_type
== 1 ? 4 : 2;
14072 if (sym_index
>= num_syms
)
14073 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
14077 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
14078 - saved_sym
->st_value
);
14080 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
14081 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
14083 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
14084 (long) reloc
->r_offset
);
14092 if (saved_sym
!= NULL
)
14093 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
14101 static uint64_t saved_sym1
= 0;
14102 static uint64_t saved_sym2
= 0;
14103 static uint64_t value
;
14107 saved_sym1
= saved_sym2
= 0;
14111 switch (reloc_type
)
14113 case 0x80: /* R_RL78_SYM. */
14114 saved_sym1
= saved_sym2
;
14115 if (sym_index
>= num_syms
)
14116 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
14120 saved_sym2
= symtab
[sym_index
].st_value
;
14121 saved_sym2
+= reloc
->r_addend
;
14125 case 0x83: /* R_RL78_OPsub. */
14126 value
= saved_sym1
- saved_sym2
;
14127 saved_sym2
= saved_sym1
= 0;
14131 case 0x41: /* R_RL78_ABS32. */
14132 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
14133 byte_put (start
+ reloc
->r_offset
, value
, 4);
14135 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
14136 (long) reloc
->r_offset
);
14140 case 0x43: /* R_RL78_ABS16. */
14141 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
14142 byte_put (start
+ reloc
->r_offset
, value
, 2);
14144 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
14145 (long) reloc
->r_offset
);
14159 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
14160 DWARF debug sections. This is a target specific test. Note - we do not
14161 go through the whole including-target-headers-multiple-times route, (as
14162 we have already done with <elf/h8.h>) because this would become very
14163 messy and even then this function would have to contain target specific
14164 information (the names of the relocs instead of their numeric values).
14165 FIXME: This is not the correct way to solve this problem. The proper way
14166 is to have target specific reloc sizing and typing functions created by
14167 the reloc-macros.h header, in the same way that it already creates the
14168 reloc naming functions. */
14171 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14173 /* Please keep this table alpha-sorted for ease of visual lookup. */
14174 switch (filedata
->file_header
.e_machine
)
14178 return reloc_type
== 1; /* R_386_32. */
14180 return reloc_type
== 1; /* R_68K_32. */
14182 return reloc_type
== 1; /* R_860_32. */
14184 return reloc_type
== 2; /* R_960_32. */
14186 return (reloc_type
== 258
14187 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
14189 return reloc_type
== 11; /* R_BPF_DATA_32 */
14190 case EM_ADAPTEVA_EPIPHANY
:
14191 return reloc_type
== 3;
14193 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
14195 return reloc_type
== 1; /* R_ARC_32. */
14196 case EM_ARC_COMPACT
:
14197 case EM_ARC_COMPACT2
:
14198 return reloc_type
== 4; /* R_ARC_32. */
14200 return reloc_type
== 2; /* R_ARM_ABS32 */
14203 return reloc_type
== 1;
14205 return reloc_type
== 0x12; /* R_byte4_data. */
14207 return reloc_type
== 3; /* R_CRIS_32. */
14209 return reloc_type
== 3; /* R_CR16_NUM32. */
14211 return reloc_type
== 15; /* R_CRX_NUM32. */
14213 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
14214 case EM_CYGNUS_FRV
:
14215 return reloc_type
== 1;
14216 case EM_CYGNUS_D10V
:
14218 return reloc_type
== 6; /* R_D10V_32. */
14219 case EM_CYGNUS_D30V
:
14221 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
14223 return reloc_type
== 3; /* R_DLX_RELOC_32. */
14224 case EM_CYGNUS_FR30
:
14226 return reloc_type
== 3; /* R_FR30_32. */
14228 return reloc_type
== 1; /* R_FT32_32. */
14232 return reloc_type
== 1; /* R_H8_DIR32. */
14234 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
14235 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
14236 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
14237 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
14240 return reloc_type
== 2; /* R_IP2K_32. */
14242 return reloc_type
== 2; /* R_IQ2000_32. */
14243 case EM_LATTICEMICO32
:
14244 return reloc_type
== 3; /* R_LM32_32. */
14246 return reloc_type
== 1; /* R_LARCH_32. */
14249 return reloc_type
== 3; /* R_M32C_32. */
14251 return reloc_type
== 34; /* R_M32R_32_RELA. */
14254 return reloc_type
== 6; /* R_M68HC11_32. */
14256 return reloc_type
== 7 || /* R_S12Z_EXT32 */
14257 reloc_type
== 6; /* R_S12Z_CW32. */
14259 return reloc_type
== 1; /* R_MCORE_ADDR32. */
14260 case EM_CYGNUS_MEP
:
14261 return reloc_type
== 4; /* R_MEP_32. */
14263 return reloc_type
== 2; /* R_METAG_ADDR32. */
14264 case EM_MICROBLAZE
:
14265 return reloc_type
== 1; /* R_MICROBLAZE_32. */
14267 return reloc_type
== 2; /* R_MIPS_32. */
14269 return reloc_type
== 4; /* R_MMIX_32. */
14270 case EM_CYGNUS_MN10200
:
14272 return reloc_type
== 1; /* R_MN10200_32. */
14273 case EM_CYGNUS_MN10300
:
14275 return reloc_type
== 1; /* R_MN10300_32. */
14277 return reloc_type
== 1; /* R_MOXIE_32. */
14278 case EM_MSP430_OLD
:
14280 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
14282 return reloc_type
== 2; /* R_MT_32. */
14284 return reloc_type
== 20; /* R_NDS32_32_RELA. */
14285 case EM_ALTERA_NIOS2
:
14286 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
14288 return reloc_type
== 1; /* R_NIOS_32. */
14290 return reloc_type
== 1; /* R_OR1K_32. */
14292 return (reloc_type
== 1 /* R_PARISC_DIR32. */
14293 || reloc_type
== 2 /* R_PARISC_DIR21L. */
14294 || reloc_type
== 41); /* R_PARISC_SECREL32. */
14297 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
14299 return reloc_type
== 1; /* R_PPC64_ADDR32. */
14301 return reloc_type
== 1; /* R_PPC_ADDR32. */
14303 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
14305 return reloc_type
== 1; /* R_RISCV_32. */
14307 return reloc_type
== 1; /* R_RL78_DIR32. */
14309 return reloc_type
== 1; /* R_RX_DIR32. */
14311 return reloc_type
== 1; /* R_I370_ADDR31. */
14314 return reloc_type
== 4; /* R_S390_32. */
14316 return reloc_type
== 8; /* R_SCORE_ABS32. */
14318 return reloc_type
== 1; /* R_SH_DIR32. */
14319 case EM_SPARC32PLUS
:
14322 return reloc_type
== 3 /* R_SPARC_32. */
14323 || reloc_type
== 23; /* R_SPARC_UA32. */
14325 return reloc_type
== 6; /* R_SPU_ADDR32 */
14327 return reloc_type
== 1; /* R_C6000_ABS32. */
14329 return reloc_type
== 2; /* R_TILEGX_32. */
14331 return reloc_type
== 1; /* R_TILEPRO_32. */
14332 case EM_CYGNUS_V850
:
14334 return reloc_type
== 6; /* R_V850_ABS32. */
14336 return reloc_type
== 0x33; /* R_V810_WORD. */
14338 return reloc_type
== 1; /* R_VAX_32. */
14340 return reloc_type
== 3; /* R_VISIUM_32. */
14341 case EM_WEBASSEMBLY
:
14342 return reloc_type
== 1; /* R_WASM32_32. */
14346 return reloc_type
== 10; /* R_X86_64_32. */
14348 return reloc_type
== 4; /* R_XGATE_32. */
14350 return reloc_type
== 1; /* R_XSTROMY16_32. */
14351 case EM_XTENSA_OLD
:
14353 return reloc_type
== 1; /* R_XTENSA_32. */
14355 return reloc_type
== 6; /* R_Z80_32. */
14358 static unsigned int prev_warn
= 0;
14360 /* Avoid repeating the same warning multiple times. */
14361 if (prev_warn
!= filedata
->file_header
.e_machine
)
14362 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
14363 filedata
->file_header
.e_machine
);
14364 prev_warn
= filedata
->file_header
.e_machine
;
14370 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14371 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
14374 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14376 switch (filedata
->file_header
.e_machine
)
14377 /* Please keep this table alpha-sorted for ease of visual lookup. */
14381 return reloc_type
== 2; /* R_386_PC32. */
14383 return reloc_type
== 4; /* R_68K_PC32. */
14385 return reloc_type
== 261; /* R_AARCH64_PREL32 */
14386 case EM_ADAPTEVA_EPIPHANY
:
14387 return reloc_type
== 6;
14389 return reloc_type
== 10; /* R_ALPHA_SREL32. */
14390 case EM_ARC_COMPACT
:
14391 case EM_ARC_COMPACT2
:
14392 return reloc_type
== 49; /* R_ARC_32_PCREL. */
14394 return reloc_type
== 3; /* R_ARM_REL32 */
14397 return reloc_type
== 36; /* R_AVR_32_PCREL. */
14399 return reloc_type
== 99; /* R_LARCH_32_PCREL. */
14400 case EM_MICROBLAZE
:
14401 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
14403 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
14405 return reloc_type
== 9; /* R_PARISC_PCREL32. */
14407 return reloc_type
== 26; /* R_PPC_REL32. */
14409 return reloc_type
== 26; /* R_PPC64_REL32. */
14411 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
14414 return reloc_type
== 5; /* R_390_PC32. */
14416 return reloc_type
== 2; /* R_SH_REL32. */
14417 case EM_SPARC32PLUS
:
14420 return reloc_type
== 6; /* R_SPARC_DISP32. */
14422 return reloc_type
== 13; /* R_SPU_REL32. */
14424 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
14426 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
14428 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
14432 return reloc_type
== 2; /* R_X86_64_PC32. */
14434 return reloc_type
== 4; /* R_VAX_PCREL32. */
14435 case EM_XTENSA_OLD
:
14437 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
14439 /* Do not abort or issue an error message here. Not all targets use
14440 pc-relative 32-bit relocs in their DWARF debug information and we
14441 have already tested for target coverage in is_32bit_abs_reloc. A
14442 more helpful warning message will be generated by apply_relocations
14443 anyway, so just return. */
14448 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14449 a 64-bit absolute RELA relocation used in DWARF debug sections. */
14452 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14454 switch (filedata
->file_header
.e_machine
)
14457 return reloc_type
== 257; /* R_AARCH64_ABS64. */
14459 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
14461 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
14462 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
14464 return reloc_type
== 2; /* R_LARCH_64 */
14466 return reloc_type
== 80; /* R_PARISC_DIR64. */
14468 return reloc_type
== 38; /* R_PPC64_ADDR64. */
14470 return reloc_type
== 2; /* R_RISCV_64. */
14471 case EM_SPARC32PLUS
:
14474 return reloc_type
== 32 /* R_SPARC_64. */
14475 || reloc_type
== 54; /* R_SPARC_UA64. */
14479 return reloc_type
== 1; /* R_X86_64_64. */
14482 return reloc_type
== 22; /* R_S390_64. */
14484 return reloc_type
== 1; /* R_TILEGX_64. */
14486 return reloc_type
== 18; /* R_MIPS_64. */
14492 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
14493 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
14496 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14498 switch (filedata
->file_header
.e_machine
)
14501 return reloc_type
== 260; /* R_AARCH64_PREL64. */
14503 return reloc_type
== 11; /* R_ALPHA_SREL64. */
14505 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
14506 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
14508 return reloc_type
== 72; /* R_PARISC_PCREL64. */
14510 return reloc_type
== 44; /* R_PPC64_REL64. */
14511 case EM_SPARC32PLUS
:
14514 return reloc_type
== 46; /* R_SPARC_DISP64. */
14518 return reloc_type
== 24; /* R_X86_64_PC64. */
14521 return reloc_type
== 23; /* R_S390_PC64. */
14523 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
14529 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14530 a 24-bit absolute RELA relocation used in DWARF debug sections. */
14533 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14535 switch (filedata
->file_header
.e_machine
)
14537 case EM_CYGNUS_MN10200
:
14539 return reloc_type
== 4; /* R_MN10200_24. */
14541 return reloc_type
== 5; /* R_FT32_20. */
14543 return reloc_type
== 5; /* R_Z80_24. */
14549 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14550 a 16-bit absolute RELA relocation used in DWARF debug sections. */
14553 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14555 /* Please keep this table alpha-sorted for ease of visual lookup. */
14556 switch (filedata
->file_header
.e_machine
)
14559 case EM_ARC_COMPACT
:
14560 case EM_ARC_COMPACT2
:
14561 return reloc_type
== 2; /* R_ARC_16. */
14562 case EM_ADAPTEVA_EPIPHANY
:
14563 return reloc_type
== 5;
14566 return reloc_type
== 4; /* R_AVR_16. */
14567 case EM_CYGNUS_D10V
:
14569 return reloc_type
== 3; /* R_D10V_16. */
14571 return reloc_type
== 2; /* R_FT32_16. */
14575 return reloc_type
== R_H8_DIR16
;
14578 return reloc_type
== 1; /* R_IP2K_16. */
14581 return reloc_type
== 1; /* R_M32C_16 */
14582 case EM_CYGNUS_MN10200
:
14584 return reloc_type
== 2; /* R_MN10200_16. */
14585 case EM_CYGNUS_MN10300
:
14587 return reloc_type
== 2; /* R_MN10300_16. */
14589 if (uses_msp430x_relocs (filedata
))
14590 return reloc_type
== 2; /* R_MSP430_ABS16. */
14591 /* Fall through. */
14592 case EM_MSP430_OLD
:
14593 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
14595 return reloc_type
== 19; /* R_NDS32_16_RELA. */
14596 case EM_ALTERA_NIOS2
:
14597 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
14599 return reloc_type
== 9; /* R_NIOS_16. */
14601 return reloc_type
== 2; /* R_OR1K_16. */
14603 return reloc_type
== 55; /* R_RISCV_SET16. */
14605 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
14607 return reloc_type
== 2; /* R_C6000_ABS16. */
14609 return reloc_type
== 2; /* R_VISIUM_16. */
14611 return reloc_type
== 3; /* R_XGATE_16. */
14613 return reloc_type
== 4; /* R_Z80_16. */
14619 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14620 a 8-bit absolute RELA relocation used in DWARF debug sections. */
14623 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14625 switch (filedata
->file_header
.e_machine
)
14628 return reloc_type
== 54; /* R_RISCV_SET8. */
14630 return reloc_type
== 1; /* R_Z80_8. */
14636 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14637 a 6-bit absolute RELA relocation used in DWARF debug sections. */
14640 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14642 switch (filedata
->file_header
.e_machine
)
14645 return reloc_type
== 53; /* R_RISCV_SET6. */
14651 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14652 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
14655 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14657 /* Please keep this table alpha-sorted for ease of visual lookup. */
14658 switch (filedata
->file_header
.e_machine
)
14661 return reloc_type
== 35; /* R_RISCV_ADD32. */
14667 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14668 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
14671 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14673 /* Please keep this table alpha-sorted for ease of visual lookup. */
14674 switch (filedata
->file_header
.e_machine
)
14677 return reloc_type
== 39; /* R_RISCV_SUB32. */
14683 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14684 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
14687 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14689 /* Please keep this table alpha-sorted for ease of visual lookup. */
14690 switch (filedata
->file_header
.e_machine
)
14693 return reloc_type
== 36; /* R_RISCV_ADD64. */
14699 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14700 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
14703 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14705 /* Please keep this table alpha-sorted for ease of visual lookup. */
14706 switch (filedata
->file_header
.e_machine
)
14709 return reloc_type
== 40; /* R_RISCV_SUB64. */
14715 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14716 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
14719 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14721 /* Please keep this table alpha-sorted for ease of visual lookup. */
14722 switch (filedata
->file_header
.e_machine
)
14725 return reloc_type
== 34; /* R_RISCV_ADD16. */
14731 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14732 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
14735 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14737 /* Please keep this table alpha-sorted for ease of visual lookup. */
14738 switch (filedata
->file_header
.e_machine
)
14741 return reloc_type
== 38; /* R_RISCV_SUB16. */
14747 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14748 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
14751 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14753 /* Please keep this table alpha-sorted for ease of visual lookup. */
14754 switch (filedata
->file_header
.e_machine
)
14757 return reloc_type
== 33; /* R_RISCV_ADD8. */
14763 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14764 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
14767 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14769 /* Please keep this table alpha-sorted for ease of visual lookup. */
14770 switch (filedata
->file_header
.e_machine
)
14773 return reloc_type
== 37; /* R_RISCV_SUB8. */
14779 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14780 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
14783 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14785 switch (filedata
->file_header
.e_machine
)
14788 return reloc_type
== 52; /* R_RISCV_SUB6. */
14794 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
14795 relocation entries (possibly formerly used for SHT_GROUP sections). */
14798 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14800 switch (filedata
->file_header
.e_machine
)
14802 case EM_386
: /* R_386_NONE. */
14803 case EM_68K
: /* R_68K_NONE. */
14804 case EM_ADAPTEVA_EPIPHANY
:
14805 case EM_ALPHA
: /* R_ALPHA_NONE. */
14806 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
14807 case EM_ARC
: /* R_ARC_NONE. */
14808 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
14809 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
14810 case EM_ARM
: /* R_ARM_NONE. */
14811 case EM_CRIS
: /* R_CRIS_NONE. */
14812 case EM_FT32
: /* R_FT32_NONE. */
14813 case EM_IA_64
: /* R_IA64_NONE. */
14814 case EM_K1OM
: /* R_X86_64_NONE. */
14815 case EM_L1OM
: /* R_X86_64_NONE. */
14816 case EM_M32R
: /* R_M32R_NONE. */
14817 case EM_MIPS
: /* R_MIPS_NONE. */
14818 case EM_MN10300
: /* R_MN10300_NONE. */
14819 case EM_MOXIE
: /* R_MOXIE_NONE. */
14820 case EM_NIOS32
: /* R_NIOS_NONE. */
14821 case EM_OR1K
: /* R_OR1K_NONE. */
14822 case EM_PARISC
: /* R_PARISC_NONE. */
14823 case EM_PPC64
: /* R_PPC64_NONE. */
14824 case EM_PPC
: /* R_PPC_NONE. */
14825 case EM_RISCV
: /* R_RISCV_NONE. */
14826 case EM_S390
: /* R_390_NONE. */
14828 case EM_SH
: /* R_SH_NONE. */
14829 case EM_SPARC32PLUS
:
14830 case EM_SPARC
: /* R_SPARC_NONE. */
14832 case EM_TILEGX
: /* R_TILEGX_NONE. */
14833 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
14834 case EM_TI_C6000
:/* R_C6000_NONE. */
14835 case EM_X86_64
: /* R_X86_64_NONE. */
14836 case EM_Z80
: /* R_Z80_NONE. */
14837 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
14838 return reloc_type
== 0;
14841 return reloc_type
== 0 || reloc_type
== 256;
14844 return (reloc_type
== 0 /* R_AVR_NONE. */
14845 || reloc_type
== 30 /* R_AVR_DIFF8. */
14846 || reloc_type
== 31 /* R_AVR_DIFF16. */
14847 || reloc_type
== 32 /* R_AVR_DIFF32. */);
14849 return reloc_type
== 3; /* R_METAG_NONE. */
14851 return (reloc_type
== 0 /* R_NDS32_NONE. */
14852 || reloc_type
== 205 /* R_NDS32_DIFF8. */
14853 || reloc_type
== 206 /* R_NDS32_DIFF16. */
14854 || reloc_type
== 207 /* R_NDS32_DIFF32. */
14855 || reloc_type
== 208 /* R_NDS32_DIFF_ULEB128. */);
14857 return (reloc_type
== 0 /* R_PRU_NONE. */
14858 || reloc_type
== 65 /* R_PRU_DIFF8. */
14859 || reloc_type
== 66 /* R_PRU_DIFF16. */
14860 || reloc_type
== 67 /* R_PRU_DIFF32. */);
14861 case EM_XTENSA_OLD
:
14863 return (reloc_type
== 0 /* R_XTENSA_NONE. */
14864 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
14865 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
14866 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
14867 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
14868 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
14869 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
14870 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
14871 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
14872 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
14877 /* Returns TRUE if there is a relocation against
14878 section NAME at OFFSET bytes. */
14881 reloc_at (struct dwarf_section
* dsec
, uint64_t offset
)
14883 Elf_Internal_Rela
* relocs
;
14884 Elf_Internal_Rela
* rp
;
14886 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
14889 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
14891 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
14892 if (rp
->r_offset
== offset
)
14898 /* Apply relocations to a section.
14899 Returns TRUE upon success, FALSE otherwise.
14900 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
14901 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
14902 will be set to the number of relocs loaded.
14904 Note: So far support has been added only for those relocations
14905 which can be found in debug sections. FIXME: Add support for
14906 more relocations ? */
14909 apply_relocations (Filedata
*filedata
,
14910 const Elf_Internal_Shdr
*section
,
14911 unsigned char *start
,
14913 void **relocs_return
,
14914 unsigned long *num_relocs_return
)
14916 Elf_Internal_Shdr
* relsec
;
14917 unsigned char * end
= start
+ size
;
14919 if (relocs_return
!= NULL
)
14921 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
14922 * num_relocs_return
= 0;
14925 if (filedata
->file_header
.e_type
!= ET_REL
)
14926 /* No relocs to apply. */
14929 /* Find the reloc section associated with the section. */
14930 for (relsec
= filedata
->section_headers
;
14931 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14935 unsigned long num_relocs
;
14936 Elf_Internal_Rela
* relocs
;
14937 Elf_Internal_Rela
* rp
;
14938 Elf_Internal_Shdr
* symsec
;
14939 Elf_Internal_Sym
* symtab
;
14940 unsigned long num_syms
;
14941 Elf_Internal_Sym
* sym
;
14943 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14944 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14945 || filedata
->section_headers
+ relsec
->sh_info
!= section
14946 || relsec
->sh_size
== 0
14947 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14950 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
14951 if (symsec
->sh_type
!= SHT_SYMTAB
14952 && symsec
->sh_type
!= SHT_DYNSYM
)
14955 is_rela
= relsec
->sh_type
== SHT_RELA
;
14959 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
14960 relsec
->sh_size
, & relocs
, & num_relocs
))
14965 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
14966 relsec
->sh_size
, & relocs
, & num_relocs
))
14970 /* SH uses RELA but uses in place value instead of the addend field. */
14971 if (filedata
->file_header
.e_machine
== EM_SH
)
14974 symtab
= get_elf_symbols (filedata
, symsec
, & num_syms
);
14976 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
14979 unsigned int reloc_type
;
14980 unsigned int reloc_size
;
14981 bool reloc_inplace
= false;
14982 bool reloc_subtract
= false;
14983 unsigned char *rloc
;
14984 unsigned long sym_index
;
14986 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
14988 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
14990 else if (is_none_reloc (filedata
, reloc_type
))
14992 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
14993 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
14995 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
14996 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
14998 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
15000 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
15002 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
15003 || is_6bit_abs_reloc (filedata
, reloc_type
))
15005 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
15007 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
15010 reloc_inplace
= true;
15012 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
15014 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
15017 reloc_inplace
= true;
15019 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
15021 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
15024 reloc_inplace
= true;
15026 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
15028 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
15031 reloc_inplace
= true;
15033 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
15037 reloc_inplace
= true;
15041 static unsigned int prev_reloc
= 0;
15043 if (reloc_type
!= prev_reloc
)
15044 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
15045 reloc_type
, printable_section_name (filedata
, section
));
15046 prev_reloc
= reloc_type
;
15050 rloc
= start
+ rp
->r_offset
;
15051 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
15053 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
15054 (unsigned long) rp
->r_offset
,
15055 printable_section_name (filedata
, section
));
15059 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
15060 if (sym_index
>= num_syms
)
15062 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
15063 sym_index
, printable_section_name (filedata
, section
));
15066 sym
= symtab
+ sym_index
;
15068 /* If the reloc has a symbol associated with it,
15069 make sure that it is of an appropriate type.
15071 Relocations against symbols without type can happen.
15072 Gcc -feliminate-dwarf2-dups may generate symbols
15073 without type for debug info.
15075 Icc generates relocations against function symbols
15076 instead of local labels.
15078 Relocations against object symbols can happen, eg when
15079 referencing a global array. For an example of this see
15080 the _clz.o binary in libgcc.a. */
15082 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
15083 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
15085 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
15086 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
15087 printable_section_name (filedata
, relsec
),
15088 (long int)(rp
- relocs
));
15094 addend
+= rp
->r_addend
;
15095 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
15096 partial_inplace. */
15098 || (filedata
->file_header
.e_machine
== EM_XTENSA
15099 && reloc_type
== 1)
15100 || ((filedata
->file_header
.e_machine
== EM_PJ
15101 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
15102 && reloc_type
== 1)
15103 || ((filedata
->file_header
.e_machine
== EM_D30V
15104 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
15105 && reloc_type
== 12)
15108 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
15109 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
15111 addend
+= byte_get (rloc
, reloc_size
);
15114 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
15115 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
15117 /* On HPPA, all pc-relative relocations are biased by 8. */
15118 if (filedata
->file_header
.e_machine
== EM_PARISC
)
15120 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
15123 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
15124 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
15126 if (reloc_subtract
)
15127 addend
-= sym
->st_value
;
15129 addend
+= sym
->st_value
;
15130 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
15131 byte_put (rloc
, addend
, reloc_size
);
15133 else if (reloc_subtract
)
15134 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
15136 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
15140 /* Let the target specific reloc processing code know that
15141 we have finished with these relocs. */
15142 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
15146 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
15147 * num_relocs_return
= num_relocs
;
15158 #ifdef SUPPORT_DISASSEMBLY
15160 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15162 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
15164 /* FIXME: XXX -- to be done --- XXX */
15170 /* Reads in the contents of SECTION from FILE, returning a pointer
15171 to a malloc'ed buffer or NULL if something went wrong. */
15174 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15176 uint64_t num_bytes
= section
->sh_size
;
15178 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
15180 printf (_("Section '%s' has no data to dump.\n"),
15181 printable_section_name (filedata
, section
));
15185 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
15186 _("section contents"));
15189 /* Uncompresses a section that was compressed using zlib/zstd, in place. */
15192 uncompress_section_contents (bool is_zstd
, unsigned char **buffer
,
15193 uint64_t uncompressed_size
, uint64_t *size
)
15195 uint64_t compressed_size
= *size
;
15196 unsigned char *compressed_buffer
= *buffer
;
15197 unsigned char *uncompressed_buffer
= xmalloc (uncompressed_size
);
15204 size_t ret
= ZSTD_decompress (uncompressed_buffer
, uncompressed_size
,
15205 compressed_buffer
, compressed_size
);
15206 if (ZSTD_isError (ret
))
15212 /* It is possible the section consists of several compressed
15213 buffers concatenated together, so we uncompress in a loop. */
15214 /* PR 18313: The state field in the z_stream structure is supposed
15215 to be invisible to the user (ie us), but some compilers will
15216 still complain about it being used without initialisation. So
15217 we first zero the entire z_stream structure and then set the fields
15219 memset (&strm
, 0, sizeof strm
);
15220 strm
.avail_in
= compressed_size
;
15221 strm
.next_in
= (Bytef
*)compressed_buffer
;
15222 strm
.avail_out
= uncompressed_size
;
15224 rc
= inflateInit (&strm
);
15225 while (strm
.avail_in
> 0)
15229 strm
.next_out
= ((Bytef
*)uncompressed_buffer
15230 + (uncompressed_size
- strm
.avail_out
));
15231 rc
= inflate (&strm
, Z_FINISH
);
15232 if (rc
!= Z_STREAM_END
)
15234 rc
= inflateReset (&strm
);
15236 if (inflateEnd (&strm
) != Z_OK
|| rc
!= Z_OK
|| strm
.avail_out
!= 0)
15240 *buffer
= uncompressed_buffer
;
15241 *size
= uncompressed_size
;
15245 free (uncompressed_buffer
);
15246 /* Indicate decompression failure. */
15252 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15254 Elf_Internal_Shdr
*relsec
;
15255 uint64_t num_bytes
;
15256 unsigned char *data
;
15257 unsigned char *end
;
15258 unsigned char *real_start
;
15259 unsigned char *start
;
15260 bool some_strings_shown
;
15262 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
15264 /* PR 21820: Do not fail if the section was empty. */
15265 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
15267 num_bytes
= section
->sh_size
;
15269 if (filedata
->is_separate
)
15270 printf (_("\nString dump of section '%s' in linked file %s:\n"),
15271 printable_section_name (filedata
, section
),
15272 filedata
->file_name
);
15274 printf (_("\nString dump of section '%s':\n"),
15275 printable_section_name (filedata
, section
));
15277 if (decompress_dumps
)
15279 uint64_t new_size
= num_bytes
;
15280 uint64_t uncompressed_size
= 0;
15281 bool is_zstd
= false;
15283 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
15285 Elf_Internal_Chdr chdr
;
15286 unsigned int compression_header_size
15287 = get_compression_header (& chdr
, (unsigned char *) start
,
15289 if (compression_header_size
== 0)
15290 /* An error message will have already been generated
15291 by get_compression_header. */
15294 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
15297 else if (chdr
.ch_type
== ELFCOMPRESS_ZSTD
)
15302 warn (_("section '%s' has unsupported compress type: %d\n"),
15303 printable_section_name (filedata
, section
), chdr
.ch_type
);
15306 uncompressed_size
= chdr
.ch_size
;
15307 start
+= compression_header_size
;
15308 new_size
-= compression_header_size
;
15310 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
15312 /* Read the zlib header. In this case, it should be "ZLIB"
15313 followed by the uncompressed section size, 8 bytes in
15314 big-endian order. */
15315 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
15316 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
15317 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
15318 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
15319 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
15320 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
15321 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
15322 uncompressed_size
+= start
[11];
15327 if (uncompressed_size
)
15329 if (uncompress_section_contents (is_zstd
, &start
, uncompressed_size
,
15331 num_bytes
= new_size
;
15334 error (_("Unable to decompress section %s\n"),
15335 printable_section_name (filedata
, section
));
15340 start
= real_start
;
15343 /* If the section being dumped has relocations against it the user might
15344 be expecting these relocations to have been applied. Check for this
15345 case and issue a warning message in order to avoid confusion.
15346 FIXME: Maybe we ought to have an option that dumps a section with
15347 relocs applied ? */
15348 for (relsec
= filedata
->section_headers
;
15349 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
15352 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
15353 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
15354 || filedata
->section_headers
+ relsec
->sh_info
!= section
15355 || relsec
->sh_size
== 0
15356 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
15359 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
15364 end
= start
+ num_bytes
;
15365 some_strings_shown
= false;
15367 #ifdef HAVE_MBSTATE_T
15369 /* Initialise the multibyte conversion state. */
15370 memset (& state
, 0, sizeof (state
));
15373 bool continuing
= false;
15377 while (!ISPRINT (* data
))
15378 if (++ data
>= end
)
15383 size_t maxlen
= end
- data
;
15388 continuing
= false;
15392 printf (" [%6lx] ", (unsigned long) (data
- start
));
15406 /* PR 25543: Treat new-lines as string-ending characters. */
15415 /* Do not print control characters directly as they can affect terminal
15416 settings. Such characters usually appear in the names generated
15417 by the assembler for local labels. */
15420 printf ("^%c", c
+ 0x40);
15422 else if (ISPRINT (c
))
15429 #ifdef HAVE_MBSTATE_T
15432 /* Let printf do the hard work of displaying multibyte characters. */
15433 printf ("%.1s", data
- 1);
15434 #ifdef HAVE_MBSTATE_T
15435 /* Try to find out how many bytes made up the character that was
15436 just printed. Advance the symbol pointer past the bytes that
15438 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
15442 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
15452 printf (_("<corrupt>\n"));
15455 some_strings_shown
= true;
15459 if (! some_strings_shown
)
15460 printf (_(" No strings found in this section."));
15473 dump_section_as_bytes (Elf_Internal_Shdr
*section
,
15474 Filedata
*filedata
,
15477 Elf_Internal_Shdr
*relsec
;
15479 uint64_t section_size
;
15481 unsigned char *data
;
15482 unsigned char *real_start
;
15483 unsigned char *start
;
15485 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
15487 /* PR 21820: Do not fail if the section was empty. */
15488 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
15490 section_size
= section
->sh_size
;
15492 if (filedata
->is_separate
)
15493 printf (_("\nHex dump of section '%s' in linked file %s:\n"),
15494 printable_section_name (filedata
, section
),
15495 filedata
->file_name
);
15497 printf (_("\nHex dump of section '%s':\n"),
15498 printable_section_name (filedata
, section
));
15500 if (decompress_dumps
)
15502 uint64_t new_size
= section_size
;
15503 uint64_t uncompressed_size
= 0;
15504 bool is_zstd
= false;
15506 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
15508 Elf_Internal_Chdr chdr
;
15509 unsigned int compression_header_size
15510 = get_compression_header (& chdr
, start
, section_size
);
15512 if (compression_header_size
== 0)
15513 /* An error message will have already been generated
15514 by get_compression_header. */
15517 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
15520 else if (chdr
.ch_type
== ELFCOMPRESS_ZSTD
)
15525 warn (_("section '%s' has unsupported compress type: %d\n"),
15526 printable_section_name (filedata
, section
), chdr
.ch_type
);
15529 uncompressed_size
= chdr
.ch_size
;
15530 start
+= compression_header_size
;
15531 new_size
-= compression_header_size
;
15533 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
15535 /* Read the zlib header. In this case, it should be "ZLIB"
15536 followed by the uncompressed section size, 8 bytes in
15537 big-endian order. */
15538 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
15539 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
15540 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
15541 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
15542 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
15543 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
15544 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
15545 uncompressed_size
+= start
[11];
15550 if (uncompressed_size
)
15552 if (uncompress_section_contents (is_zstd
, &start
, uncompressed_size
,
15555 section_size
= new_size
;
15559 error (_("Unable to decompress section %s\n"),
15560 printable_section_name (filedata
, section
));
15561 /* FIXME: Print the section anyway ? */
15566 start
= real_start
;
15571 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
15576 /* If the section being dumped has relocations against it the user might
15577 be expecting these relocations to have been applied. Check for this
15578 case and issue a warning message in order to avoid confusion.
15579 FIXME: Maybe we ought to have an option that dumps a section with
15580 relocs applied ? */
15581 for (relsec
= filedata
->section_headers
;
15582 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
15585 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
15586 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
15587 || filedata
->section_headers
+ relsec
->sh_info
!= section
15588 || relsec
->sh_size
== 0
15589 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
15592 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
15597 addr
= section
->sh_addr
;
15598 bytes
= section_size
;
15607 lbytes
= (bytes
> 16 ? 16 : bytes
);
15609 printf (" 0x%8.8lx ", (unsigned long) addr
);
15611 for (j
= 0; j
< 16; j
++)
15614 printf ("%2.2x", data
[j
]);
15622 for (j
= 0; j
< lbytes
; j
++)
15625 if (k
>= ' ' && k
< 0x7f)
15648 #ifdef ENABLE_LIBCTF
15649 static ctf_sect_t
*
15650 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
15652 buf
->cts_name
= section_name_print (filedata
, shdr
);
15653 buf
->cts_size
= shdr
->sh_size
;
15654 buf
->cts_entsize
= shdr
->sh_entsize
;
15659 /* Formatting callback function passed to ctf_dump. Returns either the pointer
15660 it is passed, or a pointer to newly-allocated storage, in which case
15661 dump_ctf() will free it when it no longer needs it. */
15664 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
15665 char *s
, void *arg
)
15667 const char *blanks
= arg
;
15670 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
15675 /* Dump CTF errors/warnings. */
15677 dump_ctf_errs (ctf_dict_t
*fp
)
15679 ctf_next_t
*it
= NULL
;
15684 /* Dump accumulated errors and warnings. */
15685 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
15687 error (_("%s: %s"), is_warning
? _("warning"): _("error"),
15691 if (err
!= ECTF_NEXT_END
)
15692 error (_("CTF error: cannot get CTF errors: `%s'"), ctf_errmsg (err
));
15695 /* Dump one CTF archive member. */
15698 dump_ctf_archive_member (ctf_dict_t
*ctf
, const char *name
, ctf_dict_t
*parent
,
15701 const char *things
[] = {"Header", "Labels", "Data objects",
15702 "Function objects", "Variables", "Types", "Strings",
15704 const char **thing
;
15707 /* Don't print out the name of the default-named archive member if it appears
15708 first in the list. The name .ctf appears everywhere, even for things that
15709 aren't really archives, so printing it out is liable to be confusing; also,
15710 the common case by far is for only one archive member to exist, and hiding
15711 it in that case seems worthwhile. */
15713 if (strcmp (name
, ".ctf") != 0 || member
!= 0)
15714 printf (_("\nCTF archive member: %s:\n"), name
);
15716 if (ctf_parent_name (ctf
) != NULL
)
15717 ctf_import (ctf
, parent
);
15719 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
15721 ctf_dump_state_t
*s
= NULL
;
15724 printf ("\n %s:\n", *thing
);
15725 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
15726 (void *) " ")) != NULL
)
15728 printf ("%s\n", item
);
15732 if (ctf_errno (ctf
))
15734 error (_("Iteration failed: %s, %s\n"), *thing
,
15735 ctf_errmsg (ctf_errno (ctf
)));
15740 dump_ctf_errs (ctf
);
15744 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15746 Elf_Internal_Shdr
* symtab_sec
= NULL
;
15747 Elf_Internal_Shdr
* strtab_sec
= NULL
;
15748 void * data
= NULL
;
15749 void * symdata
= NULL
;
15750 void * strdata
= NULL
;
15751 ctf_sect_t ctfsect
, symsect
, strsect
;
15752 ctf_sect_t
* symsectp
= NULL
;
15753 ctf_sect_t
* strsectp
= NULL
;
15754 ctf_archive_t
* ctfa
= NULL
;
15755 ctf_dict_t
* parent
= NULL
;
15758 ctf_next_t
*i
= NULL
;
15764 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
15765 data
= get_section_contents (section
, filedata
);
15766 ctfsect
.cts_data
= data
;
15768 if (!dump_ctf_symtab_name
)
15769 dump_ctf_symtab_name
= strdup (".dynsym");
15771 if (!dump_ctf_strtab_name
)
15772 dump_ctf_strtab_name
= strdup (".dynstr");
15774 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
15776 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
15778 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
15781 if ((symdata
= (void *) get_data (NULL
, filedata
,
15782 symtab_sec
->sh_offset
, 1,
15783 symtab_sec
->sh_size
,
15784 _("symbols"))) == NULL
)
15786 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
15787 symsect
.cts_data
= symdata
;
15790 if (dump_ctf_strtab_name
&& dump_ctf_strtab_name
[0] != 0)
15792 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
15794 error (_("No string table section named %s\n"),
15795 dump_ctf_strtab_name
);
15798 if ((strdata
= (void *) get_data (NULL
, filedata
,
15799 strtab_sec
->sh_offset
, 1,
15800 strtab_sec
->sh_size
,
15801 _("strings"))) == NULL
)
15803 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
15804 strsect
.cts_data
= strdata
;
15807 /* Load the CTF file and dump it. It may be a raw CTF section, or an archive:
15808 libctf papers over the difference, so we can pretend it is always an
15811 if ((ctfa
= ctf_arc_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
15813 dump_ctf_errs (NULL
);
15814 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15818 ctf_arc_symsect_endianness (ctfa
, filedata
->file_header
.e_ident
[EI_DATA
]
15821 /* Preload the parent dict, since it will need to be imported into every
15823 if ((parent
= ctf_dict_open (ctfa
, dump_ctf_parent_name
, &err
)) == NULL
)
15825 dump_ctf_errs (NULL
);
15826 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15832 if (filedata
->is_separate
)
15833 printf (_("\nDump of CTF section '%s' in linked file %s:\n"),
15834 printable_section_name (filedata
, section
),
15835 filedata
->file_name
);
15837 printf (_("\nDump of CTF section '%s':\n"),
15838 printable_section_name (filedata
, section
));
15840 while ((fp
= ctf_archive_next (ctfa
, &i
, &name
, 0, &err
)) != NULL
)
15841 dump_ctf_archive_member (fp
, name
, parent
, member
++);
15842 if (err
!= ECTF_NEXT_END
)
15844 dump_ctf_errs (NULL
);
15845 error (_("CTF member open failure: %s\n"), ctf_errmsg (err
));
15850 ctf_dict_close (parent
);
15860 load_specific_debug_section (enum dwarf_section_display_enum debug
,
15861 const Elf_Internal_Shdr
* sec
,
15864 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15866 Filedata
* filedata
= (Filedata
*) data
;
15868 if (section
->start
!= NULL
)
15870 /* If it is already loaded, do nothing. */
15871 if (streq (section
->filename
, filedata
->file_name
))
15873 free (section
->start
);
15876 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
15877 section
->address
= sec
->sh_addr
;
15878 section
->filename
= filedata
->file_name
;
15879 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
15881 sec
->sh_size
, buf
);
15882 if (section
->start
== NULL
)
15886 unsigned char *start
= section
->start
;
15887 uint64_t size
= sec
->sh_size
;
15888 uint64_t uncompressed_size
= 0;
15889 bool is_zstd
= false;
15891 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
15893 Elf_Internal_Chdr chdr
;
15894 unsigned int compression_header_size
;
15896 if (size
< (is_32bit_elf
15897 ? sizeof (Elf32_External_Chdr
)
15898 : sizeof (Elf64_External_Chdr
)))
15900 warn (_("compressed section %s is too small to contain a compression header\n"),
15905 compression_header_size
= get_compression_header (&chdr
, start
, size
);
15906 if (compression_header_size
== 0)
15907 /* An error message will have already been generated
15908 by get_compression_header. */
15911 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
15914 else if (chdr
.ch_type
== ELFCOMPRESS_ZSTD
)
15919 warn (_("section '%s' has unsupported compress type: %d\n"),
15920 section
->name
, chdr
.ch_type
);
15923 uncompressed_size
= chdr
.ch_size
;
15924 start
+= compression_header_size
;
15925 size
-= compression_header_size
;
15927 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
15929 /* Read the zlib header. In this case, it should be "ZLIB"
15930 followed by the uncompressed section size, 8 bytes in
15931 big-endian order. */
15932 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
15933 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
15934 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
15935 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
15936 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
15937 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
15938 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
15939 uncompressed_size
+= start
[11];
15944 if (uncompressed_size
)
15946 if (uncompress_section_contents (is_zstd
, &start
, uncompressed_size
,
15949 /* Free the compressed buffer, update the section buffer
15950 and the section size if uncompress is successful. */
15951 free (section
->start
);
15952 section
->start
= start
;
15956 error (_("Unable to decompress section %s\n"),
15957 printable_section_name (filedata
, sec
));
15962 section
->size
= size
;
15965 if (section
->start
== NULL
)
15968 if (debug_displays
[debug
].relocate
)
15970 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
15971 & section
->reloc_info
, & section
->num_relocs
))
15976 section
->reloc_info
= NULL
;
15977 section
->num_relocs
= 0;
15983 #if HAVE_LIBDEBUGINFOD
15984 /* Return a hex string representation of the build-id. */
15986 get_build_id (void * data
)
15988 Filedata
* filedata
= (Filedata
*) data
;
15989 Elf_Internal_Shdr
* shdr
;
15992 /* Iterate through notes to find note.gnu.build-id.
15993 FIXME: Only the first note in any note section is examined. */
15994 for (i
= 0, shdr
= filedata
->section_headers
;
15995 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
15998 if (shdr
->sh_type
!= SHT_NOTE
)
16003 size_t data_remaining
;
16005 Elf_External_Note
* enote
;
16006 Elf_Internal_Note inote
;
16008 uint64_t offset
= shdr
->sh_offset
;
16009 uint64_t align
= shdr
->sh_addralign
;
16010 uint64_t length
= shdr
->sh_size
;
16012 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
16018 else if (align
!= 4 && align
!= 8)
16024 end
= (char *) enote
+ length
;
16025 data_remaining
= end
- (char *) enote
;
16027 if (!is_ia64_vms (filedata
))
16029 min_notesz
= offsetof (Elf_External_Note
, name
);
16030 if (data_remaining
< min_notesz
)
16033 malformed note encountered in section %s whilst scanning for build-id note\n"),
16034 printable_section_name (filedata
, shdr
));
16038 data_remaining
-= min_notesz
;
16040 inote
.type
= BYTE_GET (enote
->type
);
16041 inote
.namesz
= BYTE_GET (enote
->namesz
);
16042 inote
.namedata
= enote
->name
;
16043 inote
.descsz
= BYTE_GET (enote
->descsz
);
16044 inote
.descdata
= ((char *) enote
16045 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
16046 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
16047 next
= ((char *) enote
16048 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
16052 Elf64_External_VMS_Note
*vms_enote
;
16054 /* PR binutils/15191
16055 Make sure that there is enough data to read. */
16056 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
16057 if (data_remaining
< min_notesz
)
16060 malformed note encountered in section %s whilst scanning for build-id note\n"),
16061 printable_section_name (filedata
, shdr
));
16065 data_remaining
-= min_notesz
;
16067 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
16068 inote
.type
= BYTE_GET (vms_enote
->type
);
16069 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
16070 inote
.namedata
= vms_enote
->name
;
16071 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
16072 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
16073 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
16074 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
16077 /* Skip malformed notes. */
16078 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
16079 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
16080 || (size_t) (next
- inote
.descdata
) < inote
.descsz
16081 || ((size_t) (next
- inote
.descdata
)
16082 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
16085 malformed note encountered in section %s whilst scanning for build-id note\n"),
16086 printable_section_name (filedata
, shdr
));
16091 /* Check if this is the build-id note. If so then convert the build-id
16092 bytes to a hex string. */
16093 if (inote
.namesz
> 0
16094 && startswith (inote
.namedata
, "GNU")
16095 && inote
.type
== NT_GNU_BUILD_ID
)
16100 build_id
= malloc (inote
.descsz
* 2 + 1);
16101 if (build_id
== NULL
)
16107 for (j
= 0; j
< inote
.descsz
; ++j
)
16108 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
16109 build_id
[inote
.descsz
* 2] = '\0';
16112 return (unsigned char *) build_id
;
16119 #endif /* HAVE_LIBDEBUGINFOD */
16121 /* If this is not NULL, load_debug_section will only look for sections
16122 within the list of sections given here. */
16123 static unsigned int * section_subset
= NULL
;
16126 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
16128 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
16129 Elf_Internal_Shdr
* sec
;
16130 Filedata
* filedata
= (Filedata
*) data
;
16132 if (!dump_any_debugging
)
16135 /* Without section headers we cannot find any sections. */
16136 if (filedata
->section_headers
== NULL
)
16139 if (filedata
->string_table
== NULL
16140 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
16141 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
16143 Elf_Internal_Shdr
* strs
;
16145 /* Read in the string table, so that we have section names to scan. */
16146 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
16148 if (strs
!= NULL
&& strs
->sh_size
!= 0)
16150 filedata
->string_table
16151 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
16152 1, strs
->sh_size
, _("string table"));
16154 filedata
->string_table_length
16155 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
16159 /* Locate the debug section. */
16160 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
16162 section
->name
= section
->uncompressed_name
;
16165 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
16167 section
->name
= section
->compressed_name
;
16172 /* If we're loading from a subset of sections, and we've loaded
16173 a section matching this name before, it's likely that it's a
16175 if (section_subset
!= NULL
)
16176 free_debug_section (debug
);
16178 return load_specific_debug_section (debug
, sec
, data
);
16182 free_debug_section (enum dwarf_section_display_enum debug
)
16184 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
16186 if (section
->start
== NULL
)
16189 free ((char *) section
->start
);
16190 section
->start
= NULL
;
16191 section
->address
= 0;
16194 free (section
->reloc_info
);
16195 section
->reloc_info
= NULL
;
16196 section
->num_relocs
= 0;
16200 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
16202 const char *name
= (section_name_valid (filedata
, section
)
16203 ? section_name (filedata
, section
) : "");
16204 const char *print_name
= printable_section_name (filedata
, section
);
16206 bool result
= true;
16209 length
= section
->sh_size
;
16212 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
16215 if (section
->sh_type
== SHT_NOBITS
)
16217 /* There is no point in dumping the contents of a debugging section
16218 which has the NOBITS type - the bits in the file will be random.
16219 This can happen when a file containing a .eh_frame section is
16220 stripped with the --only-keep-debug command line option. */
16221 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
16226 if (startswith (name
, ".gnu.linkonce.wi."))
16227 name
= ".debug_info";
16229 /* See if we know how to display the contents of this section. */
16230 for (i
= 0; i
< max
; i
++)
16232 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
16233 struct dwarf_section_display
* display
= debug_displays
+ i
;
16234 struct dwarf_section
* sec
= & display
->section
;
16236 if (streq (sec
->uncompressed_name
, name
)
16237 || (id
== line
&& startswith (name
, ".debug_line."))
16238 || streq (sec
->compressed_name
, name
))
16240 bool secondary
= (section
!= find_section (filedata
, name
));
16243 free_debug_section (id
);
16245 if (i
== line
&& startswith (name
, ".debug_line."))
16247 else if (streq (sec
->uncompressed_name
, name
))
16248 sec
->name
= sec
->uncompressed_name
;
16250 sec
->name
= sec
->compressed_name
;
16252 if (load_specific_debug_section (id
, section
, filedata
))
16254 /* If this debug section is part of a CU/TU set in a .dwp file,
16255 restrict load_debug_section to the sections in that set. */
16256 section_subset
= find_cu_tu_set (filedata
, shndx
);
16258 result
&= display
->display (sec
, filedata
);
16260 section_subset
= NULL
;
16262 if (secondary
|| (id
!= info
&& id
!= abbrev
&& id
!= debug_addr
))
16263 free_debug_section (id
);
16271 printf (_("Unrecognized debug section: %s\n"), print_name
);
16278 /* Set DUMP_SECTS for all sections where dumps were requested
16279 based on section name. */
16282 initialise_dumps_byname (Filedata
* filedata
)
16284 struct dump_list_entry
* cur
;
16286 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
16291 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
16292 if (section_name_valid (filedata
, filedata
->section_headers
+ i
)
16293 && streq (section_name (filedata
, filedata
->section_headers
+ i
),
16296 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
16300 if (!any
&& !filedata
->is_separate
)
16301 warn (_("Section '%s' was not dumped because it does not exist\n"),
16307 process_section_contents (Filedata
* filedata
)
16309 Elf_Internal_Shdr
* section
;
16316 initialise_dumps_byname (filedata
);
16318 for (i
= 0, section
= filedata
->section_headers
;
16319 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
16322 dump_type dump
= filedata
->dump
.dump_sects
[i
];
16324 if (filedata
->is_separate
&& ! process_links
)
16325 dump
&= DEBUG_DUMP
;
16327 #ifdef SUPPORT_DISASSEMBLY
16328 if (dump
& DISASS_DUMP
)
16330 if (! disassemble_section (section
, filedata
))
16334 if (dump
& HEX_DUMP
)
16336 if (! dump_section_as_bytes (section
, filedata
, false))
16340 if (dump
& RELOC_DUMP
)
16342 if (! dump_section_as_bytes (section
, filedata
, true))
16346 if (dump
& STRING_DUMP
)
16348 if (! dump_section_as_strings (section
, filedata
))
16352 if (dump
& DEBUG_DUMP
)
16354 if (! display_debug_section (i
, section
, filedata
))
16358 #ifdef ENABLE_LIBCTF
16359 if (dump
& CTF_DUMP
)
16361 if (! dump_section_as_ctf (section
, filedata
))
16367 if (! filedata
->is_separate
)
16369 /* Check to see if the user requested a
16370 dump of a section that does not exist. */
16371 for (; i
< filedata
->dump
.num_dump_sects
; i
++)
16372 if (filedata
->dump
.dump_sects
[i
])
16374 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
16383 process_mips_fpe_exception (int mask
)
16389 if (mask
& OEX_FPU_INEX
)
16390 fputs ("INEX", stdout
), first
= false;
16391 if (mask
& OEX_FPU_UFLO
)
16392 printf ("%sUFLO", first
? "" : "|"), first
= false;
16393 if (mask
& OEX_FPU_OFLO
)
16394 printf ("%sOFLO", first
? "" : "|"), first
= false;
16395 if (mask
& OEX_FPU_DIV0
)
16396 printf ("%sDIV0", first
? "" : "|"), first
= false;
16397 if (mask
& OEX_FPU_INVAL
)
16398 printf ("%sINVAL", first
? "" : "|");
16401 fputs ("0", stdout
);
16404 /* Display's the value of TAG at location P. If TAG is
16405 greater than 0 it is assumed to be an unknown tag, and
16406 a message is printed to this effect. Otherwise it is
16407 assumed that a message has already been printed.
16409 If the bottom bit of TAG is set it assumed to have a
16410 string value, otherwise it is assumed to have an integer
16413 Returns an updated P pointing to the first unread byte
16414 beyond the end of TAG's value.
16416 Reads at or beyond END will not be made. */
16418 static unsigned char *
16419 display_tag_value (signed int tag
,
16421 const unsigned char * const end
)
16426 printf (" Tag_unknown_%d: ", tag
);
16430 warn (_("<corrupt tag>\n"));
16434 /* PR 17531 file: 027-19978-0.004. */
16435 size_t maxlen
= (end
- p
) - 1;
16440 print_symbol ((int) maxlen
, (const char *) p
);
16441 p
+= strnlen ((char *) p
, maxlen
) + 1;
16445 printf (_("<corrupt string tag>"));
16446 p
= (unsigned char *) end
;
16452 READ_ULEB (val
, p
, end
);
16453 printf ("%ld (0x%lx)\n", val
, val
);
16460 /* ARC ABI attributes section. */
16462 static unsigned char *
16463 display_arc_attribute (unsigned char * p
,
16464 const unsigned char * const end
)
16469 READ_ULEB (tag
, p
, end
);
16473 case Tag_ARC_PCS_config
:
16474 READ_ULEB (val
, p
, end
);
16475 printf (" Tag_ARC_PCS_config: ");
16479 printf (_("Absent/Non standard\n"));
16482 printf (_("Bare metal/mwdt\n"));
16485 printf (_("Bare metal/newlib\n"));
16488 printf (_("Linux/uclibc\n"));
16491 printf (_("Linux/glibc\n"));
16494 printf (_("Unknown\n"));
16499 case Tag_ARC_CPU_base
:
16500 READ_ULEB (val
, p
, end
);
16501 printf (" Tag_ARC_CPU_base: ");
16506 printf (_("Absent\n"));
16508 case TAG_CPU_ARC6xx
:
16509 printf ("ARC6xx\n");
16511 case TAG_CPU_ARC7xx
:
16512 printf ("ARC7xx\n");
16514 case TAG_CPU_ARCEM
:
16515 printf ("ARCEM\n");
16517 case TAG_CPU_ARCHS
:
16518 printf ("ARCHS\n");
16523 case Tag_ARC_CPU_variation
:
16524 READ_ULEB (val
, p
, end
);
16525 printf (" Tag_ARC_CPU_variation: ");
16529 if (val
> 0 && val
< 16)
16530 printf ("Core%d\n", val
);
16532 printf ("Unknown\n");
16536 printf (_("Absent\n"));
16541 case Tag_ARC_CPU_name
:
16542 printf (" Tag_ARC_CPU_name: ");
16543 p
= display_tag_value (-1, p
, end
);
16546 case Tag_ARC_ABI_rf16
:
16547 READ_ULEB (val
, p
, end
);
16548 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
16551 case Tag_ARC_ABI_osver
:
16552 READ_ULEB (val
, p
, end
);
16553 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
16556 case Tag_ARC_ABI_pic
:
16557 case Tag_ARC_ABI_sda
:
16558 READ_ULEB (val
, p
, end
);
16559 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
16560 : " Tag_ARC_ABI_pic: ");
16564 printf (_("Absent\n"));
16573 printf (_("Unknown\n"));
16578 case Tag_ARC_ABI_tls
:
16579 READ_ULEB (val
, p
, end
);
16580 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
16583 case Tag_ARC_ABI_enumsize
:
16584 READ_ULEB (val
, p
, end
);
16585 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
16589 case Tag_ARC_ABI_exceptions
:
16590 READ_ULEB (val
, p
, end
);
16591 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
16595 case Tag_ARC_ABI_double_size
:
16596 READ_ULEB (val
, p
, end
);
16597 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
16600 case Tag_ARC_ISA_config
:
16601 printf (" Tag_ARC_ISA_config: ");
16602 p
= display_tag_value (-1, p
, end
);
16605 case Tag_ARC_ISA_apex
:
16606 printf (" Tag_ARC_ISA_apex: ");
16607 p
= display_tag_value (-1, p
, end
);
16610 case Tag_ARC_ISA_mpy_option
:
16611 READ_ULEB (val
, p
, end
);
16612 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
16615 case Tag_ARC_ATR_version
:
16616 READ_ULEB (val
, p
, end
);
16617 printf (" Tag_ARC_ATR_version: %d\n", val
);
16621 return display_tag_value (tag
& 1, p
, end
);
16627 /* ARM EABI attributes section. */
16632 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
16634 const char *const *table
;
16635 } arm_attr_public_tag
;
16637 static const char *const arm_attr_tag_CPU_arch
[] =
16638 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
16639 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
16640 "v8-M.mainline", "v8.1-A", "v8.2-A", "v8.3-A",
16641 "v8.1-M.mainline", "v9"};
16642 static const char *const arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
16643 static const char *const arm_attr_tag_THUMB_ISA_use
[] =
16644 {"No", "Thumb-1", "Thumb-2", "Yes"};
16645 static const char *const arm_attr_tag_FP_arch
[] =
16646 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
16647 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
16648 static const char *const arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
16649 static const char *const arm_attr_tag_Advanced_SIMD_arch
[] =
16650 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
16651 "NEON for ARMv8.1"};
16652 static const char *const arm_attr_tag_PCS_config
[] =
16653 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
16654 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
16655 static const char *const arm_attr_tag_ABI_PCS_R9_use
[] =
16656 {"V6", "SB", "TLS", "Unused"};
16657 static const char *const arm_attr_tag_ABI_PCS_RW_data
[] =
16658 {"Absolute", "PC-relative", "SB-relative", "None"};
16659 static const char *const arm_attr_tag_ABI_PCS_RO_data
[] =
16660 {"Absolute", "PC-relative", "None"};
16661 static const char *const arm_attr_tag_ABI_PCS_GOT_use
[] =
16662 {"None", "direct", "GOT-indirect"};
16663 static const char *const arm_attr_tag_ABI_PCS_wchar_t
[] =
16664 {"None", "??? 1", "2", "??? 3", "4"};
16665 static const char *const arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
16666 static const char *const arm_attr_tag_ABI_FP_denormal
[] =
16667 {"Unused", "Needed", "Sign only"};
16668 static const char *const arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
16669 static const char *const arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
16670 static const char *const arm_attr_tag_ABI_FP_number_model
[] =
16671 {"Unused", "Finite", "RTABI", "IEEE 754"};
16672 static const char *const arm_attr_tag_ABI_enum_size
[] =
16673 {"Unused", "small", "int", "forced to int"};
16674 static const char *const arm_attr_tag_ABI_HardFP_use
[] =
16675 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
16676 static const char *const arm_attr_tag_ABI_VFP_args
[] =
16677 {"AAPCS", "VFP registers", "custom", "compatible"};
16678 static const char *const arm_attr_tag_ABI_WMMX_args
[] =
16679 {"AAPCS", "WMMX registers", "custom"};
16680 static const char *const arm_attr_tag_ABI_optimization_goals
[] =
16681 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
16682 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
16683 static const char *const arm_attr_tag_ABI_FP_optimization_goals
[] =
16684 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
16685 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
16686 static const char *const arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
16687 static const char *const arm_attr_tag_FP_HP_extension
[] =
16688 {"Not Allowed", "Allowed"};
16689 static const char *const arm_attr_tag_ABI_FP_16bit_format
[] =
16690 {"None", "IEEE 754", "Alternative Format"};
16691 static const char *const arm_attr_tag_DSP_extension
[] =
16692 {"Follow architecture", "Allowed"};
16693 static const char *const arm_attr_tag_MPextension_use
[] =
16694 {"Not Allowed", "Allowed"};
16695 static const char *const arm_attr_tag_DIV_use
[] =
16696 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
16697 "Allowed in v7-A with integer division extension"};
16698 static const char *const arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
16699 static const char *const arm_attr_tag_Virtualization_use
[] =
16700 {"Not Allowed", "TrustZone", "Virtualization Extensions",
16701 "TrustZone and Virtualization Extensions"};
16702 static const char *const arm_attr_tag_MPextension_use_legacy
[] =
16703 {"Not Allowed", "Allowed"};
16705 static const char *const arm_attr_tag_MVE_arch
[] =
16706 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
16708 static const char * arm_attr_tag_PAC_extension
[] =
16709 {"No PAC/AUT instructions",
16710 "PAC/AUT instructions permitted in the NOP space",
16711 "PAC/AUT instructions permitted in the NOP and in the non-NOP space"};
16713 static const char * arm_attr_tag_BTI_extension
[] =
16714 {"BTI instructions not permitted",
16715 "BTI instructions permitted in the NOP space",
16716 "BTI instructions permitted in the NOP and in the non-NOP space"};
16718 static const char * arm_attr_tag_BTI_use
[] =
16719 {"Compiled without branch target enforcement",
16720 "Compiled with branch target enforcement"};
16722 static const char * arm_attr_tag_PACRET_use
[] =
16723 {"Compiled without return address signing and authentication",
16724 "Compiled with return address signing and authentication"};
16726 #define LOOKUP(id, name) \
16727 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
16728 static arm_attr_public_tag arm_attr_public_tags
[] =
16730 {4, "CPU_raw_name", 1, NULL
},
16731 {5, "CPU_name", 1, NULL
},
16732 LOOKUP(6, CPU_arch
),
16733 {7, "CPU_arch_profile", 0, NULL
},
16734 LOOKUP(8, ARM_ISA_use
),
16735 LOOKUP(9, THUMB_ISA_use
),
16736 LOOKUP(10, FP_arch
),
16737 LOOKUP(11, WMMX_arch
),
16738 LOOKUP(12, Advanced_SIMD_arch
),
16739 LOOKUP(13, PCS_config
),
16740 LOOKUP(14, ABI_PCS_R9_use
),
16741 LOOKUP(15, ABI_PCS_RW_data
),
16742 LOOKUP(16, ABI_PCS_RO_data
),
16743 LOOKUP(17, ABI_PCS_GOT_use
),
16744 LOOKUP(18, ABI_PCS_wchar_t
),
16745 LOOKUP(19, ABI_FP_rounding
),
16746 LOOKUP(20, ABI_FP_denormal
),
16747 LOOKUP(21, ABI_FP_exceptions
),
16748 LOOKUP(22, ABI_FP_user_exceptions
),
16749 LOOKUP(23, ABI_FP_number_model
),
16750 {24, "ABI_align_needed", 0, NULL
},
16751 {25, "ABI_align_preserved", 0, NULL
},
16752 LOOKUP(26, ABI_enum_size
),
16753 LOOKUP(27, ABI_HardFP_use
),
16754 LOOKUP(28, ABI_VFP_args
),
16755 LOOKUP(29, ABI_WMMX_args
),
16756 LOOKUP(30, ABI_optimization_goals
),
16757 LOOKUP(31, ABI_FP_optimization_goals
),
16758 {32, "compatibility", 0, NULL
},
16759 LOOKUP(34, CPU_unaligned_access
),
16760 LOOKUP(36, FP_HP_extension
),
16761 LOOKUP(38, ABI_FP_16bit_format
),
16762 LOOKUP(42, MPextension_use
),
16763 LOOKUP(44, DIV_use
),
16764 LOOKUP(46, DSP_extension
),
16765 LOOKUP(48, MVE_arch
),
16766 LOOKUP(50, PAC_extension
),
16767 LOOKUP(52, BTI_extension
),
16768 LOOKUP(74, BTI_use
),
16769 LOOKUP(76, PACRET_use
),
16770 {64, "nodefaults", 0, NULL
},
16771 {65, "also_compatible_with", 0, NULL
},
16772 LOOKUP(66, T2EE_use
),
16773 {67, "conformance", 1, NULL
},
16774 LOOKUP(68, Virtualization_use
),
16775 LOOKUP(70, MPextension_use_legacy
)
16779 static unsigned char *
16780 display_arm_attribute (unsigned char * p
,
16781 const unsigned char * const end
)
16785 arm_attr_public_tag
* attr
;
16789 READ_ULEB (tag
, p
, end
);
16791 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
16793 if (arm_attr_public_tags
[i
].tag
== tag
)
16795 attr
= &arm_attr_public_tags
[i
];
16802 printf (" Tag_%s: ", attr
->name
);
16803 switch (attr
->type
)
16808 case 7: /* Tag_CPU_arch_profile. */
16809 READ_ULEB (val
, p
, end
);
16812 case 0: printf (_("None\n")); break;
16813 case 'A': printf (_("Application\n")); break;
16814 case 'R': printf (_("Realtime\n")); break;
16815 case 'M': printf (_("Microcontroller\n")); break;
16816 case 'S': printf (_("Application or Realtime\n")); break;
16817 default: printf ("??? (%d)\n", val
); break;
16821 case 24: /* Tag_align_needed. */
16822 READ_ULEB (val
, p
, end
);
16825 case 0: printf (_("None\n")); break;
16826 case 1: printf (_("8-byte\n")); break;
16827 case 2: printf (_("4-byte\n")); break;
16828 case 3: printf ("??? 3\n"); break;
16831 printf (_("8-byte and up to %d-byte extended\n"),
16834 printf ("??? (%d)\n", val
);
16839 case 25: /* Tag_align_preserved. */
16840 READ_ULEB (val
, p
, end
);
16843 case 0: printf (_("None\n")); break;
16844 case 1: printf (_("8-byte, except leaf SP\n")); break;
16845 case 2: printf (_("8-byte\n")); break;
16846 case 3: printf ("??? 3\n"); break;
16849 printf (_("8-byte and up to %d-byte extended\n"),
16852 printf ("??? (%d)\n", val
);
16857 case 32: /* Tag_compatibility. */
16859 READ_ULEB (val
, p
, end
);
16860 printf (_("flag = %d, vendor = "), val
);
16863 size_t maxlen
= (end
- p
) - 1;
16865 print_symbol ((int) maxlen
, (const char *) p
);
16866 p
+= strnlen ((char *) p
, maxlen
) + 1;
16870 printf (_("<corrupt>"));
16871 p
= (unsigned char *) end
;
16877 case 64: /* Tag_nodefaults. */
16878 /* PR 17531: file: 001-505008-0.01. */
16881 printf (_("True\n"));
16884 case 65: /* Tag_also_compatible_with. */
16885 READ_ULEB (val
, p
, end
);
16886 if (val
== 6 /* Tag_CPU_arch. */)
16888 READ_ULEB (val
, p
, end
);
16889 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
16890 printf ("??? (%d)\n", val
);
16892 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
16896 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
16901 printf (_("<unknown: %d>\n"), tag
);
16907 return display_tag_value (-1, p
, end
);
16909 return display_tag_value (0, p
, end
);
16912 assert (attr
->type
& 0x80);
16913 READ_ULEB (val
, p
, end
);
16914 type
= attr
->type
& 0x7f;
16916 printf ("??? (%d)\n", val
);
16918 printf ("%s\n", attr
->table
[val
]);
16923 return display_tag_value (tag
, p
, end
);
16926 static unsigned char *
16927 display_gnu_attribute (unsigned char * p
,
16928 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
16929 const unsigned char * const end
)
16934 READ_ULEB (tag
, p
, end
);
16936 /* Tag_compatibility is the only generic GNU attribute defined at
16940 READ_ULEB (val
, p
, end
);
16942 printf (_("flag = %d, vendor = "), val
);
16945 printf (_("<corrupt>\n"));
16946 warn (_("corrupt vendor attribute\n"));
16952 size_t maxlen
= (end
- p
) - 1;
16954 print_symbol ((int) maxlen
, (const char *) p
);
16955 p
+= strnlen ((char *) p
, maxlen
) + 1;
16959 printf (_("<corrupt>"));
16960 p
= (unsigned char *) end
;
16967 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
16968 return display_proc_gnu_attribute (p
, tag
, end
);
16970 return display_tag_value (tag
, p
, end
);
16973 static unsigned char *
16974 display_m68k_gnu_attribute (unsigned char * p
,
16976 const unsigned char * const end
)
16980 if (tag
== Tag_GNU_M68K_ABI_FP
)
16982 printf (" Tag_GNU_M68K_ABI_FP: ");
16985 printf (_("<corrupt>\n"));
16988 READ_ULEB (val
, p
, end
);
16991 printf ("(%#x), ", val
);
16996 printf (_("unspecified hard/soft float\n"));
16999 printf (_("hard float\n"));
17002 printf (_("soft float\n"));
17008 return display_tag_value (tag
& 1, p
, end
);
17011 static unsigned char *
17012 display_power_gnu_attribute (unsigned char * p
,
17014 const unsigned char * const end
)
17018 if (tag
== Tag_GNU_Power_ABI_FP
)
17020 printf (" Tag_GNU_Power_ABI_FP: ");
17023 printf (_("<corrupt>\n"));
17026 READ_ULEB (val
, p
, end
);
17029 printf ("(%#x), ", val
);
17034 printf (_("unspecified hard/soft float, "));
17037 printf (_("hard float, "));
17040 printf (_("soft float, "));
17043 printf (_("single-precision hard float, "));
17050 printf (_("unspecified long double\n"));
17053 printf (_("128-bit IBM long double\n"));
17056 printf (_("64-bit long double\n"));
17059 printf (_("128-bit IEEE long double\n"));
17065 if (tag
== Tag_GNU_Power_ABI_Vector
)
17067 printf (" Tag_GNU_Power_ABI_Vector: ");
17070 printf (_("<corrupt>\n"));
17073 READ_ULEB (val
, p
, end
);
17076 printf ("(%#x), ", val
);
17081 printf (_("unspecified\n"));
17084 printf (_("generic\n"));
17087 printf ("AltiVec\n");
17096 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
17098 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
17101 printf (_("<corrupt>\n"));
17104 READ_ULEB (val
, p
, end
);
17107 printf ("(%#x), ", val
);
17112 printf (_("unspecified\n"));
17115 printf ("r3/r4\n");
17118 printf (_("memory\n"));
17127 return display_tag_value (tag
& 1, p
, end
);
17130 static unsigned char *
17131 display_s390_gnu_attribute (unsigned char * p
,
17133 const unsigned char * const end
)
17137 if (tag
== Tag_GNU_S390_ABI_Vector
)
17139 printf (" Tag_GNU_S390_ABI_Vector: ");
17140 READ_ULEB (val
, p
, end
);
17145 printf (_("any\n"));
17148 printf (_("software\n"));
17151 printf (_("hardware\n"));
17154 printf ("??? (%d)\n", val
);
17160 return display_tag_value (tag
& 1, p
, end
);
17164 display_sparc_hwcaps (unsigned int mask
)
17170 if (mask
& ELF_SPARC_HWCAP_MUL32
)
17171 fputs ("mul32", stdout
), first
= false;
17172 if (mask
& ELF_SPARC_HWCAP_DIV32
)
17173 printf ("%sdiv32", first
? "" : "|"), first
= false;
17174 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
17175 printf ("%sfsmuld", first
? "" : "|"), first
= false;
17176 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
17177 printf ("%sv8plus", first
? "" : "|"), first
= false;
17178 if (mask
& ELF_SPARC_HWCAP_POPC
)
17179 printf ("%spopc", first
? "" : "|"), first
= false;
17180 if (mask
& ELF_SPARC_HWCAP_VIS
)
17181 printf ("%svis", first
? "" : "|"), first
= false;
17182 if (mask
& ELF_SPARC_HWCAP_VIS2
)
17183 printf ("%svis2", first
? "" : "|"), first
= false;
17184 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
17185 printf ("%sASIBlkInit", first
? "" : "|"), first
= false;
17186 if (mask
& ELF_SPARC_HWCAP_FMAF
)
17187 printf ("%sfmaf", first
? "" : "|"), first
= false;
17188 if (mask
& ELF_SPARC_HWCAP_VIS3
)
17189 printf ("%svis3", first
? "" : "|"), first
= false;
17190 if (mask
& ELF_SPARC_HWCAP_HPC
)
17191 printf ("%shpc", first
? "" : "|"), first
= false;
17192 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
17193 printf ("%srandom", first
? "" : "|"), first
= false;
17194 if (mask
& ELF_SPARC_HWCAP_TRANS
)
17195 printf ("%strans", first
? "" : "|"), first
= false;
17196 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
17197 printf ("%sfjfmau", first
? "" : "|"), first
= false;
17198 if (mask
& ELF_SPARC_HWCAP_IMA
)
17199 printf ("%sima", first
? "" : "|"), first
= false;
17200 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
17201 printf ("%scspare", first
? "" : "|"), first
= false;
17204 fputc ('0', stdout
);
17205 fputc ('\n', stdout
);
17209 display_sparc_hwcaps2 (unsigned int mask
)
17215 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
17216 fputs ("fjathplus", stdout
), first
= false;
17217 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
17218 printf ("%svis3b", first
? "" : "|"), first
= false;
17219 if (mask
& ELF_SPARC_HWCAP2_ADP
)
17220 printf ("%sadp", first
? "" : "|"), first
= false;
17221 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
17222 printf ("%ssparc5", first
? "" : "|"), first
= false;
17223 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
17224 printf ("%smwait", first
? "" : "|"), first
= false;
17225 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
17226 printf ("%sxmpmul", first
? "" : "|"), first
= false;
17227 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
17228 printf ("%sxmont2", first
? "" : "|"), first
= false;
17229 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
17230 printf ("%snsec", first
? "" : "|"), first
= false;
17231 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
17232 printf ("%sfjathhpc", first
? "" : "|"), first
= false;
17233 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
17234 printf ("%sfjdes", first
? "" : "|"), first
= false;
17235 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
17236 printf ("%sfjaes", first
? "" : "|"), first
= false;
17239 fputc ('0', stdout
);
17240 fputc ('\n', stdout
);
17243 static unsigned char *
17244 display_sparc_gnu_attribute (unsigned char * p
,
17246 const unsigned char * const end
)
17250 if (tag
== Tag_GNU_Sparc_HWCAPS
)
17252 READ_ULEB (val
, p
, end
);
17253 printf (" Tag_GNU_Sparc_HWCAPS: ");
17254 display_sparc_hwcaps (val
);
17257 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
17259 READ_ULEB (val
, p
, end
);
17260 printf (" Tag_GNU_Sparc_HWCAPS2: ");
17261 display_sparc_hwcaps2 (val
);
17265 return display_tag_value (tag
, p
, end
);
17269 print_mips_fp_abi_value (unsigned int val
)
17273 case Val_GNU_MIPS_ABI_FP_ANY
:
17274 printf (_("Hard or soft float\n"));
17276 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
17277 printf (_("Hard float (double precision)\n"));
17279 case Val_GNU_MIPS_ABI_FP_SINGLE
:
17280 printf (_("Hard float (single precision)\n"));
17282 case Val_GNU_MIPS_ABI_FP_SOFT
:
17283 printf (_("Soft float\n"));
17285 case Val_GNU_MIPS_ABI_FP_OLD_64
:
17286 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
17288 case Val_GNU_MIPS_ABI_FP_XX
:
17289 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
17291 case Val_GNU_MIPS_ABI_FP_64
:
17292 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
17294 case Val_GNU_MIPS_ABI_FP_64A
:
17295 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
17297 case Val_GNU_MIPS_ABI_FP_NAN2008
:
17298 printf (_("NaN 2008 compatibility\n"));
17301 printf ("??? (%d)\n", val
);
17306 static unsigned char *
17307 display_mips_gnu_attribute (unsigned char * p
,
17309 const unsigned char * const end
)
17311 if (tag
== Tag_GNU_MIPS_ABI_FP
)
17315 printf (" Tag_GNU_MIPS_ABI_FP: ");
17316 READ_ULEB (val
, p
, end
);
17317 print_mips_fp_abi_value (val
);
17321 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
17325 printf (" Tag_GNU_MIPS_ABI_MSA: ");
17326 READ_ULEB (val
, p
, end
);
17330 case Val_GNU_MIPS_ABI_MSA_ANY
:
17331 printf (_("Any MSA or not\n"));
17333 case Val_GNU_MIPS_ABI_MSA_128
:
17334 printf (_("128-bit MSA\n"));
17337 printf ("??? (%d)\n", val
);
17343 return display_tag_value (tag
& 1, p
, end
);
17346 static unsigned char *
17347 display_tic6x_attribute (unsigned char * p
,
17348 const unsigned char * const end
)
17353 READ_ULEB (tag
, p
, end
);
17358 printf (" Tag_ISA: ");
17359 READ_ULEB (val
, p
, end
);
17363 case C6XABI_Tag_ISA_none
:
17364 printf (_("None\n"));
17366 case C6XABI_Tag_ISA_C62X
:
17369 case C6XABI_Tag_ISA_C67X
:
17372 case C6XABI_Tag_ISA_C67XP
:
17373 printf ("C67x+\n");
17375 case C6XABI_Tag_ISA_C64X
:
17378 case C6XABI_Tag_ISA_C64XP
:
17379 printf ("C64x+\n");
17381 case C6XABI_Tag_ISA_C674X
:
17382 printf ("C674x\n");
17385 printf ("??? (%d)\n", val
);
17390 case Tag_ABI_wchar_t
:
17391 printf (" Tag_ABI_wchar_t: ");
17392 READ_ULEB (val
, p
, end
);
17396 printf (_("Not used\n"));
17399 printf (_("2 bytes\n"));
17402 printf (_("4 bytes\n"));
17405 printf ("??? (%d)\n", val
);
17410 case Tag_ABI_stack_align_needed
:
17411 printf (" Tag_ABI_stack_align_needed: ");
17412 READ_ULEB (val
, p
, end
);
17416 printf (_("8-byte\n"));
17419 printf (_("16-byte\n"));
17422 printf ("??? (%d)\n", val
);
17427 case Tag_ABI_stack_align_preserved
:
17428 READ_ULEB (val
, p
, end
);
17429 printf (" Tag_ABI_stack_align_preserved: ");
17433 printf (_("8-byte\n"));
17436 printf (_("16-byte\n"));
17439 printf ("??? (%d)\n", val
);
17445 READ_ULEB (val
, p
, end
);
17446 printf (" Tag_ABI_DSBT: ");
17450 printf (_("DSBT addressing not used\n"));
17453 printf (_("DSBT addressing used\n"));
17456 printf ("??? (%d)\n", val
);
17462 READ_ULEB (val
, p
, end
);
17463 printf (" Tag_ABI_PID: ");
17467 printf (_("Data addressing position-dependent\n"));
17470 printf (_("Data addressing position-independent, GOT near DP\n"));
17473 printf (_("Data addressing position-independent, GOT far from DP\n"));
17476 printf ("??? (%d)\n", val
);
17482 READ_ULEB (val
, p
, end
);
17483 printf (" Tag_ABI_PIC: ");
17487 printf (_("Code addressing position-dependent\n"));
17490 printf (_("Code addressing position-independent\n"));
17493 printf ("??? (%d)\n", val
);
17498 case Tag_ABI_array_object_alignment
:
17499 READ_ULEB (val
, p
, end
);
17500 printf (" Tag_ABI_array_object_alignment: ");
17504 printf (_("8-byte\n"));
17507 printf (_("4-byte\n"));
17510 printf (_("16-byte\n"));
17513 printf ("??? (%d)\n", val
);
17518 case Tag_ABI_array_object_align_expected
:
17519 READ_ULEB (val
, p
, end
);
17520 printf (" Tag_ABI_array_object_align_expected: ");
17524 printf (_("8-byte\n"));
17527 printf (_("4-byte\n"));
17530 printf (_("16-byte\n"));
17533 printf ("??? (%d)\n", val
);
17538 case Tag_ABI_compatibility
:
17540 READ_ULEB (val
, p
, end
);
17541 printf (" Tag_ABI_compatibility: ");
17542 printf (_("flag = %d, vendor = "), val
);
17545 size_t maxlen
= (end
- p
) - 1;
17547 print_symbol ((int) maxlen
, (const char *) p
);
17548 p
+= strnlen ((char *) p
, maxlen
) + 1;
17552 printf (_("<corrupt>"));
17553 p
= (unsigned char *) end
;
17559 case Tag_ABI_conformance
:
17561 printf (" Tag_ABI_conformance: \"");
17564 size_t maxlen
= (end
- p
) - 1;
17566 print_symbol ((int) maxlen
, (const char *) p
);
17567 p
+= strnlen ((char *) p
, maxlen
) + 1;
17571 printf (_("<corrupt>"));
17572 p
= (unsigned char *) end
;
17579 return display_tag_value (tag
, p
, end
);
17583 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
17585 unsigned long addr
= 0;
17586 size_t bytes
= end
- p
;
17593 int lbytes
= (bytes
> 16 ? 16 : bytes
);
17595 printf (" 0x%8.8lx ", addr
);
17597 for (j
= 0; j
< 16; j
++)
17600 printf ("%2.2x", p
[j
]);
17608 for (j
= 0; j
< lbytes
; j
++)
17611 if (k
>= ' ' && k
< 0x7f)
17627 static unsigned char *
17628 display_msp430_attribute (unsigned char * p
,
17629 const unsigned char * const end
)
17634 READ_ULEB (tag
, p
, end
);
17638 case OFBA_MSPABI_Tag_ISA
:
17639 printf (" Tag_ISA: ");
17640 READ_ULEB (val
, p
, end
);
17643 case 0: printf (_("None\n")); break;
17644 case 1: printf (_("MSP430\n")); break;
17645 case 2: printf (_("MSP430X\n")); break;
17646 default: printf ("??? (%d)\n", val
); break;
17650 case OFBA_MSPABI_Tag_Code_Model
:
17651 printf (" Tag_Code_Model: ");
17652 READ_ULEB (val
, p
, end
);
17655 case 0: printf (_("None\n")); break;
17656 case 1: printf (_("Small\n")); break;
17657 case 2: printf (_("Large\n")); break;
17658 default: printf ("??? (%d)\n", val
); break;
17662 case OFBA_MSPABI_Tag_Data_Model
:
17663 printf (" Tag_Data_Model: ");
17664 READ_ULEB (val
, p
, end
);
17667 case 0: printf (_("None\n")); break;
17668 case 1: printf (_("Small\n")); break;
17669 case 2: printf (_("Large\n")); break;
17670 case 3: printf (_("Restricted Large\n")); break;
17671 default: printf ("??? (%d)\n", val
); break;
17676 printf (_(" <unknown tag %d>: "), tag
);
17683 size_t maxlen
= (end
- p
) - 1;
17685 print_symbol ((int) maxlen
, (const char *) p
);
17686 p
+= strnlen ((char *) p
, maxlen
) + 1;
17690 printf (_("<corrupt>"));
17691 p
= (unsigned char *) end
;
17697 READ_ULEB (val
, p
, end
);
17698 printf ("%d (0x%x)\n", val
, val
);
17707 static unsigned char *
17708 display_msp430_gnu_attribute (unsigned char * p
,
17710 const unsigned char * const end
)
17712 if (tag
== Tag_GNU_MSP430_Data_Region
)
17716 printf (" Tag_GNU_MSP430_Data_Region: ");
17717 READ_ULEB (val
, p
, end
);
17721 case Val_GNU_MSP430_Data_Region_Any
:
17722 printf (_("Any Region\n"));
17724 case Val_GNU_MSP430_Data_Region_Lower
:
17725 printf (_("Lower Region Only\n"));
17728 printf ("??? (%u)\n", val
);
17732 return display_tag_value (tag
& 1, p
, end
);
17735 struct riscv_attr_tag_t
{
17740 static struct riscv_attr_tag_t riscv_attr_tag
[] =
17742 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
17745 T(priv_spec_minor
),
17746 T(priv_spec_revision
),
17747 T(unaligned_access
),
17752 static unsigned char *
17753 display_riscv_attribute (unsigned char *p
,
17754 const unsigned char * const end
)
17758 struct riscv_attr_tag_t
*attr
= NULL
;
17761 READ_ULEB (tag
, p
, end
);
17763 /* Find the name of attribute. */
17764 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
17766 if (riscv_attr_tag
[i
].tag
== tag
)
17768 attr
= &riscv_attr_tag
[i
];
17774 printf (" %s: ", attr
->name
);
17776 return display_tag_value (tag
, p
, end
);
17780 case Tag_RISCV_priv_spec
:
17781 case Tag_RISCV_priv_spec_minor
:
17782 case Tag_RISCV_priv_spec_revision
:
17783 READ_ULEB (val
, p
, end
);
17784 printf (_("%u\n"), val
);
17786 case Tag_RISCV_unaligned_access
:
17787 READ_ULEB (val
, p
, end
);
17791 printf (_("No unaligned access\n"));
17794 printf (_("Unaligned access\n"));
17798 case Tag_RISCV_stack_align
:
17799 READ_ULEB (val
, p
, end
);
17800 printf (_("%u-bytes\n"), val
);
17802 case Tag_RISCV_arch
:
17803 p
= display_tag_value (-1, p
, end
);
17806 return display_tag_value (tag
, p
, end
);
17812 static unsigned char *
17813 display_csky_attribute (unsigned char * p
,
17814 const unsigned char * const end
)
17818 READ_ULEB (tag
, p
, end
);
17820 if (tag
>= Tag_CSKY_MAX
)
17822 return display_tag_value (-1, p
, end
);
17827 case Tag_CSKY_ARCH_NAME
:
17828 printf (" Tag_CSKY_ARCH_NAME:\t\t");
17829 return display_tag_value (-1, p
, end
);
17830 case Tag_CSKY_CPU_NAME
:
17831 printf (" Tag_CSKY_CPU_NAME:\t\t");
17832 return display_tag_value (-1, p
, end
);
17834 case Tag_CSKY_ISA_FLAGS
:
17835 printf (" Tag_CSKY_ISA_FLAGS:\t\t");
17836 return display_tag_value (0, p
, end
);
17837 case Tag_CSKY_ISA_EXT_FLAGS
:
17838 printf (" Tag_CSKY_ISA_EXT_FLAGS:\t");
17839 return display_tag_value (0, p
, end
);
17841 case Tag_CSKY_DSP_VERSION
:
17842 printf (" Tag_CSKY_DSP_VERSION:\t\t");
17843 READ_ULEB (val
, p
, end
);
17844 if (val
== VAL_CSKY_DSP_VERSION_EXTENSION
)
17845 printf ("DSP Extension\n");
17846 else if (val
== VAL_CSKY_DSP_VERSION_2
)
17847 printf ("DSP 2.0\n");
17850 case Tag_CSKY_VDSP_VERSION
:
17851 printf (" Tag_CSKY_VDSP_VERSION:\t");
17852 READ_ULEB (val
, p
, end
);
17853 printf ("VDSP Version %d\n", val
);
17856 case Tag_CSKY_FPU_VERSION
:
17857 printf (" Tag_CSKY_FPU_VERSION:\t\t");
17858 READ_ULEB (val
, p
, end
);
17859 if (val
== VAL_CSKY_FPU_VERSION_1
)
17860 printf ("ABIV1 FPU Version 1\n");
17861 else if (val
== VAL_CSKY_FPU_VERSION_2
)
17862 printf ("FPU Version 2\n");
17865 case Tag_CSKY_FPU_ABI
:
17866 printf (" Tag_CSKY_FPU_ABI:\t\t");
17867 READ_ULEB (val
, p
, end
);
17868 if (val
== VAL_CSKY_FPU_ABI_HARD
)
17870 else if (val
== VAL_CSKY_FPU_ABI_SOFTFP
)
17871 printf ("SoftFP\n");
17872 else if (val
== VAL_CSKY_FPU_ABI_SOFT
)
17875 case Tag_CSKY_FPU_ROUNDING
:
17876 READ_ULEB (val
, p
, end
);
17879 printf (" Tag_CSKY_FPU_ROUNDING:\t");
17880 printf ("Needed\n");
17883 case Tag_CSKY_FPU_DENORMAL
:
17884 READ_ULEB (val
, p
, end
);
17887 printf (" Tag_CSKY_FPU_DENORMAL:\t");
17888 printf ("Needed\n");
17891 case Tag_CSKY_FPU_Exception
:
17892 READ_ULEB (val
, p
, end
);
17895 printf (" Tag_CSKY_FPU_Exception:\t");
17896 printf ("Needed\n");
17899 case Tag_CSKY_FPU_NUMBER_MODULE
:
17900 printf (" Tag_CSKY_FPU_NUMBER_MODULE:\t");
17901 return display_tag_value (-1, p
, end
);
17902 case Tag_CSKY_FPU_HARDFP
:
17903 printf (" Tag_CSKY_FPU_HARDFP:\t\t");
17904 READ_ULEB (val
, p
, end
);
17905 if (val
& VAL_CSKY_FPU_HARDFP_HALF
)
17907 if (val
& VAL_CSKY_FPU_HARDFP_SINGLE
)
17908 printf (" Single");
17909 if (val
& VAL_CSKY_FPU_HARDFP_DOUBLE
)
17910 printf (" Double");
17914 return display_tag_value (tag
, p
, end
);
17920 process_attributes (Filedata
* filedata
,
17921 const char * public_name
,
17922 unsigned int proc_type
,
17923 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
17924 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
17926 Elf_Internal_Shdr
* sect
;
17930 /* Find the section header so that we get the size. */
17931 for (i
= 0, sect
= filedata
->section_headers
;
17932 i
< filedata
->file_header
.e_shnum
;
17935 unsigned char * contents
;
17938 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
17941 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17942 sect
->sh_size
, _("attributes"));
17943 if (contents
== NULL
)
17950 /* The first character is the version of the attributes.
17951 Currently only version 1, (aka 'A') is recognised here. */
17954 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
17959 uint64_t section_len
;
17961 section_len
= sect
->sh_size
- 1;
17964 while (section_len
> 0)
17967 unsigned int namelen
;
17968 bool public_section
;
17971 if (section_len
<= 4)
17973 error (_("Tag section ends prematurely\n"));
17977 attr_len
= byte_get (p
, 4);
17980 if (attr_len
> section_len
)
17982 error (_("Bad attribute length (%u > %u)\n"),
17983 (unsigned) attr_len
, (unsigned) section_len
);
17984 attr_len
= section_len
;
17987 /* PR 17531: file: 001-101425-0.004 */
17988 else if (attr_len
< 5)
17990 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
17995 section_len
-= attr_len
;
17998 namelen
= strnlen ((char *) p
, attr_len
) + 1;
17999 if (namelen
== 0 || namelen
>= attr_len
)
18001 error (_("Corrupt attribute section name\n"));
18006 printf (_("Attribute Section: "));
18007 print_symbol (INT_MAX
, (const char *) p
);
18010 if (public_name
&& streq ((char *) p
, public_name
))
18011 public_section
= true;
18013 public_section
= false;
18015 if (streq ((char *) p
, "gnu"))
18016 gnu_section
= true;
18018 gnu_section
= false;
18021 attr_len
-= namelen
;
18023 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
18028 unsigned char * end
;
18030 /* PR binutils/17531: Safe handling of corrupt files. */
18033 error (_("Unused bytes at end of section\n"));
18040 size
= byte_get (p
, 4);
18041 if (size
> attr_len
)
18043 error (_("Bad subsection length (%u > %u)\n"),
18044 (unsigned) size
, (unsigned) attr_len
);
18048 /* PR binutils/17531: Safe handling of corrupt files. */
18051 error (_("Bad subsection length (%u < 6)\n"),
18059 end
= p
+ size
- 1;
18060 assert (end
<= contents
+ sect
->sh_size
);
18066 printf (_("File Attributes\n"));
18069 printf (_("Section Attributes:"));
18072 printf (_("Symbol Attributes:"));
18073 /* Fall through. */
18077 READ_ULEB (val
, p
, end
);
18080 printf (" %d", val
);
18085 printf (_("Unknown tag: %d\n"), tag
);
18086 public_section
= false;
18090 if (public_section
&& display_pub_attribute
!= NULL
)
18093 p
= display_pub_attribute (p
, end
);
18096 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
18099 p
= display_gnu_attribute (p
,
18100 display_proc_gnu_attribute
,
18106 printf (_(" Unknown attribute:\n"));
18107 display_raw_attribute (p
, end
);
18122 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
18123 Print the Address, Access and Initial fields of an entry at VMA ADDR
18124 and return the VMA of the next entry, or -1 if there was a problem.
18125 Does not read from DATA_END or beyond. */
18128 print_mips_got_entry (unsigned char * data
, uint64_t pltgot
, uint64_t addr
,
18129 unsigned char * data_end
)
18132 print_vma (addr
, LONG_HEX
);
18134 if (addr
< pltgot
+ 0xfff0)
18135 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
18137 printf ("%10s", "");
18140 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
18144 unsigned char * from
= data
+ addr
- pltgot
;
18146 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
18148 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
18149 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
18150 return (uint64_t) -1;
18154 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
18155 print_vma (entry
, LONG_HEX
);
18158 return addr
+ (is_32bit_elf
? 4 : 8);
18161 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
18162 PLTGOT. Print the Address and Initial fields of an entry at VMA
18163 ADDR and return the VMA of the next entry. */
18166 print_mips_pltgot_entry (unsigned char * data
, uint64_t pltgot
, uint64_t addr
)
18169 print_vma (addr
, LONG_HEX
);
18172 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
18177 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
18178 print_vma (entry
, LONG_HEX
);
18180 return addr
+ (is_32bit_elf
? 4 : 8);
18184 print_mips_ases (unsigned int mask
)
18186 if (mask
& AFL_ASE_DSP
)
18187 fputs ("\n\tDSP ASE", stdout
);
18188 if (mask
& AFL_ASE_DSPR2
)
18189 fputs ("\n\tDSP R2 ASE", stdout
);
18190 if (mask
& AFL_ASE_DSPR3
)
18191 fputs ("\n\tDSP R3 ASE", stdout
);
18192 if (mask
& AFL_ASE_EVA
)
18193 fputs ("\n\tEnhanced VA Scheme", stdout
);
18194 if (mask
& AFL_ASE_MCU
)
18195 fputs ("\n\tMCU (MicroController) ASE", stdout
);
18196 if (mask
& AFL_ASE_MDMX
)
18197 fputs ("\n\tMDMX ASE", stdout
);
18198 if (mask
& AFL_ASE_MIPS3D
)
18199 fputs ("\n\tMIPS-3D ASE", stdout
);
18200 if (mask
& AFL_ASE_MT
)
18201 fputs ("\n\tMT ASE", stdout
);
18202 if (mask
& AFL_ASE_SMARTMIPS
)
18203 fputs ("\n\tSmartMIPS ASE", stdout
);
18204 if (mask
& AFL_ASE_VIRT
)
18205 fputs ("\n\tVZ ASE", stdout
);
18206 if (mask
& AFL_ASE_MSA
)
18207 fputs ("\n\tMSA ASE", stdout
);
18208 if (mask
& AFL_ASE_MIPS16
)
18209 fputs ("\n\tMIPS16 ASE", stdout
);
18210 if (mask
& AFL_ASE_MICROMIPS
)
18211 fputs ("\n\tMICROMIPS ASE", stdout
);
18212 if (mask
& AFL_ASE_XPA
)
18213 fputs ("\n\tXPA ASE", stdout
);
18214 if (mask
& AFL_ASE_MIPS16E2
)
18215 fputs ("\n\tMIPS16e2 ASE", stdout
);
18216 if (mask
& AFL_ASE_CRC
)
18217 fputs ("\n\tCRC ASE", stdout
);
18218 if (mask
& AFL_ASE_GINV
)
18219 fputs ("\n\tGINV ASE", stdout
);
18220 if (mask
& AFL_ASE_LOONGSON_MMI
)
18221 fputs ("\n\tLoongson MMI ASE", stdout
);
18222 if (mask
& AFL_ASE_LOONGSON_CAM
)
18223 fputs ("\n\tLoongson CAM ASE", stdout
);
18224 if (mask
& AFL_ASE_LOONGSON_EXT
)
18225 fputs ("\n\tLoongson EXT ASE", stdout
);
18226 if (mask
& AFL_ASE_LOONGSON_EXT2
)
18227 fputs ("\n\tLoongson EXT2 ASE", stdout
);
18229 fprintf (stdout
, "\n\t%s", _("None"));
18230 else if ((mask
& ~AFL_ASE_MASK
) != 0)
18231 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
18235 print_mips_isa_ext (unsigned int isa_ext
)
18240 fputs (_("None"), stdout
);
18243 fputs ("RMI XLR", stdout
);
18245 case AFL_EXT_OCTEON3
:
18246 fputs ("Cavium Networks Octeon3", stdout
);
18248 case AFL_EXT_OCTEON2
:
18249 fputs ("Cavium Networks Octeon2", stdout
);
18251 case AFL_EXT_OCTEONP
:
18252 fputs ("Cavium Networks OcteonP", stdout
);
18254 case AFL_EXT_OCTEON
:
18255 fputs ("Cavium Networks Octeon", stdout
);
18258 fputs ("Toshiba R5900", stdout
);
18261 fputs ("MIPS R4650", stdout
);
18264 fputs ("LSI R4010", stdout
);
18267 fputs ("NEC VR4100", stdout
);
18270 fputs ("Toshiba R3900", stdout
);
18272 case AFL_EXT_10000
:
18273 fputs ("MIPS R10000", stdout
);
18276 fputs ("Broadcom SB-1", stdout
);
18279 fputs ("NEC VR4111/VR4181", stdout
);
18282 fputs ("NEC VR4120", stdout
);
18285 fputs ("NEC VR5400", stdout
);
18288 fputs ("NEC VR5500", stdout
);
18290 case AFL_EXT_LOONGSON_2E
:
18291 fputs ("ST Microelectronics Loongson 2E", stdout
);
18293 case AFL_EXT_LOONGSON_2F
:
18294 fputs ("ST Microelectronics Loongson 2F", stdout
);
18296 case AFL_EXT_INTERAPTIV_MR2
:
18297 fputs ("Imagination interAptiv MR2", stdout
);
18300 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
18305 get_mips_reg_size (int reg_size
)
18307 return (reg_size
== AFL_REG_NONE
) ? 0
18308 : (reg_size
== AFL_REG_32
) ? 32
18309 : (reg_size
== AFL_REG_64
) ? 64
18310 : (reg_size
== AFL_REG_128
) ? 128
18315 process_mips_specific (Filedata
* filedata
)
18317 Elf_Internal_Dyn
* entry
;
18318 Elf_Internal_Shdr
*sect
= NULL
;
18319 size_t liblist_offset
= 0;
18320 size_t liblistno
= 0;
18321 size_t conflictsno
= 0;
18322 size_t options_offset
= 0;
18323 size_t conflicts_offset
= 0;
18324 size_t pltrelsz
= 0;
18326 uint64_t pltgot
= 0;
18327 uint64_t mips_pltgot
= 0;
18328 uint64_t jmprel
= 0;
18329 uint64_t local_gotno
= 0;
18330 uint64_t gotsym
= 0;
18331 uint64_t symtabno
= 0;
18334 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18335 display_mips_gnu_attribute
))
18338 sect
= find_section (filedata
, ".MIPS.abiflags");
18342 Elf_External_ABIFlags_v0
*abiflags_ext
;
18343 Elf_Internal_ABIFlags_v0 abiflags_in
;
18345 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
18347 error (_("Corrupt MIPS ABI Flags section.\n"));
18352 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
18353 sect
->sh_size
, _("MIPS ABI Flags section"));
18356 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
18357 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
18358 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
18359 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
18360 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
18361 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
18362 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
18363 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
18364 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
18365 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
18366 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
18368 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
18369 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
18370 if (abiflags_in
.isa_rev
> 1)
18371 printf ("r%d", abiflags_in
.isa_rev
);
18372 printf ("\nGPR size: %d",
18373 get_mips_reg_size (abiflags_in
.gpr_size
));
18374 printf ("\nCPR1 size: %d",
18375 get_mips_reg_size (abiflags_in
.cpr1_size
));
18376 printf ("\nCPR2 size: %d",
18377 get_mips_reg_size (abiflags_in
.cpr2_size
));
18378 fputs ("\nFP ABI: ", stdout
);
18379 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
18380 fputs ("ISA Extension: ", stdout
);
18381 print_mips_isa_ext (abiflags_in
.isa_ext
);
18382 fputs ("\nASEs:", stdout
);
18383 print_mips_ases (abiflags_in
.ases
);
18384 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
18385 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
18386 fputc ('\n', stdout
);
18387 free (abiflags_ext
);
18392 /* We have a lot of special sections. Thanks SGI! */
18393 if (filedata
->dynamic_section
== NULL
)
18395 /* No dynamic information available. See if there is static GOT. */
18396 sect
= find_section (filedata
, ".got");
18399 unsigned char *data_end
;
18400 unsigned char *data
;
18404 pltgot
= sect
->sh_addr
;
18407 addr_size
= (is_32bit_elf
? 4 : 8);
18408 end
= pltgot
+ sect
->sh_size
;
18410 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
18412 _("Global Offset Table data"));
18413 /* PR 12855: Null data is handled gracefully throughout. */
18414 data_end
= data
+ (end
- pltgot
);
18416 printf (_("\nStatic GOT:\n"));
18417 printf (_(" Canonical gp value: "));
18418 print_vma (ent
+ 0x7ff0, LONG_HEX
);
18421 /* In a dynamic binary GOT[0] is reserved for the dynamic
18422 loader to store the lazy resolver pointer, however in
18423 a static binary it may well have been omitted and GOT
18424 reduced to a table of addresses.
18425 PR 21344: Check for the entry being fully available
18426 before fetching it. */
18428 && data
+ ent
- pltgot
+ addr_size
<= data_end
18429 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
18431 printf (_(" Reserved entries:\n"));
18432 printf (_(" %*s %10s %*s\n"),
18433 addr_size
* 2, _("Address"), _("Access"),
18434 addr_size
* 2, _("Value"));
18435 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18437 if (ent
== (uint64_t) -1)
18438 goto sgot_print_fail
;
18440 /* Check for the MSB of GOT[1] being set, identifying a
18441 GNU object. This entry will be used by some runtime
18442 loaders, to store the module pointer. Otherwise this
18443 is an ordinary local entry.
18444 PR 21344: Check for the entry being fully available
18445 before fetching it. */
18447 && data
+ ent
- pltgot
+ addr_size
<= data_end
18448 && (byte_get (data
+ ent
- pltgot
, addr_size
)
18449 >> (addr_size
* 8 - 1)) != 0)
18451 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18453 if (ent
== (uint64_t) -1)
18454 goto sgot_print_fail
;
18459 if (data
!= NULL
&& ent
< end
)
18461 printf (_(" Local entries:\n"));
18462 printf (" %*s %10s %*s\n",
18463 addr_size
* 2, _("Address"), _("Access"),
18464 addr_size
* 2, _("Value"));
18467 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18469 if (ent
== (uint64_t) -1)
18470 goto sgot_print_fail
;
18481 for (entry
= filedata
->dynamic_section
;
18482 /* PR 17531 file: 012-50589-0.004. */
18483 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
18484 && entry
->d_tag
!= DT_NULL
);
18486 switch (entry
->d_tag
)
18488 case DT_MIPS_LIBLIST
:
18490 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
18491 liblistno
* sizeof (Elf32_External_Lib
));
18493 case DT_MIPS_LIBLISTNO
:
18494 liblistno
= entry
->d_un
.d_val
;
18496 case DT_MIPS_OPTIONS
:
18497 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
18499 case DT_MIPS_CONFLICT
:
18501 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
18502 conflictsno
* sizeof (Elf32_External_Conflict
));
18504 case DT_MIPS_CONFLICTNO
:
18505 conflictsno
= entry
->d_un
.d_val
;
18508 pltgot
= entry
->d_un
.d_ptr
;
18510 case DT_MIPS_LOCAL_GOTNO
:
18511 local_gotno
= entry
->d_un
.d_val
;
18513 case DT_MIPS_GOTSYM
:
18514 gotsym
= entry
->d_un
.d_val
;
18516 case DT_MIPS_SYMTABNO
:
18517 symtabno
= entry
->d_un
.d_val
;
18519 case DT_MIPS_PLTGOT
:
18520 mips_pltgot
= entry
->d_un
.d_ptr
;
18523 pltrel
= entry
->d_un
.d_val
;
18526 pltrelsz
= entry
->d_un
.d_val
;
18529 jmprel
= entry
->d_un
.d_ptr
;
18535 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
18537 Elf32_External_Lib
* elib
;
18540 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
18541 sizeof (Elf32_External_Lib
),
18543 _("liblist section data"));
18546 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
18547 "\nSection '.liblist' contains %lu entries:\n",
18548 (unsigned long) liblistno
),
18549 (unsigned long) liblistno
);
18550 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
18553 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
18560 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
18561 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
18562 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
18563 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
18564 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
18566 tmp
= gmtime (&atime
);
18567 snprintf (timebuf
, sizeof (timebuf
),
18568 "%04u-%02u-%02uT%02u:%02u:%02u",
18569 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
18570 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
18572 printf ("%3lu: ", (unsigned long) cnt
);
18573 if (valid_dynamic_name (filedata
, liblist
.l_name
))
18574 print_symbol (20, get_dynamic_name (filedata
, liblist
.l_name
));
18576 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
18577 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
18578 liblist
.l_version
);
18580 if (liblist
.l_flags
== 0)
18584 static const struct
18591 { " EXACT_MATCH", LL_EXACT_MATCH
},
18592 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
18593 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
18594 { " EXPORTS", LL_EXPORTS
},
18595 { " DELAY_LOAD", LL_DELAY_LOAD
},
18596 { " DELTA", LL_DELTA
}
18598 int flags
= liblist
.l_flags
;
18601 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
18602 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
18604 fputs (l_flags_vals
[fcnt
].name
, stdout
);
18605 flags
^= l_flags_vals
[fcnt
].bit
;
18608 printf (" %#x", (unsigned int) flags
);
18620 if (options_offset
!= 0)
18622 Elf_External_Options
* eopt
;
18626 /* Find the section header so that we get the size. */
18627 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
18628 /* PR 17533 file: 012-277276-0.004. */
18631 error (_("No MIPS_OPTIONS header found\n"));
18635 if (sect
->sh_size
< sizeof (* eopt
))
18637 error (_("The MIPS options section is too small.\n"));
18641 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
18642 sect
->sh_size
, _("options"));
18645 Elf_Internal_Options option
;
18648 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
18650 Elf_External_Options
* eoption
;
18651 unsigned int optsize
;
18653 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
18655 optsize
= BYTE_GET (eoption
->size
);
18657 /* PR 17531: file: ffa0fa3b. */
18658 if (optsize
< sizeof (* eopt
)
18659 || optsize
> sect
->sh_size
- offset
)
18661 error (_("Invalid size (%u) for MIPS option\n"),
18670 printf (ngettext ("\nSection '%s' contains %d entry:\n",
18671 "\nSection '%s' contains %d entries:\n",
18673 printable_section_name (filedata
, sect
), cnt
);
18679 Elf_External_Options
* eoption
;
18681 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
18683 option
.kind
= BYTE_GET (eoption
->kind
);
18684 option
.size
= BYTE_GET (eoption
->size
);
18685 option
.section
= BYTE_GET (eoption
->section
);
18686 option
.info
= BYTE_GET (eoption
->info
);
18688 switch (option
.kind
)
18691 /* This shouldn't happen. */
18692 printf (" NULL %" PRId16
" %" PRIx32
,
18693 option
.section
, option
.info
);
18697 printf (" REGINFO ");
18698 if (filedata
->file_header
.e_machine
== EM_MIPS
)
18700 Elf32_External_RegInfo
* ereg
;
18701 Elf32_RegInfo reginfo
;
18704 if (option
.size
< (sizeof (Elf_External_Options
)
18705 + sizeof (Elf32_External_RegInfo
)))
18707 printf (_("<corrupt>\n"));
18708 error (_("Truncated MIPS REGINFO option\n"));
18713 ereg
= (Elf32_External_RegInfo
*) (eoption
+ 1);
18715 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
18716 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
18717 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
18718 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
18719 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
18720 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
18722 printf ("GPR %08" PRIx32
" GP 0x%" PRIx32
"\n",
18723 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
18725 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
18726 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
18727 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
18728 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
18733 Elf64_External_RegInfo
* ereg
;
18734 Elf64_Internal_RegInfo reginfo
;
18736 if (option
.size
< (sizeof (Elf_External_Options
)
18737 + sizeof (Elf64_External_RegInfo
)))
18739 printf (_("<corrupt>\n"));
18740 error (_("Truncated MIPS REGINFO option\n"));
18745 ereg
= (Elf64_External_RegInfo
*) (eoption
+ 1);
18746 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
18747 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
18748 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
18749 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
18750 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
18751 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
18753 printf ("GPR %08" PRIx32
" GP 0x%" PRIx64
"\n",
18754 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
18756 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
18757 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
18758 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
18759 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
18761 offset
+= option
.size
;
18764 case ODK_EXCEPTIONS
:
18765 fputs (" EXCEPTIONS fpe_min(", stdout
);
18766 process_mips_fpe_exception (option
.info
& OEX_FPU_MIN
);
18767 fputs (") fpe_max(", stdout
);
18768 process_mips_fpe_exception ((option
.info
& OEX_FPU_MAX
) >> 8);
18769 fputs (")", stdout
);
18771 if (option
.info
& OEX_PAGE0
)
18772 fputs (" PAGE0", stdout
);
18773 if (option
.info
& OEX_SMM
)
18774 fputs (" SMM", stdout
);
18775 if (option
.info
& OEX_FPDBUG
)
18776 fputs (" FPDBUG", stdout
);
18777 if (option
.info
& OEX_DISMISS
)
18778 fputs (" DISMISS", stdout
);
18782 fputs (" PAD ", stdout
);
18783 if (option
.info
& OPAD_PREFIX
)
18784 fputs (" PREFIX", stdout
);
18785 if (option
.info
& OPAD_POSTFIX
)
18786 fputs (" POSTFIX", stdout
);
18787 if (option
.info
& OPAD_SYMBOL
)
18788 fputs (" SYMBOL", stdout
);
18792 fputs (" HWPATCH ", stdout
);
18793 if (option
.info
& OHW_R4KEOP
)
18794 fputs (" R4KEOP", stdout
);
18795 if (option
.info
& OHW_R8KPFETCH
)
18796 fputs (" R8KPFETCH", stdout
);
18797 if (option
.info
& OHW_R5KEOP
)
18798 fputs (" R5KEOP", stdout
);
18799 if (option
.info
& OHW_R5KCVTL
)
18800 fputs (" R5KCVTL", stdout
);
18804 fputs (" FILL ", stdout
);
18805 /* XXX Print content of info word? */
18809 fputs (" TAGS ", stdout
);
18810 /* XXX Print content of info word? */
18814 fputs (" HWAND ", stdout
);
18815 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
18816 fputs (" R4KEOP_CHECKED", stdout
);
18817 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
18818 fputs (" R4KEOP_CLEAN", stdout
);
18822 fputs (" HWOR ", stdout
);
18823 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
18824 fputs (" R4KEOP_CHECKED", stdout
);
18825 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
18826 fputs (" R4KEOP_CLEAN", stdout
);
18830 printf (" GP_GROUP %#06x self-contained %#06x",
18831 option
.info
& OGP_GROUP
,
18832 (option
.info
& OGP_SELF
) >> 16);
18836 printf (" IDENT %#06x self-contained %#06x",
18837 option
.info
& OGP_GROUP
,
18838 (option
.info
& OGP_SELF
) >> 16);
18842 /* This shouldn't happen. */
18843 printf (" %3d ??? %" PRId16
" %" PRIx32
,
18844 option
.kind
, option
.section
, option
.info
);
18848 len
= sizeof (* eopt
);
18849 while (len
< option
.size
)
18851 unsigned char datum
= *((unsigned char *) eoption
+ len
);
18853 if (ISPRINT (datum
))
18854 printf ("%c", datum
);
18856 printf ("\\%03o", datum
);
18859 fputs ("\n", stdout
);
18861 offset
+= option
.size
;
18869 if (conflicts_offset
!= 0 && conflictsno
!= 0)
18871 Elf32_Conflict
* iconf
;
18874 if (filedata
->dynamic_symbols
== NULL
)
18876 error (_("conflict list found without a dynamic symbol table\n"));
18880 /* PR 21345 - print a slightly more helpful error message
18881 if we are sure that the cmalloc will fail. */
18882 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
18884 error (_("Overlarge number of conflicts detected: %lx\n"),
18885 (long) conflictsno
);
18889 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
18892 error (_("Out of memory allocating space for dynamic conflicts\n"));
18898 Elf32_External_Conflict
* econf32
;
18900 econf32
= (Elf32_External_Conflict
*)
18901 get_data (NULL
, filedata
, conflicts_offset
,
18902 sizeof (*econf32
), conflictsno
, _("conflict"));
18909 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18910 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
18916 Elf64_External_Conflict
* econf64
;
18918 econf64
= (Elf64_External_Conflict
*)
18919 get_data (NULL
, filedata
, conflicts_offset
,
18920 sizeof (*econf64
), conflictsno
, _("conflict"));
18927 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18928 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
18933 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
18934 "\nSection '.conflict' contains %lu entries:\n",
18935 (unsigned long) conflictsno
),
18936 (unsigned long) conflictsno
);
18937 puts (_(" Num: Index Value Name"));
18939 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18941 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
18943 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
18944 printf (_("<corrupt symbol index>"));
18947 Elf_Internal_Sym
* psym
;
18949 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
18950 print_vma (psym
->st_value
, FULL_HEX
);
18952 if (valid_dynamic_name (filedata
, psym
->st_name
))
18953 print_symbol (25, get_dynamic_name (filedata
, psym
->st_name
));
18955 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18963 if (pltgot
!= 0 && local_gotno
!= 0)
18965 uint64_t ent
, local_end
, global_end
;
18967 unsigned char * data
;
18968 unsigned char * data_end
;
18972 addr_size
= (is_32bit_elf
? 4 : 8);
18973 local_end
= pltgot
+ local_gotno
* addr_size
;
18975 /* PR binutils/17533 file: 012-111227-0.004 */
18976 if (symtabno
< gotsym
)
18978 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
18979 (unsigned long) gotsym
, (unsigned long) symtabno
);
18983 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
18984 /* PR 17531: file: 54c91a34. */
18985 if (global_end
< local_end
)
18987 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
18991 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
18992 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
18993 global_end
- pltgot
, 1,
18994 _("Global Offset Table data"));
18995 /* PR 12855: Null data is handled gracefully throughout. */
18996 data_end
= data
+ (global_end
- pltgot
);
18998 printf (_("\nPrimary GOT:\n"));
18999 printf (_(" Canonical gp value: "));
19000 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
19003 printf (_(" Reserved entries:\n"));
19004 printf (_(" %*s %10s %*s Purpose\n"),
19005 addr_size
* 2, _("Address"), _("Access"),
19006 addr_size
* 2, _("Initial"));
19007 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19008 printf (_(" Lazy resolver\n"));
19009 if (ent
== (uint64_t) -1)
19010 goto got_print_fail
;
19012 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
19013 This entry will be used by some runtime loaders, to store the
19014 module pointer. Otherwise this is an ordinary local entry.
19015 PR 21344: Check for the entry being fully available before
19018 && data
+ ent
- pltgot
+ addr_size
<= data_end
19019 && (byte_get (data
+ ent
- pltgot
, addr_size
)
19020 >> (addr_size
* 8 - 1)) != 0)
19022 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19023 printf (_(" Module pointer (GNU extension)\n"));
19024 if (ent
== (uint64_t) -1)
19025 goto got_print_fail
;
19029 if (data
!= NULL
&& ent
< local_end
)
19031 printf (_(" Local entries:\n"));
19032 printf (" %*s %10s %*s\n",
19033 addr_size
* 2, _("Address"), _("Access"),
19034 addr_size
* 2, _("Initial"));
19035 while (ent
< local_end
)
19037 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19039 if (ent
== (uint64_t) -1)
19040 goto got_print_fail
;
19045 if (data
!= NULL
&& gotsym
< symtabno
)
19049 printf (_(" Global entries:\n"));
19050 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
19051 addr_size
* 2, _("Address"),
19053 addr_size
* 2, _("Initial"),
19054 addr_size
* 2, _("Sym.Val."),
19056 /* Note for translators: "Ndx" = abbreviated form of "Index". */
19057 _("Ndx"), _("Name"));
19059 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
19061 for (i
= gotsym
; i
< symtabno
; i
++)
19063 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19066 if (filedata
->dynamic_symbols
== NULL
)
19067 printf (_("<no dynamic symbols>"));
19068 else if (i
< filedata
->num_dynamic_syms
)
19070 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
19072 print_vma (psym
->st_value
, LONG_HEX
);
19073 printf (" %-7s %3s ",
19074 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
19075 get_symbol_index_type (filedata
, psym
->st_shndx
));
19077 if (valid_dynamic_name (filedata
, psym
->st_name
))
19078 print_symbol (sym_width
,
19079 get_dynamic_name (filedata
, psym
->st_name
));
19081 printf (_("<corrupt: %14ld>"), psym
->st_name
);
19084 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
19085 (unsigned long) i
);
19088 if (ent
== (uint64_t) -1)
19098 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
19101 size_t offset
, rel_offset
;
19102 unsigned long count
, i
;
19103 unsigned char * data
;
19104 int addr_size
, sym_width
;
19105 Elf_Internal_Rela
* rels
;
19107 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
19108 if (pltrel
== DT_RELA
)
19110 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
19115 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
19120 addr_size
= (is_32bit_elf
? 4 : 8);
19121 end
= mips_pltgot
+ (2 + count
) * addr_size
;
19123 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
19124 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
19125 1, _("Procedure Linkage Table data"));
19132 printf ("\nPLT GOT:\n\n");
19133 printf (_(" Reserved entries:\n"));
19134 printf (_(" %*s %*s Purpose\n"),
19135 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
19136 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
19137 printf (_(" PLT lazy resolver\n"));
19138 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
19139 printf (_(" Module pointer\n"));
19142 printf (_(" Entries:\n"));
19143 printf (" %*s %*s %*s %-7s %3s %s\n",
19144 addr_size
* 2, _("Address"),
19145 addr_size
* 2, _("Initial"),
19146 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
19147 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
19148 for (i
= 0; i
< count
; i
++)
19150 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
19152 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
19155 if (idx
>= filedata
->num_dynamic_syms
)
19156 printf (_("<corrupt symbol index: %lu>"), idx
);
19159 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
19161 print_vma (psym
->st_value
, LONG_HEX
);
19162 printf (" %-7s %3s ",
19163 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
19164 get_symbol_index_type (filedata
, psym
->st_shndx
));
19165 if (valid_dynamic_name (filedata
, psym
->st_name
))
19166 print_symbol (sym_width
,
19167 get_dynamic_name (filedata
, psym
->st_name
));
19169 printf (_("<corrupt: %14ld>"), psym
->st_name
);
19183 process_nds32_specific (Filedata
* filedata
)
19185 Elf_Internal_Shdr
*sect
= NULL
;
19187 sect
= find_section (filedata
, ".nds32_e_flags");
19188 if (sect
!= NULL
&& sect
->sh_size
>= 4)
19190 unsigned char *buf
;
19193 printf ("\nNDS32 elf flags section:\n");
19194 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
19195 _("NDS32 elf flags section"));
19200 flag
= byte_get (buf
, 4);
19202 switch (flag
& 0x3)
19205 printf ("(VEC_SIZE):\tNo entry.\n");
19208 printf ("(VEC_SIZE):\t4 bytes\n");
19211 printf ("(VEC_SIZE):\t16 bytes\n");
19214 printf ("(VEC_SIZE):\treserved\n");
19223 process_gnu_liblist (Filedata
* filedata
)
19225 Elf_Internal_Shdr
* section
;
19226 Elf_Internal_Shdr
* string_sec
;
19227 Elf32_External_Lib
* elib
;
19229 size_t strtab_size
;
19231 unsigned long num_liblist
;
19238 for (i
= 0, section
= filedata
->section_headers
;
19239 i
< filedata
->file_header
.e_shnum
;
19242 switch (section
->sh_type
)
19244 case SHT_GNU_LIBLIST
:
19245 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
19248 elib
= (Elf32_External_Lib
*)
19249 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
19250 _("liblist section data"));
19258 string_sec
= filedata
->section_headers
+ section
->sh_link
;
19259 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
19260 string_sec
->sh_size
,
19261 _("liblist string table"));
19263 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
19270 strtab_size
= string_sec
->sh_size
;
19272 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
19273 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
19274 "\nLibrary list section '%s' contains %lu entries:\n",
19276 printable_section_name (filedata
, section
),
19279 puts (_(" Library Time Stamp Checksum Version Flags"));
19281 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
19289 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
19290 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
19291 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
19292 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
19293 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
19295 tmp
= gmtime (&atime
);
19296 snprintf (timebuf
, sizeof (timebuf
),
19297 "%04u-%02u-%02uT%02u:%02u:%02u",
19298 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
19299 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
19301 printf ("%3lu: ", (unsigned long) cnt
);
19303 printf ("%-20s", liblist
.l_name
< strtab_size
19304 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
19306 printf ("%-20.20s", liblist
.l_name
< strtab_size
19307 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
19308 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
19309 liblist
.l_version
, liblist
.l_flags
);
19320 static const char *
19321 get_note_type (Filedata
* filedata
, unsigned e_type
)
19323 static char buff
[64];
19325 if (filedata
->file_header
.e_type
== ET_CORE
)
19329 return _("NT_AUXV (auxiliary vector)");
19331 return _("NT_PRSTATUS (prstatus structure)");
19333 return _("NT_FPREGSET (floating point registers)");
19335 return _("NT_PRPSINFO (prpsinfo structure)");
19336 case NT_TASKSTRUCT
:
19337 return _("NT_TASKSTRUCT (task structure)");
19339 return _("NT_GDB_TDESC (GDB XML target description)");
19341 return _("NT_PRXFPREG (user_xfpregs structure)");
19343 return _("NT_PPC_VMX (ppc Altivec registers)");
19345 return _("NT_PPC_VSX (ppc VSX registers)");
19347 return _("NT_PPC_TAR (ppc TAR register)");
19349 return _("NT_PPC_PPR (ppc PPR register)");
19351 return _("NT_PPC_DSCR (ppc DSCR register)");
19353 return _("NT_PPC_EBB (ppc EBB registers)");
19355 return _("NT_PPC_PMU (ppc PMU registers)");
19356 case NT_PPC_TM_CGPR
:
19357 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
19358 case NT_PPC_TM_CFPR
:
19359 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
19360 case NT_PPC_TM_CVMX
:
19361 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
19362 case NT_PPC_TM_CVSX
:
19363 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
19364 case NT_PPC_TM_SPR
:
19365 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
19366 case NT_PPC_TM_CTAR
:
19367 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
19368 case NT_PPC_TM_CPPR
:
19369 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
19370 case NT_PPC_TM_CDSCR
:
19371 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
19373 return _("NT_386_TLS (x86 TLS information)");
19374 case NT_386_IOPERM
:
19375 return _("NT_386_IOPERM (x86 I/O permissions)");
19376 case NT_X86_XSTATE
:
19377 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
19379 return _("NT_X86_CET (x86 CET state)");
19380 case NT_S390_HIGH_GPRS
:
19381 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
19382 case NT_S390_TIMER
:
19383 return _("NT_S390_TIMER (s390 timer register)");
19384 case NT_S390_TODCMP
:
19385 return _("NT_S390_TODCMP (s390 TOD comparator register)");
19386 case NT_S390_TODPREG
:
19387 return _("NT_S390_TODPREG (s390 TOD programmable register)");
19389 return _("NT_S390_CTRS (s390 control registers)");
19390 case NT_S390_PREFIX
:
19391 return _("NT_S390_PREFIX (s390 prefix register)");
19392 case NT_S390_LAST_BREAK
:
19393 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
19394 case NT_S390_SYSTEM_CALL
:
19395 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
19397 return _("NT_S390_TDB (s390 transaction diagnostic block)");
19398 case NT_S390_VXRS_LOW
:
19399 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
19400 case NT_S390_VXRS_HIGH
:
19401 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
19402 case NT_S390_GS_CB
:
19403 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
19404 case NT_S390_GS_BC
:
19405 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
19407 return _("NT_ARM_VFP (arm VFP registers)");
19409 return _("NT_ARM_TLS (AArch TLS registers)");
19410 case NT_ARM_HW_BREAK
:
19411 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
19412 case NT_ARM_HW_WATCH
:
19413 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
19414 case NT_ARM_SYSTEM_CALL
:
19415 return _("NT_ARM_SYSTEM_CALL (AArch system call number)");
19417 return _("NT_ARM_SVE (AArch SVE registers)");
19418 case NT_ARM_PAC_MASK
:
19419 return _("NT_ARM_PAC_MASK (AArch pointer authentication code masks)");
19420 case NT_ARM_PACA_KEYS
:
19421 return _("NT_ARM_PACA_KEYS (ARM pointer authentication address keys)");
19422 case NT_ARM_PACG_KEYS
:
19423 return _("NT_ARM_PACG_KEYS (ARM pointer authentication generic keys)");
19424 case NT_ARM_TAGGED_ADDR_CTRL
:
19425 return _("NT_ARM_TAGGED_ADDR_CTRL (AArch tagged address control)");
19426 case NT_ARM_PAC_ENABLED_KEYS
:
19427 return _("NT_ARM_PAC_ENABLED_KEYS (AArch64 pointer authentication enabled keys)");
19429 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
19431 return _("NT_RISCV_CSR (RISC-V control and status registers)");
19433 return _("NT_PSTATUS (pstatus structure)");
19435 return _("NT_FPREGS (floating point registers)");
19437 return _("NT_PSINFO (psinfo structure)");
19439 return _("NT_LWPSTATUS (lwpstatus_t structure)");
19441 return _("NT_LWPSINFO (lwpsinfo_t structure)");
19442 case NT_WIN32PSTATUS
:
19443 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
19445 return _("NT_SIGINFO (siginfo_t data)");
19447 return _("NT_FILE (mapped files)");
19455 return _("NT_VERSION (version)");
19457 return _("NT_ARCH (architecture)");
19458 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
19460 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
19462 case NT_GO_BUILDID
:
19463 return _("GO BUILDID");
19464 case FDO_PACKAGING_METADATA
:
19465 return _("FDO_PACKAGING_METADATA");
19470 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19475 print_core_note (Elf_Internal_Note
*pnote
)
19477 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
19478 uint64_t count
, page_size
;
19479 unsigned char *descdata
, *filenames
, *descend
;
19481 if (pnote
->type
!= NT_FILE
)
19490 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
19491 /* Still "successful". */
19495 if (pnote
->descsz
< 2 * addr_size
)
19497 error (_(" Malformed note - too short for header\n"));
19501 descdata
= (unsigned char *) pnote
->descdata
;
19502 descend
= descdata
+ pnote
->descsz
;
19504 if (descdata
[pnote
->descsz
- 1] != '\0')
19506 error (_(" Malformed note - does not end with \\0\n"));
19510 count
= byte_get (descdata
, addr_size
);
19511 descdata
+= addr_size
;
19513 page_size
= byte_get (descdata
, addr_size
);
19514 descdata
+= addr_size
;
19516 if (count
> ((uint64_t) -1 - 2 * addr_size
) / (3 * addr_size
)
19517 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
19519 error (_(" Malformed note - too short for supplied file count\n"));
19523 printf (_(" Page size: "));
19524 print_vma (page_size
, DEC
);
19527 printf (_(" %*s%*s%*s\n"),
19528 (int) (2 + 2 * addr_size
), _("Start"),
19529 (int) (4 + 2 * addr_size
), _("End"),
19530 (int) (4 + 2 * addr_size
), _("Page Offset"));
19531 filenames
= descdata
+ count
* 3 * addr_size
;
19532 while (count
-- > 0)
19534 uint64_t start
, end
, file_ofs
;
19536 if (filenames
== descend
)
19538 error (_(" Malformed note - filenames end too early\n"));
19542 start
= byte_get (descdata
, addr_size
);
19543 descdata
+= addr_size
;
19544 end
= byte_get (descdata
, addr_size
);
19545 descdata
+= addr_size
;
19546 file_ofs
= byte_get (descdata
, addr_size
);
19547 descdata
+= addr_size
;
19550 print_vma (start
, FULL_HEX
);
19552 print_vma (end
, FULL_HEX
);
19554 print_vma (file_ofs
, FULL_HEX
);
19555 printf ("\n %s\n", filenames
);
19557 filenames
+= 1 + strlen ((char *) filenames
);
19563 static const char *
19564 get_gnu_elf_note_type (unsigned e_type
)
19566 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
19569 case NT_GNU_ABI_TAG
:
19570 return _("NT_GNU_ABI_TAG (ABI version tag)");
19572 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
19573 case NT_GNU_BUILD_ID
:
19574 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
19575 case NT_GNU_GOLD_VERSION
:
19576 return _("NT_GNU_GOLD_VERSION (gold version)");
19577 case NT_GNU_PROPERTY_TYPE_0
:
19578 return _("NT_GNU_PROPERTY_TYPE_0");
19579 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
19580 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
19581 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
19582 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
19585 static char buff
[64];
19587 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19594 decode_x86_compat_isa (unsigned int bitmask
)
19598 unsigned int bit
= bitmask
& (- bitmask
);
19603 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
19606 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
19609 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
19612 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
19615 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
19618 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
19621 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
19624 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
19627 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
19630 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
19633 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
19636 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
19637 printf ("AVX512F");
19639 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
19640 printf ("AVX512CD");
19642 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
19643 printf ("AVX512ER");
19645 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
19646 printf ("AVX512PF");
19648 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
19649 printf ("AVX512VL");
19651 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
19652 printf ("AVX512DQ");
19654 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
19655 printf ("AVX512BW");
19658 printf (_("<unknown: %x>"), bit
);
19667 decode_x86_compat_2_isa (unsigned int bitmask
)
19671 printf (_("<None>"));
19677 unsigned int bit
= bitmask
& (- bitmask
);
19682 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_CMOV
:
19685 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE
:
19688 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE2
:
19691 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE3
:
19694 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSSE3
:
19697 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_1
:
19700 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_2
:
19703 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX
:
19706 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX2
:
19709 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_FMA
:
19712 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512F
:
19713 printf ("AVX512F");
19715 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512CD
:
19716 printf ("AVX512CD");
19718 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512ER
:
19719 printf ("AVX512ER");
19721 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512PF
:
19722 printf ("AVX512PF");
19724 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512VL
:
19725 printf ("AVX512VL");
19727 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512DQ
:
19728 printf ("AVX512DQ");
19730 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512BW
:
19731 printf ("AVX512BW");
19733 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4FMAPS
:
19734 printf ("AVX512_4FMAPS");
19736 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4VNNIW
:
19737 printf ("AVX512_4VNNIW");
19739 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BITALG
:
19740 printf ("AVX512_BITALG");
19742 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_IFMA
:
19743 printf ("AVX512_IFMA");
19745 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI
:
19746 printf ("AVX512_VBMI");
19748 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI2
:
19749 printf ("AVX512_VBMI2");
19751 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VNNI
:
19752 printf ("AVX512_VNNI");
19754 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BF16
:
19755 printf ("AVX512_BF16");
19758 printf (_("<unknown: %x>"), bit
);
19766 static const char *
19767 get_amdgpu_elf_note_type (unsigned int e_type
)
19771 case NT_AMDGPU_METADATA
:
19772 return _("NT_AMDGPU_METADATA (code object metadata)");
19775 static char buf
[64];
19776 snprintf (buf
, sizeof (buf
), _("Unknown note type: (0x%08x)"), e_type
);
19783 decode_x86_isa (unsigned int bitmask
)
19787 unsigned int bit
= bitmask
& (- bitmask
);
19792 case GNU_PROPERTY_X86_ISA_1_BASELINE
:
19793 printf ("x86-64-baseline");
19795 case GNU_PROPERTY_X86_ISA_1_V2
:
19796 printf ("x86-64-v2");
19798 case GNU_PROPERTY_X86_ISA_1_V3
:
19799 printf ("x86-64-v3");
19801 case GNU_PROPERTY_X86_ISA_1_V4
:
19802 printf ("x86-64-v4");
19805 printf (_("<unknown: %x>"), bit
);
19814 decode_x86_feature_1 (unsigned int bitmask
)
19818 printf (_("<None>"));
19824 unsigned int bit
= bitmask
& (- bitmask
);
19829 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
19832 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
19835 case GNU_PROPERTY_X86_FEATURE_1_LAM_U48
:
19836 printf ("LAM_U48");
19838 case GNU_PROPERTY_X86_FEATURE_1_LAM_U57
:
19839 printf ("LAM_U57");
19842 printf (_("<unknown: %x>"), bit
);
19851 decode_x86_feature_2 (unsigned int bitmask
)
19855 printf (_("<None>"));
19861 unsigned int bit
= bitmask
& (- bitmask
);
19866 case GNU_PROPERTY_X86_FEATURE_2_X86
:
19869 case GNU_PROPERTY_X86_FEATURE_2_X87
:
19872 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
19875 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
19878 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
19881 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
19884 case GNU_PROPERTY_X86_FEATURE_2_TMM
:
19887 case GNU_PROPERTY_X86_FEATURE_2_MASK
:
19890 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
19893 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
19896 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
19897 printf ("XSAVEOPT");
19899 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
19903 printf (_("<unknown: %x>"), bit
);
19912 decode_aarch64_feature_1_and (unsigned int bitmask
)
19916 unsigned int bit
= bitmask
& (- bitmask
);
19921 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
19925 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
19930 printf (_("<unknown: %x>"), bit
);
19939 decode_1_needed (unsigned int bitmask
)
19943 unsigned int bit
= bitmask
& (- bitmask
);
19948 case GNU_PROPERTY_1_NEEDED_INDIRECT_EXTERN_ACCESS
:
19949 printf ("indirect external access");
19952 printf (_("<unknown: %x>"), bit
);
19961 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
19963 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
19964 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
19965 unsigned int size
= is_32bit_elf
? 4 : 8;
19967 printf (_(" Properties: "));
19969 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
19971 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
19975 while (ptr
< ptr_end
)
19979 unsigned int datasz
;
19981 if ((size_t) (ptr_end
- ptr
) < 8)
19983 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
19987 type
= byte_get (ptr
, 4);
19988 datasz
= byte_get (ptr
+ 4, 4);
19992 if (datasz
> (size_t) (ptr_end
- ptr
))
19994 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
19999 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
20001 if (filedata
->file_header
.e_machine
== EM_X86_64
20002 || filedata
->file_header
.e_machine
== EM_IAMCU
20003 || filedata
->file_header
.e_machine
== EM_386
)
20005 unsigned int bitmask
;
20008 bitmask
= byte_get (ptr
, 4);
20014 case GNU_PROPERTY_X86_ISA_1_USED
:
20016 printf (_("x86 ISA used: <corrupt length: %#x> "),
20020 printf ("x86 ISA used: ");
20021 decode_x86_isa (bitmask
);
20025 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
20027 printf (_("x86 ISA needed: <corrupt length: %#x> "),
20031 printf ("x86 ISA needed: ");
20032 decode_x86_isa (bitmask
);
20036 case GNU_PROPERTY_X86_FEATURE_1_AND
:
20038 printf (_("x86 feature: <corrupt length: %#x> "),
20042 printf ("x86 feature: ");
20043 decode_x86_feature_1 (bitmask
);
20047 case GNU_PROPERTY_X86_FEATURE_2_USED
:
20049 printf (_("x86 feature used: <corrupt length: %#x> "),
20053 printf ("x86 feature used: ");
20054 decode_x86_feature_2 (bitmask
);
20058 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
20060 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
20063 printf ("x86 feature needed: ");
20064 decode_x86_feature_2 (bitmask
);
20068 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
20070 printf (_("x86 ISA used: <corrupt length: %#x> "),
20074 printf ("x86 ISA used: ");
20075 decode_x86_compat_isa (bitmask
);
20079 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
20081 printf (_("x86 ISA needed: <corrupt length: %#x> "),
20085 printf ("x86 ISA needed: ");
20086 decode_x86_compat_isa (bitmask
);
20090 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_USED
:
20092 printf (_("x86 ISA used: <corrupt length: %#x> "),
20096 printf ("x86 ISA used: ");
20097 decode_x86_compat_2_isa (bitmask
);
20101 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_NEEDED
:
20103 printf (_("x86 ISA needed: <corrupt length: %#x> "),
20107 printf ("x86 ISA needed: ");
20108 decode_x86_compat_2_isa (bitmask
);
20116 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
20118 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
20120 printf ("AArch64 feature: ");
20122 printf (_("<corrupt length: %#x> "), datasz
);
20124 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
20133 case GNU_PROPERTY_STACK_SIZE
:
20134 printf (_("stack size: "));
20135 if (datasz
!= size
)
20136 printf (_("<corrupt length: %#x> "), datasz
);
20138 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
20141 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
20142 printf ("no copy on protected ");
20144 printf (_("<corrupt length: %#x> "), datasz
);
20148 if ((type
>= GNU_PROPERTY_UINT32_AND_LO
20149 && type
<= GNU_PROPERTY_UINT32_AND_HI
)
20150 || (type
>= GNU_PROPERTY_UINT32_OR_LO
20151 && type
<= GNU_PROPERTY_UINT32_OR_HI
))
20155 case GNU_PROPERTY_1_NEEDED
:
20157 printf (_("1_needed: <corrupt length: %#x> "),
20161 unsigned int bitmask
= byte_get (ptr
, 4);
20162 printf ("1_needed: ");
20163 decode_1_needed (bitmask
);
20170 if (type
<= GNU_PROPERTY_UINT32_AND_HI
)
20171 printf (_("UINT32_AND (%#x): "), type
);
20173 printf (_("UINT32_OR (%#x): "), type
);
20175 printf (_("<corrupt length: %#x> "), datasz
);
20177 printf ("%#x", (unsigned int) byte_get (ptr
, 4));
20184 if (type
< GNU_PROPERTY_LOPROC
)
20185 printf (_("<unknown type %#x data: "), type
);
20186 else if (type
< GNU_PROPERTY_LOUSER
)
20187 printf (_("<processor-specific type %#x data: "), type
);
20189 printf (_("<application-specific type %#x data: "), type
);
20190 for (j
= 0; j
< datasz
; ++j
)
20191 printf ("%02x ", ptr
[j
] & 0xff);
20195 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
20196 if (ptr
== ptr_end
)
20209 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
20211 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
20212 switch (pnote
->type
)
20214 case NT_GNU_BUILD_ID
:
20218 printf (_(" Build ID: "));
20219 for (i
= 0; i
< pnote
->descsz
; ++i
)
20220 printf ("%02x", pnote
->descdata
[i
] & 0xff);
20225 case NT_GNU_ABI_TAG
:
20227 unsigned long os
, major
, minor
, subminor
;
20228 const char *osname
;
20230 /* PR 17531: file: 030-599401-0.004. */
20231 if (pnote
->descsz
< 16)
20233 printf (_(" <corrupt GNU_ABI_TAG>\n"));
20237 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20238 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
20239 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
20240 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
20244 case GNU_ABI_TAG_LINUX
:
20247 case GNU_ABI_TAG_HURD
:
20250 case GNU_ABI_TAG_SOLARIS
:
20251 osname
= "Solaris";
20253 case GNU_ABI_TAG_FREEBSD
:
20254 osname
= "FreeBSD";
20256 case GNU_ABI_TAG_NETBSD
:
20259 case GNU_ABI_TAG_SYLLABLE
:
20260 osname
= "Syllable";
20262 case GNU_ABI_TAG_NACL
:
20266 osname
= "Unknown";
20270 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
20271 major
, minor
, subminor
);
20275 case NT_GNU_GOLD_VERSION
:
20279 printf (_(" Version: "));
20280 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
20281 printf ("%c", pnote
->descdata
[i
]);
20288 unsigned long num_entries
, mask
;
20290 /* Hardware capabilities information. Word 0 is the number of entries.
20291 Word 1 is a bitmask of enabled entries. The rest of the descriptor
20292 is a series of entries, where each entry is a single byte followed
20293 by a nul terminated string. The byte gives the bit number to test
20294 if enabled in the bitmask. */
20295 printf (_(" Hardware Capabilities: "));
20296 if (pnote
->descsz
< 8)
20298 error (_("<corrupt GNU_HWCAP>\n"));
20301 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20302 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
20303 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
20304 /* FIXME: Add code to display the entries... */
20308 case NT_GNU_PROPERTY_TYPE_0
:
20309 print_gnu_property_note (filedata
, pnote
);
20313 /* Handle unrecognised types. An error message should have already been
20314 created by get_gnu_elf_note_type(), so all that we need to do is to
20315 display the data. */
20319 printf (_(" Description data: "));
20320 for (i
= 0; i
< pnote
->descsz
; ++i
)
20321 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
20330 static const char *
20331 get_v850_elf_note_type (enum v850_notes n_type
)
20333 static char buff
[64];
20337 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
20338 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
20339 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
20340 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
20341 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
20342 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
20344 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
20350 print_v850_note (Elf_Internal_Note
* pnote
)
20354 if (pnote
->descsz
!= 4)
20357 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
20361 printf (_("not set\n"));
20365 switch (pnote
->type
)
20367 case V850_NOTE_ALIGNMENT
:
20370 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return true;
20371 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return true;
20375 case V850_NOTE_DATA_SIZE
:
20378 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return true;
20379 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return true;
20383 case V850_NOTE_FPU_INFO
:
20386 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return true;
20387 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return true;
20391 case V850_NOTE_MMU_INFO
:
20392 case V850_NOTE_CACHE_INFO
:
20393 case V850_NOTE_SIMD_INFO
:
20394 if (val
== EF_RH850_SIMD
)
20396 printf (_("yes\n"));
20402 /* An 'unknown note type' message will already have been displayed. */
20406 printf (_("unknown value: %x\n"), val
);
20411 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
20413 unsigned int version
;
20415 switch (pnote
->type
)
20417 case NT_NETBSD_IDENT
:
20418 if (pnote
->descsz
< 1)
20420 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
20421 if ((version
/ 10000) % 100)
20422 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
20423 version
, version
/ 100000000, (version
/ 1000000) % 100,
20424 (version
/ 10000) % 100 > 26 ? "Z" : "",
20425 'A' + (version
/ 10000) % 26);
20427 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
20428 version
, version
/ 100000000, (version
/ 1000000) % 100,
20429 (version
/ 100) % 100);
20432 case NT_NETBSD_MARCH
:
20433 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
20437 case NT_NETBSD_PAX
:
20438 if (pnote
->descsz
< 1)
20440 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
20441 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
20442 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
20443 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
20444 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
20445 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
20446 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
20447 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
20451 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
20452 pnote
->descsz
, pnote
->type
);
20456 static const char *
20457 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
20461 case NT_FREEBSD_THRMISC
:
20462 return _("NT_THRMISC (thrmisc structure)");
20463 case NT_FREEBSD_PROCSTAT_PROC
:
20464 return _("NT_PROCSTAT_PROC (proc data)");
20465 case NT_FREEBSD_PROCSTAT_FILES
:
20466 return _("NT_PROCSTAT_FILES (files data)");
20467 case NT_FREEBSD_PROCSTAT_VMMAP
:
20468 return _("NT_PROCSTAT_VMMAP (vmmap data)");
20469 case NT_FREEBSD_PROCSTAT_GROUPS
:
20470 return _("NT_PROCSTAT_GROUPS (groups data)");
20471 case NT_FREEBSD_PROCSTAT_UMASK
:
20472 return _("NT_PROCSTAT_UMASK (umask data)");
20473 case NT_FREEBSD_PROCSTAT_RLIMIT
:
20474 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
20475 case NT_FREEBSD_PROCSTAT_OSREL
:
20476 return _("NT_PROCSTAT_OSREL (osreldate data)");
20477 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
20478 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
20479 case NT_FREEBSD_PROCSTAT_AUXV
:
20480 return _("NT_PROCSTAT_AUXV (auxv data)");
20481 case NT_FREEBSD_PTLWPINFO
:
20482 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
20483 case NT_FREEBSD_X86_SEGBASES
:
20484 return _("NT_X86_SEGBASES (x86 segment base registers)");
20486 return get_note_type (filedata
, e_type
);
20489 static const char *
20490 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
20492 static char buff
[64];
20496 case NT_NETBSDCORE_PROCINFO
:
20497 /* NetBSD core "procinfo" structure. */
20498 return _("NetBSD procinfo structure");
20500 case NT_NETBSDCORE_AUXV
:
20501 return _("NetBSD ELF auxiliary vector data");
20503 case NT_NETBSDCORE_LWPSTATUS
:
20504 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
20507 /* As of Jan 2020 there are no other machine-independent notes
20508 defined for NetBSD core files. If the note type is less
20509 than the start of the machine-dependent note types, we don't
20512 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
20514 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
20520 switch (filedata
->file_header
.e_machine
)
20522 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
20523 and PT_GETFPREGS == mach+2. */
20528 case EM_SPARC32PLUS
:
20532 case NT_NETBSDCORE_FIRSTMACH
+ 0:
20533 return _("PT_GETREGS (reg structure)");
20534 case NT_NETBSDCORE_FIRSTMACH
+ 2:
20535 return _("PT_GETFPREGS (fpreg structure)");
20541 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
20542 There's also old PT___GETREGS40 == mach + 1 for old reg
20543 structure which lacks GBR. */
20547 case NT_NETBSDCORE_FIRSTMACH
+ 1:
20548 return _("PT___GETREGS40 (old reg structure)");
20549 case NT_NETBSDCORE_FIRSTMACH
+ 3:
20550 return _("PT_GETREGS (reg structure)");
20551 case NT_NETBSDCORE_FIRSTMACH
+ 5:
20552 return _("PT_GETFPREGS (fpreg structure)");
20558 /* On all other arch's, PT_GETREGS == mach+1 and
20559 PT_GETFPREGS == mach+3. */
20563 case NT_NETBSDCORE_FIRSTMACH
+ 1:
20564 return _("PT_GETREGS (reg structure)");
20565 case NT_NETBSDCORE_FIRSTMACH
+ 3:
20566 return _("PT_GETFPREGS (fpreg structure)");
20572 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
20573 e_type
- NT_NETBSDCORE_FIRSTMACH
);
20577 static const char *
20578 get_openbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
20582 case NT_OPENBSD_PROCINFO
:
20583 return _("OpenBSD procinfo structure");
20584 case NT_OPENBSD_AUXV
:
20585 return _("OpenBSD ELF auxiliary vector data");
20586 case NT_OPENBSD_REGS
:
20587 return _("OpenBSD regular registers");
20588 case NT_OPENBSD_FPREGS
:
20589 return _("OpenBSD floating point registers");
20590 case NT_OPENBSD_WCOOKIE
:
20591 return _("OpenBSD window cookie");
20594 return get_note_type (filedata
, e_type
);
20597 static const char *
20598 get_stapsdt_note_type (unsigned e_type
)
20600 static char buff
[64];
20605 return _("NT_STAPSDT (SystemTap probe descriptors)");
20611 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
20616 print_stapsdt_note (Elf_Internal_Note
*pnote
)
20618 size_t len
, maxlen
;
20619 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
20620 char *data
= pnote
->descdata
;
20621 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
20622 uint64_t pc
, base_addr
, semaphore
;
20623 char *provider
, *probe
, *arg_fmt
;
20625 if (pnote
->descsz
< (addr_size
* 3))
20626 goto stapdt_note_too_small
;
20628 pc
= byte_get ((unsigned char *) data
, addr_size
);
20631 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
20634 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
20637 if (data
>= data_end
)
20638 goto stapdt_note_too_small
;
20639 maxlen
= data_end
- data
;
20640 len
= strnlen (data
, maxlen
);
20647 goto stapdt_note_too_small
;
20649 if (data
>= data_end
)
20650 goto stapdt_note_too_small
;
20651 maxlen
= data_end
- data
;
20652 len
= strnlen (data
, maxlen
);
20659 goto stapdt_note_too_small
;
20661 if (data
>= data_end
)
20662 goto stapdt_note_too_small
;
20663 maxlen
= data_end
- data
;
20664 len
= strnlen (data
, maxlen
);
20671 goto stapdt_note_too_small
;
20673 printf (_(" Provider: %s\n"), provider
);
20674 printf (_(" Name: %s\n"), probe
);
20675 printf (_(" Location: "));
20676 print_vma (pc
, FULL_HEX
);
20677 printf (_(", Base: "));
20678 print_vma (base_addr
, FULL_HEX
);
20679 printf (_(", Semaphore: "));
20680 print_vma (semaphore
, FULL_HEX
);
20682 printf (_(" Arguments: %s\n"), arg_fmt
);
20684 return data
== data_end
;
20686 stapdt_note_too_small
:
20687 printf (_(" <corrupt - note is too small>\n"));
20688 error (_("corrupt stapdt note - the data size is too small\n"));
20693 print_fdo_note (Elf_Internal_Note
* pnote
)
20695 if (pnote
->descsz
> 0 && pnote
->type
== FDO_PACKAGING_METADATA
)
20697 printf (_(" Packaging Metadata: %.*s\n"), (int) pnote
->descsz
, pnote
->descdata
);
20703 static const char *
20704 get_ia64_vms_note_type (unsigned e_type
)
20706 static char buff
[64];
20711 return _("NT_VMS_MHD (module header)");
20713 return _("NT_VMS_LNM (language name)");
20715 return _("NT_VMS_SRC (source files)");
20717 return "NT_VMS_TITLE";
20719 return _("NT_VMS_EIDC (consistency check)");
20720 case NT_VMS_FPMODE
:
20721 return _("NT_VMS_FPMODE (FP mode)");
20722 case NT_VMS_LINKTIME
:
20723 return "NT_VMS_LINKTIME";
20724 case NT_VMS_IMGNAM
:
20725 return _("NT_VMS_IMGNAM (image name)");
20727 return _("NT_VMS_IMGID (image id)");
20728 case NT_VMS_LINKID
:
20729 return _("NT_VMS_LINKID (link id)");
20730 case NT_VMS_IMGBID
:
20731 return _("NT_VMS_IMGBID (build id)");
20732 case NT_VMS_GSTNAM
:
20733 return _("NT_VMS_GSTNAM (sym table name)");
20734 case NT_VMS_ORIG_DYN
:
20735 return "NT_VMS_ORIG_DYN";
20736 case NT_VMS_PATCHTIME
:
20737 return "NT_VMS_PATCHTIME";
20739 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
20745 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
20747 int maxlen
= pnote
->descsz
;
20749 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
20750 goto desc_size_fail
;
20752 switch (pnote
->type
)
20756 goto desc_size_fail
;
20758 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
20760 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
20761 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
20762 if (l
+ 34 < maxlen
)
20764 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
20765 if (l
+ 35 < maxlen
)
20766 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
20768 printf (_(" Module version : <missing>\n"));
20772 printf (_(" Module name : <missing>\n"));
20773 printf (_(" Module version : <missing>\n"));
20778 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
20781 case NT_VMS_FPMODE
:
20782 printf (_(" Floating Point mode: "));
20784 goto desc_size_fail
;
20785 /* FIXME: Generate an error if descsz > 8 ? */
20787 printf ("0x%016" PRIx64
"\n",
20788 byte_get ((unsigned char *) pnote
->descdata
, 8));
20791 case NT_VMS_LINKTIME
:
20792 printf (_(" Link time: "));
20794 goto desc_size_fail
;
20795 /* FIXME: Generate an error if descsz > 8 ? */
20797 print_vms_time (byte_get ((unsigned char *) pnote
->descdata
, 8));
20801 case NT_VMS_PATCHTIME
:
20802 printf (_(" Patch time: "));
20804 goto desc_size_fail
;
20805 /* FIXME: Generate an error if descsz > 8 ? */
20807 print_vms_time (byte_get ((unsigned char *) pnote
->descdata
, 8));
20811 case NT_VMS_ORIG_DYN
:
20813 goto desc_size_fail
;
20815 printf (_(" Major id: %u, minor id: %u\n"),
20816 (unsigned) byte_get ((unsigned char *) pnote
->descdata
, 4),
20817 (unsigned) byte_get ((unsigned char *) pnote
->descdata
+ 4, 4));
20818 printf (_(" Last modified : "));
20819 print_vms_time (byte_get ((unsigned char *) pnote
->descdata
+ 8, 8));
20820 printf (_("\n Link flags : "));
20821 printf ("0x%016" PRIx64
"\n",
20822 byte_get ((unsigned char *) pnote
->descdata
+ 16, 8));
20823 printf (_(" Header flags: 0x%08x\n"),
20824 (unsigned) byte_get ((unsigned char *) pnote
->descdata
+ 24, 4));
20825 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
20828 case NT_VMS_IMGNAM
:
20829 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
20832 case NT_VMS_GSTNAM
:
20833 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
20837 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
20840 case NT_VMS_LINKID
:
20841 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
20851 printf (_(" <corrupt - data size is too small>\n"));
20852 error (_("corrupt IA64 note: data size is too small\n"));
20856 struct build_attr_cache
{
20857 Filedata
*filedata
;
20859 unsigned long strtablen
;
20860 Elf_Internal_Sym
*symtab
;
20861 unsigned long nsyms
;
20864 /* Find the symbol associated with a build attribute that is attached
20865 to address OFFSET. If PNAME is non-NULL then store the name of
20866 the symbol (if found) in the provided pointer, Returns NULL if a
20867 symbol could not be found. */
20869 static Elf_Internal_Sym
*
20870 get_symbol_for_build_attribute (Filedata
*filedata
,
20871 unsigned long offset
,
20873 const char **pname
)
20875 Elf_Internal_Sym
*saved_sym
= NULL
;
20876 Elf_Internal_Sym
*sym
;
20878 if (filedata
->section_headers
!= NULL
20879 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
20881 Elf_Internal_Shdr
* symsec
;
20883 free (ba_cache
.strtab
);
20884 ba_cache
.strtab
= NULL
;
20885 free (ba_cache
.symtab
);
20886 ba_cache
.symtab
= NULL
;
20888 /* Load the symbol and string sections. */
20889 for (symsec
= filedata
->section_headers
;
20890 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
20893 if (symsec
->sh_type
== SHT_SYMTAB
20894 && get_symtab (filedata
, symsec
,
20895 &ba_cache
.symtab
, &ba_cache
.nsyms
,
20896 &ba_cache
.strtab
, &ba_cache
.strtablen
))
20899 ba_cache
.filedata
= filedata
;
20902 if (ba_cache
.symtab
== NULL
)
20905 /* Find a symbol whose value matches offset. */
20906 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
20907 if (sym
->st_value
== offset
)
20909 if (sym
->st_name
>= ba_cache
.strtablen
)
20910 /* Huh ? This should not happen. */
20913 if (ba_cache
.strtab
[sym
->st_name
] == 0)
20916 /* The AArch64, ARM and RISC-V architectures define mapping symbols
20917 (eg $d, $x, $t) which we want to ignore. */
20918 if (ba_cache
.strtab
[sym
->st_name
] == '$'
20919 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
20920 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
20925 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
20926 and FILE or OBJECT symbols over NOTYPE symbols. We skip
20927 FUNC symbols entirely. */
20928 switch (ELF_ST_TYPE (sym
->st_info
))
20935 /* If the symbol has a size associated
20936 with it then we can stop searching. */
20937 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
20942 /* Ignore function symbols. */
20949 switch (ELF_ST_BIND (sym
->st_info
))
20952 if (saved_sym
== NULL
20953 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
20958 if (saved_sym
== NULL
)
20968 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
20976 if (saved_sym
&& pname
)
20977 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
20982 /* Returns true iff addr1 and addr2 are in the same section. */
20985 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
20987 Elf_Internal_Shdr
* a1
;
20988 Elf_Internal_Shdr
* a2
;
20990 a1
= find_section_by_address (filedata
, addr1
);
20991 a2
= find_section_by_address (filedata
, addr2
);
20993 return a1
== a2
&& a1
!= NULL
;
20997 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
20998 Filedata
* filedata
)
21000 static unsigned long global_offset
= 0;
21001 static unsigned long global_end
= 0;
21002 static unsigned long func_offset
= 0;
21003 static unsigned long func_end
= 0;
21005 Elf_Internal_Sym
*sym
;
21007 unsigned long start
;
21009 bool is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
21011 switch (pnote
->descsz
)
21014 /* A zero-length description means that the range of
21015 the previous note of the same type should be used. */
21018 if (global_end
> global_offset
)
21019 printf (_(" Applies to region from %#lx to %#lx\n"),
21020 global_offset
, global_end
);
21022 printf (_(" Applies to region from %#lx\n"), global_offset
);
21026 if (func_end
> func_offset
)
21027 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
21029 printf (_(" Applies to region from %#lx\n"), func_offset
);
21034 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
21039 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
21040 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
21044 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
21045 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
21049 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
21050 printf (_(" <invalid descsz>"));
21055 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
21056 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
21057 in order to avoid them being confused with the start address of the
21058 first function in the file... */
21059 if (sym
== NULL
&& is_open_attr
)
21060 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
21063 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
21064 end
= start
+ sym
->st_size
;
21068 /* FIXME: Need to properly allow for section alignment.
21069 16 is just the alignment used on x86_64. */
21071 && start
> BFD_ALIGN (global_end
, 16)
21072 /* Build notes are not guaranteed to be organised in order of
21073 increasing address, but we should find the all of the notes
21074 for one section in the same place. */
21075 && same_section (filedata
, start
, global_end
))
21076 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
21077 global_end
+ 1, start
- 1);
21079 printf (_(" Applies to region from %#lx"), start
);
21080 global_offset
= start
;
21084 printf (_(" to %#lx"), end
);
21090 printf (_(" Applies to region from %#lx"), start
);
21091 func_offset
= start
;
21095 printf (_(" to %#lx"), end
);
21101 printf (_(" (%s)"), name
);
21108 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
21110 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
21111 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
21112 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
21114 char name_attribute
;
21115 const char * expected_types
;
21116 const char * name
= pnote
->namedata
;
21120 if (name
== NULL
|| pnote
->namesz
< 2)
21122 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
21123 print_symbol (-20, _(" <corrupt name>"));
21132 /* Version 2 of the spec adds a "GA" prefix to the name field. */
21133 if (name
[0] == 'G' && name
[1] == 'A')
21135 if (pnote
->namesz
< 4)
21137 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
21138 print_symbol (-20, _(" <corrupt name>"));
21147 switch ((name_type
= * name
))
21149 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
21150 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
21151 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
21152 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
21153 printf ("%c", * name
);
21157 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
21158 print_symbol (-20, _("<unknown name type>"));
21165 switch ((name_attribute
= * name
))
21167 case GNU_BUILD_ATTRIBUTE_VERSION
:
21168 text
= _("<version>");
21169 expected_types
= string_expected
;
21172 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
21173 text
= _("<stack prot>");
21174 expected_types
= "!+*";
21177 case GNU_BUILD_ATTRIBUTE_RELRO
:
21178 text
= _("<relro>");
21179 expected_types
= bool_expected
;
21182 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
21183 text
= _("<stack size>");
21184 expected_types
= number_expected
;
21187 case GNU_BUILD_ATTRIBUTE_TOOL
:
21188 text
= _("<tool>");
21189 expected_types
= string_expected
;
21192 case GNU_BUILD_ATTRIBUTE_ABI
:
21194 expected_types
= "$*";
21197 case GNU_BUILD_ATTRIBUTE_PIC
:
21199 expected_types
= number_expected
;
21202 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
21203 text
= _("<short enum>");
21204 expected_types
= bool_expected
;
21208 if (ISPRINT (* name
))
21210 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
21212 if (len
> left
&& ! do_wide
)
21214 printf ("%.*s:", len
, name
);
21220 static char tmpbuf
[128];
21222 error (_("unrecognised byte in name field: %d\n"), * name
);
21223 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
21227 expected_types
= "*$!+";
21232 left
-= printf ("%s", text
);
21234 if (strchr (expected_types
, name_type
) == NULL
)
21235 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
21237 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
21239 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
21240 (unsigned long) pnote
->namesz
,
21241 (long) (name
- pnote
->namedata
));
21245 if (left
< 1 && ! do_wide
)
21250 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
21252 unsigned int bytes
;
21253 unsigned long long val
= 0;
21254 unsigned int shift
= 0;
21255 char * decoded
= NULL
;
21257 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
21259 /* The -1 is because the name field is always 0 terminated, and we
21260 want to be able to ensure that the shift in the while loop below
21261 will not overflow. */
21264 if (bytes
> sizeof (val
))
21266 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
21268 bytes
= sizeof (val
);
21270 /* We do not bother to warn if bytes == 0 as this can
21271 happen with some early versions of the gcc plugin. */
21275 unsigned long long byte
= *name
++ & 0xff;
21277 val
|= byte
<< shift
;
21281 switch (name_attribute
)
21283 case GNU_BUILD_ATTRIBUTE_PIC
:
21286 case 0: decoded
= "static"; break;
21287 case 1: decoded
= "pic"; break;
21288 case 2: decoded
= "PIC"; break;
21289 case 3: decoded
= "pie"; break;
21290 case 4: decoded
= "PIE"; break;
21294 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
21297 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
21298 case 0: decoded
= "off"; break;
21299 case 1: decoded
= "on"; break;
21300 case 2: decoded
= "all"; break;
21301 case 3: decoded
= "strong"; break;
21302 case 4: decoded
= "explicit"; break;
21310 if (decoded
!= NULL
)
21312 print_symbol (-left
, decoded
);
21323 left
-= printf ("0x%llx", val
);
21325 left
-= printf ("0x%-.*llx", left
, val
);
21329 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
21330 left
-= print_symbol (- left
, name
);
21332 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
21333 left
-= print_symbol (- left
, "true");
21335 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
21336 left
-= print_symbol (- left
, "false");
21340 if (do_wide
&& left
> 0)
21341 printf ("%-*s", left
, " ");
21346 /* Print the contents of PNOTE as hex. */
21349 print_note_contents_hex (Elf_Internal_Note
*pnote
)
21355 printf (_(" description data: "));
21356 for (i
= 0; i
< pnote
->descsz
; i
++)
21357 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
21366 #if defined HAVE_MSGPACK
21369 print_indents (int n
)
21373 for (int i
= 0; i
< n
; i
++)
21377 /* Print OBJ in human-readable form. */
21380 dump_msgpack_obj (const msgpack_object
*obj
, int indent
)
21384 case MSGPACK_OBJECT_NIL
:
21388 case MSGPACK_OBJECT_BOOLEAN
:
21389 printf ("%s", obj
->via
.boolean
? "true" : "false");
21392 case MSGPACK_OBJECT_POSITIVE_INTEGER
:
21393 printf ("%" PRIu64
, obj
->via
.u64
);
21396 case MSGPACK_OBJECT_NEGATIVE_INTEGER
:
21397 printf ("%" PRIi64
, obj
->via
.i64
);
21400 case MSGPACK_OBJECT_FLOAT32
:
21401 case MSGPACK_OBJECT_FLOAT64
:
21402 printf ("%f", obj
->via
.f64
);
21405 case MSGPACK_OBJECT_STR
:
21406 printf ("\"%.*s\"", obj
->via
.str
.size
, obj
->via
.str
.ptr
);
21409 case MSGPACK_OBJECT_ARRAY
:
21411 const msgpack_object_array
*array
= &obj
->via
.array
;
21416 for (uint32_t i
= 0; i
< array
->size
; ++i
)
21418 const msgpack_object
*item
= &array
->ptr
[i
];
21420 print_indents (indent
);
21421 dump_msgpack_obj (item
, indent
);
21426 print_indents (indent
);
21432 case MSGPACK_OBJECT_MAP
:
21434 const msgpack_object_map
*map
= &obj
->via
.map
;
21439 for (uint32_t i
= 0; i
< map
->size
; ++i
)
21441 const msgpack_object_kv
*kv
= &map
->ptr
[i
];
21442 const msgpack_object
*key
= &kv
->key
;
21443 const msgpack_object
*val
= &kv
->val
;
21445 print_indents (indent
);
21446 dump_msgpack_obj (key
, indent
);
21448 dump_msgpack_obj (val
, indent
);
21454 print_indents (indent
);
21460 case MSGPACK_OBJECT_BIN
:
21464 case MSGPACK_OBJECT_EXT
:
21471 dump_msgpack (const msgpack_unpacked
*msg
)
21474 dump_msgpack_obj (&msg
->data
, 0);
21478 #endif /* defined HAVE_MSGPACK */
21481 print_amdgpu_note (Elf_Internal_Note
*pnote
)
21483 #if defined HAVE_MSGPACK
21484 /* If msgpack is available, decode and dump the note's content. */
21486 msgpack_unpacked msg
;
21487 msgpack_unpack_return msgpack_ret
;
21489 assert (pnote
->type
== NT_AMDGPU_METADATA
);
21491 msgpack_unpacked_init (&msg
);
21492 msgpack_ret
= msgpack_unpack_next (&msg
, pnote
->descdata
, pnote
->descsz
,
21495 switch (msgpack_ret
)
21497 case MSGPACK_UNPACK_SUCCESS
:
21498 dump_msgpack (&msg
);
21503 error (_("failed to unpack msgpack contents in NT_AMDGPU_METADATA note"));
21508 msgpack_unpacked_destroy (&msg
);
21511 /* msgpack is not available, dump contents as hex. */
21512 print_note_contents_hex (pnote
);
21517 /* Note that by the ELF standard, the name field is already null byte
21518 terminated, and namesz includes the terminating null byte.
21519 I.E. the value of namesz for the name "FSF" is 4.
21521 If the value of namesz is zero, there is no name present. */
21524 process_note (Elf_Internal_Note
* pnote
,
21525 Filedata
* filedata
)
21527 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
21530 if (pnote
->namesz
== 0)
21531 /* If there is no note name, then use the default set of
21532 note type strings. */
21533 nt
= get_note_type (filedata
, pnote
->type
);
21535 else if (startswith (pnote
->namedata
, "GNU"))
21536 /* GNU-specific object file notes. */
21537 nt
= get_gnu_elf_note_type (pnote
->type
);
21539 else if (startswith (pnote
->namedata
, "AMDGPU"))
21540 /* AMDGPU-specific object file notes. */
21541 nt
= get_amdgpu_elf_note_type (pnote
->type
);
21543 else if (startswith (pnote
->namedata
, "FreeBSD"))
21544 /* FreeBSD-specific core file notes. */
21545 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
21547 else if (startswith (pnote
->namedata
, "NetBSD-CORE"))
21548 /* NetBSD-specific core file notes. */
21549 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
21551 else if (startswith (pnote
->namedata
, "NetBSD"))
21552 /* NetBSD-specific core file notes. */
21553 return process_netbsd_elf_note (pnote
);
21555 else if (startswith (pnote
->namedata
, "PaX"))
21556 /* NetBSD-specific core file notes. */
21557 return process_netbsd_elf_note (pnote
);
21559 else if (startswith (pnote
->namedata
, "OpenBSD"))
21560 /* OpenBSD-specific core file notes. */
21561 nt
= get_openbsd_elfcore_note_type (filedata
, pnote
->type
);
21563 else if (startswith (pnote
->namedata
, "SPU/"))
21565 /* SPU-specific core file notes. */
21566 nt
= pnote
->namedata
+ 4;
21570 else if (startswith (pnote
->namedata
, "IPF/VMS"))
21571 /* VMS/ia64-specific file notes. */
21572 nt
= get_ia64_vms_note_type (pnote
->type
);
21574 else if (startswith (pnote
->namedata
, "stapsdt"))
21575 nt
= get_stapsdt_note_type (pnote
->type
);
21578 /* Don't recognize this note name; just use the default set of
21579 note type strings. */
21580 nt
= get_note_type (filedata
, pnote
->type
);
21584 if (((startswith (pnote
->namedata
, "GA")
21585 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
21586 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
21587 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
21588 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
21589 print_gnu_build_attribute_name (pnote
);
21591 print_symbol (-20, name
);
21594 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
21596 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
21598 if (startswith (pnote
->namedata
, "IPF/VMS"))
21599 return print_ia64_vms_note (pnote
);
21600 else if (startswith (pnote
->namedata
, "GNU"))
21601 return print_gnu_note (filedata
, pnote
);
21602 else if (startswith (pnote
->namedata
, "stapsdt"))
21603 return print_stapsdt_note (pnote
);
21604 else if (startswith (pnote
->namedata
, "CORE"))
21605 return print_core_note (pnote
);
21606 else if (startswith (pnote
->namedata
, "FDO"))
21607 return print_fdo_note (pnote
);
21608 else if (((startswith (pnote
->namedata
, "GA")
21609 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
21610 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
21611 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
21612 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
21613 return print_gnu_build_attribute_description (pnote
, filedata
);
21614 else if (startswith (pnote
->namedata
, "AMDGPU")
21615 && pnote
->type
== NT_AMDGPU_METADATA
)
21616 return print_amdgpu_note (pnote
);
21618 print_note_contents_hex (pnote
);
21623 process_notes_at (Filedata
* filedata
,
21624 Elf_Internal_Shdr
* section
,
21629 Elf_External_Note
*pnotes
;
21630 Elf_External_Note
*external
;
21639 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
21642 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
21650 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
21653 if (pnotes
== NULL
)
21658 if (filedata
->is_separate
)
21659 printf (_("In linked file '%s': "), filedata
->file_name
);
21663 printf (_("Displaying notes found in: %s\n"), printable_section_name (filedata
, section
));
21665 printf (_("Displaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
21666 (unsigned long) offset
, (unsigned long) length
);
21668 /* NB: Some note sections may have alignment value of 0 or 1. gABI
21669 specifies that notes should be aligned to 4 bytes in 32-bit
21670 objects and to 8 bytes in 64-bit objects. As a Linux extension,
21671 we also support 4 byte alignment in 64-bit objects. If section
21672 alignment is less than 4, we treate alignment as 4 bytes. */
21675 else if (align
!= 4 && align
!= 8)
21677 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
21683 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
21685 end
= (char *) pnotes
+ length
;
21686 while ((char *) external
< end
)
21688 Elf_Internal_Note inote
;
21691 char * temp
= NULL
;
21692 size_t data_remaining
= end
- (char *) external
;
21694 if (!is_ia64_vms (filedata
))
21696 /* PR binutils/15191
21697 Make sure that there is enough data to read. */
21698 min_notesz
= offsetof (Elf_External_Note
, name
);
21699 if (data_remaining
< min_notesz
)
21701 warn (ngettext ("Corrupt note: only %ld byte remains, "
21702 "not enough for a full note\n",
21703 "Corrupt note: only %ld bytes remain, "
21704 "not enough for a full note\n",
21706 (long) data_remaining
);
21709 data_remaining
-= min_notesz
;
21711 inote
.type
= BYTE_GET (external
->type
);
21712 inote
.namesz
= BYTE_GET (external
->namesz
);
21713 inote
.namedata
= external
->name
;
21714 inote
.descsz
= BYTE_GET (external
->descsz
);
21715 inote
.descdata
= ((char *) external
21716 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
21717 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
21718 next
= ((char *) external
21719 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
21723 Elf64_External_VMS_Note
*vms_external
;
21725 /* PR binutils/15191
21726 Make sure that there is enough data to read. */
21727 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
21728 if (data_remaining
< min_notesz
)
21730 warn (ngettext ("Corrupt note: only %ld byte remains, "
21731 "not enough for a full note\n",
21732 "Corrupt note: only %ld bytes remain, "
21733 "not enough for a full note\n",
21735 (long) data_remaining
);
21738 data_remaining
-= min_notesz
;
21740 vms_external
= (Elf64_External_VMS_Note
*) external
;
21741 inote
.type
= BYTE_GET (vms_external
->type
);
21742 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
21743 inote
.namedata
= vms_external
->name
;
21744 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
21745 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
21746 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
21747 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
21750 /* PR 17531: file: 3443835e. */
21751 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
21752 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
21753 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
21754 || (size_t) (next
- inote
.descdata
) < inote
.descsz
21755 || ((size_t) (next
- inote
.descdata
)
21756 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
21758 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
21759 (unsigned long) ((char *) external
- (char *) pnotes
));
21760 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
21761 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
21765 external
= (Elf_External_Note
*) next
;
21767 /* Verify that name is null terminated. It appears that at least
21768 one version of Linux (RedHat 6.0) generates corefiles that don't
21769 comply with the ELF spec by failing to include the null byte in
21771 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
21773 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
21775 temp
= (char *) malloc (inote
.namesz
+ 1);
21778 error (_("Out of memory allocating space for inote name\n"));
21783 memcpy (temp
, inote
.namedata
, inote
.namesz
);
21784 inote
.namedata
= temp
;
21786 inote
.namedata
[inote
.namesz
] = 0;
21789 if (! process_note (& inote
, filedata
))
21802 process_corefile_note_segments (Filedata
* filedata
)
21804 Elf_Internal_Phdr
*segment
;
21808 if (! get_program_headers (filedata
))
21811 for (i
= 0, segment
= filedata
->program_headers
;
21812 i
< filedata
->file_header
.e_phnum
;
21815 if (segment
->p_type
== PT_NOTE
)
21816 if (! process_notes_at (filedata
, NULL
, segment
->p_offset
,
21817 segment
->p_filesz
, segment
->p_align
))
21825 process_v850_notes (Filedata
* filedata
, uint64_t offset
, uint64_t length
)
21827 Elf_External_Note
* pnotes
;
21828 Elf_External_Note
* external
;
21835 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
21837 if (pnotes
== NULL
)
21841 end
= (char*) pnotes
+ length
;
21843 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
21844 (unsigned long) offset
, (unsigned long) length
);
21846 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
21848 Elf_External_Note
* next
;
21849 Elf_Internal_Note inote
;
21851 inote
.type
= BYTE_GET (external
->type
);
21852 inote
.namesz
= BYTE_GET (external
->namesz
);
21853 inote
.namedata
= external
->name
;
21854 inote
.descsz
= BYTE_GET (external
->descsz
);
21855 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
21856 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
21858 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
21860 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
21861 inote
.descdata
= inote
.namedata
;
21865 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
21867 if ( ((char *) next
> end
)
21868 || ((char *) next
< (char *) pnotes
))
21870 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
21871 (unsigned long) ((char *) external
- (char *) pnotes
));
21872 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
21873 inote
.type
, inote
.namesz
, inote
.descsz
);
21879 /* Prevent out-of-bounds indexing. */
21880 if ( inote
.namedata
+ inote
.namesz
> end
21881 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
21883 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
21884 (unsigned long) ((char *) external
- (char *) pnotes
));
21885 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
21886 inote
.type
, inote
.namesz
, inote
.descsz
);
21890 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
21892 if (! print_v850_note (& inote
))
21895 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
21896 inote
.namesz
, inote
.descsz
);
21906 process_note_sections (Filedata
* filedata
)
21908 Elf_Internal_Shdr
*section
;
21910 unsigned int n
= 0;
21913 for (i
= 0, section
= filedata
->section_headers
;
21914 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
21917 if (section
->sh_type
== SHT_NOTE
)
21919 if (! process_notes_at (filedata
, section
, section
->sh_offset
,
21920 section
->sh_size
, section
->sh_addralign
))
21925 if (( filedata
->file_header
.e_machine
== EM_V800
21926 || filedata
->file_header
.e_machine
== EM_V850
21927 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
21928 && section
->sh_type
== SHT_RENESAS_INFO
)
21930 if (! process_v850_notes (filedata
, section
->sh_offset
,
21938 /* Try processing NOTE segments instead. */
21939 return process_corefile_note_segments (filedata
);
21945 process_notes (Filedata
* filedata
)
21947 /* If we have not been asked to display the notes then do nothing. */
21951 if (filedata
->file_header
.e_type
!= ET_CORE
)
21952 return process_note_sections (filedata
);
21954 /* No program headers means no NOTE segment. */
21955 if (filedata
->file_header
.e_phnum
> 0)
21956 return process_corefile_note_segments (filedata
);
21958 if (filedata
->is_separate
)
21959 printf (_("No notes found in linked file '%s'.\n"),
21960 filedata
->file_name
);
21962 printf (_("No notes found file.\n"));
21967 static unsigned char *
21968 display_public_gnu_attributes (unsigned char * start
,
21969 const unsigned char * const end
)
21971 printf (_(" Unknown GNU attribute: %s\n"), start
);
21973 start
+= strnlen ((char *) start
, end
- start
);
21974 display_raw_attribute (start
, end
);
21976 return (unsigned char *) end
;
21979 static unsigned char *
21980 display_generic_attribute (unsigned char * start
,
21982 const unsigned char * const end
)
21985 return (unsigned char *) end
;
21987 return display_tag_value (tag
, start
, end
);
21991 process_arch_specific (Filedata
* filedata
)
21996 switch (filedata
->file_header
.e_machine
)
21999 case EM_ARC_COMPACT
:
22000 case EM_ARC_COMPACT2
:
22001 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
22002 display_arc_attribute
,
22003 display_generic_attribute
);
22005 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
22006 display_arm_attribute
,
22007 display_generic_attribute
);
22010 case EM_MIPS_RS3_LE
:
22011 return process_mips_specific (filedata
);
22014 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
22015 display_msp430_attribute
,
22016 display_msp430_gnu_attribute
);
22019 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
22020 display_riscv_attribute
,
22021 display_generic_attribute
);
22024 return process_nds32_specific (filedata
);
22027 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22028 display_m68k_gnu_attribute
);
22032 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22033 display_power_gnu_attribute
);
22037 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22038 display_s390_gnu_attribute
);
22041 case EM_SPARC32PLUS
:
22043 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22044 display_sparc_gnu_attribute
);
22047 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
22048 display_tic6x_attribute
,
22049 display_generic_attribute
);
22052 return process_attributes (filedata
, "csky", SHT_CSKY_ATTRIBUTES
,
22053 display_csky_attribute
, NULL
);
22056 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
22057 display_public_gnu_attributes
,
22058 display_generic_attribute
);
22063 get_file_header (Filedata
* filedata
)
22065 /* Read in the identity array. */
22066 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
22069 /* Determine how to read the rest of the header. */
22070 switch (filedata
->file_header
.e_ident
[EI_DATA
])
22075 byte_get
= byte_get_little_endian
;
22076 byte_put
= byte_put_little_endian
;
22079 byte_get
= byte_get_big_endian
;
22080 byte_put
= byte_put_big_endian
;
22084 /* For now we only support 32 bit and 64 bit ELF files. */
22085 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
22087 /* Read in the rest of the header. */
22090 Elf32_External_Ehdr ehdr32
;
22092 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
22095 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
22096 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
22097 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
22098 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
22099 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
22100 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
22101 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
22102 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
22103 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
22104 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
22105 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
22106 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
22107 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
22111 Elf64_External_Ehdr ehdr64
;
22113 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
22116 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
22117 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
22118 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
22119 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
22120 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
22121 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
22122 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
22123 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
22124 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
22125 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
22126 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
22127 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
22128 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
22135 free_filedata (Filedata
*filedata
)
22137 free (filedata
->program_interpreter
);
22138 free (filedata
->program_headers
);
22139 free (filedata
->section_headers
);
22140 free (filedata
->string_table
);
22141 free (filedata
->dump
.dump_sects
);
22142 free (filedata
->dynamic_strings
);
22143 free (filedata
->dynamic_symbols
);
22144 free (filedata
->dynamic_syminfo
);
22145 free (filedata
->dynamic_section
);
22147 while (filedata
->symtab_shndx_list
!= NULL
)
22149 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
22150 free (filedata
->symtab_shndx_list
);
22151 filedata
->symtab_shndx_list
= next
;
22154 free (filedata
->section_headers_groups
);
22156 if (filedata
->section_groups
)
22159 struct group_list
* g
;
22160 struct group_list
* next
;
22162 for (i
= 0; i
< filedata
->group_count
; i
++)
22164 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
22171 free (filedata
->section_groups
);
22173 memset (&filedata
->section_headers
, 0,
22174 sizeof (Filedata
) - offsetof (Filedata
, section_headers
));
22178 close_file (Filedata
* filedata
)
22182 if (filedata
->handle
)
22183 fclose (filedata
->handle
);
22189 close_debug_file (void * data
)
22191 free_filedata ((Filedata
*) data
);
22192 close_file ((Filedata
*) data
);
22196 open_file (const char * pathname
, bool is_separate
)
22198 struct stat statbuf
;
22199 Filedata
* filedata
= NULL
;
22201 if (stat (pathname
, & statbuf
) < 0
22202 || ! S_ISREG (statbuf
.st_mode
))
22205 filedata
= calloc (1, sizeof * filedata
);
22206 if (filedata
== NULL
)
22209 filedata
->handle
= fopen (pathname
, "rb");
22210 if (filedata
->handle
== NULL
)
22213 filedata
->file_size
= statbuf
.st_size
;
22214 filedata
->file_name
= pathname
;
22215 filedata
->is_separate
= is_separate
;
22217 if (! get_file_header (filedata
))
22220 if (!get_section_headers (filedata
, false))
22228 if (filedata
->handle
)
22229 fclose (filedata
->handle
);
22236 open_debug_file (const char * pathname
)
22238 return open_file (pathname
, true);
22242 initialise_dump_sects (Filedata
* filedata
)
22244 /* Initialise the dump_sects array from the cmdline_dump_sects array.
22245 Note we do this even if cmdline_dump_sects is empty because we
22246 must make sure that the dump_sets array is zeroed out before each
22247 object file is processed. */
22248 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
22249 memset (filedata
->dump
.dump_sects
, 0,
22250 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
22252 if (cmdline
.num_dump_sects
> 0)
22254 if (filedata
->dump
.num_dump_sects
== 0)
22255 /* A sneaky way of allocating the dump_sects array. */
22256 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
22258 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
22259 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
22260 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
22265 might_need_separate_debug_info (Filedata
* filedata
)
22267 /* Debuginfo files do not need further separate file loading. */
22268 if (filedata
->file_header
.e_shstrndx
== SHN_UNDEF
)
22271 /* Since do_follow_links might be enabled by default, only treat it as an
22272 indication that separate files should be loaded if setting it was a
22273 deliberate user action. */
22274 if (DEFAULT_FOR_FOLLOW_LINKS
== 0 && do_follow_links
)
22277 if (process_links
|| do_syms
|| do_unwind
22278 || dump_any_debugging
|| do_dump
|| do_debugging
)
22284 /* Process one ELF object file according to the command line options.
22285 This file may actually be stored in an archive. The file is
22286 positioned at the start of the ELF object. Returns TRUE if no
22287 problems were encountered, FALSE otherwise. */
22290 process_object (Filedata
* filedata
)
22292 bool have_separate_files
;
22296 if (! get_file_header (filedata
))
22298 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
22302 /* Initialise per file variables. */
22303 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
22304 filedata
->version_info
[i
] = 0;
22306 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
22307 filedata
->dynamic_info
[i
] = 0;
22308 filedata
->dynamic_info_DT_GNU_HASH
= 0;
22309 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
22311 /* Process the file. */
22313 printf (_("\nFile: %s\n"), filedata
->file_name
);
22315 initialise_dump_sects (filedata
);
22317 /* There may be some extensions in the first section header. Don't
22318 bomb if we can't read it. */
22319 get_section_headers (filedata
, true);
22321 if (! process_file_header (filedata
))
22327 /* Throw away the single section header read above, so that we
22328 re-read the entire set. */
22329 free (filedata
->section_headers
);
22330 filedata
->section_headers
= NULL
;
22332 if (! process_section_headers (filedata
))
22334 /* Without loaded section headers we cannot process lots of things. */
22335 do_unwind
= do_version
= do_dump
= do_arch
= false;
22337 if (! do_using_dynamic
)
22338 do_syms
= do_dyn_syms
= do_reloc
= false;
22341 if (! process_section_groups (filedata
))
22342 /* Without loaded section groups we cannot process unwind. */
22345 process_program_headers (filedata
);
22347 res
= process_dynamic_section (filedata
);
22349 if (! process_relocs (filedata
))
22352 if (! process_unwind (filedata
))
22355 if (! process_symbol_table (filedata
))
22358 if (! process_lto_symbol_tables (filedata
))
22361 if (! process_syminfo (filedata
))
22364 if (! process_version_sections (filedata
))
22367 if (might_need_separate_debug_info (filedata
))
22368 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
22370 have_separate_files
= false;
22372 if (! process_section_contents (filedata
))
22375 if (have_separate_files
)
22379 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
22381 initialise_dump_sects (d
->handle
);
22383 if (process_links
&& ! process_file_header (d
->handle
))
22385 else if (! process_section_headers (d
->handle
))
22387 else if (! process_section_contents (d
->handle
))
22389 else if (process_links
)
22391 if (! process_section_groups (d
->handle
))
22393 process_program_headers (d
->handle
);
22394 if (! process_dynamic_section (d
->handle
))
22396 if (! process_relocs (d
->handle
))
22398 if (! process_unwind (d
->handle
))
22400 if (! process_symbol_table (d
->handle
))
22402 if (! process_lto_symbol_tables (d
->handle
))
22404 if (! process_syminfo (d
->handle
))
22406 if (! process_version_sections (d
->handle
))
22408 if (! process_notes (d
->handle
))
22413 /* The file handles are closed by the call to free_debug_memory() below. */
22416 if (! process_notes (filedata
))
22419 if (! process_gnu_liblist (filedata
))
22422 if (! process_arch_specific (filedata
))
22426 free_filedata (filedata
);
22428 free_debug_memory ();
22433 /* Process an ELF archive.
22434 On entry the file is positioned just after the ARMAG string.
22435 Returns TRUE upon success, FALSE otherwise. */
22438 process_archive (Filedata
* filedata
, bool is_thin_archive
)
22440 struct archive_info arch
;
22441 struct archive_info nested_arch
;
22447 /* The ARCH structure is used to hold information about this archive. */
22448 arch
.file_name
= NULL
;
22450 arch
.index_array
= NULL
;
22451 arch
.sym_table
= NULL
;
22452 arch
.longnames
= NULL
;
22454 /* The NESTED_ARCH structure is used as a single-item cache of information
22455 about a nested archive (when members of a thin archive reside within
22456 another regular archive file). */
22457 nested_arch
.file_name
= NULL
;
22458 nested_arch
.file
= NULL
;
22459 nested_arch
.index_array
= NULL
;
22460 nested_arch
.sym_table
= NULL
;
22461 nested_arch
.longnames
= NULL
;
22463 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
22464 filedata
->file_size
, is_thin_archive
,
22465 do_archive_index
) != 0)
22471 if (do_archive_index
)
22473 if (arch
.sym_table
== NULL
)
22474 error (_("%s: unable to dump the index as none was found\n"),
22475 filedata
->file_name
);
22478 unsigned long i
, l
;
22479 unsigned long current_pos
;
22481 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
22482 "in the symbol table)\n"),
22483 filedata
->file_name
, (unsigned long) arch
.index_num
,
22486 current_pos
= ftell (filedata
->handle
);
22488 for (i
= l
= 0; i
< arch
.index_num
; i
++)
22491 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
22494 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
22497 if (member_name
!= NULL
)
22499 char * qualified_name
22500 = make_qualified_name (&arch
, &nested_arch
,
22503 if (qualified_name
!= NULL
)
22505 printf (_("Contents of binary %s at offset "),
22507 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
22509 free (qualified_name
);
22511 free (member_name
);
22515 if (l
>= arch
.sym_size
)
22517 error (_("%s: end of the symbol table reached "
22518 "before the end of the index\n"),
22519 filedata
->file_name
);
22523 /* PR 17531: file: 0b6630b2. */
22524 printf ("\t%.*s\n",
22525 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
22526 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
22529 if (arch
.uses_64bit_indices
)
22534 if (l
< arch
.sym_size
)
22536 error (ngettext ("%s: %ld byte remains in the symbol table, "
22537 "but without corresponding entries in "
22538 "the index table\n",
22539 "%s: %ld bytes remain in the symbol table, "
22540 "but without corresponding entries in "
22541 "the index table\n",
22542 arch
.sym_size
- l
),
22543 filedata
->file_name
, arch
.sym_size
- l
);
22547 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
22549 error (_("%s: failed to seek back to start of object files "
22550 "in the archive\n"),
22551 filedata
->file_name
);
22557 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
22558 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
22559 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
22560 && !do_section_groups
&& !do_dyn_syms
)
22562 ret
= true; /* Archive index only. */
22571 char * qualified_name
;
22573 /* Read the next archive header. */
22574 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
22576 error (_("%s: failed to seek to next archive header\n"),
22581 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
22582 if (got
!= sizeof arch
.arhdr
)
22586 /* PR 24049 - we cannot use filedata->file_name as this will
22587 have already been freed. */
22588 error (_("%s: failed to read archive header\n"), arch
.file_name
);
22593 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
22595 error (_("%s: did not find a valid archive header\n"),
22601 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
22603 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
22605 name
= get_archive_member_name (&arch
, &nested_arch
);
22608 error (_("%s: bad archive file name\n"), arch
.file_name
);
22612 namelen
= strlen (name
);
22614 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
22615 if (qualified_name
== NULL
)
22617 error (_("%s: bad archive file name\n"), arch
.file_name
);
22623 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
22625 /* This is a proxy for an external member of a thin archive. */
22626 Filedata
* member_filedata
;
22627 char * member_file_name
= adjust_relative_path
22628 (filedata
->file_name
, name
, namelen
);
22631 if (member_file_name
== NULL
)
22633 free (qualified_name
);
22638 member_filedata
= open_file (member_file_name
, false);
22639 if (member_filedata
== NULL
)
22641 error (_("Input file '%s' is not readable.\n"), member_file_name
);
22642 free (member_file_name
);
22643 free (qualified_name
);
22648 filedata
->archive_file_offset
= arch
.nested_member_origin
;
22649 member_filedata
->file_name
= qualified_name
;
22651 /* The call to process_object() expects the file to be at the beginning. */
22652 rewind (member_filedata
->handle
);
22654 if (! process_object (member_filedata
))
22657 close_file (member_filedata
);
22658 free (member_file_name
);
22660 else if (is_thin_archive
)
22662 Filedata thin_filedata
;
22664 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
22666 /* PR 15140: Allow for corrupt thin archives. */
22667 if (nested_arch
.file
== NULL
)
22669 error (_("%s: contains corrupt thin archive: %s\n"),
22670 qualified_name
, name
);
22671 free (qualified_name
);
22678 /* This is a proxy for a member of a nested archive. */
22679 filedata
->archive_file_offset
22680 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
22682 /* The nested archive file will have been opened and setup by
22683 get_archive_member_name. */
22684 if (fseek (nested_arch
.file
, filedata
->archive_file_offset
,
22687 error (_("%s: failed to seek to archive member.\n"),
22688 nested_arch
.file_name
);
22689 free (qualified_name
);
22694 thin_filedata
.handle
= nested_arch
.file
;
22695 thin_filedata
.file_name
= qualified_name
;
22697 if (! process_object (& thin_filedata
))
22703 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
22704 filedata
->file_name
= qualified_name
;
22705 if (! process_object (filedata
))
22707 arch
.next_arhdr_offset
+= (filedata
->archive_file_size
+ 1) & -2;
22708 /* Stop looping with "negative" archive_file_size. */
22709 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
22710 arch
.next_arhdr_offset
= -1ul;
22713 free (qualified_name
);
22717 if (nested_arch
.file
!= NULL
)
22718 fclose (nested_arch
.file
);
22719 release_archive (&nested_arch
);
22720 release_archive (&arch
);
22726 process_file (char * file_name
)
22728 Filedata
* filedata
= NULL
;
22729 struct stat statbuf
;
22730 char armag
[SARMAG
];
22733 if (stat (file_name
, &statbuf
) < 0)
22735 if (errno
== ENOENT
)
22736 error (_("'%s': No such file\n"), file_name
);
22738 error (_("Could not locate '%s'. System error message: %s\n"),
22739 file_name
, strerror (errno
));
22743 if (! S_ISREG (statbuf
.st_mode
))
22745 error (_("'%s' is not an ordinary file\n"), file_name
);
22749 filedata
= calloc (1, sizeof * filedata
);
22750 if (filedata
== NULL
)
22752 error (_("Out of memory allocating file data structure\n"));
22756 filedata
->file_name
= file_name
;
22757 filedata
->handle
= fopen (file_name
, "rb");
22758 if (filedata
->handle
== NULL
)
22760 error (_("Input file '%s' is not readable.\n"), file_name
);
22765 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
22767 error (_("%s: Failed to read file's magic number\n"), file_name
);
22768 fclose (filedata
->handle
);
22773 filedata
->file_size
= statbuf
.st_size
;
22774 filedata
->is_separate
= false;
22776 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
22778 if (! process_archive (filedata
, false))
22781 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
22783 if ( ! process_archive (filedata
, true))
22788 if (do_archive_index
&& !check_all
)
22789 error (_("File %s is not an archive so its index cannot be displayed.\n"),
22792 rewind (filedata
->handle
);
22793 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
22795 if (! process_object (filedata
))
22799 fclose (filedata
->handle
);
22800 free (filedata
->section_headers
);
22801 free (filedata
->program_headers
);
22802 free (filedata
->string_table
);
22803 free (filedata
->dump
.dump_sects
);
22806 free (ba_cache
.strtab
);
22807 ba_cache
.strtab
= NULL
;
22808 free (ba_cache
.symtab
);
22809 ba_cache
.symtab
= NULL
;
22810 ba_cache
.filedata
= NULL
;
22815 #ifdef SUPPORT_DISASSEMBLY
22816 /* Needed by the i386 disassembler. For extra credit, someone could
22817 fix this so that we insert symbolic addresses here, esp for GOT/PLT
22821 print_address (unsigned int addr
, FILE * outfile
)
22823 fprintf (outfile
,"0x%8.8x", addr
);
22826 /* Needed by the i386 disassembler. */
22829 db_task_printsym (unsigned int addr
)
22831 print_address (addr
, stderr
);
22836 main (int argc
, char ** argv
)
22840 #ifdef HAVE_LC_MESSAGES
22841 setlocale (LC_MESSAGES
, "");
22843 setlocale (LC_CTYPE
, "");
22844 bindtextdomain (PACKAGE
, LOCALEDIR
);
22845 textdomain (PACKAGE
);
22847 expandargv (&argc
, &argv
);
22849 parse_args (& cmdline
, argc
, argv
);
22851 if (optind
< (argc
- 1))
22852 /* When displaying information for more than one file,
22853 prefix the information with the file name. */
22855 else if (optind
>= argc
)
22857 /* Ensure that the warning is always displayed. */
22860 warn (_("Nothing to do.\n"));
22865 while (optind
< argc
)
22866 if (! process_file (argv
[optind
++]))
22869 free (cmdline
.dump_sects
);
22871 free (dump_ctf_symtab_name
);
22872 free (dump_ctf_strtab_name
);
22873 free (dump_ctf_parent_name
);
22875 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;