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
== 0xb5)
9920 printf (_(" vsp as modifier for PAC validation"));
9921 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
9923 unsigned int count
= op
& 0x07;
9927 printf ("-D%d", 8 + count
);
9930 else if (op
>= 0xc0 && op
<= 0xc5)
9932 unsigned int count
= op
& 0x07;
9934 printf (" pop {wR10");
9936 printf ("-wR%d", 10 + count
);
9939 else if (op
== 0xc6)
9941 unsigned int first
, last
;
9946 printf ("pop {wR%d", first
);
9948 printf ("-wR%d", first
+ last
);
9951 else if (op
== 0xc7)
9954 if (op2
== 0 || (op2
& 0xf0) != 0)
9955 printf (_("[Spare]"));
9958 unsigned int mask
= op2
& 0x0f;
9963 for (i
= 0; i
< 4; i
++)
9964 if (mask
& (1 << i
))
9970 printf ("wCGR%d", i
);
9977 printf (_(" [unsupported opcode]"));
9988 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
9989 struct arm_unw_aux_info
* aux
,
9991 unsigned int remaining
,
9992 unsigned int more_words
,
9993 uint64_t data_offset
,
9994 Elf_Internal_Shdr
* data_sec
,
9995 struct arm_section
* data_arm_sec
)
9997 struct absaddr addr
;
9999 /* Decode the unwinding instructions. */
10002 unsigned int op
, op2
;
10005 if (remaining
== 0)
10011 printf (" 0x%02x ", op
);
10013 if ((op
& 0xc0) == 0x00)
10015 int offset
= ((op
& 0x3f) << 3) + 8;
10016 printf (" sp = sp + %d", offset
);
10018 else if ((op
& 0xc0) == 0x80)
10021 if (op
== 0x80 && op2
== 0)
10022 printf (_("Refuse to unwind"));
10025 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
10027 printf ("pop compact {");
10031 decode_tic6x_unwind_regmask (mask
);
10035 else if ((op
& 0xf0) == 0xc0)
10038 unsigned int nregs
;
10043 unsigned int offset
;
10047 /* Scan entire instruction first so that GET_OP output is not
10048 interleaved with disassembly. */
10050 for (i
= 0; nregs
< (op
& 0xf); i
++)
10056 regpos
[nregs
].offset
= i
* 2;
10057 regpos
[nregs
].reg
= reg
;
10064 regpos
[nregs
].offset
= i
* 2 + 1;
10065 regpos
[nregs
].reg
= reg
;
10070 printf (_("pop frame {"));
10073 printf (_("*corrupt* - no registers specified"));
10078 for (i
= i
* 2; i
> 0; i
--)
10080 if (regpos
[reg
].offset
== i
- 1)
10082 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
10089 fputs (name
, stdout
);
10097 else if (op
== 0xd0)
10098 printf (" MOV FP, SP");
10099 else if (op
== 0xd1)
10100 printf (" __c6xabi_pop_rts");
10101 else if (op
== 0xd2)
10103 unsigned char buf
[9];
10104 unsigned int i
, len
;
10105 unsigned long offset
;
10107 for (i
= 0; i
< sizeof (buf
); i
++)
10110 if ((buf
[i
] & 0x80) == 0)
10113 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
10114 if (i
== sizeof (buf
))
10116 warn (_("Corrupt stack pointer adjustment detected\n"));
10120 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
10121 assert (len
== i
+ 1);
10122 offset
= offset
* 8 + 0x408;
10123 printf (_("sp = sp + %ld"), offset
);
10125 else if ((op
& 0xf0) == 0xe0)
10127 if ((op
& 0x0f) == 7)
10128 printf (" RETURN");
10130 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
10134 printf (_(" [unsupported opcode]"));
10143 arm_expand_prel31 (Filedata
* filedata
, uint64_t word
, uint64_t where
)
10147 offset
= word
& 0x7fffffff;
10148 if (offset
& 0x40000000)
10149 offset
|= ~ (uint64_t) 0x7fffffff;
10151 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
10154 return offset
+ where
;
10158 decode_arm_unwind (Filedata
* filedata
,
10159 struct arm_unw_aux_info
* aux
,
10161 unsigned int remaining
,
10162 uint64_t data_offset
,
10163 Elf_Internal_Shdr
* data_sec
,
10164 struct arm_section
* data_arm_sec
)
10167 unsigned int more_words
= 0;
10168 struct absaddr addr
;
10169 uint64_t sym_name
= (uint64_t) -1;
10172 if (remaining
== 0)
10174 /* Fetch the first word.
10175 Note - when decoding an object file the address extracted
10176 here will always be 0. So we also pass in the sym_name
10177 parameter so that we can find the symbol associated with
10178 the personality routine. */
10179 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
10180 & word
, & addr
, & sym_name
))
10187 addr
.section
= SHN_UNDEF
;
10191 if ((word
& 0x80000000) == 0)
10193 /* Expand prel31 for personality routine. */
10195 const char *procname
;
10197 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
10198 printf (_(" Personality routine: "));
10200 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
10201 && sym_name
!= (uint64_t) -1 && sym_name
< aux
->strtab_size
)
10203 procname
= aux
->strtab
+ sym_name
;
10204 print_vma (fn
, PREFIX_HEX
);
10207 fputs (" <", stdout
);
10208 fputs (procname
, stdout
);
10209 fputc ('>', stdout
);
10213 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
10214 fputc ('\n', stdout
);
10216 /* The GCC personality routines use the standard compact
10217 encoding, starting with one byte giving the number of
10219 if (procname
!= NULL
10220 && (startswith (procname
, "__gcc_personality_v0")
10221 || startswith (procname
, "__gxx_personality_v0")
10222 || startswith (procname
, "__gcj_personality_v0")
10223 || startswith (procname
, "__gnu_objc_personality_v0")))
10230 printf (_(" [Truncated data]\n"));
10233 more_words
= word
>> 24;
10243 /* ARM EHABI Section 6.3:
10245 An exception-handling table entry for the compact model looks like:
10247 31 30-28 27-24 23-0
10248 -- ----- ----- ----
10249 1 0 index Data for personalityRoutine[index] */
10251 if (filedata
->file_header
.e_machine
== EM_ARM
10252 && (word
& 0x70000000))
10254 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
10258 per_index
= (word
>> 24) & 0x7f;
10259 printf (_(" Compact model index: %d\n"), per_index
);
10260 if (per_index
== 0)
10266 else if (per_index
< 3)
10268 more_words
= (word
>> 16) & 0xff;
10274 switch (filedata
->file_header
.e_machine
)
10279 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
10280 data_offset
, data_sec
, data_arm_sec
))
10285 warn (_("Unknown ARM compact model index encountered\n"));
10286 printf (_(" [reserved]\n"));
10294 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
10295 data_offset
, data_sec
, data_arm_sec
))
10298 else if (per_index
< 5)
10300 if (((word
>> 17) & 0x7f) == 0x7f)
10301 printf (_(" Restore stack from frame pointer\n"));
10303 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
10304 printf (_(" Registers restored: "));
10305 if (per_index
== 4)
10306 printf (" (compact) ");
10307 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
10309 printf (_(" Return register: %s\n"),
10310 tic6x_unwind_regnames
[word
& 0xf]);
10313 printf (_(" [reserved (%d)]\n"), per_index
);
10317 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
10318 filedata
->file_header
.e_machine
);
10322 /* Decode the descriptors. Not implemented. */
10328 dump_arm_unwind (Filedata
* filedata
,
10329 struct arm_unw_aux_info
* aux
,
10330 Elf_Internal_Shdr
* exidx_sec
)
10332 struct arm_section exidx_arm_sec
, extab_arm_sec
;
10333 unsigned int i
, exidx_len
;
10334 unsigned long j
, nfuns
;
10337 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
10338 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
10339 exidx_len
= exidx_sec
->sh_size
/ 8;
10341 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
10342 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
10343 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
10344 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
10345 aux
->nfuns
= nfuns
;
10346 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
10348 for (i
= 0; i
< exidx_len
; i
++)
10350 unsigned int exidx_fn
, exidx_entry
;
10351 struct absaddr fn_addr
, entry_addr
;
10354 fputc ('\n', stdout
);
10356 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
10357 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
10358 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
10359 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
10361 free (aux
->funtab
);
10362 arm_free_section (& exidx_arm_sec
);
10363 arm_free_section (& extab_arm_sec
);
10367 /* ARM EHABI, Section 5:
10368 An index table entry consists of 2 words.
10369 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
10370 if (exidx_fn
& 0x80000000)
10372 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
10376 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
10378 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
10379 fputs (": ", stdout
);
10381 if (exidx_entry
== 1)
10383 print_vma (exidx_entry
, PREFIX_HEX
);
10384 fputs (" [cantunwind]\n", stdout
);
10386 else if (exidx_entry
& 0x80000000)
10388 print_vma (exidx_entry
, PREFIX_HEX
);
10389 fputc ('\n', stdout
);
10390 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
10394 uint64_t table
, table_offset
= 0;
10395 Elf_Internal_Shdr
*table_sec
;
10397 fputs ("@", stdout
);
10398 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
10399 print_vma (table
, PREFIX_HEX
);
10402 /* Locate the matching .ARM.extab. */
10403 if (entry_addr
.section
!= SHN_UNDEF
10404 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
10406 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
10407 table_offset
= entry_addr
.offset
;
10409 if (table_offset
> table_sec
->sh_size
)
10411 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
10412 (unsigned long) table_offset
,
10413 printable_section_name (filedata
, table_sec
));
10420 table_sec
= find_section_by_address (filedata
, table
);
10421 if (table_sec
!= NULL
)
10422 table_offset
= table
- table_sec
->sh_addr
;
10425 if (table_sec
== NULL
)
10427 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
10428 (unsigned long) table
);
10433 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
10441 free (aux
->funtab
);
10442 arm_free_section (&exidx_arm_sec
);
10443 arm_free_section (&extab_arm_sec
);
10448 /* Used for both ARM and C6X unwinding tables. */
10451 arm_process_unwind (Filedata
* filedata
)
10453 struct arm_unw_aux_info aux
;
10454 Elf_Internal_Shdr
*unwsec
= NULL
;
10455 Elf_Internal_Shdr
*sec
;
10457 unsigned int sec_type
;
10460 switch (filedata
->file_header
.e_machine
)
10463 sec_type
= SHT_ARM_EXIDX
;
10467 sec_type
= SHT_C6000_UNWIND
;
10471 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
10472 filedata
->file_header
.e_machine
);
10476 if (filedata
->string_table
== NULL
)
10479 memset (& aux
, 0, sizeof (aux
));
10480 aux
.filedata
= filedata
;
10482 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
10484 if (sec
->sh_type
== SHT_SYMTAB
)
10488 error (_("Multiple symbol tables encountered\n"));
10494 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
10495 &aux
.strtab
, &aux
.strtab_size
))
10498 else if (sec
->sh_type
== sec_type
)
10502 if (unwsec
== NULL
)
10503 printf (_("\nThere are no unwind sections in this file.\n"));
10505 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
10507 if (sec
->sh_type
== sec_type
)
10509 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
10510 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
10511 "contains %lu entry:\n",
10512 "\nUnwind section '%s' at offset 0x%lx "
10513 "contains %lu entries:\n",
10515 printable_section_name (filedata
, sec
),
10516 (unsigned long) sec
->sh_offset
,
10519 if (! dump_arm_unwind (filedata
, &aux
, sec
))
10525 free ((char *) aux
.strtab
);
10531 no_processor_specific_unwind (Filedata
* filedata ATTRIBUTE_UNUSED
)
10533 printf (_("No processor specific unwind information to decode\n"));
10538 process_unwind (Filedata
* filedata
)
10540 struct unwind_handler
10542 unsigned int machtype
;
10543 bool (* handler
)(Filedata
*);
10546 { EM_ARM
, arm_process_unwind
},
10547 { EM_IA_64
, ia64_process_unwind
},
10548 { EM_PARISC
, hppa_process_unwind
},
10549 { EM_TI_C6000
, arm_process_unwind
},
10550 { EM_386
, no_processor_specific_unwind
},
10551 { EM_X86_64
, no_processor_specific_unwind
},
10559 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
10560 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
10561 return handlers
[i
].handler (filedata
);
10563 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
10564 get_machine_name (filedata
->file_header
.e_machine
));
10569 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
10571 switch (entry
->d_tag
)
10573 case DT_AARCH64_BTI_PLT
:
10574 case DT_AARCH64_PAC_PLT
:
10577 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10584 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
10586 switch (entry
->d_tag
)
10588 case DT_MIPS_FLAGS
:
10589 if (entry
->d_un
.d_val
== 0)
10590 printf (_("NONE"));
10593 static const char * opts
[] =
10595 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
10596 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
10597 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
10598 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
10604 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
10605 if (entry
->d_un
.d_val
& (1 << cnt
))
10607 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
10613 case DT_MIPS_IVERSION
:
10614 if (valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
10615 printf (_("Interface Version: %s"),
10616 get_dynamic_name (filedata
, entry
->d_un
.d_val
));
10618 printf (_("Interface Version: <corrupt: %" PRIx64
">"),
10619 entry
->d_un
.d_ptr
);
10622 case DT_MIPS_TIME_STAMP
:
10626 time_t atime
= entry
->d_un
.d_val
;
10628 tmp
= gmtime (&atime
);
10629 /* PR 17531: file: 6accc532. */
10631 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
10633 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
10634 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10635 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10636 printf (_("Time Stamp: %s"), timebuf
);
10640 case DT_MIPS_RLD_VERSION
:
10641 case DT_MIPS_LOCAL_GOTNO
:
10642 case DT_MIPS_CONFLICTNO
:
10643 case DT_MIPS_LIBLISTNO
:
10644 case DT_MIPS_SYMTABNO
:
10645 case DT_MIPS_UNREFEXTNO
:
10646 case DT_MIPS_HIPAGENO
:
10647 case DT_MIPS_DELTA_CLASS_NO
:
10648 case DT_MIPS_DELTA_INSTANCE_NO
:
10649 case DT_MIPS_DELTA_RELOC_NO
:
10650 case DT_MIPS_DELTA_SYM_NO
:
10651 case DT_MIPS_DELTA_CLASSSYM_NO
:
10652 case DT_MIPS_COMPACT_SIZE
:
10653 print_vma (entry
->d_un
.d_val
, DEC
);
10656 case DT_MIPS_XHASH
:
10657 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10658 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10659 /* Falls through. */
10662 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10668 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
10670 switch (entry
->d_tag
)
10672 case DT_HP_DLD_FLAGS
:
10681 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
10682 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
10683 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
10684 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
10685 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
10686 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
10687 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
10688 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
10689 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
10690 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
10691 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
10692 { DT_HP_GST
, "HP_GST" },
10693 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
10694 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
10695 { DT_HP_NODELETE
, "HP_NODELETE" },
10696 { DT_HP_GROUP
, "HP_GROUP" },
10697 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
10701 uint64_t val
= entry
->d_un
.d_val
;
10703 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
10704 if (val
& flags
[cnt
].bit
)
10708 fputs (flags
[cnt
].str
, stdout
);
10710 val
^= flags
[cnt
].bit
;
10713 if (val
!= 0 || first
)
10717 print_vma (val
, HEX
);
10723 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10729 /* VMS vs Unix time offset and factor. */
10731 #define VMS_EPOCH_OFFSET 35067168000000000LL
10732 #define VMS_GRANULARITY_FACTOR 10000000
10734 #define INT64_MIN (-9223372036854775807LL - 1)
10737 /* Display a VMS time in a human readable format. */
10740 print_vms_time (int64_t vmstime
)
10742 struct tm
*tm
= NULL
;
10745 if (vmstime
>= INT64_MIN
+ VMS_EPOCH_OFFSET
)
10747 vmstime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
10749 if (unxtime
== vmstime
)
10750 tm
= gmtime (&unxtime
);
10753 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
10754 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
10755 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
10759 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
10761 switch (entry
->d_tag
)
10763 case DT_IA_64_PLT_RESERVE
:
10764 /* First 3 slots reserved. */
10765 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10767 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
10770 case DT_IA_64_VMS_LINKTIME
:
10771 print_vms_time (entry
->d_un
.d_val
);
10774 case DT_IA_64_VMS_LNKFLAGS
:
10775 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10776 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
10777 printf (" CALL_DEBUG");
10778 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
10779 printf (" NOP0BUFS");
10780 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
10781 printf (" P0IMAGE");
10782 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
10783 printf (" MKTHREADS");
10784 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
10785 printf (" UPCALLS");
10786 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
10787 printf (" IMGSTA");
10788 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
10789 printf (" INITIALIZE");
10790 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
10792 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
10793 printf (" EXE_INIT");
10794 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
10795 printf (" TBK_IN_IMG");
10796 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
10797 printf (" DBG_IN_IMG");
10798 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
10799 printf (" TBK_IN_DSF");
10800 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
10801 printf (" DBG_IN_DSF");
10802 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
10803 printf (" SIGNATURES");
10804 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
10805 printf (" REL_SEG_OFF");
10809 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10816 get_32bit_dynamic_section (Filedata
* filedata
)
10818 Elf32_External_Dyn
* edyn
;
10819 Elf32_External_Dyn
* ext
;
10820 Elf_Internal_Dyn
* entry
;
10822 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
10823 filedata
->dynamic_addr
, 1,
10824 filedata
->dynamic_size
,
10825 _("dynamic section"));
10829 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
10830 might not have the luxury of section headers. Look for the DT_NULL
10831 terminator to determine the number of entries. */
10832 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
10833 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
10836 filedata
->dynamic_nent
++;
10837 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
10841 filedata
->dynamic_section
10842 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
10843 if (filedata
->dynamic_section
== NULL
)
10845 error (_("Out of memory allocating space for %lu dynamic entries\n"),
10846 (unsigned long) filedata
->dynamic_nent
);
10851 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10852 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10855 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10856 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10865 get_64bit_dynamic_section (Filedata
* filedata
)
10867 Elf64_External_Dyn
* edyn
;
10868 Elf64_External_Dyn
* ext
;
10869 Elf_Internal_Dyn
* entry
;
10871 /* Read in the data. */
10872 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
10873 filedata
->dynamic_addr
, 1,
10874 filedata
->dynamic_size
,
10875 _("dynamic section"));
10879 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
10880 might not have the luxury of section headers. Look for the DT_NULL
10881 terminator to determine the number of entries. */
10882 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
10883 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
10884 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
10887 filedata
->dynamic_nent
++;
10888 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
10892 filedata
->dynamic_section
10893 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
10894 if (filedata
->dynamic_section
== NULL
)
10896 error (_("Out of memory allocating space for %lu dynamic entries\n"),
10897 (unsigned long) filedata
->dynamic_nent
);
10902 /* Convert from external to internal formats. */
10903 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10904 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10907 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10908 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10917 get_dynamic_section (Filedata
*filedata
)
10919 if (filedata
->dynamic_section
)
10923 return get_32bit_dynamic_section (filedata
);
10925 return get_64bit_dynamic_section (filedata
);
10929 print_dynamic_flags (uint64_t flags
)
10937 flag
= flags
& - flags
;
10943 putc (' ', stdout
);
10947 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
10948 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
10949 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
10950 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
10951 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
10952 default: fputs (_("unknown"), stdout
); break;
10959 get_dynamic_data (Filedata
* filedata
, uint64_t number
, unsigned int ent_size
)
10961 unsigned char * e_data
;
10964 /* If size_t is smaller than uint64_t, eg because you are building
10965 on a 32-bit host, then make sure that when number is cast to
10966 size_t no information is lost. */
10967 if ((size_t) number
!= number
10968 || ent_size
* number
/ ent_size
!= number
)
10970 error (_("Size overflow prevents reading %" PRIu64
10971 " elements of size %u\n"),
10976 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
10977 attempting to allocate memory when the read is bound to fail. */
10978 if (ent_size
* number
> filedata
->file_size
)
10980 error (_("Invalid number of dynamic entries: %" PRIu64
"\n"),
10985 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10986 if (e_data
== NULL
)
10988 error (_("Out of memory reading %" PRIu64
" dynamic entries\n"),
10993 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
10995 error (_("Unable to read in %" PRIu64
" bytes of dynamic data\n"),
10996 number
* ent_size
);
11001 i_data
= (uint64_t *) cmalloc ((size_t) number
, sizeof (*i_data
));
11002 if (i_data
== NULL
)
11004 error (_("Out of memory allocating space for %" PRIu64
" dynamic entries\n"),
11011 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11018 static unsigned long
11019 get_num_dynamic_syms (Filedata
* filedata
)
11021 unsigned long num_of_syms
= 0;
11023 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
11024 return num_of_syms
;
11026 if (filedata
->dynamic_info
[DT_HASH
])
11028 unsigned char nb
[8];
11029 unsigned char nc
[8];
11030 unsigned int hash_ent_size
= 4;
11032 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11033 || filedata
->file_header
.e_machine
== EM_S390
11034 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11035 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11038 if (fseek (filedata
->handle
,
11039 (filedata
->archive_file_offset
11040 + offset_from_vma (filedata
, filedata
->dynamic_info
[DT_HASH
],
11041 sizeof nb
+ sizeof nc
)),
11044 error (_("Unable to seek to start of dynamic information\n"));
11048 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11050 error (_("Failed to read in number of buckets\n"));
11054 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11056 error (_("Failed to read in number of chains\n"));
11060 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
11061 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
11063 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
11065 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
11067 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
11070 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
11071 num_of_syms
= filedata
->nchains
;
11074 if (num_of_syms
== 0)
11076 free (filedata
->buckets
);
11077 filedata
->buckets
= NULL
;
11078 free (filedata
->chains
);
11079 filedata
->chains
= NULL
;
11080 filedata
->nbuckets
= 0;
11084 if (filedata
->dynamic_info_DT_GNU_HASH
)
11086 unsigned char nb
[16];
11087 uint64_t i
, maxchain
= 0xffffffff, bitmaskwords
;
11088 uint64_t buckets_vma
;
11091 if (fseek (filedata
->handle
,
11092 (filedata
->archive_file_offset
11093 + offset_from_vma (filedata
,
11094 filedata
->dynamic_info_DT_GNU_HASH
,
11098 error (_("Unable to seek to start of dynamic information\n"));
11102 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11104 error (_("Failed to read in number of buckets\n"));
11108 filedata
->ngnubuckets
= byte_get (nb
, 4);
11109 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
11110 bitmaskwords
= byte_get (nb
+ 8, 4);
11111 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
11113 buckets_vma
+= bitmaskwords
* 4;
11115 buckets_vma
+= bitmaskwords
* 8;
11117 if (fseek (filedata
->handle
,
11118 (filedata
->archive_file_offset
11119 + offset_from_vma (filedata
, buckets_vma
, 4)),
11122 error (_("Unable to seek to start of dynamic information\n"));
11126 filedata
->gnubuckets
11127 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
11129 if (filedata
->gnubuckets
== NULL
)
11132 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
11133 if (filedata
->gnubuckets
[i
] != 0)
11135 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
11138 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
11139 maxchain
= filedata
->gnubuckets
[i
];
11142 if (maxchain
== 0xffffffff)
11145 maxchain
-= filedata
->gnusymidx
;
11147 if (fseek (filedata
->handle
,
11148 (filedata
->archive_file_offset
11149 + offset_from_vma (filedata
,
11150 buckets_vma
+ 4 * (filedata
->ngnubuckets
11155 error (_("Unable to seek to start of dynamic information\n"));
11161 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11163 error (_("Failed to determine last chain length\n"));
11167 if (maxchain
+ 1 == 0)
11172 while ((byte_get (nb
, 4) & 1) == 0);
11174 if (fseek (filedata
->handle
,
11175 (filedata
->archive_file_offset
11176 + offset_from_vma (filedata
, (buckets_vma
11177 + 4 * filedata
->ngnubuckets
),
11181 error (_("Unable to seek to start of dynamic information\n"));
11185 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11186 filedata
->ngnuchains
= maxchain
;
11188 if (filedata
->gnuchains
== NULL
)
11191 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
11193 if (fseek (filedata
->handle
,
11194 (filedata
->archive_file_offset
11195 + offset_from_vma (filedata
, (buckets_vma
11196 + 4 * (filedata
->ngnubuckets
11200 error (_("Unable to seek to start of dynamic information\n"));
11204 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
11205 if (filedata
->mipsxlat
== NULL
)
11209 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
11210 if (filedata
->gnubuckets
[hn
] != 0)
11212 uint64_t si
= filedata
->gnubuckets
[hn
];
11213 uint64_t off
= si
- filedata
->gnusymidx
;
11217 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
11219 if (off
< filedata
->ngnuchains
11220 && filedata
->mipsxlat
[off
] >= num_of_syms
)
11221 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
11225 if (si
>= num_of_syms
)
11226 num_of_syms
= si
+ 1;
11230 while (off
< filedata
->ngnuchains
11231 && (filedata
->gnuchains
[off
++] & 1) == 0);
11234 if (num_of_syms
== 0)
11237 free (filedata
->mipsxlat
);
11238 filedata
->mipsxlat
= NULL
;
11239 free (filedata
->gnuchains
);
11240 filedata
->gnuchains
= NULL
;
11241 free (filedata
->gnubuckets
);
11242 filedata
->gnubuckets
= NULL
;
11243 filedata
->ngnubuckets
= 0;
11244 filedata
->ngnuchains
= 0;
11248 return num_of_syms
;
11251 /* Parse and display the contents of the dynamic section. */
11254 process_dynamic_section (Filedata
* filedata
)
11256 Elf_Internal_Dyn
* entry
;
11258 if (filedata
->dynamic_size
<= 1)
11262 if (filedata
->is_separate
)
11263 printf (_("\nThere is no dynamic section in linked file '%s'.\n"),
11264 filedata
->file_name
);
11266 printf (_("\nThere is no dynamic section in this file.\n"));
11272 if (!get_dynamic_section (filedata
))
11275 /* Find the appropriate symbol table. */
11276 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
11278 unsigned long num_of_syms
;
11280 for (entry
= filedata
->dynamic_section
;
11281 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11283 if (entry
->d_tag
== DT_SYMTAB
)
11284 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
11285 else if (entry
->d_tag
== DT_SYMENT
)
11286 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
11287 else if (entry
->d_tag
== DT_HASH
)
11288 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
11289 else if (entry
->d_tag
== DT_GNU_HASH
)
11290 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11291 else if ((filedata
->file_header
.e_machine
== EM_MIPS
11292 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
11293 && entry
->d_tag
== DT_MIPS_XHASH
)
11295 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
11296 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11299 num_of_syms
= get_num_dynamic_syms (filedata
);
11301 if (num_of_syms
!= 0
11302 && filedata
->dynamic_symbols
== NULL
11303 && filedata
->dynamic_info
[DT_SYMTAB
]
11304 && filedata
->dynamic_info
[DT_SYMENT
])
11306 Elf_Internal_Phdr
*seg
;
11307 uint64_t vma
= filedata
->dynamic_info
[DT_SYMTAB
];
11309 if (! get_program_headers (filedata
))
11311 error (_("Cannot interpret virtual addresses "
11312 "without program headers.\n"));
11316 for (seg
= filedata
->program_headers
;
11317 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
11320 if (seg
->p_type
!= PT_LOAD
)
11323 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
11325 /* See PR 21379 for a reproducer. */
11326 error (_("Invalid PT_LOAD entry\n"));
11330 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
11331 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
11333 /* Since we do not know how big the symbol table is,
11334 we default to reading in up to the end of PT_LOAD
11335 segment and processing that. This is overkill, I
11336 know, but it should work. */
11337 Elf_Internal_Shdr section
;
11338 section
.sh_offset
= (vma
- seg
->p_vaddr
11340 section
.sh_size
= (num_of_syms
11341 * filedata
->dynamic_info
[DT_SYMENT
]);
11342 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
11345 && filedata
->dynamic_symtab_section
!= NULL
11346 && ((filedata
->dynamic_symtab_section
->sh_offset
11347 != section
.sh_offset
)
11348 || (filedata
->dynamic_symtab_section
->sh_size
11349 != section
.sh_size
)
11350 || (filedata
->dynamic_symtab_section
->sh_entsize
11351 != section
.sh_entsize
)))
11353 the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
11355 section
.sh_name
= filedata
->string_table_length
;
11356 filedata
->dynamic_symbols
11357 = get_elf_symbols (filedata
, §ion
,
11358 &filedata
->num_dynamic_syms
);
11359 if (filedata
->dynamic_symbols
== NULL
11360 || filedata
->num_dynamic_syms
!= num_of_syms
)
11362 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
11371 /* Similarly find a string table. */
11372 if (filedata
->dynamic_strings
== NULL
)
11373 for (entry
= filedata
->dynamic_section
;
11374 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11377 if (entry
->d_tag
== DT_STRTAB
)
11378 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
11380 if (entry
->d_tag
== DT_STRSZ
)
11381 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
11383 if (filedata
->dynamic_info
[DT_STRTAB
]
11384 && filedata
->dynamic_info
[DT_STRSZ
])
11386 unsigned long offset
;
11387 uint64_t str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
11389 offset
= offset_from_vma (filedata
,
11390 filedata
->dynamic_info
[DT_STRTAB
],
11393 && filedata
->dynamic_strtab_section
11394 && ((filedata
->dynamic_strtab_section
->sh_offset
11395 != (file_ptr
) offset
)
11396 || (filedata
->dynamic_strtab_section
->sh_size
11399 the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
11401 filedata
->dynamic_strings
11402 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
11403 _("dynamic string table"));
11404 if (filedata
->dynamic_strings
== NULL
)
11406 error (_("Corrupt DT_STRTAB dynamic entry\n"));
11410 filedata
->dynamic_strings_length
= str_tab_len
;
11415 /* And find the syminfo section if available. */
11416 if (filedata
->dynamic_syminfo
== NULL
)
11418 unsigned long syminsz
= 0;
11420 for (entry
= filedata
->dynamic_section
;
11421 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11424 if (entry
->d_tag
== DT_SYMINENT
)
11426 /* Note: these braces are necessary to avoid a syntax
11427 error from the SunOS4 C compiler. */
11428 /* PR binutils/17531: A corrupt file can trigger this test.
11429 So do not use an assert, instead generate an error message. */
11430 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
11431 error (_("Bad value (%d) for SYMINENT entry\n"),
11432 (int) entry
->d_un
.d_val
);
11434 else if (entry
->d_tag
== DT_SYMINSZ
)
11435 syminsz
= entry
->d_un
.d_val
;
11436 else if (entry
->d_tag
== DT_SYMINFO
)
11437 filedata
->dynamic_syminfo_offset
11438 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
11441 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
11443 Elf_External_Syminfo
* extsyminfo
;
11444 Elf_External_Syminfo
* extsym
;
11445 Elf_Internal_Syminfo
* syminfo
;
11447 /* There is a syminfo section. Read the data. */
11448 extsyminfo
= (Elf_External_Syminfo
*)
11449 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
11450 1, syminsz
, _("symbol information"));
11454 if (filedata
->dynamic_syminfo
!= NULL
)
11456 error (_("Multiple dynamic symbol information sections found\n"));
11457 free (filedata
->dynamic_syminfo
);
11459 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
11460 if (filedata
->dynamic_syminfo
== NULL
)
11462 error (_("Out of memory allocating %lu bytes "
11463 "for dynamic symbol info\n"),
11464 (unsigned long) syminsz
);
11468 filedata
->dynamic_syminfo_nent
11469 = syminsz
/ sizeof (Elf_External_Syminfo
);
11470 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
11471 syminfo
< (filedata
->dynamic_syminfo
11472 + filedata
->dynamic_syminfo_nent
);
11473 ++syminfo
, ++extsym
)
11475 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
11476 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
11483 if (do_dynamic
&& filedata
->dynamic_addr
)
11485 if (filedata
->is_separate
)
11486 printf (ngettext ("\nIn linked file '%s' the dynamic section at offset 0x%lx contains %lu entry:\n",
11487 "\nIn linked file '%s' the dynamic section at offset 0x%lx contains %lu entries:\n",
11488 (unsigned long) filedata
->dynamic_nent
),
11489 filedata
->file_name
,
11490 filedata
->dynamic_addr
,
11491 (unsigned long) filedata
->dynamic_nent
);
11493 printf (ngettext ("\nDynamic section at offset 0x%lx contains %lu entry:\n",
11494 "\nDynamic section at offset 0x%lx contains %lu entries:\n",
11495 (unsigned long) filedata
->dynamic_nent
),
11496 filedata
->dynamic_addr
,
11497 (unsigned long) filedata
->dynamic_nent
);
11500 printf (_(" Tag Type Name/Value\n"));
11502 for (entry
= filedata
->dynamic_section
;
11503 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11508 const char * dtype
;
11511 print_vma (entry
->d_tag
, FULL_HEX
);
11512 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
11513 printf (" (%s)%*s", dtype
,
11514 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
11517 switch (entry
->d_tag
)
11521 print_dynamic_flags (entry
->d_un
.d_val
);
11531 switch (entry
->d_tag
)
11534 printf (_("Auxiliary library"));
11538 printf (_("Filter library"));
11542 printf (_("Configuration file"));
11546 printf (_("Dependency audit library"));
11550 printf (_("Audit library"));
11554 if (valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
11555 printf (": [%s]\n",
11556 get_dynamic_name (filedata
, entry
->d_un
.d_val
));
11560 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11569 printf (_("Flags:"));
11571 if (entry
->d_un
.d_val
== 0)
11572 printf (_(" None\n"));
11575 unsigned long int val
= entry
->d_un
.d_val
;
11577 if (val
& DTF_1_PARINIT
)
11579 printf (" PARINIT");
11580 val
^= DTF_1_PARINIT
;
11582 if (val
& DTF_1_CONFEXP
)
11584 printf (" CONFEXP");
11585 val
^= DTF_1_CONFEXP
;
11588 printf (" %lx", val
);
11597 printf (_("Flags:"));
11599 if (entry
->d_un
.d_val
== 0)
11600 printf (_(" None\n"));
11603 unsigned long int val
= entry
->d_un
.d_val
;
11605 if (val
& DF_P1_LAZYLOAD
)
11607 printf (" LAZYLOAD");
11608 val
^= DF_P1_LAZYLOAD
;
11610 if (val
& DF_P1_GROUPPERM
)
11612 printf (" GROUPPERM");
11613 val
^= DF_P1_GROUPPERM
;
11616 printf (" %lx", val
);
11625 printf (_("Flags:"));
11626 if (entry
->d_un
.d_val
== 0)
11627 printf (_(" None\n"));
11630 unsigned long int val
= entry
->d_un
.d_val
;
11632 if (val
& DF_1_NOW
)
11637 if (val
& DF_1_GLOBAL
)
11639 printf (" GLOBAL");
11640 val
^= DF_1_GLOBAL
;
11642 if (val
& DF_1_GROUP
)
11647 if (val
& DF_1_NODELETE
)
11649 printf (" NODELETE");
11650 val
^= DF_1_NODELETE
;
11652 if (val
& DF_1_LOADFLTR
)
11654 printf (" LOADFLTR");
11655 val
^= DF_1_LOADFLTR
;
11657 if (val
& DF_1_INITFIRST
)
11659 printf (" INITFIRST");
11660 val
^= DF_1_INITFIRST
;
11662 if (val
& DF_1_NOOPEN
)
11664 printf (" NOOPEN");
11665 val
^= DF_1_NOOPEN
;
11667 if (val
& DF_1_ORIGIN
)
11669 printf (" ORIGIN");
11670 val
^= DF_1_ORIGIN
;
11672 if (val
& DF_1_DIRECT
)
11674 printf (" DIRECT");
11675 val
^= DF_1_DIRECT
;
11677 if (val
& DF_1_TRANS
)
11682 if (val
& DF_1_INTERPOSE
)
11684 printf (" INTERPOSE");
11685 val
^= DF_1_INTERPOSE
;
11687 if (val
& DF_1_NODEFLIB
)
11689 printf (" NODEFLIB");
11690 val
^= DF_1_NODEFLIB
;
11692 if (val
& DF_1_NODUMP
)
11694 printf (" NODUMP");
11695 val
^= DF_1_NODUMP
;
11697 if (val
& DF_1_CONFALT
)
11699 printf (" CONFALT");
11700 val
^= DF_1_CONFALT
;
11702 if (val
& DF_1_ENDFILTEE
)
11704 printf (" ENDFILTEE");
11705 val
^= DF_1_ENDFILTEE
;
11707 if (val
& DF_1_DISPRELDNE
)
11709 printf (" DISPRELDNE");
11710 val
^= DF_1_DISPRELDNE
;
11712 if (val
& DF_1_DISPRELPND
)
11714 printf (" DISPRELPND");
11715 val
^= DF_1_DISPRELPND
;
11717 if (val
& DF_1_NODIRECT
)
11719 printf (" NODIRECT");
11720 val
^= DF_1_NODIRECT
;
11722 if (val
& DF_1_IGNMULDEF
)
11724 printf (" IGNMULDEF");
11725 val
^= DF_1_IGNMULDEF
;
11727 if (val
& DF_1_NOKSYMS
)
11729 printf (" NOKSYMS");
11730 val
^= DF_1_NOKSYMS
;
11732 if (val
& DF_1_NOHDR
)
11737 if (val
& DF_1_EDITED
)
11739 printf (" EDITED");
11740 val
^= DF_1_EDITED
;
11742 if (val
& DF_1_NORELOC
)
11744 printf (" NORELOC");
11745 val
^= DF_1_NORELOC
;
11747 if (val
& DF_1_SYMINTPOSE
)
11749 printf (" SYMINTPOSE");
11750 val
^= DF_1_SYMINTPOSE
;
11752 if (val
& DF_1_GLOBAUDIT
)
11754 printf (" GLOBAUDIT");
11755 val
^= DF_1_GLOBAUDIT
;
11757 if (val
& DF_1_SINGLETON
)
11759 printf (" SINGLETON");
11760 val
^= DF_1_SINGLETON
;
11762 if (val
& DF_1_STUB
)
11767 if (val
& DF_1_PIE
)
11772 if (val
& DF_1_KMOD
)
11777 if (val
& DF_1_WEAKFILTER
)
11779 printf (" WEAKFILTER");
11780 val
^= DF_1_WEAKFILTER
;
11782 if (val
& DF_1_NOCOMMON
)
11784 printf (" NOCOMMON");
11785 val
^= DF_1_NOCOMMON
;
11788 printf (" %lx", val
);
11795 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11797 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
11818 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11824 if (valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
11825 name
= get_dynamic_name (filedata
, entry
->d_un
.d_val
);
11831 switch (entry
->d_tag
)
11834 printf (_("Shared library: [%s]"), name
);
11836 if (filedata
->program_interpreter
11837 && streq (name
, filedata
->program_interpreter
))
11838 printf (_(" program interpreter"));
11842 printf (_("Library soname: [%s]"), name
);
11846 printf (_("Library rpath: [%s]"), name
);
11850 printf (_("Library runpath: [%s]"), name
);
11854 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11859 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11874 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11875 /* Fall through. */
11879 case DT_PREINIT_ARRAYSZ
:
11880 case DT_INIT_ARRAYSZ
:
11881 case DT_FINI_ARRAYSZ
:
11882 case DT_GNU_CONFLICTSZ
:
11883 case DT_GNU_LIBLISTSZ
:
11886 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11887 printf (_(" (bytes)\n"));
11892 case DT_VERNEEDNUM
:
11897 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11906 case DT_INIT_ARRAY
:
11907 case DT_FINI_ARRAY
:
11910 if (entry
->d_tag
== DT_USED
11911 && valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
11914 = get_dynamic_name (filedata
, entry
->d_un
.d_val
);
11918 printf (_("Not needed object: [%s]\n"), name
);
11923 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11929 /* The value of this entry is ignored. */
11934 case DT_GNU_PRELINKED
:
11938 time_t atime
= entry
->d_un
.d_val
;
11940 tmp
= gmtime (&atime
);
11941 /* PR 17533 file: 041-1244816-0.004. */
11943 printf (_("<corrupt time val: %lx"),
11944 (unsigned long) atime
);
11946 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
11947 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11948 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11954 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11957 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11962 case DT_GNU_FLAGS_1
:
11965 printf (_("Flags:"));
11966 if (entry
->d_un
.d_val
== 0)
11967 printf (_(" None\n"));
11970 unsigned long int val
= entry
->d_un
.d_val
;
11972 if (val
& DF_GNU_1_UNIQUE
)
11974 printf (" UNIQUE");
11975 val
^= DF_GNU_1_UNIQUE
;
11978 printf (" %lx", val
);
11985 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
11986 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
11987 = entry
->d_un
.d_val
;
11991 switch (filedata
->file_header
.e_machine
)
11994 dynamic_section_aarch64_val (entry
);
11997 case EM_MIPS_RS3_LE
:
11998 dynamic_section_mips_val (filedata
, entry
);
12001 dynamic_section_parisc_val (entry
);
12004 dynamic_section_ia64_val (entry
);
12007 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12019 get_ver_flags (unsigned int flags
)
12021 static char buff
[128];
12028 if (flags
& VER_FLG_BASE
)
12029 strcat (buff
, "BASE");
12031 if (flags
& VER_FLG_WEAK
)
12033 if (flags
& VER_FLG_BASE
)
12034 strcat (buff
, " | ");
12036 strcat (buff
, "WEAK");
12039 if (flags
& VER_FLG_INFO
)
12041 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
12042 strcat (buff
, " | ");
12044 strcat (buff
, "INFO");
12047 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
12049 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
12050 strcat (buff
, " | ");
12052 strcat (buff
, _("<unknown>"));
12058 /* Display the contents of the version sections. */
12061 process_version_sections (Filedata
* filedata
)
12063 Elf_Internal_Shdr
* section
;
12065 bool found
= false;
12070 for (i
= 0, section
= filedata
->section_headers
;
12071 i
< filedata
->file_header
.e_shnum
;
12074 switch (section
->sh_type
)
12076 case SHT_GNU_verdef
:
12078 Elf_External_Verdef
* edefs
;
12085 if (filedata
->is_separate
)
12086 printf (ngettext ("\nIn linked file '%s' the version definition section '%s' contains %u entry:\n",
12087 "\nIn linked file '%s' the version definition section '%s' contains %u entries:\n",
12089 filedata
->file_name
,
12090 printable_section_name (filedata
, section
),
12093 printf (ngettext ("\nVersion definition section '%s' "
12094 "contains %u entry:\n",
12095 "\nVersion definition section '%s' "
12096 "contains %u entries:\n",
12098 printable_section_name (filedata
, section
),
12101 printf (_(" Addr: 0x%016" PRIx64
), section
->sh_addr
);
12102 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
12103 (unsigned long) section
->sh_offset
, section
->sh_link
,
12104 printable_section_name_from_index (filedata
, section
->sh_link
));
12106 edefs
= (Elf_External_Verdef
*)
12107 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
12108 _("version definition section"));
12111 endbuf
= (char *) edefs
+ section
->sh_size
;
12113 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
12116 Elf_External_Verdef
* edef
;
12117 Elf_Internal_Verdef ent
;
12118 Elf_External_Verdaux
* eaux
;
12119 Elf_Internal_Verdaux aux
;
12120 unsigned long isum
;
12123 vstart
= ((char *) edefs
) + idx
;
12124 if (vstart
+ sizeof (*edef
) > endbuf
)
12127 edef
= (Elf_External_Verdef
*) vstart
;
12129 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
12130 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
12131 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
12132 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
12133 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
12134 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
12135 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
12137 printf (_(" %#06lx: Rev: %d Flags: %s"),
12138 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
12140 printf (_(" Index: %d Cnt: %d "),
12141 ent
.vd_ndx
, ent
.vd_cnt
);
12143 /* Check for overflow. */
12144 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
12147 vstart
+= ent
.vd_aux
;
12149 if (vstart
+ sizeof (*eaux
) > endbuf
)
12151 eaux
= (Elf_External_Verdaux
*) vstart
;
12153 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
12154 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
12156 if (valid_dynamic_name (filedata
, aux
.vda_name
))
12157 printf (_("Name: %s\n"),
12158 get_dynamic_name (filedata
, aux
.vda_name
));
12160 printf (_("Name index: %ld\n"), aux
.vda_name
);
12162 isum
= idx
+ ent
.vd_aux
;
12164 for (j
= 1; j
< ent
.vd_cnt
; j
++)
12166 if (aux
.vda_next
< sizeof (*eaux
)
12167 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
12169 warn (_("Invalid vda_next field of %lx\n"),
12174 /* Check for overflow. */
12175 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
12178 isum
+= aux
.vda_next
;
12179 vstart
+= aux
.vda_next
;
12181 if (vstart
+ sizeof (*eaux
) > endbuf
)
12183 eaux
= (Elf_External_Verdaux
*) vstart
;
12185 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
12186 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
12188 if (valid_dynamic_name (filedata
, aux
.vda_name
))
12189 printf (_(" %#06lx: Parent %d: %s\n"),
12191 get_dynamic_name (filedata
, aux
.vda_name
));
12193 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
12194 isum
, j
, aux
.vda_name
);
12197 if (j
< ent
.vd_cnt
)
12198 printf (_(" Version def aux past end of section\n"));
12201 file: id:000001,src:000172+005151,op:splice,rep:2. */
12202 if (ent
.vd_next
< sizeof (*edef
)
12203 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
12205 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
12206 cnt
= section
->sh_info
;
12209 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
12212 idx
+= ent
.vd_next
;
12215 if (cnt
< section
->sh_info
)
12216 printf (_(" Version definition past end of section\n"));
12222 case SHT_GNU_verneed
:
12224 Elf_External_Verneed
* eneed
;
12231 if (filedata
->is_separate
)
12232 printf (ngettext ("\nIn linked file '%s' the version needs section '%s' contains %u entry:\n",
12233 "\nIn linked file '%s' the version needs section '%s' contains %u entries:\n",
12235 filedata
->file_name
,
12236 printable_section_name (filedata
, section
),
12239 printf (ngettext ("\nVersion needs section '%s' "
12240 "contains %u entry:\n",
12241 "\nVersion needs section '%s' "
12242 "contains %u entries:\n",
12244 printable_section_name (filedata
, section
),
12247 printf (_(" Addr: 0x%016" PRIx64
), section
->sh_addr
);
12248 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
12249 (unsigned long) section
->sh_offset
, section
->sh_link
,
12250 printable_section_name_from_index (filedata
, section
->sh_link
));
12252 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
12253 section
->sh_offset
, 1,
12255 _("Version Needs section"));
12258 endbuf
= (char *) eneed
+ section
->sh_size
;
12260 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
12262 Elf_External_Verneed
* entry
;
12263 Elf_Internal_Verneed ent
;
12264 unsigned long isum
;
12268 vstart
= ((char *) eneed
) + idx
;
12269 if (vstart
+ sizeof (*entry
) > endbuf
)
12272 entry
= (Elf_External_Verneed
*) vstart
;
12274 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
12275 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
12276 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
12277 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
12278 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
12280 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
12282 if (valid_dynamic_name (filedata
, ent
.vn_file
))
12283 printf (_(" File: %s"),
12284 get_dynamic_name (filedata
, ent
.vn_file
));
12286 printf (_(" File: %lx"), ent
.vn_file
);
12288 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
12290 /* Check for overflow. */
12291 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
12293 vstart
+= ent
.vn_aux
;
12295 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
12297 Elf_External_Vernaux
* eaux
;
12298 Elf_Internal_Vernaux aux
;
12300 if (vstart
+ sizeof (*eaux
) > endbuf
)
12302 eaux
= (Elf_External_Vernaux
*) vstart
;
12304 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
12305 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
12306 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
12307 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
12308 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
12310 if (valid_dynamic_name (filedata
, aux
.vna_name
))
12311 printf (_(" %#06lx: Name: %s"),
12312 isum
, get_dynamic_name (filedata
, aux
.vna_name
));
12314 printf (_(" %#06lx: Name index: %lx"),
12315 isum
, aux
.vna_name
);
12317 printf (_(" Flags: %s Version: %d\n"),
12318 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
12320 if (aux
.vna_next
< sizeof (*eaux
)
12321 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
12323 warn (_("Invalid vna_next field of %lx\n"),
12328 /* Check for overflow. */
12329 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
12331 isum
+= aux
.vna_next
;
12332 vstart
+= aux
.vna_next
;
12335 if (j
< ent
.vn_cnt
)
12336 warn (_("Missing Version Needs auxiliary information\n"));
12338 if (ent
.vn_next
< sizeof (*entry
)
12339 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
12341 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
12342 cnt
= section
->sh_info
;
12345 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
12347 idx
+= ent
.vn_next
;
12350 if (cnt
< section
->sh_info
)
12351 warn (_("Missing Version Needs information\n"));
12357 case SHT_GNU_versym
:
12359 Elf_Internal_Shdr
* link_section
;
12362 unsigned char * edata
;
12363 unsigned short * data
;
12365 Elf_Internal_Sym
* symbols
;
12366 Elf_Internal_Shdr
* string_sec
;
12367 unsigned long num_syms
;
12370 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
12373 link_section
= filedata
->section_headers
+ section
->sh_link
;
12374 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
12376 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
12381 symbols
= get_elf_symbols (filedata
, link_section
, & num_syms
);
12382 if (symbols
== NULL
)
12385 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
12387 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
12388 string_sec
->sh_size
,
12389 _("version string table"));
12396 if (filedata
->is_separate
)
12397 printf (ngettext ("\nIn linked file '%s' the version symbols section '%s' contains %lu entry:\n",
12398 "\nIn linked file '%s' the version symbols section '%s' contains %lu entries:\n",
12400 filedata
->file_name
,
12401 printable_section_name (filedata
, section
),
12402 (unsigned long) total
);
12404 printf (ngettext ("\nVersion symbols section '%s' "
12405 "contains %lu entry:\n",
12406 "\nVersion symbols section '%s' "
12407 "contains %lu entries:\n",
12409 printable_section_name (filedata
, section
),
12410 (unsigned long) total
);
12412 printf (_(" Addr: 0x%016" PRIx64
), section
->sh_addr
);
12413 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
12414 (unsigned long) section
->sh_offset
, section
->sh_link
,
12415 printable_section_name (filedata
, link_section
));
12417 off
= offset_from_vma (filedata
,
12418 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
12419 total
* sizeof (short));
12420 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
12421 sizeof (short), total
,
12422 _("version symbol data"));
12430 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
12432 for (cnt
= total
; cnt
--;)
12433 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
12438 for (cnt
= 0; cnt
< total
; cnt
+= 4)
12442 char *invalid
= _("*invalid*");
12444 printf (" %03x:", cnt
);
12446 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
12447 switch (data
[cnt
+ j
])
12450 fputs (_(" 0 (*local*) "), stdout
);
12454 fputs (_(" 1 (*global*) "), stdout
);
12458 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
12459 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
12461 /* If this index value is greater than the size of the symbols
12462 array, break to avoid an out-of-bounds read. */
12463 if ((unsigned long)(cnt
+ j
) >= num_syms
)
12465 warn (_("invalid index into symbol array\n"));
12470 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
12472 Elf_Internal_Verneed ivn
;
12473 unsigned long offset
;
12475 offset
= offset_from_vma
12477 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
12478 sizeof (Elf_External_Verneed
));
12482 Elf_Internal_Vernaux ivna
;
12483 Elf_External_Verneed evn
;
12484 Elf_External_Vernaux evna
;
12485 unsigned long a_off
;
12487 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
12488 _("version need")) == NULL
)
12491 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
12492 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
12494 a_off
= offset
+ ivn
.vn_aux
;
12498 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
12499 1, _("version need aux (2)")) == NULL
)
12502 ivna
.vna_other
= 0;
12506 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
12507 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
12510 a_off
+= ivna
.vna_next
;
12512 while (ivna
.vna_other
!= data
[cnt
+ j
]
12513 && ivna
.vna_next
!= 0);
12515 if (ivna
.vna_other
== data
[cnt
+ j
])
12517 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
12519 if (ivna
.vna_name
>= string_sec
->sh_size
)
12522 name
= strtab
+ ivna
.vna_name
;
12526 offset
+= ivn
.vn_next
;
12528 while (ivn
.vn_next
);
12531 if (data
[cnt
+ j
] != 0x8001
12532 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
12534 Elf_Internal_Verdef ivd
;
12535 Elf_External_Verdef evd
;
12536 unsigned long offset
;
12538 offset
= offset_from_vma
12540 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
12545 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
12546 _("version def")) == NULL
)
12549 /* PR 17531: file: 046-1082287-0.004. */
12550 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
12555 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
12556 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
12559 offset
+= ivd
.vd_next
;
12561 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
12562 && ivd
.vd_next
!= 0);
12564 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
12566 Elf_External_Verdaux evda
;
12567 Elf_Internal_Verdaux ivda
;
12569 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
12571 if (get_data (&evda
, filedata
,
12572 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
12574 _("version def aux")) == NULL
)
12577 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
12579 if (ivda
.vda_name
>= string_sec
->sh_size
)
12581 else if (name
!= NULL
&& name
!= invalid
)
12582 name
= _("*both*");
12584 name
= strtab
+ ivda
.vda_name
;
12588 nn
+= printf ("(%s%-*s",
12590 12 - (int) strlen (name
),
12594 printf ("%*c", 18 - nn
, ' ');
12613 if (filedata
->is_separate
)
12614 printf (_("\nNo version information found in linked file '%s'.\n"),
12615 filedata
->file_name
);
12617 printf (_("\nNo version information found in this file.\n"));
12623 static const char *
12624 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
12626 static char buff
[64];
12630 case STB_LOCAL
: return "LOCAL";
12631 case STB_GLOBAL
: return "GLOBAL";
12632 case STB_WEAK
: return "WEAK";
12634 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
12635 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
12637 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
12639 if (binding
== STB_GNU_UNIQUE
12640 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
12642 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
12645 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
12650 static const char *
12651 get_symbol_type (Filedata
* filedata
, unsigned int type
)
12653 static char buff
[64];
12657 case STT_NOTYPE
: return "NOTYPE";
12658 case STT_OBJECT
: return "OBJECT";
12659 case STT_FUNC
: return "FUNC";
12660 case STT_SECTION
: return "SECTION";
12661 case STT_FILE
: return "FILE";
12662 case STT_COMMON
: return "COMMON";
12663 case STT_TLS
: return "TLS";
12664 case STT_RELC
: return "RELC";
12665 case STT_SRELC
: return "SRELC";
12667 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
12669 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
12670 return "THUMB_FUNC";
12672 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
12675 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
12676 return "PARISC_MILLI";
12678 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
12680 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
12682 if (filedata
->file_header
.e_machine
== EM_PARISC
)
12684 if (type
== STT_HP_OPAQUE
)
12685 return "HP_OPAQUE";
12686 if (type
== STT_HP_STUB
)
12690 if (type
== STT_GNU_IFUNC
12691 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
12692 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
12695 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
12698 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
12703 static const char *
12704 get_symbol_visibility (unsigned int visibility
)
12706 switch (visibility
)
12708 case STV_DEFAULT
: return "DEFAULT";
12709 case STV_INTERNAL
: return "INTERNAL";
12710 case STV_HIDDEN
: return "HIDDEN";
12711 case STV_PROTECTED
: return "PROTECTED";
12713 error (_("Unrecognized visibility value: %u\n"), visibility
);
12714 return _("<unknown>");
12718 static const char *
12719 get_alpha_symbol_other (unsigned int other
)
12723 case STO_ALPHA_NOPV
: return "NOPV";
12724 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
12726 error (_("Unrecognized alpha specific other value: %u\n"), other
);
12727 return _("<unknown>");
12731 static const char *
12732 get_solaris_symbol_visibility (unsigned int visibility
)
12734 switch (visibility
)
12736 case 4: return "EXPORTED";
12737 case 5: return "SINGLETON";
12738 case 6: return "ELIMINATE";
12739 default: return get_symbol_visibility (visibility
);
12743 static const char *
12744 get_aarch64_symbol_other (unsigned int other
)
12746 static char buf
[32];
12748 if (other
& STO_AARCH64_VARIANT_PCS
)
12750 other
&= ~STO_AARCH64_VARIANT_PCS
;
12752 return "VARIANT_PCS";
12753 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
12759 static const char *
12760 get_mips_symbol_other (unsigned int other
)
12764 case STO_OPTIONAL
: return "OPTIONAL";
12765 case STO_MIPS_PLT
: return "MIPS PLT";
12766 case STO_MIPS_PIC
: return "MIPS PIC";
12767 case STO_MICROMIPS
: return "MICROMIPS";
12768 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
12769 case STO_MIPS16
: return "MIPS16";
12770 default: return NULL
;
12774 static const char *
12775 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
12777 if (is_ia64_vms (filedata
))
12779 static char res
[32];
12783 /* Function types is for images and .STB files only. */
12784 switch (filedata
->file_header
.e_type
)
12788 switch (VMS_ST_FUNC_TYPE (other
))
12790 case VMS_SFT_CODE_ADDR
:
12791 strcat (res
, " CA");
12793 case VMS_SFT_SYMV_IDX
:
12794 strcat (res
, " VEC");
12797 strcat (res
, " FD");
12799 case VMS_SFT_RESERVE
:
12800 strcat (res
, " RSV");
12803 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
12804 VMS_ST_FUNC_TYPE (other
));
12805 strcat (res
, " <unknown>");
12812 switch (VMS_ST_LINKAGE (other
))
12814 case VMS_STL_IGNORE
:
12815 strcat (res
, " IGN");
12817 case VMS_STL_RESERVE
:
12818 strcat (res
, " RSV");
12821 strcat (res
, " STD");
12824 strcat (res
, " LNK");
12827 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
12828 VMS_ST_LINKAGE (other
));
12829 strcat (res
, " <unknown>");
12841 static const char *
12842 get_ppc64_symbol_other (unsigned int other
)
12844 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
12847 other
>>= STO_PPC64_LOCAL_BIT
;
12850 static char buf
[64];
12852 other
= ppc64_decode_local_entry (other
);
12853 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
12859 static const char *
12860 get_riscv_symbol_other (unsigned int other
)
12862 static char buf
[32];
12865 if (other
& STO_RISCV_VARIANT_CC
)
12867 strcat (buf
, _(" VARIANT_CC"));
12868 other
&= ~STO_RISCV_VARIANT_CC
;
12872 snprintf (buf
, sizeof buf
, " %x", other
);
12881 static const char *
12882 get_symbol_other (Filedata
* filedata
, unsigned int other
)
12884 const char * result
= NULL
;
12885 static char buff
[64];
12890 switch (filedata
->file_header
.e_machine
)
12893 result
= get_alpha_symbol_other (other
);
12896 result
= get_aarch64_symbol_other (other
);
12899 result
= get_mips_symbol_other (other
);
12902 result
= get_ia64_symbol_other (filedata
, other
);
12905 result
= get_ppc64_symbol_other (other
);
12908 result
= get_riscv_symbol_other (other
);
12918 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
12922 static const char *
12923 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
12925 static char buff
[32];
12929 case SHN_UNDEF
: return "UND";
12930 case SHN_ABS
: return "ABS";
12931 case SHN_COMMON
: return "COM";
12933 if (type
== SHN_IA_64_ANSI_COMMON
12934 && filedata
->file_header
.e_machine
== EM_IA_64
12935 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
12937 else if ((filedata
->file_header
.e_machine
== EM_X86_64
12938 || filedata
->file_header
.e_machine
== EM_L1OM
12939 || filedata
->file_header
.e_machine
== EM_K1OM
)
12940 && type
== SHN_X86_64_LCOMMON
)
12941 return "LARGE_COM";
12942 else if ((type
== SHN_MIPS_SCOMMON
12943 && filedata
->file_header
.e_machine
== EM_MIPS
)
12944 || (type
== SHN_TIC6X_SCOMMON
12945 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
12947 else if (type
== SHN_MIPS_SUNDEFINED
12948 && filedata
->file_header
.e_machine
== EM_MIPS
)
12950 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
12951 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
12952 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
12953 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
12954 else if (type
>= SHN_LORESERVE
)
12955 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
12956 else if (filedata
->file_header
.e_shnum
!= 0
12957 && type
>= filedata
->file_header
.e_shnum
)
12958 sprintf (buff
, _("bad section index[%3d]"), type
);
12960 sprintf (buff
, "%3d", type
);
12967 static const char *
12968 get_symbol_version_string (Filedata
* filedata
,
12970 const char * strtab
,
12971 unsigned long int strtab_size
,
12973 Elf_Internal_Sym
* psym
,
12974 enum versioned_symbol_info
* sym_info
,
12975 unsigned short * vna_other
)
12977 unsigned char data
[2];
12978 unsigned short vers_data
;
12979 unsigned long offset
;
12980 unsigned short max_vd_ndx
;
12983 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
12986 offset
= offset_from_vma (filedata
,
12987 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
12988 sizeof data
+ si
* sizeof (vers_data
));
12990 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
12991 sizeof (data
), 1, _("version data")) == NULL
)
12994 vers_data
= byte_get (data
, 2);
12996 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
12999 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
13002 /* Usually we'd only see verdef for defined symbols, and verneed for
13003 undefined symbols. However, symbols defined by the linker in
13004 .dynbss for variables copied from a shared library in order to
13005 avoid text relocations are defined yet have verneed. We could
13006 use a heuristic to detect the special case, for example, check
13007 for verneed first on symbols defined in SHT_NOBITS sections, but
13008 it is simpler and more reliable to just look for both verdef and
13009 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
13011 if (psym
->st_shndx
!= SHN_UNDEF
13012 && vers_data
!= 0x8001
13013 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
13015 Elf_Internal_Verdef ivd
;
13016 Elf_Internal_Verdaux ivda
;
13017 Elf_External_Verdaux evda
;
13020 off
= offset_from_vma (filedata
,
13021 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
13022 sizeof (Elf_External_Verdef
));
13026 Elf_External_Verdef evd
;
13028 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
13029 _("version def")) == NULL
)
13038 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
13039 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
13040 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
13041 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
13044 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
13045 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
13047 off
+= ivd
.vd_next
;
13049 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
13051 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
13053 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
13056 off
-= ivd
.vd_next
;
13059 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
13060 _("version def aux")) != NULL
)
13062 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
13064 if (psym
->st_name
!= ivda
.vda_name
)
13065 return (ivda
.vda_name
< strtab_size
13066 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
13071 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
13073 Elf_External_Verneed evn
;
13074 Elf_Internal_Verneed ivn
;
13075 Elf_Internal_Vernaux ivna
;
13077 offset
= offset_from_vma (filedata
,
13078 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
13082 unsigned long vna_off
;
13084 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
13085 _("version need")) == NULL
)
13088 ivna
.vna_other
= 0;
13093 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
13094 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
13096 vna_off
= offset
+ ivn
.vn_aux
;
13100 Elf_External_Vernaux evna
;
13102 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
13103 _("version need aux (3)")) == NULL
)
13106 ivna
.vna_other
= 0;
13111 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
13112 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
13113 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
13116 vna_off
+= ivna
.vna_next
;
13118 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
13120 if (ivna
.vna_other
== vers_data
)
13123 offset
+= ivn
.vn_next
;
13125 while (ivn
.vn_next
!= 0);
13127 if (ivna
.vna_other
== vers_data
)
13129 *sym_info
= symbol_undefined
;
13130 *vna_other
= ivna
.vna_other
;
13131 return (ivna
.vna_name
< strtab_size
13132 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
13134 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
13135 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
13136 return _("<corrupt>");
13141 /* Display a symbol size on stdout. Format is based on --sym-base setting. */
13143 static unsigned int
13144 print_dynamic_symbol_size (uint64_t vma
, int base
)
13149 return print_vma (vma
, OCTAL_5
);
13152 return print_vma (vma
, UNSIGNED_5
);
13155 return print_vma (vma
, PREFIX_HEX_5
);
13159 return print_vma (vma
, DEC_5
);
13164 print_dynamic_symbol (Filedata
*filedata
, unsigned long si
,
13165 Elf_Internal_Sym
*symtab
,
13166 Elf_Internal_Shdr
*section
,
13167 char *strtab
, size_t strtab_size
)
13169 const char *version_string
;
13170 enum versioned_symbol_info sym_info
;
13171 unsigned short vna_other
;
13174 Elf_Internal_Sym
*psym
= symtab
+ si
;
13176 printf ("%6ld: ", si
);
13177 print_vma (psym
->st_value
, LONG_HEX
);
13179 print_dynamic_symbol_size (psym
->st_size
, sym_base
);
13180 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
13181 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
13182 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
13183 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
13186 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
13188 printf (" %-7s", get_symbol_visibility (vis
));
13189 /* Check to see if any other bits in the st_other field are set.
13190 Note - displaying this information disrupts the layout of the
13191 table being generated, but for the moment this case is very rare. */
13192 if (psym
->st_other
^ vis
)
13193 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
13195 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
13197 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
13198 && psym
->st_shndx
< filedata
->file_header
.e_shnum
13199 && filedata
->section_headers
!= NULL
13200 && psym
->st_name
== 0)
13203 = section_name_valid (filedata
,
13204 filedata
->section_headers
+ psym
->st_shndx
);
13206 section_name_print (filedata
,
13207 filedata
->section_headers
+ psym
->st_shndx
)
13212 is_valid
= valid_symbol_name (strtab
, strtab_size
, psym
->st_name
);
13213 sstr
= is_valid
? strtab
+ psym
->st_name
: _("<corrupt>");
13217 = get_symbol_version_string (filedata
,
13219 || section
->sh_type
== SHT_DYNSYM
),
13220 strtab
, strtab_size
, si
,
13221 psym
, &sym_info
, &vna_other
);
13223 int len_avail
= 21;
13224 if (! do_wide
&& version_string
!= NULL
)
13228 len_avail
-= 1 + strlen (version_string
);
13230 if (sym_info
== symbol_undefined
)
13231 len_avail
-= sprintf (buffer
," (%d)", vna_other
);
13232 else if (sym_info
!= symbol_hidden
)
13236 print_symbol (len_avail
, sstr
);
13238 if (version_string
)
13240 if (sym_info
== symbol_undefined
)
13241 printf ("@%s (%d)", version_string
, vna_other
);
13243 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
13249 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
13251 && si
>= section
->sh_info
13252 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
13253 && filedata
->file_header
.e_machine
!= EM_MIPS
13254 /* Solaris binaries have been found to violate this requirement as
13255 well. Not sure if this is a bug or an ABI requirement. */
13256 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
13257 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
13258 si
, printable_section_name (filedata
, section
), section
->sh_info
);
13261 static const char *
13262 get_lto_kind (unsigned int kind
)
13266 case 0: return "DEF";
13267 case 1: return "WEAKDEF";
13268 case 2: return "UNDEF";
13269 case 3: return "WEAKUNDEF";
13270 case 4: return "COMMON";
13275 static char buffer
[30];
13276 error (_("Unknown LTO symbol definition encountered: %u\n"), kind
);
13277 sprintf (buffer
, "<unknown: %u>", kind
);
13281 static const char *
13282 get_lto_visibility (unsigned int visibility
)
13284 switch (visibility
)
13286 case 0: return "DEFAULT";
13287 case 1: return "PROTECTED";
13288 case 2: return "INTERNAL";
13289 case 3: return "HIDDEN";
13294 static char buffer
[30];
13295 error (_("Unknown LTO symbol visibility encountered: %u\n"), visibility
);
13296 sprintf (buffer
, "<unknown: %u>", visibility
);
13300 static const char *
13301 get_lto_sym_type (unsigned int sym_type
)
13305 case 0: return "UNKNOWN";
13306 case 1: return "FUNCTION";
13307 case 2: return "VARIABLE";
13312 static char buffer
[30];
13313 error (_("Unknown LTO symbol type encountered: %u\n"), sym_type
);
13314 sprintf (buffer
, "<unknown: %u>", sym_type
);
13318 /* Display an LTO format symbol table.
13319 FIXME: The format of LTO symbol tables is not formalized.
13320 So this code could need changing in the future. */
13323 display_lto_symtab (Filedata
* filedata
,
13324 Elf_Internal_Shdr
* section
)
13326 if (section
->sh_size
== 0)
13328 if (filedata
->is_separate
)
13329 printf (_("\nThe LTO Symbol table section '%s' in linked file '%s' is empty!\n"),
13330 printable_section_name (filedata
, section
),
13331 filedata
->file_name
);
13333 printf (_("\nLTO Symbol table '%s' is empty!\n"),
13334 printable_section_name (filedata
, section
));
13339 if (section
->sh_size
> filedata
->file_size
)
13341 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
13342 printable_section_name (filedata
, section
),
13343 (unsigned long) section
->sh_size
);
13347 void * alloced_data
= get_data (NULL
, filedata
, section
->sh_offset
,
13348 section
->sh_size
, 1, _("LTO symbols"));
13349 if (alloced_data
== NULL
)
13352 /* Look for extended data for the symbol table. */
13353 Elf_Internal_Shdr
* ext
;
13354 void * ext_data_orig
= NULL
;
13355 char * ext_data
= NULL
;
13356 char * ext_data_end
= NULL
;
13357 char * ext_name
= NULL
;
13359 if (asprintf (& ext_name
, ".gnu.lto_.ext_symtab.%s",
13360 (section_name (filedata
, section
)
13361 + sizeof (".gnu.lto_.symtab.") - 1)) > 0
13362 && ext_name
!= NULL
/* Paranoia. */
13363 && (ext
= find_section (filedata
, ext_name
)) != NULL
)
13365 if (ext
->sh_size
< 3)
13366 error (_("LTO Symbol extension table '%s' is empty!\n"),
13367 printable_section_name (filedata
, ext
));
13370 ext_data_orig
= ext_data
= get_data (NULL
, filedata
, ext
->sh_offset
,
13372 _("LTO ext symbol data"));
13373 if (ext_data
!= NULL
)
13375 ext_data_end
= ext_data
+ ext
->sh_size
;
13376 if (* ext_data
++ != 1)
13377 error (_("Unexpected version number in symbol extension table\n"));
13382 const unsigned char * data
= (const unsigned char *) alloced_data
;
13383 const unsigned char * end
= data
+ section
->sh_size
;
13385 if (filedata
->is_separate
)
13386 printf (_("\nIn linked file '%s': "), filedata
->file_name
);
13390 if (ext_data_orig
!= NULL
)
13393 printf (_("LTO Symbol table '%s' and extension table '%s' contain:\n"),
13394 printable_section_name (filedata
, section
),
13395 printable_section_name (filedata
, ext
));
13398 printf (_("LTO Symbol table '%s'\n"),
13399 printable_section_name (filedata
, section
));
13400 printf (_(" and extension table '%s' contain:\n"),
13401 printable_section_name (filedata
, ext
));
13405 printf (_("LTO Symbol table '%s' contains:\n"),
13406 printable_section_name (filedata
, section
));
13408 /* FIXME: Add a wide version. */
13409 if (ext_data_orig
!= NULL
)
13410 printf (_(" Comdat_Key Kind Visibility Size Slot Type Section Name\n"));
13412 printf (_(" Comdat_Key Kind Visibility Size Slot Name\n"));
13414 /* FIXME: We do not handle style prefixes. */
13418 const unsigned char * sym_name
= data
;
13419 data
+= strnlen ((const char *) sym_name
, end
- data
) + 1;
13423 const unsigned char * comdat_key
= data
;
13424 data
+= strnlen ((const char *) comdat_key
, end
- data
) + 1;
13428 if (data
+ 2 + 8 + 4 > end
)
13431 unsigned int kind
= *data
++;
13432 unsigned int visibility
= *data
++;
13434 uint64_t size
= byte_get (data
, 8);
13437 uint64_t slot
= byte_get (data
, 4);
13440 if (ext_data
!= NULL
)
13442 if (ext_data
< (ext_data_end
- 1))
13444 unsigned int sym_type
= * ext_data
++;
13445 unsigned int sec_kind
= * ext_data
++;
13447 printf (" %10s %10s %11s %08" PRIx64
" %08" PRIx64
" %9s %08x _",
13448 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
13449 get_lto_kind (kind
),
13450 get_lto_visibility (visibility
),
13453 get_lto_sym_type (sym_type
),
13455 print_symbol (6, (const char *) sym_name
);
13459 error (_("Ran out of LTO symbol extension data\n"));
13461 /* FIXME: return FAIL result ? */
13466 printf (" %10s %10s %11s %08" PRIx64
" %08" PRIx64
" _",
13467 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
13468 get_lto_kind (kind
),
13469 get_lto_visibility (visibility
),
13472 print_symbol (21, (const char *) sym_name
);
13477 if (ext_data
!= NULL
&& ext_data
< ext_data_end
)
13479 error (_("Data remains in the LTO symbol extension table\n"));
13483 free (alloced_data
);
13484 free (ext_data_orig
);
13489 error (_("Buffer overrun encountered whilst decoding LTO symbol table\n"));
13490 free (alloced_data
);
13491 free (ext_data_orig
);
13496 /* Display LTO symbol tables. */
13499 process_lto_symbol_tables (Filedata
* filedata
)
13501 Elf_Internal_Shdr
* section
;
13508 if (filedata
->section_headers
== NULL
)
13511 for (i
= 0, section
= filedata
->section_headers
;
13512 i
< filedata
->file_header
.e_shnum
;
13514 if (section_name_valid (filedata
, section
)
13515 && startswith (section_name (filedata
, section
), ".gnu.lto_.symtab."))
13516 res
&= display_lto_symtab (filedata
, section
);
13521 /* Dump the symbol table. */
13524 process_symbol_table (Filedata
* filedata
)
13526 Elf_Internal_Shdr
* section
;
13528 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
13531 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
13533 && do_using_dynamic
13534 && filedata
->dynamic_strings
!= NULL
13535 && filedata
->dynamic_symbols
!= NULL
)
13539 if (filedata
->is_separate
)
13541 printf (ngettext ("\nIn linked file '%s' the dynamic symbol table contains %lu entry:\n",
13542 "\nIn linked file '%s' the dynamic symbol table contains %lu entries:\n",
13543 filedata
->num_dynamic_syms
),
13544 filedata
->file_name
,
13545 filedata
->num_dynamic_syms
);
13549 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
13550 "\nSymbol table for image contains %lu entries:\n",
13551 filedata
->num_dynamic_syms
),
13552 filedata
->num_dynamic_syms
);
13555 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
13557 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
13559 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
13560 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
13561 filedata
->dynamic_strings
,
13562 filedata
->dynamic_strings_length
);
13564 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
13565 && filedata
->section_headers
!= NULL
)
13569 for (i
= 0, section
= filedata
->section_headers
;
13570 i
< filedata
->file_header
.e_shnum
;
13573 char * strtab
= NULL
;
13574 unsigned long int strtab_size
= 0;
13575 Elf_Internal_Sym
* symtab
;
13576 unsigned long si
, num_syms
;
13578 if ((section
->sh_type
!= SHT_SYMTAB
13579 && section
->sh_type
!= SHT_DYNSYM
)
13581 && section
->sh_type
== SHT_SYMTAB
))
13584 if (section
->sh_entsize
== 0)
13586 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
13587 printable_section_name (filedata
, section
));
13591 num_syms
= section
->sh_size
/ section
->sh_entsize
;
13593 if (filedata
->is_separate
)
13594 printf (ngettext ("\nIn linked file '%s' symbol section '%s' contains %lu entry:\n",
13595 "\nIn linked file '%s' symbol section '%s' contains %lu entries:\n",
13597 filedata
->file_name
,
13598 printable_section_name (filedata
, section
),
13601 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
13602 "\nSymbol table '%s' contains %lu entries:\n",
13604 printable_section_name (filedata
, section
),
13608 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
13610 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
13612 symtab
= get_elf_symbols (filedata
, section
, & num_syms
);
13613 if (symtab
== NULL
)
13616 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
13618 strtab
= filedata
->string_table
;
13619 strtab_size
= filedata
->string_table_length
;
13621 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
13623 Elf_Internal_Shdr
* string_sec
;
13625 string_sec
= filedata
->section_headers
+ section
->sh_link
;
13627 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
13628 1, string_sec
->sh_size
,
13629 _("string table"));
13630 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
13633 for (si
= 0; si
< num_syms
; si
++)
13634 print_dynamic_symbol (filedata
, si
, symtab
, section
,
13635 strtab
, strtab_size
);
13638 if (strtab
!= filedata
->string_table
)
13644 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
13646 if (do_histogram
&& filedata
->buckets
!= NULL
)
13648 unsigned long * lengths
;
13649 unsigned long * counts
;
13652 unsigned long maxlength
= 0;
13653 unsigned long nzero_counts
= 0;
13654 unsigned long nsyms
= 0;
13657 printf (ngettext ("\nHistogram for bucket list length "
13658 "(total of %lu bucket):\n",
13659 "\nHistogram for bucket list length "
13660 "(total of %lu buckets):\n",
13661 (unsigned long) filedata
->nbuckets
),
13662 (unsigned long) filedata
->nbuckets
);
13664 lengths
= (unsigned long *) calloc (filedata
->nbuckets
,
13665 sizeof (*lengths
));
13666 if (lengths
== NULL
)
13668 error (_("Out of memory allocating space for histogram buckets\n"));
13671 visited
= xcmalloc (filedata
->nchains
, 1);
13672 memset (visited
, 0, filedata
->nchains
);
13674 printf (_(" Length Number %% of total Coverage\n"));
13675 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
13677 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
13680 if (maxlength
< ++lengths
[hn
])
13682 if (si
>= filedata
->nchains
|| visited
[si
])
13684 error (_("histogram chain is corrupt\n"));
13692 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
13693 if (counts
== NULL
)
13696 error (_("Out of memory allocating space for histogram counts\n"));
13700 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
13701 ++counts
[lengths
[hn
]];
13703 if (filedata
->nbuckets
> 0)
13706 printf (" 0 %-10lu (%5.1f%%)\n",
13707 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
13708 for (i
= 1; i
<= maxlength
; ++i
)
13710 nzero_counts
+= counts
[i
] * i
;
13711 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
13712 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
13713 (nzero_counts
* 100.0) / nsyms
);
13721 free (filedata
->buckets
);
13722 filedata
->buckets
= NULL
;
13723 filedata
->nbuckets
= 0;
13724 free (filedata
->chains
);
13725 filedata
->chains
= NULL
;
13727 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
13729 unsigned long * lengths
;
13730 unsigned long * counts
;
13732 unsigned long maxlength
= 0;
13733 unsigned long nzero_counts
= 0;
13734 unsigned long nsyms
= 0;
13736 printf (ngettext ("\nHistogram for `%s' bucket list length "
13737 "(total of %lu bucket):\n",
13738 "\nHistogram for `%s' bucket list length "
13739 "(total of %lu buckets):\n",
13740 (unsigned long) filedata
->ngnubuckets
),
13741 GNU_HASH_SECTION_NAME (filedata
),
13742 (unsigned long) filedata
->ngnubuckets
);
13744 lengths
= (unsigned long *) calloc (filedata
->ngnubuckets
,
13745 sizeof (*lengths
));
13746 if (lengths
== NULL
)
13748 error (_("Out of memory allocating space for gnu histogram buckets\n"));
13752 printf (_(" Length Number %% of total Coverage\n"));
13754 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
13755 if (filedata
->gnubuckets
[hn
] != 0)
13757 uint64_t off
, length
= 1;
13759 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
13760 /* PR 17531 file: 010-77222-0.004. */
13761 off
< filedata
->ngnuchains
13762 && (filedata
->gnuchains
[off
] & 1) == 0;
13765 lengths
[hn
] = length
;
13766 if (length
> maxlength
)
13767 maxlength
= length
;
13771 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
13772 if (counts
== NULL
)
13775 error (_("Out of memory allocating space for gnu histogram counts\n"));
13779 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
13780 ++counts
[lengths
[hn
]];
13782 if (filedata
->ngnubuckets
> 0)
13785 printf (" 0 %-10lu (%5.1f%%)\n",
13786 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
13787 for (j
= 1; j
<= maxlength
; ++j
)
13789 nzero_counts
+= counts
[j
] * j
;
13790 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
13791 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
13792 (nzero_counts
* 100.0) / nsyms
);
13799 free (filedata
->gnubuckets
);
13800 filedata
->gnubuckets
= NULL
;
13801 filedata
->ngnubuckets
= 0;
13802 free (filedata
->gnuchains
);
13803 filedata
->gnuchains
= NULL
;
13804 filedata
->ngnuchains
= 0;
13805 free (filedata
->mipsxlat
);
13806 filedata
->mipsxlat
= NULL
;
13810 free (filedata
->gnubuckets
);
13811 filedata
->gnubuckets
= NULL
;
13812 filedata
->ngnubuckets
= 0;
13813 free (filedata
->gnuchains
);
13814 filedata
->gnuchains
= NULL
;
13815 filedata
->ngnuchains
= 0;
13816 free (filedata
->mipsxlat
);
13817 filedata
->mipsxlat
= NULL
;
13818 free (filedata
->buckets
);
13819 filedata
->buckets
= NULL
;
13820 filedata
->nbuckets
= 0;
13821 free (filedata
->chains
);
13822 filedata
->chains
= NULL
;
13827 process_syminfo (Filedata
* filedata
)
13831 if (filedata
->dynamic_syminfo
== NULL
13833 /* No syminfo, this is ok. */
13836 /* There better should be a dynamic symbol section. */
13837 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
13840 if (filedata
->is_separate
)
13841 printf (ngettext ("\nIn linked file '%s: the dynamic info segment at offset 0x%lx contains %d entry:\n",
13842 "\nIn linked file '%s: the dynamic info segment at offset 0x%lx contains %d entries:\n",
13843 filedata
->dynamic_syminfo_nent
),
13844 filedata
->file_name
,
13845 filedata
->dynamic_syminfo_offset
,
13846 filedata
->dynamic_syminfo_nent
);
13848 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
13849 "contains %d entry:\n",
13850 "\nDynamic info segment at offset 0x%lx "
13851 "contains %d entries:\n",
13852 filedata
->dynamic_syminfo_nent
),
13853 filedata
->dynamic_syminfo_offset
,
13854 filedata
->dynamic_syminfo_nent
);
13856 printf (_(" Num: Name BoundTo Flags\n"));
13857 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
13859 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
13861 printf ("%4d: ", i
);
13862 if (i
>= filedata
->num_dynamic_syms
)
13863 printf (_("<corrupt index>"));
13864 else if (valid_dynamic_name (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
13865 print_symbol (30, get_dynamic_name (filedata
,
13866 filedata
->dynamic_symbols
[i
].st_name
));
13868 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
13871 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
13873 case SYMINFO_BT_SELF
:
13874 fputs ("SELF ", stdout
);
13876 case SYMINFO_BT_PARENT
:
13877 fputs ("PARENT ", stdout
);
13880 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
13881 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
13882 && valid_dynamic_name (filedata
,
13883 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
13885 print_symbol (10, get_dynamic_name (filedata
,
13886 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
13890 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
13894 if (flags
& SYMINFO_FLG_DIRECT
)
13895 printf (" DIRECT");
13896 if (flags
& SYMINFO_FLG_PASSTHRU
)
13897 printf (" PASSTHRU");
13898 if (flags
& SYMINFO_FLG_COPY
)
13900 if (flags
& SYMINFO_FLG_LAZYLOAD
)
13901 printf (" LAZYLOAD");
13909 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
13910 is contained by the region START .. END. The types of ADDR, START
13911 and END should all be the same. Note both ADDR + NELEM and END
13912 point to just beyond the end of the regions that are being tested. */
13913 #define IN_RANGE(START,END,ADDR,NELEM) \
13914 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
13916 /* Check to see if the given reloc needs to be handled in a target specific
13917 manner. If so then process the reloc and return TRUE otherwise return
13920 If called with reloc == NULL, then this is a signal that reloc processing
13921 for the current section has finished, and any saved state should be
13925 target_specific_reloc_handling (Filedata
* filedata
,
13926 Elf_Internal_Rela
* reloc
,
13927 unsigned char * start
,
13928 unsigned char * end
,
13929 Elf_Internal_Sym
* symtab
,
13930 unsigned long num_syms
)
13932 unsigned int reloc_type
= 0;
13933 unsigned long sym_index
= 0;
13937 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
13938 sym_index
= get_reloc_symindex (reloc
->r_info
);
13941 switch (filedata
->file_header
.e_machine
)
13944 case EM_MSP430_OLD
:
13946 static Elf_Internal_Sym
* saved_sym
= NULL
;
13954 switch (reloc_type
)
13956 case 10: /* R_MSP430_SYM_DIFF */
13957 case 12: /* R_MSP430_GNU_SUB_ULEB128 */
13958 if (uses_msp430x_relocs (filedata
))
13960 /* Fall through. */
13961 case 21: /* R_MSP430X_SYM_DIFF */
13962 case 23: /* R_MSP430X_GNU_SUB_ULEB128 */
13964 if (sym_index
>= num_syms
)
13965 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
13968 saved_sym
= symtab
+ sym_index
;
13971 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
13972 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
13973 goto handle_sym_diff
;
13975 case 5: /* R_MSP430_16_BYTE */
13976 case 9: /* R_MSP430_8 */
13977 case 11: /* R_MSP430_GNU_SET_ULEB128 */
13978 if (uses_msp430x_relocs (filedata
))
13980 goto handle_sym_diff
;
13982 case 2: /* R_MSP430_ABS16 */
13983 case 15: /* R_MSP430X_ABS16 */
13984 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
13985 if (! uses_msp430x_relocs (filedata
))
13987 goto handle_sym_diff
;
13990 if (saved_sym
!= NULL
)
13993 unsigned int reloc_size
= 0;
13995 switch (reloc_type
)
13997 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
14000 case 11: /* R_MSP430_GNU_SET_ULEB128 */
14001 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
14002 if (reloc
->r_offset
< (size_t) (end
- start
))
14003 read_leb128 (start
+ reloc
->r_offset
, end
, false,
14004 &reloc_size
, &leb_ret
);
14011 if (leb_ret
!= 0 || reloc_size
== 0 || reloc_size
> 8)
14012 error (_("MSP430 ULEB128 field at 0x%lx contains invalid "
14013 "ULEB128 value\n"),
14014 (long) reloc
->r_offset
);
14015 else if (sym_index
>= num_syms
)
14016 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
14020 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
14021 - saved_sym
->st_value
);
14023 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
14024 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
14027 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
14028 (long) reloc
->r_offset
);
14037 if (saved_sym
!= NULL
)
14038 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
14045 case EM_CYGNUS_MN10300
:
14047 static Elf_Internal_Sym
* saved_sym
= NULL
;
14055 switch (reloc_type
)
14057 case 34: /* R_MN10300_ALIGN */
14059 case 33: /* R_MN10300_SYM_DIFF */
14060 if (sym_index
>= num_syms
)
14061 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
14064 saved_sym
= symtab
+ sym_index
;
14067 case 1: /* R_MN10300_32 */
14068 case 2: /* R_MN10300_16 */
14069 if (saved_sym
!= NULL
)
14071 int reloc_size
= reloc_type
== 1 ? 4 : 2;
14074 if (sym_index
>= num_syms
)
14075 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
14079 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
14080 - saved_sym
->st_value
);
14082 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
14083 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
14085 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
14086 (long) reloc
->r_offset
);
14094 if (saved_sym
!= NULL
)
14095 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
14103 static uint64_t saved_sym1
= 0;
14104 static uint64_t saved_sym2
= 0;
14105 static uint64_t value
;
14109 saved_sym1
= saved_sym2
= 0;
14113 switch (reloc_type
)
14115 case 0x80: /* R_RL78_SYM. */
14116 saved_sym1
= saved_sym2
;
14117 if (sym_index
>= num_syms
)
14118 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
14122 saved_sym2
= symtab
[sym_index
].st_value
;
14123 saved_sym2
+= reloc
->r_addend
;
14127 case 0x83: /* R_RL78_OPsub. */
14128 value
= saved_sym1
- saved_sym2
;
14129 saved_sym2
= saved_sym1
= 0;
14133 case 0x41: /* R_RL78_ABS32. */
14134 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
14135 byte_put (start
+ reloc
->r_offset
, value
, 4);
14137 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
14138 (long) reloc
->r_offset
);
14142 case 0x43: /* R_RL78_ABS16. */
14143 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
14144 byte_put (start
+ reloc
->r_offset
, value
, 2);
14146 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
14147 (long) reloc
->r_offset
);
14161 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
14162 DWARF debug sections. This is a target specific test. Note - we do not
14163 go through the whole including-target-headers-multiple-times route, (as
14164 we have already done with <elf/h8.h>) because this would become very
14165 messy and even then this function would have to contain target specific
14166 information (the names of the relocs instead of their numeric values).
14167 FIXME: This is not the correct way to solve this problem. The proper way
14168 is to have target specific reloc sizing and typing functions created by
14169 the reloc-macros.h header, in the same way that it already creates the
14170 reloc naming functions. */
14173 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14175 /* Please keep this table alpha-sorted for ease of visual lookup. */
14176 switch (filedata
->file_header
.e_machine
)
14180 return reloc_type
== 1; /* R_386_32. */
14182 return reloc_type
== 1; /* R_68K_32. */
14184 return reloc_type
== 1; /* R_860_32. */
14186 return reloc_type
== 2; /* R_960_32. */
14188 return (reloc_type
== 258
14189 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
14191 return reloc_type
== 11; /* R_BPF_DATA_32 */
14192 case EM_ADAPTEVA_EPIPHANY
:
14193 return reloc_type
== 3;
14195 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
14197 return reloc_type
== 1; /* R_ARC_32. */
14198 case EM_ARC_COMPACT
:
14199 case EM_ARC_COMPACT2
:
14200 return reloc_type
== 4; /* R_ARC_32. */
14202 return reloc_type
== 2; /* R_ARM_ABS32 */
14205 return reloc_type
== 1;
14207 return reloc_type
== 0x12; /* R_byte4_data. */
14209 return reloc_type
== 3; /* R_CRIS_32. */
14211 return reloc_type
== 3; /* R_CR16_NUM32. */
14213 return reloc_type
== 15; /* R_CRX_NUM32. */
14215 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
14216 case EM_CYGNUS_FRV
:
14217 return reloc_type
== 1;
14218 case EM_CYGNUS_D10V
:
14220 return reloc_type
== 6; /* R_D10V_32. */
14221 case EM_CYGNUS_D30V
:
14223 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
14225 return reloc_type
== 3; /* R_DLX_RELOC_32. */
14226 case EM_CYGNUS_FR30
:
14228 return reloc_type
== 3; /* R_FR30_32. */
14230 return reloc_type
== 1; /* R_FT32_32. */
14234 return reloc_type
== 1; /* R_H8_DIR32. */
14236 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
14237 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
14238 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
14239 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
14242 return reloc_type
== 2; /* R_IP2K_32. */
14244 return reloc_type
== 2; /* R_IQ2000_32. */
14245 case EM_LATTICEMICO32
:
14246 return reloc_type
== 3; /* R_LM32_32. */
14248 return reloc_type
== 1; /* R_LARCH_32. */
14251 return reloc_type
== 3; /* R_M32C_32. */
14253 return reloc_type
== 34; /* R_M32R_32_RELA. */
14256 return reloc_type
== 6; /* R_M68HC11_32. */
14258 return reloc_type
== 7 || /* R_S12Z_EXT32 */
14259 reloc_type
== 6; /* R_S12Z_CW32. */
14261 return reloc_type
== 1; /* R_MCORE_ADDR32. */
14262 case EM_CYGNUS_MEP
:
14263 return reloc_type
== 4; /* R_MEP_32. */
14265 return reloc_type
== 2; /* R_METAG_ADDR32. */
14266 case EM_MICROBLAZE
:
14267 return reloc_type
== 1; /* R_MICROBLAZE_32. */
14269 return reloc_type
== 2; /* R_MIPS_32. */
14271 return reloc_type
== 4; /* R_MMIX_32. */
14272 case EM_CYGNUS_MN10200
:
14274 return reloc_type
== 1; /* R_MN10200_32. */
14275 case EM_CYGNUS_MN10300
:
14277 return reloc_type
== 1; /* R_MN10300_32. */
14279 return reloc_type
== 1; /* R_MOXIE_32. */
14280 case EM_MSP430_OLD
:
14282 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
14284 return reloc_type
== 2; /* R_MT_32. */
14286 return reloc_type
== 20; /* R_NDS32_32_RELA. */
14287 case EM_ALTERA_NIOS2
:
14288 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
14290 return reloc_type
== 1; /* R_NIOS_32. */
14292 return reloc_type
== 1; /* R_OR1K_32. */
14294 return (reloc_type
== 1 /* R_PARISC_DIR32. */
14295 || reloc_type
== 2 /* R_PARISC_DIR21L. */
14296 || reloc_type
== 41); /* R_PARISC_SECREL32. */
14299 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
14301 return reloc_type
== 1; /* R_PPC64_ADDR32. */
14303 return reloc_type
== 1; /* R_PPC_ADDR32. */
14305 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
14307 return reloc_type
== 1; /* R_RISCV_32. */
14309 return reloc_type
== 1; /* R_RL78_DIR32. */
14311 return reloc_type
== 1; /* R_RX_DIR32. */
14313 return reloc_type
== 1; /* R_I370_ADDR31. */
14316 return reloc_type
== 4; /* R_S390_32. */
14318 return reloc_type
== 8; /* R_SCORE_ABS32. */
14320 return reloc_type
== 1; /* R_SH_DIR32. */
14321 case EM_SPARC32PLUS
:
14324 return reloc_type
== 3 /* R_SPARC_32. */
14325 || reloc_type
== 23; /* R_SPARC_UA32. */
14327 return reloc_type
== 6; /* R_SPU_ADDR32 */
14329 return reloc_type
== 1; /* R_C6000_ABS32. */
14331 return reloc_type
== 2; /* R_TILEGX_32. */
14333 return reloc_type
== 1; /* R_TILEPRO_32. */
14334 case EM_CYGNUS_V850
:
14336 return reloc_type
== 6; /* R_V850_ABS32. */
14338 return reloc_type
== 0x33; /* R_V810_WORD. */
14340 return reloc_type
== 1; /* R_VAX_32. */
14342 return reloc_type
== 3; /* R_VISIUM_32. */
14343 case EM_WEBASSEMBLY
:
14344 return reloc_type
== 1; /* R_WASM32_32. */
14348 return reloc_type
== 10; /* R_X86_64_32. */
14350 return reloc_type
== 4; /* R_XGATE_32. */
14352 return reloc_type
== 1; /* R_XSTROMY16_32. */
14353 case EM_XTENSA_OLD
:
14355 return reloc_type
== 1; /* R_XTENSA_32. */
14357 return reloc_type
== 6; /* R_Z80_32. */
14360 static unsigned int prev_warn
= 0;
14362 /* Avoid repeating the same warning multiple times. */
14363 if (prev_warn
!= filedata
->file_header
.e_machine
)
14364 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
14365 filedata
->file_header
.e_machine
);
14366 prev_warn
= filedata
->file_header
.e_machine
;
14372 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14373 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
14376 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14378 switch (filedata
->file_header
.e_machine
)
14379 /* Please keep this table alpha-sorted for ease of visual lookup. */
14383 return reloc_type
== 2; /* R_386_PC32. */
14385 return reloc_type
== 4; /* R_68K_PC32. */
14387 return reloc_type
== 261; /* R_AARCH64_PREL32 */
14388 case EM_ADAPTEVA_EPIPHANY
:
14389 return reloc_type
== 6;
14391 return reloc_type
== 10; /* R_ALPHA_SREL32. */
14392 case EM_ARC_COMPACT
:
14393 case EM_ARC_COMPACT2
:
14394 return reloc_type
== 49; /* R_ARC_32_PCREL. */
14396 return reloc_type
== 3; /* R_ARM_REL32 */
14399 return reloc_type
== 36; /* R_AVR_32_PCREL. */
14401 return reloc_type
== 99; /* R_LARCH_32_PCREL. */
14402 case EM_MICROBLAZE
:
14403 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
14405 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
14407 return reloc_type
== 9; /* R_PARISC_PCREL32. */
14409 return reloc_type
== 26; /* R_PPC_REL32. */
14411 return reloc_type
== 26; /* R_PPC64_REL32. */
14413 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
14416 return reloc_type
== 5; /* R_390_PC32. */
14418 return reloc_type
== 2; /* R_SH_REL32. */
14419 case EM_SPARC32PLUS
:
14422 return reloc_type
== 6; /* R_SPARC_DISP32. */
14424 return reloc_type
== 13; /* R_SPU_REL32. */
14426 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
14428 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
14430 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
14434 return reloc_type
== 2; /* R_X86_64_PC32. */
14436 return reloc_type
== 4; /* R_VAX_PCREL32. */
14437 case EM_XTENSA_OLD
:
14439 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
14441 /* Do not abort or issue an error message here. Not all targets use
14442 pc-relative 32-bit relocs in their DWARF debug information and we
14443 have already tested for target coverage in is_32bit_abs_reloc. A
14444 more helpful warning message will be generated by apply_relocations
14445 anyway, so just return. */
14450 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14451 a 64-bit absolute RELA relocation used in DWARF debug sections. */
14454 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14456 switch (filedata
->file_header
.e_machine
)
14459 return reloc_type
== 257; /* R_AARCH64_ABS64. */
14461 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
14463 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
14464 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
14466 return reloc_type
== 2; /* R_LARCH_64 */
14468 return reloc_type
== 80; /* R_PARISC_DIR64. */
14470 return reloc_type
== 38; /* R_PPC64_ADDR64. */
14472 return reloc_type
== 2; /* R_RISCV_64. */
14473 case EM_SPARC32PLUS
:
14476 return reloc_type
== 32 /* R_SPARC_64. */
14477 || reloc_type
== 54; /* R_SPARC_UA64. */
14481 return reloc_type
== 1; /* R_X86_64_64. */
14484 return reloc_type
== 22; /* R_S390_64. */
14486 return reloc_type
== 1; /* R_TILEGX_64. */
14488 return reloc_type
== 18; /* R_MIPS_64. */
14494 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
14495 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
14498 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14500 switch (filedata
->file_header
.e_machine
)
14503 return reloc_type
== 260; /* R_AARCH64_PREL64. */
14505 return reloc_type
== 11; /* R_ALPHA_SREL64. */
14507 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
14508 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
14510 return reloc_type
== 72; /* R_PARISC_PCREL64. */
14512 return reloc_type
== 44; /* R_PPC64_REL64. */
14513 case EM_SPARC32PLUS
:
14516 return reloc_type
== 46; /* R_SPARC_DISP64. */
14520 return reloc_type
== 24; /* R_X86_64_PC64. */
14523 return reloc_type
== 23; /* R_S390_PC64. */
14525 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
14531 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14532 a 24-bit absolute RELA relocation used in DWARF debug sections. */
14535 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14537 switch (filedata
->file_header
.e_machine
)
14539 case EM_CYGNUS_MN10200
:
14541 return reloc_type
== 4; /* R_MN10200_24. */
14543 return reloc_type
== 5; /* R_FT32_20. */
14545 return reloc_type
== 5; /* R_Z80_24. */
14551 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14552 a 16-bit absolute RELA relocation used in DWARF debug sections. */
14555 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14557 /* Please keep this table alpha-sorted for ease of visual lookup. */
14558 switch (filedata
->file_header
.e_machine
)
14561 case EM_ARC_COMPACT
:
14562 case EM_ARC_COMPACT2
:
14563 return reloc_type
== 2; /* R_ARC_16. */
14564 case EM_ADAPTEVA_EPIPHANY
:
14565 return reloc_type
== 5;
14568 return reloc_type
== 4; /* R_AVR_16. */
14569 case EM_CYGNUS_D10V
:
14571 return reloc_type
== 3; /* R_D10V_16. */
14573 return reloc_type
== 2; /* R_FT32_16. */
14577 return reloc_type
== R_H8_DIR16
;
14580 return reloc_type
== 1; /* R_IP2K_16. */
14583 return reloc_type
== 1; /* R_M32C_16 */
14584 case EM_CYGNUS_MN10200
:
14586 return reloc_type
== 2; /* R_MN10200_16. */
14587 case EM_CYGNUS_MN10300
:
14589 return reloc_type
== 2; /* R_MN10300_16. */
14591 if (uses_msp430x_relocs (filedata
))
14592 return reloc_type
== 2; /* R_MSP430_ABS16. */
14593 /* Fall through. */
14594 case EM_MSP430_OLD
:
14595 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
14597 return reloc_type
== 19; /* R_NDS32_16_RELA. */
14598 case EM_ALTERA_NIOS2
:
14599 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
14601 return reloc_type
== 9; /* R_NIOS_16. */
14603 return reloc_type
== 2; /* R_OR1K_16. */
14605 return reloc_type
== 55; /* R_RISCV_SET16. */
14607 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
14609 return reloc_type
== 2; /* R_C6000_ABS16. */
14611 return reloc_type
== 2; /* R_VISIUM_16. */
14613 return reloc_type
== 3; /* R_XGATE_16. */
14615 return reloc_type
== 4; /* R_Z80_16. */
14621 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14622 a 8-bit absolute RELA relocation used in DWARF debug sections. */
14625 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14627 switch (filedata
->file_header
.e_machine
)
14630 return reloc_type
== 54; /* R_RISCV_SET8. */
14632 return reloc_type
== 1; /* R_Z80_8. */
14638 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14639 a 6-bit absolute RELA relocation used in DWARF debug sections. */
14642 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14644 switch (filedata
->file_header
.e_machine
)
14647 return reloc_type
== 53; /* R_RISCV_SET6. */
14653 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14654 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
14657 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14659 /* Please keep this table alpha-sorted for ease of visual lookup. */
14660 switch (filedata
->file_header
.e_machine
)
14663 return reloc_type
== 35; /* R_RISCV_ADD32. */
14669 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14670 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
14673 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14675 /* Please keep this table alpha-sorted for ease of visual lookup. */
14676 switch (filedata
->file_header
.e_machine
)
14679 return reloc_type
== 39; /* R_RISCV_SUB32. */
14685 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14686 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
14689 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14691 /* Please keep this table alpha-sorted for ease of visual lookup. */
14692 switch (filedata
->file_header
.e_machine
)
14695 return reloc_type
== 36; /* R_RISCV_ADD64. */
14701 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14702 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
14705 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14707 /* Please keep this table alpha-sorted for ease of visual lookup. */
14708 switch (filedata
->file_header
.e_machine
)
14711 return reloc_type
== 40; /* R_RISCV_SUB64. */
14717 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14718 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
14721 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14723 /* Please keep this table alpha-sorted for ease of visual lookup. */
14724 switch (filedata
->file_header
.e_machine
)
14727 return reloc_type
== 34; /* R_RISCV_ADD16. */
14733 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14734 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
14737 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14739 /* Please keep this table alpha-sorted for ease of visual lookup. */
14740 switch (filedata
->file_header
.e_machine
)
14743 return reloc_type
== 38; /* R_RISCV_SUB16. */
14749 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14750 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
14753 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14755 /* Please keep this table alpha-sorted for ease of visual lookup. */
14756 switch (filedata
->file_header
.e_machine
)
14759 return reloc_type
== 33; /* R_RISCV_ADD8. */
14765 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14766 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
14769 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14771 /* Please keep this table alpha-sorted for ease of visual lookup. */
14772 switch (filedata
->file_header
.e_machine
)
14775 return reloc_type
== 37; /* R_RISCV_SUB8. */
14781 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14782 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
14785 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14787 switch (filedata
->file_header
.e_machine
)
14790 return reloc_type
== 52; /* R_RISCV_SUB6. */
14796 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
14797 relocation entries (possibly formerly used for SHT_GROUP sections). */
14800 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14802 switch (filedata
->file_header
.e_machine
)
14804 case EM_386
: /* R_386_NONE. */
14805 case EM_68K
: /* R_68K_NONE. */
14806 case EM_ADAPTEVA_EPIPHANY
:
14807 case EM_ALPHA
: /* R_ALPHA_NONE. */
14808 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
14809 case EM_ARC
: /* R_ARC_NONE. */
14810 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
14811 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
14812 case EM_ARM
: /* R_ARM_NONE. */
14813 case EM_CRIS
: /* R_CRIS_NONE. */
14814 case EM_FT32
: /* R_FT32_NONE. */
14815 case EM_IA_64
: /* R_IA64_NONE. */
14816 case EM_K1OM
: /* R_X86_64_NONE. */
14817 case EM_L1OM
: /* R_X86_64_NONE. */
14818 case EM_M32R
: /* R_M32R_NONE. */
14819 case EM_MIPS
: /* R_MIPS_NONE. */
14820 case EM_MN10300
: /* R_MN10300_NONE. */
14821 case EM_MOXIE
: /* R_MOXIE_NONE. */
14822 case EM_NIOS32
: /* R_NIOS_NONE. */
14823 case EM_OR1K
: /* R_OR1K_NONE. */
14824 case EM_PARISC
: /* R_PARISC_NONE. */
14825 case EM_PPC64
: /* R_PPC64_NONE. */
14826 case EM_PPC
: /* R_PPC_NONE. */
14827 case EM_RISCV
: /* R_RISCV_NONE. */
14828 case EM_S390
: /* R_390_NONE. */
14830 case EM_SH
: /* R_SH_NONE. */
14831 case EM_SPARC32PLUS
:
14832 case EM_SPARC
: /* R_SPARC_NONE. */
14834 case EM_TILEGX
: /* R_TILEGX_NONE. */
14835 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
14836 case EM_TI_C6000
:/* R_C6000_NONE. */
14837 case EM_X86_64
: /* R_X86_64_NONE. */
14838 case EM_Z80
: /* R_Z80_NONE. */
14839 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
14840 return reloc_type
== 0;
14843 return reloc_type
== 0 || reloc_type
== 256;
14846 return (reloc_type
== 0 /* R_AVR_NONE. */
14847 || reloc_type
== 30 /* R_AVR_DIFF8. */
14848 || reloc_type
== 31 /* R_AVR_DIFF16. */
14849 || reloc_type
== 32 /* R_AVR_DIFF32. */);
14851 return reloc_type
== 3; /* R_METAG_NONE. */
14853 return (reloc_type
== 0 /* R_NDS32_NONE. */
14854 || reloc_type
== 205 /* R_NDS32_DIFF8. */
14855 || reloc_type
== 206 /* R_NDS32_DIFF16. */
14856 || reloc_type
== 207 /* R_NDS32_DIFF32. */
14857 || reloc_type
== 208 /* R_NDS32_DIFF_ULEB128. */);
14859 return (reloc_type
== 0 /* R_PRU_NONE. */
14860 || reloc_type
== 65 /* R_PRU_DIFF8. */
14861 || reloc_type
== 66 /* R_PRU_DIFF16. */
14862 || reloc_type
== 67 /* R_PRU_DIFF32. */);
14863 case EM_XTENSA_OLD
:
14865 return (reloc_type
== 0 /* R_XTENSA_NONE. */
14866 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
14867 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
14868 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
14869 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
14870 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
14871 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
14872 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
14873 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
14874 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
14879 /* Returns TRUE if there is a relocation against
14880 section NAME at OFFSET bytes. */
14883 reloc_at (struct dwarf_section
* dsec
, uint64_t offset
)
14885 Elf_Internal_Rela
* relocs
;
14886 Elf_Internal_Rela
* rp
;
14888 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
14891 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
14893 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
14894 if (rp
->r_offset
== offset
)
14900 /* Apply relocations to a section.
14901 Returns TRUE upon success, FALSE otherwise.
14902 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
14903 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
14904 will be set to the number of relocs loaded.
14906 Note: So far support has been added only for those relocations
14907 which can be found in debug sections. FIXME: Add support for
14908 more relocations ? */
14911 apply_relocations (Filedata
*filedata
,
14912 const Elf_Internal_Shdr
*section
,
14913 unsigned char *start
,
14915 void **relocs_return
,
14916 unsigned long *num_relocs_return
)
14918 Elf_Internal_Shdr
* relsec
;
14919 unsigned char * end
= start
+ size
;
14921 if (relocs_return
!= NULL
)
14923 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
14924 * num_relocs_return
= 0;
14927 if (filedata
->file_header
.e_type
!= ET_REL
)
14928 /* No relocs to apply. */
14931 /* Find the reloc section associated with the section. */
14932 for (relsec
= filedata
->section_headers
;
14933 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14937 unsigned long num_relocs
;
14938 Elf_Internal_Rela
* relocs
;
14939 Elf_Internal_Rela
* rp
;
14940 Elf_Internal_Shdr
* symsec
;
14941 Elf_Internal_Sym
* symtab
;
14942 unsigned long num_syms
;
14943 Elf_Internal_Sym
* sym
;
14945 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14946 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14947 || filedata
->section_headers
+ relsec
->sh_info
!= section
14948 || relsec
->sh_size
== 0
14949 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14952 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
14953 if (symsec
->sh_type
!= SHT_SYMTAB
14954 && symsec
->sh_type
!= SHT_DYNSYM
)
14957 is_rela
= relsec
->sh_type
== SHT_RELA
;
14961 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
14962 relsec
->sh_size
, & relocs
, & num_relocs
))
14967 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
14968 relsec
->sh_size
, & relocs
, & num_relocs
))
14972 /* SH uses RELA but uses in place value instead of the addend field. */
14973 if (filedata
->file_header
.e_machine
== EM_SH
)
14976 symtab
= get_elf_symbols (filedata
, symsec
, & num_syms
);
14978 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
14981 unsigned int reloc_type
;
14982 unsigned int reloc_size
;
14983 bool reloc_inplace
= false;
14984 bool reloc_subtract
= false;
14985 unsigned char *rloc
;
14986 unsigned long sym_index
;
14988 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
14990 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
14992 else if (is_none_reloc (filedata
, reloc_type
))
14994 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
14995 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
14997 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
14998 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
15000 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
15002 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
15004 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
15005 || is_6bit_abs_reloc (filedata
, reloc_type
))
15007 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
15009 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
15012 reloc_inplace
= true;
15014 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
15016 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
15019 reloc_inplace
= true;
15021 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
15023 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
15026 reloc_inplace
= true;
15028 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
15030 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
15033 reloc_inplace
= true;
15035 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
15039 reloc_inplace
= true;
15043 static unsigned int prev_reloc
= 0;
15045 if (reloc_type
!= prev_reloc
)
15046 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
15047 reloc_type
, printable_section_name (filedata
, section
));
15048 prev_reloc
= reloc_type
;
15052 rloc
= start
+ rp
->r_offset
;
15053 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
15055 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
15056 (unsigned long) rp
->r_offset
,
15057 printable_section_name (filedata
, section
));
15061 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
15062 if (sym_index
>= num_syms
)
15064 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
15065 sym_index
, printable_section_name (filedata
, section
));
15068 sym
= symtab
+ sym_index
;
15070 /* If the reloc has a symbol associated with it,
15071 make sure that it is of an appropriate type.
15073 Relocations against symbols without type can happen.
15074 Gcc -feliminate-dwarf2-dups may generate symbols
15075 without type for debug info.
15077 Icc generates relocations against function symbols
15078 instead of local labels.
15080 Relocations against object symbols can happen, eg when
15081 referencing a global array. For an example of this see
15082 the _clz.o binary in libgcc.a. */
15084 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
15085 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
15087 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
15088 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
15089 printable_section_name (filedata
, relsec
),
15090 (long int)(rp
- relocs
));
15096 addend
+= rp
->r_addend
;
15097 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
15098 partial_inplace. */
15100 || (filedata
->file_header
.e_machine
== EM_XTENSA
15101 && reloc_type
== 1)
15102 || ((filedata
->file_header
.e_machine
== EM_PJ
15103 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
15104 && reloc_type
== 1)
15105 || ((filedata
->file_header
.e_machine
== EM_D30V
15106 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
15107 && reloc_type
== 12)
15110 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
15111 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
15113 addend
+= byte_get (rloc
, reloc_size
);
15116 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
15117 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
15119 /* On HPPA, all pc-relative relocations are biased by 8. */
15120 if (filedata
->file_header
.e_machine
== EM_PARISC
)
15122 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
15125 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
15126 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
15128 if (reloc_subtract
)
15129 addend
-= sym
->st_value
;
15131 addend
+= sym
->st_value
;
15132 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
15133 byte_put (rloc
, addend
, reloc_size
);
15135 else if (reloc_subtract
)
15136 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
15138 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
15142 /* Let the target specific reloc processing code know that
15143 we have finished with these relocs. */
15144 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
15148 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
15149 * num_relocs_return
= num_relocs
;
15160 #ifdef SUPPORT_DISASSEMBLY
15162 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15164 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
15166 /* FIXME: XXX -- to be done --- XXX */
15172 /* Reads in the contents of SECTION from FILE, returning a pointer
15173 to a malloc'ed buffer or NULL if something went wrong. */
15176 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15178 uint64_t num_bytes
= section
->sh_size
;
15180 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
15182 printf (_("Section '%s' has no data to dump.\n"),
15183 printable_section_name (filedata
, section
));
15187 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
15188 _("section contents"));
15191 /* Uncompresses a section that was compressed using zlib/zstd, in place. */
15194 uncompress_section_contents (bool is_zstd
, unsigned char **buffer
,
15195 uint64_t uncompressed_size
, uint64_t *size
)
15197 uint64_t compressed_size
= *size
;
15198 unsigned char *compressed_buffer
= *buffer
;
15199 unsigned char *uncompressed_buffer
= xmalloc (uncompressed_size
);
15206 size_t ret
= ZSTD_decompress (uncompressed_buffer
, uncompressed_size
,
15207 compressed_buffer
, compressed_size
);
15208 if (ZSTD_isError (ret
))
15214 /* It is possible the section consists of several compressed
15215 buffers concatenated together, so we uncompress in a loop. */
15216 /* PR 18313: The state field in the z_stream structure is supposed
15217 to be invisible to the user (ie us), but some compilers will
15218 still complain about it being used without initialisation. So
15219 we first zero the entire z_stream structure and then set the fields
15221 memset (&strm
, 0, sizeof strm
);
15222 strm
.avail_in
= compressed_size
;
15223 strm
.next_in
= (Bytef
*)compressed_buffer
;
15224 strm
.avail_out
= uncompressed_size
;
15226 rc
= inflateInit (&strm
);
15227 while (strm
.avail_in
> 0)
15231 strm
.next_out
= ((Bytef
*)uncompressed_buffer
15232 + (uncompressed_size
- strm
.avail_out
));
15233 rc
= inflate (&strm
, Z_FINISH
);
15234 if (rc
!= Z_STREAM_END
)
15236 rc
= inflateReset (&strm
);
15238 if (inflateEnd (&strm
) != Z_OK
|| rc
!= Z_OK
|| strm
.avail_out
!= 0)
15242 *buffer
= uncompressed_buffer
;
15243 *size
= uncompressed_size
;
15247 free (uncompressed_buffer
);
15248 /* Indicate decompression failure. */
15254 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15256 Elf_Internal_Shdr
*relsec
;
15257 uint64_t num_bytes
;
15258 unsigned char *data
;
15259 unsigned char *end
;
15260 unsigned char *real_start
;
15261 unsigned char *start
;
15262 bool some_strings_shown
;
15264 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
15266 /* PR 21820: Do not fail if the section was empty. */
15267 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
15269 num_bytes
= section
->sh_size
;
15271 if (filedata
->is_separate
)
15272 printf (_("\nString dump of section '%s' in linked file %s:\n"),
15273 printable_section_name (filedata
, section
),
15274 filedata
->file_name
);
15276 printf (_("\nString dump of section '%s':\n"),
15277 printable_section_name (filedata
, section
));
15279 if (decompress_dumps
)
15281 uint64_t new_size
= num_bytes
;
15282 uint64_t uncompressed_size
= 0;
15283 bool is_zstd
= false;
15285 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
15287 Elf_Internal_Chdr chdr
;
15288 unsigned int compression_header_size
15289 = get_compression_header (& chdr
, (unsigned char *) start
,
15291 if (compression_header_size
== 0)
15292 /* An error message will have already been generated
15293 by get_compression_header. */
15296 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
15299 else if (chdr
.ch_type
== ELFCOMPRESS_ZSTD
)
15304 warn (_("section '%s' has unsupported compress type: %d\n"),
15305 printable_section_name (filedata
, section
), chdr
.ch_type
);
15308 uncompressed_size
= chdr
.ch_size
;
15309 start
+= compression_header_size
;
15310 new_size
-= compression_header_size
;
15312 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
15314 /* Read the zlib header. In this case, it should be "ZLIB"
15315 followed by the uncompressed section size, 8 bytes in
15316 big-endian order. */
15317 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
15318 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
15319 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
15320 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
15321 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
15322 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
15323 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
15324 uncompressed_size
+= start
[11];
15329 if (uncompressed_size
)
15331 if (uncompress_section_contents (is_zstd
, &start
, uncompressed_size
,
15333 num_bytes
= new_size
;
15336 error (_("Unable to decompress section %s\n"),
15337 printable_section_name (filedata
, section
));
15342 start
= real_start
;
15345 /* If the section being dumped has relocations against it the user might
15346 be expecting these relocations to have been applied. Check for this
15347 case and issue a warning message in order to avoid confusion.
15348 FIXME: Maybe we ought to have an option that dumps a section with
15349 relocs applied ? */
15350 for (relsec
= filedata
->section_headers
;
15351 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
15354 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
15355 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
15356 || filedata
->section_headers
+ relsec
->sh_info
!= section
15357 || relsec
->sh_size
== 0
15358 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
15361 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
15366 end
= start
+ num_bytes
;
15367 some_strings_shown
= false;
15369 #ifdef HAVE_MBSTATE_T
15371 /* Initialise the multibyte conversion state. */
15372 memset (& state
, 0, sizeof (state
));
15375 bool continuing
= false;
15379 while (!ISPRINT (* data
))
15380 if (++ data
>= end
)
15385 size_t maxlen
= end
- data
;
15390 continuing
= false;
15394 printf (" [%6lx] ", (unsigned long) (data
- start
));
15408 /* PR 25543: Treat new-lines as string-ending characters. */
15417 /* Do not print control characters directly as they can affect terminal
15418 settings. Such characters usually appear in the names generated
15419 by the assembler for local labels. */
15422 printf ("^%c", c
+ 0x40);
15424 else if (ISPRINT (c
))
15431 #ifdef HAVE_MBSTATE_T
15434 /* Let printf do the hard work of displaying multibyte characters. */
15435 printf ("%.1s", data
- 1);
15436 #ifdef HAVE_MBSTATE_T
15437 /* Try to find out how many bytes made up the character that was
15438 just printed. Advance the symbol pointer past the bytes that
15440 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
15444 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
15454 printf (_("<corrupt>\n"));
15457 some_strings_shown
= true;
15461 if (! some_strings_shown
)
15462 printf (_(" No strings found in this section."));
15475 dump_section_as_bytes (Elf_Internal_Shdr
*section
,
15476 Filedata
*filedata
,
15479 Elf_Internal_Shdr
*relsec
;
15481 uint64_t section_size
;
15483 unsigned char *data
;
15484 unsigned char *real_start
;
15485 unsigned char *start
;
15487 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
15489 /* PR 21820: Do not fail if the section was empty. */
15490 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
15492 section_size
= section
->sh_size
;
15494 if (filedata
->is_separate
)
15495 printf (_("\nHex dump of section '%s' in linked file %s:\n"),
15496 printable_section_name (filedata
, section
),
15497 filedata
->file_name
);
15499 printf (_("\nHex dump of section '%s':\n"),
15500 printable_section_name (filedata
, section
));
15502 if (decompress_dumps
)
15504 uint64_t new_size
= section_size
;
15505 uint64_t uncompressed_size
= 0;
15506 bool is_zstd
= false;
15508 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
15510 Elf_Internal_Chdr chdr
;
15511 unsigned int compression_header_size
15512 = get_compression_header (& chdr
, start
, section_size
);
15514 if (compression_header_size
== 0)
15515 /* An error message will have already been generated
15516 by get_compression_header. */
15519 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
15522 else if (chdr
.ch_type
== ELFCOMPRESS_ZSTD
)
15527 warn (_("section '%s' has unsupported compress type: %d\n"),
15528 printable_section_name (filedata
, section
), chdr
.ch_type
);
15531 uncompressed_size
= chdr
.ch_size
;
15532 start
+= compression_header_size
;
15533 new_size
-= compression_header_size
;
15535 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
15537 /* Read the zlib header. In this case, it should be "ZLIB"
15538 followed by the uncompressed section size, 8 bytes in
15539 big-endian order. */
15540 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
15541 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
15542 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
15543 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
15544 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
15545 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
15546 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
15547 uncompressed_size
+= start
[11];
15552 if (uncompressed_size
)
15554 if (uncompress_section_contents (is_zstd
, &start
, uncompressed_size
,
15557 section_size
= new_size
;
15561 error (_("Unable to decompress section %s\n"),
15562 printable_section_name (filedata
, section
));
15563 /* FIXME: Print the section anyway ? */
15568 start
= real_start
;
15573 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
15578 /* If the section being dumped has relocations against it the user might
15579 be expecting these relocations to have been applied. Check for this
15580 case and issue a warning message in order to avoid confusion.
15581 FIXME: Maybe we ought to have an option that dumps a section with
15582 relocs applied ? */
15583 for (relsec
= filedata
->section_headers
;
15584 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
15587 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
15588 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
15589 || filedata
->section_headers
+ relsec
->sh_info
!= section
15590 || relsec
->sh_size
== 0
15591 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
15594 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
15599 addr
= section
->sh_addr
;
15600 bytes
= section_size
;
15609 lbytes
= (bytes
> 16 ? 16 : bytes
);
15611 printf (" 0x%8.8lx ", (unsigned long) addr
);
15613 for (j
= 0; j
< 16; j
++)
15616 printf ("%2.2x", data
[j
]);
15624 for (j
= 0; j
< lbytes
; j
++)
15627 if (k
>= ' ' && k
< 0x7f)
15650 #ifdef ENABLE_LIBCTF
15651 static ctf_sect_t
*
15652 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
15654 buf
->cts_name
= section_name_print (filedata
, shdr
);
15655 buf
->cts_size
= shdr
->sh_size
;
15656 buf
->cts_entsize
= shdr
->sh_entsize
;
15661 /* Formatting callback function passed to ctf_dump. Returns either the pointer
15662 it is passed, or a pointer to newly-allocated storage, in which case
15663 dump_ctf() will free it when it no longer needs it. */
15666 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
15667 char *s
, void *arg
)
15669 const char *blanks
= arg
;
15672 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
15677 /* Dump CTF errors/warnings. */
15679 dump_ctf_errs (ctf_dict_t
*fp
)
15681 ctf_next_t
*it
= NULL
;
15686 /* Dump accumulated errors and warnings. */
15687 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
15689 error (_("%s: %s"), is_warning
? _("warning"): _("error"),
15693 if (err
!= ECTF_NEXT_END
)
15694 error (_("CTF error: cannot get CTF errors: `%s'"), ctf_errmsg (err
));
15697 /* Dump one CTF archive member. */
15700 dump_ctf_archive_member (ctf_dict_t
*ctf
, const char *name
, ctf_dict_t
*parent
,
15703 const char *things
[] = {"Header", "Labels", "Data objects",
15704 "Function objects", "Variables", "Types", "Strings",
15706 const char **thing
;
15709 /* Don't print out the name of the default-named archive member if it appears
15710 first in the list. The name .ctf appears everywhere, even for things that
15711 aren't really archives, so printing it out is liable to be confusing; also,
15712 the common case by far is for only one archive member to exist, and hiding
15713 it in that case seems worthwhile. */
15715 if (strcmp (name
, ".ctf") != 0 || member
!= 0)
15716 printf (_("\nCTF archive member: %s:\n"), name
);
15718 if (ctf_parent_name (ctf
) != NULL
)
15719 ctf_import (ctf
, parent
);
15721 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
15723 ctf_dump_state_t
*s
= NULL
;
15726 printf ("\n %s:\n", *thing
);
15727 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
15728 (void *) " ")) != NULL
)
15730 printf ("%s\n", item
);
15734 if (ctf_errno (ctf
))
15736 error (_("Iteration failed: %s, %s\n"), *thing
,
15737 ctf_errmsg (ctf_errno (ctf
)));
15742 dump_ctf_errs (ctf
);
15746 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15748 Elf_Internal_Shdr
* symtab_sec
= NULL
;
15749 Elf_Internal_Shdr
* strtab_sec
= NULL
;
15750 void * data
= NULL
;
15751 void * symdata
= NULL
;
15752 void * strdata
= NULL
;
15753 ctf_sect_t ctfsect
, symsect
, strsect
;
15754 ctf_sect_t
* symsectp
= NULL
;
15755 ctf_sect_t
* strsectp
= NULL
;
15756 ctf_archive_t
* ctfa
= NULL
;
15757 ctf_dict_t
* parent
= NULL
;
15760 ctf_next_t
*i
= NULL
;
15766 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
15767 data
= get_section_contents (section
, filedata
);
15768 ctfsect
.cts_data
= data
;
15770 if (!dump_ctf_symtab_name
)
15771 dump_ctf_symtab_name
= strdup (".dynsym");
15773 if (!dump_ctf_strtab_name
)
15774 dump_ctf_strtab_name
= strdup (".dynstr");
15776 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
15778 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
15780 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
15783 if ((symdata
= (void *) get_data (NULL
, filedata
,
15784 symtab_sec
->sh_offset
, 1,
15785 symtab_sec
->sh_size
,
15786 _("symbols"))) == NULL
)
15788 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
15789 symsect
.cts_data
= symdata
;
15792 if (dump_ctf_strtab_name
&& dump_ctf_strtab_name
[0] != 0)
15794 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
15796 error (_("No string table section named %s\n"),
15797 dump_ctf_strtab_name
);
15800 if ((strdata
= (void *) get_data (NULL
, filedata
,
15801 strtab_sec
->sh_offset
, 1,
15802 strtab_sec
->sh_size
,
15803 _("strings"))) == NULL
)
15805 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
15806 strsect
.cts_data
= strdata
;
15809 /* Load the CTF file and dump it. It may be a raw CTF section, or an archive:
15810 libctf papers over the difference, so we can pretend it is always an
15813 if ((ctfa
= ctf_arc_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
15815 dump_ctf_errs (NULL
);
15816 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15820 ctf_arc_symsect_endianness (ctfa
, filedata
->file_header
.e_ident
[EI_DATA
]
15823 /* Preload the parent dict, since it will need to be imported into every
15825 if ((parent
= ctf_dict_open (ctfa
, dump_ctf_parent_name
, &err
)) == NULL
)
15827 dump_ctf_errs (NULL
);
15828 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15834 if (filedata
->is_separate
)
15835 printf (_("\nDump of CTF section '%s' in linked file %s:\n"),
15836 printable_section_name (filedata
, section
),
15837 filedata
->file_name
);
15839 printf (_("\nDump of CTF section '%s':\n"),
15840 printable_section_name (filedata
, section
));
15842 while ((fp
= ctf_archive_next (ctfa
, &i
, &name
, 0, &err
)) != NULL
)
15843 dump_ctf_archive_member (fp
, name
, parent
, member
++);
15844 if (err
!= ECTF_NEXT_END
)
15846 dump_ctf_errs (NULL
);
15847 error (_("CTF member open failure: %s\n"), ctf_errmsg (err
));
15852 ctf_dict_close (parent
);
15862 load_specific_debug_section (enum dwarf_section_display_enum debug
,
15863 const Elf_Internal_Shdr
* sec
,
15866 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15868 Filedata
* filedata
= (Filedata
*) data
;
15870 if (section
->start
!= NULL
)
15872 /* If it is already loaded, do nothing. */
15873 if (streq (section
->filename
, filedata
->file_name
))
15875 free (section
->start
);
15878 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
15879 section
->address
= sec
->sh_addr
;
15880 section
->filename
= filedata
->file_name
;
15881 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
15883 sec
->sh_size
, buf
);
15884 if (section
->start
== NULL
)
15888 unsigned char *start
= section
->start
;
15889 uint64_t size
= sec
->sh_size
;
15890 uint64_t uncompressed_size
= 0;
15891 bool is_zstd
= false;
15893 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
15895 Elf_Internal_Chdr chdr
;
15896 unsigned int compression_header_size
;
15898 if (size
< (is_32bit_elf
15899 ? sizeof (Elf32_External_Chdr
)
15900 : sizeof (Elf64_External_Chdr
)))
15902 warn (_("compressed section %s is too small to contain a compression header\n"),
15907 compression_header_size
= get_compression_header (&chdr
, start
, size
);
15908 if (compression_header_size
== 0)
15909 /* An error message will have already been generated
15910 by get_compression_header. */
15913 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
15916 else if (chdr
.ch_type
== ELFCOMPRESS_ZSTD
)
15921 warn (_("section '%s' has unsupported compress type: %d\n"),
15922 section
->name
, chdr
.ch_type
);
15925 uncompressed_size
= chdr
.ch_size
;
15926 start
+= compression_header_size
;
15927 size
-= compression_header_size
;
15929 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
15931 /* Read the zlib header. In this case, it should be "ZLIB"
15932 followed by the uncompressed section size, 8 bytes in
15933 big-endian order. */
15934 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
15935 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
15936 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
15937 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
15938 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
15939 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
15940 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
15941 uncompressed_size
+= start
[11];
15946 if (uncompressed_size
)
15948 if (uncompress_section_contents (is_zstd
, &start
, uncompressed_size
,
15951 /* Free the compressed buffer, update the section buffer
15952 and the section size if uncompress is successful. */
15953 free (section
->start
);
15954 section
->start
= start
;
15958 error (_("Unable to decompress section %s\n"),
15959 printable_section_name (filedata
, sec
));
15964 section
->size
= size
;
15967 if (section
->start
== NULL
)
15970 if (debug_displays
[debug
].relocate
)
15972 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
15973 & section
->reloc_info
, & section
->num_relocs
))
15978 section
->reloc_info
= NULL
;
15979 section
->num_relocs
= 0;
15985 #if HAVE_LIBDEBUGINFOD
15986 /* Return a hex string representation of the build-id. */
15988 get_build_id (void * data
)
15990 Filedata
* filedata
= (Filedata
*) data
;
15991 Elf_Internal_Shdr
* shdr
;
15994 /* Iterate through notes to find note.gnu.build-id.
15995 FIXME: Only the first note in any note section is examined. */
15996 for (i
= 0, shdr
= filedata
->section_headers
;
15997 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
16000 if (shdr
->sh_type
!= SHT_NOTE
)
16005 size_t data_remaining
;
16007 Elf_External_Note
* enote
;
16008 Elf_Internal_Note inote
;
16010 uint64_t offset
= shdr
->sh_offset
;
16011 uint64_t align
= shdr
->sh_addralign
;
16012 uint64_t length
= shdr
->sh_size
;
16014 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
16020 else if (align
!= 4 && align
!= 8)
16026 end
= (char *) enote
+ length
;
16027 data_remaining
= end
- (char *) enote
;
16029 if (!is_ia64_vms (filedata
))
16031 min_notesz
= offsetof (Elf_External_Note
, name
);
16032 if (data_remaining
< min_notesz
)
16035 malformed note encountered in section %s whilst scanning for build-id note\n"),
16036 printable_section_name (filedata
, shdr
));
16040 data_remaining
-= min_notesz
;
16042 inote
.type
= BYTE_GET (enote
->type
);
16043 inote
.namesz
= BYTE_GET (enote
->namesz
);
16044 inote
.namedata
= enote
->name
;
16045 inote
.descsz
= BYTE_GET (enote
->descsz
);
16046 inote
.descdata
= ((char *) enote
16047 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
16048 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
16049 next
= ((char *) enote
16050 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
16054 Elf64_External_VMS_Note
*vms_enote
;
16056 /* PR binutils/15191
16057 Make sure that there is enough data to read. */
16058 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
16059 if (data_remaining
< min_notesz
)
16062 malformed note encountered in section %s whilst scanning for build-id note\n"),
16063 printable_section_name (filedata
, shdr
));
16067 data_remaining
-= min_notesz
;
16069 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
16070 inote
.type
= BYTE_GET (vms_enote
->type
);
16071 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
16072 inote
.namedata
= vms_enote
->name
;
16073 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
16074 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
16075 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
16076 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
16079 /* Skip malformed notes. */
16080 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
16081 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
16082 || (size_t) (next
- inote
.descdata
) < inote
.descsz
16083 || ((size_t) (next
- inote
.descdata
)
16084 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
16087 malformed note encountered in section %s whilst scanning for build-id note\n"),
16088 printable_section_name (filedata
, shdr
));
16093 /* Check if this is the build-id note. If so then convert the build-id
16094 bytes to a hex string. */
16095 if (inote
.namesz
> 0
16096 && startswith (inote
.namedata
, "GNU")
16097 && inote
.type
== NT_GNU_BUILD_ID
)
16102 build_id
= malloc (inote
.descsz
* 2 + 1);
16103 if (build_id
== NULL
)
16109 for (j
= 0; j
< inote
.descsz
; ++j
)
16110 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
16111 build_id
[inote
.descsz
* 2] = '\0';
16114 return (unsigned char *) build_id
;
16121 #endif /* HAVE_LIBDEBUGINFOD */
16123 /* If this is not NULL, load_debug_section will only look for sections
16124 within the list of sections given here. */
16125 static unsigned int * section_subset
= NULL
;
16128 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
16130 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
16131 Elf_Internal_Shdr
* sec
;
16132 Filedata
* filedata
= (Filedata
*) data
;
16134 if (!dump_any_debugging
)
16137 /* Without section headers we cannot find any sections. */
16138 if (filedata
->section_headers
== NULL
)
16141 if (filedata
->string_table
== NULL
16142 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
16143 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
16145 Elf_Internal_Shdr
* strs
;
16147 /* Read in the string table, so that we have section names to scan. */
16148 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
16150 if (strs
!= NULL
&& strs
->sh_size
!= 0)
16152 filedata
->string_table
16153 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
16154 1, strs
->sh_size
, _("string table"));
16156 filedata
->string_table_length
16157 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
16161 /* Locate the debug section. */
16162 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
16164 section
->name
= section
->uncompressed_name
;
16167 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
16169 section
->name
= section
->compressed_name
;
16174 /* If we're loading from a subset of sections, and we've loaded
16175 a section matching this name before, it's likely that it's a
16177 if (section_subset
!= NULL
)
16178 free_debug_section (debug
);
16180 return load_specific_debug_section (debug
, sec
, data
);
16184 free_debug_section (enum dwarf_section_display_enum debug
)
16186 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
16188 if (section
->start
== NULL
)
16191 free ((char *) section
->start
);
16192 section
->start
= NULL
;
16193 section
->address
= 0;
16196 free (section
->reloc_info
);
16197 section
->reloc_info
= NULL
;
16198 section
->num_relocs
= 0;
16202 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
16204 const char *name
= (section_name_valid (filedata
, section
)
16205 ? section_name (filedata
, section
) : "");
16206 const char *print_name
= printable_section_name (filedata
, section
);
16208 bool result
= true;
16211 length
= section
->sh_size
;
16214 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
16217 if (section
->sh_type
== SHT_NOBITS
)
16219 /* There is no point in dumping the contents of a debugging section
16220 which has the NOBITS type - the bits in the file will be random.
16221 This can happen when a file containing a .eh_frame section is
16222 stripped with the --only-keep-debug command line option. */
16223 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
16228 if (startswith (name
, ".gnu.linkonce.wi."))
16229 name
= ".debug_info";
16231 /* See if we know how to display the contents of this section. */
16232 for (i
= 0; i
< max
; i
++)
16234 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
16235 struct dwarf_section_display
* display
= debug_displays
+ i
;
16236 struct dwarf_section
* sec
= & display
->section
;
16238 if (streq (sec
->uncompressed_name
, name
)
16239 || (id
== line
&& startswith (name
, ".debug_line."))
16240 || streq (sec
->compressed_name
, name
))
16242 bool secondary
= (section
!= find_section (filedata
, name
));
16245 free_debug_section (id
);
16247 if (i
== line
&& startswith (name
, ".debug_line."))
16249 else if (streq (sec
->uncompressed_name
, name
))
16250 sec
->name
= sec
->uncompressed_name
;
16252 sec
->name
= sec
->compressed_name
;
16254 if (load_specific_debug_section (id
, section
, filedata
))
16256 /* If this debug section is part of a CU/TU set in a .dwp file,
16257 restrict load_debug_section to the sections in that set. */
16258 section_subset
= find_cu_tu_set (filedata
, shndx
);
16260 result
&= display
->display (sec
, filedata
);
16262 section_subset
= NULL
;
16264 if (secondary
|| (id
!= info
&& id
!= abbrev
&& id
!= debug_addr
))
16265 free_debug_section (id
);
16273 printf (_("Unrecognized debug section: %s\n"), print_name
);
16280 /* Set DUMP_SECTS for all sections where dumps were requested
16281 based on section name. */
16284 initialise_dumps_byname (Filedata
* filedata
)
16286 struct dump_list_entry
* cur
;
16288 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
16293 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
16294 if (section_name_valid (filedata
, filedata
->section_headers
+ i
)
16295 && streq (section_name (filedata
, filedata
->section_headers
+ i
),
16298 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
16302 if (!any
&& !filedata
->is_separate
)
16303 warn (_("Section '%s' was not dumped because it does not exist\n"),
16309 process_section_contents (Filedata
* filedata
)
16311 Elf_Internal_Shdr
* section
;
16318 initialise_dumps_byname (filedata
);
16320 for (i
= 0, section
= filedata
->section_headers
;
16321 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
16324 dump_type dump
= filedata
->dump
.dump_sects
[i
];
16326 if (filedata
->is_separate
&& ! process_links
)
16327 dump
&= DEBUG_DUMP
;
16329 #ifdef SUPPORT_DISASSEMBLY
16330 if (dump
& DISASS_DUMP
)
16332 if (! disassemble_section (section
, filedata
))
16336 if (dump
& HEX_DUMP
)
16338 if (! dump_section_as_bytes (section
, filedata
, false))
16342 if (dump
& RELOC_DUMP
)
16344 if (! dump_section_as_bytes (section
, filedata
, true))
16348 if (dump
& STRING_DUMP
)
16350 if (! dump_section_as_strings (section
, filedata
))
16354 if (dump
& DEBUG_DUMP
)
16356 if (! display_debug_section (i
, section
, filedata
))
16360 #ifdef ENABLE_LIBCTF
16361 if (dump
& CTF_DUMP
)
16363 if (! dump_section_as_ctf (section
, filedata
))
16369 if (! filedata
->is_separate
)
16371 /* Check to see if the user requested a
16372 dump of a section that does not exist. */
16373 for (; i
< filedata
->dump
.num_dump_sects
; i
++)
16374 if (filedata
->dump
.dump_sects
[i
])
16376 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
16385 process_mips_fpe_exception (int mask
)
16391 if (mask
& OEX_FPU_INEX
)
16392 fputs ("INEX", stdout
), first
= false;
16393 if (mask
& OEX_FPU_UFLO
)
16394 printf ("%sUFLO", first
? "" : "|"), first
= false;
16395 if (mask
& OEX_FPU_OFLO
)
16396 printf ("%sOFLO", first
? "" : "|"), first
= false;
16397 if (mask
& OEX_FPU_DIV0
)
16398 printf ("%sDIV0", first
? "" : "|"), first
= false;
16399 if (mask
& OEX_FPU_INVAL
)
16400 printf ("%sINVAL", first
? "" : "|");
16403 fputs ("0", stdout
);
16406 /* Display's the value of TAG at location P. If TAG is
16407 greater than 0 it is assumed to be an unknown tag, and
16408 a message is printed to this effect. Otherwise it is
16409 assumed that a message has already been printed.
16411 If the bottom bit of TAG is set it assumed to have a
16412 string value, otherwise it is assumed to have an integer
16415 Returns an updated P pointing to the first unread byte
16416 beyond the end of TAG's value.
16418 Reads at or beyond END will not be made. */
16420 static unsigned char *
16421 display_tag_value (signed int tag
,
16423 const unsigned char * const end
)
16428 printf (" Tag_unknown_%d: ", tag
);
16432 warn (_("<corrupt tag>\n"));
16436 /* PR 17531 file: 027-19978-0.004. */
16437 size_t maxlen
= (end
- p
) - 1;
16442 print_symbol ((int) maxlen
, (const char *) p
);
16443 p
+= strnlen ((char *) p
, maxlen
) + 1;
16447 printf (_("<corrupt string tag>"));
16448 p
= (unsigned char *) end
;
16454 READ_ULEB (val
, p
, end
);
16455 printf ("%ld (0x%lx)\n", val
, val
);
16462 /* ARC ABI attributes section. */
16464 static unsigned char *
16465 display_arc_attribute (unsigned char * p
,
16466 const unsigned char * const end
)
16471 READ_ULEB (tag
, p
, end
);
16475 case Tag_ARC_PCS_config
:
16476 READ_ULEB (val
, p
, end
);
16477 printf (" Tag_ARC_PCS_config: ");
16481 printf (_("Absent/Non standard\n"));
16484 printf (_("Bare metal/mwdt\n"));
16487 printf (_("Bare metal/newlib\n"));
16490 printf (_("Linux/uclibc\n"));
16493 printf (_("Linux/glibc\n"));
16496 printf (_("Unknown\n"));
16501 case Tag_ARC_CPU_base
:
16502 READ_ULEB (val
, p
, end
);
16503 printf (" Tag_ARC_CPU_base: ");
16508 printf (_("Absent\n"));
16510 case TAG_CPU_ARC6xx
:
16511 printf ("ARC6xx\n");
16513 case TAG_CPU_ARC7xx
:
16514 printf ("ARC7xx\n");
16516 case TAG_CPU_ARCEM
:
16517 printf ("ARCEM\n");
16519 case TAG_CPU_ARCHS
:
16520 printf ("ARCHS\n");
16525 case Tag_ARC_CPU_variation
:
16526 READ_ULEB (val
, p
, end
);
16527 printf (" Tag_ARC_CPU_variation: ");
16531 if (val
> 0 && val
< 16)
16532 printf ("Core%d\n", val
);
16534 printf ("Unknown\n");
16538 printf (_("Absent\n"));
16543 case Tag_ARC_CPU_name
:
16544 printf (" Tag_ARC_CPU_name: ");
16545 p
= display_tag_value (-1, p
, end
);
16548 case Tag_ARC_ABI_rf16
:
16549 READ_ULEB (val
, p
, end
);
16550 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
16553 case Tag_ARC_ABI_osver
:
16554 READ_ULEB (val
, p
, end
);
16555 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
16558 case Tag_ARC_ABI_pic
:
16559 case Tag_ARC_ABI_sda
:
16560 READ_ULEB (val
, p
, end
);
16561 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
16562 : " Tag_ARC_ABI_pic: ");
16566 printf (_("Absent\n"));
16575 printf (_("Unknown\n"));
16580 case Tag_ARC_ABI_tls
:
16581 READ_ULEB (val
, p
, end
);
16582 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
16585 case Tag_ARC_ABI_enumsize
:
16586 READ_ULEB (val
, p
, end
);
16587 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
16591 case Tag_ARC_ABI_exceptions
:
16592 READ_ULEB (val
, p
, end
);
16593 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
16597 case Tag_ARC_ABI_double_size
:
16598 READ_ULEB (val
, p
, end
);
16599 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
16602 case Tag_ARC_ISA_config
:
16603 printf (" Tag_ARC_ISA_config: ");
16604 p
= display_tag_value (-1, p
, end
);
16607 case Tag_ARC_ISA_apex
:
16608 printf (" Tag_ARC_ISA_apex: ");
16609 p
= display_tag_value (-1, p
, end
);
16612 case Tag_ARC_ISA_mpy_option
:
16613 READ_ULEB (val
, p
, end
);
16614 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
16617 case Tag_ARC_ATR_version
:
16618 READ_ULEB (val
, p
, end
);
16619 printf (" Tag_ARC_ATR_version: %d\n", val
);
16623 return display_tag_value (tag
& 1, p
, end
);
16629 /* ARM EABI attributes section. */
16634 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
16636 const char *const *table
;
16637 } arm_attr_public_tag
;
16639 static const char *const arm_attr_tag_CPU_arch
[] =
16640 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
16641 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
16642 "v8-M.mainline", "v8.1-A", "v8.2-A", "v8.3-A",
16643 "v8.1-M.mainline", "v9"};
16644 static const char *const arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
16645 static const char *const arm_attr_tag_THUMB_ISA_use
[] =
16646 {"No", "Thumb-1", "Thumb-2", "Yes"};
16647 static const char *const arm_attr_tag_FP_arch
[] =
16648 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
16649 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
16650 static const char *const arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
16651 static const char *const arm_attr_tag_Advanced_SIMD_arch
[] =
16652 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
16653 "NEON for ARMv8.1"};
16654 static const char *const arm_attr_tag_PCS_config
[] =
16655 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
16656 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
16657 static const char *const arm_attr_tag_ABI_PCS_R9_use
[] =
16658 {"V6", "SB", "TLS", "Unused"};
16659 static const char *const arm_attr_tag_ABI_PCS_RW_data
[] =
16660 {"Absolute", "PC-relative", "SB-relative", "None"};
16661 static const char *const arm_attr_tag_ABI_PCS_RO_data
[] =
16662 {"Absolute", "PC-relative", "None"};
16663 static const char *const arm_attr_tag_ABI_PCS_GOT_use
[] =
16664 {"None", "direct", "GOT-indirect"};
16665 static const char *const arm_attr_tag_ABI_PCS_wchar_t
[] =
16666 {"None", "??? 1", "2", "??? 3", "4"};
16667 static const char *const arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
16668 static const char *const arm_attr_tag_ABI_FP_denormal
[] =
16669 {"Unused", "Needed", "Sign only"};
16670 static const char *const arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
16671 static const char *const arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
16672 static const char *const arm_attr_tag_ABI_FP_number_model
[] =
16673 {"Unused", "Finite", "RTABI", "IEEE 754"};
16674 static const char *const arm_attr_tag_ABI_enum_size
[] =
16675 {"Unused", "small", "int", "forced to int"};
16676 static const char *const arm_attr_tag_ABI_HardFP_use
[] =
16677 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
16678 static const char *const arm_attr_tag_ABI_VFP_args
[] =
16679 {"AAPCS", "VFP registers", "custom", "compatible"};
16680 static const char *const arm_attr_tag_ABI_WMMX_args
[] =
16681 {"AAPCS", "WMMX registers", "custom"};
16682 static const char *const arm_attr_tag_ABI_optimization_goals
[] =
16683 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
16684 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
16685 static const char *const arm_attr_tag_ABI_FP_optimization_goals
[] =
16686 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
16687 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
16688 static const char *const arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
16689 static const char *const arm_attr_tag_FP_HP_extension
[] =
16690 {"Not Allowed", "Allowed"};
16691 static const char *const arm_attr_tag_ABI_FP_16bit_format
[] =
16692 {"None", "IEEE 754", "Alternative Format"};
16693 static const char *const arm_attr_tag_DSP_extension
[] =
16694 {"Follow architecture", "Allowed"};
16695 static const char *const arm_attr_tag_MPextension_use
[] =
16696 {"Not Allowed", "Allowed"};
16697 static const char *const arm_attr_tag_DIV_use
[] =
16698 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
16699 "Allowed in v7-A with integer division extension"};
16700 static const char *const arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
16701 static const char *const arm_attr_tag_Virtualization_use
[] =
16702 {"Not Allowed", "TrustZone", "Virtualization Extensions",
16703 "TrustZone and Virtualization Extensions"};
16704 static const char *const arm_attr_tag_MPextension_use_legacy
[] =
16705 {"Not Allowed", "Allowed"};
16707 static const char *const arm_attr_tag_MVE_arch
[] =
16708 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
16710 static const char * arm_attr_tag_PAC_extension
[] =
16711 {"No PAC/AUT instructions",
16712 "PAC/AUT instructions permitted in the NOP space",
16713 "PAC/AUT instructions permitted in the NOP and in the non-NOP space"};
16715 static const char * arm_attr_tag_BTI_extension
[] =
16716 {"BTI instructions not permitted",
16717 "BTI instructions permitted in the NOP space",
16718 "BTI instructions permitted in the NOP and in the non-NOP space"};
16720 static const char * arm_attr_tag_BTI_use
[] =
16721 {"Compiled without branch target enforcement",
16722 "Compiled with branch target enforcement"};
16724 static const char * arm_attr_tag_PACRET_use
[] =
16725 {"Compiled without return address signing and authentication",
16726 "Compiled with return address signing and authentication"};
16728 #define LOOKUP(id, name) \
16729 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
16730 static arm_attr_public_tag arm_attr_public_tags
[] =
16732 {4, "CPU_raw_name", 1, NULL
},
16733 {5, "CPU_name", 1, NULL
},
16734 LOOKUP(6, CPU_arch
),
16735 {7, "CPU_arch_profile", 0, NULL
},
16736 LOOKUP(8, ARM_ISA_use
),
16737 LOOKUP(9, THUMB_ISA_use
),
16738 LOOKUP(10, FP_arch
),
16739 LOOKUP(11, WMMX_arch
),
16740 LOOKUP(12, Advanced_SIMD_arch
),
16741 LOOKUP(13, PCS_config
),
16742 LOOKUP(14, ABI_PCS_R9_use
),
16743 LOOKUP(15, ABI_PCS_RW_data
),
16744 LOOKUP(16, ABI_PCS_RO_data
),
16745 LOOKUP(17, ABI_PCS_GOT_use
),
16746 LOOKUP(18, ABI_PCS_wchar_t
),
16747 LOOKUP(19, ABI_FP_rounding
),
16748 LOOKUP(20, ABI_FP_denormal
),
16749 LOOKUP(21, ABI_FP_exceptions
),
16750 LOOKUP(22, ABI_FP_user_exceptions
),
16751 LOOKUP(23, ABI_FP_number_model
),
16752 {24, "ABI_align_needed", 0, NULL
},
16753 {25, "ABI_align_preserved", 0, NULL
},
16754 LOOKUP(26, ABI_enum_size
),
16755 LOOKUP(27, ABI_HardFP_use
),
16756 LOOKUP(28, ABI_VFP_args
),
16757 LOOKUP(29, ABI_WMMX_args
),
16758 LOOKUP(30, ABI_optimization_goals
),
16759 LOOKUP(31, ABI_FP_optimization_goals
),
16760 {32, "compatibility", 0, NULL
},
16761 LOOKUP(34, CPU_unaligned_access
),
16762 LOOKUP(36, FP_HP_extension
),
16763 LOOKUP(38, ABI_FP_16bit_format
),
16764 LOOKUP(42, MPextension_use
),
16765 LOOKUP(44, DIV_use
),
16766 LOOKUP(46, DSP_extension
),
16767 LOOKUP(48, MVE_arch
),
16768 LOOKUP(50, PAC_extension
),
16769 LOOKUP(52, BTI_extension
),
16770 LOOKUP(74, BTI_use
),
16771 LOOKUP(76, PACRET_use
),
16772 {64, "nodefaults", 0, NULL
},
16773 {65, "also_compatible_with", 0, NULL
},
16774 LOOKUP(66, T2EE_use
),
16775 {67, "conformance", 1, NULL
},
16776 LOOKUP(68, Virtualization_use
),
16777 LOOKUP(70, MPextension_use_legacy
)
16781 static unsigned char *
16782 display_arm_attribute (unsigned char * p
,
16783 const unsigned char * const end
)
16787 arm_attr_public_tag
* attr
;
16791 READ_ULEB (tag
, p
, end
);
16793 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
16795 if (arm_attr_public_tags
[i
].tag
== tag
)
16797 attr
= &arm_attr_public_tags
[i
];
16804 printf (" Tag_%s: ", attr
->name
);
16805 switch (attr
->type
)
16810 case 7: /* Tag_CPU_arch_profile. */
16811 READ_ULEB (val
, p
, end
);
16814 case 0: printf (_("None\n")); break;
16815 case 'A': printf (_("Application\n")); break;
16816 case 'R': printf (_("Realtime\n")); break;
16817 case 'M': printf (_("Microcontroller\n")); break;
16818 case 'S': printf (_("Application or Realtime\n")); break;
16819 default: printf ("??? (%d)\n", val
); break;
16823 case 24: /* Tag_align_needed. */
16824 READ_ULEB (val
, p
, end
);
16827 case 0: printf (_("None\n")); break;
16828 case 1: printf (_("8-byte\n")); break;
16829 case 2: printf (_("4-byte\n")); break;
16830 case 3: printf ("??? 3\n"); break;
16833 printf (_("8-byte and up to %d-byte extended\n"),
16836 printf ("??? (%d)\n", val
);
16841 case 25: /* Tag_align_preserved. */
16842 READ_ULEB (val
, p
, end
);
16845 case 0: printf (_("None\n")); break;
16846 case 1: printf (_("8-byte, except leaf SP\n")); break;
16847 case 2: printf (_("8-byte\n")); break;
16848 case 3: printf ("??? 3\n"); break;
16851 printf (_("8-byte and up to %d-byte extended\n"),
16854 printf ("??? (%d)\n", val
);
16859 case 32: /* Tag_compatibility. */
16861 READ_ULEB (val
, p
, end
);
16862 printf (_("flag = %d, vendor = "), val
);
16865 size_t maxlen
= (end
- p
) - 1;
16867 print_symbol ((int) maxlen
, (const char *) p
);
16868 p
+= strnlen ((char *) p
, maxlen
) + 1;
16872 printf (_("<corrupt>"));
16873 p
= (unsigned char *) end
;
16879 case 64: /* Tag_nodefaults. */
16880 /* PR 17531: file: 001-505008-0.01. */
16883 printf (_("True\n"));
16886 case 65: /* Tag_also_compatible_with. */
16887 READ_ULEB (val
, p
, end
);
16888 if (val
== 6 /* Tag_CPU_arch. */)
16890 READ_ULEB (val
, p
, end
);
16891 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
16892 printf ("??? (%d)\n", val
);
16894 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
16898 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
16903 printf (_("<unknown: %d>\n"), tag
);
16909 return display_tag_value (-1, p
, end
);
16911 return display_tag_value (0, p
, end
);
16914 assert (attr
->type
& 0x80);
16915 READ_ULEB (val
, p
, end
);
16916 type
= attr
->type
& 0x7f;
16918 printf ("??? (%d)\n", val
);
16920 printf ("%s\n", attr
->table
[val
]);
16925 return display_tag_value (tag
, p
, end
);
16928 static unsigned char *
16929 display_gnu_attribute (unsigned char * p
,
16930 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
16931 const unsigned char * const end
)
16936 READ_ULEB (tag
, p
, end
);
16938 /* Tag_compatibility is the only generic GNU attribute defined at
16942 READ_ULEB (val
, p
, end
);
16944 printf (_("flag = %d, vendor = "), val
);
16947 printf (_("<corrupt>\n"));
16948 warn (_("corrupt vendor attribute\n"));
16954 size_t maxlen
= (end
- p
) - 1;
16956 print_symbol ((int) maxlen
, (const char *) p
);
16957 p
+= strnlen ((char *) p
, maxlen
) + 1;
16961 printf (_("<corrupt>"));
16962 p
= (unsigned char *) end
;
16969 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
16970 return display_proc_gnu_attribute (p
, tag
, end
);
16972 return display_tag_value (tag
, p
, end
);
16975 static unsigned char *
16976 display_m68k_gnu_attribute (unsigned char * p
,
16978 const unsigned char * const end
)
16982 if (tag
== Tag_GNU_M68K_ABI_FP
)
16984 printf (" Tag_GNU_M68K_ABI_FP: ");
16987 printf (_("<corrupt>\n"));
16990 READ_ULEB (val
, p
, end
);
16993 printf ("(%#x), ", val
);
16998 printf (_("unspecified hard/soft float\n"));
17001 printf (_("hard float\n"));
17004 printf (_("soft float\n"));
17010 return display_tag_value (tag
& 1, p
, end
);
17013 static unsigned char *
17014 display_power_gnu_attribute (unsigned char * p
,
17016 const unsigned char * const end
)
17020 if (tag
== Tag_GNU_Power_ABI_FP
)
17022 printf (" Tag_GNU_Power_ABI_FP: ");
17025 printf (_("<corrupt>\n"));
17028 READ_ULEB (val
, p
, end
);
17031 printf ("(%#x), ", val
);
17036 printf (_("unspecified hard/soft float, "));
17039 printf (_("hard float, "));
17042 printf (_("soft float, "));
17045 printf (_("single-precision hard float, "));
17052 printf (_("unspecified long double\n"));
17055 printf (_("128-bit IBM long double\n"));
17058 printf (_("64-bit long double\n"));
17061 printf (_("128-bit IEEE long double\n"));
17067 if (tag
== Tag_GNU_Power_ABI_Vector
)
17069 printf (" Tag_GNU_Power_ABI_Vector: ");
17072 printf (_("<corrupt>\n"));
17075 READ_ULEB (val
, p
, end
);
17078 printf ("(%#x), ", val
);
17083 printf (_("unspecified\n"));
17086 printf (_("generic\n"));
17089 printf ("AltiVec\n");
17098 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
17100 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
17103 printf (_("<corrupt>\n"));
17106 READ_ULEB (val
, p
, end
);
17109 printf ("(%#x), ", val
);
17114 printf (_("unspecified\n"));
17117 printf ("r3/r4\n");
17120 printf (_("memory\n"));
17129 return display_tag_value (tag
& 1, p
, end
);
17132 static unsigned char *
17133 display_s390_gnu_attribute (unsigned char * p
,
17135 const unsigned char * const end
)
17139 if (tag
== Tag_GNU_S390_ABI_Vector
)
17141 printf (" Tag_GNU_S390_ABI_Vector: ");
17142 READ_ULEB (val
, p
, end
);
17147 printf (_("any\n"));
17150 printf (_("software\n"));
17153 printf (_("hardware\n"));
17156 printf ("??? (%d)\n", val
);
17162 return display_tag_value (tag
& 1, p
, end
);
17166 display_sparc_hwcaps (unsigned int mask
)
17172 if (mask
& ELF_SPARC_HWCAP_MUL32
)
17173 fputs ("mul32", stdout
), first
= false;
17174 if (mask
& ELF_SPARC_HWCAP_DIV32
)
17175 printf ("%sdiv32", first
? "" : "|"), first
= false;
17176 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
17177 printf ("%sfsmuld", first
? "" : "|"), first
= false;
17178 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
17179 printf ("%sv8plus", first
? "" : "|"), first
= false;
17180 if (mask
& ELF_SPARC_HWCAP_POPC
)
17181 printf ("%spopc", first
? "" : "|"), first
= false;
17182 if (mask
& ELF_SPARC_HWCAP_VIS
)
17183 printf ("%svis", first
? "" : "|"), first
= false;
17184 if (mask
& ELF_SPARC_HWCAP_VIS2
)
17185 printf ("%svis2", first
? "" : "|"), first
= false;
17186 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
17187 printf ("%sASIBlkInit", first
? "" : "|"), first
= false;
17188 if (mask
& ELF_SPARC_HWCAP_FMAF
)
17189 printf ("%sfmaf", first
? "" : "|"), first
= false;
17190 if (mask
& ELF_SPARC_HWCAP_VIS3
)
17191 printf ("%svis3", first
? "" : "|"), first
= false;
17192 if (mask
& ELF_SPARC_HWCAP_HPC
)
17193 printf ("%shpc", first
? "" : "|"), first
= false;
17194 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
17195 printf ("%srandom", first
? "" : "|"), first
= false;
17196 if (mask
& ELF_SPARC_HWCAP_TRANS
)
17197 printf ("%strans", first
? "" : "|"), first
= false;
17198 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
17199 printf ("%sfjfmau", first
? "" : "|"), first
= false;
17200 if (mask
& ELF_SPARC_HWCAP_IMA
)
17201 printf ("%sima", first
? "" : "|"), first
= false;
17202 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
17203 printf ("%scspare", first
? "" : "|"), first
= false;
17206 fputc ('0', stdout
);
17207 fputc ('\n', stdout
);
17211 display_sparc_hwcaps2 (unsigned int mask
)
17217 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
17218 fputs ("fjathplus", stdout
), first
= false;
17219 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
17220 printf ("%svis3b", first
? "" : "|"), first
= false;
17221 if (mask
& ELF_SPARC_HWCAP2_ADP
)
17222 printf ("%sadp", first
? "" : "|"), first
= false;
17223 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
17224 printf ("%ssparc5", first
? "" : "|"), first
= false;
17225 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
17226 printf ("%smwait", first
? "" : "|"), first
= false;
17227 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
17228 printf ("%sxmpmul", first
? "" : "|"), first
= false;
17229 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
17230 printf ("%sxmont2", first
? "" : "|"), first
= false;
17231 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
17232 printf ("%snsec", first
? "" : "|"), first
= false;
17233 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
17234 printf ("%sfjathhpc", first
? "" : "|"), first
= false;
17235 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
17236 printf ("%sfjdes", first
? "" : "|"), first
= false;
17237 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
17238 printf ("%sfjaes", first
? "" : "|"), first
= false;
17241 fputc ('0', stdout
);
17242 fputc ('\n', stdout
);
17245 static unsigned char *
17246 display_sparc_gnu_attribute (unsigned char * p
,
17248 const unsigned char * const end
)
17252 if (tag
== Tag_GNU_Sparc_HWCAPS
)
17254 READ_ULEB (val
, p
, end
);
17255 printf (" Tag_GNU_Sparc_HWCAPS: ");
17256 display_sparc_hwcaps (val
);
17259 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
17261 READ_ULEB (val
, p
, end
);
17262 printf (" Tag_GNU_Sparc_HWCAPS2: ");
17263 display_sparc_hwcaps2 (val
);
17267 return display_tag_value (tag
, p
, end
);
17271 print_mips_fp_abi_value (unsigned int val
)
17275 case Val_GNU_MIPS_ABI_FP_ANY
:
17276 printf (_("Hard or soft float\n"));
17278 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
17279 printf (_("Hard float (double precision)\n"));
17281 case Val_GNU_MIPS_ABI_FP_SINGLE
:
17282 printf (_("Hard float (single precision)\n"));
17284 case Val_GNU_MIPS_ABI_FP_SOFT
:
17285 printf (_("Soft float\n"));
17287 case Val_GNU_MIPS_ABI_FP_OLD_64
:
17288 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
17290 case Val_GNU_MIPS_ABI_FP_XX
:
17291 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
17293 case Val_GNU_MIPS_ABI_FP_64
:
17294 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
17296 case Val_GNU_MIPS_ABI_FP_64A
:
17297 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
17299 case Val_GNU_MIPS_ABI_FP_NAN2008
:
17300 printf (_("NaN 2008 compatibility\n"));
17303 printf ("??? (%d)\n", val
);
17308 static unsigned char *
17309 display_mips_gnu_attribute (unsigned char * p
,
17311 const unsigned char * const end
)
17313 if (tag
== Tag_GNU_MIPS_ABI_FP
)
17317 printf (" Tag_GNU_MIPS_ABI_FP: ");
17318 READ_ULEB (val
, p
, end
);
17319 print_mips_fp_abi_value (val
);
17323 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
17327 printf (" Tag_GNU_MIPS_ABI_MSA: ");
17328 READ_ULEB (val
, p
, end
);
17332 case Val_GNU_MIPS_ABI_MSA_ANY
:
17333 printf (_("Any MSA or not\n"));
17335 case Val_GNU_MIPS_ABI_MSA_128
:
17336 printf (_("128-bit MSA\n"));
17339 printf ("??? (%d)\n", val
);
17345 return display_tag_value (tag
& 1, p
, end
);
17348 static unsigned char *
17349 display_tic6x_attribute (unsigned char * p
,
17350 const unsigned char * const end
)
17355 READ_ULEB (tag
, p
, end
);
17360 printf (" Tag_ISA: ");
17361 READ_ULEB (val
, p
, end
);
17365 case C6XABI_Tag_ISA_none
:
17366 printf (_("None\n"));
17368 case C6XABI_Tag_ISA_C62X
:
17371 case C6XABI_Tag_ISA_C67X
:
17374 case C6XABI_Tag_ISA_C67XP
:
17375 printf ("C67x+\n");
17377 case C6XABI_Tag_ISA_C64X
:
17380 case C6XABI_Tag_ISA_C64XP
:
17381 printf ("C64x+\n");
17383 case C6XABI_Tag_ISA_C674X
:
17384 printf ("C674x\n");
17387 printf ("??? (%d)\n", val
);
17392 case Tag_ABI_wchar_t
:
17393 printf (" Tag_ABI_wchar_t: ");
17394 READ_ULEB (val
, p
, end
);
17398 printf (_("Not used\n"));
17401 printf (_("2 bytes\n"));
17404 printf (_("4 bytes\n"));
17407 printf ("??? (%d)\n", val
);
17412 case Tag_ABI_stack_align_needed
:
17413 printf (" Tag_ABI_stack_align_needed: ");
17414 READ_ULEB (val
, p
, end
);
17418 printf (_("8-byte\n"));
17421 printf (_("16-byte\n"));
17424 printf ("??? (%d)\n", val
);
17429 case Tag_ABI_stack_align_preserved
:
17430 READ_ULEB (val
, p
, end
);
17431 printf (" Tag_ABI_stack_align_preserved: ");
17435 printf (_("8-byte\n"));
17438 printf (_("16-byte\n"));
17441 printf ("??? (%d)\n", val
);
17447 READ_ULEB (val
, p
, end
);
17448 printf (" Tag_ABI_DSBT: ");
17452 printf (_("DSBT addressing not used\n"));
17455 printf (_("DSBT addressing used\n"));
17458 printf ("??? (%d)\n", val
);
17464 READ_ULEB (val
, p
, end
);
17465 printf (" Tag_ABI_PID: ");
17469 printf (_("Data addressing position-dependent\n"));
17472 printf (_("Data addressing position-independent, GOT near DP\n"));
17475 printf (_("Data addressing position-independent, GOT far from DP\n"));
17478 printf ("??? (%d)\n", val
);
17484 READ_ULEB (val
, p
, end
);
17485 printf (" Tag_ABI_PIC: ");
17489 printf (_("Code addressing position-dependent\n"));
17492 printf (_("Code addressing position-independent\n"));
17495 printf ("??? (%d)\n", val
);
17500 case Tag_ABI_array_object_alignment
:
17501 READ_ULEB (val
, p
, end
);
17502 printf (" Tag_ABI_array_object_alignment: ");
17506 printf (_("8-byte\n"));
17509 printf (_("4-byte\n"));
17512 printf (_("16-byte\n"));
17515 printf ("??? (%d)\n", val
);
17520 case Tag_ABI_array_object_align_expected
:
17521 READ_ULEB (val
, p
, end
);
17522 printf (" Tag_ABI_array_object_align_expected: ");
17526 printf (_("8-byte\n"));
17529 printf (_("4-byte\n"));
17532 printf (_("16-byte\n"));
17535 printf ("??? (%d)\n", val
);
17540 case Tag_ABI_compatibility
:
17542 READ_ULEB (val
, p
, end
);
17543 printf (" Tag_ABI_compatibility: ");
17544 printf (_("flag = %d, vendor = "), val
);
17547 size_t maxlen
= (end
- p
) - 1;
17549 print_symbol ((int) maxlen
, (const char *) p
);
17550 p
+= strnlen ((char *) p
, maxlen
) + 1;
17554 printf (_("<corrupt>"));
17555 p
= (unsigned char *) end
;
17561 case Tag_ABI_conformance
:
17563 printf (" Tag_ABI_conformance: \"");
17566 size_t maxlen
= (end
- p
) - 1;
17568 print_symbol ((int) maxlen
, (const char *) p
);
17569 p
+= strnlen ((char *) p
, maxlen
) + 1;
17573 printf (_("<corrupt>"));
17574 p
= (unsigned char *) end
;
17581 return display_tag_value (tag
, p
, end
);
17585 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
17587 unsigned long addr
= 0;
17588 size_t bytes
= end
- p
;
17595 int lbytes
= (bytes
> 16 ? 16 : bytes
);
17597 printf (" 0x%8.8lx ", addr
);
17599 for (j
= 0; j
< 16; j
++)
17602 printf ("%2.2x", p
[j
]);
17610 for (j
= 0; j
< lbytes
; j
++)
17613 if (k
>= ' ' && k
< 0x7f)
17629 static unsigned char *
17630 display_msp430_attribute (unsigned char * p
,
17631 const unsigned char * const end
)
17636 READ_ULEB (tag
, p
, end
);
17640 case OFBA_MSPABI_Tag_ISA
:
17641 printf (" Tag_ISA: ");
17642 READ_ULEB (val
, p
, end
);
17645 case 0: printf (_("None\n")); break;
17646 case 1: printf (_("MSP430\n")); break;
17647 case 2: printf (_("MSP430X\n")); break;
17648 default: printf ("??? (%d)\n", val
); break;
17652 case OFBA_MSPABI_Tag_Code_Model
:
17653 printf (" Tag_Code_Model: ");
17654 READ_ULEB (val
, p
, end
);
17657 case 0: printf (_("None\n")); break;
17658 case 1: printf (_("Small\n")); break;
17659 case 2: printf (_("Large\n")); break;
17660 default: printf ("??? (%d)\n", val
); break;
17664 case OFBA_MSPABI_Tag_Data_Model
:
17665 printf (" Tag_Data_Model: ");
17666 READ_ULEB (val
, p
, end
);
17669 case 0: printf (_("None\n")); break;
17670 case 1: printf (_("Small\n")); break;
17671 case 2: printf (_("Large\n")); break;
17672 case 3: printf (_("Restricted Large\n")); break;
17673 default: printf ("??? (%d)\n", val
); break;
17678 printf (_(" <unknown tag %d>: "), tag
);
17685 size_t maxlen
= (end
- p
) - 1;
17687 print_symbol ((int) maxlen
, (const char *) p
);
17688 p
+= strnlen ((char *) p
, maxlen
) + 1;
17692 printf (_("<corrupt>"));
17693 p
= (unsigned char *) end
;
17699 READ_ULEB (val
, p
, end
);
17700 printf ("%d (0x%x)\n", val
, val
);
17709 static unsigned char *
17710 display_msp430_gnu_attribute (unsigned char * p
,
17712 const unsigned char * const end
)
17714 if (tag
== Tag_GNU_MSP430_Data_Region
)
17718 printf (" Tag_GNU_MSP430_Data_Region: ");
17719 READ_ULEB (val
, p
, end
);
17723 case Val_GNU_MSP430_Data_Region_Any
:
17724 printf (_("Any Region\n"));
17726 case Val_GNU_MSP430_Data_Region_Lower
:
17727 printf (_("Lower Region Only\n"));
17730 printf ("??? (%u)\n", val
);
17734 return display_tag_value (tag
& 1, p
, end
);
17737 struct riscv_attr_tag_t
{
17742 static struct riscv_attr_tag_t riscv_attr_tag
[] =
17744 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
17747 T(priv_spec_minor
),
17748 T(priv_spec_revision
),
17749 T(unaligned_access
),
17754 static unsigned char *
17755 display_riscv_attribute (unsigned char *p
,
17756 const unsigned char * const end
)
17760 struct riscv_attr_tag_t
*attr
= NULL
;
17763 READ_ULEB (tag
, p
, end
);
17765 /* Find the name of attribute. */
17766 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
17768 if (riscv_attr_tag
[i
].tag
== tag
)
17770 attr
= &riscv_attr_tag
[i
];
17776 printf (" %s: ", attr
->name
);
17778 return display_tag_value (tag
, p
, end
);
17782 case Tag_RISCV_priv_spec
:
17783 case Tag_RISCV_priv_spec_minor
:
17784 case Tag_RISCV_priv_spec_revision
:
17785 READ_ULEB (val
, p
, end
);
17786 printf (_("%u\n"), val
);
17788 case Tag_RISCV_unaligned_access
:
17789 READ_ULEB (val
, p
, end
);
17793 printf (_("No unaligned access\n"));
17796 printf (_("Unaligned access\n"));
17800 case Tag_RISCV_stack_align
:
17801 READ_ULEB (val
, p
, end
);
17802 printf (_("%u-bytes\n"), val
);
17804 case Tag_RISCV_arch
:
17805 p
= display_tag_value (-1, p
, end
);
17808 return display_tag_value (tag
, p
, end
);
17814 static unsigned char *
17815 display_csky_attribute (unsigned char * p
,
17816 const unsigned char * const end
)
17820 READ_ULEB (tag
, p
, end
);
17822 if (tag
>= Tag_CSKY_MAX
)
17824 return display_tag_value (-1, p
, end
);
17829 case Tag_CSKY_ARCH_NAME
:
17830 printf (" Tag_CSKY_ARCH_NAME:\t\t");
17831 return display_tag_value (-1, p
, end
);
17832 case Tag_CSKY_CPU_NAME
:
17833 printf (" Tag_CSKY_CPU_NAME:\t\t");
17834 return display_tag_value (-1, p
, end
);
17836 case Tag_CSKY_ISA_FLAGS
:
17837 printf (" Tag_CSKY_ISA_FLAGS:\t\t");
17838 return display_tag_value (0, p
, end
);
17839 case Tag_CSKY_ISA_EXT_FLAGS
:
17840 printf (" Tag_CSKY_ISA_EXT_FLAGS:\t");
17841 return display_tag_value (0, p
, end
);
17843 case Tag_CSKY_DSP_VERSION
:
17844 printf (" Tag_CSKY_DSP_VERSION:\t\t");
17845 READ_ULEB (val
, p
, end
);
17846 if (val
== VAL_CSKY_DSP_VERSION_EXTENSION
)
17847 printf ("DSP Extension\n");
17848 else if (val
== VAL_CSKY_DSP_VERSION_2
)
17849 printf ("DSP 2.0\n");
17852 case Tag_CSKY_VDSP_VERSION
:
17853 printf (" Tag_CSKY_VDSP_VERSION:\t");
17854 READ_ULEB (val
, p
, end
);
17855 printf ("VDSP Version %d\n", val
);
17858 case Tag_CSKY_FPU_VERSION
:
17859 printf (" Tag_CSKY_FPU_VERSION:\t\t");
17860 READ_ULEB (val
, p
, end
);
17861 if (val
== VAL_CSKY_FPU_VERSION_1
)
17862 printf ("ABIV1 FPU Version 1\n");
17863 else if (val
== VAL_CSKY_FPU_VERSION_2
)
17864 printf ("FPU Version 2\n");
17867 case Tag_CSKY_FPU_ABI
:
17868 printf (" Tag_CSKY_FPU_ABI:\t\t");
17869 READ_ULEB (val
, p
, end
);
17870 if (val
== VAL_CSKY_FPU_ABI_HARD
)
17872 else if (val
== VAL_CSKY_FPU_ABI_SOFTFP
)
17873 printf ("SoftFP\n");
17874 else if (val
== VAL_CSKY_FPU_ABI_SOFT
)
17877 case Tag_CSKY_FPU_ROUNDING
:
17878 READ_ULEB (val
, p
, end
);
17881 printf (" Tag_CSKY_FPU_ROUNDING:\t");
17882 printf ("Needed\n");
17885 case Tag_CSKY_FPU_DENORMAL
:
17886 READ_ULEB (val
, p
, end
);
17889 printf (" Tag_CSKY_FPU_DENORMAL:\t");
17890 printf ("Needed\n");
17893 case Tag_CSKY_FPU_Exception
:
17894 READ_ULEB (val
, p
, end
);
17897 printf (" Tag_CSKY_FPU_Exception:\t");
17898 printf ("Needed\n");
17901 case Tag_CSKY_FPU_NUMBER_MODULE
:
17902 printf (" Tag_CSKY_FPU_NUMBER_MODULE:\t");
17903 return display_tag_value (-1, p
, end
);
17904 case Tag_CSKY_FPU_HARDFP
:
17905 printf (" Tag_CSKY_FPU_HARDFP:\t\t");
17906 READ_ULEB (val
, p
, end
);
17907 if (val
& VAL_CSKY_FPU_HARDFP_HALF
)
17909 if (val
& VAL_CSKY_FPU_HARDFP_SINGLE
)
17910 printf (" Single");
17911 if (val
& VAL_CSKY_FPU_HARDFP_DOUBLE
)
17912 printf (" Double");
17916 return display_tag_value (tag
, p
, end
);
17922 process_attributes (Filedata
* filedata
,
17923 const char * public_name
,
17924 unsigned int proc_type
,
17925 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
17926 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
17928 Elf_Internal_Shdr
* sect
;
17932 /* Find the section header so that we get the size. */
17933 for (i
= 0, sect
= filedata
->section_headers
;
17934 i
< filedata
->file_header
.e_shnum
;
17937 unsigned char * contents
;
17940 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
17943 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17944 sect
->sh_size
, _("attributes"));
17945 if (contents
== NULL
)
17952 /* The first character is the version of the attributes.
17953 Currently only version 1, (aka 'A') is recognised here. */
17956 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
17961 uint64_t section_len
;
17963 section_len
= sect
->sh_size
- 1;
17966 while (section_len
> 0)
17969 unsigned int namelen
;
17970 bool public_section
;
17973 if (section_len
<= 4)
17975 error (_("Tag section ends prematurely\n"));
17979 attr_len
= byte_get (p
, 4);
17982 if (attr_len
> section_len
)
17984 error (_("Bad attribute length (%u > %u)\n"),
17985 (unsigned) attr_len
, (unsigned) section_len
);
17986 attr_len
= section_len
;
17989 /* PR 17531: file: 001-101425-0.004 */
17990 else if (attr_len
< 5)
17992 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
17997 section_len
-= attr_len
;
18000 namelen
= strnlen ((char *) p
, attr_len
) + 1;
18001 if (namelen
== 0 || namelen
>= attr_len
)
18003 error (_("Corrupt attribute section name\n"));
18008 printf (_("Attribute Section: "));
18009 print_symbol (INT_MAX
, (const char *) p
);
18012 if (public_name
&& streq ((char *) p
, public_name
))
18013 public_section
= true;
18015 public_section
= false;
18017 if (streq ((char *) p
, "gnu"))
18018 gnu_section
= true;
18020 gnu_section
= false;
18023 attr_len
-= namelen
;
18025 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
18030 unsigned char * end
;
18032 /* PR binutils/17531: Safe handling of corrupt files. */
18035 error (_("Unused bytes at end of section\n"));
18042 size
= byte_get (p
, 4);
18043 if (size
> attr_len
)
18045 error (_("Bad subsection length (%u > %u)\n"),
18046 (unsigned) size
, (unsigned) attr_len
);
18050 /* PR binutils/17531: Safe handling of corrupt files. */
18053 error (_("Bad subsection length (%u < 6)\n"),
18061 end
= p
+ size
- 1;
18062 assert (end
<= contents
+ sect
->sh_size
);
18068 printf (_("File Attributes\n"));
18071 printf (_("Section Attributes:"));
18074 printf (_("Symbol Attributes:"));
18075 /* Fall through. */
18079 READ_ULEB (val
, p
, end
);
18082 printf (" %d", val
);
18087 printf (_("Unknown tag: %d\n"), tag
);
18088 public_section
= false;
18092 if (public_section
&& display_pub_attribute
!= NULL
)
18095 p
= display_pub_attribute (p
, end
);
18098 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
18101 p
= display_gnu_attribute (p
,
18102 display_proc_gnu_attribute
,
18108 printf (_(" Unknown attribute:\n"));
18109 display_raw_attribute (p
, end
);
18124 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
18125 Print the Address, Access and Initial fields of an entry at VMA ADDR
18126 and return the VMA of the next entry, or -1 if there was a problem.
18127 Does not read from DATA_END or beyond. */
18130 print_mips_got_entry (unsigned char * data
, uint64_t pltgot
, uint64_t addr
,
18131 unsigned char * data_end
)
18134 print_vma (addr
, LONG_HEX
);
18136 if (addr
< pltgot
+ 0xfff0)
18137 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
18139 printf ("%10s", "");
18142 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
18146 unsigned char * from
= data
+ addr
- pltgot
;
18148 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
18150 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
18151 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
18152 return (uint64_t) -1;
18156 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
18157 print_vma (entry
, LONG_HEX
);
18160 return addr
+ (is_32bit_elf
? 4 : 8);
18163 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
18164 PLTGOT. Print the Address and Initial fields of an entry at VMA
18165 ADDR and return the VMA of the next entry. */
18168 print_mips_pltgot_entry (unsigned char * data
, uint64_t pltgot
, uint64_t addr
)
18171 print_vma (addr
, LONG_HEX
);
18174 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
18179 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
18180 print_vma (entry
, LONG_HEX
);
18182 return addr
+ (is_32bit_elf
? 4 : 8);
18186 print_mips_ases (unsigned int mask
)
18188 if (mask
& AFL_ASE_DSP
)
18189 fputs ("\n\tDSP ASE", stdout
);
18190 if (mask
& AFL_ASE_DSPR2
)
18191 fputs ("\n\tDSP R2 ASE", stdout
);
18192 if (mask
& AFL_ASE_DSPR3
)
18193 fputs ("\n\tDSP R3 ASE", stdout
);
18194 if (mask
& AFL_ASE_EVA
)
18195 fputs ("\n\tEnhanced VA Scheme", stdout
);
18196 if (mask
& AFL_ASE_MCU
)
18197 fputs ("\n\tMCU (MicroController) ASE", stdout
);
18198 if (mask
& AFL_ASE_MDMX
)
18199 fputs ("\n\tMDMX ASE", stdout
);
18200 if (mask
& AFL_ASE_MIPS3D
)
18201 fputs ("\n\tMIPS-3D ASE", stdout
);
18202 if (mask
& AFL_ASE_MT
)
18203 fputs ("\n\tMT ASE", stdout
);
18204 if (mask
& AFL_ASE_SMARTMIPS
)
18205 fputs ("\n\tSmartMIPS ASE", stdout
);
18206 if (mask
& AFL_ASE_VIRT
)
18207 fputs ("\n\tVZ ASE", stdout
);
18208 if (mask
& AFL_ASE_MSA
)
18209 fputs ("\n\tMSA ASE", stdout
);
18210 if (mask
& AFL_ASE_MIPS16
)
18211 fputs ("\n\tMIPS16 ASE", stdout
);
18212 if (mask
& AFL_ASE_MICROMIPS
)
18213 fputs ("\n\tMICROMIPS ASE", stdout
);
18214 if (mask
& AFL_ASE_XPA
)
18215 fputs ("\n\tXPA ASE", stdout
);
18216 if (mask
& AFL_ASE_MIPS16E2
)
18217 fputs ("\n\tMIPS16e2 ASE", stdout
);
18218 if (mask
& AFL_ASE_CRC
)
18219 fputs ("\n\tCRC ASE", stdout
);
18220 if (mask
& AFL_ASE_GINV
)
18221 fputs ("\n\tGINV ASE", stdout
);
18222 if (mask
& AFL_ASE_LOONGSON_MMI
)
18223 fputs ("\n\tLoongson MMI ASE", stdout
);
18224 if (mask
& AFL_ASE_LOONGSON_CAM
)
18225 fputs ("\n\tLoongson CAM ASE", stdout
);
18226 if (mask
& AFL_ASE_LOONGSON_EXT
)
18227 fputs ("\n\tLoongson EXT ASE", stdout
);
18228 if (mask
& AFL_ASE_LOONGSON_EXT2
)
18229 fputs ("\n\tLoongson EXT2 ASE", stdout
);
18231 fprintf (stdout
, "\n\t%s", _("None"));
18232 else if ((mask
& ~AFL_ASE_MASK
) != 0)
18233 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
18237 print_mips_isa_ext (unsigned int isa_ext
)
18242 fputs (_("None"), stdout
);
18245 fputs ("RMI XLR", stdout
);
18247 case AFL_EXT_OCTEON3
:
18248 fputs ("Cavium Networks Octeon3", stdout
);
18250 case AFL_EXT_OCTEON2
:
18251 fputs ("Cavium Networks Octeon2", stdout
);
18253 case AFL_EXT_OCTEONP
:
18254 fputs ("Cavium Networks OcteonP", stdout
);
18256 case AFL_EXT_OCTEON
:
18257 fputs ("Cavium Networks Octeon", stdout
);
18260 fputs ("Toshiba R5900", stdout
);
18263 fputs ("MIPS R4650", stdout
);
18266 fputs ("LSI R4010", stdout
);
18269 fputs ("NEC VR4100", stdout
);
18272 fputs ("Toshiba R3900", stdout
);
18274 case AFL_EXT_10000
:
18275 fputs ("MIPS R10000", stdout
);
18278 fputs ("Broadcom SB-1", stdout
);
18281 fputs ("NEC VR4111/VR4181", stdout
);
18284 fputs ("NEC VR4120", stdout
);
18287 fputs ("NEC VR5400", stdout
);
18290 fputs ("NEC VR5500", stdout
);
18292 case AFL_EXT_LOONGSON_2E
:
18293 fputs ("ST Microelectronics Loongson 2E", stdout
);
18295 case AFL_EXT_LOONGSON_2F
:
18296 fputs ("ST Microelectronics Loongson 2F", stdout
);
18298 case AFL_EXT_INTERAPTIV_MR2
:
18299 fputs ("Imagination interAptiv MR2", stdout
);
18302 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
18307 get_mips_reg_size (int reg_size
)
18309 return (reg_size
== AFL_REG_NONE
) ? 0
18310 : (reg_size
== AFL_REG_32
) ? 32
18311 : (reg_size
== AFL_REG_64
) ? 64
18312 : (reg_size
== AFL_REG_128
) ? 128
18317 process_mips_specific (Filedata
* filedata
)
18319 Elf_Internal_Dyn
* entry
;
18320 Elf_Internal_Shdr
*sect
= NULL
;
18321 size_t liblist_offset
= 0;
18322 size_t liblistno
= 0;
18323 size_t conflictsno
= 0;
18324 size_t options_offset
= 0;
18325 size_t conflicts_offset
= 0;
18326 size_t pltrelsz
= 0;
18328 uint64_t pltgot
= 0;
18329 uint64_t mips_pltgot
= 0;
18330 uint64_t jmprel
= 0;
18331 uint64_t local_gotno
= 0;
18332 uint64_t gotsym
= 0;
18333 uint64_t symtabno
= 0;
18336 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18337 display_mips_gnu_attribute
))
18340 sect
= find_section (filedata
, ".MIPS.abiflags");
18344 Elf_External_ABIFlags_v0
*abiflags_ext
;
18345 Elf_Internal_ABIFlags_v0 abiflags_in
;
18347 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
18349 error (_("Corrupt MIPS ABI Flags section.\n"));
18354 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
18355 sect
->sh_size
, _("MIPS ABI Flags section"));
18358 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
18359 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
18360 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
18361 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
18362 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
18363 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
18364 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
18365 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
18366 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
18367 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
18368 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
18370 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
18371 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
18372 if (abiflags_in
.isa_rev
> 1)
18373 printf ("r%d", abiflags_in
.isa_rev
);
18374 printf ("\nGPR size: %d",
18375 get_mips_reg_size (abiflags_in
.gpr_size
));
18376 printf ("\nCPR1 size: %d",
18377 get_mips_reg_size (abiflags_in
.cpr1_size
));
18378 printf ("\nCPR2 size: %d",
18379 get_mips_reg_size (abiflags_in
.cpr2_size
));
18380 fputs ("\nFP ABI: ", stdout
);
18381 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
18382 fputs ("ISA Extension: ", stdout
);
18383 print_mips_isa_ext (abiflags_in
.isa_ext
);
18384 fputs ("\nASEs:", stdout
);
18385 print_mips_ases (abiflags_in
.ases
);
18386 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
18387 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
18388 fputc ('\n', stdout
);
18389 free (abiflags_ext
);
18394 /* We have a lot of special sections. Thanks SGI! */
18395 if (filedata
->dynamic_section
== NULL
)
18397 /* No dynamic information available. See if there is static GOT. */
18398 sect
= find_section (filedata
, ".got");
18401 unsigned char *data_end
;
18402 unsigned char *data
;
18406 pltgot
= sect
->sh_addr
;
18409 addr_size
= (is_32bit_elf
? 4 : 8);
18410 end
= pltgot
+ sect
->sh_size
;
18412 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
18414 _("Global Offset Table data"));
18415 /* PR 12855: Null data is handled gracefully throughout. */
18416 data_end
= data
+ (end
- pltgot
);
18418 printf (_("\nStatic GOT:\n"));
18419 printf (_(" Canonical gp value: "));
18420 print_vma (ent
+ 0x7ff0, LONG_HEX
);
18423 /* In a dynamic binary GOT[0] is reserved for the dynamic
18424 loader to store the lazy resolver pointer, however in
18425 a static binary it may well have been omitted and GOT
18426 reduced to a table of addresses.
18427 PR 21344: Check for the entry being fully available
18428 before fetching it. */
18430 && data
+ ent
- pltgot
+ addr_size
<= data_end
18431 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
18433 printf (_(" Reserved entries:\n"));
18434 printf (_(" %*s %10s %*s\n"),
18435 addr_size
* 2, _("Address"), _("Access"),
18436 addr_size
* 2, _("Value"));
18437 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18439 if (ent
== (uint64_t) -1)
18440 goto sgot_print_fail
;
18442 /* Check for the MSB of GOT[1] being set, identifying a
18443 GNU object. This entry will be used by some runtime
18444 loaders, to store the module pointer. Otherwise this
18445 is an ordinary local entry.
18446 PR 21344: Check for the entry being fully available
18447 before fetching it. */
18449 && data
+ ent
- pltgot
+ addr_size
<= data_end
18450 && (byte_get (data
+ ent
- pltgot
, addr_size
)
18451 >> (addr_size
* 8 - 1)) != 0)
18453 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18455 if (ent
== (uint64_t) -1)
18456 goto sgot_print_fail
;
18461 if (data
!= NULL
&& ent
< end
)
18463 printf (_(" Local entries:\n"));
18464 printf (" %*s %10s %*s\n",
18465 addr_size
* 2, _("Address"), _("Access"),
18466 addr_size
* 2, _("Value"));
18469 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18471 if (ent
== (uint64_t) -1)
18472 goto sgot_print_fail
;
18483 for (entry
= filedata
->dynamic_section
;
18484 /* PR 17531 file: 012-50589-0.004. */
18485 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
18486 && entry
->d_tag
!= DT_NULL
);
18488 switch (entry
->d_tag
)
18490 case DT_MIPS_LIBLIST
:
18492 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
18493 liblistno
* sizeof (Elf32_External_Lib
));
18495 case DT_MIPS_LIBLISTNO
:
18496 liblistno
= entry
->d_un
.d_val
;
18498 case DT_MIPS_OPTIONS
:
18499 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
18501 case DT_MIPS_CONFLICT
:
18503 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
18504 conflictsno
* sizeof (Elf32_External_Conflict
));
18506 case DT_MIPS_CONFLICTNO
:
18507 conflictsno
= entry
->d_un
.d_val
;
18510 pltgot
= entry
->d_un
.d_ptr
;
18512 case DT_MIPS_LOCAL_GOTNO
:
18513 local_gotno
= entry
->d_un
.d_val
;
18515 case DT_MIPS_GOTSYM
:
18516 gotsym
= entry
->d_un
.d_val
;
18518 case DT_MIPS_SYMTABNO
:
18519 symtabno
= entry
->d_un
.d_val
;
18521 case DT_MIPS_PLTGOT
:
18522 mips_pltgot
= entry
->d_un
.d_ptr
;
18525 pltrel
= entry
->d_un
.d_val
;
18528 pltrelsz
= entry
->d_un
.d_val
;
18531 jmprel
= entry
->d_un
.d_ptr
;
18537 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
18539 Elf32_External_Lib
* elib
;
18542 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
18543 sizeof (Elf32_External_Lib
),
18545 _("liblist section data"));
18548 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
18549 "\nSection '.liblist' contains %lu entries:\n",
18550 (unsigned long) liblistno
),
18551 (unsigned long) liblistno
);
18552 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
18555 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
18562 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
18563 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
18564 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
18565 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
18566 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
18568 tmp
= gmtime (&atime
);
18569 snprintf (timebuf
, sizeof (timebuf
),
18570 "%04u-%02u-%02uT%02u:%02u:%02u",
18571 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
18572 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
18574 printf ("%3lu: ", (unsigned long) cnt
);
18575 if (valid_dynamic_name (filedata
, liblist
.l_name
))
18576 print_symbol (20, get_dynamic_name (filedata
, liblist
.l_name
));
18578 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
18579 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
18580 liblist
.l_version
);
18582 if (liblist
.l_flags
== 0)
18586 static const struct
18593 { " EXACT_MATCH", LL_EXACT_MATCH
},
18594 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
18595 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
18596 { " EXPORTS", LL_EXPORTS
},
18597 { " DELAY_LOAD", LL_DELAY_LOAD
},
18598 { " DELTA", LL_DELTA
}
18600 int flags
= liblist
.l_flags
;
18603 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
18604 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
18606 fputs (l_flags_vals
[fcnt
].name
, stdout
);
18607 flags
^= l_flags_vals
[fcnt
].bit
;
18610 printf (" %#x", (unsigned int) flags
);
18622 if (options_offset
!= 0)
18624 Elf_External_Options
* eopt
;
18628 /* Find the section header so that we get the size. */
18629 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
18630 /* PR 17533 file: 012-277276-0.004. */
18633 error (_("No MIPS_OPTIONS header found\n"));
18637 if (sect
->sh_size
< sizeof (* eopt
))
18639 error (_("The MIPS options section is too small.\n"));
18643 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
18644 sect
->sh_size
, _("options"));
18647 Elf_Internal_Options option
;
18650 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
18652 Elf_External_Options
* eoption
;
18653 unsigned int optsize
;
18655 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
18657 optsize
= BYTE_GET (eoption
->size
);
18659 /* PR 17531: file: ffa0fa3b. */
18660 if (optsize
< sizeof (* eopt
)
18661 || optsize
> sect
->sh_size
- offset
)
18663 error (_("Invalid size (%u) for MIPS option\n"),
18672 printf (ngettext ("\nSection '%s' contains %d entry:\n",
18673 "\nSection '%s' contains %d entries:\n",
18675 printable_section_name (filedata
, sect
), cnt
);
18681 Elf_External_Options
* eoption
;
18683 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
18685 option
.kind
= BYTE_GET (eoption
->kind
);
18686 option
.size
= BYTE_GET (eoption
->size
);
18687 option
.section
= BYTE_GET (eoption
->section
);
18688 option
.info
= BYTE_GET (eoption
->info
);
18690 switch (option
.kind
)
18693 /* This shouldn't happen. */
18694 printf (" NULL %" PRId16
" %" PRIx32
,
18695 option
.section
, option
.info
);
18699 printf (" REGINFO ");
18700 if (filedata
->file_header
.e_machine
== EM_MIPS
)
18702 Elf32_External_RegInfo
* ereg
;
18703 Elf32_RegInfo reginfo
;
18706 if (option
.size
< (sizeof (Elf_External_Options
)
18707 + sizeof (Elf32_External_RegInfo
)))
18709 printf (_("<corrupt>\n"));
18710 error (_("Truncated MIPS REGINFO option\n"));
18715 ereg
= (Elf32_External_RegInfo
*) (eoption
+ 1);
18717 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
18718 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
18719 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
18720 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
18721 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
18722 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
18724 printf ("GPR %08" PRIx32
" GP 0x%" PRIx32
"\n",
18725 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
18727 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
18728 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
18729 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
18730 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
18735 Elf64_External_RegInfo
* ereg
;
18736 Elf64_Internal_RegInfo reginfo
;
18738 if (option
.size
< (sizeof (Elf_External_Options
)
18739 + sizeof (Elf64_External_RegInfo
)))
18741 printf (_("<corrupt>\n"));
18742 error (_("Truncated MIPS REGINFO option\n"));
18747 ereg
= (Elf64_External_RegInfo
*) (eoption
+ 1);
18748 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
18749 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
18750 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
18751 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
18752 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
18753 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
18755 printf ("GPR %08" PRIx32
" GP 0x%" PRIx64
"\n",
18756 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
18758 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
18759 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
18760 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
18761 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
18763 offset
+= option
.size
;
18766 case ODK_EXCEPTIONS
:
18767 fputs (" EXCEPTIONS fpe_min(", stdout
);
18768 process_mips_fpe_exception (option
.info
& OEX_FPU_MIN
);
18769 fputs (") fpe_max(", stdout
);
18770 process_mips_fpe_exception ((option
.info
& OEX_FPU_MAX
) >> 8);
18771 fputs (")", stdout
);
18773 if (option
.info
& OEX_PAGE0
)
18774 fputs (" PAGE0", stdout
);
18775 if (option
.info
& OEX_SMM
)
18776 fputs (" SMM", stdout
);
18777 if (option
.info
& OEX_FPDBUG
)
18778 fputs (" FPDBUG", stdout
);
18779 if (option
.info
& OEX_DISMISS
)
18780 fputs (" DISMISS", stdout
);
18784 fputs (" PAD ", stdout
);
18785 if (option
.info
& OPAD_PREFIX
)
18786 fputs (" PREFIX", stdout
);
18787 if (option
.info
& OPAD_POSTFIX
)
18788 fputs (" POSTFIX", stdout
);
18789 if (option
.info
& OPAD_SYMBOL
)
18790 fputs (" SYMBOL", stdout
);
18794 fputs (" HWPATCH ", stdout
);
18795 if (option
.info
& OHW_R4KEOP
)
18796 fputs (" R4KEOP", stdout
);
18797 if (option
.info
& OHW_R8KPFETCH
)
18798 fputs (" R8KPFETCH", stdout
);
18799 if (option
.info
& OHW_R5KEOP
)
18800 fputs (" R5KEOP", stdout
);
18801 if (option
.info
& OHW_R5KCVTL
)
18802 fputs (" R5KCVTL", stdout
);
18806 fputs (" FILL ", stdout
);
18807 /* XXX Print content of info word? */
18811 fputs (" TAGS ", stdout
);
18812 /* XXX Print content of info word? */
18816 fputs (" HWAND ", stdout
);
18817 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
18818 fputs (" R4KEOP_CHECKED", stdout
);
18819 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
18820 fputs (" R4KEOP_CLEAN", stdout
);
18824 fputs (" HWOR ", stdout
);
18825 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
18826 fputs (" R4KEOP_CHECKED", stdout
);
18827 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
18828 fputs (" R4KEOP_CLEAN", stdout
);
18832 printf (" GP_GROUP %#06x self-contained %#06x",
18833 option
.info
& OGP_GROUP
,
18834 (option
.info
& OGP_SELF
) >> 16);
18838 printf (" IDENT %#06x self-contained %#06x",
18839 option
.info
& OGP_GROUP
,
18840 (option
.info
& OGP_SELF
) >> 16);
18844 /* This shouldn't happen. */
18845 printf (" %3d ??? %" PRId16
" %" PRIx32
,
18846 option
.kind
, option
.section
, option
.info
);
18850 len
= sizeof (* eopt
);
18851 while (len
< option
.size
)
18853 unsigned char datum
= *((unsigned char *) eoption
+ len
);
18855 if (ISPRINT (datum
))
18856 printf ("%c", datum
);
18858 printf ("\\%03o", datum
);
18861 fputs ("\n", stdout
);
18863 offset
+= option
.size
;
18871 if (conflicts_offset
!= 0 && conflictsno
!= 0)
18873 Elf32_Conflict
* iconf
;
18876 if (filedata
->dynamic_symbols
== NULL
)
18878 error (_("conflict list found without a dynamic symbol table\n"));
18882 /* PR 21345 - print a slightly more helpful error message
18883 if we are sure that the cmalloc will fail. */
18884 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
18886 error (_("Overlarge number of conflicts detected: %lx\n"),
18887 (long) conflictsno
);
18891 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
18894 error (_("Out of memory allocating space for dynamic conflicts\n"));
18900 Elf32_External_Conflict
* econf32
;
18902 econf32
= (Elf32_External_Conflict
*)
18903 get_data (NULL
, filedata
, conflicts_offset
,
18904 sizeof (*econf32
), conflictsno
, _("conflict"));
18911 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18912 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
18918 Elf64_External_Conflict
* econf64
;
18920 econf64
= (Elf64_External_Conflict
*)
18921 get_data (NULL
, filedata
, conflicts_offset
,
18922 sizeof (*econf64
), conflictsno
, _("conflict"));
18929 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18930 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
18935 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
18936 "\nSection '.conflict' contains %lu entries:\n",
18937 (unsigned long) conflictsno
),
18938 (unsigned long) conflictsno
);
18939 puts (_(" Num: Index Value Name"));
18941 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18943 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
18945 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
18946 printf (_("<corrupt symbol index>"));
18949 Elf_Internal_Sym
* psym
;
18951 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
18952 print_vma (psym
->st_value
, FULL_HEX
);
18954 if (valid_dynamic_name (filedata
, psym
->st_name
))
18955 print_symbol (25, get_dynamic_name (filedata
, psym
->st_name
));
18957 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18965 if (pltgot
!= 0 && local_gotno
!= 0)
18967 uint64_t ent
, local_end
, global_end
;
18969 unsigned char * data
;
18970 unsigned char * data_end
;
18974 addr_size
= (is_32bit_elf
? 4 : 8);
18975 local_end
= pltgot
+ local_gotno
* addr_size
;
18977 /* PR binutils/17533 file: 012-111227-0.004 */
18978 if (symtabno
< gotsym
)
18980 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
18981 (unsigned long) gotsym
, (unsigned long) symtabno
);
18985 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
18986 /* PR 17531: file: 54c91a34. */
18987 if (global_end
< local_end
)
18989 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
18993 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
18994 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
18995 global_end
- pltgot
, 1,
18996 _("Global Offset Table data"));
18997 /* PR 12855: Null data is handled gracefully throughout. */
18998 data_end
= data
+ (global_end
- pltgot
);
19000 printf (_("\nPrimary GOT:\n"));
19001 printf (_(" Canonical gp value: "));
19002 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
19005 printf (_(" Reserved entries:\n"));
19006 printf (_(" %*s %10s %*s Purpose\n"),
19007 addr_size
* 2, _("Address"), _("Access"),
19008 addr_size
* 2, _("Initial"));
19009 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19010 printf (_(" Lazy resolver\n"));
19011 if (ent
== (uint64_t) -1)
19012 goto got_print_fail
;
19014 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
19015 This entry will be used by some runtime loaders, to store the
19016 module pointer. Otherwise this is an ordinary local entry.
19017 PR 21344: Check for the entry being fully available before
19020 && data
+ ent
- pltgot
+ addr_size
<= data_end
19021 && (byte_get (data
+ ent
- pltgot
, addr_size
)
19022 >> (addr_size
* 8 - 1)) != 0)
19024 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19025 printf (_(" Module pointer (GNU extension)\n"));
19026 if (ent
== (uint64_t) -1)
19027 goto got_print_fail
;
19031 if (data
!= NULL
&& ent
< local_end
)
19033 printf (_(" Local entries:\n"));
19034 printf (" %*s %10s %*s\n",
19035 addr_size
* 2, _("Address"), _("Access"),
19036 addr_size
* 2, _("Initial"));
19037 while (ent
< local_end
)
19039 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19041 if (ent
== (uint64_t) -1)
19042 goto got_print_fail
;
19047 if (data
!= NULL
&& gotsym
< symtabno
)
19051 printf (_(" Global entries:\n"));
19052 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
19053 addr_size
* 2, _("Address"),
19055 addr_size
* 2, _("Initial"),
19056 addr_size
* 2, _("Sym.Val."),
19058 /* Note for translators: "Ndx" = abbreviated form of "Index". */
19059 _("Ndx"), _("Name"));
19061 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
19063 for (i
= gotsym
; i
< symtabno
; i
++)
19065 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19068 if (filedata
->dynamic_symbols
== NULL
)
19069 printf (_("<no dynamic symbols>"));
19070 else if (i
< filedata
->num_dynamic_syms
)
19072 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
19074 print_vma (psym
->st_value
, LONG_HEX
);
19075 printf (" %-7s %3s ",
19076 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
19077 get_symbol_index_type (filedata
, psym
->st_shndx
));
19079 if (valid_dynamic_name (filedata
, psym
->st_name
))
19080 print_symbol (sym_width
,
19081 get_dynamic_name (filedata
, psym
->st_name
));
19083 printf (_("<corrupt: %14ld>"), psym
->st_name
);
19086 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
19087 (unsigned long) i
);
19090 if (ent
== (uint64_t) -1)
19100 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
19103 size_t offset
, rel_offset
;
19104 unsigned long count
, i
;
19105 unsigned char * data
;
19106 int addr_size
, sym_width
;
19107 Elf_Internal_Rela
* rels
;
19109 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
19110 if (pltrel
== DT_RELA
)
19112 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
19117 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
19122 addr_size
= (is_32bit_elf
? 4 : 8);
19123 end
= mips_pltgot
+ (2 + count
) * addr_size
;
19125 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
19126 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
19127 1, _("Procedure Linkage Table data"));
19134 printf ("\nPLT GOT:\n\n");
19135 printf (_(" Reserved entries:\n"));
19136 printf (_(" %*s %*s Purpose\n"),
19137 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
19138 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
19139 printf (_(" PLT lazy resolver\n"));
19140 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
19141 printf (_(" Module pointer\n"));
19144 printf (_(" Entries:\n"));
19145 printf (" %*s %*s %*s %-7s %3s %s\n",
19146 addr_size
* 2, _("Address"),
19147 addr_size
* 2, _("Initial"),
19148 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
19149 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
19150 for (i
= 0; i
< count
; i
++)
19152 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
19154 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
19157 if (idx
>= filedata
->num_dynamic_syms
)
19158 printf (_("<corrupt symbol index: %lu>"), idx
);
19161 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
19163 print_vma (psym
->st_value
, LONG_HEX
);
19164 printf (" %-7s %3s ",
19165 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
19166 get_symbol_index_type (filedata
, psym
->st_shndx
));
19167 if (valid_dynamic_name (filedata
, psym
->st_name
))
19168 print_symbol (sym_width
,
19169 get_dynamic_name (filedata
, psym
->st_name
));
19171 printf (_("<corrupt: %14ld>"), psym
->st_name
);
19185 process_nds32_specific (Filedata
* filedata
)
19187 Elf_Internal_Shdr
*sect
= NULL
;
19189 sect
= find_section (filedata
, ".nds32_e_flags");
19190 if (sect
!= NULL
&& sect
->sh_size
>= 4)
19192 unsigned char *buf
;
19195 printf ("\nNDS32 elf flags section:\n");
19196 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
19197 _("NDS32 elf flags section"));
19202 flag
= byte_get (buf
, 4);
19204 switch (flag
& 0x3)
19207 printf ("(VEC_SIZE):\tNo entry.\n");
19210 printf ("(VEC_SIZE):\t4 bytes\n");
19213 printf ("(VEC_SIZE):\t16 bytes\n");
19216 printf ("(VEC_SIZE):\treserved\n");
19225 process_gnu_liblist (Filedata
* filedata
)
19227 Elf_Internal_Shdr
* section
;
19228 Elf_Internal_Shdr
* string_sec
;
19229 Elf32_External_Lib
* elib
;
19231 size_t strtab_size
;
19233 unsigned long num_liblist
;
19240 for (i
= 0, section
= filedata
->section_headers
;
19241 i
< filedata
->file_header
.e_shnum
;
19244 switch (section
->sh_type
)
19246 case SHT_GNU_LIBLIST
:
19247 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
19250 elib
= (Elf32_External_Lib
*)
19251 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
19252 _("liblist section data"));
19260 string_sec
= filedata
->section_headers
+ section
->sh_link
;
19261 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
19262 string_sec
->sh_size
,
19263 _("liblist string table"));
19265 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
19272 strtab_size
= string_sec
->sh_size
;
19274 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
19275 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
19276 "\nLibrary list section '%s' contains %lu entries:\n",
19278 printable_section_name (filedata
, section
),
19281 puts (_(" Library Time Stamp Checksum Version Flags"));
19283 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
19291 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
19292 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
19293 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
19294 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
19295 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
19297 tmp
= gmtime (&atime
);
19298 snprintf (timebuf
, sizeof (timebuf
),
19299 "%04u-%02u-%02uT%02u:%02u:%02u",
19300 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
19301 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
19303 printf ("%3lu: ", (unsigned long) cnt
);
19305 printf ("%-20s", liblist
.l_name
< strtab_size
19306 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
19308 printf ("%-20.20s", liblist
.l_name
< strtab_size
19309 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
19310 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
19311 liblist
.l_version
, liblist
.l_flags
);
19322 static const char *
19323 get_note_type (Filedata
* filedata
, unsigned e_type
)
19325 static char buff
[64];
19327 if (filedata
->file_header
.e_type
== ET_CORE
)
19331 return _("NT_AUXV (auxiliary vector)");
19333 return _("NT_PRSTATUS (prstatus structure)");
19335 return _("NT_FPREGSET (floating point registers)");
19337 return _("NT_PRPSINFO (prpsinfo structure)");
19338 case NT_TASKSTRUCT
:
19339 return _("NT_TASKSTRUCT (task structure)");
19341 return _("NT_GDB_TDESC (GDB XML target description)");
19343 return _("NT_PRXFPREG (user_xfpregs structure)");
19345 return _("NT_PPC_VMX (ppc Altivec registers)");
19347 return _("NT_PPC_VSX (ppc VSX registers)");
19349 return _("NT_PPC_TAR (ppc TAR register)");
19351 return _("NT_PPC_PPR (ppc PPR register)");
19353 return _("NT_PPC_DSCR (ppc DSCR register)");
19355 return _("NT_PPC_EBB (ppc EBB registers)");
19357 return _("NT_PPC_PMU (ppc PMU registers)");
19358 case NT_PPC_TM_CGPR
:
19359 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
19360 case NT_PPC_TM_CFPR
:
19361 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
19362 case NT_PPC_TM_CVMX
:
19363 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
19364 case NT_PPC_TM_CVSX
:
19365 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
19366 case NT_PPC_TM_SPR
:
19367 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
19368 case NT_PPC_TM_CTAR
:
19369 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
19370 case NT_PPC_TM_CPPR
:
19371 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
19372 case NT_PPC_TM_CDSCR
:
19373 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
19375 return _("NT_386_TLS (x86 TLS information)");
19376 case NT_386_IOPERM
:
19377 return _("NT_386_IOPERM (x86 I/O permissions)");
19378 case NT_X86_XSTATE
:
19379 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
19381 return _("NT_X86_CET (x86 CET state)");
19382 case NT_S390_HIGH_GPRS
:
19383 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
19384 case NT_S390_TIMER
:
19385 return _("NT_S390_TIMER (s390 timer register)");
19386 case NT_S390_TODCMP
:
19387 return _("NT_S390_TODCMP (s390 TOD comparator register)");
19388 case NT_S390_TODPREG
:
19389 return _("NT_S390_TODPREG (s390 TOD programmable register)");
19391 return _("NT_S390_CTRS (s390 control registers)");
19392 case NT_S390_PREFIX
:
19393 return _("NT_S390_PREFIX (s390 prefix register)");
19394 case NT_S390_LAST_BREAK
:
19395 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
19396 case NT_S390_SYSTEM_CALL
:
19397 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
19399 return _("NT_S390_TDB (s390 transaction diagnostic block)");
19400 case NT_S390_VXRS_LOW
:
19401 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
19402 case NT_S390_VXRS_HIGH
:
19403 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
19404 case NT_S390_GS_CB
:
19405 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
19406 case NT_S390_GS_BC
:
19407 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
19409 return _("NT_ARM_VFP (arm VFP registers)");
19411 return _("NT_ARM_TLS (AArch TLS registers)");
19412 case NT_ARM_HW_BREAK
:
19413 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
19414 case NT_ARM_HW_WATCH
:
19415 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
19416 case NT_ARM_SYSTEM_CALL
:
19417 return _("NT_ARM_SYSTEM_CALL (AArch system call number)");
19419 return _("NT_ARM_SVE (AArch SVE registers)");
19420 case NT_ARM_PAC_MASK
:
19421 return _("NT_ARM_PAC_MASK (AArch pointer authentication code masks)");
19422 case NT_ARM_PACA_KEYS
:
19423 return _("NT_ARM_PACA_KEYS (ARM pointer authentication address keys)");
19424 case NT_ARM_PACG_KEYS
:
19425 return _("NT_ARM_PACG_KEYS (ARM pointer authentication generic keys)");
19426 case NT_ARM_TAGGED_ADDR_CTRL
:
19427 return _("NT_ARM_TAGGED_ADDR_CTRL (AArch tagged address control)");
19428 case NT_ARM_PAC_ENABLED_KEYS
:
19429 return _("NT_ARM_PAC_ENABLED_KEYS (AArch64 pointer authentication enabled keys)");
19431 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
19433 return _("NT_RISCV_CSR (RISC-V control and status registers)");
19435 return _("NT_PSTATUS (pstatus structure)");
19437 return _("NT_FPREGS (floating point registers)");
19439 return _("NT_PSINFO (psinfo structure)");
19441 return _("NT_LWPSTATUS (lwpstatus_t structure)");
19443 return _("NT_LWPSINFO (lwpsinfo_t structure)");
19444 case NT_WIN32PSTATUS
:
19445 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
19447 return _("NT_SIGINFO (siginfo_t data)");
19449 return _("NT_FILE (mapped files)");
19457 return _("NT_VERSION (version)");
19459 return _("NT_ARCH (architecture)");
19460 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
19462 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
19464 case NT_GO_BUILDID
:
19465 return _("GO BUILDID");
19466 case FDO_PACKAGING_METADATA
:
19467 return _("FDO_PACKAGING_METADATA");
19472 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19477 print_core_note (Elf_Internal_Note
*pnote
)
19479 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
19480 uint64_t count
, page_size
;
19481 unsigned char *descdata
, *filenames
, *descend
;
19483 if (pnote
->type
!= NT_FILE
)
19492 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
19493 /* Still "successful". */
19497 if (pnote
->descsz
< 2 * addr_size
)
19499 error (_(" Malformed note - too short for header\n"));
19503 descdata
= (unsigned char *) pnote
->descdata
;
19504 descend
= descdata
+ pnote
->descsz
;
19506 if (descdata
[pnote
->descsz
- 1] != '\0')
19508 error (_(" Malformed note - does not end with \\0\n"));
19512 count
= byte_get (descdata
, addr_size
);
19513 descdata
+= addr_size
;
19515 page_size
= byte_get (descdata
, addr_size
);
19516 descdata
+= addr_size
;
19518 if (count
> ((uint64_t) -1 - 2 * addr_size
) / (3 * addr_size
)
19519 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
19521 error (_(" Malformed note - too short for supplied file count\n"));
19525 printf (_(" Page size: "));
19526 print_vma (page_size
, DEC
);
19529 printf (_(" %*s%*s%*s\n"),
19530 (int) (2 + 2 * addr_size
), _("Start"),
19531 (int) (4 + 2 * addr_size
), _("End"),
19532 (int) (4 + 2 * addr_size
), _("Page Offset"));
19533 filenames
= descdata
+ count
* 3 * addr_size
;
19534 while (count
-- > 0)
19536 uint64_t start
, end
, file_ofs
;
19538 if (filenames
== descend
)
19540 error (_(" Malformed note - filenames end too early\n"));
19544 start
= byte_get (descdata
, addr_size
);
19545 descdata
+= addr_size
;
19546 end
= byte_get (descdata
, addr_size
);
19547 descdata
+= addr_size
;
19548 file_ofs
= byte_get (descdata
, addr_size
);
19549 descdata
+= addr_size
;
19552 print_vma (start
, FULL_HEX
);
19554 print_vma (end
, FULL_HEX
);
19556 print_vma (file_ofs
, FULL_HEX
);
19557 printf ("\n %s\n", filenames
);
19559 filenames
+= 1 + strlen ((char *) filenames
);
19565 static const char *
19566 get_gnu_elf_note_type (unsigned e_type
)
19568 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
19571 case NT_GNU_ABI_TAG
:
19572 return _("NT_GNU_ABI_TAG (ABI version tag)");
19574 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
19575 case NT_GNU_BUILD_ID
:
19576 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
19577 case NT_GNU_GOLD_VERSION
:
19578 return _("NT_GNU_GOLD_VERSION (gold version)");
19579 case NT_GNU_PROPERTY_TYPE_0
:
19580 return _("NT_GNU_PROPERTY_TYPE_0");
19581 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
19582 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
19583 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
19584 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
19587 static char buff
[64];
19589 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19596 decode_x86_compat_isa (unsigned int bitmask
)
19600 unsigned int bit
= bitmask
& (- bitmask
);
19605 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
19608 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
19611 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
19614 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
19617 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
19620 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
19623 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
19626 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
19629 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
19632 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
19635 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
19638 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
19639 printf ("AVX512F");
19641 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
19642 printf ("AVX512CD");
19644 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
19645 printf ("AVX512ER");
19647 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
19648 printf ("AVX512PF");
19650 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
19651 printf ("AVX512VL");
19653 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
19654 printf ("AVX512DQ");
19656 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
19657 printf ("AVX512BW");
19660 printf (_("<unknown: %x>"), bit
);
19669 decode_x86_compat_2_isa (unsigned int bitmask
)
19673 printf (_("<None>"));
19679 unsigned int bit
= bitmask
& (- bitmask
);
19684 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_CMOV
:
19687 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE
:
19690 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE2
:
19693 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE3
:
19696 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSSE3
:
19699 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_1
:
19702 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_2
:
19705 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX
:
19708 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX2
:
19711 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_FMA
:
19714 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512F
:
19715 printf ("AVX512F");
19717 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512CD
:
19718 printf ("AVX512CD");
19720 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512ER
:
19721 printf ("AVX512ER");
19723 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512PF
:
19724 printf ("AVX512PF");
19726 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512VL
:
19727 printf ("AVX512VL");
19729 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512DQ
:
19730 printf ("AVX512DQ");
19732 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512BW
:
19733 printf ("AVX512BW");
19735 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4FMAPS
:
19736 printf ("AVX512_4FMAPS");
19738 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4VNNIW
:
19739 printf ("AVX512_4VNNIW");
19741 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BITALG
:
19742 printf ("AVX512_BITALG");
19744 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_IFMA
:
19745 printf ("AVX512_IFMA");
19747 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI
:
19748 printf ("AVX512_VBMI");
19750 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI2
:
19751 printf ("AVX512_VBMI2");
19753 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VNNI
:
19754 printf ("AVX512_VNNI");
19756 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BF16
:
19757 printf ("AVX512_BF16");
19760 printf (_("<unknown: %x>"), bit
);
19768 static const char *
19769 get_amdgpu_elf_note_type (unsigned int e_type
)
19773 case NT_AMDGPU_METADATA
:
19774 return _("NT_AMDGPU_METADATA (code object metadata)");
19777 static char buf
[64];
19778 snprintf (buf
, sizeof (buf
), _("Unknown note type: (0x%08x)"), e_type
);
19785 decode_x86_isa (unsigned int bitmask
)
19789 unsigned int bit
= bitmask
& (- bitmask
);
19794 case GNU_PROPERTY_X86_ISA_1_BASELINE
:
19795 printf ("x86-64-baseline");
19797 case GNU_PROPERTY_X86_ISA_1_V2
:
19798 printf ("x86-64-v2");
19800 case GNU_PROPERTY_X86_ISA_1_V3
:
19801 printf ("x86-64-v3");
19803 case GNU_PROPERTY_X86_ISA_1_V4
:
19804 printf ("x86-64-v4");
19807 printf (_("<unknown: %x>"), bit
);
19816 decode_x86_feature_1 (unsigned int bitmask
)
19820 printf (_("<None>"));
19826 unsigned int bit
= bitmask
& (- bitmask
);
19831 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
19834 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
19837 case GNU_PROPERTY_X86_FEATURE_1_LAM_U48
:
19838 printf ("LAM_U48");
19840 case GNU_PROPERTY_X86_FEATURE_1_LAM_U57
:
19841 printf ("LAM_U57");
19844 printf (_("<unknown: %x>"), bit
);
19853 decode_x86_feature_2 (unsigned int bitmask
)
19857 printf (_("<None>"));
19863 unsigned int bit
= bitmask
& (- bitmask
);
19868 case GNU_PROPERTY_X86_FEATURE_2_X86
:
19871 case GNU_PROPERTY_X86_FEATURE_2_X87
:
19874 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
19877 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
19880 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
19883 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
19886 case GNU_PROPERTY_X86_FEATURE_2_TMM
:
19889 case GNU_PROPERTY_X86_FEATURE_2_MASK
:
19892 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
19895 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
19898 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
19899 printf ("XSAVEOPT");
19901 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
19905 printf (_("<unknown: %x>"), bit
);
19914 decode_aarch64_feature_1_and (unsigned int bitmask
)
19918 unsigned int bit
= bitmask
& (- bitmask
);
19923 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
19927 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
19932 printf (_("<unknown: %x>"), bit
);
19941 decode_1_needed (unsigned int bitmask
)
19945 unsigned int bit
= bitmask
& (- bitmask
);
19950 case GNU_PROPERTY_1_NEEDED_INDIRECT_EXTERN_ACCESS
:
19951 printf ("indirect external access");
19954 printf (_("<unknown: %x>"), bit
);
19963 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
19965 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
19966 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
19967 unsigned int size
= is_32bit_elf
? 4 : 8;
19969 printf (_(" Properties: "));
19971 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
19973 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
19977 while (ptr
< ptr_end
)
19981 unsigned int datasz
;
19983 if ((size_t) (ptr_end
- ptr
) < 8)
19985 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
19989 type
= byte_get (ptr
, 4);
19990 datasz
= byte_get (ptr
+ 4, 4);
19994 if (datasz
> (size_t) (ptr_end
- ptr
))
19996 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
20001 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
20003 if (filedata
->file_header
.e_machine
== EM_X86_64
20004 || filedata
->file_header
.e_machine
== EM_IAMCU
20005 || filedata
->file_header
.e_machine
== EM_386
)
20007 unsigned int bitmask
;
20010 bitmask
= byte_get (ptr
, 4);
20016 case GNU_PROPERTY_X86_ISA_1_USED
:
20018 printf (_("x86 ISA used: <corrupt length: %#x> "),
20022 printf ("x86 ISA used: ");
20023 decode_x86_isa (bitmask
);
20027 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
20029 printf (_("x86 ISA needed: <corrupt length: %#x> "),
20033 printf ("x86 ISA needed: ");
20034 decode_x86_isa (bitmask
);
20038 case GNU_PROPERTY_X86_FEATURE_1_AND
:
20040 printf (_("x86 feature: <corrupt length: %#x> "),
20044 printf ("x86 feature: ");
20045 decode_x86_feature_1 (bitmask
);
20049 case GNU_PROPERTY_X86_FEATURE_2_USED
:
20051 printf (_("x86 feature used: <corrupt length: %#x> "),
20055 printf ("x86 feature used: ");
20056 decode_x86_feature_2 (bitmask
);
20060 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
20062 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
20065 printf ("x86 feature needed: ");
20066 decode_x86_feature_2 (bitmask
);
20070 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
20072 printf (_("x86 ISA used: <corrupt length: %#x> "),
20076 printf ("x86 ISA used: ");
20077 decode_x86_compat_isa (bitmask
);
20081 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
20083 printf (_("x86 ISA needed: <corrupt length: %#x> "),
20087 printf ("x86 ISA needed: ");
20088 decode_x86_compat_isa (bitmask
);
20092 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_USED
:
20094 printf (_("x86 ISA used: <corrupt length: %#x> "),
20098 printf ("x86 ISA used: ");
20099 decode_x86_compat_2_isa (bitmask
);
20103 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_NEEDED
:
20105 printf (_("x86 ISA needed: <corrupt length: %#x> "),
20109 printf ("x86 ISA needed: ");
20110 decode_x86_compat_2_isa (bitmask
);
20118 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
20120 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
20122 printf ("AArch64 feature: ");
20124 printf (_("<corrupt length: %#x> "), datasz
);
20126 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
20135 case GNU_PROPERTY_STACK_SIZE
:
20136 printf (_("stack size: "));
20137 if (datasz
!= size
)
20138 printf (_("<corrupt length: %#x> "), datasz
);
20140 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
20143 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
20144 printf ("no copy on protected ");
20146 printf (_("<corrupt length: %#x> "), datasz
);
20150 if ((type
>= GNU_PROPERTY_UINT32_AND_LO
20151 && type
<= GNU_PROPERTY_UINT32_AND_HI
)
20152 || (type
>= GNU_PROPERTY_UINT32_OR_LO
20153 && type
<= GNU_PROPERTY_UINT32_OR_HI
))
20157 case GNU_PROPERTY_1_NEEDED
:
20159 printf (_("1_needed: <corrupt length: %#x> "),
20163 unsigned int bitmask
= byte_get (ptr
, 4);
20164 printf ("1_needed: ");
20165 decode_1_needed (bitmask
);
20172 if (type
<= GNU_PROPERTY_UINT32_AND_HI
)
20173 printf (_("UINT32_AND (%#x): "), type
);
20175 printf (_("UINT32_OR (%#x): "), type
);
20177 printf (_("<corrupt length: %#x> "), datasz
);
20179 printf ("%#x", (unsigned int) byte_get (ptr
, 4));
20186 if (type
< GNU_PROPERTY_LOPROC
)
20187 printf (_("<unknown type %#x data: "), type
);
20188 else if (type
< GNU_PROPERTY_LOUSER
)
20189 printf (_("<processor-specific type %#x data: "), type
);
20191 printf (_("<application-specific type %#x data: "), type
);
20192 for (j
= 0; j
< datasz
; ++j
)
20193 printf ("%02x ", ptr
[j
] & 0xff);
20197 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
20198 if (ptr
== ptr_end
)
20211 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
20213 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
20214 switch (pnote
->type
)
20216 case NT_GNU_BUILD_ID
:
20220 printf (_(" Build ID: "));
20221 for (i
= 0; i
< pnote
->descsz
; ++i
)
20222 printf ("%02x", pnote
->descdata
[i
] & 0xff);
20227 case NT_GNU_ABI_TAG
:
20229 unsigned long os
, major
, minor
, subminor
;
20230 const char *osname
;
20232 /* PR 17531: file: 030-599401-0.004. */
20233 if (pnote
->descsz
< 16)
20235 printf (_(" <corrupt GNU_ABI_TAG>\n"));
20239 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20240 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
20241 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
20242 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
20246 case GNU_ABI_TAG_LINUX
:
20249 case GNU_ABI_TAG_HURD
:
20252 case GNU_ABI_TAG_SOLARIS
:
20253 osname
= "Solaris";
20255 case GNU_ABI_TAG_FREEBSD
:
20256 osname
= "FreeBSD";
20258 case GNU_ABI_TAG_NETBSD
:
20261 case GNU_ABI_TAG_SYLLABLE
:
20262 osname
= "Syllable";
20264 case GNU_ABI_TAG_NACL
:
20268 osname
= "Unknown";
20272 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
20273 major
, minor
, subminor
);
20277 case NT_GNU_GOLD_VERSION
:
20281 printf (_(" Version: "));
20282 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
20283 printf ("%c", pnote
->descdata
[i
]);
20290 unsigned long num_entries
, mask
;
20292 /* Hardware capabilities information. Word 0 is the number of entries.
20293 Word 1 is a bitmask of enabled entries. The rest of the descriptor
20294 is a series of entries, where each entry is a single byte followed
20295 by a nul terminated string. The byte gives the bit number to test
20296 if enabled in the bitmask. */
20297 printf (_(" Hardware Capabilities: "));
20298 if (pnote
->descsz
< 8)
20300 error (_("<corrupt GNU_HWCAP>\n"));
20303 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20304 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
20305 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
20306 /* FIXME: Add code to display the entries... */
20310 case NT_GNU_PROPERTY_TYPE_0
:
20311 print_gnu_property_note (filedata
, pnote
);
20315 /* Handle unrecognised types. An error message should have already been
20316 created by get_gnu_elf_note_type(), so all that we need to do is to
20317 display the data. */
20321 printf (_(" Description data: "));
20322 for (i
= 0; i
< pnote
->descsz
; ++i
)
20323 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
20332 static const char *
20333 get_v850_elf_note_type (enum v850_notes n_type
)
20335 static char buff
[64];
20339 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
20340 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
20341 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
20342 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
20343 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
20344 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
20346 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
20352 print_v850_note (Elf_Internal_Note
* pnote
)
20356 if (pnote
->descsz
!= 4)
20359 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
20363 printf (_("not set\n"));
20367 switch (pnote
->type
)
20369 case V850_NOTE_ALIGNMENT
:
20372 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return true;
20373 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return true;
20377 case V850_NOTE_DATA_SIZE
:
20380 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return true;
20381 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return true;
20385 case V850_NOTE_FPU_INFO
:
20388 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return true;
20389 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return true;
20393 case V850_NOTE_MMU_INFO
:
20394 case V850_NOTE_CACHE_INFO
:
20395 case V850_NOTE_SIMD_INFO
:
20396 if (val
== EF_RH850_SIMD
)
20398 printf (_("yes\n"));
20404 /* An 'unknown note type' message will already have been displayed. */
20408 printf (_("unknown value: %x\n"), val
);
20413 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
20415 unsigned int version
;
20417 switch (pnote
->type
)
20419 case NT_NETBSD_IDENT
:
20420 if (pnote
->descsz
< 1)
20422 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
20423 if ((version
/ 10000) % 100)
20424 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
20425 version
, version
/ 100000000, (version
/ 1000000) % 100,
20426 (version
/ 10000) % 100 > 26 ? "Z" : "",
20427 'A' + (version
/ 10000) % 26);
20429 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
20430 version
, version
/ 100000000, (version
/ 1000000) % 100,
20431 (version
/ 100) % 100);
20434 case NT_NETBSD_MARCH
:
20435 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
20439 case NT_NETBSD_PAX
:
20440 if (pnote
->descsz
< 1)
20442 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
20443 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
20444 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
20445 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
20446 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
20447 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
20448 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
20449 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
20453 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
20454 pnote
->descsz
, pnote
->type
);
20458 static const char *
20459 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
20463 case NT_FREEBSD_THRMISC
:
20464 return _("NT_THRMISC (thrmisc structure)");
20465 case NT_FREEBSD_PROCSTAT_PROC
:
20466 return _("NT_PROCSTAT_PROC (proc data)");
20467 case NT_FREEBSD_PROCSTAT_FILES
:
20468 return _("NT_PROCSTAT_FILES (files data)");
20469 case NT_FREEBSD_PROCSTAT_VMMAP
:
20470 return _("NT_PROCSTAT_VMMAP (vmmap data)");
20471 case NT_FREEBSD_PROCSTAT_GROUPS
:
20472 return _("NT_PROCSTAT_GROUPS (groups data)");
20473 case NT_FREEBSD_PROCSTAT_UMASK
:
20474 return _("NT_PROCSTAT_UMASK (umask data)");
20475 case NT_FREEBSD_PROCSTAT_RLIMIT
:
20476 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
20477 case NT_FREEBSD_PROCSTAT_OSREL
:
20478 return _("NT_PROCSTAT_OSREL (osreldate data)");
20479 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
20480 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
20481 case NT_FREEBSD_PROCSTAT_AUXV
:
20482 return _("NT_PROCSTAT_AUXV (auxv data)");
20483 case NT_FREEBSD_PTLWPINFO
:
20484 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
20485 case NT_FREEBSD_X86_SEGBASES
:
20486 return _("NT_X86_SEGBASES (x86 segment base registers)");
20488 return get_note_type (filedata
, e_type
);
20491 static const char *
20492 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
20494 static char buff
[64];
20498 case NT_NETBSDCORE_PROCINFO
:
20499 /* NetBSD core "procinfo" structure. */
20500 return _("NetBSD procinfo structure");
20502 case NT_NETBSDCORE_AUXV
:
20503 return _("NetBSD ELF auxiliary vector data");
20505 case NT_NETBSDCORE_LWPSTATUS
:
20506 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
20509 /* As of Jan 2020 there are no other machine-independent notes
20510 defined for NetBSD core files. If the note type is less
20511 than the start of the machine-dependent note types, we don't
20514 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
20516 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
20522 switch (filedata
->file_header
.e_machine
)
20524 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
20525 and PT_GETFPREGS == mach+2. */
20530 case EM_SPARC32PLUS
:
20534 case NT_NETBSDCORE_FIRSTMACH
+ 0:
20535 return _("PT_GETREGS (reg structure)");
20536 case NT_NETBSDCORE_FIRSTMACH
+ 2:
20537 return _("PT_GETFPREGS (fpreg structure)");
20543 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
20544 There's also old PT___GETREGS40 == mach + 1 for old reg
20545 structure which lacks GBR. */
20549 case NT_NETBSDCORE_FIRSTMACH
+ 1:
20550 return _("PT___GETREGS40 (old reg structure)");
20551 case NT_NETBSDCORE_FIRSTMACH
+ 3:
20552 return _("PT_GETREGS (reg structure)");
20553 case NT_NETBSDCORE_FIRSTMACH
+ 5:
20554 return _("PT_GETFPREGS (fpreg structure)");
20560 /* On all other arch's, PT_GETREGS == mach+1 and
20561 PT_GETFPREGS == mach+3. */
20565 case NT_NETBSDCORE_FIRSTMACH
+ 1:
20566 return _("PT_GETREGS (reg structure)");
20567 case NT_NETBSDCORE_FIRSTMACH
+ 3:
20568 return _("PT_GETFPREGS (fpreg structure)");
20574 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
20575 e_type
- NT_NETBSDCORE_FIRSTMACH
);
20579 static const char *
20580 get_openbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
20584 case NT_OPENBSD_PROCINFO
:
20585 return _("OpenBSD procinfo structure");
20586 case NT_OPENBSD_AUXV
:
20587 return _("OpenBSD ELF auxiliary vector data");
20588 case NT_OPENBSD_REGS
:
20589 return _("OpenBSD regular registers");
20590 case NT_OPENBSD_FPREGS
:
20591 return _("OpenBSD floating point registers");
20592 case NT_OPENBSD_WCOOKIE
:
20593 return _("OpenBSD window cookie");
20596 return get_note_type (filedata
, e_type
);
20599 static const char *
20600 get_stapsdt_note_type (unsigned e_type
)
20602 static char buff
[64];
20607 return _("NT_STAPSDT (SystemTap probe descriptors)");
20613 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
20618 print_stapsdt_note (Elf_Internal_Note
*pnote
)
20620 size_t len
, maxlen
;
20621 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
20622 char *data
= pnote
->descdata
;
20623 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
20624 uint64_t pc
, base_addr
, semaphore
;
20625 char *provider
, *probe
, *arg_fmt
;
20627 if (pnote
->descsz
< (addr_size
* 3))
20628 goto stapdt_note_too_small
;
20630 pc
= byte_get ((unsigned char *) data
, addr_size
);
20633 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
20636 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
20639 if (data
>= data_end
)
20640 goto stapdt_note_too_small
;
20641 maxlen
= data_end
- data
;
20642 len
= strnlen (data
, maxlen
);
20649 goto stapdt_note_too_small
;
20651 if (data
>= data_end
)
20652 goto stapdt_note_too_small
;
20653 maxlen
= data_end
- data
;
20654 len
= strnlen (data
, maxlen
);
20661 goto stapdt_note_too_small
;
20663 if (data
>= data_end
)
20664 goto stapdt_note_too_small
;
20665 maxlen
= data_end
- data
;
20666 len
= strnlen (data
, maxlen
);
20673 goto stapdt_note_too_small
;
20675 printf (_(" Provider: %s\n"), provider
);
20676 printf (_(" Name: %s\n"), probe
);
20677 printf (_(" Location: "));
20678 print_vma (pc
, FULL_HEX
);
20679 printf (_(", Base: "));
20680 print_vma (base_addr
, FULL_HEX
);
20681 printf (_(", Semaphore: "));
20682 print_vma (semaphore
, FULL_HEX
);
20684 printf (_(" Arguments: %s\n"), arg_fmt
);
20686 return data
== data_end
;
20688 stapdt_note_too_small
:
20689 printf (_(" <corrupt - note is too small>\n"));
20690 error (_("corrupt stapdt note - the data size is too small\n"));
20695 print_fdo_note (Elf_Internal_Note
* pnote
)
20697 if (pnote
->descsz
> 0 && pnote
->type
== FDO_PACKAGING_METADATA
)
20699 printf (_(" Packaging Metadata: %.*s\n"), (int) pnote
->descsz
, pnote
->descdata
);
20705 static const char *
20706 get_ia64_vms_note_type (unsigned e_type
)
20708 static char buff
[64];
20713 return _("NT_VMS_MHD (module header)");
20715 return _("NT_VMS_LNM (language name)");
20717 return _("NT_VMS_SRC (source files)");
20719 return "NT_VMS_TITLE";
20721 return _("NT_VMS_EIDC (consistency check)");
20722 case NT_VMS_FPMODE
:
20723 return _("NT_VMS_FPMODE (FP mode)");
20724 case NT_VMS_LINKTIME
:
20725 return "NT_VMS_LINKTIME";
20726 case NT_VMS_IMGNAM
:
20727 return _("NT_VMS_IMGNAM (image name)");
20729 return _("NT_VMS_IMGID (image id)");
20730 case NT_VMS_LINKID
:
20731 return _("NT_VMS_LINKID (link id)");
20732 case NT_VMS_IMGBID
:
20733 return _("NT_VMS_IMGBID (build id)");
20734 case NT_VMS_GSTNAM
:
20735 return _("NT_VMS_GSTNAM (sym table name)");
20736 case NT_VMS_ORIG_DYN
:
20737 return "NT_VMS_ORIG_DYN";
20738 case NT_VMS_PATCHTIME
:
20739 return "NT_VMS_PATCHTIME";
20741 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
20747 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
20749 int maxlen
= pnote
->descsz
;
20751 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
20752 goto desc_size_fail
;
20754 switch (pnote
->type
)
20758 goto desc_size_fail
;
20760 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
20762 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
20763 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
20764 if (l
+ 34 < maxlen
)
20766 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
20767 if (l
+ 35 < maxlen
)
20768 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
20770 printf (_(" Module version : <missing>\n"));
20774 printf (_(" Module name : <missing>\n"));
20775 printf (_(" Module version : <missing>\n"));
20780 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
20783 case NT_VMS_FPMODE
:
20784 printf (_(" Floating Point mode: "));
20786 goto desc_size_fail
;
20787 /* FIXME: Generate an error if descsz > 8 ? */
20789 printf ("0x%016" PRIx64
"\n",
20790 byte_get ((unsigned char *) pnote
->descdata
, 8));
20793 case NT_VMS_LINKTIME
:
20794 printf (_(" Link time: "));
20796 goto desc_size_fail
;
20797 /* FIXME: Generate an error if descsz > 8 ? */
20799 print_vms_time (byte_get ((unsigned char *) pnote
->descdata
, 8));
20803 case NT_VMS_PATCHTIME
:
20804 printf (_(" Patch time: "));
20806 goto desc_size_fail
;
20807 /* FIXME: Generate an error if descsz > 8 ? */
20809 print_vms_time (byte_get ((unsigned char *) pnote
->descdata
, 8));
20813 case NT_VMS_ORIG_DYN
:
20815 goto desc_size_fail
;
20817 printf (_(" Major id: %u, minor id: %u\n"),
20818 (unsigned) byte_get ((unsigned char *) pnote
->descdata
, 4),
20819 (unsigned) byte_get ((unsigned char *) pnote
->descdata
+ 4, 4));
20820 printf (_(" Last modified : "));
20821 print_vms_time (byte_get ((unsigned char *) pnote
->descdata
+ 8, 8));
20822 printf (_("\n Link flags : "));
20823 printf ("0x%016" PRIx64
"\n",
20824 byte_get ((unsigned char *) pnote
->descdata
+ 16, 8));
20825 printf (_(" Header flags: 0x%08x\n"),
20826 (unsigned) byte_get ((unsigned char *) pnote
->descdata
+ 24, 4));
20827 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
20830 case NT_VMS_IMGNAM
:
20831 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
20834 case NT_VMS_GSTNAM
:
20835 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
20839 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
20842 case NT_VMS_LINKID
:
20843 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
20853 printf (_(" <corrupt - data size is too small>\n"));
20854 error (_("corrupt IA64 note: data size is too small\n"));
20858 struct build_attr_cache
{
20859 Filedata
*filedata
;
20861 unsigned long strtablen
;
20862 Elf_Internal_Sym
*symtab
;
20863 unsigned long nsyms
;
20866 /* Find the symbol associated with a build attribute that is attached
20867 to address OFFSET. If PNAME is non-NULL then store the name of
20868 the symbol (if found) in the provided pointer, Returns NULL if a
20869 symbol could not be found. */
20871 static Elf_Internal_Sym
*
20872 get_symbol_for_build_attribute (Filedata
*filedata
,
20873 unsigned long offset
,
20875 const char **pname
)
20877 Elf_Internal_Sym
*saved_sym
= NULL
;
20878 Elf_Internal_Sym
*sym
;
20880 if (filedata
->section_headers
!= NULL
20881 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
20883 Elf_Internal_Shdr
* symsec
;
20885 free (ba_cache
.strtab
);
20886 ba_cache
.strtab
= NULL
;
20887 free (ba_cache
.symtab
);
20888 ba_cache
.symtab
= NULL
;
20890 /* Load the symbol and string sections. */
20891 for (symsec
= filedata
->section_headers
;
20892 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
20895 if (symsec
->sh_type
== SHT_SYMTAB
20896 && get_symtab (filedata
, symsec
,
20897 &ba_cache
.symtab
, &ba_cache
.nsyms
,
20898 &ba_cache
.strtab
, &ba_cache
.strtablen
))
20901 ba_cache
.filedata
= filedata
;
20904 if (ba_cache
.symtab
== NULL
)
20907 /* Find a symbol whose value matches offset. */
20908 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
20909 if (sym
->st_value
== offset
)
20911 if (sym
->st_name
>= ba_cache
.strtablen
)
20912 /* Huh ? This should not happen. */
20915 if (ba_cache
.strtab
[sym
->st_name
] == 0)
20918 /* The AArch64, ARM and RISC-V architectures define mapping symbols
20919 (eg $d, $x, $t) which we want to ignore. */
20920 if (ba_cache
.strtab
[sym
->st_name
] == '$'
20921 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
20922 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
20927 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
20928 and FILE or OBJECT symbols over NOTYPE symbols. We skip
20929 FUNC symbols entirely. */
20930 switch (ELF_ST_TYPE (sym
->st_info
))
20937 /* If the symbol has a size associated
20938 with it then we can stop searching. */
20939 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
20944 /* Ignore function symbols. */
20951 switch (ELF_ST_BIND (sym
->st_info
))
20954 if (saved_sym
== NULL
20955 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
20960 if (saved_sym
== NULL
)
20970 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
20978 if (saved_sym
&& pname
)
20979 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
20984 /* Returns true iff addr1 and addr2 are in the same section. */
20987 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
20989 Elf_Internal_Shdr
* a1
;
20990 Elf_Internal_Shdr
* a2
;
20992 a1
= find_section_by_address (filedata
, addr1
);
20993 a2
= find_section_by_address (filedata
, addr2
);
20995 return a1
== a2
&& a1
!= NULL
;
20999 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
21000 Filedata
* filedata
)
21002 static unsigned long global_offset
= 0;
21003 static unsigned long global_end
= 0;
21004 static unsigned long func_offset
= 0;
21005 static unsigned long func_end
= 0;
21007 Elf_Internal_Sym
*sym
;
21009 unsigned long start
;
21011 bool is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
21013 switch (pnote
->descsz
)
21016 /* A zero-length description means that the range of
21017 the previous note of the same type should be used. */
21020 if (global_end
> global_offset
)
21021 printf (_(" Applies to region from %#lx to %#lx\n"),
21022 global_offset
, global_end
);
21024 printf (_(" Applies to region from %#lx\n"), global_offset
);
21028 if (func_end
> func_offset
)
21029 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
21031 printf (_(" Applies to region from %#lx\n"), func_offset
);
21036 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
21041 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
21042 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
21046 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
21047 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
21051 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
21052 printf (_(" <invalid descsz>"));
21057 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
21058 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
21059 in order to avoid them being confused with the start address of the
21060 first function in the file... */
21061 if (sym
== NULL
&& is_open_attr
)
21062 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
21065 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
21066 end
= start
+ sym
->st_size
;
21070 /* FIXME: Need to properly allow for section alignment.
21071 16 is just the alignment used on x86_64. */
21073 && start
> BFD_ALIGN (global_end
, 16)
21074 /* Build notes are not guaranteed to be organised in order of
21075 increasing address, but we should find the all of the notes
21076 for one section in the same place. */
21077 && same_section (filedata
, start
, global_end
))
21078 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
21079 global_end
+ 1, start
- 1);
21081 printf (_(" Applies to region from %#lx"), start
);
21082 global_offset
= start
;
21086 printf (_(" to %#lx"), end
);
21092 printf (_(" Applies to region from %#lx"), start
);
21093 func_offset
= start
;
21097 printf (_(" to %#lx"), end
);
21103 printf (_(" (%s)"), name
);
21110 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
21112 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
21113 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
21114 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
21116 char name_attribute
;
21117 const char * expected_types
;
21118 const char * name
= pnote
->namedata
;
21122 if (name
== NULL
|| pnote
->namesz
< 2)
21124 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
21125 print_symbol (-20, _(" <corrupt name>"));
21134 /* Version 2 of the spec adds a "GA" prefix to the name field. */
21135 if (name
[0] == 'G' && name
[1] == 'A')
21137 if (pnote
->namesz
< 4)
21139 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
21140 print_symbol (-20, _(" <corrupt name>"));
21149 switch ((name_type
= * name
))
21151 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
21152 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
21153 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
21154 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
21155 printf ("%c", * name
);
21159 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
21160 print_symbol (-20, _("<unknown name type>"));
21167 switch ((name_attribute
= * name
))
21169 case GNU_BUILD_ATTRIBUTE_VERSION
:
21170 text
= _("<version>");
21171 expected_types
= string_expected
;
21174 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
21175 text
= _("<stack prot>");
21176 expected_types
= "!+*";
21179 case GNU_BUILD_ATTRIBUTE_RELRO
:
21180 text
= _("<relro>");
21181 expected_types
= bool_expected
;
21184 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
21185 text
= _("<stack size>");
21186 expected_types
= number_expected
;
21189 case GNU_BUILD_ATTRIBUTE_TOOL
:
21190 text
= _("<tool>");
21191 expected_types
= string_expected
;
21194 case GNU_BUILD_ATTRIBUTE_ABI
:
21196 expected_types
= "$*";
21199 case GNU_BUILD_ATTRIBUTE_PIC
:
21201 expected_types
= number_expected
;
21204 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
21205 text
= _("<short enum>");
21206 expected_types
= bool_expected
;
21210 if (ISPRINT (* name
))
21212 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
21214 if (len
> left
&& ! do_wide
)
21216 printf ("%.*s:", len
, name
);
21222 static char tmpbuf
[128];
21224 error (_("unrecognised byte in name field: %d\n"), * name
);
21225 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
21229 expected_types
= "*$!+";
21234 left
-= printf ("%s", text
);
21236 if (strchr (expected_types
, name_type
) == NULL
)
21237 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
21239 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
21241 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
21242 (unsigned long) pnote
->namesz
,
21243 (long) (name
- pnote
->namedata
));
21247 if (left
< 1 && ! do_wide
)
21252 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
21254 unsigned int bytes
;
21255 unsigned long long val
= 0;
21256 unsigned int shift
= 0;
21257 char * decoded
= NULL
;
21259 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
21261 /* The -1 is because the name field is always 0 terminated, and we
21262 want to be able to ensure that the shift in the while loop below
21263 will not overflow. */
21266 if (bytes
> sizeof (val
))
21268 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
21270 bytes
= sizeof (val
);
21272 /* We do not bother to warn if bytes == 0 as this can
21273 happen with some early versions of the gcc plugin. */
21277 unsigned long long byte
= *name
++ & 0xff;
21279 val
|= byte
<< shift
;
21283 switch (name_attribute
)
21285 case GNU_BUILD_ATTRIBUTE_PIC
:
21288 case 0: decoded
= "static"; break;
21289 case 1: decoded
= "pic"; break;
21290 case 2: decoded
= "PIC"; break;
21291 case 3: decoded
= "pie"; break;
21292 case 4: decoded
= "PIE"; break;
21296 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
21299 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
21300 case 0: decoded
= "off"; break;
21301 case 1: decoded
= "on"; break;
21302 case 2: decoded
= "all"; break;
21303 case 3: decoded
= "strong"; break;
21304 case 4: decoded
= "explicit"; break;
21312 if (decoded
!= NULL
)
21314 print_symbol (-left
, decoded
);
21325 left
-= printf ("0x%llx", val
);
21327 left
-= printf ("0x%-.*llx", left
, val
);
21331 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
21332 left
-= print_symbol (- left
, name
);
21334 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
21335 left
-= print_symbol (- left
, "true");
21337 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
21338 left
-= print_symbol (- left
, "false");
21342 if (do_wide
&& left
> 0)
21343 printf ("%-*s", left
, " ");
21348 /* Print the contents of PNOTE as hex. */
21351 print_note_contents_hex (Elf_Internal_Note
*pnote
)
21357 printf (_(" description data: "));
21358 for (i
= 0; i
< pnote
->descsz
; i
++)
21359 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
21368 #if defined HAVE_MSGPACK
21371 print_indents (int n
)
21375 for (int i
= 0; i
< n
; i
++)
21379 /* Print OBJ in human-readable form. */
21382 dump_msgpack_obj (const msgpack_object
*obj
, int indent
)
21386 case MSGPACK_OBJECT_NIL
:
21390 case MSGPACK_OBJECT_BOOLEAN
:
21391 printf ("%s", obj
->via
.boolean
? "true" : "false");
21394 case MSGPACK_OBJECT_POSITIVE_INTEGER
:
21395 printf ("%" PRIu64
, obj
->via
.u64
);
21398 case MSGPACK_OBJECT_NEGATIVE_INTEGER
:
21399 printf ("%" PRIi64
, obj
->via
.i64
);
21402 case MSGPACK_OBJECT_FLOAT32
:
21403 case MSGPACK_OBJECT_FLOAT64
:
21404 printf ("%f", obj
->via
.f64
);
21407 case MSGPACK_OBJECT_STR
:
21408 printf ("\"%.*s\"", obj
->via
.str
.size
, obj
->via
.str
.ptr
);
21411 case MSGPACK_OBJECT_ARRAY
:
21413 const msgpack_object_array
*array
= &obj
->via
.array
;
21418 for (uint32_t i
= 0; i
< array
->size
; ++i
)
21420 const msgpack_object
*item
= &array
->ptr
[i
];
21422 print_indents (indent
);
21423 dump_msgpack_obj (item
, indent
);
21428 print_indents (indent
);
21434 case MSGPACK_OBJECT_MAP
:
21436 const msgpack_object_map
*map
= &obj
->via
.map
;
21441 for (uint32_t i
= 0; i
< map
->size
; ++i
)
21443 const msgpack_object_kv
*kv
= &map
->ptr
[i
];
21444 const msgpack_object
*key
= &kv
->key
;
21445 const msgpack_object
*val
= &kv
->val
;
21447 print_indents (indent
);
21448 dump_msgpack_obj (key
, indent
);
21450 dump_msgpack_obj (val
, indent
);
21456 print_indents (indent
);
21462 case MSGPACK_OBJECT_BIN
:
21466 case MSGPACK_OBJECT_EXT
:
21473 dump_msgpack (const msgpack_unpacked
*msg
)
21476 dump_msgpack_obj (&msg
->data
, 0);
21480 #endif /* defined HAVE_MSGPACK */
21483 print_amdgpu_note (Elf_Internal_Note
*pnote
)
21485 #if defined HAVE_MSGPACK
21486 /* If msgpack is available, decode and dump the note's content. */
21488 msgpack_unpacked msg
;
21489 msgpack_unpack_return msgpack_ret
;
21491 assert (pnote
->type
== NT_AMDGPU_METADATA
);
21493 msgpack_unpacked_init (&msg
);
21494 msgpack_ret
= msgpack_unpack_next (&msg
, pnote
->descdata
, pnote
->descsz
,
21497 switch (msgpack_ret
)
21499 case MSGPACK_UNPACK_SUCCESS
:
21500 dump_msgpack (&msg
);
21505 error (_("failed to unpack msgpack contents in NT_AMDGPU_METADATA note"));
21510 msgpack_unpacked_destroy (&msg
);
21513 /* msgpack is not available, dump contents as hex. */
21514 print_note_contents_hex (pnote
);
21519 /* Note that by the ELF standard, the name field is already null byte
21520 terminated, and namesz includes the terminating null byte.
21521 I.E. the value of namesz for the name "FSF" is 4.
21523 If the value of namesz is zero, there is no name present. */
21526 process_note (Elf_Internal_Note
* pnote
,
21527 Filedata
* filedata
)
21529 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
21532 if (pnote
->namesz
== 0)
21533 /* If there is no note name, then use the default set of
21534 note type strings. */
21535 nt
= get_note_type (filedata
, pnote
->type
);
21537 else if (startswith (pnote
->namedata
, "GNU"))
21538 /* GNU-specific object file notes. */
21539 nt
= get_gnu_elf_note_type (pnote
->type
);
21541 else if (startswith (pnote
->namedata
, "AMDGPU"))
21542 /* AMDGPU-specific object file notes. */
21543 nt
= get_amdgpu_elf_note_type (pnote
->type
);
21545 else if (startswith (pnote
->namedata
, "FreeBSD"))
21546 /* FreeBSD-specific core file notes. */
21547 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
21549 else if (startswith (pnote
->namedata
, "NetBSD-CORE"))
21550 /* NetBSD-specific core file notes. */
21551 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
21553 else if (startswith (pnote
->namedata
, "NetBSD"))
21554 /* NetBSD-specific core file notes. */
21555 return process_netbsd_elf_note (pnote
);
21557 else if (startswith (pnote
->namedata
, "PaX"))
21558 /* NetBSD-specific core file notes. */
21559 return process_netbsd_elf_note (pnote
);
21561 else if (startswith (pnote
->namedata
, "OpenBSD"))
21562 /* OpenBSD-specific core file notes. */
21563 nt
= get_openbsd_elfcore_note_type (filedata
, pnote
->type
);
21565 else if (startswith (pnote
->namedata
, "SPU/"))
21567 /* SPU-specific core file notes. */
21568 nt
= pnote
->namedata
+ 4;
21572 else if (startswith (pnote
->namedata
, "IPF/VMS"))
21573 /* VMS/ia64-specific file notes. */
21574 nt
= get_ia64_vms_note_type (pnote
->type
);
21576 else if (startswith (pnote
->namedata
, "stapsdt"))
21577 nt
= get_stapsdt_note_type (pnote
->type
);
21580 /* Don't recognize this note name; just use the default set of
21581 note type strings. */
21582 nt
= get_note_type (filedata
, pnote
->type
);
21586 if (((startswith (pnote
->namedata
, "GA")
21587 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
21588 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
21589 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
21590 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
21591 print_gnu_build_attribute_name (pnote
);
21593 print_symbol (-20, name
);
21596 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
21598 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
21600 if (startswith (pnote
->namedata
, "IPF/VMS"))
21601 return print_ia64_vms_note (pnote
);
21602 else if (startswith (pnote
->namedata
, "GNU"))
21603 return print_gnu_note (filedata
, pnote
);
21604 else if (startswith (pnote
->namedata
, "stapsdt"))
21605 return print_stapsdt_note (pnote
);
21606 else if (startswith (pnote
->namedata
, "CORE"))
21607 return print_core_note (pnote
);
21608 else if (startswith (pnote
->namedata
, "FDO"))
21609 return print_fdo_note (pnote
);
21610 else if (((startswith (pnote
->namedata
, "GA")
21611 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
21612 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
21613 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
21614 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
21615 return print_gnu_build_attribute_description (pnote
, filedata
);
21616 else if (startswith (pnote
->namedata
, "AMDGPU")
21617 && pnote
->type
== NT_AMDGPU_METADATA
)
21618 return print_amdgpu_note (pnote
);
21620 print_note_contents_hex (pnote
);
21625 process_notes_at (Filedata
* filedata
,
21626 Elf_Internal_Shdr
* section
,
21631 Elf_External_Note
*pnotes
;
21632 Elf_External_Note
*external
;
21641 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
21644 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
21652 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
21655 if (pnotes
== NULL
)
21660 if (filedata
->is_separate
)
21661 printf (_("In linked file '%s': "), filedata
->file_name
);
21665 printf (_("Displaying notes found in: %s\n"), printable_section_name (filedata
, section
));
21667 printf (_("Displaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
21668 (unsigned long) offset
, (unsigned long) length
);
21670 /* NB: Some note sections may have alignment value of 0 or 1. gABI
21671 specifies that notes should be aligned to 4 bytes in 32-bit
21672 objects and to 8 bytes in 64-bit objects. As a Linux extension,
21673 we also support 4 byte alignment in 64-bit objects. If section
21674 alignment is less than 4, we treate alignment as 4 bytes. */
21677 else if (align
!= 4 && align
!= 8)
21679 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
21685 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
21687 end
= (char *) pnotes
+ length
;
21688 while ((char *) external
< end
)
21690 Elf_Internal_Note inote
;
21693 char * temp
= NULL
;
21694 size_t data_remaining
= end
- (char *) external
;
21696 if (!is_ia64_vms (filedata
))
21698 /* PR binutils/15191
21699 Make sure that there is enough data to read. */
21700 min_notesz
= offsetof (Elf_External_Note
, name
);
21701 if (data_remaining
< min_notesz
)
21703 warn (ngettext ("Corrupt note: only %ld byte remains, "
21704 "not enough for a full note\n",
21705 "Corrupt note: only %ld bytes remain, "
21706 "not enough for a full note\n",
21708 (long) data_remaining
);
21711 data_remaining
-= min_notesz
;
21713 inote
.type
= BYTE_GET (external
->type
);
21714 inote
.namesz
= BYTE_GET (external
->namesz
);
21715 inote
.namedata
= external
->name
;
21716 inote
.descsz
= BYTE_GET (external
->descsz
);
21717 inote
.descdata
= ((char *) external
21718 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
21719 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
21720 next
= ((char *) external
21721 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
21725 Elf64_External_VMS_Note
*vms_external
;
21727 /* PR binutils/15191
21728 Make sure that there is enough data to read. */
21729 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
21730 if (data_remaining
< min_notesz
)
21732 warn (ngettext ("Corrupt note: only %ld byte remains, "
21733 "not enough for a full note\n",
21734 "Corrupt note: only %ld bytes remain, "
21735 "not enough for a full note\n",
21737 (long) data_remaining
);
21740 data_remaining
-= min_notesz
;
21742 vms_external
= (Elf64_External_VMS_Note
*) external
;
21743 inote
.type
= BYTE_GET (vms_external
->type
);
21744 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
21745 inote
.namedata
= vms_external
->name
;
21746 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
21747 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
21748 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
21749 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
21752 /* PR 17531: file: 3443835e. */
21753 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
21754 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
21755 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
21756 || (size_t) (next
- inote
.descdata
) < inote
.descsz
21757 || ((size_t) (next
- inote
.descdata
)
21758 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
21760 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
21761 (unsigned long) ((char *) external
- (char *) pnotes
));
21762 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
21763 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
21767 external
= (Elf_External_Note
*) next
;
21769 /* Verify that name is null terminated. It appears that at least
21770 one version of Linux (RedHat 6.0) generates corefiles that don't
21771 comply with the ELF spec by failing to include the null byte in
21773 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
21775 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
21777 temp
= (char *) malloc (inote
.namesz
+ 1);
21780 error (_("Out of memory allocating space for inote name\n"));
21785 memcpy (temp
, inote
.namedata
, inote
.namesz
);
21786 inote
.namedata
= temp
;
21788 inote
.namedata
[inote
.namesz
] = 0;
21791 if (! process_note (& inote
, filedata
))
21804 process_corefile_note_segments (Filedata
* filedata
)
21806 Elf_Internal_Phdr
*segment
;
21810 if (! get_program_headers (filedata
))
21813 for (i
= 0, segment
= filedata
->program_headers
;
21814 i
< filedata
->file_header
.e_phnum
;
21817 if (segment
->p_type
== PT_NOTE
)
21818 if (! process_notes_at (filedata
, NULL
, segment
->p_offset
,
21819 segment
->p_filesz
, segment
->p_align
))
21827 process_v850_notes (Filedata
* filedata
, uint64_t offset
, uint64_t length
)
21829 Elf_External_Note
* pnotes
;
21830 Elf_External_Note
* external
;
21837 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
21839 if (pnotes
== NULL
)
21843 end
= (char*) pnotes
+ length
;
21845 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
21846 (unsigned long) offset
, (unsigned long) length
);
21848 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
21850 Elf_External_Note
* next
;
21851 Elf_Internal_Note inote
;
21853 inote
.type
= BYTE_GET (external
->type
);
21854 inote
.namesz
= BYTE_GET (external
->namesz
);
21855 inote
.namedata
= external
->name
;
21856 inote
.descsz
= BYTE_GET (external
->descsz
);
21857 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
21858 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
21860 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
21862 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
21863 inote
.descdata
= inote
.namedata
;
21867 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
21869 if ( ((char *) next
> end
)
21870 || ((char *) next
< (char *) pnotes
))
21872 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
21873 (unsigned long) ((char *) external
- (char *) pnotes
));
21874 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
21875 inote
.type
, inote
.namesz
, inote
.descsz
);
21881 /* Prevent out-of-bounds indexing. */
21882 if ( inote
.namedata
+ inote
.namesz
> end
21883 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
21885 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
21886 (unsigned long) ((char *) external
- (char *) pnotes
));
21887 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
21888 inote
.type
, inote
.namesz
, inote
.descsz
);
21892 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
21894 if (! print_v850_note (& inote
))
21897 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
21898 inote
.namesz
, inote
.descsz
);
21908 process_note_sections (Filedata
* filedata
)
21910 Elf_Internal_Shdr
*section
;
21912 unsigned int n
= 0;
21915 for (i
= 0, section
= filedata
->section_headers
;
21916 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
21919 if (section
->sh_type
== SHT_NOTE
)
21921 if (! process_notes_at (filedata
, section
, section
->sh_offset
,
21922 section
->sh_size
, section
->sh_addralign
))
21927 if (( filedata
->file_header
.e_machine
== EM_V800
21928 || filedata
->file_header
.e_machine
== EM_V850
21929 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
21930 && section
->sh_type
== SHT_RENESAS_INFO
)
21932 if (! process_v850_notes (filedata
, section
->sh_offset
,
21940 /* Try processing NOTE segments instead. */
21941 return process_corefile_note_segments (filedata
);
21947 process_notes (Filedata
* filedata
)
21949 /* If we have not been asked to display the notes then do nothing. */
21953 if (filedata
->file_header
.e_type
!= ET_CORE
)
21954 return process_note_sections (filedata
);
21956 /* No program headers means no NOTE segment. */
21957 if (filedata
->file_header
.e_phnum
> 0)
21958 return process_corefile_note_segments (filedata
);
21960 if (filedata
->is_separate
)
21961 printf (_("No notes found in linked file '%s'.\n"),
21962 filedata
->file_name
);
21964 printf (_("No notes found file.\n"));
21969 static unsigned char *
21970 display_public_gnu_attributes (unsigned char * start
,
21971 const unsigned char * const end
)
21973 printf (_(" Unknown GNU attribute: %s\n"), start
);
21975 start
+= strnlen ((char *) start
, end
- start
);
21976 display_raw_attribute (start
, end
);
21978 return (unsigned char *) end
;
21981 static unsigned char *
21982 display_generic_attribute (unsigned char * start
,
21984 const unsigned char * const end
)
21987 return (unsigned char *) end
;
21989 return display_tag_value (tag
, start
, end
);
21993 process_arch_specific (Filedata
* filedata
)
21998 switch (filedata
->file_header
.e_machine
)
22001 case EM_ARC_COMPACT
:
22002 case EM_ARC_COMPACT2
:
22003 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
22004 display_arc_attribute
,
22005 display_generic_attribute
);
22007 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
22008 display_arm_attribute
,
22009 display_generic_attribute
);
22012 case EM_MIPS_RS3_LE
:
22013 return process_mips_specific (filedata
);
22016 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
22017 display_msp430_attribute
,
22018 display_msp430_gnu_attribute
);
22021 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
22022 display_riscv_attribute
,
22023 display_generic_attribute
);
22026 return process_nds32_specific (filedata
);
22029 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22030 display_m68k_gnu_attribute
);
22034 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22035 display_power_gnu_attribute
);
22039 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22040 display_s390_gnu_attribute
);
22043 case EM_SPARC32PLUS
:
22045 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22046 display_sparc_gnu_attribute
);
22049 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
22050 display_tic6x_attribute
,
22051 display_generic_attribute
);
22054 return process_attributes (filedata
, "csky", SHT_CSKY_ATTRIBUTES
,
22055 display_csky_attribute
, NULL
);
22058 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
22059 display_public_gnu_attributes
,
22060 display_generic_attribute
);
22065 get_file_header (Filedata
* filedata
)
22067 /* Read in the identity array. */
22068 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
22071 /* Determine how to read the rest of the header. */
22072 switch (filedata
->file_header
.e_ident
[EI_DATA
])
22077 byte_get
= byte_get_little_endian
;
22078 byte_put
= byte_put_little_endian
;
22081 byte_get
= byte_get_big_endian
;
22082 byte_put
= byte_put_big_endian
;
22086 /* For now we only support 32 bit and 64 bit ELF files. */
22087 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
22089 /* Read in the rest of the header. */
22092 Elf32_External_Ehdr ehdr32
;
22094 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
22097 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
22098 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
22099 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
22100 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
22101 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
22102 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
22103 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
22104 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
22105 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
22106 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
22107 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
22108 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
22109 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
22113 Elf64_External_Ehdr ehdr64
;
22115 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
22118 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
22119 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
22120 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
22121 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
22122 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
22123 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
22124 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
22125 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
22126 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
22127 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
22128 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
22129 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
22130 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
22137 free_filedata (Filedata
*filedata
)
22139 free (filedata
->program_interpreter
);
22140 free (filedata
->program_headers
);
22141 free (filedata
->section_headers
);
22142 free (filedata
->string_table
);
22143 free (filedata
->dump
.dump_sects
);
22144 free (filedata
->dynamic_strings
);
22145 free (filedata
->dynamic_symbols
);
22146 free (filedata
->dynamic_syminfo
);
22147 free (filedata
->dynamic_section
);
22149 while (filedata
->symtab_shndx_list
!= NULL
)
22151 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
22152 free (filedata
->symtab_shndx_list
);
22153 filedata
->symtab_shndx_list
= next
;
22156 free (filedata
->section_headers_groups
);
22158 if (filedata
->section_groups
)
22161 struct group_list
* g
;
22162 struct group_list
* next
;
22164 for (i
= 0; i
< filedata
->group_count
; i
++)
22166 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
22173 free (filedata
->section_groups
);
22175 memset (&filedata
->section_headers
, 0,
22176 sizeof (Filedata
) - offsetof (Filedata
, section_headers
));
22180 close_file (Filedata
* filedata
)
22184 if (filedata
->handle
)
22185 fclose (filedata
->handle
);
22191 close_debug_file (void * data
)
22193 free_filedata ((Filedata
*) data
);
22194 close_file ((Filedata
*) data
);
22198 open_file (const char * pathname
, bool is_separate
)
22200 struct stat statbuf
;
22201 Filedata
* filedata
= NULL
;
22203 if (stat (pathname
, & statbuf
) < 0
22204 || ! S_ISREG (statbuf
.st_mode
))
22207 filedata
= calloc (1, sizeof * filedata
);
22208 if (filedata
== NULL
)
22211 filedata
->handle
= fopen (pathname
, "rb");
22212 if (filedata
->handle
== NULL
)
22215 filedata
->file_size
= statbuf
.st_size
;
22216 filedata
->file_name
= pathname
;
22217 filedata
->is_separate
= is_separate
;
22219 if (! get_file_header (filedata
))
22222 if (!get_section_headers (filedata
, false))
22230 if (filedata
->handle
)
22231 fclose (filedata
->handle
);
22238 open_debug_file (const char * pathname
)
22240 return open_file (pathname
, true);
22244 initialise_dump_sects (Filedata
* filedata
)
22246 /* Initialise the dump_sects array from the cmdline_dump_sects array.
22247 Note we do this even if cmdline_dump_sects is empty because we
22248 must make sure that the dump_sets array is zeroed out before each
22249 object file is processed. */
22250 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
22251 memset (filedata
->dump
.dump_sects
, 0,
22252 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
22254 if (cmdline
.num_dump_sects
> 0)
22256 if (filedata
->dump
.num_dump_sects
== 0)
22257 /* A sneaky way of allocating the dump_sects array. */
22258 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
22260 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
22261 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
22262 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
22267 might_need_separate_debug_info (Filedata
* filedata
)
22269 /* Debuginfo files do not need further separate file loading. */
22270 if (filedata
->file_header
.e_shstrndx
== SHN_UNDEF
)
22273 /* Since do_follow_links might be enabled by default, only treat it as an
22274 indication that separate files should be loaded if setting it was a
22275 deliberate user action. */
22276 if (DEFAULT_FOR_FOLLOW_LINKS
== 0 && do_follow_links
)
22279 if (process_links
|| do_syms
|| do_unwind
22280 || dump_any_debugging
|| do_dump
|| do_debugging
)
22286 /* Process one ELF object file according to the command line options.
22287 This file may actually be stored in an archive. The file is
22288 positioned at the start of the ELF object. Returns TRUE if no
22289 problems were encountered, FALSE otherwise. */
22292 process_object (Filedata
* filedata
)
22294 bool have_separate_files
;
22298 if (! get_file_header (filedata
))
22300 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
22304 /* Initialise per file variables. */
22305 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
22306 filedata
->version_info
[i
] = 0;
22308 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
22309 filedata
->dynamic_info
[i
] = 0;
22310 filedata
->dynamic_info_DT_GNU_HASH
= 0;
22311 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
22313 /* Process the file. */
22315 printf (_("\nFile: %s\n"), filedata
->file_name
);
22317 initialise_dump_sects (filedata
);
22319 /* There may be some extensions in the first section header. Don't
22320 bomb if we can't read it. */
22321 get_section_headers (filedata
, true);
22323 if (! process_file_header (filedata
))
22329 /* Throw away the single section header read above, so that we
22330 re-read the entire set. */
22331 free (filedata
->section_headers
);
22332 filedata
->section_headers
= NULL
;
22334 if (! process_section_headers (filedata
))
22336 /* Without loaded section headers we cannot process lots of things. */
22337 do_unwind
= do_version
= do_dump
= do_arch
= false;
22339 if (! do_using_dynamic
)
22340 do_syms
= do_dyn_syms
= do_reloc
= false;
22343 if (! process_section_groups (filedata
))
22344 /* Without loaded section groups we cannot process unwind. */
22347 process_program_headers (filedata
);
22349 res
= process_dynamic_section (filedata
);
22351 if (! process_relocs (filedata
))
22354 if (! process_unwind (filedata
))
22357 if (! process_symbol_table (filedata
))
22360 if (! process_lto_symbol_tables (filedata
))
22363 if (! process_syminfo (filedata
))
22366 if (! process_version_sections (filedata
))
22369 if (might_need_separate_debug_info (filedata
))
22370 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
22372 have_separate_files
= false;
22374 if (! process_section_contents (filedata
))
22377 if (have_separate_files
)
22381 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
22383 initialise_dump_sects (d
->handle
);
22385 if (process_links
&& ! process_file_header (d
->handle
))
22387 else if (! process_section_headers (d
->handle
))
22389 else if (! process_section_contents (d
->handle
))
22391 else if (process_links
)
22393 if (! process_section_groups (d
->handle
))
22395 process_program_headers (d
->handle
);
22396 if (! process_dynamic_section (d
->handle
))
22398 if (! process_relocs (d
->handle
))
22400 if (! process_unwind (d
->handle
))
22402 if (! process_symbol_table (d
->handle
))
22404 if (! process_lto_symbol_tables (d
->handle
))
22406 if (! process_syminfo (d
->handle
))
22408 if (! process_version_sections (d
->handle
))
22410 if (! process_notes (d
->handle
))
22415 /* The file handles are closed by the call to free_debug_memory() below. */
22418 if (! process_notes (filedata
))
22421 if (! process_gnu_liblist (filedata
))
22424 if (! process_arch_specific (filedata
))
22428 free_filedata (filedata
);
22430 free_debug_memory ();
22435 /* Process an ELF archive.
22436 On entry the file is positioned just after the ARMAG string.
22437 Returns TRUE upon success, FALSE otherwise. */
22440 process_archive (Filedata
* filedata
, bool is_thin_archive
)
22442 struct archive_info arch
;
22443 struct archive_info nested_arch
;
22449 /* The ARCH structure is used to hold information about this archive. */
22450 arch
.file_name
= NULL
;
22452 arch
.index_array
= NULL
;
22453 arch
.sym_table
= NULL
;
22454 arch
.longnames
= NULL
;
22456 /* The NESTED_ARCH structure is used as a single-item cache of information
22457 about a nested archive (when members of a thin archive reside within
22458 another regular archive file). */
22459 nested_arch
.file_name
= NULL
;
22460 nested_arch
.file
= NULL
;
22461 nested_arch
.index_array
= NULL
;
22462 nested_arch
.sym_table
= NULL
;
22463 nested_arch
.longnames
= NULL
;
22465 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
22466 filedata
->file_size
, is_thin_archive
,
22467 do_archive_index
) != 0)
22473 if (do_archive_index
)
22475 if (arch
.sym_table
== NULL
)
22476 error (_("%s: unable to dump the index as none was found\n"),
22477 filedata
->file_name
);
22480 unsigned long i
, l
;
22481 unsigned long current_pos
;
22483 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
22484 "in the symbol table)\n"),
22485 filedata
->file_name
, (unsigned long) arch
.index_num
,
22488 current_pos
= ftell (filedata
->handle
);
22490 for (i
= l
= 0; i
< arch
.index_num
; i
++)
22493 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
22496 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
22499 if (member_name
!= NULL
)
22501 char * qualified_name
22502 = make_qualified_name (&arch
, &nested_arch
,
22505 if (qualified_name
!= NULL
)
22507 printf (_("Contents of binary %s at offset "),
22509 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
22511 free (qualified_name
);
22513 free (member_name
);
22517 if (l
>= arch
.sym_size
)
22519 error (_("%s: end of the symbol table reached "
22520 "before the end of the index\n"),
22521 filedata
->file_name
);
22525 /* PR 17531: file: 0b6630b2. */
22526 printf ("\t%.*s\n",
22527 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
22528 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
22531 if (arch
.uses_64bit_indices
)
22536 if (l
< arch
.sym_size
)
22538 error (ngettext ("%s: %ld byte remains in the symbol table, "
22539 "but without corresponding entries in "
22540 "the index table\n",
22541 "%s: %ld bytes remain in the symbol table, "
22542 "but without corresponding entries in "
22543 "the index table\n",
22544 arch
.sym_size
- l
),
22545 filedata
->file_name
, arch
.sym_size
- l
);
22549 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
22551 error (_("%s: failed to seek back to start of object files "
22552 "in the archive\n"),
22553 filedata
->file_name
);
22559 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
22560 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
22561 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
22562 && !do_section_groups
&& !do_dyn_syms
)
22564 ret
= true; /* Archive index only. */
22573 char * qualified_name
;
22575 /* Read the next archive header. */
22576 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
22578 error (_("%s: failed to seek to next archive header\n"),
22583 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
22584 if (got
!= sizeof arch
.arhdr
)
22588 /* PR 24049 - we cannot use filedata->file_name as this will
22589 have already been freed. */
22590 error (_("%s: failed to read archive header\n"), arch
.file_name
);
22595 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
22597 error (_("%s: did not find a valid archive header\n"),
22603 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
22605 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
22607 name
= get_archive_member_name (&arch
, &nested_arch
);
22610 error (_("%s: bad archive file name\n"), arch
.file_name
);
22614 namelen
= strlen (name
);
22616 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
22617 if (qualified_name
== NULL
)
22619 error (_("%s: bad archive file name\n"), arch
.file_name
);
22625 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
22627 /* This is a proxy for an external member of a thin archive. */
22628 Filedata
* member_filedata
;
22629 char * member_file_name
= adjust_relative_path
22630 (filedata
->file_name
, name
, namelen
);
22633 if (member_file_name
== NULL
)
22635 free (qualified_name
);
22640 member_filedata
= open_file (member_file_name
, false);
22641 if (member_filedata
== NULL
)
22643 error (_("Input file '%s' is not readable.\n"), member_file_name
);
22644 free (member_file_name
);
22645 free (qualified_name
);
22650 filedata
->archive_file_offset
= arch
.nested_member_origin
;
22651 member_filedata
->file_name
= qualified_name
;
22653 /* The call to process_object() expects the file to be at the beginning. */
22654 rewind (member_filedata
->handle
);
22656 if (! process_object (member_filedata
))
22659 close_file (member_filedata
);
22660 free (member_file_name
);
22662 else if (is_thin_archive
)
22664 Filedata thin_filedata
;
22666 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
22668 /* PR 15140: Allow for corrupt thin archives. */
22669 if (nested_arch
.file
== NULL
)
22671 error (_("%s: contains corrupt thin archive: %s\n"),
22672 qualified_name
, name
);
22673 free (qualified_name
);
22680 /* This is a proxy for a member of a nested archive. */
22681 filedata
->archive_file_offset
22682 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
22684 /* The nested archive file will have been opened and setup by
22685 get_archive_member_name. */
22686 if (fseek (nested_arch
.file
, filedata
->archive_file_offset
,
22689 error (_("%s: failed to seek to archive member.\n"),
22690 nested_arch
.file_name
);
22691 free (qualified_name
);
22696 thin_filedata
.handle
= nested_arch
.file
;
22697 thin_filedata
.file_name
= qualified_name
;
22699 if (! process_object (& thin_filedata
))
22705 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
22706 filedata
->file_name
= qualified_name
;
22707 if (! process_object (filedata
))
22709 arch
.next_arhdr_offset
+= (filedata
->archive_file_size
+ 1) & -2;
22710 /* Stop looping with "negative" archive_file_size. */
22711 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
22712 arch
.next_arhdr_offset
= -1ul;
22715 free (qualified_name
);
22719 if (nested_arch
.file
!= NULL
)
22720 fclose (nested_arch
.file
);
22721 release_archive (&nested_arch
);
22722 release_archive (&arch
);
22728 process_file (char * file_name
)
22730 Filedata
* filedata
= NULL
;
22731 struct stat statbuf
;
22732 char armag
[SARMAG
];
22735 if (stat (file_name
, &statbuf
) < 0)
22737 if (errno
== ENOENT
)
22738 error (_("'%s': No such file\n"), file_name
);
22740 error (_("Could not locate '%s'. System error message: %s\n"),
22741 file_name
, strerror (errno
));
22745 if (! S_ISREG (statbuf
.st_mode
))
22747 error (_("'%s' is not an ordinary file\n"), file_name
);
22751 filedata
= calloc (1, sizeof * filedata
);
22752 if (filedata
== NULL
)
22754 error (_("Out of memory allocating file data structure\n"));
22758 filedata
->file_name
= file_name
;
22759 filedata
->handle
= fopen (file_name
, "rb");
22760 if (filedata
->handle
== NULL
)
22762 error (_("Input file '%s' is not readable.\n"), file_name
);
22767 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
22769 error (_("%s: Failed to read file's magic number\n"), file_name
);
22770 fclose (filedata
->handle
);
22775 filedata
->file_size
= statbuf
.st_size
;
22776 filedata
->is_separate
= false;
22778 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
22780 if (! process_archive (filedata
, false))
22783 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
22785 if ( ! process_archive (filedata
, true))
22790 if (do_archive_index
&& !check_all
)
22791 error (_("File %s is not an archive so its index cannot be displayed.\n"),
22794 rewind (filedata
->handle
);
22795 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
22797 if (! process_object (filedata
))
22801 fclose (filedata
->handle
);
22802 free (filedata
->section_headers
);
22803 free (filedata
->program_headers
);
22804 free (filedata
->string_table
);
22805 free (filedata
->dump
.dump_sects
);
22808 free (ba_cache
.strtab
);
22809 ba_cache
.strtab
= NULL
;
22810 free (ba_cache
.symtab
);
22811 ba_cache
.symtab
= NULL
;
22812 ba_cache
.filedata
= NULL
;
22817 #ifdef SUPPORT_DISASSEMBLY
22818 /* Needed by the i386 disassembler. For extra credit, someone could
22819 fix this so that we insert symbolic addresses here, esp for GOT/PLT
22823 print_address (unsigned int addr
, FILE * outfile
)
22825 fprintf (outfile
,"0x%8.8x", addr
);
22828 /* Needed by the i386 disassembler. */
22831 db_task_printsym (unsigned int addr
)
22833 print_address (addr
, stderr
);
22838 main (int argc
, char ** argv
)
22842 #ifdef HAVE_LC_MESSAGES
22843 setlocale (LC_MESSAGES
, "");
22845 setlocale (LC_CTYPE
, "");
22846 bindtextdomain (PACKAGE
, LOCALEDIR
);
22847 textdomain (PACKAGE
);
22849 expandargv (&argc
, &argv
);
22851 parse_args (& cmdline
, argc
, argv
);
22853 if (optind
< (argc
- 1))
22854 /* When displaying information for more than one file,
22855 prefix the information with the file name. */
22857 else if (optind
>= argc
)
22859 /* Ensure that the warning is always displayed. */
22862 warn (_("Nothing to do.\n"));
22867 while (optind
< argc
)
22868 if (! process_file (argv
[optind
++]))
22871 free (cmdline
.dump_sects
);
22873 free (dump_ctf_symtab_name
);
22874 free (dump_ctf_strtab_name
);
22875 free (dump_ctf_parent_name
);
22877 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;