1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2024 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
52 #if defined HAVE_MSGPACK
56 /* Define BFD64 here, even if our default architecture is 32 bit ELF
57 as this will allow us to read in and parse 64bit and 32bit ELF files. */
63 #include "demanguse.h"
66 #include "sframe-api.h"
69 #include "elf/common.h"
70 #include "elf/external.h"
71 #include "elf/internal.h"
74 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
75 we can obtain the H8 reloc numbers. We need these for the
76 get_reloc_size() function. We include h8.h again after defining
77 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
82 /* Undo the effects of #including reloc-macros.h. */
84 #undef START_RELOC_NUMBERS
88 #undef END_RELOC_NUMBERS
89 #undef _RELOC_MACROS_H
91 /* The following headers use the elf/reloc-macros.h file to
92 automatically generate relocation recognition functions
93 such as elf_mips_reloc_type() */
95 #define RELOC_MACROS_GEN_FUNC
97 #include "elf/aarch64.h"
98 #include "elf/alpha.h"
99 #include "elf/amdgpu.h"
103 #include "elf/bfin.h"
104 #include "elf/cr16.h"
105 #include "elf/cris.h"
107 #include "elf/csky.h"
108 #include "elf/d10v.h"
109 #include "elf/d30v.h"
112 #include "elf/epiphany.h"
113 #include "elf/fr30.h"
115 #include "elf/ft32.h"
117 #include "elf/hppa.h"
118 #include "elf/i386.h"
119 #include "elf/i370.h"
120 #include "elf/i860.h"
121 #include "elf/i960.h"
122 #include "elf/ia64.h"
123 #include "elf/ip2k.h"
125 #include "elf/lm32.h"
126 #include "elf/iq2000.h"
127 #include "elf/m32c.h"
128 #include "elf/m32r.h"
129 #include "elf/m68k.h"
130 #include "elf/m68hc11.h"
131 #include "elf/s12z.h"
132 #include "elf/mcore.h"
134 #include "elf/metag.h"
135 #include "elf/microblaze.h"
136 #include "elf/mips.h"
137 #include "elf/mmix.h"
138 #include "elf/mn10200.h"
139 #include "elf/mn10300.h"
140 #include "elf/moxie.h"
142 #include "elf/msp430.h"
143 #include "elf/nds32.h"
145 #include "elf/nios2.h"
146 #include "elf/or1k.h"
149 #include "elf/ppc64.h"
151 #include "elf/riscv.h"
152 #include "elf/rl78.h"
154 #include "elf/s390.h"
155 #include "elf/score.h"
157 #include "elf/sparc.h"
159 #include "elf/tic6x.h"
160 #include "elf/tilegx.h"
161 #include "elf/tilepro.h"
162 #include "elf/v850.h"
164 #include "elf/visium.h"
165 #include "elf/wasm32.h"
166 #include "elf/x86-64.h"
167 #include "elf/xgate.h"
168 #include "elf/xstormy16.h"
169 #include "elf/xtensa.h"
171 #include "elf/loongarch.h"
175 #include "libiberty.h"
176 #include "safe-ctype.h"
177 #include "filenames.h"
180 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
183 typedef struct elf_section_list
185 Elf_Internal_Shdr
* hdr
;
186 struct elf_section_list
* next
;
189 /* Flag bits indicating particular types of dump. */
190 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
191 #ifdef SUPPORT_DISASSEMBLY
192 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
194 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
195 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
196 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
197 #define CTF_DUMP (1 << 5) /* The --ctf command line switch. */
198 #define SFRAME_DUMP (1 << 6) /* The --sframe command line switch. */
199 #define AUTO_DUMP (1 << 7) /* The -j command line switch. */
201 typedef unsigned char dump_type
;
203 /* A linked list of the section names for which dumps were requested. */
204 struct dump_list_entry
208 struct dump_list_entry
* next
;
211 /* A dynamic array of flags indicating for which sections a dump
212 has been requested via command line switches. */
215 dump_type
* dump_sects
;
216 unsigned int num_dump_sects
;
219 static struct dump_data cmdline
;
221 static struct dump_list_entry
* dump_sects_byname
;
223 char * program_name
= "readelf";
225 static bool show_name
= false;
226 static bool do_dynamic
= false;
227 static bool do_syms
= false;
228 static bool do_dyn_syms
= false;
229 static bool do_lto_syms
= false;
230 static bool do_reloc
= false;
231 static bool do_sections
= false;
232 static bool do_section_groups
= false;
233 static bool do_section_details
= false;
234 static bool do_segments
= false;
235 static bool do_unwind
= false;
236 static bool do_using_dynamic
= false;
237 static bool do_header
= false;
238 static bool do_dump
= false;
239 static bool do_version
= false;
240 static bool do_histogram
= false;
241 static bool do_debugging
= false;
242 static bool do_ctf
= false;
243 static bool do_sframe
= false;
244 static bool do_arch
= false;
245 static bool do_notes
= false;
246 static bool do_archive_index
= false;
247 static bool check_all
= false;
248 static bool is_32bit_elf
= false;
249 static bool decompress_dumps
= false;
250 static bool do_not_show_symbol_truncation
= false;
251 static bool do_demangle
= false; /* Pretty print C++ symbol names. */
252 static bool process_links
= false;
253 static bool dump_any_debugging
= false;
254 static bool extra_sym_info
= false;
255 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
256 static int sym_base
= 0;
258 static char *dump_ctf_parent_name
;
259 static char *dump_ctf_symtab_name
;
260 static char *dump_ctf_strtab_name
;
264 struct group_list
* next
;
265 unsigned int section_index
;
270 struct group_list
* root
;
271 unsigned int group_index
;
274 typedef struct filedata
276 const char * file_name
;
280 Elf_Internal_Ehdr file_header
;
281 uint64_t archive_file_offset
;
282 uint64_t archive_file_size
;
283 /* Everything below this point is cleared out by free_filedata. */
284 Elf_Internal_Shdr
* section_headers
;
285 Elf_Internal_Phdr
* program_headers
;
287 uint64_t string_table_length
;
288 uint64_t dynamic_addr
;
289 uint64_t dynamic_size
;
290 uint64_t dynamic_nent
;
291 Elf_Internal_Dyn
* dynamic_section
;
292 Elf_Internal_Shdr
* dynamic_strtab_section
;
293 char * dynamic_strings
;
294 uint64_t dynamic_strings_length
;
295 Elf_Internal_Shdr
* dynamic_symtab_section
;
296 uint64_t num_dynamic_syms
;
297 Elf_Internal_Sym
* dynamic_symbols
;
298 uint64_t version_info
[16];
299 unsigned int dynamic_syminfo_nent
;
300 Elf_Internal_Syminfo
* dynamic_syminfo
;
301 uint64_t dynamic_syminfo_offset
;
306 uint64_t ngnubuckets
;
308 uint64_t * gnubuckets
;
309 uint64_t * gnuchains
;
312 char * program_interpreter
;
313 uint64_t dynamic_info
[DT_RELRENT
+ 1];
314 uint64_t dynamic_info_DT_GNU_HASH
;
315 uint64_t dynamic_info_DT_MIPS_XHASH
;
316 elf_section_list
* symtab_shndx_list
;
318 struct group
* section_groups
;
319 struct group
** section_headers_groups
;
320 /* A dynamic array of flags indicating for which sections a dump of
321 some kind has been requested. It is reset on a per-object file
322 basis and then initialised from the cmdline_dump_sects array,
323 the results of interpreting the -w switch, and the
324 dump_sects_byname list. */
325 struct dump_data dump
;
328 /* How to print a vma value. */
329 typedef enum print_mode
347 typedef enum unicode_display_type
355 } unicode_display_type
;
357 static unicode_display_type unicode_display
= unicode_default
;
367 /* Versioned symbol info. */
368 enum versioned_symbol_info
376 fseek64 (FILE *stream
, int64_t offset
, int whence
)
378 #if defined (HAVE_FSEEKO64)
385 return fseeko64 (stream
, o
, whence
);
386 #elif defined (HAVE_FSEEKO)
393 return fseeko (stream
, o
, whence
);
401 return fseek (stream
, o
, whence
);
405 static const char * get_symbol_version_string
406 (Filedata
*, bool, const char *, size_t, unsigned,
407 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
409 static bool process_notes_at
410 (Filedata
*, Elf_Internal_Shdr
*, uint64_t, uint64_t, uint64_t);
414 static inline const char *
415 section_name (const Filedata
*filedata
, const Elf_Internal_Shdr
*hdr
)
417 return filedata
->string_table
+ hdr
->sh_name
;
421 section_name_valid (const Filedata
*filedata
, const Elf_Internal_Shdr
*hdr
)
423 return (filedata
!= NULL
425 && filedata
->string_table
!= NULL
426 && hdr
->sh_name
< filedata
->string_table_length
);
429 /* Returns true if the given index is real/valid. Note: "real" here
430 means "references a real section in the section header" and not
431 "is a valid section index as per the ELF standard". */
434 section_index_real (const Filedata
*filedata
, unsigned int ndx
)
436 return (filedata
!= NULL
437 && filedata
->section_headers
!= NULL
438 && ndx
< filedata
->file_header
.e_shnum
442 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
445 valid_symbol_name (const char *strtab
, size_t strtab_size
, uint64_t offset
)
447 return strtab
!= NULL
&& offset
< strtab_size
;
451 valid_dynamic_name (const Filedata
*filedata
, uint64_t offset
)
453 return valid_symbol_name (filedata
->dynamic_strings
,
454 filedata
->dynamic_strings_length
, offset
);
457 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
458 already been called and verified that the string exists. */
459 static inline const char *
460 get_dynamic_name (const Filedata
*filedata
, size_t offset
)
462 return filedata
->dynamic_strings
+ offset
;
465 #define REMOVE_ARCH_BITS(ADDR) \
468 if (filedata->file_header.e_machine == EM_ARM) \
473 /* Get the correct GNU hash section name. */
474 #define GNU_HASH_SECTION_NAME(filedata) \
475 filedata->dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
477 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
478 OFFSET + the offset of the current archive member, if we are examining an
479 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
480 allocate a buffer using malloc and fill that. In either case return the
481 pointer to the start of the retrieved data or NULL if something went wrong.
482 If something does go wrong and REASON is not NULL then emit an error
483 message using REASON as part of the context. */
494 uint64_t amt
= size
* nmemb
;
496 if (size
== 0 || nmemb
== 0)
499 /* If size_t is smaller than uint64_t, eg because you are building
500 on a 32-bit host, then make sure that when the sizes are cast to
501 size_t no information is lost. */
502 if ((size_t) size
!= size
503 || (size_t) nmemb
!= nmemb
504 || (size_t) amt
!= amt
505 || amt
/ size
!= nmemb
506 || (size_t) amt
+ 1 == 0)
509 error (_("Size overflow prevents reading %" PRIu64
510 " elements of size %" PRIu64
" for %s\n"),
511 nmemb
, size
, reason
);
515 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
516 attempting to allocate memory when the read is bound to fail. */
517 if (filedata
->archive_file_offset
> filedata
->file_size
518 || offset
> filedata
->file_size
- filedata
->archive_file_offset
519 || amt
> filedata
->file_size
- filedata
->archive_file_offset
- offset
)
522 error (_("Reading %" PRIu64
" bytes extends past end of file for %s\n"),
527 if (fseek64 (filedata
->handle
, filedata
->archive_file_offset
+ offset
,
531 error (_("Unable to seek to %#" PRIx64
" for %s\n"),
532 filedata
->archive_file_offset
+ offset
, reason
);
539 /* + 1 so that we can '\0' terminate invalid string table sections. */
540 mvar
= malloc ((size_t) amt
+ 1);
545 error (_("Out of memory allocating %" PRIu64
" bytes for %s\n"),
550 ((char *) mvar
)[amt
] = '\0';
553 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
556 error (_("Unable to read in %" PRIu64
" bytes of %s\n"),
566 /* Print a VMA value in the MODE specified.
567 Returns the number of characters displayed. */
570 print_vma (uint64_t vma
, print_mode mode
)
581 return nc
+ printf ("%16.16" PRIx64
, vma
);
582 return nc
+ printf ("%8.8" PRIx64
, vma
);
586 return printf ("%08" PRIx64
, vma
);
587 return printf ("%016" PRIx64
, vma
);
591 return printf ("%5" PRId64
, vma
);
597 return nc
+ printf ("%" PRIx64
, vma
);
603 return nc
+ printf ("%05" PRIx64
, vma
);
606 return printf ("%" PRId64
, vma
);
609 return printf ("%" PRIu64
, vma
);
612 return printf ("%5" PRIu64
, vma
);
615 return printf ("%" PRIo64
, vma
);
618 return printf ("%5" PRIo64
, vma
);
621 /* FIXME: Report unrecognised mode ? */
627 /* Display a symbol on stdout. Handles the display of control characters and
628 multibye characters (assuming the host environment supports them).
630 Display at most abs(WIDTH) characters, truncating as necessary,
631 unless do_wide or extra_sym_info is true.
633 If truncation will happen and do_not_show_symbol_truncation is FALSE then display
634 abs(WIDTH) - 5 characters followed by "[...]".
636 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
637 padding as necessary.
639 Returns the number of emitted characters. */
642 print_symbol_name (signed int width
, const char * symbol
)
644 bool extra_padding
= false;
645 bool do_dots
= false;
646 signed int num_printed
= 0;
647 #ifdef HAVE_MBSTATE_T
650 unsigned int width_remaining
;
651 const void * alloced_symbol
= NULL
;
655 /* Keep the width positive. This helps the code below. */
657 extra_padding
= true;
662 if (do_wide
|| extra_sym_info
)
663 /* Set the remaining width to a very large value.
664 This simplifies the code below. */
665 width_remaining
= INT_MAX
;
668 width_remaining
= width
;
670 if (! do_not_show_symbol_truncation
671 && (int) strlen (symbol
) > width
)
673 width_remaining
-= 5;
674 if ((int) width_remaining
< 0)
680 #ifdef HAVE_MBSTATE_T
681 /* Initialise the multibyte conversion state. */
682 memset (& state
, 0, sizeof (state
));
685 if (do_demangle
&& *symbol
)
687 const char * res
= cplus_demangle (symbol
, demangle_flags
);
690 alloced_symbol
= symbol
= res
;
693 while (width_remaining
)
696 const char c
= *symbol
++;
707 else if (ISCNTRL (c
))
709 /* Do not print control characters directly as they can affect terminal
710 settings. Such characters usually appear in the names generated
711 by the assembler for local labels. */
713 if (width_remaining
< 2)
716 printf ("^%c", c
+ 0x40);
717 width_remaining
-= 2;
722 if (width_remaining
< 5)
725 width_remaining
-= 5;
728 else if (unicode_display
!= unicode_locale
729 && unicode_display
!= unicode_default
)
731 /* Display unicode characters as something else. */
732 unsigned char bytes
[4];
745 bytes
[1] = *symbol
++;
747 if ((bytes
[1] & 0xc0) != 0x80)
750 /* Do not consume this character. It may only
751 be the first byte in the sequence that was
756 else if ((bytes
[0] & 0x20) == 0)
763 bytes
[2] = *symbol
++;
765 if ((bytes
[2] & 0xc0) != 0x80)
771 else if ((bytes
[0] & 0x10) == 0)
778 bytes
[3] = *symbol
++;
782 if ((bytes
[3] & 0xc0) != 0x80)
794 if (unicode_display
== unicode_invalid
)
797 if (unicode_display
== unicode_hex
|| ! is_utf8
)
801 if (width_remaining
< (nbytes
* 2) + 2)
804 putchar (is_utf8
? '<' : '{');
806 for (i
= 0; i
< nbytes
; i
++)
807 printf ("%02x", bytes
[i
]);
808 putchar (is_utf8
? '>' : '}');
812 if (unicode_display
== unicode_highlight
&& isatty (1))
813 printf ("\x1B[31;47m"); /* Red. */
818 if (width_remaining
< 6)
820 printf ("\\u%02x%02x",
821 (bytes
[0] & 0x1c) >> 2,
822 ((bytes
[0] & 0x03) << 6) | (bytes
[1] & 0x3f));
825 if (width_remaining
< 6)
827 printf ("\\u%02x%02x",
828 ((bytes
[0] & 0x0f) << 4) | ((bytes
[1] & 0x3c) >> 2),
829 ((bytes
[1] & 0x03) << 6) | (bytes
[2] & 0x3f));
832 if (width_remaining
< 8)
834 printf ("\\u%02x%02x%02x",
835 ((bytes
[0] & 0x07) << 6) | ((bytes
[1] & 0x3c) >> 2),
836 ((bytes
[1] & 0x03) << 6) | ((bytes
[2] & 0x3c) >> 2),
837 ((bytes
[2] & 0x03) << 6) | (bytes
[3] & 0x3f));
845 if (unicode_display
== unicode_highlight
&& isatty (1))
846 printf ("\033[0m"); /* Default colour. */
849 if (bytes
[nbytes
- 1] == 0)
854 #ifdef HAVE_MBSTATE_T
857 /* Let printf do the hard work of displaying multibyte characters. */
858 printf ("%.1s", symbol
- 1);
862 #ifdef HAVE_MBSTATE_T
863 /* Try to find out how many bytes made up the character that was
864 just printed. Advance the symbol pointer past the bytes that
866 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
870 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
876 num_printed
+= printf ("[...]");
878 if (extra_padding
&& num_printed
< width
)
880 /* Fill in the remaining spaces. */
881 printf ("%-*s", width
- num_printed
, " ");
885 free ((void *) alloced_symbol
);
889 /* Returns a pointer to a static buffer containing a printable version of
890 the given section's name. Like print_symbol, except that it does not try
891 to print multibyte characters, it just interprets them as hex values. */
894 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
896 #define NUM_SEC_NAME_BUFS 5
897 #define MAX_PRINT_SEC_NAME_LEN 256
899 static int sec_name_buf_index
= 0;
900 /* We use a rotating array of static buffers, so that multiple successive calls
901 to printable_section_name() will still work. eg when used in a printf. */
902 static char sec_name_buf
[NUM_SEC_NAME_BUFS
][MAX_PRINT_SEC_NAME_LEN
+ 1];
908 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
910 /* Validate the input parameters. */
911 if (filedata
== NULL
)
912 return _("<internal error>");
915 if (filedata
->string_table
== NULL
)
916 return _("<no-strings>");
917 if (sec
->sh_name
>= filedata
->string_table_length
)
918 return _("<corrupt>");
920 /* Select a buffer to use. */
921 buf_start
= buf
= sec_name_buf
[sec_name_buf_index
];
922 if (++sec_name_buf_index
>= NUM_SEC_NAME_BUFS
)
923 sec_name_buf_index
= 0;
925 name
= section_name (filedata
, sec
);
927 while ((c
= * name
++) != 0)
938 else if (ISPRINT (c
))
945 static char hex
[17] = "0123456789ABCDEF";
950 * buf
++ = hex
[(c
& 0xf0) >> 4];
951 * buf
++ = hex
[c
& 0x0f];
964 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
965 This OS has so many departures from the ELF standard that we test it at
969 is_ia64_vms (Filedata
* filedata
)
971 return filedata
->file_header
.e_machine
== EM_IA_64
972 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
976 printable_section_name_from_index (Filedata
* filedata
,
980 if (is_special
!= NULL
)
985 case SHN_UNDEF
: return "UND";
986 case SHN_ABS
: return "ABS";
987 case SHN_COMMON
: return "COM";
991 if (filedata
!= NULL
)
993 switch (filedata
->file_header
.e_machine
)
996 if (ndx
== SHN_MIPS_SCOMMON
)
998 if (ndx
== SHN_MIPS_SUNDEFINED
)
1003 if (ndx
== SHN_TIC6X_SCOMMON
)
1010 if (ndx
== SHN_X86_64_LCOMMON
)
1015 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1016 && ndx
== SHN_IA_64_ANSI_COMMON
)
1019 if (is_ia64_vms (filedata
) && ndx
== SHN_IA_64_VMS_SYMVEC
)
1020 return "VMS_SYMVEC";
1027 if (filedata
->section_headers
!= NULL
1028 && ndx
< filedata
->file_header
.e_shnum
)
1032 res
= printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
1033 if (is_special
!= NULL
)
1034 * is_special
= (res
[0] == '<');
1040 static char name_buf
[40];
1041 unsigned int short_ndx
= (unsigned int) (ndx
& 0xffff);
1043 if (ndx
>= SHN_LOPROC
&& ndx
<= SHN_HIPROC
)
1044 sprintf (name_buf
, "PRC[0x%04x]", short_ndx
);
1045 else if (ndx
>= SHN_LOOS
&& ndx
<= SHN_HIOS
)
1046 sprintf (name_buf
, "OS [0x%04x]", short_ndx
);
1047 else if (ndx
>= SHN_LORESERVE
)
1048 sprintf (name_buf
, "RSV[0x%04x]", short_ndx
);
1049 else if (filedata
->file_header
.e_shnum
!= 0
1050 && ndx
>= filedata
->file_header
.e_shnum
)
1051 sprintf (name_buf
, _("BAD[0x%lx]"), (long) ndx
);
1053 sprintf (name_buf
, "<section 0x%lx>", (long) ndx
);
1058 /* Return a pointer to section NAME, or NULL if no such section exists. */
1060 static Elf_Internal_Shdr
*
1061 find_section (Filedata
* filedata
, const char * name
)
1065 if (filedata
->section_headers
== NULL
)
1068 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
1069 if (section_name_valid (filedata
, filedata
->section_headers
+ i
)
1070 && streq (section_name (filedata
, filedata
->section_headers
+ i
),
1072 return filedata
->section_headers
+ i
;
1077 /* Return a pointer to a section containing ADDR, or NULL if no such
1080 static Elf_Internal_Shdr
*
1081 find_section_by_address (Filedata
* filedata
, uint64_t addr
)
1085 if (filedata
->section_headers
== NULL
)
1088 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
1090 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
1092 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
1099 static Elf_Internal_Shdr
*
1100 find_section_by_type (Filedata
* filedata
, unsigned int type
)
1104 if (filedata
->section_headers
== NULL
)
1107 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
1109 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
1111 if (sec
->sh_type
== type
)
1118 static Elf_Internal_Shdr
*
1119 find_section_by_name (Filedata
* filedata
, const char * name
)
1123 if (filedata
->section_headers
== NULL
|| filedata
->string_table_length
== 0)
1126 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
1128 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
1130 if (sec
->sh_name
< filedata
->string_table_length
1131 && streq (name
, filedata
->string_table
+ sec
->sh_name
))
1138 /* Return a pointer to section NAME, or NULL if no such section exists,
1139 restricted to the list of sections given in SET. */
1141 static Elf_Internal_Shdr
*
1142 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
1146 if (filedata
->section_headers
== NULL
)
1151 while ((i
= *set
++) > 0)
1153 /* See PR 21156 for a reproducer. */
1154 if (i
>= filedata
->file_header
.e_shnum
)
1155 continue; /* FIXME: Should we issue an error message ? */
1157 if (section_name_valid (filedata
, filedata
->section_headers
+ i
)
1158 && streq (section_name (filedata
, filedata
->section_headers
+ i
),
1160 return filedata
->section_headers
+ i
;
1164 return find_section (filedata
, name
);
1167 /* Guess the relocation size commonly used by the specific machines. */
1170 guess_is_rela (unsigned int e_machine
)
1174 /* Targets that use REL relocations. */
1180 case EM_CYGNUS_D10V
:
1183 case EM_MIPS_RS3_LE
:
1184 case EM_CYGNUS_M32R
:
1191 /* Targets that use RELA relocations. */
1195 case EM_ADAPTEVA_EPIPHANY
:
1197 case EM_ALTERA_NIOS2
:
1199 case EM_ARC_COMPACT
:
1200 case EM_ARC_COMPACT2
:
1201 case EM_ARC_COMPACT3
:
1202 case EM_ARC_COMPACT3_64
:
1211 case EM_CYGNUS_D30V
:
1214 case EM_CYGNUS_FR30
:
1224 case EM_LATTICEMICO32
:
1233 case EM_CYGNUS_MN10200
:
1235 case EM_CYGNUS_MN10300
:
1253 case EM_SPARC32PLUS
:
1261 case EM_CYGNUS_V850
:
1271 case EM_MICROBLAZE_OLD
:
1272 case EM_WEBASSEMBLY
:
1293 warn (_("Don't know about relocations on this machine architecture\n"));
1298 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1299 Returns TRUE upon success, FALSE otherwise. If successful then a
1300 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
1301 and the number of relocs loaded is placed in *NRELASP. It is the caller's
1302 responsibility to free the allocated buffer. */
1305 slurp_rela_relocs (Filedata
*filedata
,
1306 uint64_t rel_offset
,
1308 Elf_Internal_Rela
**relasp
,
1311 Elf_Internal_Rela
* relas
;
1317 Elf32_External_Rela
* erelas
;
1319 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
1320 rel_size
, _("32-bit relocation data"));
1324 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
1326 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
1327 sizeof (Elf_Internal_Rela
));
1332 error (_("out of memory parsing relocs\n"));
1336 for (i
= 0; i
< nrelas
; i
++)
1338 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
1339 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
1340 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
1347 Elf64_External_Rela
* erelas
;
1349 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
1350 rel_size
, _("64-bit relocation data"));
1354 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
1356 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
1357 sizeof (Elf_Internal_Rela
));
1362 error (_("out of memory parsing relocs\n"));
1366 for (i
= 0; i
< nrelas
; i
++)
1368 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
1369 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
1370 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
1372 if (filedata
->file_header
.e_machine
== EM_MIPS
1373 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1375 /* In little-endian objects, r_info isn't really a
1376 64-bit little-endian value: it has a 32-bit
1377 little-endian symbol index followed by four
1378 individual byte fields. Reorder INFO
1380 uint64_t inf
= relas
[i
].r_info
;
1381 inf
= (((inf
& 0xffffffff) << 32)
1382 | ((inf
>> 56) & 0xff)
1383 | ((inf
>> 40) & 0xff00)
1384 | ((inf
>> 24) & 0xff0000)
1385 | ((inf
>> 8) & 0xff000000));
1386 relas
[i
].r_info
= inf
;
1398 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1399 Returns TRUE upon success, FALSE otherwise. If successful then a
1400 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1401 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1402 responsibility to free the allocated buffer. */
1405 slurp_rel_relocs (Filedata
*filedata
,
1406 uint64_t rel_offset
,
1408 Elf_Internal_Rela
**relsp
,
1411 Elf_Internal_Rela
* rels
;
1417 Elf32_External_Rel
* erels
;
1419 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1420 rel_size
, _("32-bit relocation data"));
1424 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1426 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1431 error (_("out of memory parsing relocs\n"));
1435 for (i
= 0; i
< nrels
; i
++)
1437 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1438 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1439 rels
[i
].r_addend
= 0;
1446 Elf64_External_Rel
* erels
;
1448 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1449 rel_size
, _("64-bit relocation data"));
1453 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1455 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1460 error (_("out of memory parsing relocs\n"));
1464 for (i
= 0; i
< nrels
; i
++)
1466 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1467 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1468 rels
[i
].r_addend
= 0;
1470 if (filedata
->file_header
.e_machine
== EM_MIPS
1471 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1473 /* In little-endian objects, r_info isn't really a
1474 64-bit little-endian value: it has a 32-bit
1475 little-endian symbol index followed by four
1476 individual byte fields. Reorder INFO
1478 uint64_t inf
= rels
[i
].r_info
;
1479 inf
= (((inf
& 0xffffffff) << 32)
1480 | ((inf
>> 56) & 0xff)
1481 | ((inf
>> 40) & 0xff00)
1482 | ((inf
>> 24) & 0xff0000)
1483 | ((inf
>> 8) & 0xff000000));
1484 rels
[i
].r_info
= inf
;
1496 /* Returns the reloc type extracted from the reloc info field. */
1499 get_reloc_type (Filedata
* filedata
, uint64_t reloc_info
)
1502 return ELF32_R_TYPE (reloc_info
);
1504 switch (filedata
->file_header
.e_machine
)
1507 /* Note: We assume that reloc_info has already been adjusted for us. */
1508 return ELF64_MIPS_R_TYPE (reloc_info
);
1511 return ELF64_R_TYPE_ID (reloc_info
);
1514 return ELF64_R_TYPE (reloc_info
);
1518 /* Return the symbol index extracted from the reloc info field. */
1521 get_reloc_symindex (uint64_t reloc_info
)
1523 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1527 uses_msp430x_relocs (Filedata
* filedata
)
1530 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1531 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1532 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1533 /* TI compiler uses ELFOSABI_NONE. */
1534 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1539 get_symbol_at (Elf_Internal_Sym
* symtab
,
1544 uint64_t * offset_return
)
1546 Elf_Internal_Sym
* beg
= symtab
;
1547 Elf_Internal_Sym
* end
= symtab
+ nsyms
;
1548 Elf_Internal_Sym
* best
= NULL
;
1549 uint64_t dist
= 0x100000;
1552 if (symtab
== NULL
|| nsyms
== 0 || strtab
== NULL
|| strtablen
== 0)
1555 /* FIXME: Since this function is likely to be called repeatedly with
1556 slightly increasing addresses each time, we could speed things up by
1557 caching the last returned value and starting our search from there. */
1560 Elf_Internal_Sym
* sym
;
1563 sym
= beg
+ (end
- beg
) / 2;
1565 value
= sym
->st_value
;
1567 if (sym
->st_name
!= 0
1569 && where
- value
< dist
)
1572 dist
= where
- value
;
1586 if (best
->st_name
>= strtablen
)
1589 if (offset_return
!= NULL
)
1590 * offset_return
= dist
;
1592 return strtab
+ best
->st_name
;
1596 print_relr_addr_and_sym (Elf_Internal_Sym
* symtab
,
1602 const char * symname
= NULL
;
1603 uint64_t offset
= 0;
1605 print_vma (where
, ZERO_HEX
);
1608 symname
= get_symbol_at (symtab
, nsyms
, strtab
, strtablen
, where
, & offset
);
1610 if (symname
== NULL
)
1611 printf ("<no sym>");
1612 else if (offset
== 0)
1613 print_symbol_name (38, symname
);
1616 print_symbol_name (28, symname
);
1618 print_vma (offset
, PREFIX_HEX
);
1622 static /* signed */ int
1623 symcmp (const void *p
, const void *q
)
1625 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
1626 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
1628 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
1632 count_relr_relocations (Filedata
* filedata
,
1633 Elf_Internal_Shdr
* section
)
1642 || section
->sh_type
!= SHT_RELR
1643 || section
->sh_size
== 0)
1646 entsize
= section
->sh_entsize
;
1648 entsize
= is_32bit_elf
1649 ? sizeof (Elf32_External_Relr
) : sizeof (Elf64_External_Relr
);
1650 else if (entsize
!= sizeof (Elf32_External_Relr
)
1651 && entsize
!= sizeof (Elf64_External_Relr
))
1654 nentries
= section
->sh_size
/ entsize
;
1658 /* FIXME: This call to get_data duplicates one that follows in
1659 dump_relr_relocations(). They could be combined into just
1661 relrs
= get_data (NULL
, filedata
, section
->sh_offset
, 1,
1662 section
->sh_size
, _("RELR relocation data"));
1666 for (count
= i
= 0; i
< nentries
; i
++)
1670 if (entsize
== sizeof (Elf32_External_Relr
))
1671 entry
= BYTE_GET (((Elf32_External_Relr
*)relrs
)[i
].r_data
);
1673 entry
= BYTE_GET (((Elf64_External_Relr
*)relrs
)[i
].r_data
);
1675 if ((entry
& 1) == 0)
1684 for (; entry
>>= 1;)
1685 if ((entry
& 1) == 1)
1695 dump_relr_relocations (Filedata
* filedata
,
1696 Elf_Internal_Shdr
* section
,
1697 Elf_Internal_Sym
* symtab
,
1703 uint64_t nentries
, i
;
1704 uint64_t relr_size
= section
->sh_size
;
1705 int relr_entsize
= section
->sh_entsize
;
1706 uint64_t relr_offset
= section
->sh_offset
;
1708 int num_bits_in_entry
;
1710 if (relr_entsize
== 0)
1711 relr_entsize
= is_32bit_elf
1712 ? sizeof (Elf32_External_Relr
) : sizeof (Elf64_External_Relr
);
1714 nentries
= relr_size
/ relr_entsize
;
1719 if (relr_entsize
== sizeof (Elf32_External_Relr
))
1720 num_bits_in_entry
= 31;
1721 else if (relr_entsize
== sizeof (Elf64_External_Relr
))
1722 num_bits_in_entry
= 63;
1725 warn (_("Unexpected entsize for RELR section\n"));
1729 relrs
= get_data (NULL
, filedata
, relr_offset
, 1, relr_size
, _("RELR relocation data"));
1735 /* Symbol tables are not sorted on address, but we want a quick lookup
1736 for the symbol associated with each address computed below, so sort
1737 the table now. FIXME: This assumes that the symbol table will not
1738 be used later on for some other purpose. */
1739 qsort (symtab
, nsyms
, sizeof (Elf_Internal_Sym
), symcmp
);
1742 if (relr_entsize
== sizeof (Elf32_External_Relr
))
1743 printf (_ ("Index: Entry Address Symbolic Address\n"));
1745 printf (_ ("Index: Entry Address Symbolic Address\n"));
1747 for (i
= 0; i
< nentries
; i
++)
1751 if (relr_entsize
== sizeof (Elf32_External_Relr
))
1752 entry
= BYTE_GET (((Elf32_External_Relr
*)relrs
)[i
].r_data
);
1754 entry
= BYTE_GET (((Elf64_External_Relr
*)relrs
)[i
].r_data
);
1756 /* We assume that there will never be more than 9999 entries. */
1757 printf (_("%04u: "), (unsigned int) i
);
1758 print_vma (entry
, ZERO_HEX
);
1761 if ((entry
& 1) == 0)
1764 print_relr_addr_and_sym (symtab
, nsyms
, strtab
, strtablen
, where
);
1766 where
+= relr_entsize
;
1773 /* The least significant bit is ignored. */
1775 /* This can actually happen when the linker is allowed to shrink
1776 RELR sections. For more details see: https://reviews.llvm.org/D67164. */
1779 warn (_("Unusual RELR bitmap - no previous entry to set the base address\n"));
1781 for (j
= 0; entry
>>= 1; j
++)
1782 if ((entry
& 1) == 1)
1784 uint64_t addr
= where
+ (j
* relr_entsize
);
1788 print_relr_addr_and_sym (symtab
, nsyms
, strtab
, strtablen
, addr
);
1793 printf (_("\n%*s "), relr_entsize
== 4 ? 15 : 23, " ");
1794 print_relr_addr_and_sym (symtab
, nsyms
, strtab
, strtablen
, addr
);
1799 where
+= num_bits_in_entry
* relr_entsize
;
1807 /* Display the contents of the relocation data found at the specified
1811 dump_relocations (Filedata
* filedata
,
1812 uint64_t rel_offset
,
1814 Elf_Internal_Sym
* symtab
,
1818 relocation_type rel_type
,
1822 Elf_Internal_Rela
* rels
;
1825 if (rel_type
== reltype_unknown
)
1826 rel_type
= guess_is_rela (filedata
->file_header
.e_machine
) ? reltype_rela
: reltype_rel
;
1828 if (rel_type
== reltype_rela
)
1830 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1833 else if (rel_type
== reltype_rel
)
1835 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1838 else if (rel_type
== reltype_relr
)
1840 /* This should have been handled by display_relocations(). */
1846 if (rel_type
== reltype_rela
)
1849 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1851 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1856 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1858 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1863 if (rel_type
== reltype_rela
)
1866 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1868 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1873 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1875 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1879 for (i
= 0; i
< rel_size
; i
++)
1884 uint64_t symtab_index
;
1887 offset
= rels
[i
].r_offset
;
1888 inf
= rels
[i
].r_info
;
1890 type
= get_reloc_type (filedata
, inf
);
1891 symtab_index
= get_reloc_symindex (inf
);
1895 printf ("%8.8lx %8.8lx ",
1896 (unsigned long) offset
& 0xffffffff,
1897 (unsigned long) inf
& 0xffffffff);
1902 ? "%16.16" PRIx64
" %16.16" PRIx64
" "
1903 : "%12.12" PRIx64
" %12.12" PRIx64
" ",
1907 switch (filedata
->file_header
.e_machine
)
1914 rtype
= elf_aarch64_reloc_type (type
);
1918 case EM_CYGNUS_M32R
:
1919 rtype
= elf_m32r_reloc_type (type
);
1924 rtype
= elf_i386_reloc_type (type
);
1929 rtype
= elf_m68hc11_reloc_type (type
);
1933 rtype
= elf_s12z_reloc_type (type
);
1937 rtype
= elf_m68k_reloc_type (type
);
1941 rtype
= elf_i960_reloc_type (type
);
1946 rtype
= elf_avr_reloc_type (type
);
1949 case EM_OLD_SPARCV9
:
1950 case EM_SPARC32PLUS
:
1953 rtype
= elf_sparc_reloc_type (type
);
1957 rtype
= elf_spu_reloc_type (type
);
1961 rtype
= v800_reloc_type (type
);
1964 case EM_CYGNUS_V850
:
1965 rtype
= v850_reloc_type (type
);
1969 case EM_CYGNUS_D10V
:
1970 rtype
= elf_d10v_reloc_type (type
);
1974 case EM_CYGNUS_D30V
:
1975 rtype
= elf_d30v_reloc_type (type
);
1979 rtype
= elf_dlx_reloc_type (type
);
1983 rtype
= elf_sh_reloc_type (type
);
1987 case EM_CYGNUS_MN10300
:
1988 rtype
= elf_mn10300_reloc_type (type
);
1992 case EM_CYGNUS_MN10200
:
1993 rtype
= elf_mn10200_reloc_type (type
);
1997 case EM_CYGNUS_FR30
:
1998 rtype
= elf_fr30_reloc_type (type
);
2002 rtype
= elf_frv_reloc_type (type
);
2006 rtype
= elf_csky_reloc_type (type
);
2010 rtype
= elf_ft32_reloc_type (type
);
2014 rtype
= elf_mcore_reloc_type (type
);
2018 rtype
= elf_mmix_reloc_type (type
);
2022 rtype
= elf_moxie_reloc_type (type
);
2026 if (uses_msp430x_relocs (filedata
))
2028 rtype
= elf_msp430x_reloc_type (type
);
2033 rtype
= elf_msp430_reloc_type (type
);
2037 rtype
= elf_nds32_reloc_type (type
);
2041 rtype
= elf_ppc_reloc_type (type
);
2045 rtype
= elf_ppc64_reloc_type (type
);
2049 case EM_MIPS_RS3_LE
:
2050 rtype
= elf_mips_reloc_type (type
);
2054 rtype
= elf_riscv_reloc_type (type
);
2058 rtype
= elf_alpha_reloc_type (type
);
2062 rtype
= elf_arm_reloc_type (type
);
2066 case EM_ARC_COMPACT
:
2067 case EM_ARC_COMPACT2
:
2068 case EM_ARC_COMPACT3
:
2069 case EM_ARC_COMPACT3_64
:
2070 rtype
= elf_arc_reloc_type (type
);
2074 rtype
= elf_hppa_reloc_type (type
);
2080 rtype
= elf_h8_reloc_type (type
);
2084 rtype
= elf_or1k_reloc_type (type
);
2089 rtype
= elf_pj_reloc_type (type
);
2092 rtype
= elf_ia64_reloc_type (type
);
2096 rtype
= elf_kvx_reloc_type (type
);
2100 rtype
= elf_cris_reloc_type (type
);
2104 rtype
= elf_i860_reloc_type (type
);
2110 rtype
= elf_x86_64_reloc_type (type
);
2114 rtype
= i370_reloc_type (type
);
2119 rtype
= elf_s390_reloc_type (type
);
2123 rtype
= elf_score_reloc_type (type
);
2127 rtype
= elf_xstormy16_reloc_type (type
);
2131 rtype
= elf_crx_reloc_type (type
);
2135 rtype
= elf_vax_reloc_type (type
);
2139 rtype
= elf_visium_reloc_type (type
);
2143 rtype
= elf_bpf_reloc_type (type
);
2146 case EM_ADAPTEVA_EPIPHANY
:
2147 rtype
= elf_epiphany_reloc_type (type
);
2152 rtype
= elf_ip2k_reloc_type (type
);
2156 rtype
= elf_iq2000_reloc_type (type
);
2161 rtype
= elf_xtensa_reloc_type (type
);
2164 case EM_LATTICEMICO32
:
2165 rtype
= elf_lm32_reloc_type (type
);
2170 rtype
= elf_m32c_reloc_type (type
);
2174 rtype
= elf_mt_reloc_type (type
);
2178 rtype
= elf_bfin_reloc_type (type
);
2182 rtype
= elf_mep_reloc_type (type
);
2186 rtype
= elf_cr16_reloc_type (type
);
2190 case EM_MICROBLAZE_OLD
:
2191 rtype
= elf_microblaze_reloc_type (type
);
2195 rtype
= elf_rl78_reloc_type (type
);
2199 rtype
= elf_rx_reloc_type (type
);
2203 rtype
= elf_metag_reloc_type (type
);
2207 rtype
= elf_tic6x_reloc_type (type
);
2211 rtype
= elf_tilegx_reloc_type (type
);
2215 rtype
= elf_tilepro_reloc_type (type
);
2218 case EM_WEBASSEMBLY
:
2219 rtype
= elf_wasm32_reloc_type (type
);
2223 rtype
= elf_xgate_reloc_type (type
);
2226 case EM_ALTERA_NIOS2
:
2227 rtype
= elf_nios2_reloc_type (type
);
2231 rtype
= elf_pru_reloc_type (type
);
2235 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
2236 rtype
= elf_nfp3200_reloc_type (type
);
2238 rtype
= elf_nfp_reloc_type (type
);
2242 rtype
= elf_z80_reloc_type (type
);
2246 rtype
= elf_loongarch_reloc_type (type
);
2250 rtype
= elf_amdgpu_reloc_type (type
);
2255 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
2257 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
2259 if (filedata
->file_header
.e_machine
== EM_ALPHA
2261 && streq (rtype
, "R_ALPHA_LITUSE")
2262 && rel_type
== reltype_rela
)
2264 switch (rels
[i
].r_addend
)
2266 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
2267 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
2268 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
2269 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
2270 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
2271 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
2272 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
2273 default: rtype
= NULL
;
2277 printf (" (%s)", rtype
);
2281 printf (_("<unknown addend: %" PRIx64
">"),
2286 else if (symtab_index
)
2288 if (symtab
== NULL
|| symtab_index
>= nsyms
)
2290 error (_(" bad symbol index: %08lx in reloc\n"),
2291 (unsigned long) symtab_index
);
2296 Elf_Internal_Sym
* psym
;
2297 const char * version_string
;
2298 enum versioned_symbol_info sym_info
;
2299 unsigned short vna_other
;
2301 psym
= symtab
+ symtab_index
;
2304 = get_symbol_version_string (filedata
, is_dynsym
,
2313 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
2317 unsigned int width
= is_32bit_elf
? 8 : 14;
2319 /* Relocations against GNU_IFUNC symbols do not use the value
2320 of the symbol as the address to relocate against. Instead
2321 they invoke the function named by the symbol and use its
2322 result as the address for relocation.
2324 To indicate this to the user, do not display the value of
2325 the symbol in the "Symbols's Value" field. Instead show
2326 its name followed by () as a hint that the symbol is
2330 || psym
->st_name
== 0
2331 || psym
->st_name
>= strtablen
)
2334 name
= strtab
+ psym
->st_name
;
2336 len
= print_symbol_name (width
, name
);
2338 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
2340 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
2344 print_vma (psym
->st_value
, LONG_HEX
);
2346 printf (is_32bit_elf
? " " : " ");
2349 if (psym
->st_name
== 0)
2351 const char * sec_name
= "<null>";
2353 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
2354 sec_name
= printable_section_name_from_index
2355 (filedata
, psym
->st_shndx
, NULL
);
2357 print_symbol_name (22, sec_name
);
2359 else if (strtab
== NULL
)
2360 printf (_("<string table index: %3ld>"), psym
->st_name
);
2361 else if (psym
->st_name
>= strtablen
)
2363 error (_("<corrupt string table index: %3ld>\n"),
2369 print_symbol_name (22, strtab
+ psym
->st_name
);
2371 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
2375 if (rel_type
== reltype_rela
)
2377 uint64_t off
= rels
[i
].r_addend
;
2379 if ((int64_t) off
< 0)
2380 printf (" - %" PRIx64
, -off
);
2382 printf (" + %" PRIx64
, off
);
2386 else if (rel_type
== reltype_rela
)
2388 uint64_t off
= rels
[i
].r_addend
;
2390 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
2391 if ((int64_t) off
< 0)
2392 printf ("-%" PRIx64
, -off
);
2394 printf ("%" PRIx64
, off
);
2397 if (filedata
->file_header
.e_machine
== EM_SPARCV9
2399 && streq (rtype
, "R_SPARC_OLO10"))
2400 printf (" + %" PRIx64
, ELF64_R_TYPE_DATA (inf
));
2404 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
2406 uint64_t type2
= ELF64_MIPS_R_TYPE2 (inf
);
2407 uint64_t type3
= ELF64_MIPS_R_TYPE3 (inf
);
2408 const char * rtype2
= elf_mips_reloc_type (type2
);
2409 const char * rtype3
= elf_mips_reloc_type (type3
);
2411 printf (" Type2: ");
2414 printf (_("unrecognized: %-7lx"),
2415 (unsigned long) type2
& 0xffffffff);
2417 printf ("%-17.17s", rtype2
);
2419 printf ("\n Type3: ");
2422 printf (_("unrecognized: %-7lx"),
2423 (unsigned long) type3
& 0xffffffff);
2425 printf ("%-17.17s", rtype3
);
2437 get_aarch64_dynamic_type (unsigned long type
)
2441 case DT_AARCH64_BTI_PLT
: return "AARCH64_BTI_PLT";
2442 case DT_AARCH64_PAC_PLT
: return "AARCH64_PAC_PLT";
2443 case DT_AARCH64_VARIANT_PCS
: return "AARCH64_VARIANT_PCS";
2450 get_mips_dynamic_type (unsigned long type
)
2454 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
2455 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
2456 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
2457 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
2458 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
2459 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
2460 case DT_MIPS_MSYM
: return "MIPS_MSYM";
2461 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2462 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2463 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
2464 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
2465 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
2466 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
2467 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
2468 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
2469 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
2470 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
2471 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
2472 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
2473 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
2474 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
2475 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
2476 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
2477 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
2478 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
2479 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
2480 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
2481 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
2482 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
2483 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
2484 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2485 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
2486 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
2487 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
2488 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
2489 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2490 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
2491 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
2492 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
2493 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
2494 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
2495 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
2496 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
2497 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
2498 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
2499 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
2500 case DT_MIPS_XHASH
: return "MIPS_XHASH";
2507 get_sparc64_dynamic_type (unsigned long type
)
2511 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
2518 get_ppc_dynamic_type (unsigned long type
)
2522 case DT_PPC_GOT
: return "PPC_GOT";
2523 case DT_PPC_OPT
: return "PPC_OPT";
2530 get_ppc64_dynamic_type (unsigned long type
)
2534 case DT_PPC64_GLINK
: return "PPC64_GLINK";
2535 case DT_PPC64_OPD
: return "PPC64_OPD";
2536 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
2537 case DT_PPC64_OPT
: return "PPC64_OPT";
2544 get_parisc_dynamic_type (unsigned long type
)
2548 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
2549 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
2550 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
2551 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
2552 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
2553 case DT_HP_PREINIT
: return "HP_PREINIT";
2554 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
2555 case DT_HP_NEEDED
: return "HP_NEEDED";
2556 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
2557 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
2558 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
2559 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
2560 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
2561 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
2562 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
2563 case DT_HP_FILTERED
: return "HP_FILTERED";
2564 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
2565 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
2566 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
2567 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
2568 case DT_PLT
: return "PLT";
2569 case DT_PLT_SIZE
: return "PLT_SIZE";
2570 case DT_DLT
: return "DLT";
2571 case DT_DLT_SIZE
: return "DLT_SIZE";
2578 get_ia64_dynamic_type (unsigned long type
)
2582 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
2583 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
2584 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
2585 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
2586 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
2587 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
2588 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
2589 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
2590 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
2591 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
2592 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
2593 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
2594 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
2595 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
2596 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
2597 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
2598 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
2599 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
2600 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
2601 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
2602 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
2603 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
2604 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
2605 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
2606 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
2607 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
2608 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
2609 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
2610 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
2611 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
2612 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
2619 get_solaris_section_type (unsigned long type
)
2623 case 0x6fffffee: return "SUNW_ancillary";
2624 case 0x6fffffef: return "SUNW_capchain";
2625 case 0x6ffffff0: return "SUNW_capinfo";
2626 case 0x6ffffff1: return "SUNW_symsort";
2627 case 0x6ffffff2: return "SUNW_tlssort";
2628 case 0x6ffffff3: return "SUNW_LDYNSYM";
2629 case 0x6ffffff4: return "SUNW_dof";
2630 case 0x6ffffff5: return "SUNW_cap";
2631 case 0x6ffffff6: return "SUNW_SIGNATURE";
2632 case 0x6ffffff7: return "SUNW_ANNOTATE";
2633 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2634 case 0x6ffffff9: return "SUNW_DEBUG";
2635 case 0x6ffffffa: return "SUNW_move";
2636 case 0x6ffffffb: return "SUNW_COMDAT";
2637 case 0x6ffffffc: return "SUNW_syminfo";
2638 case 0x6ffffffd: return "SUNW_verdef";
2639 case 0x6ffffffe: return "SUNW_verneed";
2640 case 0x6fffffff: return "SUNW_versym";
2641 case 0x70000000: return "SPARC_GOTDATA";
2642 default: return NULL
;
2647 get_alpha_dynamic_type (unsigned long type
)
2651 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2652 default: return NULL
;
2657 get_score_dynamic_type (unsigned long type
)
2661 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2662 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2663 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2664 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2665 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2666 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2667 default: return NULL
;
2672 get_tic6x_dynamic_type (unsigned long type
)
2676 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2677 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2678 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2679 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2680 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2681 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2682 default: return NULL
;
2687 get_nios2_dynamic_type (unsigned long type
)
2691 case DT_NIOS2_GP
: return "NIOS2_GP";
2692 default: return NULL
;
2697 get_solaris_dynamic_type (unsigned long type
)
2701 case 0x6000000d: return "SUNW_AUXILIARY";
2702 case 0x6000000e: return "SUNW_RTLDINF";
2703 case 0x6000000f: return "SUNW_FILTER";
2704 case 0x60000010: return "SUNW_CAP";
2705 case 0x60000011: return "SUNW_SYMTAB";
2706 case 0x60000012: return "SUNW_SYMSZ";
2707 case 0x60000013: return "SUNW_SORTENT";
2708 case 0x60000014: return "SUNW_SYMSORT";
2709 case 0x60000015: return "SUNW_SYMSORTSZ";
2710 case 0x60000016: return "SUNW_TLSSORT";
2711 case 0x60000017: return "SUNW_TLSSORTSZ";
2712 case 0x60000018: return "SUNW_CAPINFO";
2713 case 0x60000019: return "SUNW_STRPAD";
2714 case 0x6000001a: return "SUNW_CAPCHAIN";
2715 case 0x6000001b: return "SUNW_LDMACH";
2716 case 0x6000001d: return "SUNW_CAPCHAINENT";
2717 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2718 case 0x60000021: return "SUNW_PARENT";
2719 case 0x60000023: return "SUNW_ASLR";
2720 case 0x60000025: return "SUNW_RELAX";
2721 case 0x60000029: return "SUNW_NXHEAP";
2722 case 0x6000002b: return "SUNW_NXSTACK";
2724 case 0x70000001: return "SPARC_REGISTER";
2725 case 0x7ffffffd: return "AUXILIARY";
2726 case 0x7ffffffe: return "USED";
2727 case 0x7fffffff: return "FILTER";
2729 default: return NULL
;
2734 get_riscv_dynamic_type (unsigned long type
)
2738 case DT_RISCV_VARIANT_CC
: return "RISCV_VARIANT_CC";
2745 get_x86_64_dynamic_type (unsigned long type
)
2750 return "DT_X86_64_PLT";
2751 case DT_X86_64_PLTSZ
:
2752 return "DT_X86_64_PLTSZ";
2753 case DT_X86_64_PLTENT
:
2754 return "DT_X86_64_PLTENT";
2761 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2763 static char buff
[64];
2767 case DT_NULL
: return "NULL";
2768 case DT_NEEDED
: return "NEEDED";
2769 case DT_PLTRELSZ
: return "PLTRELSZ";
2770 case DT_PLTGOT
: return "PLTGOT";
2771 case DT_HASH
: return "HASH";
2772 case DT_STRTAB
: return "STRTAB";
2773 case DT_SYMTAB
: return "SYMTAB";
2774 case DT_RELA
: return "RELA";
2775 case DT_RELASZ
: return "RELASZ";
2776 case DT_RELAENT
: return "RELAENT";
2777 case DT_STRSZ
: return "STRSZ";
2778 case DT_SYMENT
: return "SYMENT";
2779 case DT_INIT
: return "INIT";
2780 case DT_FINI
: return "FINI";
2781 case DT_SONAME
: return "SONAME";
2782 case DT_RPATH
: return "RPATH";
2783 case DT_SYMBOLIC
: return "SYMBOLIC";
2784 case DT_REL
: return "REL";
2785 case DT_RELSZ
: return "RELSZ";
2786 case DT_RELENT
: return "RELENT";
2787 case DT_RELR
: return "RELR";
2788 case DT_RELRSZ
: return "RELRSZ";
2789 case DT_RELRENT
: return "RELRENT";
2790 case DT_PLTREL
: return "PLTREL";
2791 case DT_DEBUG
: return "DEBUG";
2792 case DT_TEXTREL
: return "TEXTREL";
2793 case DT_JMPREL
: return "JMPREL";
2794 case DT_BIND_NOW
: return "BIND_NOW";
2795 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2796 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2797 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2798 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2799 case DT_RUNPATH
: return "RUNPATH";
2800 case DT_FLAGS
: return "FLAGS";
2802 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2803 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2804 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2806 case DT_CHECKSUM
: return "CHECKSUM";
2807 case DT_PLTPADSZ
: return "PLTPADSZ";
2808 case DT_MOVEENT
: return "MOVEENT";
2809 case DT_MOVESZ
: return "MOVESZ";
2810 case DT_FEATURE
: return "FEATURE";
2811 case DT_POSFLAG_1
: return "POSFLAG_1";
2812 case DT_SYMINSZ
: return "SYMINSZ";
2813 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2815 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2816 case DT_CONFIG
: return "CONFIG";
2817 case DT_DEPAUDIT
: return "DEPAUDIT";
2818 case DT_AUDIT
: return "AUDIT";
2819 case DT_PLTPAD
: return "PLTPAD";
2820 case DT_MOVETAB
: return "MOVETAB";
2821 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2823 case DT_VERSYM
: return "VERSYM";
2825 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2826 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2827 case DT_RELACOUNT
: return "RELACOUNT";
2828 case DT_RELCOUNT
: return "RELCOUNT";
2829 case DT_FLAGS_1
: return "FLAGS_1";
2830 case DT_VERDEF
: return "VERDEF";
2831 case DT_VERDEFNUM
: return "VERDEFNUM";
2832 case DT_VERNEED
: return "VERNEED";
2833 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2835 case DT_AUXILIARY
: return "AUXILIARY";
2836 case DT_USED
: return "USED";
2837 case DT_FILTER
: return "FILTER";
2839 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2840 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2841 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2842 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2843 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2844 case DT_GNU_HASH
: return "GNU_HASH";
2845 case DT_GNU_FLAGS_1
: return "GNU_FLAGS_1";
2848 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2850 const char * result
;
2852 switch (filedata
->file_header
.e_machine
)
2855 result
= get_aarch64_dynamic_type (type
);
2858 case EM_MIPS_RS3_LE
:
2859 result
= get_mips_dynamic_type (type
);
2862 result
= get_sparc64_dynamic_type (type
);
2865 result
= get_ppc_dynamic_type (type
);
2868 result
= get_ppc64_dynamic_type (type
);
2871 result
= get_ia64_dynamic_type (type
);
2874 result
= get_alpha_dynamic_type (type
);
2877 result
= get_score_dynamic_type (type
);
2880 result
= get_tic6x_dynamic_type (type
);
2882 case EM_ALTERA_NIOS2
:
2883 result
= get_nios2_dynamic_type (type
);
2886 result
= get_riscv_dynamic_type (type
);
2889 result
= get_x86_64_dynamic_type (type
);
2892 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2893 result
= get_solaris_dynamic_type (type
);
2902 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2904 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2905 || (filedata
->file_header
.e_machine
== EM_PARISC
2906 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2908 const char * result
;
2910 switch (filedata
->file_header
.e_machine
)
2913 result
= get_parisc_dynamic_type (type
);
2916 result
= get_ia64_dynamic_type (type
);
2919 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2920 result
= get_solaris_dynamic_type (type
);
2929 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2933 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2939 static bool get_program_headers (Filedata
*);
2940 static bool get_dynamic_section (Filedata
*);
2943 locate_dynamic_section (Filedata
*filedata
)
2945 uint64_t dynamic_addr
= 0;
2946 uint64_t dynamic_size
= 0;
2948 if (filedata
->file_header
.e_phnum
!= 0
2949 && get_program_headers (filedata
))
2951 Elf_Internal_Phdr
*segment
;
2954 for (i
= 0, segment
= filedata
->program_headers
;
2955 i
< filedata
->file_header
.e_phnum
;
2958 if (segment
->p_type
== PT_DYNAMIC
)
2960 dynamic_addr
= segment
->p_offset
;
2961 dynamic_size
= segment
->p_filesz
;
2963 if (filedata
->section_headers
!= NULL
)
2965 Elf_Internal_Shdr
*sec
;
2967 sec
= find_section (filedata
, ".dynamic");
2970 if (sec
->sh_size
== 0
2971 || sec
->sh_type
== SHT_NOBITS
)
2978 dynamic_addr
= sec
->sh_offset
;
2979 dynamic_size
= sec
->sh_size
;
2984 if (dynamic_addr
> filedata
->file_size
2985 || (dynamic_size
> filedata
->file_size
- dynamic_addr
))
2994 filedata
->dynamic_addr
= dynamic_addr
;
2995 filedata
->dynamic_size
= dynamic_size
? dynamic_size
: 1;
2999 is_pie (Filedata
*filedata
)
3001 Elf_Internal_Dyn
*entry
;
3003 if (filedata
->dynamic_size
== 0)
3004 locate_dynamic_section (filedata
);
3005 if (filedata
->dynamic_size
<= 1)
3008 if (!get_dynamic_section (filedata
))
3011 for (entry
= filedata
->dynamic_section
;
3012 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
3015 if (entry
->d_tag
== DT_FLAGS_1
)
3017 if ((entry
->d_un
.d_val
& DF_1_PIE
) != 0)
3026 get_file_type (Filedata
*filedata
)
3028 unsigned e_type
= filedata
->file_header
.e_type
;
3029 static char buff
[64];
3033 case ET_NONE
: return _("NONE (None)");
3034 case ET_REL
: return _("REL (Relocatable file)");
3035 case ET_EXEC
: return _("EXEC (Executable file)");
3037 if (is_pie (filedata
))
3038 return _("DYN (Position-Independent Executable file)");
3040 return _("DYN (Shared object file)");
3041 case ET_CORE
: return _("CORE (Core file)");
3044 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
3045 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
3046 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
3047 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
3049 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
3055 get_machine_name (unsigned e_machine
)
3057 static char buff
[64]; /* XXX */
3061 /* Please keep this switch table sorted by increasing EM_ value. */
3063 case EM_NONE
: return _("None");
3064 case EM_M32
: return "WE32100";
3065 case EM_SPARC
: return "Sparc";
3066 case EM_386
: return "Intel 80386";
3067 case EM_68K
: return "MC68000";
3068 case EM_88K
: return "MC88000";
3069 case EM_IAMCU
: return "Intel MCU";
3070 case EM_860
: return "Intel 80860";
3071 case EM_MIPS
: return "MIPS R3000";
3072 case EM_S370
: return "IBM System/370";
3074 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
3075 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
3076 case EM_PARISC
: return "HPPA";
3077 case EM_VPP550
: return "Fujitsu VPP500";
3078 case EM_SPARC32PLUS
: return "Sparc v8+" ;
3079 case EM_960
: return "Intel 80960";
3080 case EM_PPC
: return "PowerPC";
3082 case EM_PPC64
: return "PowerPC64";
3084 case EM_S390
: return "IBM S/390";
3085 case EM_SPU
: return "SPU";
3087 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
3088 case EM_FR20
: return "Fujitsu FR20";
3089 case EM_RH32
: return "TRW RH32";
3090 case EM_MCORE
: return "MCORE";
3092 case EM_ARM
: return "ARM";
3093 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
3094 case EM_SH
: return "Renesas / SuperH SH";
3095 case EM_SPARCV9
: return "Sparc v9";
3096 case EM_TRICORE
: return "Siemens Tricore";
3097 case EM_ARC
: return "ARC";
3098 case EM_H8_300
: return "Renesas H8/300";
3099 case EM_H8_300H
: return "Renesas H8/300H";
3100 case EM_H8S
: return "Renesas H8S";
3101 case EM_H8_500
: return "Renesas H8/500";
3103 case EM_IA_64
: return "Intel IA-64";
3104 case EM_MIPS_X
: return "Stanford MIPS-X";
3105 case EM_COLDFIRE
: return "Motorola Coldfire";
3106 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
3107 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
3108 case EM_PCP
: return "Siemens PCP";
3109 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
3110 case EM_NDR1
: return "Denso NDR1 microprocessor";
3111 case EM_STARCORE
: return "Motorola Star*Core processor";
3112 case EM_ME16
: return "Toyota ME16 processor";
3114 case EM_ST100
: return "STMicroelectronics ST100 processor";
3115 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
3116 case EM_X86_64
: return "Advanced Micro Devices X86-64";
3117 case EM_PDSP
: return "Sony DSP processor";
3118 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
3119 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
3120 case EM_FX66
: return "Siemens FX66 microcontroller";
3121 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
3122 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
3123 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
3125 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
3126 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
3127 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
3128 case EM_SVX
: return "Silicon Graphics SVx";
3129 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
3130 case EM_VAX
: return "Digital VAX";
3131 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
3132 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
3133 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
3134 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
3136 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
3137 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
3138 case EM_PRISM
: return "Vitesse Prism";
3140 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
3141 case EM_CYGNUS_FR30
:
3142 case EM_FR30
: return "Fujitsu FR30";
3143 case EM_CYGNUS_D10V
:
3144 case EM_D10V
: return "d10v";
3145 case EM_CYGNUS_D30V
:
3146 case EM_D30V
: return "d30v";
3147 case EM_CYGNUS_V850
:
3148 case EM_V850
: return "Renesas V850";
3149 case EM_CYGNUS_M32R
:
3150 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
3151 case EM_CYGNUS_MN10300
:
3152 case EM_MN10300
: return "mn10300";
3154 case EM_CYGNUS_MN10200
:
3155 case EM_MN10200
: return "mn10200";
3156 case EM_PJ
: return "picoJava";
3157 case EM_OR1K
: return "OpenRISC 1000";
3158 case EM_ARC_COMPACT
: return "ARCompact";
3160 case EM_XTENSA
: return "Tensilica Xtensa Processor";
3161 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
3162 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
3163 case EM_NS32K
: return "National Semiconductor 32000 series";
3164 case EM_TPC
: return "Tenor Network TPC processor";
3165 case EM_SNP1K
: return "Trebia SNP 1000 processor";
3167 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
3169 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
3170 case EM_MAX
: return "MAX Processor";
3171 case EM_CR
: return "National Semiconductor CompactRISC";
3172 case EM_F2MC16
: return "Fujitsu F2MC16";
3173 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
3174 case EM_BLACKFIN
: return "Analog Devices Blackfin";
3175 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
3176 case EM_SEP
: return "Sharp embedded microprocessor";
3177 case EM_ARCA
: return "Arca RISC microprocessor";
3179 case EM_UNICORE
: return "Unicore";
3180 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
3181 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
3182 case EM_ALTERA_NIOS2
: return "Altera Nios II";
3183 case EM_CRX
: return "National Semiconductor CRX microprocessor";
3184 case EM_XGATE
: return "Motorola XGATE embedded processor";
3186 case EM_XC16X
: return "Infineon Technologies xc16x";
3187 case EM_M16C
: return "Renesas M16C series microprocessors";
3188 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
3189 case EM_CE
: return "Freescale Communication Engine RISC core";
3191 case EM_M32C
: return "Renesas M32c";
3193 case EM_TSK3000
: return "Altium TSK3000 core";
3194 case EM_RS08
: return "Freescale RS08 embedded processor";
3195 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
3196 case EM_SCORE
: return "SUNPLUS S+Core";
3197 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
3198 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
3199 case EM_LATTICEMICO32
: return "Lattice Mico32";
3200 case EM_SE_C17
: return "Seiko Epson C17 family";
3202 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
3203 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
3204 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
3205 case EM_TI_PRU
: return "TI PRU I/O processor";
3207 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
3208 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
3209 case EM_R32C
: return "Renesas R32C series microprocessors";
3210 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
3211 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
3212 case EM_8051
: return "Intel 8051 and variants";
3213 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
3214 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
3215 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
3216 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
3218 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
3219 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
3220 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
3221 case EM_RX
: return "Renesas RX";
3222 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
3223 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
3224 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
3227 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
3228 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
3229 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
3231 case EM_L1OM
: return "Intel L1OM";
3232 case EM_K1OM
: return "Intel K1OM";
3233 case EM_INTEL182
: return "Intel (reserved)";
3234 case EM_AARCH64
: return "AArch64";
3235 case EM_ARM184
: return "ARM (reserved)";
3236 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
3237 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
3238 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
3239 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
3241 case EM_CUDA
: return "NVIDIA CUDA architecture";
3242 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
3243 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
3244 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
3245 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
3246 case EM_ARC_COMPACT2
: return "ARCv2";
3247 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
3248 case EM_RL78
: return "Renesas RL78";
3249 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
3250 case EM_78K0R
: return "Renesas 78K0R";
3252 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
3253 case EM_BA1
: return "Beyond BA1 CPU architecture";
3254 case EM_BA2
: return "Beyond BA2 CPU architecture";
3255 case EM_XCORE
: return "XMOS xCORE processor family";
3256 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
3257 case EM_INTELGT
: return "Intel Graphics Technology";
3259 case EM_KM32
: return "KM211 KM32 32-bit processor";
3260 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
3261 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
3262 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
3263 case EM_KVARC
: return "KM211 KVARC processor";
3264 case EM_CDP
: return "Paneve CDP architecture family";
3265 case EM_COGE
: return "Cognitive Smart Memory Processor";
3266 case EM_COOL
: return "Bluechip Systems CoolEngine";
3267 case EM_NORC
: return "Nanoradio Optimized RISC";
3268 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
3270 case EM_Z80
: return "Zilog Z80";
3271 case EM_VISIUM
: return "CDS VISIUMcore processor";
3272 case EM_FT32
: return "FTDI Chip FT32";
3273 case EM_MOXIE
: return "Moxie";
3274 case EM_AMDGPU
: return "AMD GPU";
3275 /* 230 (all reserved) */
3277 case EM_RISCV
: return "RISC-V";
3278 case EM_LANAI
: return "Lanai 32-bit processor";
3279 case EM_CEVA
: return "CEVA Processor Architecture Family";
3280 case EM_CEVA_X2
: return "CEVA X2 Processor Family";
3281 case EM_BPF
: return "Linux BPF";
3282 case EM_GRAPHCORE_IPU
: return "Graphcore Intelligent Processing Unit";
3283 case EM_IMG1
: return "Imagination Technologies";
3285 case EM_NFP
: return "Netronome Flow Processor";
3286 case EM_VE
: return "NEC Vector Engine";
3287 case EM_CSKY
: return "C-SKY";
3288 case EM_ARC_COMPACT3_64
: return "Synopsys ARCv3 64-bit processor";
3289 case EM_MCS6502
: return "MOS Technology MCS 6502 processor";
3290 case EM_ARC_COMPACT3
: return "Synopsys ARCv3 32-bit processor";
3291 case EM_KVX
: return "Kalray VLIW core of the MPPA processor family";
3292 case EM_65816
: return "WDC 65816/65C816";
3293 case EM_LOONGARCH
: return "LoongArch";
3294 case EM_KF32
: return "ChipON KungFu32";
3296 /* Large numbers... */
3297 case EM_MT
: return "Morpho Techologies MT processor";
3298 case EM_ALPHA
: return "Alpha";
3299 case EM_WEBASSEMBLY
: return "Web Assembly";
3300 case EM_DLX
: return "OpenDLX";
3301 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
3302 case EM_IQ2000
: return "Vitesse IQ2000";
3304 case EM_NIOS32
: return "Altera Nios";
3305 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
3306 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
3307 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
3308 case EM_S12Z
: return "Freescale S12Z";
3311 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
3317 decode_ARC_machine_flags (char *out
, unsigned e_flags
, unsigned e_machine
)
3319 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
3320 other compilers don't specify an architecture type in the e_flags, and
3321 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
3322 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
3325 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
3326 but also sets a specific architecture type in the e_flags field.
3328 However, when decoding the flags we don't worry if we see an
3329 unexpected pairing, for example EM_ARC_COMPACT machine type, with
3330 ARCEM architecture type. */
3332 switch (e_flags
& EF_ARC_MACH_MSK
)
3334 /* We only expect these to occur for EM_ARC_COMPACT2. */
3335 case EF_ARC_CPU_ARCV2EM
:
3336 out
= stpcpy (out
, ", ARC EM");
3338 case EF_ARC_CPU_ARCV2HS
:
3339 out
= stpcpy (out
, ", ARC HS");
3342 /* We only expect these to occur for EM_ARC_COMPACT. */
3343 case E_ARC_MACH_ARC600
:
3344 out
= stpcpy (out
, ", ARC600");
3346 case E_ARC_MACH_ARC601
:
3347 out
= stpcpy (out
, ", ARC601");
3349 case E_ARC_MACH_ARC700
:
3350 out
= stpcpy (out
, ", ARC700");
3353 /* The only times we should end up here are (a) A corrupt ELF, (b) A
3354 new ELF with new architecture being read by an old version of
3355 readelf, or (c) An ELF built with non-GNU compiler that does not
3356 set the architecture in the e_flags. */
3358 if (e_machine
== EM_ARC_COMPACT
)
3359 out
= stpcpy (out
, ", Unknown ARCompact");
3361 out
= stpcpy (out
, ", Unknown ARC");
3365 switch (e_flags
& EF_ARC_OSABI_MSK
)
3367 case E_ARC_OSABI_ORIG
:
3368 out
= stpcpy (out
, ", (ABI:legacy)");
3370 case E_ARC_OSABI_V2
:
3371 out
= stpcpy (out
, ", (ABI:v2)");
3373 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
3374 case E_ARC_OSABI_V3
:
3375 out
= stpcpy (out
, ", v3 no-legacy-syscalls ABI");
3377 case E_ARC_OSABI_V4
:
3378 out
= stpcpy (out
, ", v4 ABI");
3381 out
= stpcpy (out
, ", unrecognised ARC OSABI flag");
3388 decode_ARM_machine_flags (char *out
, unsigned e_flags
)
3391 bool unknown
= false;
3393 eabi
= EF_ARM_EABI_VERSION (e_flags
);
3394 e_flags
&= ~ EF_ARM_EABIMASK
;
3396 /* Handle "generic" ARM flags. */
3397 if (e_flags
& EF_ARM_RELEXEC
)
3399 out
= stpcpy (out
, ", relocatable executable");
3400 e_flags
&= ~ EF_ARM_RELEXEC
;
3403 if (e_flags
& EF_ARM_PIC
)
3405 out
= stpcpy (out
, ", position independent");
3406 e_flags
&= ~ EF_ARM_PIC
;
3409 /* Now handle EABI specific flags. */
3413 out
= stpcpy (out
, ", <unrecognized EABI>");
3418 case EF_ARM_EABI_VER1
:
3419 out
= stpcpy (out
, ", Version1 EABI");
3424 /* Process flags one bit at a time. */
3425 flag
= e_flags
& - e_flags
;
3430 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
3431 out
= stpcpy (out
, ", sorted symbol tables");
3441 case EF_ARM_EABI_VER2
:
3442 out
= stpcpy (out
, ", Version2 EABI");
3447 /* Process flags one bit at a time. */
3448 flag
= e_flags
& - e_flags
;
3453 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
3454 out
= stpcpy (out
, ", sorted symbol tables");
3457 case EF_ARM_DYNSYMSUSESEGIDX
:
3458 out
= stpcpy (out
, ", dynamic symbols use segment index");
3461 case EF_ARM_MAPSYMSFIRST
:
3462 out
= stpcpy (out
, ", mapping symbols precede others");
3472 case EF_ARM_EABI_VER3
:
3473 out
= stpcpy (out
, ", Version3 EABI");
3476 case EF_ARM_EABI_VER4
:
3477 out
= stpcpy (out
, ", Version4 EABI");
3482 /* Process flags one bit at a time. */
3483 flag
= e_flags
& - e_flags
;
3489 out
= stpcpy (out
, ", BE8");
3493 out
= stpcpy (out
, ", LE8");
3503 case EF_ARM_EABI_VER5
:
3504 out
= stpcpy (out
, ", Version5 EABI");
3509 /* Process flags one bit at a time. */
3510 flag
= e_flags
& - e_flags
;
3516 out
= stpcpy (out
, ", BE8");
3520 out
= stpcpy (out
, ", LE8");
3523 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
3524 out
= stpcpy (out
, ", soft-float ABI");
3527 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
3528 out
= stpcpy (out
, ", hard-float ABI");
3538 case EF_ARM_EABI_UNKNOWN
:
3539 out
= stpcpy (out
, ", GNU EABI");
3544 /* Process flags one bit at a time. */
3545 flag
= e_flags
& - e_flags
;
3550 case EF_ARM_INTERWORK
:
3551 out
= stpcpy (out
, ", interworking enabled");
3554 case EF_ARM_APCS_26
:
3555 out
= stpcpy (out
, ", uses APCS/26");
3558 case EF_ARM_APCS_FLOAT
:
3559 out
= stpcpy (out
, ", uses APCS/float");
3563 out
= stpcpy (out
, ", position independent");
3567 out
= stpcpy (out
, ", 8 bit structure alignment");
3570 case EF_ARM_NEW_ABI
:
3571 out
= stpcpy (out
, ", uses new ABI");
3574 case EF_ARM_OLD_ABI
:
3575 out
= stpcpy (out
, ", uses old ABI");
3578 case EF_ARM_SOFT_FLOAT
:
3579 out
= stpcpy (out
, ", software FP");
3582 case EF_ARM_VFP_FLOAT
:
3583 out
= stpcpy (out
, ", VFP");
3586 case EF_ARM_MAVERICK_FLOAT
:
3587 out
= stpcpy (out
, ", Maverick FP");
3598 out
= stpcpy (out
,_(", <unknown>"));
3603 decode_AVR_machine_flags (char *out
, unsigned e_flags
)
3605 switch (e_flags
& EF_AVR_MACH
)
3607 case E_AVR_MACH_AVR1
:
3608 out
= stpcpy (out
, ", avr:1");
3610 case E_AVR_MACH_AVR2
:
3611 out
= stpcpy (out
, ", avr:2");
3613 case E_AVR_MACH_AVR25
:
3614 out
= stpcpy (out
, ", avr:25");
3616 case E_AVR_MACH_AVR3
:
3617 out
= stpcpy (out
, ", avr:3");
3619 case E_AVR_MACH_AVR31
:
3620 out
= stpcpy (out
, ", avr:31");
3622 case E_AVR_MACH_AVR35
:
3623 out
= stpcpy (out
, ", avr:35");
3625 case E_AVR_MACH_AVR4
:
3626 out
= stpcpy (out
, ", avr:4");
3628 case E_AVR_MACH_AVR5
:
3629 out
= stpcpy (out
, ", avr:5");
3631 case E_AVR_MACH_AVR51
:
3632 out
= stpcpy (out
, ", avr:51");
3634 case E_AVR_MACH_AVR6
:
3635 out
= stpcpy (out
, ", avr:6");
3637 case E_AVR_MACH_AVRTINY
:
3638 out
= stpcpy (out
, ", avr:100");
3640 case E_AVR_MACH_XMEGA1
:
3641 out
= stpcpy (out
, ", avr:101");
3643 case E_AVR_MACH_XMEGA2
:
3644 out
= stpcpy (out
, ", avr:102");
3646 case E_AVR_MACH_XMEGA3
:
3647 out
= stpcpy (out
, ", avr:103");
3649 case E_AVR_MACH_XMEGA4
:
3650 out
= stpcpy (out
, ", avr:104");
3652 case E_AVR_MACH_XMEGA5
:
3653 out
= stpcpy (out
, ", avr:105");
3655 case E_AVR_MACH_XMEGA6
:
3656 out
= stpcpy (out
, ", avr:106");
3658 case E_AVR_MACH_XMEGA7
:
3659 out
= stpcpy (out
, ", avr:107");
3662 out
= stpcpy (out
, ", avr:<unknown>");
3666 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
3667 out
= stpcpy (out
, ", link-relax");
3672 decode_BLACKFIN_machine_flags (char *out
, unsigned e_flags
)
3674 if (e_flags
& EF_BFIN_PIC
)
3675 out
= stpcpy (out
, ", PIC");
3677 if (e_flags
& EF_BFIN_FDPIC
)
3678 out
= stpcpy (out
, ", FDPIC");
3680 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3681 out
= stpcpy (out
, ", code in L1");
3683 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3684 out
= stpcpy (out
, ", data in L1");
3689 decode_FRV_machine_flags (char *out
, unsigned e_flags
)
3691 switch (e_flags
& EF_FRV_CPU_MASK
)
3693 case EF_FRV_CPU_GENERIC
:
3697 out
= stpcpy (out
, ", fr???");
3700 case EF_FRV_CPU_FR300
:
3701 out
= stpcpy (out
, ", fr300");
3704 case EF_FRV_CPU_FR400
:
3705 out
= stpcpy (out
, ", fr400");
3707 case EF_FRV_CPU_FR405
:
3708 out
= stpcpy (out
, ", fr405");
3711 case EF_FRV_CPU_FR450
:
3712 out
= stpcpy (out
, ", fr450");
3715 case EF_FRV_CPU_FR500
:
3716 out
= stpcpy (out
, ", fr500");
3718 case EF_FRV_CPU_FR550
:
3719 out
= stpcpy (out
, ", fr550");
3722 case EF_FRV_CPU_SIMPLE
:
3723 out
= stpcpy (out
, ", simple");
3725 case EF_FRV_CPU_TOMCAT
:
3726 out
= stpcpy (out
, ", tomcat");
3733 decode_IA64_machine_flags (char *out
, unsigned e_flags
, Filedata
*filedata
)
3735 if ((e_flags
& EF_IA_64_ABI64
))
3736 out
= stpcpy (out
, ", 64-bit");
3738 out
= stpcpy (out
, ", 32-bit");
3739 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3740 out
= stpcpy (out
, ", reduced fp model");
3741 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3742 out
= stpcpy (out
, ", no function descriptors, constant gp");
3743 else if ((e_flags
& EF_IA_64_CONS_GP
))
3744 out
= stpcpy (out
, ", constant gp");
3745 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3746 out
= stpcpy (out
, ", absolute");
3747 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3749 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3750 out
= stpcpy (out
, ", vms_linkages");
3751 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3753 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3755 case EF_IA_64_VMS_COMCOD_WARNING
:
3756 out
= stpcpy (out
, ", warning");
3758 case EF_IA_64_VMS_COMCOD_ERROR
:
3759 out
= stpcpy (out
, ", error");
3761 case EF_IA_64_VMS_COMCOD_ABORT
:
3762 out
= stpcpy (out
, ", abort");
3765 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3766 e_flags
& EF_IA_64_VMS_COMCOD
);
3767 out
= stpcpy (out
, ", <unknown>");
3774 decode_LOONGARCH_machine_flags (char *out
, unsigned int e_flags
)
3776 if (EF_LOONGARCH_IS_SOFT_FLOAT (e_flags
))
3777 out
= stpcpy (out
, ", SOFT-FLOAT");
3778 else if (EF_LOONGARCH_IS_SINGLE_FLOAT (e_flags
))
3779 out
= stpcpy (out
, ", SINGLE-FLOAT");
3780 else if (EF_LOONGARCH_IS_DOUBLE_FLOAT (e_flags
))
3781 out
= stpcpy (out
, ", DOUBLE-FLOAT");
3783 if (EF_LOONGARCH_IS_OBJ_V0 (e_flags
))
3784 out
= stpcpy (out
, ", OBJ-v0");
3785 else if (EF_LOONGARCH_IS_OBJ_V1 (e_flags
))
3786 out
= stpcpy (out
, ", OBJ-v1");
3791 decode_M68K_machine_flags (char *out
, unsigned int e_flags
)
3793 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3794 out
= stpcpy (out
, ", m68000");
3795 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3796 out
= stpcpy (out
, ", cpu32");
3797 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3798 out
= stpcpy (out
, ", fido_a");
3801 char const *isa
= _("unknown");
3802 char const *mac
= _("unknown mac");
3803 char const *additional
= NULL
;
3805 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3807 case EF_M68K_CF_ISA_A_NODIV
:
3809 additional
= ", nodiv";
3811 case EF_M68K_CF_ISA_A
:
3814 case EF_M68K_CF_ISA_A_PLUS
:
3817 case EF_M68K_CF_ISA_B_NOUSP
:
3819 additional
= ", nousp";
3821 case EF_M68K_CF_ISA_B
:
3824 case EF_M68K_CF_ISA_C
:
3827 case EF_M68K_CF_ISA_C_NODIV
:
3829 additional
= ", nodiv";
3832 out
= stpcpy (out
, ", cf, isa ");
3833 out
= stpcpy (out
, isa
);
3835 out
= stpcpy (out
, additional
);
3836 if (e_flags
& EF_M68K_CF_FLOAT
)
3837 out
= stpcpy (out
, ", float");
3838 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3843 case EF_M68K_CF_MAC
:
3846 case EF_M68K_CF_EMAC
:
3849 case EF_M68K_CF_EMAC_B
:
3855 out
= stpcpy (out
, ", ");
3856 out
= stpcpy (out
, mac
);
3863 decode_MeP_machine_flags (char *out
, unsigned int e_flags
)
3865 switch (e_flags
& EF_MEP_CPU_MASK
)
3867 case EF_MEP_CPU_MEP
:
3868 out
= stpcpy (out
, ", generic MeP");
3871 out
= stpcpy (out
, ", MeP C2");
3874 out
= stpcpy (out
, ", MeP C3");
3877 out
= stpcpy (out
, ", MeP C4");
3880 out
= stpcpy (out
, ", MeP C5");
3883 out
= stpcpy (out
, ", MeP H1");
3886 out
= stpcpy (out
, _(", <unknown MeP cpu type>"));
3890 switch (e_flags
& EF_MEP_COP_MASK
)
3892 case EF_MEP_COP_NONE
:
3894 case EF_MEP_COP_AVC
:
3895 out
= stpcpy (out
, ", AVC coprocessor");
3897 case EF_MEP_COP_AVC2
:
3898 out
= stpcpy (out
, ", AVC2 coprocessor");
3900 case EF_MEP_COP_FMAX
:
3901 out
= stpcpy (out
, ", FMAX coprocessor");
3903 case EF_MEP_COP_IVC2
:
3904 out
= stpcpy (out
, ", IVC2 coprocessor");
3907 out
= stpcpy (out
, _("<unknown MeP copro type>"));
3911 if (e_flags
& EF_MEP_LIBRARY
)
3912 out
= stpcpy (out
, ", Built for Library");
3914 if (e_flags
& EF_MEP_INDEX_MASK
)
3915 out
+= sprintf (out
, ", Configuration Index: %#x",
3916 e_flags
& EF_MEP_INDEX_MASK
);
3918 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3919 out
+= sprintf (out
, _(", unknown flags bits: %#x"),
3920 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3925 decode_MIPS_machine_flags (char *out
, unsigned int e_flags
)
3927 if (e_flags
& EF_MIPS_NOREORDER
)
3928 out
= stpcpy (out
, ", noreorder");
3930 if (e_flags
& EF_MIPS_PIC
)
3931 out
= stpcpy (out
, ", pic");
3933 if (e_flags
& EF_MIPS_CPIC
)
3934 out
= stpcpy (out
, ", cpic");
3936 if (e_flags
& EF_MIPS_UCODE
)
3937 out
= stpcpy (out
, ", ugen_reserved");
3939 if (e_flags
& EF_MIPS_ABI2
)
3940 out
= stpcpy (out
, ", abi2");
3942 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3943 out
= stpcpy (out
, ", odk first");
3945 if (e_flags
& EF_MIPS_32BITMODE
)
3946 out
= stpcpy (out
, ", 32bitmode");
3948 if (e_flags
& EF_MIPS_NAN2008
)
3949 out
= stpcpy (out
, ", nan2008");
3951 if (e_flags
& EF_MIPS_FP64
)
3952 out
= stpcpy (out
, ", fp64");
3954 switch ((e_flags
& EF_MIPS_MACH
))
3956 case EF_MIPS_MACH_3900
:
3957 out
= stpcpy (out
, ", 3900");
3959 case EF_MIPS_MACH_4010
:
3960 out
= stpcpy (out
, ", 4010");
3962 case EF_MIPS_MACH_4100
:
3963 out
= stpcpy (out
, ", 4100");
3965 case EF_MIPS_MACH_4111
:
3966 out
= stpcpy (out
, ", 4111");
3968 case EF_MIPS_MACH_4120
:
3969 out
= stpcpy (out
, ", 4120");
3971 case EF_MIPS_MACH_4650
:
3972 out
= stpcpy (out
, ", 4650");
3974 case EF_MIPS_MACH_5400
:
3975 out
= stpcpy (out
, ", 5400");
3977 case EF_MIPS_MACH_5500
:
3978 out
= stpcpy (out
, ", 5500");
3980 case EF_MIPS_MACH_5900
:
3981 out
= stpcpy (out
, ", 5900");
3983 case EF_MIPS_MACH_SB1
:
3984 out
= stpcpy (out
, ", sb1");
3986 case EF_MIPS_MACH_9000
:
3987 out
= stpcpy (out
, ", 9000");
3989 case EF_MIPS_MACH_LS2E
:
3990 out
= stpcpy (out
, ", loongson-2e");
3992 case EF_MIPS_MACH_LS2F
:
3993 out
= stpcpy (out
, ", loongson-2f");
3995 case EF_MIPS_MACH_GS464
:
3996 out
= stpcpy (out
, ", gs464");
3998 case EF_MIPS_MACH_GS464E
:
3999 out
= stpcpy (out
, ", gs464e");
4001 case EF_MIPS_MACH_GS264E
:
4002 out
= stpcpy (out
, ", gs264e");
4004 case EF_MIPS_MACH_OCTEON
:
4005 out
= stpcpy (out
, ", octeon");
4007 case EF_MIPS_MACH_OCTEON2
:
4008 out
= stpcpy (out
, ", octeon2");
4010 case EF_MIPS_MACH_OCTEON3
:
4011 out
= stpcpy (out
, ", octeon3");
4013 case EF_MIPS_MACH_XLR
:
4014 out
= stpcpy (out
, ", xlr");
4016 case EF_MIPS_MACH_IAMR2
:
4017 out
= stpcpy (out
, ", interaptiv-mr2");
4019 case EF_MIPS_MACH_ALLEGREX
:
4020 out
= stpcpy (out
, ", allegrex");
4023 /* We simply ignore the field in this case to avoid confusion:
4024 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
4028 out
= stpcpy (out
, _(", unknown CPU"));
4032 switch ((e_flags
& EF_MIPS_ABI
))
4034 case EF_MIPS_ABI_O32
:
4035 out
= stpcpy (out
, ", o32");
4037 case EF_MIPS_ABI_O64
:
4038 out
= stpcpy (out
, ", o64");
4040 case EF_MIPS_ABI_EABI32
:
4041 out
= stpcpy (out
, ", eabi32");
4043 case EF_MIPS_ABI_EABI64
:
4044 out
= stpcpy (out
, ", eabi64");
4047 /* We simply ignore the field in this case to avoid confusion:
4048 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
4049 This means it is likely to be an o32 file, but not for
4053 out
= stpcpy (out
, _(", unknown ABI"));
4057 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
4058 out
= stpcpy (out
, ", mdmx");
4060 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
4061 out
= stpcpy (out
, ", mips16");
4063 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
4064 out
= stpcpy (out
, ", micromips");
4066 switch ((e_flags
& EF_MIPS_ARCH
))
4068 case EF_MIPS_ARCH_1
:
4069 out
= stpcpy (out
, ", mips1");
4071 case EF_MIPS_ARCH_2
:
4072 out
= stpcpy (out
, ", mips2");
4074 case EF_MIPS_ARCH_3
:
4075 out
= stpcpy (out
, ", mips3");
4077 case EF_MIPS_ARCH_4
:
4078 out
= stpcpy (out
, ", mips4");
4080 case EF_MIPS_ARCH_5
:
4081 out
= stpcpy (out
, ", mips5");
4083 case EF_MIPS_ARCH_32
:
4084 out
= stpcpy (out
, ", mips32");
4086 case EF_MIPS_ARCH_32R2
:
4087 out
= stpcpy (out
, ", mips32r2");
4089 case EF_MIPS_ARCH_32R6
:
4090 out
= stpcpy (out
, ", mips32r6");
4092 case EF_MIPS_ARCH_64
:
4093 out
= stpcpy (out
, ", mips64");
4095 case EF_MIPS_ARCH_64R2
:
4096 out
= stpcpy (out
, ", mips64r2");
4098 case EF_MIPS_ARCH_64R6
:
4099 out
= stpcpy (out
, ", mips64r6");
4102 out
= stpcpy (out
, _(", unknown ISA"));
4109 decode_MSP430_machine_flags (char *out
, unsigned e_flags
)
4111 out
= stpcpy (out
, _(": architecture variant: "));
4112 switch (e_flags
& EF_MSP430_MACH
)
4114 case E_MSP430_MACH_MSP430x11
:
4115 out
= stpcpy (out
, "MSP430x11");
4117 case E_MSP430_MACH_MSP430x11x1
:
4118 out
= stpcpy (out
, "MSP430x11x1 ");
4120 case E_MSP430_MACH_MSP430x12
:
4121 out
= stpcpy (out
, "MSP430x12");
4123 case E_MSP430_MACH_MSP430x13
:
4124 out
= stpcpy (out
, "MSP430x13");
4126 case E_MSP430_MACH_MSP430x14
:
4127 out
= stpcpy (out
, "MSP430x14");
4129 case E_MSP430_MACH_MSP430x15
:
4130 out
= stpcpy (out
, "MSP430x15");
4132 case E_MSP430_MACH_MSP430x16
:
4133 out
= stpcpy (out
, "MSP430x16");
4135 case E_MSP430_MACH_MSP430x31
:
4136 out
= stpcpy (out
, "MSP430x31");
4138 case E_MSP430_MACH_MSP430x32
:
4139 out
= stpcpy (out
, "MSP430x32");
4141 case E_MSP430_MACH_MSP430x33
:
4142 out
= stpcpy (out
, "MSP430x33");
4144 case E_MSP430_MACH_MSP430x41
:
4145 out
= stpcpy (out
, "MSP430x41");
4147 case E_MSP430_MACH_MSP430x42
:
4148 out
= stpcpy (out
, "MSP430x42");
4150 case E_MSP430_MACH_MSP430x43
:
4151 out
= stpcpy (out
, "MSP430x43");
4153 case E_MSP430_MACH_MSP430x44
:
4154 out
= stpcpy (out
, "MSP430x44");
4156 case E_MSP430_MACH_MSP430X
:
4157 out
= stpcpy (out
, "MSP430X");
4160 out
= stpcpy (out
, _(": unknown"));
4164 if (e_flags
& ~ EF_MSP430_MACH
)
4165 out
= stpcpy (out
, _(": unknown extra flag bits also present"));
4170 decode_NDS32_machine_flags (char *out
, unsigned e_flags
)
4176 bool has_fpu
= false;
4178 static const char *ABI_STRINGS
[] =
4180 "ABI v0", /* use r5 as return register; only used in N1213HC */
4181 "ABI v1", /* use r0 as return register */
4182 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
4183 "ABI v2fp", /* for FPU */
4187 static const char *VER_STRINGS
[] =
4189 "Andes ELF V1.3 or older",
4193 static const char *ARCH_STRINGS
[] =
4202 abi
= EF_NDS_ABI
& e_flags
;
4203 arch
= EF_NDS_ARCH
& e_flags
;
4204 config
= EF_NDS_INST
& e_flags
;
4205 version
= EF_NDS32_ELF_VERSION
& e_flags
;
4212 case E_NDS_ABI_V2FP
:
4213 case E_NDS_ABI_AABI
:
4214 case E_NDS_ABI_V2FP_PLUS
:
4215 /* In case there are holes in the array. */
4216 out
+= sprintf (out
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
4220 out
= stpcpy (out
, ", <unrecognized ABI>");
4226 case E_NDS32_ELF_VER_1_2
:
4227 case E_NDS32_ELF_VER_1_3
:
4228 case E_NDS32_ELF_VER_1_4
:
4229 out
+= sprintf (out
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
4233 out
= stpcpy (out
, ", <unrecognized ELF version number>");
4237 if (E_NDS_ABI_V0
== abi
)
4239 /* OLD ABI; only used in N1213HC, has performance extension 1. */
4240 out
= stpcpy (out
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
4241 if (arch
== E_NDS_ARCH_STAR_V1_0
)
4242 out
= stpcpy (out
, ", 16b"); /* has 16-bit instructions */
4248 case E_NDS_ARCH_STAR_V1_0
:
4249 case E_NDS_ARCH_STAR_V2_0
:
4250 case E_NDS_ARCH_STAR_V3_0
:
4251 case E_NDS_ARCH_STAR_V3_M
:
4252 out
+= sprintf (out
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
4256 out
= stpcpy (out
, ", <unrecognized architecture>");
4257 /* ARCH version determines how the e_flags are interpreted.
4258 If it is unknown, we cannot proceed. */
4262 /* Newer ABI; Now handle architecture specific flags. */
4263 if (arch
== E_NDS_ARCH_STAR_V1_0
)
4265 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
4266 out
= stpcpy (out
, ", MFUSR_PC");
4268 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
4269 out
= stpcpy (out
, ", MAC");
4271 if (config
& E_NDS32_HAS_DIV_INST
)
4272 out
= stpcpy (out
, ", DIV");
4274 if (config
& E_NDS32_HAS_16BIT_INST
)
4275 out
= stpcpy (out
, ", 16b");
4279 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
4281 if (version
<= E_NDS32_ELF_VER_1_3
)
4282 out
= stpcpy (out
, ", [B8]");
4284 out
= stpcpy (out
, ", EX9");
4287 if (config
& E_NDS32_HAS_MAC_DX_INST
)
4288 out
= stpcpy (out
, ", MAC_DX");
4290 if (config
& E_NDS32_HAS_DIV_DX_INST
)
4291 out
= stpcpy (out
, ", DIV_DX");
4293 if (config
& E_NDS32_HAS_16BIT_INST
)
4295 if (version
<= E_NDS32_ELF_VER_1_3
)
4296 out
= stpcpy (out
, ", 16b");
4298 out
= stpcpy (out
, ", IFC");
4302 if (config
& E_NDS32_HAS_EXT_INST
)
4303 out
= stpcpy (out
, ", PERF1");
4305 if (config
& E_NDS32_HAS_EXT2_INST
)
4306 out
= stpcpy (out
, ", PERF2");
4308 if (config
& E_NDS32_HAS_FPU_INST
)
4311 out
= stpcpy (out
, ", FPU_SP");
4314 if (config
& E_NDS32_HAS_FPU_DP_INST
)
4317 out
= stpcpy (out
, ", FPU_DP");
4320 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
4323 out
= stpcpy (out
, ", FPU_MAC");
4328 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
4330 case E_NDS32_FPU_REG_8SP_4DP
:
4331 out
= stpcpy (out
, ", FPU_REG:8/4");
4333 case E_NDS32_FPU_REG_16SP_8DP
:
4334 out
= stpcpy (out
, ", FPU_REG:16/8");
4336 case E_NDS32_FPU_REG_32SP_16DP
:
4337 out
= stpcpy (out
, ", FPU_REG:32/16");
4339 case E_NDS32_FPU_REG_32SP_32DP
:
4340 out
= stpcpy (out
, ", FPU_REG:32/32");
4345 if (config
& E_NDS32_HAS_AUDIO_INST
)
4346 out
= stpcpy (out
, ", AUDIO");
4348 if (config
& E_NDS32_HAS_STRING_INST
)
4349 out
= stpcpy (out
, ", STR");
4351 if (config
& E_NDS32_HAS_REDUCED_REGS
)
4352 out
= stpcpy (out
, ", 16REG");
4354 if (config
& E_NDS32_HAS_VIDEO_INST
)
4356 if (version
<= E_NDS32_ELF_VER_1_3
)
4357 out
= stpcpy (out
, ", VIDEO");
4359 out
= stpcpy (out
, ", SATURATION");
4362 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
4363 out
= stpcpy (out
, ", ENCRP");
4365 if (config
& E_NDS32_HAS_L2C_INST
)
4366 out
= stpcpy (out
, ", L2C");
4372 decode_PARISC_machine_flags (char *out
, unsigned e_flags
)
4374 switch (e_flags
& EF_PARISC_ARCH
)
4376 case EFA_PARISC_1_0
:
4377 out
= stpcpy (out
, ", PA-RISC 1.0");
4379 case EFA_PARISC_1_1
:
4380 out
= stpcpy (out
, ", PA-RISC 1.1");
4382 case EFA_PARISC_2_0
:
4383 out
= stpcpy (out
, ", PA-RISC 2.0");
4388 if (e_flags
& EF_PARISC_TRAPNIL
)
4389 out
= stpcpy (out
, ", trapnil");
4390 if (e_flags
& EF_PARISC_EXT
)
4391 out
= stpcpy (out
, ", ext");
4392 if (e_flags
& EF_PARISC_LSB
)
4393 out
= stpcpy (out
, ", lsb");
4394 if (e_flags
& EF_PARISC_WIDE
)
4395 out
= stpcpy (out
, ", wide");
4396 if (e_flags
& EF_PARISC_NO_KABP
)
4397 out
= stpcpy (out
, ", no kabp");
4398 if (e_flags
& EF_PARISC_LAZYSWAP
)
4399 out
= stpcpy (out
, ", lazyswap");
4404 decode_RISCV_machine_flags (char *out
, unsigned e_flags
)
4406 if (e_flags
& EF_RISCV_RVC
)
4407 out
= stpcpy (out
, ", RVC");
4409 if (e_flags
& EF_RISCV_RVE
)
4410 out
= stpcpy (out
, ", RVE");
4412 if (e_flags
& EF_RISCV_TSO
)
4413 out
= stpcpy (out
, ", TSO");
4415 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
4417 case EF_RISCV_FLOAT_ABI_SOFT
:
4418 out
= stpcpy (out
, ", soft-float ABI");
4421 case EF_RISCV_FLOAT_ABI_SINGLE
:
4422 out
= stpcpy (out
, ", single-float ABI");
4425 case EF_RISCV_FLOAT_ABI_DOUBLE
:
4426 out
= stpcpy (out
, ", double-float ABI");
4429 case EF_RISCV_FLOAT_ABI_QUAD
:
4430 out
= stpcpy (out
, ", quad-float ABI");
4437 decode_RL78_machine_flags (char *out
, unsigned e_flags
)
4439 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
4441 case E_FLAG_RL78_ANY_CPU
:
4443 case E_FLAG_RL78_G10
:
4444 out
= stpcpy (out
, ", G10");
4446 case E_FLAG_RL78_G13
:
4447 out
= stpcpy (out
, ", G13");
4449 case E_FLAG_RL78_G14
:
4450 out
= stpcpy (out
, ", G14");
4453 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
4454 out
= stpcpy (out
, ", 64-bit doubles");
4459 decode_RX_machine_flags (char *out
, unsigned e_flags
)
4461 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
4462 out
= stpcpy (out
, ", 64-bit doubles");
4463 if (e_flags
& E_FLAG_RX_DSP
)
4464 out
= stpcpy (out
, ", dsp");
4465 if (e_flags
& E_FLAG_RX_PID
)
4466 out
= stpcpy (out
, ", pid");
4467 if (e_flags
& E_FLAG_RX_ABI
)
4468 out
= stpcpy (out
, ", RX ABI");
4469 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
4470 out
= stpcpy (out
, (e_flags
& E_FLAG_RX_SINSNS_YES
4471 ? ", uses String instructions"
4472 : ", bans String instructions"));
4473 if (e_flags
& E_FLAG_RX_V2
)
4474 out
= stpcpy (out
, ", V2");
4475 if (e_flags
& E_FLAG_RX_V3
)
4476 out
= stpcpy (out
, ", V3");
4481 decode_SH_machine_flags (char *out
, unsigned e_flags
)
4483 switch ((e_flags
& EF_SH_MACH_MASK
))
4486 out
= stpcpy (out
, ", sh1");
4489 out
= stpcpy (out
, ", sh2");
4492 out
= stpcpy (out
, ", sh3");
4495 out
= stpcpy (out
, ", sh-dsp");
4498 out
= stpcpy (out
, ", sh3-dsp");
4501 out
= stpcpy (out
, ", sh4al-dsp");
4504 out
= stpcpy (out
, ", sh3e");
4507 out
= stpcpy (out
, ", sh4");
4510 out
= stpcpy (out
, ", sh5");
4513 out
= stpcpy (out
, ", sh2e");
4516 out
= stpcpy (out
, ", sh4a");
4519 out
= stpcpy (out
, ", sh2a");
4522 out
= stpcpy (out
, ", sh4-nofpu");
4525 out
= stpcpy (out
, ", sh4a-nofpu");
4528 out
= stpcpy (out
, ", sh2a-nofpu");
4531 out
= stpcpy (out
, ", sh3-nommu");
4533 case EF_SH4_NOMMU_NOFPU
:
4534 out
= stpcpy (out
, ", sh4-nommu-nofpu");
4536 case EF_SH2A_SH4_NOFPU
:
4537 out
= stpcpy (out
, ", sh2a-nofpu-or-sh4-nommu-nofpu");
4539 case EF_SH2A_SH3_NOFPU
:
4540 out
= stpcpy (out
, ", sh2a-nofpu-or-sh3-nommu");
4543 out
= stpcpy (out
, ", sh2a-or-sh4");
4546 out
= stpcpy (out
, ", sh2a-or-sh3e");
4549 out
= stpcpy (out
, _(", unknown ISA"));
4553 if (e_flags
& EF_SH_PIC
)
4554 out
= stpcpy (out
, ", pic");
4556 if (e_flags
& EF_SH_FDPIC
)
4557 out
= stpcpy (out
, ", fdpic");
4562 decode_SPARC_machine_flags (char *out
, unsigned e_flags
)
4564 if (e_flags
& EF_SPARC_32PLUS
)
4565 out
= stpcpy (out
, ", v8+");
4567 if (e_flags
& EF_SPARC_SUN_US1
)
4568 out
= stpcpy (out
, ", ultrasparcI");
4570 if (e_flags
& EF_SPARC_SUN_US3
)
4571 out
= stpcpy (out
, ", ultrasparcIII");
4573 if (e_flags
& EF_SPARC_HAL_R1
)
4574 out
= stpcpy (out
, ", halr1");
4576 if (e_flags
& EF_SPARC_LEDATA
)
4577 out
= stpcpy (out
, ", ledata");
4579 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
4580 out
= stpcpy (out
, ", tso");
4582 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
4583 out
= stpcpy (out
, ", pso");
4585 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
4586 out
= stpcpy (out
, ", rmo");
4591 decode_V800_machine_flags (char *out
, unsigned int e_flags
)
4593 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
4594 out
= stpcpy (out
, ", RH850 ABI");
4596 if (e_flags
& EF_V800_850E3
)
4597 out
= stpcpy (out
, ", V3 architecture");
4599 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
4600 out
= stpcpy (out
, ", FPU not used");
4602 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
4603 out
= stpcpy (out
, ", regmode: COMMON");
4605 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
4606 out
= stpcpy (out
, ", r4 not used");
4608 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
4609 out
= stpcpy (out
, ", r30 not used");
4611 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
4612 out
= stpcpy (out
, ", r5 not used");
4614 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
4615 out
= stpcpy (out
, ", r2 not used");
4617 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
4619 switch (e_flags
& - e_flags
)
4621 case EF_RH850_FPU_DOUBLE
:
4622 out
= stpcpy (out
, ", double precision FPU");
4624 case EF_RH850_FPU_SINGLE
:
4625 out
= stpcpy (out
, ", single precision FPU");
4627 case EF_RH850_REGMODE22
:
4628 out
= stpcpy (out
, ", regmode:22");
4630 case EF_RH850_REGMODE32
:
4631 out
= stpcpy (out
, ", regmode:23");
4633 case EF_RH850_GP_FIX
:
4634 out
= stpcpy (out
, ", r4 fixed");
4636 case EF_RH850_GP_NOFIX
:
4637 out
= stpcpy (out
, ", r4 free");
4639 case EF_RH850_EP_FIX
:
4640 out
= stpcpy (out
, ", r30 fixed");
4642 case EF_RH850_EP_NOFIX
:
4643 out
= stpcpy (out
, ", r30 free");
4645 case EF_RH850_TP_FIX
:
4646 out
= stpcpy (out
, ", r5 fixed");
4648 case EF_RH850_TP_NOFIX
:
4649 out
= stpcpy (out
, ", r5 free");
4651 case EF_RH850_REG2_RESERVE
:
4652 out
= stpcpy (out
, ", r2 fixed");
4654 case EF_RH850_REG2_NORESERVE
:
4655 out
= stpcpy (out
, ", r2 free");
4665 decode_V850_machine_flags (char *out
, unsigned int e_flags
)
4667 switch (e_flags
& EF_V850_ARCH
)
4669 case E_V850E3V5_ARCH
:
4670 out
= stpcpy (out
, ", v850e3v5");
4672 case E_V850E2V3_ARCH
:
4673 out
= stpcpy (out
, ", v850e2v3");
4676 out
= stpcpy (out
, ", v850e2");
4679 out
= stpcpy (out
, ", v850e1");
4682 out
= stpcpy (out
, ", v850e");
4685 out
= stpcpy (out
, ", v850");
4688 out
= stpcpy (out
, _(", unknown v850 architecture variant"));
4695 decode_Z80_machine_flags (char *out
, unsigned int e_flags
)
4697 switch (e_flags
& EF_Z80_MACH_MSK
)
4699 case EF_Z80_MACH_Z80
:
4700 out
= stpcpy (out
, ", Z80");
4702 case EF_Z80_MACH_Z180
:
4703 out
= stpcpy (out
, ", Z180");
4705 case EF_Z80_MACH_R800
:
4706 out
= stpcpy (out
, ", R800");
4708 case EF_Z80_MACH_EZ80_Z80
:
4709 out
= stpcpy (out
, ", EZ80");
4711 case EF_Z80_MACH_EZ80_ADL
:
4712 out
= stpcpy (out
, ", EZ80, ADL");
4714 case EF_Z80_MACH_GBZ80
:
4715 out
= stpcpy (out
, ", GBZ80");
4717 case EF_Z80_MACH_Z80N
:
4718 out
= stpcpy (out
, ", Z80N");
4721 out
= stpcpy (out
, _(", unknown"));
4728 decode_AMDGPU_machine_flags (char *out
, unsigned int e_flags
, Filedata
*filedata
)
4730 unsigned char *e_ident
= filedata
->file_header
.e_ident
;
4731 unsigned char osabi
= e_ident
[EI_OSABI
];
4732 unsigned char abiversion
= e_ident
[EI_ABIVERSION
];
4735 /* HSA OS ABI v2 used a different encoding, but we don't need to support it,
4736 it has been deprecated for a while.
4738 The PAL, MESA3D and NONE OS ABIs are not properly versioned, at the time
4739 of writing, they use the same flags as HSA v3, so the code below uses that
4741 if (osabi
== ELFOSABI_AMDGPU_HSA
&& abiversion
< ELFABIVERSION_AMDGPU_HSA_V3
)
4744 mach
= e_flags
& EF_AMDGPU_MACH
;
4747 #define AMDGPU_CASE(code, string) \
4748 case code: out = stpcpy (out, ", " string); break;
4749 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX600
, "gfx600")
4750 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX601
, "gfx601")
4751 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX700
, "gfx700")
4752 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX701
, "gfx701")
4753 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX702
, "gfx702")
4754 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX703
, "gfx703")
4755 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX704
, "gfx704")
4756 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX801
, "gfx801")
4757 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX802
, "gfx802")
4758 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX803
, "gfx803")
4759 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX810
, "gfx810")
4760 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX900
, "gfx900")
4761 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX902
, "gfx902")
4762 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX904
, "gfx904")
4763 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX906
, "gfx906")
4764 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX908
, "gfx908")
4765 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX909
, "gfx909")
4766 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX90C
, "gfx90c")
4767 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1010
, "gfx1010")
4768 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1011
, "gfx1011")
4769 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1012
, "gfx1012")
4770 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1030
, "gfx1030")
4771 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1031
, "gfx1031")
4772 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1032
, "gfx1032")
4773 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1033
, "gfx1033")
4774 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1100
, "gfx1100")
4775 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1101
, "gfx1101")
4776 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1102
, "gfx1102")
4777 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX602
, "gfx602")
4778 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX705
, "gfx705")
4779 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX805
, "gfx805")
4780 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1035
, "gfx1035")
4781 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1034
, "gfx1034")
4782 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX90A
, "gfx90a")
4783 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX940
, "gfx940")
4784 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1013
, "gfx1013")
4785 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1036
, "gfx1036")
4787 out
+= sprintf (out
, _(", <unknown AMDGPU GPU type: %#x>"), mach
);
4792 e_flags
&= ~EF_AMDGPU_MACH
;
4794 if ((osabi
== ELFOSABI_AMDGPU_HSA
4795 && abiversion
== ELFABIVERSION_AMDGPU_HSA_V3
)
4796 || osabi
!= ELFOSABI_AMDGPU_HSA
)
4798 /* For HSA v3 and other OS ABIs. */
4799 if (e_flags
& EF_AMDGPU_FEATURE_XNACK_V3
)
4801 out
= stpcpy (out
, ", xnack on");
4802 e_flags
&= ~EF_AMDGPU_FEATURE_XNACK_V3
;
4805 if (e_flags
& EF_AMDGPU_FEATURE_SRAMECC_V3
)
4807 out
= stpcpy (out
, ", sramecc on");
4808 e_flags
&= ~EF_AMDGPU_FEATURE_SRAMECC_V3
;
4816 xnack
= e_flags
& EF_AMDGPU_FEATURE_XNACK_V4
;
4819 case EF_AMDGPU_FEATURE_XNACK_UNSUPPORTED_V4
:
4822 case EF_AMDGPU_FEATURE_XNACK_ANY_V4
:
4823 out
= stpcpy (out
, ", xnack any");
4826 case EF_AMDGPU_FEATURE_XNACK_OFF_V4
:
4827 out
= stpcpy (out
, ", xnack off");
4830 case EF_AMDGPU_FEATURE_XNACK_ON_V4
:
4831 out
= stpcpy (out
, ", xnack on");
4835 out
+= sprintf (out
, _(", <unknown xnack value: %#x>"), xnack
);
4839 e_flags
&= ~EF_AMDGPU_FEATURE_XNACK_V4
;
4841 sramecc
= e_flags
& EF_AMDGPU_FEATURE_SRAMECC_V4
;
4844 case EF_AMDGPU_FEATURE_SRAMECC_UNSUPPORTED_V4
:
4847 case EF_AMDGPU_FEATURE_SRAMECC_ANY_V4
:
4848 out
= stpcpy (out
, ", sramecc any");
4851 case EF_AMDGPU_FEATURE_SRAMECC_OFF_V4
:
4852 out
= stpcpy (out
, ", sramecc off");
4855 case EF_AMDGPU_FEATURE_SRAMECC_ON_V4
:
4856 out
= stpcpy (out
, ", sramecc on");
4860 out
+= sprintf (out
, _(", <unknown sramecc value: %#x>"), sramecc
);
4864 e_flags
&= ~EF_AMDGPU_FEATURE_SRAMECC_V4
;
4868 out
+= sprintf (out
, _(", unknown flags bits: %#x"), e_flags
);
4873 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
4875 static char buf
[1024];
4887 case EM_ARC_COMPACT3
:
4888 out
= stpcpy (out
, ", HS5x");
4891 case EM_ARC_COMPACT3_64
:
4892 out
= stpcpy (out
, ", HS6x");
4895 case EM_ARC_COMPACT2
:
4896 case EM_ARC_COMPACT
:
4897 out
= decode_ARC_machine_flags (out
, e_flags
, e_machine
);
4901 out
= decode_ARM_machine_flags (out
, e_flags
);
4905 out
= decode_AVR_machine_flags (out
, e_flags
);
4909 out
= decode_BLACKFIN_machine_flags (out
, e_flags
);
4913 out
= decode_FRV_machine_flags (out
, e_flags
);
4917 out
= decode_M68K_machine_flags (out
, e_flags
);
4921 out
= decode_AMDGPU_machine_flags (out
, e_flags
, filedata
);
4925 out
= decode_MeP_machine_flags (out
, e_flags
);
4929 if (e_flags
& EF_PPC_EMB
)
4930 out
= stpcpy (out
, ", emb");
4932 if (e_flags
& EF_PPC_RELOCATABLE
)
4933 out
= stpcpy (out
, _(", relocatable"));
4935 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
4936 out
= stpcpy (out
, _(", relocatable-lib"));
4940 if (e_flags
& EF_PPC64_ABI
)
4941 out
+= sprintf (out
, ", abiv%d", e_flags
& EF_PPC64_ABI
);
4945 out
= decode_V800_machine_flags (out
, e_flags
);
4949 case EM_CYGNUS_V850
:
4950 out
= decode_V850_machine_flags (out
, e_flags
);
4954 case EM_CYGNUS_M32R
:
4955 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
4956 out
= stpcpy (out
, ", m32r");
4960 case EM_MIPS_RS3_LE
:
4961 out
= decode_MIPS_machine_flags (out
, e_flags
);
4965 out
= decode_NDS32_machine_flags (out
, e_flags
);
4969 switch (EF_NFP_MACH (e_flags
))
4971 case E_NFP_MACH_3200
:
4972 out
= stpcpy (out
, ", NFP-32xx");
4974 case E_NFP_MACH_6000
:
4975 out
= stpcpy (out
, ", NFP-6xxx");
4981 out
= decode_RISCV_machine_flags (out
, e_flags
);
4985 out
= decode_SH_machine_flags (out
, e_flags
);
4989 if (e_flags
& EF_OR1K_NODELAY
)
4990 out
= stpcpy (out
, ", no delay");
4994 out
+= sprintf (out
, ", CPU Version: %u", e_flags
& EF_BPF_CPUVER
);
4998 out
= decode_SPARC_machine_flags (out
, e_flags
);
5002 out
= decode_PARISC_machine_flags (out
, e_flags
);
5007 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
5008 out
= stpcpy (out
, ", new calling convention");
5010 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
5011 out
= stpcpy (out
, ", gnu calling convention");
5015 out
= decode_IA64_machine_flags (out
, e_flags
, filedata
);
5019 if ((e_flags
& EF_VAX_NONPIC
))
5020 out
= stpcpy (out
, ", non-PIC");
5021 if ((e_flags
& EF_VAX_DFLOAT
))
5022 out
= stpcpy (out
, ", D-Float");
5023 if ((e_flags
& EF_VAX_GFLOAT
))
5024 out
= stpcpy (out
, ", G-Float");
5028 if (e_flags
& EF_VISIUM_ARCH_MCM
)
5029 out
= stpcpy (out
, ", mcm");
5030 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
5031 out
= stpcpy (out
, ", mcm24");
5032 if (e_flags
& EF_VISIUM_ARCH_GR6
)
5033 out
= stpcpy (out
, ", gr6");
5037 out
= decode_RL78_machine_flags (out
, e_flags
);
5041 out
= decode_RX_machine_flags (out
, e_flags
);
5045 if (e_flags
& EF_S390_HIGH_GPRS
)
5046 out
= stpcpy (out
, ", highgprs");
5050 if ((e_flags
& EF_C6000_REL
))
5051 out
= stpcpy (out
, ", relocatable module");
5055 if ((e_flags
& (ELF_KVX_CORE_MAJOR_MASK
| ELF_KVX_CORE_MINOR_MASK
)) == ELF_KVX_CORE_KV3_1
)
5056 strcat (buf
, ", Kalray VLIW kv3-1");
5057 else if ((e_flags
& (ELF_KVX_CORE_MAJOR_MASK
| ELF_KVX_CORE_MINOR_MASK
)) == ELF_KVX_CORE_KV3_2
)
5058 strcat (buf
, ", Kalray VLIW kv3-2");
5059 else if ((e_flags
& (ELF_KVX_CORE_MAJOR_MASK
| ELF_KVX_CORE_MINOR_MASK
)) == ELF_KVX_CORE_KV4_1
)
5060 strcat (buf
, ", Kalray VLIW kv4-1");
5062 strcat (buf
, ", unknown KVX MPPA");
5066 out
= decode_MSP430_machine_flags (out
, e_flags
);
5070 out
= decode_Z80_machine_flags (out
, e_flags
);
5074 out
= decode_LOONGARCH_machine_flags (out
, e_flags
);
5083 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
5085 static char buff
[32];
5089 case ELFOSABI_NONE
: return "UNIX - System V";
5090 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
5091 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
5092 case ELFOSABI_GNU
: return "UNIX - GNU";
5093 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
5094 case ELFOSABI_AIX
: return "UNIX - AIX";
5095 case ELFOSABI_IRIX
: return "UNIX - IRIX";
5096 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
5097 case ELFOSABI_TRU64
: return "UNIX - TRU64";
5098 case ELFOSABI_MODESTO
: return "Novell - Modesto";
5099 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
5100 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
5101 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
5102 case ELFOSABI_AROS
: return "AROS";
5103 case ELFOSABI_FENIXOS
: return "FenixOS";
5104 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
5105 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
5108 switch (filedata
->file_header
.e_machine
)
5113 case ELFOSABI_AMDGPU_HSA
: return "AMD HSA";
5114 case ELFOSABI_AMDGPU_PAL
: return "AMD PAL";
5115 case ELFOSABI_AMDGPU_MESA3D
: return "AMD Mesa3D";
5124 case ELFOSABI_ARM
: return "ARM";
5125 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
5136 case ELFOSABI_STANDALONE
: return _("Standalone App");
5145 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
5146 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
5155 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
5161 get_aarch64_segment_type (unsigned long type
)
5165 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
5166 case PT_AARCH64_MEMTAG_MTE
: return "AARCH64_MEMTAG_MTE";
5167 default: return NULL
;
5172 get_arm_segment_type (unsigned long type
)
5176 case PT_ARM_EXIDX
: return "EXIDX";
5177 default: return NULL
;
5182 get_s390_segment_type (unsigned long type
)
5186 case PT_S390_PGSTE
: return "S390_PGSTE";
5187 default: return NULL
;
5192 get_mips_segment_type (unsigned long type
)
5196 case PT_MIPS_REGINFO
: return "REGINFO";
5197 case PT_MIPS_RTPROC
: return "RTPROC";
5198 case PT_MIPS_OPTIONS
: return "OPTIONS";
5199 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
5200 default: return NULL
;
5205 get_parisc_segment_type (unsigned long type
)
5209 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
5210 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
5211 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
5212 default: return NULL
;
5217 get_ia64_segment_type (unsigned long type
)
5221 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
5222 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
5223 default: return NULL
;
5228 get_tic6x_segment_type (unsigned long type
)
5232 case PT_C6000_PHATTR
: return "C6000_PHATTR";
5233 default: return NULL
;
5238 get_riscv_segment_type (unsigned long type
)
5242 case PT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
5243 default: return NULL
;
5248 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
5250 if (e_machine
== EM_PARISC
)
5253 case PT_HP_TLS
: return "HP_TLS";
5254 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
5255 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
5256 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
5257 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
5258 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
5259 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
5260 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
5261 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
5262 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
5263 case PT_HP_PARALLEL
: return "HP_PARALLEL";
5264 case PT_HP_FASTBIND
: return "HP_FASTBIND";
5265 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
5266 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
5267 case PT_HP_STACK
: return "HP_STACK";
5268 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
5269 default: return NULL
;
5272 if (e_machine
== EM_IA_64
)
5275 case PT_HP_TLS
: return "HP_TLS";
5276 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
5277 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
5278 case PT_IA_64_HP_STACK
: return "HP_STACK";
5279 default: return NULL
;
5286 get_solaris_segment_type (unsigned long type
)
5290 case 0x6464e550: return "PT_SUNW_UNWIND";
5291 case 0x6474e550: return "PT_SUNW_EH_FRAME";
5292 case 0x6ffffff7: return "PT_LOSUNW";
5293 case 0x6ffffffa: return "PT_SUNWBSS";
5294 case 0x6ffffffb: return "PT_SUNWSTACK";
5295 case 0x6ffffffc: return "PT_SUNWDTRACE";
5296 case 0x6ffffffd: return "PT_SUNWCAP";
5297 case 0x6fffffff: return "PT_HISUNW";
5298 default: return NULL
;
5303 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
5305 static char buff
[32];
5309 case PT_NULL
: return "NULL";
5310 case PT_LOAD
: return "LOAD";
5311 case PT_DYNAMIC
: return "DYNAMIC";
5312 case PT_INTERP
: return "INTERP";
5313 case PT_NOTE
: return "NOTE";
5314 case PT_SHLIB
: return "SHLIB";
5315 case PT_PHDR
: return "PHDR";
5316 case PT_TLS
: return "TLS";
5317 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
5318 case PT_GNU_STACK
: return "GNU_STACK";
5319 case PT_GNU_RELRO
: return "GNU_RELRO";
5320 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
5321 case PT_GNU_SFRAME
: return "GNU_SFRAME";
5323 case PT_OPENBSD_MUTABLE
: return "OPENBSD_MUTABLE";
5324 case PT_OPENBSD_RANDOMIZE
: return "OPENBSD_RANDOMIZE";
5325 case PT_OPENBSD_WXNEEDED
: return "OPENBSD_WXNEEDED";
5326 case PT_OPENBSD_NOBTCFI
: return "OPENBSD_NOBTCFI";
5327 case PT_OPENBSD_SYSCALLS
: return "OPENBSD_SYSCALLS";
5328 case PT_OPENBSD_BOOTDATA
: return "OPENBSD_BOOTDATA";
5331 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
5333 const char * result
;
5335 switch (filedata
->file_header
.e_machine
)
5338 result
= get_aarch64_segment_type (p_type
);
5341 result
= get_arm_segment_type (p_type
);
5344 case EM_MIPS_RS3_LE
:
5345 result
= get_mips_segment_type (p_type
);
5348 result
= get_parisc_segment_type (p_type
);
5351 result
= get_ia64_segment_type (p_type
);
5354 result
= get_tic6x_segment_type (p_type
);
5358 result
= get_s390_segment_type (p_type
);
5361 result
= get_riscv_segment_type (p_type
);
5371 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
5373 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
5375 const char * result
= NULL
;
5377 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
5380 case ELFOSABI_FREEBSD
:
5381 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
5383 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
5388 result
= get_hpux_segment_type (p_type
,
5389 filedata
->file_header
.e_machine
);
5391 case ELFOSABI_SOLARIS
:
5392 result
= get_solaris_segment_type (p_type
);
5400 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
5403 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
5410 get_arc_section_type_name (unsigned int sh_type
)
5414 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
5422 get_mips_section_type_name (unsigned int sh_type
)
5426 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
5427 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
5428 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
5429 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
5430 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
5431 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
5432 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
5433 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
5434 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
5435 case SHT_MIPS_RELD
: return "MIPS_RELD";
5436 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
5437 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
5438 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
5439 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
5440 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
5441 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
5442 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
5443 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
5444 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
5445 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
5446 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
5447 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
5448 case SHT_MIPS_LINE
: return "MIPS_LINE";
5449 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
5450 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
5451 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
5452 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
5453 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
5454 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
5455 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
5456 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
5457 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
5458 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
5459 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
5460 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
5461 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
5462 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
5463 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
5464 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
5465 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
5466 case SHT_MIPS_XHASH
: return "MIPS_XHASH";
5474 get_parisc_section_type_name (unsigned int sh_type
)
5478 case SHT_PARISC_EXT
: return "PARISC_EXT";
5479 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
5480 case SHT_PARISC_DOC
: return "PARISC_DOC";
5481 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
5482 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
5483 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
5484 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
5485 default: return NULL
;
5490 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
5492 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
5493 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
5494 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
5498 case SHT_IA_64_EXT
: return "IA_64_EXT";
5499 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
5500 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
5501 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
5502 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
5503 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
5504 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
5505 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
5506 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
5507 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
5515 get_x86_64_section_type_name (unsigned int sh_type
)
5519 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
5520 default: return NULL
;
5525 get_aarch64_section_type_name (unsigned int sh_type
)
5529 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
5530 default: return NULL
;
5535 get_arm_section_type_name (unsigned int sh_type
)
5539 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
5540 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
5541 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
5542 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
5543 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
5544 default: return NULL
;
5549 get_tic6x_section_type_name (unsigned int sh_type
)
5553 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
5554 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
5555 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
5556 case SHT_TI_ICODE
: return "TI_ICODE";
5557 case SHT_TI_XREF
: return "TI_XREF";
5558 case SHT_TI_HANDLER
: return "TI_HANDLER";
5559 case SHT_TI_INITINFO
: return "TI_INITINFO";
5560 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
5561 default: return NULL
;
5566 get_msp430_section_type_name (unsigned int sh_type
)
5570 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
5571 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
5572 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
5573 default: return NULL
;
5578 get_nfp_section_type_name (unsigned int sh_type
)
5582 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
5583 case SHT_NFP_INITREG
: return "NFP_INITREG";
5584 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
5585 default: return NULL
;
5590 get_v850_section_type_name (unsigned int sh_type
)
5594 case SHT_V850_SCOMMON
: return "V850 Small Common";
5595 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
5596 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
5597 case SHT_RENESAS_IOP
: return "RENESAS IOP";
5598 case SHT_RENESAS_INFO
: return "RENESAS INFO";
5599 default: return NULL
;
5604 get_riscv_section_type_name (unsigned int sh_type
)
5608 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
5609 default: return NULL
;
5614 get_csky_section_type_name (unsigned int sh_type
)
5618 case SHT_CSKY_ATTRIBUTES
: return "CSKY_ATTRIBUTES";
5619 default: return NULL
;
5624 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
5626 static char buff
[32];
5627 const char * result
;
5631 case SHT_NULL
: return "NULL";
5632 case SHT_PROGBITS
: return "PROGBITS";
5633 case SHT_SYMTAB
: return "SYMTAB";
5634 case SHT_STRTAB
: return "STRTAB";
5635 case SHT_RELA
: return "RELA";
5636 case SHT_HASH
: return "HASH";
5637 case SHT_DYNAMIC
: return "DYNAMIC";
5638 case SHT_NOTE
: return "NOTE";
5639 case SHT_NOBITS
: return "NOBITS";
5640 case SHT_REL
: return "REL";
5641 case SHT_SHLIB
: return "SHLIB";
5642 case SHT_DYNSYM
: return "DYNSYM";
5643 /* 12 and 13 are not defined. */
5644 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
5645 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
5646 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
5647 case SHT_GROUP
: return "GROUP";
5648 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
5649 case SHT_RELR
: return "RELR";
5650 /* End of generic section types. */
5652 /* OS specific section types: */
5653 case SHT_GNU_verdef
: return "VERDEF";
5654 case SHT_GNU_verneed
: return "VERNEED";
5655 case SHT_GNU_versym
: return "VERSYM";
5656 case SHT_GNU_INCREMENTAL_INPUTS
: return "GNU_INCREMENTAL_INPUTS";
5657 case 0x6ffffff0: return "VERSYM";
5658 case SHT_GNU_ATTRIBUTES
: return "GNU_ATTRIBUTES";
5659 case SHT_GNU_HASH
: return "GNU_HASH";
5660 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
5661 case 0x6ffffffc: return "VERDEF";
5662 case 0x7ffffffd: return "AUXILIARY";
5663 case 0x7fffffff: return "FILTER";
5666 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
5668 switch (filedata
->file_header
.e_machine
)
5671 case EM_ARC_COMPACT
:
5672 case EM_ARC_COMPACT2
:
5673 case EM_ARC_COMPACT3
:
5674 case EM_ARC_COMPACT3_64
:
5675 result
= get_arc_section_type_name (sh_type
);
5678 case EM_MIPS_RS3_LE
:
5679 result
= get_mips_section_type_name (sh_type
);
5682 result
= get_parisc_section_type_name (sh_type
);
5685 result
= get_ia64_section_type_name (filedata
, sh_type
);
5690 result
= get_x86_64_section_type_name (sh_type
);
5693 result
= get_aarch64_section_type_name (sh_type
);
5696 result
= get_arm_section_type_name (sh_type
);
5699 result
= get_tic6x_section_type_name (sh_type
);
5702 result
= get_msp430_section_type_name (sh_type
);
5705 result
= get_nfp_section_type_name (sh_type
);
5709 case EM_CYGNUS_V850
:
5710 result
= get_v850_section_type_name (sh_type
);
5713 result
= get_riscv_section_type_name (sh_type
);
5716 result
= get_csky_section_type_name (sh_type
);
5726 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
5728 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
5730 switch (filedata
->file_header
.e_machine
)
5733 result
= get_ia64_section_type_name (filedata
, sh_type
);
5736 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
5737 result
= get_solaris_section_type (sh_type
);
5742 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
5743 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
5744 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
5745 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
5757 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
5759 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
5761 switch (filedata
->file_header
.e_machine
)
5765 case EM_CYGNUS_V850
:
5766 result
= get_v850_section_type_name (sh_type
);
5776 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
5779 /* This message is probably going to be displayed in a 15
5780 character wide field, so put the hex value first. */
5781 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
5787 enum long_option_values
5789 OPTION_DEBUG_DUMP
= 512,
5800 OPTION_WITH_SYMBOL_VERSIONS
,
5801 OPTION_RECURSE_LIMIT
,
5802 OPTION_NO_RECURSE_LIMIT
,
5803 OPTION_NO_DEMANGLING
,
5804 OPTION_NO_EXTRA_SYM_INFO
,
5808 static struct option options
[] =
5810 /* Note - This table is alpha-sorted on the 'val'
5811 field in order to make adding new options easier. */
5812 {"arch-specific", no_argument
, 0, 'A'},
5813 {"all", no_argument
, 0, 'a'},
5814 {"demangle", optional_argument
, 0, 'C'},
5815 {"archive-index", no_argument
, 0, 'c'},
5816 {"use-dynamic", no_argument
, 0, 'D'},
5817 {"dynamic", no_argument
, 0, 'd'},
5818 {"headers", no_argument
, 0, 'e'},
5819 {"section-groups", no_argument
, 0, 'g'},
5820 {"help", no_argument
, 0, 'H'},
5821 {"file-header", no_argument
, 0, 'h'},
5822 {"histogram", no_argument
, 0, 'I'},
5823 {"display-section", required_argument
, 0, 'j'},
5824 {"lint", no_argument
, 0, 'L'},
5825 {"enable-checks", no_argument
, 0, 'L'},
5826 {"program-headers", no_argument
, 0, 'l'},
5827 {"segments", no_argument
, 0, 'l'},
5828 {"full-section-name",no_argument
, 0, 'N'},
5829 {"notes", no_argument
, 0, 'n'},
5830 {"process-links", no_argument
, 0, 'P'},
5831 {"string-dump", required_argument
, 0, 'p'},
5832 {"relocated-dump", required_argument
, 0, 'R'},
5833 {"relocs", no_argument
, 0, 'r'},
5834 {"section-headers", no_argument
, 0, 'S'},
5835 {"sections", no_argument
, 0, 'S'},
5836 {"symbols", no_argument
, 0, 's'},
5837 {"syms", no_argument
, 0, 's'},
5838 {"silent-truncation",no_argument
, 0, 'T'},
5839 {"section-details", no_argument
, 0, 't'},
5840 {"unicode", required_argument
, NULL
, 'U'},
5841 {"unwind", no_argument
, 0, 'u'},
5842 {"version-info", no_argument
, 0, 'V'},
5843 {"version", no_argument
, 0, 'v'},
5844 {"wide", no_argument
, 0, 'W'},
5845 {"extra-sym-info", no_argument
, 0, 'X'},
5846 {"hex-dump", required_argument
, 0, 'x'},
5847 {"decompress", no_argument
, 0, 'z'},
5849 {"no-demangle", no_argument
, 0, OPTION_NO_DEMANGLING
},
5850 {"no-extra-sym-info",no_argument
, 0, OPTION_NO_EXTRA_SYM_INFO
},
5851 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
5852 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
5853 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
5854 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
5855 {"lto-syms", no_argument
, 0, OPTION_LTO_SYMS
},
5856 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
5857 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
5858 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
5859 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
5860 #ifdef ENABLE_LIBCTF
5861 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
5862 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
5863 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
5864 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
5866 {"sframe", optional_argument
, 0, OPTION_SFRAME_DUMP
},
5867 {"sym-base", optional_argument
, 0, OPTION_SYM_BASE
},
5869 {0, no_argument
, 0, 0}
5873 usage (FILE * stream
)
5875 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
5876 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
5877 fprintf (stream
, _(" Options are:\n"));
5878 fprintf (stream
, _("\
5879 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
5880 fprintf (stream
, _("\
5881 -h --file-header Display the ELF file header\n"));
5882 fprintf (stream
, _("\
5883 -l --program-headers Display the program headers\n"));
5884 fprintf (stream
, _("\
5885 --segments An alias for --program-headers\n"));
5886 fprintf (stream
, _("\
5887 -S --section-headers Display the sections' header\n"));
5888 fprintf (stream
, _("\
5889 --sections An alias for --section-headers\n"));
5890 fprintf (stream
, _("\
5891 -g --section-groups Display the section groups\n"));
5892 fprintf (stream
, _("\
5893 -t --section-details Display the section details\n"));
5894 fprintf (stream
, _("\
5895 -e --headers Equivalent to: -h -l -S\n"));
5896 fprintf (stream
, _("\
5897 -s --syms Display the symbol table\n"));
5898 fprintf (stream
, _("\
5899 --symbols An alias for --syms\n"));
5900 fprintf (stream
, _("\
5901 --dyn-syms Display the dynamic symbol table\n"));
5902 fprintf (stream
, _("\
5903 --lto-syms Display LTO symbol tables\n"));
5904 fprintf (stream
, _("\
5905 --sym-base=[0|8|10|16] \n\
5906 Force base for symbol sizes. The options are \n\
5907 mixed (the default), octal, decimal, hexadecimal.\n"));
5908 fprintf (stream
, _("\
5909 -C --demangle[=STYLE] Decode mangled/processed symbol names\n"));
5910 display_demangler_styles (stream
, _("\
5912 fprintf (stream
, _("\
5913 --no-demangle Do not demangle low-level symbol names. (default)\n"));
5914 fprintf (stream
, _("\
5915 --recurse-limit Enable a demangling recursion limit. (default)\n"));
5916 fprintf (stream
, _("\
5917 --no-recurse-limit Disable a demangling recursion limit\n"));
5918 fprintf (stream
, _("\
5919 -U[dlexhi] --unicode=[default|locale|escape|hex|highlight|invalid]\n\
5920 Display unicode characters as determined by the current locale\n\
5921 (default), escape sequences, \"<hex sequences>\", highlighted\n\
5922 escape sequences, or treat them as invalid and display as\n\
5923 \"{hex sequences}\"\n"));
5924 fprintf (stream
, _("\
5925 -X --extra-sym-info Display extra information when showing symbols\n"));
5926 fprintf (stream
, _("\
5927 --no-extra-sym-info Do not display extra information when showing symbols (default)\n"));
5928 fprintf (stream
, _("\
5929 -n --notes Display the contents of note sections (if present)\n"));
5930 fprintf (stream
, _("\
5931 -r --relocs Display the relocations (if present)\n"));
5932 fprintf (stream
, _("\
5933 -u --unwind Display the unwind info (if present)\n"));
5934 fprintf (stream
, _("\
5935 -d --dynamic Display the dynamic section (if present)\n"));
5936 fprintf (stream
, _("\
5937 -V --version-info Display the version sections (if present)\n"));
5938 fprintf (stream
, _("\
5939 -A --arch-specific Display architecture specific information (if any)\n"));
5940 fprintf (stream
, _("\
5941 -c --archive-index Display the symbol/file index in an archive\n"));
5942 fprintf (stream
, _("\
5943 -D --use-dynamic Use the dynamic section info when displaying symbols\n"));
5944 fprintf (stream
, _("\
5945 -L --lint|--enable-checks\n\
5946 Display warning messages for possible problems\n"));
5947 fprintf (stream
, _("\
5948 -x --hex-dump=<number|name>\n\
5949 Dump the contents of section <number|name> as bytes\n"));
5950 fprintf (stream
, _("\
5951 -p --string-dump=<number|name>\n\
5952 Dump the contents of section <number|name> as strings\n"));
5953 fprintf (stream
, _("\
5954 -R --relocated-dump=<number|name>\n\
5955 Dump the relocated contents of section <number|name>\n"));
5956 fprintf (stream
, _("\
5957 -z --decompress Decompress section before dumping it\n"));
5958 fprintf (stream
, _("\n\
5959 -j --display-section=<name|number>\n\
5960 Display the contents of the indicated section. Can be repeated\n"));
5961 fprintf (stream
, _("\
5962 -w --debug-dump[a/=abbrev, A/=addr, r/=aranges, c/=cu_index, L/=decodedline,\n\
5963 f/=frames, F/=frames-interp, g/=gdb_index, i/=info, o/=loc,\n\
5964 m/=macro, p/=pubnames, t/=pubtypes, R/=Ranges, l/=rawline,\n\
5965 s/=str, O/=str-offsets, u/=trace_abbrev, T/=trace_aranges,\n\
5967 Display the contents of DWARF debug sections\n"));
5968 fprintf (stream
, _("\
5969 -wk --debug-dump=links Display the contents of sections that link to separate\n\
5970 debuginfo files\n"));
5971 fprintf (stream
, _("\
5972 -P --process-links Display the contents of non-debug sections in separate\n\
5973 debuginfo files. (Implies -wK)\n"));
5974 #if DEFAULT_FOR_FOLLOW_LINKS
5975 fprintf (stream
, _("\
5976 -wK --debug-dump=follow-links\n\
5977 Follow links to separate debug info files (default)\n"));
5978 fprintf (stream
, _("\
5979 -wN --debug-dump=no-follow-links\n\
5980 Do not follow links to separate debug info files\n"));
5982 fprintf (stream
, _("\
5983 -wK --debug-dump=follow-links\n\
5984 Follow links to separate debug info files\n"));
5985 fprintf (stream
, _("\
5986 -wN --debug-dump=no-follow-links\n\
5987 Do not follow links to separate debug info files\n\
5990 #if HAVE_LIBDEBUGINFOD
5991 fprintf (stream
, _("\
5992 -wD --debug-dump=use-debuginfod\n\
5993 When following links, also query debuginfod servers (default)\n"));
5994 fprintf (stream
, _("\
5995 -wE --debug-dump=do-not-use-debuginfod\n\
5996 When following links, do not query debuginfod servers\n"));
5998 fprintf (stream
, _("\
5999 --dwarf-depth=N Do not display DIEs at depth N or greater\n"));
6000 fprintf (stream
, _("\
6001 --dwarf-start=N Display DIEs starting at offset N\n"));
6002 #ifdef ENABLE_LIBCTF
6003 fprintf (stream
, _("\
6004 --ctf=<number|name> Display CTF info from section <number|name>\n"));
6005 fprintf (stream
, _("\
6006 --ctf-parent=<name> Use CTF archive member <name> as the CTF parent\n"));
6007 fprintf (stream
, _("\
6008 --ctf-symbols=<number|name>\n\
6009 Use section <number|name> as the CTF external symtab\n"));
6010 fprintf (stream
, _("\
6011 --ctf-strings=<number|name>\n\
6012 Use section <number|name> as the CTF external strtab\n"));
6014 fprintf (stream
, _("\
6015 --sframe[=NAME] Display SFrame info from section NAME, (default '.sframe')\n"));
6017 #ifdef SUPPORT_DISASSEMBLY
6018 fprintf (stream
, _("\
6019 -i --instruction-dump=<number|name>\n\
6020 Disassemble the contents of section <number|name>\n"));
6022 fprintf (stream
, _("\
6023 -I --histogram Display histogram of bucket list lengths\n"));
6024 fprintf (stream
, _("\
6025 -W --wide Allow output width to exceed 80 characters\n"));
6026 fprintf (stream
, _("\
6027 -T --silent-truncation If a symbol name is truncated, do not add [...] suffix\n"));
6028 fprintf (stream
, _("\
6029 @<file> Read options from <file>\n"));
6030 fprintf (stream
, _("\
6031 -H --help Display this information\n"));
6032 fprintf (stream
, _("\
6033 -v --version Display the version number of readelf\n"));
6035 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
6036 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
6038 exit (stream
== stdout
? 0 : 1);
6041 /* Record the fact that the user wants the contents of section number
6042 SECTION to be displayed using the method(s) encoded as flags bits
6043 in TYPE. Note, TYPE can be zero if we are creating the array for
6047 request_dump_bynumber (struct dump_data
*dumpdata
,
6048 unsigned int section
, dump_type type
)
6050 if (section
>= dumpdata
->num_dump_sects
)
6052 dump_type
* new_dump_sects
;
6054 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
6055 sizeof (* new_dump_sects
));
6057 if (new_dump_sects
== NULL
)
6058 error (_("Out of memory allocating dump request table.\n"));
6061 if (dumpdata
->dump_sects
)
6063 /* Copy current flag settings. */
6064 memcpy (new_dump_sects
, dumpdata
->dump_sects
,
6065 dumpdata
->num_dump_sects
* sizeof (* new_dump_sects
));
6067 free (dumpdata
->dump_sects
);
6070 dumpdata
->dump_sects
= new_dump_sects
;
6071 dumpdata
->num_dump_sects
= section
+ 1;
6075 if (dumpdata
->dump_sects
)
6076 dumpdata
->dump_sects
[section
] |= type
;
6079 /* Request a dump by section name. */
6082 request_dump_byname (const char * section
, dump_type type
)
6084 struct dump_list_entry
* new_request
;
6086 new_request
= (struct dump_list_entry
*)
6087 malloc (sizeof (struct dump_list_entry
));
6089 error (_("Out of memory allocating dump request table.\n"));
6091 new_request
->name
= strdup (section
);
6092 if (!new_request
->name
)
6093 error (_("Out of memory allocating dump request table.\n"));
6095 new_request
->type
= type
;
6097 new_request
->next
= dump_sects_byname
;
6098 dump_sects_byname
= new_request
;
6102 request_dump (struct dump_data
*dumpdata
, dump_type type
)
6108 section
= strtoul (optarg
, & cp
, 0);
6110 if (! *cp
&& section
>= 0)
6111 request_dump_bynumber (dumpdata
, section
, type
);
6113 request_dump_byname (optarg
, type
);
6117 parse_args (struct dump_data
*dumpdata
, int argc
, char ** argv
)
6124 while ((c
= getopt_long
6125 (argc
, argv
, "ACDHILNPR:STU:VWXacdeghi:j:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
6143 do_section_groups
= true;
6146 do_histogram
= true;
6152 do_section_groups
= true;
6157 do_section_details
= true;
6168 do_using_dynamic
= true;
6192 do_histogram
= true;
6198 do_archive_index
= true;
6204 process_links
= true;
6205 do_follow_links
= true;
6206 dump_any_debugging
= true;
6209 request_dump (dumpdata
, AUTO_DUMP
);
6212 request_dump (dumpdata
, HEX_DUMP
);
6215 request_dump (dumpdata
, STRING_DUMP
);
6218 request_dump (dumpdata
, RELOC_DUMP
);
6221 decompress_dumps
= true;
6226 do_debugging
= true;
6228 dump_any_debugging
= true;
6229 dwarf_select_sections_all ();
6233 do_debugging
= false;
6234 if (dwarf_select_sections_by_letters (optarg
))
6237 dump_any_debugging
= true;
6241 case OPTION_DEBUG_DUMP
:
6245 do_debugging
= true;
6246 dump_any_debugging
= true;
6247 dwarf_select_sections_all ();
6251 do_debugging
= false;
6252 if (dwarf_select_sections_by_names (optarg
))
6255 dump_any_debugging
= true;
6259 case OPTION_DWARF_DEPTH
:
6263 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
6266 case OPTION_DWARF_START
:
6270 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
6273 case OPTION_DWARF_CHECK
:
6276 case OPTION_CTF_DUMP
:
6278 request_dump (dumpdata
, CTF_DUMP
);
6280 case OPTION_CTF_SYMBOLS
:
6281 free (dump_ctf_symtab_name
);
6282 dump_ctf_symtab_name
= strdup (optarg
);
6284 case OPTION_CTF_STRINGS
:
6285 free (dump_ctf_strtab_name
);
6286 dump_ctf_strtab_name
= strdup (optarg
);
6288 case OPTION_CTF_PARENT
:
6289 free (dump_ctf_parent_name
);
6290 dump_ctf_parent_name
= strdup (optarg
);
6292 case OPTION_SFRAME_DUMP
:
6294 /* Providing section name is optional. request_dump (), however,
6295 thrives on non NULL optarg. Handle it explicitly here. */
6297 request_dump (dumpdata
, SFRAME_DUMP
);
6301 const char *sframe_sec_name
= strdup (".sframe");
6302 request_dump_byname (sframe_sec_name
, SFRAME_DUMP
);
6305 case OPTION_DYN_SYMS
:
6308 case OPTION_LTO_SYMS
:
6312 extra_sym_info
= true;
6314 case OPTION_NO_EXTRA_SYM_INFO
:
6315 extra_sym_info
= false;
6318 #ifdef SUPPORT_DISASSEMBLY
6320 request_dump (dumpdata
, DISASS_DUMP
);
6324 print_version (program_name
);
6333 do_not_show_symbol_truncation
= true;
6339 enum demangling_styles style
;
6341 style
= cplus_demangle_name_to_style (optarg
);
6342 if (style
== unknown_demangling
)
6343 error (_("unknown demangling style `%s'"), optarg
);
6345 cplus_demangle_set_style (style
);
6348 case OPTION_NO_DEMANGLING
:
6349 do_demangle
= false;
6351 case OPTION_RECURSE_LIMIT
:
6352 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
6354 case OPTION_NO_RECURSE_LIMIT
:
6355 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
6357 case OPTION_WITH_SYMBOL_VERSIONS
:
6358 /* Ignored for backward compatibility. */
6363 error (_("Missing arg to -U/--unicode")); /* Can this happen ? */
6364 else if (streq (optarg
, "default") || streq (optarg
, "d"))
6365 unicode_display
= unicode_default
;
6366 else if (streq (optarg
, "locale") || streq (optarg
, "l"))
6367 unicode_display
= unicode_locale
;
6368 else if (streq (optarg
, "escape") || streq (optarg
, "e"))
6369 unicode_display
= unicode_escape
;
6370 else if (streq (optarg
, "invalid") || streq (optarg
, "i"))
6371 unicode_display
= unicode_invalid
;
6372 else if (streq (optarg
, "hex") || streq (optarg
, "x"))
6373 unicode_display
= unicode_hex
;
6374 else if (streq (optarg
, "highlight") || streq (optarg
, "h"))
6375 unicode_display
= unicode_highlight
;
6377 error (_("invalid argument to -U/--unicode: %s"), optarg
);
6380 case OPTION_SYM_BASE
:
6384 sym_base
= strtoul (optarg
, NULL
, 0);
6401 /* xgettext:c-format */
6402 error (_("Invalid option '-%c'\n"), c
);
6409 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
6410 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
6411 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
6412 && !do_section_groups
&& !do_archive_index
6413 && !do_dyn_syms
&& !do_lto_syms
)
6418 do_dynamic
= do_syms
= do_reloc
= do_unwind
= do_sections
= true;
6419 do_segments
= do_header
= do_dump
= do_version
= true;
6420 do_histogram
= do_debugging
= do_arch
= do_notes
= true;
6421 do_section_groups
= do_archive_index
= do_dyn_syms
= true;
6430 get_elf_class (unsigned int elf_class
)
6432 static char buff
[32];
6436 case ELFCLASSNONE
: return _("none");
6437 case ELFCLASS32
: return "ELF32";
6438 case ELFCLASS64
: return "ELF64";
6440 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
6446 get_data_encoding (unsigned int encoding
)
6448 static char buff
[32];
6452 case ELFDATANONE
: return _("none");
6453 case ELFDATA2LSB
: return _("2's complement, little endian");
6454 case ELFDATA2MSB
: return _("2's complement, big endian");
6456 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
6462 check_magic_number (Filedata
* filedata
, Elf_Internal_Ehdr
* header
)
6464 if (header
->e_ident
[EI_MAG0
] == ELFMAG0
6465 && header
->e_ident
[EI_MAG1
] == ELFMAG1
6466 && header
->e_ident
[EI_MAG2
] == ELFMAG2
6467 && header
->e_ident
[EI_MAG3
] == ELFMAG3
)
6470 /* Some compilers produce object files that are not in the ELF file format.
6471 As an aid to users of readelf, try to identify these cases and suggest
6474 FIXME: It is not clear if all four bytes are used as constant magic
6475 valus by all compilers. It may be necessary to recode this function if
6476 different tools use different length sequences. */
6480 unsigned char magic
[4];
6481 const char * obj_message
;
6482 const char * ar_message
;
6486 { { 'B', 'C', 0xc0, 0xde },
6487 N_("This is a LLVM bitcode file - try using llvm-bcanalyzer\n"),
6488 N_("This is a LLVM bitcode file - try extracting and then using llvm-bcanalyzer\n")
6490 { { 'g', 'o', ' ', 'o' },
6491 N_("This is a GO binary file - try using 'go tool objdump' or 'go tool nm'\n"),
6497 for (i
= ARRAY_SIZE (known_magic
); i
--;)
6499 if (header
->e_ident
[EI_MAG0
] == known_magic
[i
].magic
[0]
6500 && header
->e_ident
[EI_MAG1
] == known_magic
[i
].magic
[1]
6501 && header
->e_ident
[EI_MAG2
] == known_magic
[i
].magic
[2]
6502 && header
->e_ident
[EI_MAG3
] == known_magic
[i
].magic
[3])
6504 /* Some compiler's analyzer tools do not handle archives,
6505 so we provide two different kinds of error message. */
6506 if (filedata
->archive_file_size
> 0
6507 && known_magic
[i
].ar_message
!= NULL
)
6508 error ("%s", known_magic
[i
].ar_message
);
6510 error ("%s", known_magic
[i
].obj_message
);
6515 error (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
6519 /* Decode the data held in 'filedata->file_header'. */
6522 process_file_header (Filedata
* filedata
)
6524 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
6526 if (! check_magic_number (filedata
, header
))
6529 if (! filedata
->is_separate
)
6530 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
6536 if (filedata
->is_separate
)
6537 printf (_("ELF Header in linked file '%s':\n"), filedata
->file_name
);
6539 printf (_("ELF Header:\n"));
6540 printf (_(" Magic: "));
6541 for (i
= 0; i
< EI_NIDENT
; i
++)
6542 printf ("%2.2x ", header
->e_ident
[i
]);
6544 printf (_(" Class: %s\n"),
6545 get_elf_class (header
->e_ident
[EI_CLASS
]));
6546 printf (_(" Data: %s\n"),
6547 get_data_encoding (header
->e_ident
[EI_DATA
]));
6548 printf (_(" Version: %d%s\n"),
6549 header
->e_ident
[EI_VERSION
],
6550 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
6552 : (header
->e_ident
[EI_VERSION
] != EV_NONE
6555 printf (_(" OS/ABI: %s\n"),
6556 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
6557 printf (_(" ABI Version: %d\n"),
6558 header
->e_ident
[EI_ABIVERSION
]);
6559 printf (_(" Type: %s\n"),
6560 get_file_type (filedata
));
6561 printf (_(" Machine: %s\n"),
6562 get_machine_name (header
->e_machine
));
6563 printf (_(" Version: 0x%lx\n"),
6566 printf (_(" Entry point address: "));
6567 print_vma (header
->e_entry
, PREFIX_HEX
);
6568 printf (_("\n Start of program headers: "));
6569 print_vma (header
->e_phoff
, DEC
);
6570 printf (_(" (bytes into file)\n Start of section headers: "));
6571 print_vma (header
->e_shoff
, DEC
);
6572 printf (_(" (bytes into file)\n"));
6574 printf (_(" Flags: 0x%lx%s\n"),
6576 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
6577 printf (_(" Size of this header: %u (bytes)\n"),
6579 printf (_(" Size of program headers: %u (bytes)\n"),
6580 header
->e_phentsize
);
6581 printf (_(" Number of program headers: %u"),
6583 if (filedata
->section_headers
!= NULL
6584 && header
->e_phnum
== PN_XNUM
6585 && filedata
->section_headers
[0].sh_info
!= 0)
6586 printf (" (%u)", filedata
->section_headers
[0].sh_info
);
6587 putc ('\n', stdout
);
6588 printf (_(" Size of section headers: %u (bytes)\n"),
6589 header
->e_shentsize
);
6590 printf (_(" Number of section headers: %u"),
6592 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
6594 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
6595 printf (" (%u)", header
->e_shnum
);
6597 putc ('\n', stdout
);
6598 printf (_(" Section header string table index: %u"),
6599 header
->e_shstrndx
);
6600 if (filedata
->section_headers
!= NULL
6601 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
6603 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
6604 printf (" (%u)", header
->e_shstrndx
);
6606 if (header
->e_shstrndx
!= SHN_UNDEF
6607 && header
->e_shstrndx
>= header
->e_shnum
)
6609 header
->e_shstrndx
= SHN_UNDEF
;
6610 printf (_(" <corrupt: out of range>"));
6612 putc ('\n', stdout
);
6615 if (filedata
->section_headers
!= NULL
)
6617 if (header
->e_phnum
== PN_XNUM
6618 && filedata
->section_headers
[0].sh_info
!= 0)
6620 /* Throw away any cached read of PN_XNUM headers. */
6621 free (filedata
->program_headers
);
6622 filedata
->program_headers
= NULL
;
6623 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
6625 if (header
->e_shnum
== SHN_UNDEF
)
6626 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
6627 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
6628 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
6629 if (header
->e_shstrndx
>= header
->e_shnum
)
6630 header
->e_shstrndx
= SHN_UNDEF
;
6636 /* Read in the program headers from FILEDATA and store them in PHEADERS.
6637 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
6640 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
6642 Elf32_External_Phdr
* phdrs
;
6643 Elf32_External_Phdr
* external
;
6644 Elf_Internal_Phdr
* internal
;
6646 unsigned int size
= filedata
->file_header
.e_phentsize
;
6647 unsigned int num
= filedata
->file_header
.e_phnum
;
6649 /* PR binutils/17531: Cope with unexpected section header sizes. */
6650 if (size
== 0 || num
== 0)
6652 if (size
< sizeof * phdrs
)
6654 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
6657 if (size
> sizeof * phdrs
)
6658 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
6660 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
6661 size
, num
, _("program headers"));
6665 for (i
= 0, internal
= pheaders
, external
= phdrs
;
6666 i
< filedata
->file_header
.e_phnum
;
6667 i
++, internal
++, external
++)
6669 internal
->p_type
= BYTE_GET (external
->p_type
);
6670 internal
->p_offset
= BYTE_GET (external
->p_offset
);
6671 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
6672 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
6673 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
6674 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
6675 internal
->p_flags
= BYTE_GET (external
->p_flags
);
6676 internal
->p_align
= BYTE_GET (external
->p_align
);
6683 /* Read in the program headers from FILEDATA and store them in PHEADERS.
6684 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
6687 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
6689 Elf64_External_Phdr
* phdrs
;
6690 Elf64_External_Phdr
* external
;
6691 Elf_Internal_Phdr
* internal
;
6693 unsigned int size
= filedata
->file_header
.e_phentsize
;
6694 unsigned int num
= filedata
->file_header
.e_phnum
;
6696 /* PR binutils/17531: Cope with unexpected section header sizes. */
6697 if (size
== 0 || num
== 0)
6699 if (size
< sizeof * phdrs
)
6701 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
6704 if (size
> sizeof * phdrs
)
6705 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
6707 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
6708 size
, num
, _("program headers"));
6712 for (i
= 0, internal
= pheaders
, external
= phdrs
;
6713 i
< filedata
->file_header
.e_phnum
;
6714 i
++, internal
++, external
++)
6716 internal
->p_type
= BYTE_GET (external
->p_type
);
6717 internal
->p_flags
= BYTE_GET (external
->p_flags
);
6718 internal
->p_offset
= BYTE_GET (external
->p_offset
);
6719 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
6720 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
6721 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
6722 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
6723 internal
->p_align
= BYTE_GET (external
->p_align
);
6730 /* Returns TRUE if the program headers were read into `program_headers'. */
6733 get_program_headers (Filedata
* filedata
)
6735 Elf_Internal_Phdr
* phdrs
;
6737 /* Check cache of prior read. */
6738 if (filedata
->program_headers
!= NULL
)
6741 /* Be kind to memory checkers by looking for
6742 e_phnum values which we know must be invalid. */
6743 if (filedata
->file_header
.e_phnum
6744 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
6745 >= filedata
->file_size
)
6747 error (_("Too many program headers - %#x - the file is not that big\n"),
6748 filedata
->file_header
.e_phnum
);
6752 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
6753 sizeof (Elf_Internal_Phdr
));
6756 error (_("Out of memory reading %u program headers\n"),
6757 filedata
->file_header
.e_phnum
);
6762 ? get_32bit_program_headers (filedata
, phdrs
)
6763 : get_64bit_program_headers (filedata
, phdrs
))
6765 filedata
->program_headers
= phdrs
;
6773 /* Print program header info and locate dynamic section. */
6776 process_program_headers (Filedata
* filedata
)
6778 Elf_Internal_Phdr
* segment
;
6780 Elf_Internal_Phdr
* previous_load
= NULL
;
6782 if (filedata
->file_header
.e_phnum
== 0)
6784 /* PR binutils/12467. */
6785 if (filedata
->file_header
.e_phoff
!= 0)
6786 warn (_("possibly corrupt ELF header - it has a non-zero program"
6787 " header offset, but no program headers\n"));
6788 else if (do_segments
)
6790 if (filedata
->is_separate
)
6791 printf (_("\nThere are no program headers in linked file '%s'.\n"),
6792 filedata
->file_name
);
6794 printf (_("\nThere are no program headers in this file.\n"));
6799 if (do_segments
&& !do_header
)
6801 if (filedata
->is_separate
)
6802 printf ("\nIn linked file '%s' the ELF file type is %s\n",
6803 filedata
->file_name
, get_file_type (filedata
));
6805 printf (_("\nElf file type is %s\n"), get_file_type (filedata
));
6806 printf (_("Entry point 0x%" PRIx64
"\n"),
6807 filedata
->file_header
.e_entry
);
6808 printf (ngettext ("There is %d program header,"
6809 " starting at offset %" PRIu64
"\n",
6810 "There are %d program headers,"
6811 " starting at offset %" PRIu64
"\n",
6812 filedata
->file_header
.e_phnum
),
6813 filedata
->file_header
.e_phnum
,
6814 filedata
->file_header
.e_phoff
);
6817 if (! get_program_headers (filedata
))
6822 if (filedata
->file_header
.e_phnum
> 1)
6823 printf (_("\nProgram Headers:\n"));
6825 printf (_("\nProgram Headers:\n"));
6829 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
6832 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
6836 (_(" Type Offset VirtAddr PhysAddr\n"));
6838 (_(" FileSiz MemSiz Flags Align\n"));
6842 uint64_t dynamic_addr
= 0;
6843 uint64_t dynamic_size
= 0;
6844 for (i
= 0, segment
= filedata
->program_headers
;
6845 i
< filedata
->file_header
.e_phnum
;
6850 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
6854 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
6855 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
6856 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
6857 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
6858 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
6860 (segment
->p_flags
& PF_R
? 'R' : ' '),
6861 (segment
->p_flags
& PF_W
? 'W' : ' '),
6862 (segment
->p_flags
& PF_X
? 'E' : ' '));
6863 printf ("%#lx", (unsigned long) segment
->p_align
);
6867 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
6868 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
6871 print_vma (segment
->p_offset
, FULL_HEX
);
6875 print_vma (segment
->p_vaddr
, FULL_HEX
);
6877 print_vma (segment
->p_paddr
, FULL_HEX
);
6880 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
6881 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
6884 print_vma (segment
->p_filesz
, FULL_HEX
);
6888 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
6889 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
6892 print_vma (segment
->p_memsz
, FULL_HEX
);
6896 (segment
->p_flags
& PF_R
? 'R' : ' '),
6897 (segment
->p_flags
& PF_W
? 'W' : ' '),
6898 (segment
->p_flags
& PF_X
? 'E' : ' '));
6900 if ((unsigned long) segment
->p_align
== segment
->p_align
)
6901 printf ("%#lx", (unsigned long) segment
->p_align
);
6904 print_vma (segment
->p_align
, PREFIX_HEX
);
6909 print_vma (segment
->p_offset
, FULL_HEX
);
6911 print_vma (segment
->p_vaddr
, FULL_HEX
);
6913 print_vma (segment
->p_paddr
, FULL_HEX
);
6915 print_vma (segment
->p_filesz
, FULL_HEX
);
6917 print_vma (segment
->p_memsz
, FULL_HEX
);
6919 (segment
->p_flags
& PF_R
? 'R' : ' '),
6920 (segment
->p_flags
& PF_W
? 'W' : ' '),
6921 (segment
->p_flags
& PF_X
? 'E' : ' '));
6922 print_vma (segment
->p_align
, PREFIX_HEX
);
6925 putc ('\n', stdout
);
6928 switch (segment
->p_type
)
6931 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
6932 required by the ELF standard, several programs, including the Linux
6933 kernel, make use of non-ordered segments. */
6935 && previous_load
->p_vaddr
> segment
->p_vaddr
)
6936 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
6938 if (segment
->p_memsz
< segment
->p_filesz
)
6939 error (_("the segment's file size is larger than its memory size\n"));
6940 previous_load
= segment
;
6944 /* PR 20815 - Verify that the program header is loaded into memory. */
6945 if (i
> 0 && previous_load
!= NULL
)
6946 error (_("the PHDR segment must occur before any LOAD segment\n"));
6947 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
6951 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
6953 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
6954 if (load
->p_type
== PT_LOAD
6955 && load
->p_offset
<= segment
->p_offset
6956 && (load
->p_offset
+ load
->p_filesz
6957 >= segment
->p_offset
+ segment
->p_filesz
)
6958 && load
->p_vaddr
<= segment
->p_vaddr
6959 && (load
->p_vaddr
+ load
->p_filesz
6960 >= segment
->p_vaddr
+ segment
->p_filesz
))
6963 if (j
== filedata
->file_header
.e_phnum
)
6964 error (_("the PHDR segment is not covered by a LOAD segment\n"));
6970 error (_("more than one dynamic segment\n"));
6972 /* By default, assume that the .dynamic section is the first
6973 section in the DYNAMIC segment. */
6974 dynamic_addr
= segment
->p_offset
;
6975 dynamic_size
= segment
->p_filesz
;
6977 /* Try to locate the .dynamic section. If there is
6978 a section header table, we can easily locate it. */
6979 if (filedata
->section_headers
!= NULL
)
6981 Elf_Internal_Shdr
* sec
;
6983 sec
= find_section (filedata
, ".dynamic");
6984 if (sec
== NULL
|| sec
->sh_size
== 0)
6986 /* A corresponding .dynamic section is expected, but on
6987 IA-64/OpenVMS it is OK for it to be missing. */
6988 if (!is_ia64_vms (filedata
))
6989 error (_("no .dynamic section in the dynamic segment\n"));
6993 if (sec
->sh_type
== SHT_NOBITS
)
7000 dynamic_addr
= sec
->sh_offset
;
7001 dynamic_size
= sec
->sh_size
;
7003 /* The PT_DYNAMIC segment, which is used by the run-time
7004 loader, should exactly match the .dynamic section. */
7006 && (dynamic_addr
!= segment
->p_offset
7007 || dynamic_size
!= segment
->p_filesz
))
7009 the .dynamic section is not the same as the dynamic segment\n"));
7012 /* PR binutils/17512: Avoid corrupt dynamic section info in the
7013 segment. Check this after matching against the section headers
7014 so we don't warn on debuginfo file (which have NOBITS .dynamic
7016 if (dynamic_addr
> filedata
->file_size
7017 || (dynamic_size
> filedata
->file_size
- dynamic_addr
))
7019 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
7026 if (segment
->p_offset
>= filedata
->file_size
7027 || segment
->p_filesz
> filedata
->file_size
- segment
->p_offset
7028 || segment
->p_filesz
- 1 >= (size_t) -2
7029 || fseek64 (filedata
->handle
,
7030 filedata
->archive_file_offset
+ segment
->p_offset
,
7032 error (_("Unable to find program interpreter name\n"));
7035 size_t len
= segment
->p_filesz
;
7036 free (filedata
->program_interpreter
);
7037 filedata
->program_interpreter
= xmalloc (len
+ 1);
7038 len
= fread (filedata
->program_interpreter
, 1, len
,
7040 filedata
->program_interpreter
[len
] = 0;
7043 printf (_(" [Requesting program interpreter: %s]\n"),
7044 filedata
->program_interpreter
);
7051 && filedata
->section_headers
!= NULL
7052 && filedata
->string_table
!= NULL
)
7054 printf (_("\n Section to Segment mapping:\n"));
7055 printf (_(" Segment Sections...\n"));
7057 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
7060 Elf_Internal_Shdr
* section
;
7062 segment
= filedata
->program_headers
+ i
;
7063 section
= filedata
->section_headers
+ 1;
7065 printf (" %2.2d ", i
);
7067 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
7069 if (!ELF_TBSS_SPECIAL (section
, segment
)
7070 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
7071 printf ("%s ", printable_section_name (filedata
, section
));
7078 filedata
->dynamic_addr
= dynamic_addr
;
7079 filedata
->dynamic_size
= dynamic_size
? dynamic_size
: 1;
7083 filedata
->dynamic_addr
= 0;
7084 filedata
->dynamic_size
= 1;
7088 /* Find the file offset corresponding to VMA by using the program headers. */
7091 offset_from_vma (Filedata
* filedata
, uint64_t vma
, uint64_t size
)
7093 Elf_Internal_Phdr
* seg
;
7095 if (! get_program_headers (filedata
))
7097 warn (_("Cannot interpret virtual addresses without program headers.\n"));
7101 for (seg
= filedata
->program_headers
;
7102 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7105 if (seg
->p_type
!= PT_LOAD
)
7108 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
7109 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
7110 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
7113 warn (_("Virtual address %#" PRIx64
7114 " not located in any PT_LOAD segment.\n"), vma
);
7119 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
7120 If PROBE is true, this is just a probe and we do not generate any error
7121 messages if the load fails. */
7124 get_32bit_section_headers (Filedata
* filedata
, bool probe
)
7126 Elf32_External_Shdr
* shdrs
;
7127 Elf_Internal_Shdr
* internal
;
7129 unsigned int size
= filedata
->file_header
.e_shentsize
;
7130 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
7132 /* PR binutils/17531: Cope with unexpected section header sizes. */
7133 if (size
== 0 || num
== 0)
7136 /* The section header cannot be at the start of the file - that is
7137 where the ELF file header is located. A file with absolutely no
7138 sections in it will use a shoff of 0. */
7139 if (filedata
->file_header
.e_shoff
== 0)
7142 if (size
< sizeof * shdrs
)
7145 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
7148 if (!probe
&& size
> sizeof * shdrs
)
7149 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
7151 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
7153 probe
? NULL
: _("section headers"));
7157 filedata
->section_headers
= (Elf_Internal_Shdr
*)
7158 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
7159 if (filedata
->section_headers
== NULL
)
7162 error (_("Out of memory reading %u section headers\n"), num
);
7167 for (i
= 0, internal
= filedata
->section_headers
;
7171 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
7172 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
7173 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
7174 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
7175 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
7176 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
7177 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
7178 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
7179 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
7180 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
7181 if (!probe
&& internal
->sh_link
> num
)
7182 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
7183 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
7184 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
7191 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
7194 get_64bit_section_headers (Filedata
* filedata
, bool probe
)
7196 Elf64_External_Shdr
* shdrs
;
7197 Elf_Internal_Shdr
* internal
;
7199 unsigned int size
= filedata
->file_header
.e_shentsize
;
7200 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
7202 /* PR binutils/17531: Cope with unexpected section header sizes. */
7203 if (size
== 0 || num
== 0)
7206 /* The section header cannot be at the start of the file - that is
7207 where the ELF file header is located. A file with absolutely no
7208 sections in it will use a shoff of 0. */
7209 if (filedata
->file_header
.e_shoff
== 0)
7212 if (size
< sizeof * shdrs
)
7215 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
7219 if (! probe
&& size
> sizeof * shdrs
)
7220 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
7222 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
7223 filedata
->file_header
.e_shoff
,
7225 probe
? NULL
: _("section headers"));
7229 filedata
->section_headers
= (Elf_Internal_Shdr
*)
7230 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
7231 if (filedata
->section_headers
== NULL
)
7234 error (_("Out of memory reading %u section headers\n"), num
);
7239 for (i
= 0, internal
= filedata
->section_headers
;
7243 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
7244 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
7245 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
7246 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
7247 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
7248 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
7249 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
7250 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
7251 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
7252 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
7253 if (!probe
&& internal
->sh_link
> num
)
7254 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
7255 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
7256 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
7264 get_section_headers (Filedata
*filedata
, bool probe
)
7266 if (filedata
->section_headers
!= NULL
)
7270 return get_32bit_section_headers (filedata
, probe
);
7272 return get_64bit_section_headers (filedata
, probe
);
7275 static Elf_Internal_Sym
*
7276 get_32bit_elf_symbols (Filedata
*filedata
,
7277 Elf_Internal_Shdr
*section
,
7278 uint64_t *num_syms_return
)
7280 uint64_t number
= 0;
7281 Elf32_External_Sym
* esyms
= NULL
;
7282 Elf_External_Sym_Shndx
* shndx
= NULL
;
7283 Elf_Internal_Sym
* isyms
= NULL
;
7284 Elf_Internal_Sym
* psym
;
7286 elf_section_list
* entry
;
7288 if (section
->sh_size
== 0)
7290 if (num_syms_return
!= NULL
)
7291 * num_syms_return
= 0;
7295 /* Run some sanity checks first. */
7296 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
7298 error (_("Section %s has an invalid sh_entsize of %#" PRIx64
"\n"),
7299 printable_section_name (filedata
, section
),
7300 section
->sh_entsize
);
7304 if (section
->sh_size
> filedata
->file_size
)
7306 error (_("Section %s has an invalid sh_size of %#" PRIx64
"\n"),
7307 printable_section_name (filedata
, section
),
7312 number
= section
->sh_size
/ section
->sh_entsize
;
7314 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
7316 error (_("Size (%#" PRIx64
") of section %s "
7317 "is not a multiple of its sh_entsize (%#" PRIx64
")\n"),
7319 printable_section_name (filedata
, section
),
7320 section
->sh_entsize
);
7324 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
7325 section
->sh_size
, _("symbols"));
7330 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
7332 if (entry
->hdr
->sh_link
!= (size_t) (section
- filedata
->section_headers
))
7337 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
7341 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
7342 entry
->hdr
->sh_offset
,
7343 1, entry
->hdr
->sh_size
,
7344 _("symbol table section indices"));
7348 /* PR17531: file: heap-buffer-overflow */
7349 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
7351 error (_("Index section %s has an sh_size of %#" PRIx64
" - expected %#" PRIx64
"\n"),
7352 printable_section_name (filedata
, entry
->hdr
),
7353 entry
->hdr
->sh_size
,
7359 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
7363 error (_("Out of memory reading %" PRIu64
" symbols\n"), number
);
7367 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
7369 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
7370 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
7371 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
7372 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
7373 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
7375 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
7376 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
7377 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
7378 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
7379 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
7386 if (num_syms_return
!= NULL
)
7387 * num_syms_return
= isyms
== NULL
? 0 : number
;
7392 static Elf_Internal_Sym
*
7393 get_64bit_elf_symbols (Filedata
*filedata
,
7394 Elf_Internal_Shdr
*section
,
7395 uint64_t *num_syms_return
)
7397 uint64_t number
= 0;
7398 Elf64_External_Sym
* esyms
= NULL
;
7399 Elf_External_Sym_Shndx
* shndx
= NULL
;
7400 Elf_Internal_Sym
* isyms
= NULL
;
7401 Elf_Internal_Sym
* psym
;
7403 elf_section_list
* entry
;
7405 if (section
->sh_size
== 0)
7407 if (num_syms_return
!= NULL
)
7408 * num_syms_return
= 0;
7412 /* Run some sanity checks first. */
7413 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
7415 error (_("Section %s has an invalid sh_entsize of %#" PRIx64
"\n"),
7416 printable_section_name (filedata
, section
),
7417 section
->sh_entsize
);
7421 if (section
->sh_size
> filedata
->file_size
)
7423 error (_("Section %s has an invalid sh_size of %#" PRIx64
"\n"),
7424 printable_section_name (filedata
, section
),
7429 number
= section
->sh_size
/ section
->sh_entsize
;
7431 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
7433 error (_("Size (%#" PRIx64
") of section %s "
7434 "is not a multiple of its sh_entsize (%#" PRIx64
")\n"),
7436 printable_section_name (filedata
, section
),
7437 section
->sh_entsize
);
7441 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
7442 section
->sh_size
, _("symbols"));
7447 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
7449 if (entry
->hdr
->sh_link
!= (size_t) (section
- filedata
->section_headers
))
7454 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
7458 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
7459 entry
->hdr
->sh_offset
,
7460 1, entry
->hdr
->sh_size
,
7461 _("symbol table section indices"));
7465 /* PR17531: file: heap-buffer-overflow */
7466 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
7468 error (_("Index section %s has an sh_size of %#" PRIx64
" - expected %#" PRIx64
"\n"),
7469 printable_section_name (filedata
, entry
->hdr
),
7470 entry
->hdr
->sh_size
,
7476 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
7480 error (_("Out of memory reading %" PRIu64
" symbols\n"), number
);
7484 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
7486 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
7487 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
7488 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
7489 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
7491 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
7493 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
7494 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
7495 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
7497 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
7498 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
7505 if (num_syms_return
!= NULL
)
7506 * num_syms_return
= isyms
== NULL
? 0 : number
;
7511 static Elf_Internal_Sym
*
7512 get_elf_symbols (Filedata
*filedata
,
7513 Elf_Internal_Shdr
*section
,
7514 uint64_t *num_syms_return
)
7517 return get_32bit_elf_symbols (filedata
, section
, num_syms_return
);
7519 return get_64bit_elf_symbols (filedata
, section
, num_syms_return
);
7523 get_elf_section_flags (Filedata
* filedata
, uint64_t sh_flags
)
7525 static char buff
[1024];
7527 unsigned int field_size
= is_32bit_elf
? 8 : 16;
7529 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
7530 uint64_t os_flags
= 0;
7531 uint64_t proc_flags
= 0;
7532 uint64_t unknown_flags
= 0;
7540 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
7541 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
7542 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
7543 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
7544 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
7545 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
7546 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
7547 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
7548 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
7549 /* 9 */ { STRING_COMMA_LEN ("TLS") },
7550 /* IA-64 specific. */
7551 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
7552 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
7553 /* IA-64 OpenVMS specific. */
7554 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
7555 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
7556 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
7557 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
7558 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
7559 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
7561 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
7562 /* SPARC specific. */
7563 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
7564 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
7566 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
7567 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
7568 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
7570 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
7572 /* 25 */ { STRING_COMMA_LEN ("VLE") },
7574 /* 26 */ { STRING_COMMA_LEN ("GNU_RETAIN") },
7577 if (do_section_details
)
7578 p
+= sprintf (p
, "[%*.*lx]: ",
7579 field_size
, field_size
, (unsigned long) sh_flags
);
7585 flag
= sh_flags
& - sh_flags
;
7588 if (do_section_details
)
7592 case SHF_WRITE
: sindex
= 0; break;
7593 case SHF_ALLOC
: sindex
= 1; break;
7594 case SHF_EXECINSTR
: sindex
= 2; break;
7595 case SHF_MERGE
: sindex
= 3; break;
7596 case SHF_STRINGS
: sindex
= 4; break;
7597 case SHF_INFO_LINK
: sindex
= 5; break;
7598 case SHF_LINK_ORDER
: sindex
= 6; break;
7599 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
7600 case SHF_GROUP
: sindex
= 8; break;
7601 case SHF_TLS
: sindex
= 9; break;
7602 case SHF_EXCLUDE
: sindex
= 18; break;
7603 case SHF_COMPRESSED
: sindex
= 20; break;
7607 switch (filedata
->file_header
.e_machine
)
7610 if (flag
== SHF_IA_64_SHORT
)
7612 else if (flag
== SHF_IA_64_NORECOV
)
7614 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
7617 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
7618 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
7619 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
7620 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
7621 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
7622 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
7632 case EM_OLD_SPARCV9
:
7633 case EM_SPARC32PLUS
:
7636 if (flag
== SHF_ORDERED
)
7643 case SHF_ENTRYSECT
: sindex
= 21; break;
7644 case SHF_ARM_PURECODE
: sindex
= 22; break;
7645 case SHF_COMDEF
: sindex
= 23; break;
7650 if (flag
== SHF_PPC_VLE
)
7657 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
7660 case ELFOSABI_FREEBSD
:
7661 if (flag
== SHF_GNU_RETAIN
)
7665 if (flag
== SHF_GNU_MBIND
)
7666 /* We should not recognize SHF_GNU_MBIND for
7667 ELFOSABI_NONE, but binutils as of 2019-07-23 did
7668 not set the EI_OSABI header byte. */
7679 if (p
!= buff
+ field_size
+ 4)
7681 if (size
< (10 + 2))
7683 warn (_("Internal error: not enough buffer room for section flag info"));
7684 return _("<unknown>");
7691 size
-= flags
[sindex
].len
;
7692 p
= stpcpy (p
, flags
[sindex
].str
);
7694 else if (flag
& SHF_MASKOS
)
7696 else if (flag
& SHF_MASKPROC
)
7699 unknown_flags
|= flag
;
7705 case SHF_WRITE
: *p
= 'W'; break;
7706 case SHF_ALLOC
: *p
= 'A'; break;
7707 case SHF_EXECINSTR
: *p
= 'X'; break;
7708 case SHF_MERGE
: *p
= 'M'; break;
7709 case SHF_STRINGS
: *p
= 'S'; break;
7710 case SHF_INFO_LINK
: *p
= 'I'; break;
7711 case SHF_LINK_ORDER
: *p
= 'L'; break;
7712 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
7713 case SHF_GROUP
: *p
= 'G'; break;
7714 case SHF_TLS
: *p
= 'T'; break;
7715 case SHF_EXCLUDE
: *p
= 'E'; break;
7716 case SHF_COMPRESSED
: *p
= 'C'; break;
7719 if ((filedata
->file_header
.e_machine
== EM_X86_64
7720 || filedata
->file_header
.e_machine
== EM_L1OM
7721 || filedata
->file_header
.e_machine
== EM_K1OM
)
7722 && flag
== SHF_X86_64_LARGE
)
7724 else if (filedata
->file_header
.e_machine
== EM_ARM
7725 && flag
== SHF_ARM_PURECODE
)
7727 else if (filedata
->file_header
.e_machine
== EM_PPC
7728 && flag
== SHF_PPC_VLE
)
7730 else if (flag
& SHF_MASKOS
)
7732 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
7735 case ELFOSABI_FREEBSD
:
7736 if (flag
== SHF_GNU_RETAIN
)
7743 if (flag
== SHF_GNU_MBIND
)
7745 /* We should not recognize SHF_GNU_MBIND for
7746 ELFOSABI_NONE, but binutils as of 2019-07-23 did
7747 not set the EI_OSABI header byte. */
7754 sh_flags
&= ~SHF_MASKOS
;
7758 else if (flag
& SHF_MASKPROC
)
7761 sh_flags
&= ~ SHF_MASKPROC
;
7771 if (do_section_details
)
7775 if (p
!= buff
+ field_size
+ 4)
7777 if (size
< 2 + 5 + field_size
+ 1)
7779 warn (_("Internal error: not enough buffer room for section flag info"));
7780 return _("<unknown>");
7786 size
-= 5 + field_size
;
7787 p
+= sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
7788 (unsigned long) os_flags
);
7792 if (p
!= buff
+ field_size
+ 4)
7794 if (size
< 2 + 7 + field_size
+ 1)
7796 warn (_("Internal error: not enough buffer room for section flag info"));
7797 return _("<unknown>");
7803 size
-= 7 + field_size
;
7804 p
+= sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
7805 (unsigned long) proc_flags
);
7809 if (p
!= buff
+ field_size
+ 4)
7811 if (size
< 2 + 10 + field_size
+ 1)
7813 warn (_("Internal error: not enough buffer room for section flag info"));
7814 return _("<unknown>");
7820 size
-= 10 + field_size
;
7821 p
+= sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
7822 (unsigned long) unknown_flags
);
7830 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
7831 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
,
7836 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
7838 if (size
< sizeof (* echdr
))
7840 error (_("Compressed section is too small even for a compression header\n"));
7844 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
7845 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
7846 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
7847 return sizeof (*echdr
);
7851 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
7853 if (size
< sizeof (* echdr
))
7855 error (_("Compressed section is too small even for a compression header\n"));
7859 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
7860 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
7861 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
7862 return sizeof (*echdr
);
7867 process_section_headers (Filedata
* filedata
)
7869 Elf_Internal_Shdr
* section
;
7872 if (filedata
->file_header
.e_shnum
== 0)
7874 /* PR binutils/12467. */
7875 if (filedata
->file_header
.e_shoff
!= 0)
7877 warn (_("possibly corrupt ELF file header - it has a non-zero"
7878 " section header offset, but no section headers\n"));
7881 else if (do_sections
)
7882 printf (_("\nThere are no sections in this file.\n"));
7887 if (do_sections
&& !do_header
)
7889 if (filedata
->is_separate
&& process_links
)
7890 printf (_("In linked file '%s': "), filedata
->file_name
);
7891 if (! filedata
->is_separate
|| process_links
)
7892 printf (ngettext ("There is %d section header, "
7893 "starting at offset %#" PRIx64
":\n",
7894 "There are %d section headers, "
7895 "starting at offset %#" PRIx64
":\n",
7896 filedata
->file_header
.e_shnum
),
7897 filedata
->file_header
.e_shnum
,
7898 filedata
->file_header
.e_shoff
);
7901 if (!get_section_headers (filedata
, false))
7904 /* Read in the string table, so that we have names to display. */
7905 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
7906 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
7908 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
7910 if (section
->sh_size
!= 0)
7912 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
7913 1, section
->sh_size
,
7916 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
7920 /* Scan the sections for the dynamic symbol table
7921 and dynamic string table and debug sections. */
7922 eh_addr_size
= is_32bit_elf
? 4 : 8;
7923 switch (filedata
->file_header
.e_machine
)
7926 case EM_MIPS_RS3_LE
:
7927 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
7928 FDE addresses. However, the ABI also has a semi-official ILP32
7929 variant for which the normal FDE address size rules apply.
7931 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
7932 section, where XX is the size of longs in bits. Unfortunately,
7933 earlier compilers provided no way of distinguishing ILP32 objects
7934 from LP64 objects, so if there's any doubt, we should assume that
7935 the official LP64 form is being used. */
7936 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == EF_MIPS_ABI_EABI64
7937 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
7943 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
7945 case E_H8_MACH_H8300
:
7946 case E_H8_MACH_H8300HN
:
7947 case E_H8_MACH_H8300SN
:
7948 case E_H8_MACH_H8300SXN
:
7951 case E_H8_MACH_H8300H
:
7952 case E_H8_MACH_H8300S
:
7953 case E_H8_MACH_H8300SX
:
7961 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
7963 case EF_M32C_CPU_M16C
:
7970 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
7973 uint64_t expected_entsize = is_32bit_elf ? size32 : size64; \
7974 if (section->sh_entsize != expected_entsize) \
7976 error (_("Section %d has invalid sh_entsize of %" PRIx64 "\n"), \
7977 i, section->sh_entsize); \
7978 error (_("(Using the expected size of %" PRIx64 " for the rest of this dump)\n"), \
7979 expected_entsize); \
7980 section->sh_entsize = expected_entsize; \
7985 #define CHECK_ENTSIZE(section, i, type) \
7986 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
7987 sizeof (Elf64_External_##type))
7989 for (i
= 0, section
= filedata
->section_headers
;
7990 i
< filedata
->file_header
.e_shnum
;
7993 const char *name
= printable_section_name (filedata
, section
);
7995 /* Run some sanity checks on the headers and
7996 possibly fill in some file data as well. */
7997 switch (section
->sh_type
)
8000 if (filedata
->dynamic_symbols
!= NULL
)
8002 error (_("File contains multiple dynamic symbol tables\n"));
8006 CHECK_ENTSIZE (section
, i
, Sym
);
8007 filedata
->dynamic_symbols
8008 = get_elf_symbols (filedata
, section
, &filedata
->num_dynamic_syms
);
8009 filedata
->dynamic_symtab_section
= section
;
8013 if (streq (name
, ".dynstr"))
8015 if (filedata
->dynamic_strings
!= NULL
)
8017 error (_("File contains multiple dynamic string tables\n"));
8021 filedata
->dynamic_strings
8022 = (char *) get_data (NULL
, filedata
, section
->sh_offset
,
8023 1, section
->sh_size
, _("dynamic strings"));
8024 filedata
->dynamic_strings_length
8025 = filedata
->dynamic_strings
== NULL
? 0 : section
->sh_size
;
8026 filedata
->dynamic_strtab_section
= section
;
8030 case SHT_SYMTAB_SHNDX
:
8032 elf_section_list
* entry
= xmalloc (sizeof * entry
);
8034 entry
->hdr
= section
;
8035 entry
->next
= filedata
->symtab_shndx_list
;
8036 filedata
->symtab_shndx_list
= entry
;
8041 CHECK_ENTSIZE (section
, i
, Sym
);
8045 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
8049 CHECK_ENTSIZE (section
, i
, Rel
);
8050 if (do_checks
&& section
->sh_size
== 0)
8051 warn (_("Section '%s': zero-sized relocation section\n"), name
);
8055 CHECK_ENTSIZE (section
, i
, Rela
);
8056 if (do_checks
&& section
->sh_size
== 0)
8057 warn (_("Section '%s': zero-sized relocation section\n"), name
);
8061 CHECK_ENTSIZE (section
, i
, Relr
);
8066 /* Having a zero sized section is not illegal according to the
8067 ELF standard, but it might be an indication that something
8068 is wrong. So issue a warning if we are running in lint mode. */
8069 if (do_checks
&& section
->sh_size
== 0)
8070 warn (_("Section '%s': has a size of zero - is this intended ?\n"), name
);
8077 if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
8078 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
8079 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
8080 || do_debug_str
|| do_debug_str_offsets
|| do_debug_loc
8082 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
8083 && (startswith (name
, ".debug_")
8084 || startswith (name
, ".zdebug_")))
8087 name
+= sizeof (".zdebug_") - 1;
8089 name
+= sizeof (".debug_") - 1;
8092 || (do_debug_info
&& startswith (name
, "info"))
8093 || (do_debug_info
&& startswith (name
, "types"))
8094 || (do_debug_abbrevs
&& startswith (name
, "abbrev"))
8095 || (do_debug_lines
&& strcmp (name
, "line") == 0)
8096 || (do_debug_lines
&& startswith (name
, "line."))
8097 || (do_debug_pubnames
&& startswith (name
, "pubnames"))
8098 || (do_debug_pubtypes
&& startswith (name
, "pubtypes"))
8099 || (do_debug_pubnames
&& startswith (name
, "gnu_pubnames"))
8100 || (do_debug_pubtypes
&& startswith (name
, "gnu_pubtypes"))
8101 || (do_debug_aranges
&& startswith (name
, "aranges"))
8102 || (do_debug_ranges
&& startswith (name
, "ranges"))
8103 || (do_debug_ranges
&& startswith (name
, "rnglists"))
8104 || (do_debug_frames
&& startswith (name
, "frame"))
8105 || (do_debug_macinfo
&& startswith (name
, "macinfo"))
8106 || (do_debug_macinfo
&& startswith (name
, "macro"))
8107 || (do_debug_str
&& startswith (name
, "str"))
8108 || (do_debug_links
&& startswith (name
, "sup"))
8109 || (do_debug_str_offsets
&& startswith (name
, "str_offsets"))
8110 || (do_debug_loc
&& startswith (name
, "loc"))
8111 || (do_debug_loc
&& startswith (name
, "loclists"))
8112 || (do_debug_addr
&& startswith (name
, "addr"))
8113 || (do_debug_cu_index
&& startswith (name
, "cu_index"))
8114 || (do_debug_cu_index
&& startswith (name
, "tu_index"))
8116 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
8118 /* Linkonce section to be combined with .debug_info at link time. */
8119 else if ((do_debugging
|| do_debug_info
)
8120 && startswith (name
, ".gnu.linkonce.wi."))
8121 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
8122 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
8123 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
8124 else if (do_debug_frames
&& streq (name
, ".eh_frame_hdr"))
8125 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
8126 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
8127 || streq (name
, ".debug_names")))
8128 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
8129 /* Trace sections for Itanium VMS. */
8130 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
8131 || do_trace_aranges
)
8132 && startswith (name
, ".trace_"))
8134 name
+= sizeof (".trace_") - 1;
8137 || (do_trace_info
&& streq (name
, "info"))
8138 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
8139 || (do_trace_aranges
&& streq (name
, "aranges"))
8141 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
8143 else if ((do_debugging
|| do_debug_links
)
8144 && (startswith (name
, ".gnu_debuglink")
8145 || startswith (name
, ".gnu_debugaltlink")))
8146 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
8152 if (filedata
->is_separate
&& ! process_links
)
8155 if (filedata
->is_separate
)
8156 printf (_("\nSection Headers in linked file '%s':\n"), filedata
->file_name
);
8157 else if (filedata
->file_header
.e_shnum
> 1)
8158 printf (_("\nSection Headers:\n"));
8160 printf (_("\nSection Header:\n"));
8164 if (do_section_details
)
8166 printf (_(" [Nr] Name\n"));
8167 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
8171 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
8175 if (do_section_details
)
8177 printf (_(" [Nr] Name\n"));
8178 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
8182 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
8186 if (do_section_details
)
8188 printf (_(" [Nr] Name\n"));
8189 printf (_(" Type Address Offset Link\n"));
8190 printf (_(" Size EntSize Info Align\n"));
8194 printf (_(" [Nr] Name Type Address Offset\n"));
8195 printf (_(" Size EntSize Flags Link Info Align\n"));
8199 if (do_section_details
)
8200 printf (_(" Flags\n"));
8202 for (i
= 0, section
= filedata
->section_headers
;
8203 i
< filedata
->file_header
.e_shnum
;
8206 /* Run some sanity checks on the section header. */
8208 /* Check the sh_link field. */
8209 switch (section
->sh_type
)
8214 if (section
->sh_link
== 0
8215 && (filedata
->file_header
.e_type
== ET_EXEC
8216 || filedata
->file_header
.e_type
== ET_DYN
))
8217 /* A dynamic relocation section where all entries use a
8218 zero symbol index need not specify a symtab section. */
8221 case SHT_SYMTAB_SHNDX
:
8225 case SHT_GNU_versym
:
8226 if (section
->sh_link
== 0
8227 || section
->sh_link
>= filedata
->file_header
.e_shnum
8228 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
8229 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
8230 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
8231 i
, section
->sh_link
);
8237 case SHT_GNU_verneed
:
8238 case SHT_GNU_verdef
:
8239 case SHT_GNU_LIBLIST
:
8240 if (section
->sh_link
== 0
8241 || section
->sh_link
>= filedata
->file_header
.e_shnum
8242 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
8243 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
8244 i
, section
->sh_link
);
8247 case SHT_INIT_ARRAY
:
8248 case SHT_FINI_ARRAY
:
8249 case SHT_PREINIT_ARRAY
:
8250 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
8251 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
8252 i
, section
->sh_link
);
8256 /* FIXME: Add support for target specific section types. */
8257 #if 0 /* Currently we do not check other section types as there are too
8258 many special cases. Stab sections for example have a type
8259 of SHT_PROGBITS but an sh_link field that links to the .stabstr
8261 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
8262 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
8263 i
, section
->sh_link
);
8268 /* Check the sh_info field. */
8269 switch (section
->sh_type
)
8273 if (section
->sh_info
== 0
8274 && (filedata
->file_header
.e_type
== ET_EXEC
8275 || filedata
->file_header
.e_type
== ET_DYN
))
8276 /* Dynamic relocations apply to segments, so they do not
8277 need to specify the section they relocate. */
8279 if (section
->sh_info
== 0
8280 || section
->sh_info
>= filedata
->file_header
.e_shnum
8281 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
8282 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
8283 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
8284 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
8285 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
8286 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
8287 /* FIXME: Are other section types valid ? */
8288 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
8289 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
8290 i
, section
->sh_info
);
8295 case SHT_SYMTAB_SHNDX
:
8296 case SHT_INIT_ARRAY
:
8297 case SHT_FINI_ARRAY
:
8298 case SHT_PREINIT_ARRAY
:
8299 if (section
->sh_info
!= 0)
8300 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
8301 i
, section
->sh_info
);
8307 /* A symbol index - we assume that it is valid. */
8311 /* FIXME: Add support for target specific section types. */
8312 if (section
->sh_type
== SHT_NOBITS
)
8313 /* NOBITS section headers with non-zero sh_info fields can be
8314 created when a binary is stripped of everything but its debug
8315 information. The stripped sections have their headers
8316 preserved but their types set to SHT_NOBITS. So do not check
8317 this type of section. */
8319 else if (section
->sh_flags
& SHF_INFO_LINK
)
8321 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
8322 warn (_("[%2u]: Expected link to another section in info field"), i
);
8324 else if (section
->sh_type
< SHT_LOOS
8325 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
8326 && section
->sh_info
!= 0)
8327 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
8328 i
, section
->sh_info
);
8332 /* Check the sh_size field. */
8333 if (section
->sh_size
> filedata
->file_size
8334 && section
->sh_type
!= SHT_NOBITS
8335 && section
->sh_type
!= SHT_NULL
8336 && section
->sh_type
< SHT_LOOS
)
8337 warn (_("Size of section %u is larger than the entire file!\n"), i
);
8339 printf (" [%2u] ", i
);
8340 if (do_section_details
)
8341 printf ("%s\n ", printable_section_name (filedata
, section
));
8343 print_symbol_name (-17, printable_section_name (filedata
, section
));
8345 printf (do_wide
? " %-15s " : " %-15.15s ",
8346 get_section_type_name (filedata
, section
->sh_type
));
8350 const char * link_too_big
= NULL
;
8352 print_vma (section
->sh_addr
, LONG_HEX
);
8354 printf ( " %6.6lx %6.6lx %2.2lx",
8355 (unsigned long) section
->sh_offset
,
8356 (unsigned long) section
->sh_size
,
8357 (unsigned long) section
->sh_entsize
);
8359 if (do_section_details
)
8360 fputs (" ", stdout
);
8362 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
8364 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
8367 /* The sh_link value is out of range. Normally this indicates
8368 an error but it can have special values in Solaris binaries. */
8369 switch (filedata
->file_header
.e_machine
)
8376 case EM_OLD_SPARCV9
:
8377 case EM_SPARC32PLUS
:
8380 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
8381 link_too_big
= "BEFORE";
8382 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
8383 link_too_big
= "AFTER";
8390 if (do_section_details
)
8392 if (link_too_big
!= NULL
&& * link_too_big
)
8393 printf ("<%s> ", link_too_big
);
8395 printf ("%2u ", section
->sh_link
);
8396 printf ("%3u %2lu\n", section
->sh_info
,
8397 (unsigned long) section
->sh_addralign
);
8400 printf ("%2u %3u %2lu\n",
8403 (unsigned long) section
->sh_addralign
);
8405 if (link_too_big
&& ! * link_too_big
)
8406 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
8407 i
, section
->sh_link
);
8411 print_vma (section
->sh_addr
, LONG_HEX
);
8413 if ((long) section
->sh_offset
== section
->sh_offset
)
8414 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
8418 print_vma (section
->sh_offset
, LONG_HEX
);
8421 if ((unsigned long) section
->sh_size
== section
->sh_size
)
8422 printf (" %6.6lx", (unsigned long) section
->sh_size
);
8426 print_vma (section
->sh_size
, LONG_HEX
);
8429 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
8430 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
8434 print_vma (section
->sh_entsize
, LONG_HEX
);
8437 if (do_section_details
)
8438 fputs (" ", stdout
);
8440 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
8442 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
8444 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
8445 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
8448 print_vma (section
->sh_addralign
, DEC
);
8452 else if (do_section_details
)
8455 print_vma (section
->sh_addr
, LONG_HEX
);
8456 if ((long) section
->sh_offset
== section
->sh_offset
)
8457 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
8461 print_vma (section
->sh_offset
, LONG_HEX
);
8463 printf (" %u\n ", section
->sh_link
);
8464 print_vma (section
->sh_size
, LONG_HEX
);
8466 print_vma (section
->sh_entsize
, LONG_HEX
);
8468 printf (" %-16u %lu\n",
8470 (unsigned long) section
->sh_addralign
);
8475 print_vma (section
->sh_addr
, LONG_HEX
);
8476 if ((long) section
->sh_offset
== section
->sh_offset
)
8477 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
8481 print_vma (section
->sh_offset
, LONG_HEX
);
8484 print_vma (section
->sh_size
, LONG_HEX
);
8486 print_vma (section
->sh_entsize
, LONG_HEX
);
8488 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
8490 printf (" %2u %3u %lu\n",
8493 (unsigned long) section
->sh_addralign
);
8496 if (do_section_details
)
8498 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
8499 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
8501 /* Minimum section size is 12 bytes for 32-bit compression
8502 header + 12 bytes for compressed data header. */
8503 unsigned char buf
[24];
8505 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
8506 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
8507 sizeof (buf
), _("compression header")))
8509 Elf_Internal_Chdr chdr
;
8511 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
8512 printf (_(" [<corrupt>]\n"));
8515 if (chdr
.ch_type
== ch_compress_zlib
)
8517 else if (chdr
.ch_type
== ch_compress_zstd
)
8520 printf (_(" [<unknown>: 0x%x], "),
8522 print_vma (chdr
.ch_size
, LONG_HEX
);
8523 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
8530 if (!do_section_details
)
8532 /* The ordering of the letters shown here matches the ordering of the
8533 corresponding SHF_xxx values, and hence the order in which these
8534 letters will be displayed to the user. */
8535 printf (_("Key to Flags:\n\
8536 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
8537 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
8538 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
8539 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
8542 case ELFOSABI_FREEBSD
:
8543 printf (_("R (retain), "));
8546 printf (_("D (mbind), "));
8551 if (filedata
->file_header
.e_machine
== EM_X86_64
8552 || filedata
->file_header
.e_machine
== EM_L1OM
8553 || filedata
->file_header
.e_machine
== EM_K1OM
)
8554 printf (_("l (large), "));
8555 else if (filedata
->file_header
.e_machine
== EM_ARM
)
8556 printf (_("y (purecode), "));
8557 else if (filedata
->file_header
.e_machine
== EM_PPC
)
8558 printf (_("v (VLE), "));
8559 printf ("p (processor specific)\n");
8566 get_symtab (Filedata
* filedata
,
8567 Elf_Internal_Shdr
* symsec
,
8568 Elf_Internal_Sym
** symtab
,
8571 uint64_t * strtablen
)
8575 *symtab
= get_elf_symbols (filedata
, symsec
, nsyms
);
8577 if (*symtab
== NULL
)
8580 if (symsec
->sh_link
!= 0)
8582 Elf_Internal_Shdr
*strsec
;
8584 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
8586 error (_("Bad sh_link in symbol table section\n"));
8593 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
8595 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
8596 1, strsec
->sh_size
, _("string table"));
8597 if (*strtab
== NULL
)
8604 *strtablen
= strsec
->sh_size
;
8610 get_group_flags (unsigned int flags
)
8612 static char buff
[128];
8616 else if (flags
== GRP_COMDAT
)
8619 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
8621 flags
& GRP_MASKOS
? _("<OS specific>") : "",
8622 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
8623 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
8624 ? _("<unknown>") : ""));
8630 process_section_groups (Filedata
* filedata
)
8632 Elf_Internal_Shdr
* section
;
8634 struct group
* group
;
8635 Elf_Internal_Shdr
* symtab_sec
;
8636 Elf_Internal_Shdr
* strtab_sec
;
8637 Elf_Internal_Sym
* symtab
;
8642 /* Don't process section groups unless needed. */
8643 if (!do_unwind
&& !do_section_groups
)
8646 if (filedata
->file_header
.e_shnum
== 0)
8648 if (do_section_groups
)
8650 if (filedata
->is_separate
)
8651 printf (_("\nThere are no sections group in linked file '%s'.\n"),
8652 filedata
->file_name
);
8654 printf (_("\nThere are no section groups in this file.\n"));
8659 if (filedata
->section_headers
== NULL
)
8661 error (_("Section headers are not available!\n"));
8662 /* PR 13622: This can happen with a corrupt ELF header. */
8666 filedata
->section_headers_groups
8667 = (struct group
**) calloc (filedata
->file_header
.e_shnum
,
8668 sizeof (struct group
*));
8670 if (filedata
->section_headers_groups
== NULL
)
8672 error (_("Out of memory reading %u section group headers\n"),
8673 filedata
->file_header
.e_shnum
);
8677 /* Scan the sections for the group section. */
8678 filedata
->group_count
= 0;
8679 for (i
= 0, section
= filedata
->section_headers
;
8680 i
< filedata
->file_header
.e_shnum
;
8682 if (section
->sh_type
== SHT_GROUP
)
8683 filedata
->group_count
++;
8685 if (filedata
->group_count
== 0)
8687 if (do_section_groups
)
8689 if (filedata
->is_separate
)
8690 printf (_("\nThere are no section groups in linked file '%s'.\n"),
8691 filedata
->file_name
);
8693 printf (_("\nThere are no section groups in this file.\n"));
8699 filedata
->section_groups
= (struct group
*) calloc (filedata
->group_count
,
8700 sizeof (struct group
));
8702 if (filedata
->section_groups
== NULL
)
8704 error (_("Out of memory reading %zu groups\n"), filedata
->group_count
);
8715 if (filedata
->is_separate
)
8716 printf (_("Section groups in linked file '%s'\n"), filedata
->file_name
);
8718 for (i
= 0, section
= filedata
->section_headers
, group
= filedata
->section_groups
;
8719 i
< filedata
->file_header
.e_shnum
;
8722 if (section
->sh_type
== SHT_GROUP
)
8724 const char * name
= printable_section_name (filedata
, section
);
8725 const char * group_name
;
8726 unsigned char * start
;
8727 unsigned char * indices
;
8728 unsigned int entry
, j
, size
;
8729 Elf_Internal_Shdr
* sec
;
8730 Elf_Internal_Sym
* sym
;
8732 /* Get the symbol table. */
8733 if (section
->sh_link
>= filedata
->file_header
.e_shnum
8734 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
8737 error (_("Bad sh_link in group section `%s'\n"), name
);
8741 if (symtab_sec
!= sec
)
8745 symtab
= get_elf_symbols (filedata
, symtab_sec
, & num_syms
);
8750 error (_("Corrupt header in group section `%s'\n"), name
);
8754 if (section
->sh_info
>= num_syms
)
8756 error (_("Bad sh_info in group section `%s'\n"), name
);
8760 sym
= symtab
+ section
->sh_info
;
8762 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
8764 if (sym
->st_shndx
== 0
8765 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
8767 error (_("Bad sh_info in group section `%s'\n"), name
);
8771 group_name
= printable_section_name (filedata
,
8772 filedata
->section_headers
8781 /* Get the string table. */
8782 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
8790 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
8795 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
8796 1, strtab_sec
->sh_size
,
8798 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
8800 group_name
= sym
->st_name
< strtab_size
8801 ? strtab
+ sym
->st_name
: _("<corrupt>");
8804 /* PR 17531: file: loop. */
8805 if (section
->sh_entsize
> section
->sh_size
)
8807 error (_("Section %s has sh_entsize (%#" PRIx64
")"
8808 " which is larger than its size (%#" PRIx64
")\n"),
8809 printable_section_name (filedata
, section
),
8810 section
->sh_entsize
,
8815 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
8816 1, section
->sh_size
,
8822 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
8823 entry
= byte_get (indices
, 4);
8826 if (do_section_groups
)
8828 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
8829 get_group_flags (entry
), i
, name
, group_name
, size
);
8831 printf (_(" [Index] Name\n"));
8834 group
->group_index
= i
;
8836 for (j
= 0; j
< size
; j
++)
8838 struct group_list
* g
;
8840 entry
= byte_get (indices
, 4);
8843 if (entry
>= filedata
->file_header
.e_shnum
)
8845 static unsigned num_group_errors
= 0;
8847 if (num_group_errors
++ < 10)
8849 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
8850 entry
, i
, filedata
->file_header
.e_shnum
- 1);
8851 if (num_group_errors
== 10)
8852 warn (_("Further error messages about overlarge group section indices suppressed\n"));
8857 if (filedata
->section_headers_groups
[entry
] != NULL
)
8861 static unsigned num_errs
= 0;
8863 if (num_errs
++ < 10)
8865 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
8867 filedata
->section_headers_groups
[entry
]->group_index
);
8869 warn (_("Further error messages about already contained group sections suppressed\n"));
8875 /* Intel C/C++ compiler may put section 0 in a
8876 section group. We just warn it the first time
8877 and ignore it afterwards. */
8878 static bool warned
= false;
8881 error (_("section 0 in group section [%5u]\n"),
8882 filedata
->section_headers_groups
[entry
]->group_index
);
8888 filedata
->section_headers_groups
[entry
] = group
;
8890 if (do_section_groups
)
8892 sec
= filedata
->section_headers
+ entry
;
8893 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
8896 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
8897 g
->section_index
= entry
;
8898 g
->next
= group
->root
;
8913 /* Data used to display dynamic fixups. */
8915 struct ia64_vms_dynfixup
8917 uint64_t needed_ident
; /* Library ident number. */
8918 uint64_t needed
; /* Index in the dstrtab of the library name. */
8919 uint64_t fixup_needed
; /* Index of the library. */
8920 uint64_t fixup_rela_cnt
; /* Number of fixups. */
8921 uint64_t fixup_rela_off
; /* Fixups offset in the dynamic segment. */
8924 /* Data used to display dynamic relocations. */
8926 struct ia64_vms_dynimgrela
8928 uint64_t img_rela_cnt
; /* Number of relocations. */
8929 uint64_t img_rela_off
; /* Reloc offset in the dynamic segment. */
8932 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
8936 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
8937 struct ia64_vms_dynfixup
* fixup
,
8938 const char * strtab
,
8939 unsigned int strtab_sz
)
8941 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
8943 const char * lib_name
;
8945 imfs
= get_data (NULL
, filedata
,
8946 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
8947 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
8948 _("dynamic section image fixups"));
8952 if (fixup
->needed
< strtab_sz
)
8953 lib_name
= strtab
+ fixup
->needed
;
8956 warn (_("corrupt library name index of %#" PRIx64
8957 " found in dynamic entry"), fixup
->needed
);
8961 printf (_("\nImage fixups for needed library #%" PRId64
8962 ": %s - ident: %" PRIx64
"\n"),
8963 fixup
->fixup_needed
, lib_name
, fixup
->needed_ident
);
8965 (_("Seg Offset Type SymVec DataType\n"));
8967 for (i
= 0; i
< (size_t) fixup
->fixup_rela_cnt
; i
++)
8972 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
8973 printf ("%016" PRIx64
" ", BYTE_GET (imfs
[i
].fixup_offset
));
8974 type
= BYTE_GET (imfs
[i
].type
);
8975 rtype
= elf_ia64_reloc_type (type
);
8977 printf ("0x%08x ", type
);
8979 printf ("%-32s ", rtype
);
8980 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
8981 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
8988 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
8991 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
8993 Elf64_External_VMS_IMAGE_RELA
*imrs
;
8996 imrs
= get_data (NULL
, filedata
,
8997 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
8998 sizeof (*imrs
), imgrela
->img_rela_cnt
,
8999 _("dynamic section image relocations"));
9003 printf (_("\nImage relocs\n"));
9005 (_("Seg Offset Type Addend Seg Sym Off\n"));
9007 for (i
= 0; i
< (size_t) imgrela
->img_rela_cnt
; i
++)
9012 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
9013 printf ("%08" PRIx64
" ", BYTE_GET (imrs
[i
].rela_offset
));
9014 type
= BYTE_GET (imrs
[i
].type
);
9015 rtype
= elf_ia64_reloc_type (type
);
9017 printf ("0x%08x ", type
);
9019 printf ("%-31s ", rtype
);
9020 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
9021 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
9022 printf ("%08" PRIx64
"\n", BYTE_GET (imrs
[i
].sym_offset
));
9029 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
9032 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
9034 struct ia64_vms_dynfixup fixup
;
9035 struct ia64_vms_dynimgrela imgrela
;
9036 Elf_Internal_Dyn
*entry
;
9037 uint64_t strtab_off
= 0;
9038 uint64_t strtab_sz
= 0;
9039 char *strtab
= NULL
;
9042 memset (&fixup
, 0, sizeof (fixup
));
9043 memset (&imgrela
, 0, sizeof (imgrela
));
9045 /* Note: the order of the entries is specified by the OpenVMS specs. */
9046 for (entry
= filedata
->dynamic_section
;
9047 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
9050 switch (entry
->d_tag
)
9052 case DT_IA_64_VMS_STRTAB_OFFSET
:
9053 strtab_off
= entry
->d_un
.d_val
;
9056 strtab_sz
= entry
->d_un
.d_val
;
9058 strtab
= get_data (NULL
, filedata
,
9059 filedata
->dynamic_addr
+ strtab_off
,
9060 1, strtab_sz
, _("dynamic string section"));
9065 case DT_IA_64_VMS_NEEDED_IDENT
:
9066 fixup
.needed_ident
= entry
->d_un
.d_val
;
9069 fixup
.needed
= entry
->d_un
.d_val
;
9071 case DT_IA_64_VMS_FIXUP_NEEDED
:
9072 fixup
.fixup_needed
= entry
->d_un
.d_val
;
9074 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
9075 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
9077 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
9078 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
9079 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
9082 case DT_IA_64_VMS_IMG_RELA_CNT
:
9083 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
9085 case DT_IA_64_VMS_IMG_RELA_OFF
:
9086 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
9087 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
9106 relocation_type rel_type
;
9108 dynamic_relocations
[] =
9110 { "REL", DT_REL
, DT_RELSZ
, reltype_rel
},
9111 { "RELA", DT_RELA
, DT_RELASZ
, reltype_rela
},
9112 { "RELR", DT_RELR
, DT_RELRSZ
, reltype_relr
},
9113 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, reltype_unknown
}
9116 static relocation_type
9117 rel_type_from_sh_type (unsigned int sh_type
)
9121 case SHT_RELA
: return reltype_rela
;
9122 case SHT_REL
: return reltype_rel
;
9123 case SHT_RELR
: return reltype_relr
;
9124 default: return reltype_unknown
;
9129 display_relocations (Elf_Internal_Shdr
* section
,
9130 Filedata
* filedata
)
9132 relocation_type rel_type
= rel_type_from_sh_type (section
->sh_type
);
9134 if (rel_type
== reltype_unknown
)
9137 uint64_t rel_size
= section
->sh_size
;
9142 if (filedata
->is_separate
)
9143 printf (_("\nIn linked file '%s' relocation section "),
9144 filedata
->file_name
);
9146 printf (_("\nRelocation section "));
9148 if (filedata
->string_table
== NULL
)
9149 printf ("%d", section
->sh_name
);
9151 printf ("'%s'", printable_section_name (filedata
, section
));
9153 uint64_t num_rela
= rel_size
/ section
->sh_entsize
;
9154 uint64_t rel_offset
= section
->sh_offset
;
9156 if (rel_type
== reltype_relr
)
9158 /* Just stating the 'number of entries' in a RELR section can be
9159 misleading, since this is not the number of locations relocated, but
9160 the number of words in the compressed RELR format. So also provide
9161 the number of locations affected. */
9163 /* This is unlikely, but possible. */
9164 printf (_(" at offset %#" PRIx64
9165 " contains 1 entry which relocates 1 location:\n"),
9168 printf (_(" at offset %#" PRIx64
" contains %" PRIu64
9169 " entries which relocate %" PRIu64
" locations:\n"),
9170 rel_offset
, num_rela
, count_relr_relocations (filedata
, section
));
9174 printf (ngettext (" at offset %#" PRIx64
9175 " contains %" PRIu64
" entry:\n",
9176 " at offset %#" PRIx64
9177 " contains %" PRIu64
" entries:\n",
9179 rel_offset
, num_rela
);
9182 Elf_Internal_Shdr
* symsec
;
9183 Elf_Internal_Sym
* symtab
= NULL
;
9185 uint64_t strtablen
= 0;
9186 char * strtab
= NULL
;
9188 if (section
->sh_link
== 0
9189 || section
->sh_link
>= filedata
->file_header
.e_shnum
)
9191 /* Symbol data not available.
9192 This can happen, especially with RELR relocs.
9193 See if there is a .symtab section present.
9194 If so then use it. */
9195 symsec
= find_section_by_name (filedata
, ".symtab");
9199 symsec
= filedata
->section_headers
+ section
->sh_link
;
9201 if (symsec
->sh_type
!= SHT_SYMTAB
9202 && symsec
->sh_type
!= SHT_DYNSYM
)
9207 && !get_symtab (filedata
, symsec
, &symtab
, &nsyms
, &strtab
, &strtablen
))
9212 if (rel_type
== reltype_relr
)
9213 res
= dump_relr_relocations (filedata
, section
, symtab
, nsyms
, strtab
, strtablen
);
9215 res
= dump_relocations (filedata
, rel_offset
, rel_size
,
9216 symtab
, nsyms
, strtab
, strtablen
,
9218 symsec
== NULL
? false : symsec
->sh_type
== SHT_DYNSYM
);
9225 /* Process the reloc section. */
9228 process_relocs (Filedata
* filedata
)
9231 uint64_t rel_offset
;
9236 if (do_using_dynamic
)
9238 relocation_type rel_type
;
9240 bool has_dynamic_reloc
;
9243 has_dynamic_reloc
= false;
9245 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
9247 rel_type
= dynamic_relocations
[i
].rel_type
;
9248 name
= dynamic_relocations
[i
].name
;
9249 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
9250 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
9253 has_dynamic_reloc
= true;
9255 if (rel_type
== reltype_unknown
)
9257 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
9258 switch (filedata
->dynamic_info
[DT_PLTREL
])
9261 rel_type
= reltype_rel
;
9264 rel_type
= reltype_rela
;
9271 if (filedata
->is_separate
)
9273 (_("\nIn linked file '%s' section '%s' at offset %#" PRIx64
9274 " contains %" PRId64
" bytes:\n"),
9275 filedata
->file_name
, name
, rel_offset
, rel_size
);
9278 (_("\n'%s' relocation section at offset %#" PRIx64
9279 " contains %" PRId64
" bytes:\n"),
9280 name
, rel_offset
, rel_size
);
9282 dump_relocations (filedata
,
9283 offset_from_vma (filedata
, rel_offset
, rel_size
),
9285 filedata
->dynamic_symbols
,
9286 filedata
->num_dynamic_syms
,
9287 filedata
->dynamic_strings
,
9288 filedata
->dynamic_strings_length
,
9289 rel_type
, true /* is_dynamic */);
9293 if (is_ia64_vms (filedata
))
9294 if (process_ia64_vms_dynamic_relocs (filedata
))
9295 has_dynamic_reloc
= true;
9297 if (! has_dynamic_reloc
)
9299 if (filedata
->is_separate
)
9300 printf (_("\nThere are no dynamic relocations in linked file '%s'.\n"),
9301 filedata
->file_name
);
9303 printf (_("\nThere are no dynamic relocations in this file.\n"));
9308 Elf_Internal_Shdr
* section
;
9312 for (i
= 0, section
= filedata
->section_headers
;
9313 i
< filedata
->file_header
.e_shnum
;
9316 if (display_relocations (section
, filedata
))
9322 /* Users sometimes forget the -D option, so try to be helpful. */
9323 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
9325 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
9327 if (filedata
->is_separate
)
9328 printf (_("\nThere are no static relocations in linked file '%s'."),
9329 filedata
->file_name
);
9331 printf (_("\nThere are no static relocations in this file."));
9332 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
9337 if (i
== ARRAY_SIZE (dynamic_relocations
))
9339 if (filedata
->is_separate
)
9340 printf (_("\nThere are no relocations in linked file '%s'.\n"),
9341 filedata
->file_name
);
9343 printf (_("\nThere are no relocations in this file.\n"));
9351 /* An absolute address consists of a section and an offset. If the
9352 section is NULL, the offset itself is the address, otherwise, the
9353 address equals to LOAD_ADDRESS(section) + offset. */
9357 unsigned short section
;
9361 /* Find the nearest symbol at or below ADDR. Returns the symbol
9362 name, if found, and the offset from the symbol to ADDR. */
9365 find_symbol_for_address (Filedata
*filedata
,
9366 Elf_Internal_Sym
*symtab
,
9369 uint64_t strtab_size
,
9370 struct absaddr addr
,
9371 const char **symname
,
9374 uint64_t dist
= 0x100000;
9375 Elf_Internal_Sym
* sym
;
9376 Elf_Internal_Sym
* beg
;
9377 Elf_Internal_Sym
* end
;
9378 Elf_Internal_Sym
* best
= NULL
;
9380 REMOVE_ARCH_BITS (addr
.offset
);
9382 end
= symtab
+ nsyms
;
9388 sym
= beg
+ (end
- beg
) / 2;
9390 value
= sym
->st_value
;
9391 REMOVE_ARCH_BITS (value
);
9393 if (sym
->st_name
!= 0
9394 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
9395 && addr
.offset
>= value
9396 && addr
.offset
- value
< dist
)
9399 dist
= addr
.offset
- value
;
9404 if (addr
.offset
< value
)
9412 *symname
= (best
->st_name
>= strtab_size
9413 ? _("<corrupt>") : strtab
+ best
->st_name
);
9419 *offset
= addr
.offset
;
9422 /* Process the unwind section. */
9424 #include "unwind-ia64.h"
9426 struct ia64_unw_table_entry
9428 struct absaddr start
;
9430 struct absaddr info
;
9433 struct ia64_unw_aux_info
9435 struct ia64_unw_table_entry
* table
; /* Unwind table. */
9436 uint64_t table_len
; /* Length of unwind table. */
9437 unsigned char * info
; /* Unwind info. */
9438 uint64_t info_size
; /* Size of unwind info. */
9439 uint64_t info_addr
; /* Starting address of unwind info. */
9440 uint64_t seg_base
; /* Starting address of segment. */
9441 Elf_Internal_Sym
* symtab
; /* The symbol table. */
9442 uint64_t nsyms
; /* Number of symbols. */
9443 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
9444 uint64_t nfuns
; /* Number of entries in funtab. */
9445 char * strtab
; /* The string table. */
9446 uint64_t strtab_size
; /* Size of string table. */
9450 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
9452 struct ia64_unw_table_entry
* tp
;
9457 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9458 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9459 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9460 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9462 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9464 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
9468 const unsigned char * dp
;
9469 const unsigned char * head
;
9470 const unsigned char * end
;
9471 const char * procname
;
9473 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
9474 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
9476 fputs ("\n<", stdout
);
9480 fputs (procname
, stdout
);
9483 printf ("+%" PRIx64
, offset
);
9486 fputs (">: [", stdout
);
9487 print_vma (tp
->start
.offset
, PREFIX_HEX
);
9488 fputc ('-', stdout
);
9489 print_vma (tp
->end
.offset
, PREFIX_HEX
);
9490 printf ("], info at +0x%" PRIx64
"\n",
9491 tp
->info
.offset
- aux
->seg_base
);
9493 /* PR 17531: file: 86232b32. */
9494 if (aux
->info
== NULL
)
9497 offset
= tp
->info
.offset
;
9498 if (tp
->info
.section
)
9500 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
9502 warn (_("Invalid section %u in table entry %td\n"),
9503 tp
->info
.section
, tp
- aux
->table
);
9507 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
9509 offset
-= aux
->info_addr
;
9510 /* PR 17531: file: 0997b4d1. */
9511 if (offset
>= aux
->info_size
9512 || aux
->info_size
- offset
< 8)
9514 warn (_("Invalid offset %" PRIx64
" in table entry %td\n"),
9515 tp
->info
.offset
, tp
- aux
->table
);
9520 head
= aux
->info
+ offset
;
9521 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
9523 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
9524 (unsigned) UNW_VER (stamp
),
9525 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
9526 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
9527 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
9528 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
9530 if (UNW_VER (stamp
) != 1)
9532 printf (_("\tUnknown version.\n"));
9537 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
9538 /* PR 17531: file: 16ceda89. */
9539 if (end
> aux
->info
+ aux
->info_size
)
9540 end
= aux
->info
+ aux
->info_size
;
9541 for (dp
= head
+ 8; dp
< end
;)
9542 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
9551 slurp_ia64_unwind_table (Filedata
* filedata
,
9552 struct ia64_unw_aux_info
* aux
,
9553 Elf_Internal_Shdr
* sec
)
9555 uint64_t size
, nrelas
, i
;
9556 Elf_Internal_Phdr
* seg
;
9557 struct ia64_unw_table_entry
* tep
;
9558 Elf_Internal_Shdr
* relsec
;
9559 Elf_Internal_Rela
* rela
;
9560 Elf_Internal_Rela
* rp
;
9561 unsigned char * table
;
9563 Elf_Internal_Sym
* sym
;
9564 const char * relname
;
9568 /* First, find the starting address of the segment that includes
9571 if (filedata
->file_header
.e_phnum
)
9573 if (! get_program_headers (filedata
))
9576 for (seg
= filedata
->program_headers
;
9577 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
9580 if (seg
->p_type
!= PT_LOAD
)
9583 if (sec
->sh_addr
>= seg
->p_vaddr
9584 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
9586 aux
->seg_base
= seg
->p_vaddr
;
9592 /* Second, build the unwind table from the contents of the unwind section: */
9593 size
= sec
->sh_size
;
9594 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
9599 aux
->table_len
= size
/ (3 * eh_addr_size
);
9600 aux
->table
= (struct ia64_unw_table_entry
*)
9601 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
9604 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
9606 tep
->start
.section
= SHN_UNDEF
;
9607 tep
->end
.section
= SHN_UNDEF
;
9608 tep
->info
.section
= SHN_UNDEF
;
9609 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
9610 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
9611 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
9612 tep
->start
.offset
+= aux
->seg_base
;
9613 tep
->end
.offset
+= aux
->seg_base
;
9614 tep
->info
.offset
+= aux
->seg_base
;
9618 /* Third, apply any relocations to the unwind table: */
9619 for (relsec
= filedata
->section_headers
;
9620 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
9623 if (relsec
->sh_type
!= SHT_RELA
9624 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
9625 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
9628 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
9637 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
9639 unsigned int sym_ndx
;
9640 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
9641 relname
= elf_ia64_reloc_type (r_type
);
9643 /* PR 17531: file: 9fa67536. */
9644 if (relname
== NULL
)
9646 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
9650 if (! startswith (relname
, "R_IA64_SEGREL"))
9652 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
9656 i
= rp
->r_offset
/ (3 * eh_addr_size
);
9658 /* PR 17531: file: 5bc8d9bf. */
9659 if (i
>= aux
->table_len
)
9661 warn (_("Skipping reloc with overlarge offset: %#" PRIx64
"\n"),
9666 sym_ndx
= get_reloc_symindex (rp
->r_info
);
9667 if (sym_ndx
>= aux
->nsyms
)
9669 warn (_("Skipping reloc with invalid symbol index: %u\n"),
9673 sym
= aux
->symtab
+ sym_ndx
;
9675 switch (rp
->r_offset
/ eh_addr_size
% 3)
9678 aux
->table
[i
].start
.section
= sym
->st_shndx
;
9679 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
9682 aux
->table
[i
].end
.section
= sym
->st_shndx
;
9683 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
9686 aux
->table
[i
].info
.section
= sym
->st_shndx
;
9687 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
9701 ia64_process_unwind (Filedata
* filedata
)
9703 Elf_Internal_Shdr
* sec
;
9704 Elf_Internal_Shdr
* unwsec
= NULL
;
9705 uint64_t i
, unwcount
= 0, unwstart
= 0;
9706 struct ia64_unw_aux_info aux
;
9709 memset (& aux
, 0, sizeof (aux
));
9711 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9713 if (sec
->sh_type
== SHT_SYMTAB
)
9717 error (_("Multiple symbol tables encountered\n"));
9723 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9724 &aux
.strtab
, &aux
.strtab_size
))
9727 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
9732 printf (_("\nThere are no unwind sections in this file.\n"));
9734 while (unwcount
-- > 0)
9739 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
9740 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9741 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
9746 /* We have already counted the number of SHT_IA64_UNWIND
9747 sections so the loop above should never fail. */
9748 assert (unwsec
!= NULL
);
9751 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
9753 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
9755 /* We need to find which section group it is in. */
9756 struct group_list
* g
;
9758 if (filedata
->section_headers_groups
== NULL
9759 || filedata
->section_headers_groups
[i
] == NULL
)
9760 i
= filedata
->file_header
.e_shnum
;
9763 g
= filedata
->section_headers_groups
[i
]->root
;
9765 for (; g
!= NULL
; g
= g
->next
)
9767 sec
= filedata
->section_headers
+ g
->section_index
;
9769 if (section_name_valid (filedata
, sec
)
9770 && streq (section_name (filedata
, sec
),
9771 ELF_STRING_ia64_unwind_info
))
9776 i
= filedata
->file_header
.e_shnum
;
9779 else if (section_name_valid (filedata
, unwsec
)
9780 && startswith (section_name (filedata
, unwsec
),
9781 ELF_STRING_ia64_unwind_once
))
9783 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
9784 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
9785 suffix
= section_name (filedata
, unwsec
) + len
;
9786 for (i
= 0, sec
= filedata
->section_headers
;
9787 i
< filedata
->file_header
.e_shnum
;
9789 if (section_name_valid (filedata
, sec
)
9790 && startswith (section_name (filedata
, sec
),
9791 ELF_STRING_ia64_unwind_info_once
)
9792 && streq (section_name (filedata
, sec
) + len2
, suffix
))
9797 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
9798 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
9799 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
9800 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
9802 if (section_name_valid (filedata
, unwsec
)
9803 && startswith (section_name (filedata
, unwsec
),
9804 ELF_STRING_ia64_unwind
))
9805 suffix
= section_name (filedata
, unwsec
) + len
;
9806 for (i
= 0, sec
= filedata
->section_headers
;
9807 i
< filedata
->file_header
.e_shnum
;
9809 if (section_name_valid (filedata
, sec
)
9810 && startswith (section_name (filedata
, sec
),
9811 ELF_STRING_ia64_unwind_info
)
9812 && streq (section_name (filedata
, sec
) + len2
, suffix
))
9816 if (i
== filedata
->file_header
.e_shnum
)
9818 printf (_("\nCould not find unwind info section for "));
9820 if (filedata
->string_table
== NULL
)
9821 printf ("%d", unwsec
->sh_name
);
9823 printf ("'%s'", printable_section_name (filedata
, unwsec
));
9827 aux
.info_addr
= sec
->sh_addr
;
9828 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
9831 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
9833 printf (_("\nUnwind section "));
9835 if (filedata
->string_table
== NULL
)
9836 printf ("%d", unwsec
->sh_name
);
9838 printf ("'%s'", printable_section_name (filedata
, unwsec
));
9840 printf (_(" at offset %#" PRIx64
" contains %" PRIu64
" entries:\n"),
9842 unwsec
->sh_size
/ (3 * eh_addr_size
));
9844 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
9845 && aux
.table_len
> 0)
9846 dump_ia64_unwind (filedata
, & aux
);
9848 free ((char *) aux
.table
);
9849 free ((char *) aux
.info
);
9856 free ((char *) aux
.strtab
);
9861 struct hppa_unw_table_entry
9863 struct absaddr start
;
9865 unsigned int Cannot_unwind
:1; /* 0 */
9866 unsigned int Millicode
:1; /* 1 */
9867 unsigned int Millicode_save_sr0
:1; /* 2 */
9868 unsigned int Region_description
:2; /* 3..4 */
9869 unsigned int reserved1
:1; /* 5 */
9870 unsigned int Entry_SR
:1; /* 6 */
9871 unsigned int Entry_FR
:4; /* Number saved 7..10 */
9872 unsigned int Entry_GR
:5; /* Number saved 11..15 */
9873 unsigned int Args_stored
:1; /* 16 */
9874 unsigned int Variable_Frame
:1; /* 17 */
9875 unsigned int Separate_Package_Body
:1; /* 18 */
9876 unsigned int Frame_Extension_Millicode
:1; /* 19 */
9877 unsigned int Stack_Overflow_Check
:1; /* 20 */
9878 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
9879 unsigned int Ada_Region
:1; /* 22 */
9880 unsigned int cxx_info
:1; /* 23 */
9881 unsigned int cxx_try_catch
:1; /* 24 */
9882 unsigned int sched_entry_seq
:1; /* 25 */
9883 unsigned int reserved2
:1; /* 26 */
9884 unsigned int Save_SP
:1; /* 27 */
9885 unsigned int Save_RP
:1; /* 28 */
9886 unsigned int Save_MRP_in_frame
:1; /* 29 */
9887 unsigned int extn_ptr_defined
:1; /* 30 */
9888 unsigned int Cleanup_defined
:1; /* 31 */
9890 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
9891 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
9892 unsigned int Large_frame
:1; /* 2 */
9893 unsigned int Pseudo_SP_Set
:1; /* 3 */
9894 unsigned int reserved4
:1; /* 4 */
9895 unsigned int Total_frame_size
:27; /* 5..31 */
9898 struct hppa_unw_aux_info
9900 struct hppa_unw_table_entry
* table
; /* Unwind table. */
9901 uint64_t table_len
; /* Length of unwind table. */
9902 uint64_t seg_base
; /* Starting address of segment. */
9903 Elf_Internal_Sym
* symtab
; /* The symbol table. */
9904 uint64_t nsyms
; /* Number of symbols. */
9905 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
9906 uint64_t nfuns
; /* Number of entries in funtab. */
9907 char * strtab
; /* The string table. */
9908 uint64_t strtab_size
; /* Size of string table. */
9912 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
9914 struct hppa_unw_table_entry
* tp
;
9918 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9919 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9920 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9921 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9923 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9925 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
9928 const char * procname
;
9930 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
9931 aux
->strtab_size
, tp
->start
, &procname
,
9934 fputs ("\n<", stdout
);
9938 fputs (procname
, stdout
);
9941 printf ("+%" PRIx64
, offset
);
9944 fputs (">: [", stdout
);
9945 print_vma (tp
->start
.offset
, PREFIX_HEX
);
9946 fputc ('-', stdout
);
9947 print_vma (tp
->end
.offset
, PREFIX_HEX
);
9950 #define PF(_m) if (tp->_m) printf (#_m " ");
9951 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
9954 PF(Millicode_save_sr0
);
9955 /* PV(Region_description); */
9961 PF(Separate_Package_Body
);
9962 PF(Frame_Extension_Millicode
);
9963 PF(Stack_Overflow_Check
);
9964 PF(Two_Instruction_SP_Increment
);
9968 PF(sched_entry_seq
);
9971 PF(Save_MRP_in_frame
);
9972 PF(extn_ptr_defined
);
9973 PF(Cleanup_defined
);
9974 PF(MPE_XL_interrupt_marker
);
9975 PF(HP_UX_interrupt_marker
);
9978 PV(Total_frame_size
);
9991 slurp_hppa_unwind_table (Filedata
* filedata
,
9992 struct hppa_unw_aux_info
* aux
,
9993 Elf_Internal_Shdr
* sec
)
9995 uint64_t size
, unw_ent_size
, nentries
, nrelas
, i
;
9996 Elf_Internal_Phdr
* seg
;
9997 struct hppa_unw_table_entry
* tep
;
9998 Elf_Internal_Shdr
* relsec
;
9999 Elf_Internal_Rela
* rela
;
10000 Elf_Internal_Rela
* rp
;
10001 unsigned char * table
;
10002 unsigned char * tp
;
10003 Elf_Internal_Sym
* sym
;
10004 const char * relname
;
10006 /* First, find the starting address of the segment that includes
10008 if (filedata
->file_header
.e_phnum
)
10010 if (! get_program_headers (filedata
))
10013 for (seg
= filedata
->program_headers
;
10014 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
10017 if (seg
->p_type
!= PT_LOAD
)
10020 if (sec
->sh_addr
>= seg
->p_vaddr
10021 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
10023 aux
->seg_base
= seg
->p_vaddr
;
10029 /* Second, build the unwind table from the contents of the unwind
10031 size
= sec
->sh_size
;
10032 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
10033 _("unwind table"));
10038 nentries
= size
/ unw_ent_size
;
10039 size
= unw_ent_size
* nentries
;
10041 aux
->table_len
= nentries
;
10042 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
10043 xcmalloc (nentries
, sizeof (aux
->table
[0]));
10045 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
10047 unsigned int tmp1
, tmp2
;
10049 tep
->start
.section
= SHN_UNDEF
;
10050 tep
->end
.section
= SHN_UNDEF
;
10052 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
10053 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
10054 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
10055 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
10057 tep
->start
.offset
+= aux
->seg_base
;
10058 tep
->end
.offset
+= aux
->seg_base
;
10060 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
10061 tep
->Millicode
= (tmp1
>> 30) & 0x1;
10062 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
10063 tep
->Region_description
= (tmp1
>> 27) & 0x3;
10064 tep
->reserved1
= (tmp1
>> 26) & 0x1;
10065 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
10066 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
10067 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
10068 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
10069 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
10070 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
10071 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
10072 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
10073 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
10074 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
10075 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
10076 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
10077 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
10078 tep
->reserved2
= (tmp1
>> 5) & 0x1;
10079 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
10080 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
10081 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
10082 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
10083 tep
->Cleanup_defined
= tmp1
& 0x1;
10085 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
10086 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
10087 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
10088 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
10089 tep
->reserved4
= (tmp2
>> 27) & 0x1;
10090 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
10094 /* Third, apply any relocations to the unwind table. */
10095 for (relsec
= filedata
->section_headers
;
10096 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
10099 if (relsec
->sh_type
!= SHT_RELA
10100 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
10101 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
10104 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
10108 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
10110 unsigned int sym_ndx
;
10111 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
10112 relname
= elf_hppa_reloc_type (r_type
);
10114 if (relname
== NULL
)
10116 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
10120 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
10121 if (! startswith (relname
, "R_PARISC_SEGREL"))
10123 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
10127 i
= rp
->r_offset
/ unw_ent_size
;
10128 if (i
>= aux
->table_len
)
10130 warn (_("Skipping reloc with overlarge offset: %#" PRIx64
"\n"),
10135 sym_ndx
= get_reloc_symindex (rp
->r_info
);
10136 if (sym_ndx
>= aux
->nsyms
)
10138 warn (_("Skipping reloc with invalid symbol index: %u\n"),
10142 sym
= aux
->symtab
+ sym_ndx
;
10144 switch ((rp
->r_offset
% unw_ent_size
) / 4)
10147 aux
->table
[i
].start
.section
= sym
->st_shndx
;
10148 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
10151 aux
->table
[i
].end
.section
= sym
->st_shndx
;
10152 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
10166 hppa_process_unwind (Filedata
* filedata
)
10168 struct hppa_unw_aux_info aux
;
10169 Elf_Internal_Shdr
* unwsec
= NULL
;
10170 Elf_Internal_Shdr
* sec
;
10174 if (filedata
->string_table
== NULL
)
10177 memset (& aux
, 0, sizeof (aux
));
10179 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
10181 if (sec
->sh_type
== SHT_SYMTAB
)
10185 error (_("Multiple symbol tables encountered\n"));
10191 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
10192 &aux
.strtab
, &aux
.strtab_size
))
10195 else if (section_name_valid (filedata
, sec
)
10196 && streq (section_name (filedata
, sec
), ".PARISC.unwind"))
10201 printf (_("\nThere are no unwind sections in this file.\n"));
10203 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
10205 if (section_name_valid (filedata
, sec
)
10206 && streq (section_name (filedata
, sec
), ".PARISC.unwind"))
10208 uint64_t num_unwind
= sec
->sh_size
/ 16;
10210 printf (ngettext ("\nUnwind section '%s' at offset %#" PRIx64
" "
10211 "contains %" PRIu64
" entry:\n",
10212 "\nUnwind section '%s' at offset %#" PRIx64
" "
10213 "contains %" PRIu64
" entries:\n",
10215 printable_section_name (filedata
, sec
),
10219 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
10222 if (res
&& aux
.table_len
> 0)
10224 if (! dump_hppa_unwind (filedata
, &aux
))
10228 free ((char *) aux
.table
);
10234 free ((char *) aux
.strtab
);
10241 unsigned char * data
; /* The unwind data. */
10242 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
10243 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
10244 uint64_t nrelas
; /* The number of relocations. */
10245 unsigned int rel_type
; /* REL or RELA ? */
10246 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
10249 struct arm_unw_aux_info
10251 Filedata
* filedata
; /* The file containing the unwind sections. */
10252 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
10253 uint64_t nsyms
; /* Number of symbols. */
10254 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
10255 uint64_t nfuns
; /* Number of these symbols. */
10256 char * strtab
; /* The file's string table. */
10257 uint64_t strtab_size
; /* Size of string table. */
10260 static const char *
10261 arm_print_vma_and_name (Filedata
* filedata
,
10262 struct arm_unw_aux_info
* aux
,
10264 struct absaddr addr
)
10266 const char *procname
;
10267 uint64_t sym_offset
;
10269 if (addr
.section
== SHN_UNDEF
)
10272 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
10273 aux
->strtab_size
, addr
, &procname
,
10276 print_vma (fn
, PREFIX_HEX
);
10280 fputs (" <", stdout
);
10281 fputs (procname
, stdout
);
10284 printf ("+0x%" PRIx64
, sym_offset
);
10285 fputc ('>', stdout
);
10292 arm_free_section (struct arm_section
*arm_sec
)
10294 free (arm_sec
->data
);
10295 free (arm_sec
->rela
);
10298 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
10299 cached section and install SEC instead.
10300 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
10301 and return its valued in * WORDP, relocating if necessary.
10302 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
10303 relocation's offset in ADDR.
10304 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
10305 into the string table of the symbol associated with the reloc. If no
10306 reloc was applied store -1 there.
10307 5) Return TRUE upon success, FALSE otherwise. */
10310 get_unwind_section_word (Filedata
* filedata
,
10311 struct arm_unw_aux_info
* aux
,
10312 struct arm_section
* arm_sec
,
10313 Elf_Internal_Shdr
* sec
,
10314 uint64_t word_offset
,
10315 unsigned int * wordp
,
10316 struct absaddr
* addr
,
10317 uint64_t * sym_name
)
10319 Elf_Internal_Rela
*rp
;
10320 Elf_Internal_Sym
*sym
;
10321 const char * relname
;
10325 if (sec
== NULL
|| arm_sec
== NULL
)
10328 addr
->section
= SHN_UNDEF
;
10331 if (sym_name
!= NULL
)
10332 *sym_name
= (uint64_t) -1;
10334 /* If necessary, update the section cache. */
10335 if (sec
!= arm_sec
->sec
)
10337 Elf_Internal_Shdr
*relsec
;
10339 arm_free_section (arm_sec
);
10341 arm_sec
->sec
= sec
;
10342 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
10343 sec
->sh_size
, _("unwind data"));
10344 arm_sec
->rela
= NULL
;
10345 arm_sec
->nrelas
= 0;
10347 for (relsec
= filedata
->section_headers
;
10348 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
10351 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
10352 || filedata
->section_headers
+ relsec
->sh_info
!= sec
10353 /* PR 15745: Check the section type as well. */
10354 || (relsec
->sh_type
!= SHT_REL
10355 && relsec
->sh_type
!= SHT_RELA
))
10358 arm_sec
->rel_type
= relsec
->sh_type
;
10359 if (relsec
->sh_type
== SHT_REL
)
10361 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
10363 & arm_sec
->rela
, & arm_sec
->nrelas
))
10366 else /* relsec->sh_type == SHT_RELA */
10368 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
10370 & arm_sec
->rela
, & arm_sec
->nrelas
))
10376 arm_sec
->next_rela
= arm_sec
->rela
;
10379 /* If there is no unwind data we can do nothing. */
10380 if (arm_sec
->data
== NULL
)
10383 /* If the offset is invalid then fail. */
10384 if (/* PR 21343 *//* PR 18879 */
10386 || word_offset
> sec
->sh_size
- 4)
10389 /* Get the word at the required offset. */
10390 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
10392 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
10393 if (arm_sec
->rela
== NULL
)
10399 /* Look through the relocs to find the one that applies to the provided offset. */
10401 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
10403 uint64_t prelval
, offset
;
10405 if (rp
->r_offset
> word_offset
&& !wrapped
)
10407 rp
= arm_sec
->rela
;
10410 if (rp
->r_offset
> word_offset
)
10413 if (rp
->r_offset
& 3)
10415 warn (_("Skipping unexpected relocation at offset %#" PRIx64
"\n"),
10420 if (rp
->r_offset
< word_offset
)
10423 /* PR 17531: file: 027-161405-0.004 */
10424 if (aux
->symtab
== NULL
)
10427 if (arm_sec
->rel_type
== SHT_REL
)
10429 offset
= word
& 0x7fffffff;
10430 if (offset
& 0x40000000)
10431 offset
|= ~ (uint64_t) 0x7fffffff;
10433 else if (arm_sec
->rel_type
== SHT_RELA
)
10434 offset
= rp
->r_addend
;
10437 error (_("Unknown section relocation type %d encountered\n"),
10438 arm_sec
->rel_type
);
10442 /* PR 17531 file: 027-1241568-0.004. */
10443 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
10445 error (_("Bad symbol index in unwind relocation "
10446 "(%" PRIu64
" > %" PRIu64
")\n"),
10447 ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
10451 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
10452 offset
+= sym
->st_value
;
10453 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
10455 /* Check that we are processing the expected reloc type. */
10456 if (filedata
->file_header
.e_machine
== EM_ARM
)
10458 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
10459 if (relname
== NULL
)
10461 warn (_("Skipping unknown ARM relocation type: %d\n"),
10462 (int) ELF32_R_TYPE (rp
->r_info
));
10466 if (streq (relname
, "R_ARM_NONE"))
10469 if (! streq (relname
, "R_ARM_PREL31"))
10471 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
10475 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
10477 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
10478 if (relname
== NULL
)
10480 warn (_("Skipping unknown C6000 relocation type: %d\n"),
10481 (int) ELF32_R_TYPE (rp
->r_info
));
10485 if (streq (relname
, "R_C6000_NONE"))
10488 if (! streq (relname
, "R_C6000_PREL31"))
10490 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
10498 /* This function currently only supports ARM and TI unwinders. */
10499 warn (_("Only TI and ARM unwinders are currently supported\n"));
10503 word
= (word
& ~ (uint64_t) 0x7fffffff) | (prelval
& 0x7fffffff);
10504 addr
->section
= sym
->st_shndx
;
10505 addr
->offset
= offset
;
10508 * sym_name
= sym
->st_name
;
10513 arm_sec
->next_rela
= rp
;
10518 static const char *tic6x_unwind_regnames
[16] =
10520 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
10521 "A14", "A13", "A12", "A11", "A10",
10522 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
10526 decode_tic6x_unwind_regmask (unsigned int mask
)
10530 for (i
= 12; mask
; mask
>>= 1, i
--)
10534 fputs (tic6x_unwind_regnames
[i
], stdout
);
10536 fputs (", ", stdout
);
10542 if (remaining == 0 && more_words) \
10544 data_offset += 4; \
10545 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
10546 data_offset, & word, & addr, NULL)) \
10552 #define GET_OP(OP) \
10557 (OP) = word >> 24; \
10562 printf (_("[Truncated opcode]\n")); \
10565 printf ("0x%02x ", OP)
10568 decode_arm_unwind_bytecode (Filedata
* filedata
,
10569 struct arm_unw_aux_info
* aux
,
10571 unsigned int remaining
,
10572 unsigned int more_words
,
10573 uint64_t data_offset
,
10574 Elf_Internal_Shdr
* data_sec
,
10575 struct arm_section
* data_arm_sec
)
10577 struct absaddr addr
;
10580 /* Decode the unwinding instructions. */
10583 unsigned int op
, op2
;
10586 if (remaining
== 0)
10592 printf (" 0x%02x ", op
);
10594 if ((op
& 0xc0) == 0x00)
10596 int offset
= ((op
& 0x3f) << 2) + 4;
10598 printf (" vsp = vsp + %d", offset
);
10600 else if ((op
& 0xc0) == 0x40)
10602 int offset
= ((op
& 0x3f) << 2) + 4;
10604 printf (" vsp = vsp - %d", offset
);
10606 else if ((op
& 0xf0) == 0x80)
10609 if (op
== 0x80 && op2
== 0)
10610 printf (_("Refuse to unwind"));
10613 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
10618 for (i
= 0; i
< 12; i
++)
10619 if (mask
& (1 << i
))
10625 printf ("r%d", 4 + i
);
10630 else if ((op
& 0xf0) == 0x90)
10632 if (op
== 0x9d || op
== 0x9f)
10633 printf (_(" [Reserved]"));
10635 printf (" vsp = r%d", op
& 0x0f);
10637 else if ((op
& 0xf0) == 0xa0)
10639 int end
= 4 + (op
& 0x07);
10644 for (i
= 4; i
<= end
; i
++)
10660 else if (op
== 0xb0)
10661 printf (_(" finish"));
10662 else if (op
== 0xb1)
10665 if (op2
== 0 || (op2
& 0xf0) != 0)
10666 printf (_("[Spare]"));
10669 unsigned int mask
= op2
& 0x0f;
10674 for (i
= 0; i
< 12; i
++)
10675 if (mask
& (1 << i
))
10686 else if (op
== 0xb2)
10688 unsigned char buf
[9];
10689 unsigned int i
, len
;
10692 for (i
= 0; i
< sizeof (buf
); i
++)
10695 if ((buf
[i
] & 0x80) == 0)
10698 if (i
== sizeof (buf
))
10700 error (_("corrupt change to vsp\n"));
10705 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
10706 assert (len
== i
+ 1);
10707 offset
= offset
* 4 + 0x204;
10708 printf ("vsp = vsp + %" PRId64
, offset
);
10711 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
10713 unsigned int first
, last
;
10719 first
= first
+ 16;
10720 printf ("pop {D%d", first
);
10722 printf ("-D%d", first
+ last
);
10725 else if (op
== 0xb4)
10726 printf (_(" pop {ra_auth_code}"));
10727 else if (op
== 0xb5)
10728 printf (_(" vsp as modifier for PAC validation"));
10729 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
10731 unsigned int count
= op
& 0x07;
10733 printf ("pop {D8");
10735 printf ("-D%d", 8 + count
);
10738 else if (op
>= 0xc0 && op
<= 0xc5)
10740 unsigned int count
= op
& 0x07;
10742 printf (" pop {wR10");
10744 printf ("-wR%d", 10 + count
);
10747 else if (op
== 0xc6)
10749 unsigned int first
, last
;
10754 printf ("pop {wR%d", first
);
10756 printf ("-wR%d", first
+ last
);
10759 else if (op
== 0xc7)
10762 if (op2
== 0 || (op2
& 0xf0) != 0)
10763 printf (_("[Spare]"));
10766 unsigned int mask
= op2
& 0x0f;
10771 for (i
= 0; i
< 4; i
++)
10772 if (mask
& (1 << i
))
10778 printf ("wCGR%d", i
);
10785 printf (_(" [unsupported opcode]"));
10796 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
10797 struct arm_unw_aux_info
* aux
,
10799 unsigned int remaining
,
10800 unsigned int more_words
,
10801 uint64_t data_offset
,
10802 Elf_Internal_Shdr
* data_sec
,
10803 struct arm_section
* data_arm_sec
)
10805 struct absaddr addr
;
10807 /* Decode the unwinding instructions. */
10810 unsigned int op
, op2
;
10813 if (remaining
== 0)
10819 printf (" 0x%02x ", op
);
10821 if ((op
& 0xc0) == 0x00)
10823 int offset
= ((op
& 0x3f) << 3) + 8;
10824 printf (" sp = sp + %d", offset
);
10826 else if ((op
& 0xc0) == 0x80)
10829 if (op
== 0x80 && op2
== 0)
10830 printf (_("Refuse to unwind"));
10833 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
10835 printf ("pop compact {");
10839 decode_tic6x_unwind_regmask (mask
);
10843 else if ((op
& 0xf0) == 0xc0)
10846 unsigned int nregs
;
10851 unsigned int offset
;
10855 /* Scan entire instruction first so that GET_OP output is not
10856 interleaved with disassembly. */
10858 for (i
= 0; nregs
< (op
& 0xf); i
++)
10864 regpos
[nregs
].offset
= i
* 2;
10865 regpos
[nregs
].reg
= reg
;
10872 regpos
[nregs
].offset
= i
* 2 + 1;
10873 regpos
[nregs
].reg
= reg
;
10878 printf (_("pop frame {"));
10881 printf (_("*corrupt* - no registers specified"));
10886 for (i
= i
* 2; i
> 0; i
--)
10888 if (regpos
[reg
].offset
== i
- 1)
10890 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
10897 fputs (name
, stdout
);
10905 else if (op
== 0xd0)
10906 printf (" MOV FP, SP");
10907 else if (op
== 0xd1)
10908 printf (" __c6xabi_pop_rts");
10909 else if (op
== 0xd2)
10911 unsigned char buf
[9];
10912 unsigned int i
, len
;
10915 for (i
= 0; i
< sizeof (buf
); i
++)
10918 if ((buf
[i
] & 0x80) == 0)
10921 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
10922 if (i
== sizeof (buf
))
10924 warn (_("Corrupt stack pointer adjustment detected\n"));
10928 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
10929 assert (len
== i
+ 1);
10930 offset
= offset
* 8 + 0x408;
10931 printf (_("sp = sp + %" PRId64
), offset
);
10933 else if ((op
& 0xf0) == 0xe0)
10935 if ((op
& 0x0f) == 7)
10936 printf (" RETURN");
10938 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
10942 printf (_(" [unsupported opcode]"));
10951 arm_expand_prel31 (Filedata
* filedata
, uint64_t word
, uint64_t where
)
10955 offset
= word
& 0x7fffffff;
10956 if (offset
& 0x40000000)
10957 offset
|= ~ (uint64_t) 0x7fffffff;
10959 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
10962 return offset
+ where
;
10966 decode_arm_unwind (Filedata
* filedata
,
10967 struct arm_unw_aux_info
* aux
,
10969 unsigned int remaining
,
10970 uint64_t data_offset
,
10971 Elf_Internal_Shdr
* data_sec
,
10972 struct arm_section
* data_arm_sec
)
10975 unsigned int more_words
= 0;
10976 struct absaddr addr
;
10977 uint64_t sym_name
= (uint64_t) -1;
10980 if (remaining
== 0)
10982 /* Fetch the first word.
10983 Note - when decoding an object file the address extracted
10984 here will always be 0. So we also pass in the sym_name
10985 parameter so that we can find the symbol associated with
10986 the personality routine. */
10987 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
10988 & word
, & addr
, & sym_name
))
10995 addr
.section
= SHN_UNDEF
;
10999 if ((word
& 0x80000000) == 0)
11001 /* Expand prel31 for personality routine. */
11003 const char *procname
;
11005 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
11006 printf (_(" Personality routine: "));
11008 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
11009 && sym_name
!= (uint64_t) -1 && sym_name
< aux
->strtab_size
)
11011 procname
= aux
->strtab
+ sym_name
;
11012 print_vma (fn
, PREFIX_HEX
);
11015 fputs (" <", stdout
);
11016 fputs (procname
, stdout
);
11017 fputc ('>', stdout
);
11021 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
11022 fputc ('\n', stdout
);
11024 /* The GCC personality routines use the standard compact
11025 encoding, starting with one byte giving the number of
11027 if (procname
!= NULL
11028 && (startswith (procname
, "__gcc_personality_v0")
11029 || startswith (procname
, "__gxx_personality_v0")
11030 || startswith (procname
, "__gcj_personality_v0")
11031 || startswith (procname
, "__gnu_objc_personality_v0")))
11038 printf (_(" [Truncated data]\n"));
11041 more_words
= word
>> 24;
11051 /* ARM EHABI Section 6.3:
11053 An exception-handling table entry for the compact model looks like:
11055 31 30-28 27-24 23-0
11056 -- ----- ----- ----
11057 1 0 index Data for personalityRoutine[index] */
11059 if (filedata
->file_header
.e_machine
== EM_ARM
11060 && (word
& 0x70000000))
11062 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
11066 per_index
= (word
>> 24) & 0x7f;
11067 printf (_(" Compact model index: %d\n"), per_index
);
11068 if (per_index
== 0)
11074 else if (per_index
< 3)
11076 more_words
= (word
>> 16) & 0xff;
11082 switch (filedata
->file_header
.e_machine
)
11087 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
11088 data_offset
, data_sec
, data_arm_sec
))
11093 warn (_("Unknown ARM compact model index encountered\n"));
11094 printf (_(" [reserved]\n"));
11102 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
11103 data_offset
, data_sec
, data_arm_sec
))
11106 else if (per_index
< 5)
11108 if (((word
>> 17) & 0x7f) == 0x7f)
11109 printf (_(" Restore stack from frame pointer\n"));
11111 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
11112 printf (_(" Registers restored: "));
11113 if (per_index
== 4)
11114 printf (" (compact) ");
11115 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
11117 printf (_(" Return register: %s\n"),
11118 tic6x_unwind_regnames
[word
& 0xf]);
11121 printf (_(" [reserved (%d)]\n"), per_index
);
11125 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
11126 filedata
->file_header
.e_machine
);
11130 /* Decode the descriptors. Not implemented. */
11136 dump_arm_unwind (Filedata
* filedata
,
11137 struct arm_unw_aux_info
* aux
,
11138 Elf_Internal_Shdr
* exidx_sec
)
11140 struct arm_section exidx_arm_sec
, extab_arm_sec
;
11141 unsigned int i
, exidx_len
;
11145 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
11146 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
11147 exidx_len
= exidx_sec
->sh_size
/ 8;
11149 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
11150 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
11151 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
11152 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
11153 aux
->nfuns
= nfuns
;
11154 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
11156 for (i
= 0; i
< exidx_len
; i
++)
11158 unsigned int exidx_fn
, exidx_entry
;
11159 struct absaddr fn_addr
, entry_addr
;
11162 fputc ('\n', stdout
);
11164 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
11165 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
11166 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
11167 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
11169 free (aux
->funtab
);
11170 arm_free_section (& exidx_arm_sec
);
11171 arm_free_section (& extab_arm_sec
);
11175 /* ARM EHABI, Section 5:
11176 An index table entry consists of 2 words.
11177 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
11178 if (exidx_fn
& 0x80000000)
11180 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
11184 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
11186 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
11187 fputs (": ", stdout
);
11189 if (exidx_entry
== 1)
11191 print_vma (exidx_entry
, PREFIX_HEX
);
11192 fputs (" [cantunwind]\n", stdout
);
11194 else if (exidx_entry
& 0x80000000)
11196 print_vma (exidx_entry
, PREFIX_HEX
);
11197 fputc ('\n', stdout
);
11198 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
11202 uint64_t table
, table_offset
= 0;
11203 Elf_Internal_Shdr
*table_sec
;
11205 fputs ("@", stdout
);
11206 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
11207 print_vma (table
, PREFIX_HEX
);
11210 /* Locate the matching .ARM.extab. */
11211 if (entry_addr
.section
!= SHN_UNDEF
11212 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
11214 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
11215 table_offset
= entry_addr
.offset
;
11217 if (table_offset
> table_sec
->sh_size
)
11219 warn (_("Unwind entry contains corrupt offset (%#" PRIx64
") into section %s\n"),
11221 printable_section_name (filedata
, table_sec
));
11228 table_sec
= find_section_by_address (filedata
, table
);
11229 if (table_sec
!= NULL
)
11230 table_offset
= table
- table_sec
->sh_addr
;
11233 if (table_sec
== NULL
)
11235 warn (_("Could not locate .ARM.extab section containing %#" PRIx64
".\n"),
11241 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
11249 free (aux
->funtab
);
11250 arm_free_section (&exidx_arm_sec
);
11251 arm_free_section (&extab_arm_sec
);
11256 /* Used for both ARM and C6X unwinding tables. */
11259 arm_process_unwind (Filedata
* filedata
)
11261 struct arm_unw_aux_info aux
;
11262 Elf_Internal_Shdr
*unwsec
= NULL
;
11263 Elf_Internal_Shdr
*sec
;
11265 unsigned int sec_type
;
11268 switch (filedata
->file_header
.e_machine
)
11271 sec_type
= SHT_ARM_EXIDX
;
11275 sec_type
= SHT_C6000_UNWIND
;
11279 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
11280 filedata
->file_header
.e_machine
);
11284 if (filedata
->string_table
== NULL
)
11287 memset (& aux
, 0, sizeof (aux
));
11288 aux
.filedata
= filedata
;
11290 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
11292 if (sec
->sh_type
== SHT_SYMTAB
)
11296 error (_("Multiple symbol tables encountered\n"));
11302 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
11303 &aux
.strtab
, &aux
.strtab_size
))
11306 else if (sec
->sh_type
== sec_type
)
11310 if (unwsec
== NULL
)
11311 printf (_("\nThere are no unwind sections in this file.\n"));
11313 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
11315 if (sec
->sh_type
== sec_type
)
11317 uint64_t num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
11318 printf (ngettext ("\nUnwind section '%s' at offset %#" PRIx64
" "
11319 "contains %" PRIu64
" entry:\n",
11320 "\nUnwind section '%s' at offset %#" PRIx64
" "
11321 "contains %" PRIu64
" entries:\n",
11323 printable_section_name (filedata
, sec
),
11327 if (! dump_arm_unwind (filedata
, &aux
, sec
))
11333 free ((char *) aux
.strtab
);
11339 no_processor_specific_unwind (Filedata
* filedata ATTRIBUTE_UNUSED
)
11341 printf (_("No processor specific unwind information to decode\n"));
11346 process_unwind (Filedata
* filedata
)
11348 struct unwind_handler
11350 unsigned int machtype
;
11351 bool (* handler
)(Filedata
*);
11354 { EM_ARM
, arm_process_unwind
},
11355 { EM_IA_64
, ia64_process_unwind
},
11356 { EM_PARISC
, hppa_process_unwind
},
11357 { EM_TI_C6000
, arm_process_unwind
},
11358 { EM_386
, no_processor_specific_unwind
},
11359 { EM_X86_64
, no_processor_specific_unwind
},
11367 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
11368 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
11369 return handlers
[i
].handler (filedata
);
11371 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
11372 get_machine_name (filedata
->file_header
.e_machine
));
11377 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
11379 switch (entry
->d_tag
)
11381 case DT_AARCH64_BTI_PLT
:
11382 case DT_AARCH64_PAC_PLT
:
11385 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
11392 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
11394 switch (entry
->d_tag
)
11396 case DT_MIPS_FLAGS
:
11397 if (entry
->d_un
.d_val
== 0)
11398 printf (_("NONE"));
11401 static const char * opts
[] =
11403 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
11404 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
11405 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
11406 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
11412 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
11413 if (entry
->d_un
.d_val
& (1 << cnt
))
11415 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
11421 case DT_MIPS_IVERSION
:
11422 if (valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
11423 printf (_("Interface Version: %s"),
11424 get_dynamic_name (filedata
, entry
->d_un
.d_val
));
11426 printf (_("Interface Version: <corrupt: %" PRIx64
">"),
11427 entry
->d_un
.d_ptr
);
11430 case DT_MIPS_TIME_STAMP
:
11434 time_t atime
= entry
->d_un
.d_val
;
11436 tmp
= gmtime (&atime
);
11437 /* PR 17531: file: 6accc532. */
11439 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
11441 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
11442 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11443 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11444 printf (_("Time Stamp: %s"), timebuf
);
11448 case DT_MIPS_RLD_VERSION
:
11449 case DT_MIPS_LOCAL_GOTNO
:
11450 case DT_MIPS_CONFLICTNO
:
11451 case DT_MIPS_LIBLISTNO
:
11452 case DT_MIPS_SYMTABNO
:
11453 case DT_MIPS_UNREFEXTNO
:
11454 case DT_MIPS_HIPAGENO
:
11455 case DT_MIPS_DELTA_CLASS_NO
:
11456 case DT_MIPS_DELTA_INSTANCE_NO
:
11457 case DT_MIPS_DELTA_RELOC_NO
:
11458 case DT_MIPS_DELTA_SYM_NO
:
11459 case DT_MIPS_DELTA_CLASSSYM_NO
:
11460 case DT_MIPS_COMPACT_SIZE
:
11461 print_vma (entry
->d_un
.d_val
, DEC
);
11464 case DT_MIPS_XHASH
:
11465 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
11466 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11467 /* Falls through. */
11470 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
11476 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
11478 switch (entry
->d_tag
)
11480 case DT_HP_DLD_FLAGS
:
11489 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
11490 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
11491 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
11492 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
11493 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
11494 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
11495 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
11496 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
11497 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
11498 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
11499 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
11500 { DT_HP_GST
, "HP_GST" },
11501 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
11502 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
11503 { DT_HP_NODELETE
, "HP_NODELETE" },
11504 { DT_HP_GROUP
, "HP_GROUP" },
11505 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
11509 uint64_t val
= entry
->d_un
.d_val
;
11511 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
11512 if (val
& flags
[cnt
].bit
)
11516 fputs (flags
[cnt
].str
, stdout
);
11518 val
^= flags
[cnt
].bit
;
11521 if (val
!= 0 || first
)
11525 print_vma (val
, HEX
);
11531 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
11537 /* VMS vs Unix time offset and factor. */
11539 #define VMS_EPOCH_OFFSET 35067168000000000LL
11540 #define VMS_GRANULARITY_FACTOR 10000000
11542 #define INT64_MIN (-9223372036854775807LL - 1)
11545 /* Display a VMS time in a human readable format. */
11548 print_vms_time (int64_t vmstime
)
11550 struct tm
*tm
= NULL
;
11553 if (vmstime
>= INT64_MIN
+ VMS_EPOCH_OFFSET
)
11555 vmstime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
11557 if (unxtime
== vmstime
)
11558 tm
= gmtime (&unxtime
);
11561 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
11562 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
11563 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
11567 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
11569 switch (entry
->d_tag
)
11571 case DT_IA_64_PLT_RESERVE
:
11572 /* First 3 slots reserved. */
11573 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
11575 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
11578 case DT_IA_64_VMS_LINKTIME
:
11579 print_vms_time (entry
->d_un
.d_val
);
11582 case DT_IA_64_VMS_LNKFLAGS
:
11583 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
11584 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
11585 printf (" CALL_DEBUG");
11586 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
11587 printf (" NOP0BUFS");
11588 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
11589 printf (" P0IMAGE");
11590 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
11591 printf (" MKTHREADS");
11592 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
11593 printf (" UPCALLS");
11594 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
11595 printf (" IMGSTA");
11596 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
11597 printf (" INITIALIZE");
11598 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
11600 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
11601 printf (" EXE_INIT");
11602 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
11603 printf (" TBK_IN_IMG");
11604 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
11605 printf (" DBG_IN_IMG");
11606 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
11607 printf (" TBK_IN_DSF");
11608 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
11609 printf (" DBG_IN_DSF");
11610 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
11611 printf (" SIGNATURES");
11612 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
11613 printf (" REL_SEG_OFF");
11617 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
11624 get_32bit_dynamic_section (Filedata
* filedata
)
11626 Elf32_External_Dyn
* edyn
;
11627 Elf32_External_Dyn
* ext
;
11628 Elf_Internal_Dyn
* entry
;
11630 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
11631 filedata
->dynamic_addr
, 1,
11632 filedata
->dynamic_size
,
11633 _("dynamic section"));
11637 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
11638 might not have the luxury of section headers. Look for the DT_NULL
11639 terminator to determine the number of entries. */
11640 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
11641 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
11644 filedata
->dynamic_nent
++;
11645 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
11649 filedata
->dynamic_section
11650 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
11651 if (filedata
->dynamic_section
== NULL
)
11653 error (_("Out of memory allocating space for %" PRIu64
" dynamic entries\n"),
11654 filedata
->dynamic_nent
);
11659 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
11660 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11663 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
11664 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
11673 get_64bit_dynamic_section (Filedata
* filedata
)
11675 Elf64_External_Dyn
* edyn
;
11676 Elf64_External_Dyn
* ext
;
11677 Elf_Internal_Dyn
* entry
;
11679 /* Read in the data. */
11680 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
11681 filedata
->dynamic_addr
, 1,
11682 filedata
->dynamic_size
,
11683 _("dynamic section"));
11687 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
11688 might not have the luxury of section headers. Look for the DT_NULL
11689 terminator to determine the number of entries. */
11690 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
11691 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
11692 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
11695 filedata
->dynamic_nent
++;
11696 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
11700 filedata
->dynamic_section
11701 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
11702 if (filedata
->dynamic_section
== NULL
)
11704 error (_("Out of memory allocating space for %" PRIu64
" dynamic entries\n"),
11705 filedata
->dynamic_nent
);
11710 /* Convert from external to internal formats. */
11711 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
11712 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11715 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
11716 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
11725 get_dynamic_section (Filedata
*filedata
)
11727 if (filedata
->dynamic_section
)
11731 return get_32bit_dynamic_section (filedata
);
11733 return get_64bit_dynamic_section (filedata
);
11737 print_dynamic_flags (uint64_t flags
)
11745 flag
= flags
& - flags
;
11751 putc (' ', stdout
);
11755 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
11756 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
11757 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
11758 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
11759 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
11760 default: fputs (_("unknown"), stdout
); break;
11767 get_dynamic_data (Filedata
* filedata
, uint64_t number
, unsigned int ent_size
)
11769 unsigned char * e_data
;
11772 /* If size_t is smaller than uint64_t, eg because you are building
11773 on a 32-bit host, then make sure that when number is cast to
11774 size_t no information is lost. */
11775 if ((size_t) number
!= number
11776 || ent_size
* number
/ ent_size
!= number
)
11778 error (_("Size overflow prevents reading %" PRIu64
11779 " elements of size %u\n"),
11784 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
11785 attempting to allocate memory when the read is bound to fail. */
11786 if (ent_size
* number
> filedata
->file_size
)
11788 error (_("Invalid number of dynamic entries: %" PRIu64
"\n"),
11793 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11794 if (e_data
== NULL
)
11796 error (_("Out of memory reading %" PRIu64
" dynamic entries\n"),
11801 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11803 error (_("Unable to read in %" PRIu64
" bytes of dynamic data\n"),
11804 number
* ent_size
);
11809 i_data
= (uint64_t *) cmalloc ((size_t) number
, sizeof (*i_data
));
11810 if (i_data
== NULL
)
11812 error (_("Out of memory allocating space for %" PRIu64
" dynamic entries\n"),
11819 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11827 get_num_dynamic_syms (Filedata
* filedata
)
11829 uint64_t num_of_syms
= 0;
11831 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
11832 return num_of_syms
;
11834 if (filedata
->dynamic_info
[DT_HASH
])
11836 unsigned char nb
[8];
11837 unsigned char nc
[8];
11838 unsigned int hash_ent_size
= 4;
11840 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11841 || filedata
->file_header
.e_machine
== EM_S390
11842 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11843 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11846 if (fseek64 (filedata
->handle
,
11847 (filedata
->archive_file_offset
11848 + offset_from_vma (filedata
,
11849 filedata
->dynamic_info
[DT_HASH
],
11850 sizeof nb
+ sizeof nc
)),
11853 error (_("Unable to seek to start of dynamic information\n"));
11857 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11859 error (_("Failed to read in number of buckets\n"));
11863 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11865 error (_("Failed to read in number of chains\n"));
11869 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
11870 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
11872 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
11874 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
11876 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
11879 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
11880 num_of_syms
= filedata
->nchains
;
11883 if (num_of_syms
== 0)
11885 free (filedata
->buckets
);
11886 filedata
->buckets
= NULL
;
11887 free (filedata
->chains
);
11888 filedata
->chains
= NULL
;
11889 filedata
->nbuckets
= 0;
11893 if (filedata
->dynamic_info_DT_GNU_HASH
)
11895 unsigned char nb
[16];
11896 uint64_t i
, maxchain
= 0xffffffff, bitmaskwords
;
11897 uint64_t buckets_vma
;
11900 if (fseek64 (filedata
->handle
,
11901 (filedata
->archive_file_offset
11902 + offset_from_vma (filedata
,
11903 filedata
->dynamic_info_DT_GNU_HASH
,
11907 error (_("Unable to seek to start of dynamic information\n"));
11911 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11913 error (_("Failed to read in number of buckets\n"));
11917 filedata
->ngnubuckets
= byte_get (nb
, 4);
11918 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
11919 bitmaskwords
= byte_get (nb
+ 8, 4);
11920 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
11922 buckets_vma
+= bitmaskwords
* 4;
11924 buckets_vma
+= bitmaskwords
* 8;
11926 if (fseek64 (filedata
->handle
,
11927 (filedata
->archive_file_offset
11928 + offset_from_vma (filedata
, buckets_vma
, 4)),
11931 error (_("Unable to seek to start of dynamic information\n"));
11935 filedata
->gnubuckets
11936 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
11938 if (filedata
->gnubuckets
== NULL
)
11941 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
11942 if (filedata
->gnubuckets
[i
] != 0)
11944 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
11947 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
11948 maxchain
= filedata
->gnubuckets
[i
];
11951 if (maxchain
== 0xffffffff)
11954 maxchain
-= filedata
->gnusymidx
;
11956 if (fseek64 (filedata
->handle
,
11957 (filedata
->archive_file_offset
11958 + offset_from_vma (filedata
,
11959 buckets_vma
+ 4 * (filedata
->ngnubuckets
11964 error (_("Unable to seek to start of dynamic information\n"));
11970 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11972 error (_("Failed to determine last chain length\n"));
11976 if (maxchain
+ 1 == 0)
11981 while ((byte_get (nb
, 4) & 1) == 0);
11983 if (fseek64 (filedata
->handle
,
11984 (filedata
->archive_file_offset
11985 + offset_from_vma (filedata
, (buckets_vma
11986 + 4 * filedata
->ngnubuckets
),
11990 error (_("Unable to seek to start of dynamic information\n"));
11994 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11995 filedata
->ngnuchains
= maxchain
;
11997 if (filedata
->gnuchains
== NULL
)
12000 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
12002 if (fseek64 (filedata
->handle
,
12003 (filedata
->archive_file_offset
12004 + offset_from_vma (filedata
, (buckets_vma
12005 + 4 * (filedata
->ngnubuckets
12009 error (_("Unable to seek to start of dynamic information\n"));
12013 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
12014 if (filedata
->mipsxlat
== NULL
)
12018 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12019 if (filedata
->gnubuckets
[hn
] != 0)
12021 uint64_t si
= filedata
->gnubuckets
[hn
];
12022 uint64_t off
= si
- filedata
->gnusymidx
;
12026 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
12028 if (off
< filedata
->ngnuchains
12029 && filedata
->mipsxlat
[off
] >= num_of_syms
)
12030 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
12034 if (si
>= num_of_syms
)
12035 num_of_syms
= si
+ 1;
12039 while (off
< filedata
->ngnuchains
12040 && (filedata
->gnuchains
[off
++] & 1) == 0);
12043 if (num_of_syms
== 0)
12046 free (filedata
->mipsxlat
);
12047 filedata
->mipsxlat
= NULL
;
12048 free (filedata
->gnuchains
);
12049 filedata
->gnuchains
= NULL
;
12050 free (filedata
->gnubuckets
);
12051 filedata
->gnubuckets
= NULL
;
12052 filedata
->ngnubuckets
= 0;
12053 filedata
->ngnuchains
= 0;
12057 return num_of_syms
;
12060 /* Parse and display the contents of the dynamic section. */
12063 process_dynamic_section (Filedata
* filedata
)
12065 Elf_Internal_Dyn
* entry
;
12067 if (filedata
->dynamic_size
<= 1)
12071 if (filedata
->is_separate
)
12072 printf (_("\nThere is no dynamic section in linked file '%s'.\n"),
12073 filedata
->file_name
);
12075 printf (_("\nThere is no dynamic section in this file.\n"));
12081 if (!get_dynamic_section (filedata
))
12084 /* Find the appropriate symbol table. */
12085 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
12087 uint64_t num_of_syms
;
12089 for (entry
= filedata
->dynamic_section
;
12090 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
12092 if (entry
->d_tag
== DT_SYMTAB
)
12093 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
12094 else if (entry
->d_tag
== DT_SYMENT
)
12095 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
12096 else if (entry
->d_tag
== DT_HASH
)
12097 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
12098 else if (entry
->d_tag
== DT_GNU_HASH
)
12099 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
12100 else if ((filedata
->file_header
.e_machine
== EM_MIPS
12101 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
12102 && entry
->d_tag
== DT_MIPS_XHASH
)
12104 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
12105 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
12108 num_of_syms
= get_num_dynamic_syms (filedata
);
12110 if (num_of_syms
!= 0
12111 && filedata
->dynamic_symbols
== NULL
12112 && filedata
->dynamic_info
[DT_SYMTAB
]
12113 && filedata
->dynamic_info
[DT_SYMENT
])
12115 Elf_Internal_Phdr
*seg
;
12116 uint64_t vma
= filedata
->dynamic_info
[DT_SYMTAB
];
12118 if (! get_program_headers (filedata
))
12120 error (_("Cannot interpret virtual addresses "
12121 "without program headers.\n"));
12125 for (seg
= filedata
->program_headers
;
12126 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
12129 if (seg
->p_type
!= PT_LOAD
)
12132 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
12134 /* See PR 21379 for a reproducer. */
12135 error (_("Invalid PT_LOAD entry\n"));
12139 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
12140 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
12142 /* Since we do not know how big the symbol table is,
12143 we default to reading in up to the end of PT_LOAD
12144 segment and processing that. This is overkill, I
12145 know, but it should work. */
12146 Elf_Internal_Shdr section
;
12147 section
.sh_offset
= (vma
- seg
->p_vaddr
12149 section
.sh_size
= (num_of_syms
12150 * filedata
->dynamic_info
[DT_SYMENT
]);
12151 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
12154 && filedata
->dynamic_symtab_section
!= NULL
12155 && ((filedata
->dynamic_symtab_section
->sh_offset
12156 != section
.sh_offset
)
12157 || (filedata
->dynamic_symtab_section
->sh_size
12158 != section
.sh_size
)
12159 || (filedata
->dynamic_symtab_section
->sh_entsize
12160 != section
.sh_entsize
)))
12162 the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
12164 section
.sh_name
= filedata
->string_table_length
;
12165 filedata
->dynamic_symbols
12166 = get_elf_symbols (filedata
, §ion
,
12167 &filedata
->num_dynamic_syms
);
12168 if (filedata
->dynamic_symbols
== NULL
12169 || filedata
->num_dynamic_syms
!= num_of_syms
)
12171 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
12180 /* Similarly find a string table. */
12181 if (filedata
->dynamic_strings
== NULL
)
12182 for (entry
= filedata
->dynamic_section
;
12183 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
12186 if (entry
->d_tag
== DT_STRTAB
)
12187 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
12189 if (entry
->d_tag
== DT_STRSZ
)
12190 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
12192 if (filedata
->dynamic_info
[DT_STRTAB
]
12193 && filedata
->dynamic_info
[DT_STRSZ
])
12196 uint64_t str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
12198 offset
= offset_from_vma (filedata
,
12199 filedata
->dynamic_info
[DT_STRTAB
],
12202 && filedata
->dynamic_strtab_section
12203 && ((filedata
->dynamic_strtab_section
->sh_offset
12204 != (file_ptr
) offset
)
12205 || (filedata
->dynamic_strtab_section
->sh_size
12208 the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
12210 filedata
->dynamic_strings
12211 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
12212 _("dynamic string table"));
12213 if (filedata
->dynamic_strings
== NULL
)
12215 error (_("Corrupt DT_STRTAB dynamic entry\n"));
12219 filedata
->dynamic_strings_length
= str_tab_len
;
12224 /* And find the syminfo section if available. */
12225 if (filedata
->dynamic_syminfo
== NULL
)
12227 uint64_t syminsz
= 0;
12229 for (entry
= filedata
->dynamic_section
;
12230 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
12233 if (entry
->d_tag
== DT_SYMINENT
)
12235 /* Note: these braces are necessary to avoid a syntax
12236 error from the SunOS4 C compiler. */
12237 /* PR binutils/17531: A corrupt file can trigger this test.
12238 So do not use an assert, instead generate an error message. */
12239 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
12240 error (_("Bad value (%d) for SYMINENT entry\n"),
12241 (int) entry
->d_un
.d_val
);
12243 else if (entry
->d_tag
== DT_SYMINSZ
)
12244 syminsz
= entry
->d_un
.d_val
;
12245 else if (entry
->d_tag
== DT_SYMINFO
)
12246 filedata
->dynamic_syminfo_offset
12247 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
12250 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
12252 Elf_External_Syminfo
* extsyminfo
;
12253 Elf_External_Syminfo
* extsym
;
12254 Elf_Internal_Syminfo
* syminfo
;
12256 /* There is a syminfo section. Read the data. */
12257 extsyminfo
= (Elf_External_Syminfo
*)
12258 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
12259 1, syminsz
, _("symbol information"));
12263 if (filedata
->dynamic_syminfo
!= NULL
)
12265 error (_("Multiple dynamic symbol information sections found\n"));
12266 free (filedata
->dynamic_syminfo
);
12268 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
12269 if (filedata
->dynamic_syminfo
== NULL
)
12271 error (_("Out of memory allocating %" PRIu64
12272 " bytes for dynamic symbol info\n"),
12277 filedata
->dynamic_syminfo_nent
12278 = syminsz
/ sizeof (Elf_External_Syminfo
);
12279 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
12280 syminfo
< (filedata
->dynamic_syminfo
12281 + filedata
->dynamic_syminfo_nent
);
12282 ++syminfo
, ++extsym
)
12284 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
12285 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
12292 if (do_dynamic
&& filedata
->dynamic_addr
)
12294 if (filedata
->is_separate
)
12295 printf (ngettext ("\nIn linked file '%s' the dynamic section at offset %#" PRIx64
" contains %" PRIu64
" entry:\n",
12296 "\nIn linked file '%s' the dynamic section at offset %#" PRIx64
" contains %" PRIu64
" entries:\n",
12297 filedata
->dynamic_nent
),
12298 filedata
->file_name
,
12299 filedata
->dynamic_addr
,
12300 filedata
->dynamic_nent
);
12302 printf (ngettext ("\nDynamic section at offset %#" PRIx64
" contains %" PRIu64
" entry:\n",
12303 "\nDynamic section at offset %#" PRIx64
" contains %" PRIu64
" entries:\n",
12304 filedata
->dynamic_nent
),
12305 filedata
->dynamic_addr
,
12306 filedata
->dynamic_nent
);
12309 printf (_(" Tag Type Name/Value\n"));
12311 for (entry
= filedata
->dynamic_section
;
12312 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
12317 const char * dtype
;
12320 print_vma (entry
->d_tag
, FULL_HEX
);
12321 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
12322 printf (" (%s)%*s", dtype
,
12323 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
12326 switch (entry
->d_tag
)
12330 print_dynamic_flags (entry
->d_un
.d_val
);
12340 switch (entry
->d_tag
)
12343 printf (_("Auxiliary library"));
12347 printf (_("Filter library"));
12351 printf (_("Configuration file"));
12355 printf (_("Dependency audit library"));
12359 printf (_("Audit library"));
12363 if (valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
12364 printf (": [%s]\n",
12365 get_dynamic_name (filedata
, entry
->d_un
.d_val
));
12369 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12378 printf (_("Flags:"));
12380 if (entry
->d_un
.d_val
== 0)
12381 printf (_(" None\n"));
12384 uint64_t val
= entry
->d_un
.d_val
;
12386 if (val
& DTF_1_PARINIT
)
12388 printf (" PARINIT");
12389 val
^= DTF_1_PARINIT
;
12391 if (val
& DTF_1_CONFEXP
)
12393 printf (" CONFEXP");
12394 val
^= DTF_1_CONFEXP
;
12397 printf (" %" PRIx64
, val
);
12406 printf (_("Flags:"));
12408 if (entry
->d_un
.d_val
== 0)
12409 printf (_(" None\n"));
12412 uint64_t val
= entry
->d_un
.d_val
;
12414 if (val
& DF_P1_LAZYLOAD
)
12416 printf (" LAZYLOAD");
12417 val
^= DF_P1_LAZYLOAD
;
12419 if (val
& DF_P1_GROUPPERM
)
12421 printf (" GROUPPERM");
12422 val
^= DF_P1_GROUPPERM
;
12425 printf (" %" PRIx64
, val
);
12434 printf (_("Flags:"));
12435 if (entry
->d_un
.d_val
== 0)
12436 printf (_(" None\n"));
12439 uint64_t val
= entry
->d_un
.d_val
;
12441 if (val
& DF_1_NOW
)
12446 if (val
& DF_1_GLOBAL
)
12448 printf (" GLOBAL");
12449 val
^= DF_1_GLOBAL
;
12451 if (val
& DF_1_GROUP
)
12456 if (val
& DF_1_NODELETE
)
12458 printf (" NODELETE");
12459 val
^= DF_1_NODELETE
;
12461 if (val
& DF_1_LOADFLTR
)
12463 printf (" LOADFLTR");
12464 val
^= DF_1_LOADFLTR
;
12466 if (val
& DF_1_INITFIRST
)
12468 printf (" INITFIRST");
12469 val
^= DF_1_INITFIRST
;
12471 if (val
& DF_1_NOOPEN
)
12473 printf (" NOOPEN");
12474 val
^= DF_1_NOOPEN
;
12476 if (val
& DF_1_ORIGIN
)
12478 printf (" ORIGIN");
12479 val
^= DF_1_ORIGIN
;
12481 if (val
& DF_1_DIRECT
)
12483 printf (" DIRECT");
12484 val
^= DF_1_DIRECT
;
12486 if (val
& DF_1_TRANS
)
12491 if (val
& DF_1_INTERPOSE
)
12493 printf (" INTERPOSE");
12494 val
^= DF_1_INTERPOSE
;
12496 if (val
& DF_1_NODEFLIB
)
12498 printf (" NODEFLIB");
12499 val
^= DF_1_NODEFLIB
;
12501 if (val
& DF_1_NODUMP
)
12503 printf (" NODUMP");
12504 val
^= DF_1_NODUMP
;
12506 if (val
& DF_1_CONFALT
)
12508 printf (" CONFALT");
12509 val
^= DF_1_CONFALT
;
12511 if (val
& DF_1_ENDFILTEE
)
12513 printf (" ENDFILTEE");
12514 val
^= DF_1_ENDFILTEE
;
12516 if (val
& DF_1_DISPRELDNE
)
12518 printf (" DISPRELDNE");
12519 val
^= DF_1_DISPRELDNE
;
12521 if (val
& DF_1_DISPRELPND
)
12523 printf (" DISPRELPND");
12524 val
^= DF_1_DISPRELPND
;
12526 if (val
& DF_1_NODIRECT
)
12528 printf (" NODIRECT");
12529 val
^= DF_1_NODIRECT
;
12531 if (val
& DF_1_IGNMULDEF
)
12533 printf (" IGNMULDEF");
12534 val
^= DF_1_IGNMULDEF
;
12536 if (val
& DF_1_NOKSYMS
)
12538 printf (" NOKSYMS");
12539 val
^= DF_1_NOKSYMS
;
12541 if (val
& DF_1_NOHDR
)
12546 if (val
& DF_1_EDITED
)
12548 printf (" EDITED");
12549 val
^= DF_1_EDITED
;
12551 if (val
& DF_1_NORELOC
)
12553 printf (" NORELOC");
12554 val
^= DF_1_NORELOC
;
12556 if (val
& DF_1_SYMINTPOSE
)
12558 printf (" SYMINTPOSE");
12559 val
^= DF_1_SYMINTPOSE
;
12561 if (val
& DF_1_GLOBAUDIT
)
12563 printf (" GLOBAUDIT");
12564 val
^= DF_1_GLOBAUDIT
;
12566 if (val
& DF_1_SINGLETON
)
12568 printf (" SINGLETON");
12569 val
^= DF_1_SINGLETON
;
12571 if (val
& DF_1_STUB
)
12576 if (val
& DF_1_PIE
)
12581 if (val
& DF_1_KMOD
)
12586 if (val
& DF_1_WEAKFILTER
)
12588 printf (" WEAKFILTER");
12589 val
^= DF_1_WEAKFILTER
;
12591 if (val
& DF_1_NOCOMMON
)
12593 printf (" NOCOMMON");
12594 val
^= DF_1_NOCOMMON
;
12597 printf (" %" PRIx64
, val
);
12604 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
12606 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
12627 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
12633 if (valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
12634 name
= get_dynamic_name (filedata
, entry
->d_un
.d_val
);
12640 switch (entry
->d_tag
)
12643 printf (_("Shared library: [%s]"), name
);
12645 if (filedata
->program_interpreter
12646 && streq (name
, filedata
->program_interpreter
))
12647 printf (_(" program interpreter"));
12651 printf (_("Library soname: [%s]"), name
);
12655 printf (_("Library rpath: [%s]"), name
);
12659 printf (_("Library runpath: [%s]"), name
);
12663 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12668 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12683 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
12684 /* Fall through. */
12688 case DT_PREINIT_ARRAYSZ
:
12689 case DT_INIT_ARRAYSZ
:
12690 case DT_FINI_ARRAYSZ
:
12691 case DT_GNU_CONFLICTSZ
:
12692 case DT_GNU_LIBLISTSZ
:
12695 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
12696 printf (_(" (bytes)\n"));
12701 case DT_VERNEEDNUM
:
12706 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
12715 case DT_INIT_ARRAY
:
12716 case DT_FINI_ARRAY
:
12719 if (entry
->d_tag
== DT_USED
12720 && valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
12723 = get_dynamic_name (filedata
, entry
->d_un
.d_val
);
12727 printf (_("Not needed object: [%s]\n"), name
);
12732 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12738 /* The value of this entry is ignored. */
12743 case DT_GNU_PRELINKED
:
12747 time_t atime
= entry
->d_un
.d_val
;
12749 tmp
= gmtime (&atime
);
12750 /* PR 17533 file: 041-1244816-0.004. */
12752 printf (_("<corrupt time val: %" PRIx64
),
12755 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
12756 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
12757 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
12763 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
12766 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12771 case DT_GNU_FLAGS_1
:
12774 printf (_("Flags:"));
12775 if (entry
->d_un
.d_val
== 0)
12776 printf (_(" None\n"));
12779 uint64_t val
= entry
->d_un
.d_val
;
12781 if (val
& DF_GNU_1_UNIQUE
)
12783 printf (" UNIQUE");
12784 val
^= DF_GNU_1_UNIQUE
;
12787 printf (" %" PRIx64
, val
);
12794 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
12795 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
12796 = entry
->d_un
.d_val
;
12800 switch (filedata
->file_header
.e_machine
)
12803 dynamic_section_aarch64_val (entry
);
12806 case EM_MIPS_RS3_LE
:
12807 dynamic_section_mips_val (filedata
, entry
);
12810 dynamic_section_parisc_val (entry
);
12813 dynamic_section_ia64_val (entry
);
12816 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12828 get_ver_flags (unsigned int flags
)
12830 static char buff
[128];
12837 if (flags
& VER_FLG_BASE
)
12838 strcat (buff
, "BASE");
12840 if (flags
& VER_FLG_WEAK
)
12842 if (flags
& VER_FLG_BASE
)
12843 strcat (buff
, " | ");
12845 strcat (buff
, "WEAK");
12848 if (flags
& VER_FLG_INFO
)
12850 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
12851 strcat (buff
, " | ");
12853 strcat (buff
, "INFO");
12856 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
12858 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
12859 strcat (buff
, " | ");
12861 strcat (buff
, _("<unknown>"));
12867 /* Display the contents of the version sections. */
12870 process_version_sections (Filedata
* filedata
)
12872 Elf_Internal_Shdr
* section
;
12874 bool found
= false;
12879 for (i
= 0, section
= filedata
->section_headers
;
12880 i
< filedata
->file_header
.e_shnum
;
12883 switch (section
->sh_type
)
12885 case SHT_GNU_verdef
:
12887 Elf_External_Verdef
* edefs
;
12894 if (filedata
->is_separate
)
12895 printf (ngettext ("\nIn linked file '%s' the version definition section '%s' contains %u entry:\n",
12896 "\nIn linked file '%s' the version definition section '%s' contains %u entries:\n",
12898 filedata
->file_name
,
12899 printable_section_name (filedata
, section
),
12902 printf (ngettext ("\nVersion definition section '%s' "
12903 "contains %u entry:\n",
12904 "\nVersion definition section '%s' "
12905 "contains %u entries:\n",
12907 printable_section_name (filedata
, section
),
12910 printf (_(" Addr: 0x%016" PRIx64
), section
->sh_addr
);
12911 printf (_(" Offset: 0x%08" PRIx64
" Link: %u (%s)\n"),
12912 section
->sh_offset
, section
->sh_link
,
12913 printable_section_name_from_index (filedata
, section
->sh_link
, NULL
));
12915 edefs
= (Elf_External_Verdef
*)
12916 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
12917 _("version definition section"));
12920 endbuf
= (char *) edefs
+ section
->sh_size
;
12922 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
12925 Elf_External_Verdef
* edef
;
12926 Elf_Internal_Verdef ent
;
12927 Elf_External_Verdaux
* eaux
;
12928 Elf_Internal_Verdaux aux
;
12932 vstart
= ((char *) edefs
) + idx
;
12933 if (vstart
+ sizeof (*edef
) > endbuf
)
12936 edef
= (Elf_External_Verdef
*) vstart
;
12938 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
12939 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
12940 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
12941 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
12942 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
12943 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
12944 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
12946 printf (_(" %#06zx: Rev: %d Flags: %s"),
12947 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
12949 printf (_(" Index: %d Cnt: %d "),
12950 ent
.vd_ndx
, ent
.vd_cnt
);
12952 /* Check for overflow. */
12953 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
12956 vstart
+= ent
.vd_aux
;
12958 if (vstart
+ sizeof (*eaux
) > endbuf
)
12960 eaux
= (Elf_External_Verdaux
*) vstart
;
12962 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
12963 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
12965 if (valid_dynamic_name (filedata
, aux
.vda_name
))
12966 printf (_("Name: %s\n"),
12967 get_dynamic_name (filedata
, aux
.vda_name
));
12969 printf (_("Name index: %ld\n"), aux
.vda_name
);
12971 isum
= idx
+ ent
.vd_aux
;
12973 for (j
= 1; j
< ent
.vd_cnt
; j
++)
12975 if (aux
.vda_next
< sizeof (*eaux
)
12976 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
12978 warn (_("Invalid vda_next field of %lx\n"),
12983 /* Check for overflow. */
12984 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
12987 isum
+= aux
.vda_next
;
12988 vstart
+= aux
.vda_next
;
12990 if (vstart
+ sizeof (*eaux
) > endbuf
)
12992 eaux
= (Elf_External_Verdaux
*) vstart
;
12994 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
12995 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
12997 if (valid_dynamic_name (filedata
, aux
.vda_name
))
12998 printf (_(" %#06zx: Parent %d: %s\n"),
13000 get_dynamic_name (filedata
, aux
.vda_name
));
13002 printf (_(" %#06zx: Parent %d, name index: %ld\n"),
13003 isum
, j
, aux
.vda_name
);
13006 if (j
< ent
.vd_cnt
)
13007 printf (_(" Version def aux past end of section\n"));
13010 file: id:000001,src:000172+005151,op:splice,rep:2. */
13011 if (ent
.vd_next
< sizeof (*edef
)
13012 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
13014 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
13015 cnt
= section
->sh_info
;
13018 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
13021 idx
+= ent
.vd_next
;
13024 if (cnt
< section
->sh_info
)
13025 printf (_(" Version definition past end of section\n"));
13031 case SHT_GNU_verneed
:
13033 Elf_External_Verneed
* eneed
;
13040 if (filedata
->is_separate
)
13041 printf (ngettext ("\nIn linked file '%s' the version needs section '%s' contains %u entry:\n",
13042 "\nIn linked file '%s' the version needs section '%s' contains %u entries:\n",
13044 filedata
->file_name
,
13045 printable_section_name (filedata
, section
),
13048 printf (ngettext ("\nVersion needs section '%s' "
13049 "contains %u entry:\n",
13050 "\nVersion needs section '%s' "
13051 "contains %u entries:\n",
13053 printable_section_name (filedata
, section
),
13056 printf (_(" Addr: 0x%016" PRIx64
), section
->sh_addr
);
13057 printf (_(" Offset: 0x%08" PRIx64
" Link: %u (%s)\n"),
13058 section
->sh_offset
, section
->sh_link
,
13059 printable_section_name_from_index (filedata
, section
->sh_link
, NULL
));
13061 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
13062 section
->sh_offset
, 1,
13064 _("Version Needs section"));
13067 endbuf
= (char *) eneed
+ section
->sh_size
;
13069 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
13071 Elf_External_Verneed
* entry
;
13072 Elf_Internal_Verneed ent
;
13077 vstart
= ((char *) eneed
) + idx
;
13078 if (vstart
+ sizeof (*entry
) > endbuf
)
13081 entry
= (Elf_External_Verneed
*) vstart
;
13083 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
13084 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
13085 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
13086 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
13087 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
13089 printf (_(" %#06zx: Version: %d"), idx
, ent
.vn_version
);
13091 if (valid_dynamic_name (filedata
, ent
.vn_file
))
13092 printf (_(" File: %s"),
13093 get_dynamic_name (filedata
, ent
.vn_file
));
13095 printf (_(" File: %lx"), ent
.vn_file
);
13097 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
13099 /* Check for overflow. */
13100 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
13102 vstart
+= ent
.vn_aux
;
13104 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
13106 Elf_External_Vernaux
* eaux
;
13107 Elf_Internal_Vernaux aux
;
13109 if (vstart
+ sizeof (*eaux
) > endbuf
)
13111 eaux
= (Elf_External_Vernaux
*) vstart
;
13113 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
13114 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
13115 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
13116 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
13117 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
13119 if (valid_dynamic_name (filedata
, aux
.vna_name
))
13120 printf (_(" %#06zx: Name: %s"),
13121 isum
, get_dynamic_name (filedata
, aux
.vna_name
));
13123 printf (_(" %#06zx: Name index: %lx"),
13124 isum
, aux
.vna_name
);
13126 printf (_(" Flags: %s Version: %d\n"),
13127 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
13129 if (aux
.vna_next
< sizeof (*eaux
)
13130 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
13132 warn (_("Invalid vna_next field of %lx\n"),
13137 /* Check for overflow. */
13138 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
13140 isum
+= aux
.vna_next
;
13141 vstart
+= aux
.vna_next
;
13144 if (j
< ent
.vn_cnt
)
13145 warn (_("Missing Version Needs auxiliary information\n"));
13147 if (ent
.vn_next
< sizeof (*entry
)
13148 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
13150 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
13151 cnt
= section
->sh_info
;
13154 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
13156 idx
+= ent
.vn_next
;
13159 if (cnt
< section
->sh_info
)
13160 warn (_("Missing Version Needs information\n"));
13166 case SHT_GNU_versym
:
13168 Elf_Internal_Shdr
* link_section
;
13171 unsigned char * edata
;
13172 unsigned short * data
;
13174 Elf_Internal_Sym
* symbols
;
13175 Elf_Internal_Shdr
* string_sec
;
13179 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
13182 link_section
= filedata
->section_headers
+ section
->sh_link
;
13183 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
13185 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
13190 symbols
= get_elf_symbols (filedata
, link_section
, & num_syms
);
13191 if (symbols
== NULL
)
13194 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
13196 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
13197 string_sec
->sh_size
,
13198 _("version string table"));
13205 if (filedata
->is_separate
)
13206 printf (ngettext ("\nIn linked file '%s' the version symbols section '%s' contains %" PRIu64
" entry:\n",
13207 "\nIn linked file '%s' the version symbols section '%s' contains %" PRIu64
" entries:\n",
13209 filedata
->file_name
,
13210 printable_section_name (filedata
, section
),
13213 printf (ngettext ("\nVersion symbols section '%s' "
13214 "contains %" PRIu64
" entry:\n",
13215 "\nVersion symbols section '%s' "
13216 "contains %" PRIu64
" entries:\n",
13218 printable_section_name (filedata
, section
),
13221 printf (_(" Addr: 0x%016" PRIx64
), section
->sh_addr
);
13222 printf (_(" Offset: 0x%08" PRIx64
" Link: %u (%s)\n"),
13223 section
->sh_offset
, section
->sh_link
,
13224 printable_section_name (filedata
, link_section
));
13226 off
= offset_from_vma (filedata
,
13227 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
13228 total
* sizeof (short));
13229 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
13230 sizeof (short), total
,
13231 _("version symbol data"));
13239 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
13241 for (cnt
= total
; cnt
--;)
13242 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
13247 for (cnt
= 0; cnt
< total
; cnt
+= 4)
13251 char *invalid
= _("*invalid*");
13253 printf (" %03x:", cnt
);
13255 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
13256 switch (data
[cnt
+ j
])
13259 fputs (_(" 0 (*local*) "), stdout
);
13263 fputs (_(" 1 (*global*) "), stdout
);
13267 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
13268 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
13270 /* If this index value is greater than the size of the symbols
13271 array, break to avoid an out-of-bounds read. */
13272 if (cnt
+ j
>= num_syms
)
13274 warn (_("invalid index into symbol array\n"));
13279 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
13281 Elf_Internal_Verneed ivn
;
13284 offset
= offset_from_vma
13286 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
13287 sizeof (Elf_External_Verneed
));
13291 Elf_Internal_Vernaux ivna
;
13292 Elf_External_Verneed evn
;
13293 Elf_External_Vernaux evna
;
13296 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
13297 _("version need")) == NULL
)
13300 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
13301 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
13303 a_off
= offset
+ ivn
.vn_aux
;
13307 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
13308 1, _("version need aux (2)")) == NULL
)
13311 ivna
.vna_other
= 0;
13315 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
13316 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
13319 a_off
+= ivna
.vna_next
;
13321 while (ivna
.vna_other
!= data
[cnt
+ j
]
13322 && ivna
.vna_next
!= 0);
13324 if (ivna
.vna_other
== data
[cnt
+ j
])
13326 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
13328 if (ivna
.vna_name
>= string_sec
->sh_size
)
13331 name
= strtab
+ ivna
.vna_name
;
13335 offset
+= ivn
.vn_next
;
13337 while (ivn
.vn_next
);
13340 if (data
[cnt
+ j
] != 0x8001
13341 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
13343 Elf_Internal_Verdef ivd
;
13344 Elf_External_Verdef evd
;
13347 offset
= offset_from_vma
13349 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
13354 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
13355 _("version def")) == NULL
)
13358 /* PR 17531: file: 046-1082287-0.004. */
13359 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
13364 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
13365 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
13368 offset
+= ivd
.vd_next
;
13370 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
13371 && ivd
.vd_next
!= 0);
13373 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
13375 Elf_External_Verdaux evda
;
13376 Elf_Internal_Verdaux ivda
;
13378 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
13380 if (get_data (&evda
, filedata
,
13381 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
13383 _("version def aux")) == NULL
)
13386 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
13388 if (ivda
.vda_name
>= string_sec
->sh_size
)
13390 else if (name
!= NULL
&& name
!= invalid
)
13391 name
= _("*both*");
13393 name
= strtab
+ ivda
.vda_name
;
13397 nn
+= printf ("(%s%-*s",
13399 12 - (int) strlen (name
),
13403 printf ("%*c", 18 - nn
, ' ');
13422 if (filedata
->is_separate
)
13423 printf (_("\nNo version information found in linked file '%s'.\n"),
13424 filedata
->file_name
);
13426 printf (_("\nNo version information found in this file.\n"));
13432 static const char *
13433 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
13435 static char buff
[64];
13439 case STB_LOCAL
: return "LOCAL";
13440 case STB_GLOBAL
: return "GLOBAL";
13441 case STB_WEAK
: return "WEAK";
13443 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
13444 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
13446 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
13448 if (binding
== STB_GNU_UNIQUE
13449 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
13451 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
13454 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
13459 static const char *
13460 get_symbol_type (Filedata
* filedata
, unsigned int type
)
13462 static char buff
[64];
13466 case STT_NOTYPE
: return "NOTYPE";
13467 case STT_OBJECT
: return "OBJECT";
13468 case STT_FUNC
: return "FUNC";
13469 case STT_SECTION
: return "SECTION";
13470 case STT_FILE
: return "FILE";
13471 case STT_COMMON
: return "COMMON";
13472 case STT_TLS
: return "TLS";
13473 case STT_RELC
: return "RELC";
13474 case STT_SRELC
: return "SRELC";
13476 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
13478 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
13479 return "THUMB_FUNC";
13481 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
13484 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
13485 return "PARISC_MILLI";
13487 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
13489 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
13491 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13493 if (type
== STT_HP_OPAQUE
)
13494 return "HP_OPAQUE";
13495 if (type
== STT_HP_STUB
)
13499 if (type
== STT_GNU_IFUNC
13500 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
13501 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
13504 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
13507 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
13512 static const char *
13513 get_symbol_visibility (unsigned int visibility
)
13515 switch (visibility
)
13517 case STV_DEFAULT
: return "DEFAULT";
13518 case STV_INTERNAL
: return "INTERNAL";
13519 case STV_HIDDEN
: return "HIDDEN";
13520 case STV_PROTECTED
: return "PROTECTED";
13522 error (_("Unrecognized visibility value: %u\n"), visibility
);
13523 return _("<unknown>");
13527 static const char *
13528 get_alpha_symbol_other (unsigned int other
)
13532 case STO_ALPHA_NOPV
: return "NOPV";
13533 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
13535 error (_("Unrecognized alpha specific other value: %u\n"), other
);
13536 return _("<unknown>");
13540 static const char *
13541 get_solaris_symbol_visibility (unsigned int visibility
)
13543 switch (visibility
)
13545 case 4: return "EXPORTED";
13546 case 5: return "SINGLETON";
13547 case 6: return "ELIMINATE";
13548 default: return get_symbol_visibility (visibility
);
13552 static const char *
13553 get_aarch64_symbol_other (unsigned int other
)
13555 static char buf
[32];
13557 if (other
& STO_AARCH64_VARIANT_PCS
)
13559 other
&= ~STO_AARCH64_VARIANT_PCS
;
13561 return "VARIANT_PCS";
13562 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
13568 static const char *
13569 get_mips_symbol_other (unsigned int other
)
13573 case STO_OPTIONAL
: return "OPTIONAL";
13574 case STO_MIPS_PLT
: return "MIPS PLT";
13575 case STO_MIPS_PIC
: return "MIPS PIC";
13576 case STO_MICROMIPS
: return "MICROMIPS";
13577 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
13578 case STO_MIPS16
: return "MIPS16";
13579 default: return NULL
;
13583 static const char *
13584 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
13586 if (is_ia64_vms (filedata
))
13588 static char res
[32];
13592 /* Function types is for images and .STB files only. */
13593 switch (filedata
->file_header
.e_type
)
13597 switch (VMS_ST_FUNC_TYPE (other
))
13599 case VMS_SFT_CODE_ADDR
:
13600 strcat (res
, " CA");
13602 case VMS_SFT_SYMV_IDX
:
13603 strcat (res
, " VEC");
13606 strcat (res
, " FD");
13608 case VMS_SFT_RESERVE
:
13609 strcat (res
, " RSV");
13612 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
13613 VMS_ST_FUNC_TYPE (other
));
13614 strcat (res
, " <unknown>");
13621 switch (VMS_ST_LINKAGE (other
))
13623 case VMS_STL_IGNORE
:
13624 strcat (res
, " IGN");
13626 case VMS_STL_RESERVE
:
13627 strcat (res
, " RSV");
13630 strcat (res
, " STD");
13633 strcat (res
, " LNK");
13636 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
13637 VMS_ST_LINKAGE (other
));
13638 strcat (res
, " <unknown>");
13650 static const char *
13651 get_ppc64_symbol_other (unsigned int other
)
13653 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
13656 other
>>= STO_PPC64_LOCAL_BIT
;
13659 static char buf
[64];
13661 other
= ppc64_decode_local_entry (other
);
13662 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
13668 static const char *
13669 get_riscv_symbol_other (unsigned int other
)
13671 static char buf
[32];
13674 if (other
& STO_RISCV_VARIANT_CC
)
13676 strcat (buf
, _(" VARIANT_CC"));
13677 other
&= ~STO_RISCV_VARIANT_CC
;
13681 snprintf (buf
, sizeof buf
, " %x", other
);
13690 static const char *
13691 get_symbol_other (Filedata
* filedata
, unsigned int other
)
13693 const char * result
= NULL
;
13694 static char buff
[64];
13699 switch (filedata
->file_header
.e_machine
)
13702 result
= get_alpha_symbol_other (other
);
13705 result
= get_aarch64_symbol_other (other
);
13708 result
= get_mips_symbol_other (other
);
13711 result
= get_ia64_symbol_other (filedata
, other
);
13714 result
= get_ppc64_symbol_other (other
);
13717 result
= get_riscv_symbol_other (other
);
13727 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
13731 static const char *
13732 get_symbol_version_string (Filedata
*filedata
,
13734 const char *strtab
,
13735 size_t strtab_size
,
13737 Elf_Internal_Sym
*psym
,
13738 enum versioned_symbol_info
*sym_info
,
13739 unsigned short *vna_other
)
13741 unsigned char data
[2];
13742 unsigned short vers_data
;
13744 unsigned short max_vd_ndx
;
13747 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
13750 offset
= offset_from_vma (filedata
,
13751 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
13752 sizeof data
+ si
* sizeof (vers_data
));
13754 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
13755 sizeof (data
), 1, _("version data")) == NULL
)
13758 vers_data
= byte_get (data
, 2);
13760 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
13763 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
13766 /* Usually we'd only see verdef for defined symbols, and verneed for
13767 undefined symbols. However, symbols defined by the linker in
13768 .dynbss for variables copied from a shared library in order to
13769 avoid text relocations are defined yet have verneed. We could
13770 use a heuristic to detect the special case, for example, check
13771 for verneed first on symbols defined in SHT_NOBITS sections, but
13772 it is simpler and more reliable to just look for both verdef and
13773 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
13775 if (psym
->st_shndx
!= SHN_UNDEF
13776 && vers_data
!= 0x8001
13777 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
13779 Elf_Internal_Verdef ivd
;
13780 Elf_Internal_Verdaux ivda
;
13781 Elf_External_Verdaux evda
;
13784 off
= offset_from_vma (filedata
,
13785 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
13786 sizeof (Elf_External_Verdef
));
13790 Elf_External_Verdef evd
;
13792 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
13793 _("version def")) == NULL
)
13802 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
13803 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
13804 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
13805 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
13808 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
13809 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
13811 off
+= ivd
.vd_next
;
13813 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
13815 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
13817 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
13820 off
-= ivd
.vd_next
;
13823 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
13824 _("version def aux")) != NULL
)
13826 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
13828 if (psym
->st_name
!= ivda
.vda_name
)
13829 return (ivda
.vda_name
< strtab_size
13830 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
13835 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
13837 Elf_External_Verneed evn
;
13838 Elf_Internal_Verneed ivn
;
13839 Elf_Internal_Vernaux ivna
;
13841 offset
= offset_from_vma (filedata
,
13842 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
13848 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
13849 _("version need")) == NULL
)
13852 ivna
.vna_other
= 0;
13857 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
13858 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
13860 vna_off
= offset
+ ivn
.vn_aux
;
13864 Elf_External_Vernaux evna
;
13866 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
13867 _("version need aux (3)")) == NULL
)
13870 ivna
.vna_other
= 0;
13875 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
13876 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
13877 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
13880 vna_off
+= ivna
.vna_next
;
13882 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
13884 if (ivna
.vna_other
== vers_data
)
13887 offset
+= ivn
.vn_next
;
13889 while (ivn
.vn_next
!= 0);
13891 if (ivna
.vna_other
== vers_data
)
13893 *sym_info
= symbol_undefined
;
13894 *vna_other
= ivna
.vna_other
;
13895 return (ivna
.vna_name
< strtab_size
13896 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
13898 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
13899 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
13900 return _("<corrupt>");
13905 /* Display a symbol size on stdout. Format is based on --sym-base setting. */
13907 static unsigned int
13908 print_symbol_size (uint64_t vma
, int base
)
13913 return print_vma (vma
, OCTAL_5
);
13916 return print_vma (vma
, UNSIGNED_5
);
13919 return print_vma (vma
, PREFIX_HEX_5
);
13923 return print_vma (vma
, DEC_5
);
13927 /* Print information on a single symbol. */
13930 print_symbol (Filedata
* filedata
,
13931 uint64_t symbol_index
,
13932 Elf_Internal_Sym
* symtab
,
13933 Elf_Internal_Shdr
* section
,
13935 size_t strtab_size
)
13937 const char *version_string
;
13938 enum versioned_symbol_info sym_info
;
13939 unsigned short vna_other
;
13941 Elf_Internal_Sym
*psym
= symtab
+ symbol_index
;
13943 /* FIXME: We should have a table of field widths,
13944 rather than using hard coded constants. */
13945 printf ("%6" PRId64
": ", symbol_index
);
13946 print_vma (psym
->st_value
, LONG_HEX
);
13948 print_symbol_size (psym
->st_size
, sym_base
);
13949 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
13950 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
13951 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
13952 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
13955 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
13957 printf (" %-7s", get_symbol_visibility (vis
));
13959 /* Check to see if any other bits in the st_other field are set.
13960 FIXME: Displaying this information here disrupts the layout
13961 of the table being generated. */
13962 if (psym
->st_other
^ vis
)
13963 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
13968 sstr
= printable_section_name_from_index (filedata
, psym
->st_shndx
, & is_special
);
13970 /* Print the symbol's section index. If the index is special
13971 then print the index's name rather than its number. */
13976 /* Special case: If there are no section headers, and the printable
13977 name is "<section 0x...." then just display the section number
13978 as a decimal. This happens when objcopy --strip -section-headers
13980 if (filedata
->file_header
.e_shnum
== 0 && startswith (sstr
, "<section"))
13981 printed
= printf (" %4d ", psym
->st_shndx
);
13983 printed
= printf (" %4s ", sstr
);
13985 if (extra_sym_info
&& printed
< 16)
13986 printf ("%*s", 16 - printed
, "");
13990 printf (" %4u ", psym
->st_shndx
);
13992 if (extra_sym_info
)
13994 /* Display the section name referenced by the section index. */
13995 int printed
= printf ("(%s) ", sstr
);
13997 printf ("%*s", 10 - printed
, "");
14001 /* Get the symbol's name. For section symbols without a
14002 specific name use the (already computed) section name. */
14003 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
14004 && section_index_real (filedata
, psym
->st_shndx
)
14005 && psym
->st_name
== 0)
14013 is_valid
= valid_symbol_name (strtab
, strtab_size
, psym
->st_name
);
14014 sstr
= is_valid
? strtab
+ psym
->st_name
: _("<corrupt>");
14018 = get_symbol_version_string (filedata
,
14020 || section
->sh_type
== SHT_DYNSYM
),
14021 strtab
, strtab_size
, symbol_index
,
14022 psym
, &sym_info
, &vna_other
);
14024 int len_avail
= 21;
14025 if (! do_wide
&& version_string
!= NULL
)
14029 len_avail
-= 1 + strlen (version_string
);
14031 if (sym_info
== symbol_undefined
)
14032 len_avail
-= sprintf (buffer
," (%d)", vna_other
);
14033 else if (sym_info
!= symbol_hidden
)
14037 print_symbol_name (len_avail
, sstr
);
14039 if (version_string
)
14041 if (sym_info
== symbol_undefined
)
14042 printf ("@%s (%d)", version_string
, vna_other
);
14044 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
14050 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
14052 && symbol_index
>= section
->sh_info
14053 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
14054 && filedata
->file_header
.e_machine
!= EM_MIPS
14055 /* Solaris binaries have been found to violate this requirement as
14056 well. Not sure if this is a bug or an ABI requirement. */
14057 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
14058 warn (_("local symbol %" PRIu64
" found at index >= %s's sh_info value of %u\n"),
14059 symbol_index
, printable_section_name (filedata
, section
), section
->sh_info
);
14062 static const char *
14063 get_lto_kind (unsigned int kind
)
14067 case 0: return "DEF";
14068 case 1: return "WEAKDEF";
14069 case 2: return "UNDEF";
14070 case 3: return "WEAKUNDEF";
14071 case 4: return "COMMON";
14076 static char buffer
[30];
14077 error (_("Unknown LTO symbol definition encountered: %u\n"), kind
);
14078 sprintf (buffer
, "<unknown: %u>", kind
);
14082 static const char *
14083 get_lto_visibility (unsigned int visibility
)
14085 switch (visibility
)
14087 case 0: return "DEFAULT";
14088 case 1: return "PROTECTED";
14089 case 2: return "INTERNAL";
14090 case 3: return "HIDDEN";
14095 static char buffer
[30];
14096 error (_("Unknown LTO symbol visibility encountered: %u\n"), visibility
);
14097 sprintf (buffer
, "<unknown: %u>", visibility
);
14101 static const char *
14102 get_lto_sym_type (unsigned int sym_type
)
14106 case 0: return "UNKNOWN";
14107 case 1: return "FUNCTION";
14108 case 2: return "VARIABLE";
14113 static char buffer
[30];
14114 error (_("Unknown LTO symbol type encountered: %u\n"), sym_type
);
14115 sprintf (buffer
, "<unknown: %u>", sym_type
);
14119 /* Display an LTO format symbol table.
14120 FIXME: The format of LTO symbol tables is not formalized.
14121 So this code could need changing in the future. */
14124 display_lto_symtab (Filedata
* filedata
,
14125 Elf_Internal_Shdr
* section
)
14127 if (section
->sh_size
== 0)
14129 if (filedata
->is_separate
)
14130 printf (_("\nThe LTO Symbol table section '%s' in linked file '%s' is empty!\n"),
14131 printable_section_name (filedata
, section
),
14132 filedata
->file_name
);
14134 printf (_("\nLTO Symbol table '%s' is empty!\n"),
14135 printable_section_name (filedata
, section
));
14140 if (section
->sh_size
> filedata
->file_size
)
14142 error (_("Section %s has an invalid sh_size of %#" PRIx64
"\n"),
14143 printable_section_name (filedata
, section
),
14148 void * alloced_data
= get_data (NULL
, filedata
, section
->sh_offset
,
14149 section
->sh_size
, 1, _("LTO symbols"));
14150 if (alloced_data
== NULL
)
14153 /* Look for extended data for the symbol table. */
14154 Elf_Internal_Shdr
* ext
= NULL
;
14155 void * ext_data_orig
= NULL
;
14156 char * ext_data
= NULL
;
14157 char * ext_data_end
= NULL
;
14158 char * ext_name
= NULL
;
14160 if (asprintf (& ext_name
, ".gnu.lto_.ext_symtab.%s",
14161 (section_name (filedata
, section
)
14162 + sizeof (".gnu.lto_.symtab.") - 1)) > 0
14163 && ext_name
!= NULL
/* Paranoia. */
14164 && (ext
= find_section (filedata
, ext_name
)) != NULL
)
14166 if (ext
->sh_size
< 3)
14167 error (_("LTO Symbol extension table '%s' is empty!\n"),
14168 printable_section_name (filedata
, ext
));
14171 ext_data_orig
= ext_data
= get_data (NULL
, filedata
, ext
->sh_offset
,
14173 _("LTO ext symbol data"));
14174 if (ext_data
!= NULL
)
14176 ext_data_end
= ext_data
+ ext
->sh_size
;
14177 if (* ext_data
++ != 1)
14178 error (_("Unexpected version number in symbol extension table\n"));
14183 const unsigned char * data
= (const unsigned char *) alloced_data
;
14184 const unsigned char * end
= data
+ section
->sh_size
;
14186 if (filedata
->is_separate
)
14187 printf (_("\nIn linked file '%s': "), filedata
->file_name
);
14191 if (ext_data_orig
!= NULL
)
14194 printf (_("LTO Symbol table '%s' and extension table '%s' contain:\n"),
14195 printable_section_name (filedata
, section
),
14196 printable_section_name (filedata
, ext
));
14199 printf (_("LTO Symbol table '%s'\n"),
14200 printable_section_name (filedata
, section
));
14201 printf (_(" and extension table '%s' contain:\n"),
14202 printable_section_name (filedata
, ext
));
14206 printf (_("LTO Symbol table '%s' contains:\n"),
14207 printable_section_name (filedata
, section
));
14209 /* FIXME: Add a wide version. */
14210 if (ext_data_orig
!= NULL
)
14211 printf (_(" Comdat_Key Kind Visibility Size Slot Type Section Name\n"));
14213 printf (_(" Comdat_Key Kind Visibility Size Slot Name\n"));
14215 /* FIXME: We do not handle style prefixes. */
14219 const unsigned char * sym_name
= data
;
14220 data
+= strnlen ((const char *) sym_name
, end
- data
) + 1;
14224 const unsigned char * comdat_key
= data
;
14225 data
+= strnlen ((const char *) comdat_key
, end
- data
) + 1;
14229 if (data
+ 2 + 8 + 4 > end
)
14232 unsigned int kind
= *data
++;
14233 unsigned int visibility
= *data
++;
14235 uint64_t size
= byte_get (data
, 8);
14238 uint64_t slot
= byte_get (data
, 4);
14241 if (ext_data
!= NULL
)
14243 if (ext_data
< (ext_data_end
- 1))
14245 unsigned int sym_type
= * ext_data
++;
14246 unsigned int sec_kind
= * ext_data
++;
14248 printf (" %10s %10s %11s %08" PRIx64
" %08" PRIx64
" %9s %08x _",
14249 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
14250 get_lto_kind (kind
),
14251 get_lto_visibility (visibility
),
14254 get_lto_sym_type (sym_type
),
14256 print_symbol_name (6, (const char *) sym_name
);
14260 error (_("Ran out of LTO symbol extension data\n"));
14262 /* FIXME: return FAIL result ? */
14267 printf (" %10s %10s %11s %08" PRIx64
" %08" PRIx64
" _",
14268 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
14269 get_lto_kind (kind
),
14270 get_lto_visibility (visibility
),
14273 print_symbol_name (21, (const char *) sym_name
);
14278 if (ext_data
!= NULL
&& ext_data
< ext_data_end
)
14280 error (_("Data remains in the LTO symbol extension table\n"));
14284 free (alloced_data
);
14285 free (ext_data_orig
);
14290 error (_("Buffer overrun encountered whilst decoding LTO symbol table\n"));
14291 free (alloced_data
);
14292 free (ext_data_orig
);
14297 /* Display LTO symbol tables. */
14300 process_lto_symbol_tables (Filedata
* filedata
)
14302 Elf_Internal_Shdr
* section
;
14309 if (filedata
->section_headers
== NULL
)
14312 for (i
= 0, section
= filedata
->section_headers
;
14313 i
< filedata
->file_header
.e_shnum
;
14315 if (section_name_valid (filedata
, section
)
14316 && startswith (section_name (filedata
, section
), ".gnu.lto_.symtab."))
14317 res
&= display_lto_symtab (filedata
, section
);
14323 print_symbol_table_heading (void)
14325 /* FIXME: We should store the size of each field in the display in a table and
14326 then use the values inside print_symbol(), instead of that function using
14327 hard coded constants. */
14330 if (extra_sym_info
)
14332 printf (_(" Num: Value Size Type Bind Vis+Other Ndx(SecName) Name [+ Version Info]\n"));
14333 /* |--6-|: |--8---| |-5-| |--7--| |-6--| |--7--| |---8--| |----13.....| |........... */
14334 /* eg: 5: 00000000 14 FUNC LOCAL DEFAULT 1 (.text) get_sections */
14338 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
14339 /* |--6-|: |--8---| |-5-| |--7--| |-6--| |--7--| |-4| |........... */
14340 /* eg: 5: 00000000 14 FUNC LOCAL DEFAULT 1 get_sections */
14344 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
14345 /* |--6-|: |--8---| |-5-| |--7--| |-6--| |--7--| |-4| |------------29-------------| */
14346 /* eg: 5: 00000000 14 FUNC LOCAL DEFAULT 1 get_sections */
14351 if (extra_sym_info
)
14353 printf (_(" Num: Value Size Type Bind Vis+Other Ndx(SecName) Name [+ Version Info]\n"));
14354 /* |--6-|: |------16------| |-5-| |--7--| |-6--| |--7--| |-------14---| |..... */
14355 /* eg: 2: 0000000000000000 0 FUNC LOCAL DEFAULT 1 (.text) .very_long_function_name */
14360 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
14361 /* |--6-|: |------16------| |-5-| |--7--| |-6--| |--7--| |-4| |........... */
14362 /* eg: 5: 0000000000000000 14 FUNC LOCAL DEFAULT 1 very_long_function_name */
14366 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
14367 /* |--6-|: |------16------| |-5-| |--7--| |-6--| |--7--| |-4| |--------21---------| */
14368 /* eg: 5: 0000000000000000 14 FUNC LOCAL DEFAULT 1 very_long_functi[...] */
14374 dump_symbol_section (Elf_Internal_Shdr
* section
,
14375 Filedata
* filedata
)
14377 if (section
->sh_entsize
== 0)
14379 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
14380 printable_section_name (filedata
, section
));
14384 uint64_t num_syms
= section
->sh_size
/ section
->sh_entsize
;
14386 if (filedata
->is_separate
)
14387 printf (ngettext ("\nIn linked file '%s' symbol section '%s'"
14388 " contains %" PRIu64
" entry:\n",
14389 "\nIn linked file '%s' symbol section '%s'"
14390 " contains %" PRIu64
" entries:\n",
14392 filedata
->file_name
,
14393 printable_section_name (filedata
, section
),
14396 printf (ngettext ("\nSymbol table '%s' contains %" PRIu64
14398 "\nSymbol table '%s' contains %" PRIu64
14401 printable_section_name (filedata
, section
),
14404 print_symbol_table_heading ();
14406 Elf_Internal_Sym
* symtab
= get_elf_symbols (filedata
, section
, & num_syms
);
14407 if (symtab
== NULL
)
14408 /* An error message will have already been displayed. */
14411 char * strtab
= NULL
;
14412 uint64_t strtab_size
= 0;
14414 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
14416 strtab
= filedata
->string_table
;
14417 strtab_size
= filedata
->string_table_length
;
14419 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
14421 Elf_Internal_Shdr
* string_sec
;
14423 string_sec
= filedata
->section_headers
+ section
->sh_link
;
14425 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
14426 1, string_sec
->sh_size
,
14427 _("string table"));
14428 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
14433 for (si
= 0; si
< num_syms
; si
++)
14434 print_symbol (filedata
, si
, symtab
, section
, strtab
, strtab_size
);
14438 if (strtab
!= filedata
->string_table
)
14444 /* Dump the symbol table. */
14447 process_symbol_table (Filedata
* filedata
)
14449 Elf_Internal_Shdr
* section
;
14451 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
14454 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
14456 && do_using_dynamic
14457 && filedata
->dynamic_strings
!= NULL
14458 && filedata
->dynamic_symbols
!= NULL
)
14462 if (filedata
->is_separate
)
14464 printf (ngettext ("\nIn linked file '%s' the dynamic symbol table"
14465 " contains %" PRIu64
" entry:\n",
14466 "\nIn linked file '%s' the dynamic symbol table"
14467 " contains %" PRIu64
" entries:\n",
14468 filedata
->num_dynamic_syms
),
14469 filedata
->file_name
,
14470 filedata
->num_dynamic_syms
);
14474 printf (ngettext ("\nSymbol table for image contains %" PRIu64
14476 "\nSymbol table for image contains %" PRIu64
14478 filedata
->num_dynamic_syms
),
14479 filedata
->num_dynamic_syms
);
14482 print_symbol_table_heading ();
14484 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
14485 print_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
14486 filedata
->dynamic_strings
,
14487 filedata
->dynamic_strings_length
);
14489 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
14490 && filedata
->section_headers
!= NULL
)
14494 for (i
= 0, section
= filedata
->section_headers
;
14495 i
< filedata
->file_header
.e_shnum
;
14498 if ((section
->sh_type
!= SHT_SYMTAB
14499 && section
->sh_type
!= SHT_DYNSYM
)
14501 && section
->sh_type
== SHT_SYMTAB
))
14504 dump_symbol_section (section
, filedata
);
14509 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
14511 if (do_histogram
&& filedata
->buckets
!= NULL
)
14517 uint64_t maxlength
= 0;
14518 uint64_t nzero_counts
= 0;
14519 uint64_t nsyms
= 0;
14522 printf (ngettext ("\nHistogram for bucket list length "
14523 "(total of %" PRIu64
" bucket):\n",
14524 "\nHistogram for bucket list length "
14525 "(total of %" PRIu64
" buckets):\n",
14526 filedata
->nbuckets
),
14527 filedata
->nbuckets
);
14529 lengths
= calloc (filedata
->nbuckets
, sizeof (*lengths
));
14530 if (lengths
== NULL
)
14532 error (_("Out of memory allocating space for histogram buckets\n"));
14535 visited
= xcmalloc (filedata
->nchains
, 1);
14536 memset (visited
, 0, filedata
->nchains
);
14538 printf (_(" Length Number %% of total Coverage\n"));
14539 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
14541 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
14544 if (maxlength
< ++lengths
[hn
])
14546 if (si
>= filedata
->nchains
|| visited
[si
])
14548 error (_("histogram chain is corrupt\n"));
14556 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
14557 if (counts
== NULL
)
14560 error (_("Out of memory allocating space for histogram counts\n"));
14564 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
14565 ++counts
[lengths
[hn
]];
14567 if (filedata
->nbuckets
> 0)
14570 printf (" 0 %-10" PRIu64
" (%5.1f%%)\n",
14571 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
14572 for (i
= 1; i
<= maxlength
; ++i
)
14574 nzero_counts
+= counts
[i
] * i
;
14575 printf ("%7" PRIu64
" %-10" PRIu64
" (%5.1f%%) %5.1f%%\n",
14576 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
14577 (nzero_counts
* 100.0) / nsyms
);
14585 free (filedata
->buckets
);
14586 filedata
->buckets
= NULL
;
14587 filedata
->nbuckets
= 0;
14588 free (filedata
->chains
);
14589 filedata
->chains
= NULL
;
14591 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
14596 uint64_t maxlength
= 0;
14597 uint64_t nzero_counts
= 0;
14598 uint64_t nsyms
= 0;
14600 printf (ngettext ("\nHistogram for `%s' bucket list length "
14601 "(total of %" PRIu64
" bucket):\n",
14602 "\nHistogram for `%s' bucket list length "
14603 "(total of %" PRIu64
" buckets):\n",
14604 filedata
->ngnubuckets
),
14605 GNU_HASH_SECTION_NAME (filedata
),
14606 filedata
->ngnubuckets
);
14608 lengths
= calloc (filedata
->ngnubuckets
, sizeof (*lengths
));
14609 if (lengths
== NULL
)
14611 error (_("Out of memory allocating space for gnu histogram buckets\n"));
14615 printf (_(" Length Number %% of total Coverage\n"));
14617 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
14618 if (filedata
->gnubuckets
[hn
] != 0)
14620 uint64_t off
, length
= 1;
14622 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
14623 /* PR 17531 file: 010-77222-0.004. */
14624 off
< filedata
->ngnuchains
14625 && (filedata
->gnuchains
[off
] & 1) == 0;
14628 lengths
[hn
] = length
;
14629 if (length
> maxlength
)
14630 maxlength
= length
;
14634 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
14635 if (counts
== NULL
)
14638 error (_("Out of memory allocating space for gnu histogram counts\n"));
14642 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
14643 ++counts
[lengths
[hn
]];
14645 if (filedata
->ngnubuckets
> 0)
14648 printf (" 0 %-10" PRIu64
" (%5.1f%%)\n",
14649 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
14650 for (j
= 1; j
<= maxlength
; ++j
)
14652 nzero_counts
+= counts
[j
] * j
;
14653 printf ("%7" PRIu64
" %-10" PRIu64
" (%5.1f%%) %5.1f%%\n",
14654 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
14655 (nzero_counts
* 100.0) / nsyms
);
14662 free (filedata
->gnubuckets
);
14663 filedata
->gnubuckets
= NULL
;
14664 filedata
->ngnubuckets
= 0;
14665 free (filedata
->gnuchains
);
14666 filedata
->gnuchains
= NULL
;
14667 filedata
->ngnuchains
= 0;
14668 free (filedata
->mipsxlat
);
14669 filedata
->mipsxlat
= NULL
;
14673 free (filedata
->gnubuckets
);
14674 filedata
->gnubuckets
= NULL
;
14675 filedata
->ngnubuckets
= 0;
14676 free (filedata
->gnuchains
);
14677 filedata
->gnuchains
= NULL
;
14678 filedata
->ngnuchains
= 0;
14679 free (filedata
->mipsxlat
);
14680 filedata
->mipsxlat
= NULL
;
14681 free (filedata
->buckets
);
14682 filedata
->buckets
= NULL
;
14683 filedata
->nbuckets
= 0;
14684 free (filedata
->chains
);
14685 filedata
->chains
= NULL
;
14690 process_syminfo (Filedata
* filedata
)
14694 if (filedata
->dynamic_syminfo
== NULL
14696 /* No syminfo, this is ok. */
14699 /* There better should be a dynamic symbol section. */
14700 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
14703 if (filedata
->is_separate
)
14704 printf (ngettext ("\nIn linked file '%s: the dynamic info segment at offset %#" PRIx64
" contains %d entry:\n",
14705 "\nIn linked file '%s: the dynamic info segment at offset %#" PRIx64
" contains %d entries:\n",
14706 filedata
->dynamic_syminfo_nent
),
14707 filedata
->file_name
,
14708 filedata
->dynamic_syminfo_offset
,
14709 filedata
->dynamic_syminfo_nent
);
14711 printf (ngettext ("\nDynamic info segment at offset %#" PRIx64
14712 " contains %d entry:\n",
14713 "\nDynamic info segment at offset %#" PRIx64
14714 " contains %d entries:\n",
14715 filedata
->dynamic_syminfo_nent
),
14716 filedata
->dynamic_syminfo_offset
,
14717 filedata
->dynamic_syminfo_nent
);
14719 printf (_(" Num: Name BoundTo Flags\n"));
14720 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
14722 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
14724 printf ("%4d: ", i
);
14725 if (i
>= filedata
->num_dynamic_syms
)
14726 printf (_("<corrupt index>"));
14727 else if (valid_dynamic_name (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
14728 print_symbol_name (30, get_dynamic_name (filedata
,
14729 filedata
->dynamic_symbols
[i
].st_name
));
14731 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
14734 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
14736 case SYMINFO_BT_SELF
:
14737 fputs ("SELF ", stdout
);
14739 case SYMINFO_BT_PARENT
:
14740 fputs ("PARENT ", stdout
);
14743 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
14744 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
14745 && valid_dynamic_name (filedata
,
14746 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
14748 print_symbol_name (10, get_dynamic_name (filedata
,
14749 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
14753 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
14757 if (flags
& SYMINFO_FLG_DIRECT
)
14758 printf (" DIRECT");
14759 if (flags
& SYMINFO_FLG_PASSTHRU
)
14760 printf (" PASSTHRU");
14761 if (flags
& SYMINFO_FLG_COPY
)
14763 if (flags
& SYMINFO_FLG_LAZYLOAD
)
14764 printf (" LAZYLOAD");
14772 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
14773 is contained by the region START .. END. The types of ADDR, START
14774 and END should all be the same. Note both ADDR + NELEM and END
14775 point to just beyond the end of the regions that are being tested. */
14776 #define IN_RANGE(START,END,ADDR,NELEM) \
14777 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
14779 /* Check to see if the given reloc needs to be handled in a target specific
14780 manner. If so then process the reloc and return TRUE otherwise return
14783 If called with reloc == NULL, then this is a signal that reloc processing
14784 for the current section has finished, and any saved state should be
14788 target_specific_reloc_handling (Filedata
*filedata
,
14789 Elf_Internal_Rela
*reloc
,
14790 unsigned char *start
,
14791 unsigned char *end
,
14792 Elf_Internal_Sym
*symtab
,
14795 unsigned int reloc_type
= 0;
14796 uint64_t sym_index
= 0;
14800 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
14801 sym_index
= get_reloc_symindex (reloc
->r_info
);
14804 switch (filedata
->file_header
.e_machine
)
14808 switch (reloc_type
)
14810 /* For .uleb128 .LFE1-.LFB1, loongarch write 0 to object file
14811 at assembly time. */
14812 case 107: /* R_LARCH_ADD_ULEB128. */
14813 case 108: /* R_LARCH_SUB_ULEB128. */
14815 uint64_t value
= 0;
14816 unsigned int reloc_size
= 0;
14819 if (reloc
->r_offset
< (size_t) (end
- start
))
14820 value
= read_leb128 (start
+ reloc
->r_offset
, end
, false,
14821 &reloc_size
, &leb_ret
);
14822 if (leb_ret
!= 0 || reloc_size
== 0 || reloc_size
> 8)
14823 error (_("LoongArch ULEB128 field at 0x%lx contains invalid "
14824 "ULEB128 value\n"),
14825 (long) reloc
->r_offset
);
14827 else if (sym_index
>= num_syms
)
14828 error (_("%s reloc contains invalid symbol index "
14831 ? "R_LARCH_ADD_ULEB128"
14832 : "R_LARCH_SUB_ULEB128"),
14836 if (reloc_type
== 107)
14837 value
+= reloc
->r_addend
+ symtab
[sym_index
].st_value
;
14839 value
-= reloc
->r_addend
+ symtab
[sym_index
].st_value
;
14841 /* Write uleb128 value to p. */
14842 bfd_byte
*p
= start
+ reloc
->r_offset
;
14845 bfd_byte c
= value
& 0x7f;
14847 if (--reloc_size
!= 0)
14851 while (reloc_size
);
14861 case EM_MSP430_OLD
:
14863 static Elf_Internal_Sym
* saved_sym
= NULL
;
14871 switch (reloc_type
)
14873 case 10: /* R_MSP430_SYM_DIFF */
14874 case 12: /* R_MSP430_GNU_SUB_ULEB128 */
14875 if (uses_msp430x_relocs (filedata
))
14877 /* Fall through. */
14878 case 21: /* R_MSP430X_SYM_DIFF */
14879 case 23: /* R_MSP430X_GNU_SUB_ULEB128 */
14881 if (sym_index
>= num_syms
)
14882 error (_("%s reloc contains invalid symbol index "
14883 "%" PRIu64
"\n"), "MSP430 SYM_DIFF", sym_index
);
14885 saved_sym
= symtab
+ sym_index
;
14888 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
14889 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
14890 goto handle_sym_diff
;
14892 case 5: /* R_MSP430_16_BYTE */
14893 case 9: /* R_MSP430_8 */
14894 case 11: /* R_MSP430_GNU_SET_ULEB128 */
14895 if (uses_msp430x_relocs (filedata
))
14897 goto handle_sym_diff
;
14899 case 2: /* R_MSP430_ABS16 */
14900 case 15: /* R_MSP430X_ABS16 */
14901 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
14902 if (! uses_msp430x_relocs (filedata
))
14904 goto handle_sym_diff
;
14907 if (saved_sym
!= NULL
)
14910 unsigned int reloc_size
= 0;
14912 switch (reloc_type
)
14914 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
14917 case 11: /* R_MSP430_GNU_SET_ULEB128 */
14918 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
14919 if (reloc
->r_offset
< (size_t) (end
- start
))
14920 read_leb128 (start
+ reloc
->r_offset
, end
, false,
14921 &reloc_size
, &leb_ret
);
14928 if (leb_ret
!= 0 || reloc_size
== 0 || reloc_size
> 8)
14929 error (_("MSP430 ULEB128 field at %#" PRIx64
14930 " contains invalid ULEB128 value\n"),
14932 else if (sym_index
>= num_syms
)
14933 error (_("%s reloc contains invalid symbol index "
14934 "%" PRIu64
"\n"), "MSP430", sym_index
);
14937 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
14938 - saved_sym
->st_value
);
14940 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
14941 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
14944 error (_("MSP430 sym diff reloc contains invalid offset: "
14955 if (saved_sym
!= NULL
)
14956 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
14963 case EM_CYGNUS_MN10300
:
14965 static Elf_Internal_Sym
* saved_sym
= NULL
;
14973 switch (reloc_type
)
14975 case 34: /* R_MN10300_ALIGN */
14977 case 33: /* R_MN10300_SYM_DIFF */
14978 if (sym_index
>= num_syms
)
14979 error (_("%s reloc contains invalid symbol index "
14980 "%" PRIu64
"\n"), "MN10300_SYM_DIFF", sym_index
);
14982 saved_sym
= symtab
+ sym_index
;
14985 case 1: /* R_MN10300_32 */
14986 case 2: /* R_MN10300_16 */
14987 if (saved_sym
!= NULL
)
14989 int reloc_size
= reloc_type
== 1 ? 4 : 2;
14992 if (sym_index
>= num_syms
)
14993 error (_("%s reloc contains invalid symbol index "
14994 "%" PRIu64
"\n"), "MN10300", sym_index
);
14997 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
14998 - saved_sym
->st_value
);
15000 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
15001 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
15003 error (_("MN10300 sym diff reloc contains invalid offset:"
15004 " %#" PRIx64
"\n"),
15013 if (saved_sym
!= NULL
)
15014 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
15022 static uint64_t saved_sym1
= 0;
15023 static uint64_t saved_sym2
= 0;
15024 static uint64_t value
;
15028 saved_sym1
= saved_sym2
= 0;
15032 switch (reloc_type
)
15034 case 0x80: /* R_RL78_SYM. */
15035 saved_sym1
= saved_sym2
;
15036 if (sym_index
>= num_syms
)
15037 error (_("%s reloc contains invalid symbol index "
15038 "%" PRIu64
"\n"), "RL78_SYM", sym_index
);
15041 saved_sym2
= symtab
[sym_index
].st_value
;
15042 saved_sym2
+= reloc
->r_addend
;
15046 case 0x83: /* R_RL78_OPsub. */
15047 value
= saved_sym1
- saved_sym2
;
15048 saved_sym2
= saved_sym1
= 0;
15052 case 0x41: /* R_RL78_ABS32. */
15053 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
15054 byte_put (start
+ reloc
->r_offset
, value
, 4);
15056 error (_("RL78 sym diff reloc contains invalid offset: "
15062 case 0x43: /* R_RL78_ABS16. */
15063 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
15064 byte_put (start
+ reloc
->r_offset
, value
, 2);
15066 error (_("RL78 sym diff reloc contains invalid offset: "
15082 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
15083 DWARF debug sections. This is a target specific test. Note - we do not
15084 go through the whole including-target-headers-multiple-times route, (as
15085 we have already done with <elf/h8.h>) because this would become very
15086 messy and even then this function would have to contain target specific
15087 information (the names of the relocs instead of their numeric values).
15088 FIXME: This is not the correct way to solve this problem. The proper way
15089 is to have target specific reloc sizing and typing functions created by
15090 the reloc-macros.h header, in the same way that it already creates the
15091 reloc naming functions. */
15094 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15096 /* Please keep this table alpha-sorted for ease of visual lookup. */
15097 switch (filedata
->file_header
.e_machine
)
15101 return reloc_type
== 1; /* R_386_32. */
15103 return reloc_type
== 1; /* R_68K_32. */
15105 return reloc_type
== 1; /* R_860_32. */
15107 return reloc_type
== 2; /* R_960_32. */
15109 return (reloc_type
== 258
15110 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
15112 return reloc_type
== 11; /* R_BPF_DATA_32 */
15113 case EM_ADAPTEVA_EPIPHANY
:
15114 return reloc_type
== 3;
15116 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
15118 return reloc_type
== 1; /* R_ARC_32. */
15119 case EM_ARC_COMPACT
:
15120 case EM_ARC_COMPACT2
:
15121 case EM_ARC_COMPACT3
:
15122 case EM_ARC_COMPACT3_64
:
15123 return reloc_type
== 4; /* R_ARC_32. */
15125 return reloc_type
== 2; /* R_ARM_ABS32 */
15128 return reloc_type
== 1;
15130 return reloc_type
== 0x12; /* R_byte4_data. */
15132 return reloc_type
== 3; /* R_CRIS_32. */
15134 return reloc_type
== 3; /* R_CR16_NUM32. */
15136 return reloc_type
== 15; /* R_CRX_NUM32. */
15138 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
15139 case EM_CYGNUS_FRV
:
15140 return reloc_type
== 1;
15141 case EM_CYGNUS_D10V
:
15143 return reloc_type
== 6; /* R_D10V_32. */
15144 case EM_CYGNUS_D30V
:
15146 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
15148 return reloc_type
== 3; /* R_DLX_RELOC_32. */
15149 case EM_CYGNUS_FR30
:
15151 return reloc_type
== 3; /* R_FR30_32. */
15153 return reloc_type
== 1; /* R_FT32_32. */
15157 return reloc_type
== 1; /* R_H8_DIR32. */
15159 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
15160 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
15161 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
15162 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
15165 return reloc_type
== 2; /* R_IP2K_32. */
15167 return reloc_type
== 2; /* R_IQ2000_32. */
15169 return reloc_type
== 2; /* R_KVX_32. */
15170 case EM_LATTICEMICO32
:
15171 return reloc_type
== 3; /* R_LM32_32. */
15173 return reloc_type
== 1; /* R_LARCH_32. */
15176 return reloc_type
== 3; /* R_M32C_32. */
15178 return reloc_type
== 34; /* R_M32R_32_RELA. */
15181 return reloc_type
== 6; /* R_M68HC11_32. */
15183 return reloc_type
== 7 || /* R_S12Z_EXT32 */
15184 reloc_type
== 6; /* R_S12Z_CW32. */
15186 return reloc_type
== 1; /* R_MCORE_ADDR32. */
15187 case EM_CYGNUS_MEP
:
15188 return reloc_type
== 4; /* R_MEP_32. */
15190 return reloc_type
== 2; /* R_METAG_ADDR32. */
15191 case EM_MICROBLAZE
:
15192 return reloc_type
== 1; /* R_MICROBLAZE_32. */
15194 return reloc_type
== 2; /* R_MIPS_32. */
15196 return reloc_type
== 4; /* R_MMIX_32. */
15197 case EM_CYGNUS_MN10200
:
15199 return reloc_type
== 1; /* R_MN10200_32. */
15200 case EM_CYGNUS_MN10300
:
15202 return reloc_type
== 1; /* R_MN10300_32. */
15204 return reloc_type
== 1; /* R_MOXIE_32. */
15205 case EM_MSP430_OLD
:
15207 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
15209 return reloc_type
== 2; /* R_MT_32. */
15211 return reloc_type
== 20; /* R_NDS32_32_RELA. */
15212 case EM_ALTERA_NIOS2
:
15213 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
15215 return reloc_type
== 1; /* R_NIOS_32. */
15217 return reloc_type
== 1; /* R_OR1K_32. */
15219 return (reloc_type
== 1 /* R_PARISC_DIR32. */
15220 || reloc_type
== 2 /* R_PARISC_DIR21L. */
15221 || reloc_type
== 41); /* R_PARISC_SECREL32. */
15224 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
15226 return reloc_type
== 1; /* R_PPC64_ADDR32. */
15228 return reloc_type
== 1; /* R_PPC_ADDR32. */
15230 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
15232 return reloc_type
== 1; /* R_RISCV_32. */
15234 return reloc_type
== 1; /* R_RL78_DIR32. */
15236 return reloc_type
== 1; /* R_RX_DIR32. */
15238 return reloc_type
== 1; /* R_I370_ADDR31. */
15241 return reloc_type
== 4; /* R_S390_32. */
15243 return reloc_type
== 8; /* R_SCORE_ABS32. */
15245 return reloc_type
== 1; /* R_SH_DIR32. */
15246 case EM_SPARC32PLUS
:
15249 return reloc_type
== 3 /* R_SPARC_32. */
15250 || reloc_type
== 23; /* R_SPARC_UA32. */
15252 return reloc_type
== 6; /* R_SPU_ADDR32 */
15254 return reloc_type
== 1; /* R_C6000_ABS32. */
15256 return reloc_type
== 2; /* R_TILEGX_32. */
15258 return reloc_type
== 1; /* R_TILEPRO_32. */
15259 case EM_CYGNUS_V850
:
15261 return reloc_type
== 6; /* R_V850_ABS32. */
15263 return reloc_type
== 0x33; /* R_V810_WORD. */
15265 return reloc_type
== 1; /* R_VAX_32. */
15267 return reloc_type
== 3; /* R_VISIUM_32. */
15268 case EM_WEBASSEMBLY
:
15269 return reloc_type
== 1; /* R_WASM32_32. */
15273 return reloc_type
== 10; /* R_X86_64_32. */
15275 return reloc_type
== 4; /* R_XGATE_32. */
15277 return reloc_type
== 1; /* R_XSTROMY16_32. */
15278 case EM_XTENSA_OLD
:
15280 return reloc_type
== 1; /* R_XTENSA_32. */
15282 return reloc_type
== 6; /* R_Z80_32. */
15285 static unsigned int prev_warn
= 0;
15287 /* Avoid repeating the same warning multiple times. */
15288 if (prev_warn
!= filedata
->file_header
.e_machine
)
15289 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
15290 filedata
->file_header
.e_machine
);
15291 prev_warn
= filedata
->file_header
.e_machine
;
15297 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15298 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
15301 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15303 switch (filedata
->file_header
.e_machine
)
15304 /* Please keep this table alpha-sorted for ease of visual lookup. */
15308 return reloc_type
== 2; /* R_386_PC32. */
15310 return reloc_type
== 4; /* R_68K_PC32. */
15312 return reloc_type
== 261; /* R_AARCH64_PREL32 */
15313 case EM_ADAPTEVA_EPIPHANY
:
15314 return reloc_type
== 6;
15316 return reloc_type
== 10; /* R_ALPHA_SREL32. */
15317 case EM_ARC_COMPACT
:
15318 case EM_ARC_COMPACT2
:
15319 case EM_ARC_COMPACT3
:
15320 case EM_ARC_COMPACT3_64
:
15321 return reloc_type
== 49; /* R_ARC_32_PCREL. */
15323 return reloc_type
== 3; /* R_ARM_REL32 */
15326 return reloc_type
== 36; /* R_AVR_32_PCREL. */
15328 return reloc_type
== 99; /* R_LARCH_32_PCREL. */
15329 case EM_MICROBLAZE
:
15330 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
15332 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
15334 return reloc_type
== 9; /* R_PARISC_PCREL32. */
15336 return reloc_type
== 26; /* R_PPC_REL32. */
15338 return reloc_type
== 26; /* R_PPC64_REL32. */
15340 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
15343 return reloc_type
== 5; /* R_390_PC32. */
15345 return reloc_type
== 2; /* R_SH_REL32. */
15346 case EM_SPARC32PLUS
:
15349 return reloc_type
== 6; /* R_SPARC_DISP32. */
15351 return reloc_type
== 13; /* R_SPU_REL32. */
15353 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
15355 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
15357 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
15361 return reloc_type
== 2; /* R_X86_64_PC32. */
15363 return reloc_type
== 4; /* R_VAX_PCREL32. */
15364 case EM_XTENSA_OLD
:
15366 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
15368 return reloc_type
== 7; /* R_KVX_32_PCREL */
15370 /* Do not abort or issue an error message here. Not all targets use
15371 pc-relative 32-bit relocs in their DWARF debug information and we
15372 have already tested for target coverage in is_32bit_abs_reloc. A
15373 more helpful warning message will be generated by apply_relocations
15374 anyway, so just return. */
15379 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15380 a 64-bit absolute RELA relocation used in DWARF debug sections. */
15383 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15385 switch (filedata
->file_header
.e_machine
)
15388 return reloc_type
== 257; /* R_AARCH64_ABS64. */
15389 case EM_ARC_COMPACT3_64
:
15390 return reloc_type
== 5; /* R_ARC_64. */
15392 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
15394 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
15395 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
15397 return reloc_type
== 2; /* R_LARCH_64 */
15399 return reloc_type
== 80; /* R_PARISC_DIR64. */
15401 return reloc_type
== 38; /* R_PPC64_ADDR64. */
15403 return reloc_type
== 2; /* R_RISCV_64. */
15404 case EM_SPARC32PLUS
:
15407 return reloc_type
== 32 /* R_SPARC_64. */
15408 || reloc_type
== 54; /* R_SPARC_UA64. */
15412 return reloc_type
== 1; /* R_X86_64_64. */
15415 return reloc_type
== 22; /* R_S390_64. */
15417 return reloc_type
== 1; /* R_TILEGX_64. */
15419 return reloc_type
== 18; /* R_MIPS_64. */
15421 return reloc_type
== 3; /* R_KVX_64 */
15427 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
15428 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
15431 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15433 switch (filedata
->file_header
.e_machine
)
15436 return reloc_type
== 260; /* R_AARCH64_PREL64. */
15438 return reloc_type
== 11; /* R_ALPHA_SREL64. */
15440 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
15441 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
15443 return reloc_type
== 72; /* R_PARISC_PCREL64. */
15445 return reloc_type
== 44; /* R_PPC64_REL64. */
15446 case EM_SPARC32PLUS
:
15449 return reloc_type
== 46; /* R_SPARC_DISP64. */
15453 return reloc_type
== 24; /* R_X86_64_PC64. */
15456 return reloc_type
== 23; /* R_S390_PC64. */
15458 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
15464 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15465 a 24-bit absolute RELA relocation used in DWARF debug sections. */
15468 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15470 switch (filedata
->file_header
.e_machine
)
15472 case EM_CYGNUS_MN10200
:
15474 return reloc_type
== 4; /* R_MN10200_24. */
15476 return reloc_type
== 5; /* R_FT32_20. */
15478 return reloc_type
== 5; /* R_Z80_24. */
15484 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15485 a 16-bit absolute RELA relocation used in DWARF debug sections. */
15488 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15490 /* Please keep this table alpha-sorted for ease of visual lookup. */
15491 switch (filedata
->file_header
.e_machine
)
15494 case EM_ARC_COMPACT
:
15495 case EM_ARC_COMPACT2
:
15496 case EM_ARC_COMPACT3
:
15497 case EM_ARC_COMPACT3_64
:
15498 return reloc_type
== 2; /* R_ARC_16. */
15499 case EM_ADAPTEVA_EPIPHANY
:
15500 return reloc_type
== 5;
15503 return reloc_type
== 4; /* R_AVR_16. */
15504 case EM_CYGNUS_D10V
:
15506 return reloc_type
== 3; /* R_D10V_16. */
15508 return reloc_type
== 2; /* R_FT32_16. */
15512 return reloc_type
== R_H8_DIR16
;
15515 return reloc_type
== 1; /* R_IP2K_16. */
15518 return reloc_type
== 1; /* R_M32C_16 */
15519 case EM_CYGNUS_MN10200
:
15521 return reloc_type
== 2; /* R_MN10200_16. */
15522 case EM_CYGNUS_MN10300
:
15524 return reloc_type
== 2; /* R_MN10300_16. */
15526 return reloc_type
== 1; /* R_KVX_16 */
15528 if (uses_msp430x_relocs (filedata
))
15529 return reloc_type
== 2; /* R_MSP430_ABS16. */
15530 /* Fall through. */
15531 case EM_MSP430_OLD
:
15532 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
15534 return reloc_type
== 19; /* R_NDS32_16_RELA. */
15535 case EM_ALTERA_NIOS2
:
15536 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
15538 return reloc_type
== 9; /* R_NIOS_16. */
15540 return reloc_type
== 2; /* R_OR1K_16. */
15542 return reloc_type
== 55; /* R_RISCV_SET16. */
15544 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
15546 return reloc_type
== 2; /* R_C6000_ABS16. */
15548 return reloc_type
== 2; /* R_VISIUM_16. */
15550 return reloc_type
== 3; /* R_XGATE_16. */
15552 return reloc_type
== 4; /* R_Z80_16. */
15558 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15559 a 8-bit absolute RELA relocation used in DWARF debug sections. */
15562 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15564 switch (filedata
->file_header
.e_machine
)
15567 return reloc_type
== 54; /* R_RISCV_SET8. */
15569 return reloc_type
== 1; /* R_Z80_8. */
15570 case EM_MICROBLAZE
:
15571 return (reloc_type
== 33 /* R_MICROBLAZE_32_NONE. */
15572 || reloc_type
== 0 /* R_MICROBLAZE_NONE. */
15573 || reloc_type
== 9 /* R_MICROBLAZE_64_NONE. */);
15579 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15580 a 6-bit absolute RELA relocation used in DWARF debug sections. */
15583 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15585 switch (filedata
->file_header
.e_machine
)
15588 return reloc_type
== 53; /* R_RISCV_SET6. */
15594 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15595 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
15598 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15600 /* Please keep this table alpha-sorted for ease of visual lookup. */
15601 switch (filedata
->file_header
.e_machine
)
15604 return reloc_type
== 50; /* R_LARCH_ADD32. */
15606 return reloc_type
== 35; /* R_RISCV_ADD32. */
15612 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15613 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
15616 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15618 /* Please keep this table alpha-sorted for ease of visual lookup. */
15619 switch (filedata
->file_header
.e_machine
)
15622 return reloc_type
== 55; /* R_LARCH_SUB32. */
15624 return reloc_type
== 39; /* R_RISCV_SUB32. */
15630 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15631 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
15634 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15636 /* Please keep this table alpha-sorted for ease of visual lookup. */
15637 switch (filedata
->file_header
.e_machine
)
15640 return reloc_type
== 51; /* R_LARCH_ADD64. */
15642 return reloc_type
== 36; /* R_RISCV_ADD64. */
15648 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15649 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
15652 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15654 /* Please keep this table alpha-sorted for ease of visual lookup. */
15655 switch (filedata
->file_header
.e_machine
)
15658 return reloc_type
== 56; /* R_LARCH_SUB64. */
15660 return reloc_type
== 40; /* R_RISCV_SUB64. */
15666 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15667 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
15670 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15672 /* Please keep this table alpha-sorted for ease of visual lookup. */
15673 switch (filedata
->file_header
.e_machine
)
15676 return reloc_type
== 48; /* R_LARCH_ADD16. */
15678 return reloc_type
== 34; /* R_RISCV_ADD16. */
15684 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15685 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
15688 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15690 /* Please keep this table alpha-sorted for ease of visual lookup. */
15691 switch (filedata
->file_header
.e_machine
)
15694 return reloc_type
== 53; /* R_LARCH_SUB16. */
15696 return reloc_type
== 38; /* R_RISCV_SUB16. */
15702 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15703 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
15706 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15708 /* Please keep this table alpha-sorted for ease of visual lookup. */
15709 switch (filedata
->file_header
.e_machine
)
15712 return reloc_type
== 47; /* R_LARCH_ADD8. */
15714 return reloc_type
== 33; /* R_RISCV_ADD8. */
15720 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15721 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
15724 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15726 /* Please keep this table alpha-sorted for ease of visual lookup. */
15727 switch (filedata
->file_header
.e_machine
)
15730 return reloc_type
== 52; /* R_LARCH_SUB8. */
15732 return reloc_type
== 37; /* R_RISCV_SUB8. */
15738 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15739 a 6-bit inplace add RELA relocation used in DWARF debug sections. */
15742 is_6bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15744 switch (filedata
->file_header
.e_machine
)
15747 return reloc_type
== 105; /* R_LARCH_ADD6. */
15753 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15754 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
15757 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15759 switch (filedata
->file_header
.e_machine
)
15762 return reloc_type
== 106; /* R_LARCH_SUB6. */
15764 return reloc_type
== 52; /* R_RISCV_SUB6. */
15770 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
15771 relocation entries (possibly formerly used for SHT_GROUP sections). */
15774 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15776 switch (filedata
->file_header
.e_machine
)
15778 case EM_386
: /* R_386_NONE. */
15779 case EM_68K
: /* R_68K_NONE. */
15780 case EM_ADAPTEVA_EPIPHANY
:
15781 case EM_ALPHA
: /* R_ALPHA_NONE. */
15782 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
15783 case EM_ARC
: /* R_ARC_NONE. */
15784 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
15785 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
15786 case EM_ARC_COMPACT3
: /* R_ARC_NONE. */
15787 case EM_ARC_COMPACT3_64
: /* R_ARC_NONE. */
15788 case EM_ARM
: /* R_ARM_NONE. */
15789 case EM_CRIS
: /* R_CRIS_NONE. */
15790 case EM_FT32
: /* R_FT32_NONE. */
15791 case EM_IA_64
: /* R_IA64_NONE. */
15792 case EM_K1OM
: /* R_X86_64_NONE. */
15793 case EM_KVX
: /* R_KVX_NONE. */
15794 case EM_L1OM
: /* R_X86_64_NONE. */
15795 case EM_M32R
: /* R_M32R_NONE. */
15796 case EM_MIPS
: /* R_MIPS_NONE. */
15797 case EM_MN10300
: /* R_MN10300_NONE. */
15798 case EM_MOXIE
: /* R_MOXIE_NONE. */
15799 case EM_NIOS32
: /* R_NIOS_NONE. */
15800 case EM_OR1K
: /* R_OR1K_NONE. */
15801 case EM_PARISC
: /* R_PARISC_NONE. */
15802 case EM_PPC64
: /* R_PPC64_NONE. */
15803 case EM_PPC
: /* R_PPC_NONE. */
15804 case EM_RISCV
: /* R_RISCV_NONE. */
15805 case EM_S390
: /* R_390_NONE. */
15807 case EM_SH
: /* R_SH_NONE. */
15808 case EM_SPARC32PLUS
:
15809 case EM_SPARC
: /* R_SPARC_NONE. */
15811 case EM_TILEGX
: /* R_TILEGX_NONE. */
15812 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
15813 case EM_TI_C6000
:/* R_C6000_NONE. */
15814 case EM_X86_64
: /* R_X86_64_NONE. */
15815 case EM_Z80
: /* R_Z80_NONE. */
15816 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
15817 return reloc_type
== 0;
15820 return reloc_type
== 0 || reloc_type
== 256;
15823 return (reloc_type
== 0 /* R_AVR_NONE. */
15824 || reloc_type
== 30 /* R_AVR_DIFF8. */
15825 || reloc_type
== 31 /* R_AVR_DIFF16. */
15826 || reloc_type
== 32 /* R_AVR_DIFF32. */);
15828 return reloc_type
== 3; /* R_METAG_NONE. */
15830 return (reloc_type
== 0 /* R_NDS32_NONE. */
15831 || reloc_type
== 205 /* R_NDS32_DIFF8. */
15832 || reloc_type
== 206 /* R_NDS32_DIFF16. */
15833 || reloc_type
== 207 /* R_NDS32_DIFF32. */
15834 || reloc_type
== 208 /* R_NDS32_DIFF_ULEB128. */);
15836 return (reloc_type
== 0 /* R_PRU_NONE. */
15837 || reloc_type
== 65 /* R_PRU_DIFF8. */
15838 || reloc_type
== 66 /* R_PRU_DIFF16. */
15839 || reloc_type
== 67 /* R_PRU_DIFF32. */);
15840 case EM_XTENSA_OLD
:
15842 return (reloc_type
== 0 /* R_XTENSA_NONE. */
15843 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
15844 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
15845 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
15846 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
15847 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
15848 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
15849 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
15850 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
15851 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
15856 /* Returns TRUE if there is a relocation against
15857 section NAME at OFFSET bytes. */
15860 reloc_at (struct dwarf_section
* dsec
, uint64_t offset
)
15862 Elf_Internal_Rela
* relocs
;
15863 Elf_Internal_Rela
* rp
;
15865 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
15868 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
15870 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
15871 if (rp
->r_offset
== offset
)
15877 /* Apply relocations to a section.
15878 Returns TRUE upon success, FALSE otherwise.
15879 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
15880 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
15881 will be set to the number of relocs loaded.
15883 Note: So far support has been added only for those relocations
15884 which can be found in debug sections. FIXME: Add support for
15885 more relocations ? */
15888 apply_relocations (Filedata
*filedata
,
15889 const Elf_Internal_Shdr
*section
,
15890 unsigned char *start
,
15892 void **relocs_return
,
15893 uint64_t *num_relocs_return
)
15895 Elf_Internal_Shdr
* relsec
;
15896 unsigned char * end
= start
+ size
;
15898 if (relocs_return
!= NULL
)
15900 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
15901 * num_relocs_return
= 0;
15904 if (filedata
->file_header
.e_type
!= ET_REL
)
15905 /* No relocs to apply. */
15908 /* Find the reloc section associated with the section. */
15909 for (relsec
= filedata
->section_headers
;
15910 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
15914 uint64_t num_relocs
;
15915 Elf_Internal_Rela
* relocs
;
15916 Elf_Internal_Rela
* rp
;
15917 Elf_Internal_Shdr
* symsec
;
15918 Elf_Internal_Sym
* symtab
;
15920 Elf_Internal_Sym
* sym
;
15922 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
15923 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
15924 || filedata
->section_headers
+ relsec
->sh_info
!= section
15925 || relsec
->sh_size
== 0
15926 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
15929 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
15930 if (symsec
->sh_type
!= SHT_SYMTAB
15931 && symsec
->sh_type
!= SHT_DYNSYM
)
15934 is_rela
= relsec
->sh_type
== SHT_RELA
;
15938 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
15939 relsec
->sh_size
, & relocs
, & num_relocs
))
15944 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
15945 relsec
->sh_size
, & relocs
, & num_relocs
))
15949 /* SH uses RELA but uses in place value instead of the addend field. */
15950 if (filedata
->file_header
.e_machine
== EM_SH
)
15953 symtab
= get_elf_symbols (filedata
, symsec
, & num_syms
);
15955 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
15958 unsigned int reloc_type
;
15959 unsigned int reloc_size
;
15960 bool reloc_inplace
= false;
15961 bool reloc_subtract
= false;
15962 unsigned char *rloc
;
15963 uint64_t sym_index
;
15965 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
15967 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
15969 else if (is_none_reloc (filedata
, reloc_type
))
15971 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
15972 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
15974 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
15975 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
15977 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
15979 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
15981 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
15982 || is_6bit_abs_reloc (filedata
, reloc_type
))
15984 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
15986 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
15989 reloc_inplace
= true;
15991 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
15993 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
15996 reloc_inplace
= true;
15998 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
16000 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
16003 reloc_inplace
= true;
16005 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
16007 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
16010 reloc_inplace
= true;
16012 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
16014 || is_6bit_inplace_add_reloc (filedata
, reloc_type
))
16017 reloc_inplace
= true;
16021 static unsigned int prev_reloc
= 0;
16023 if (reloc_type
!= prev_reloc
)
16024 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
16025 reloc_type
, printable_section_name (filedata
, section
));
16026 prev_reloc
= reloc_type
;
16030 rloc
= start
+ rp
->r_offset
;
16031 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
16033 warn (_("skipping invalid relocation offset %#" PRIx64
16034 " in section %s\n"),
16036 printable_section_name (filedata
, section
));
16040 sym_index
= get_reloc_symindex (rp
->r_info
);
16041 if (sym_index
>= num_syms
)
16043 warn (_("skipping invalid relocation symbol index %#" PRIx64
16044 " in section %s\n"),
16045 sym_index
, printable_section_name (filedata
, section
));
16048 sym
= symtab
+ sym_index
;
16050 /* If the reloc has a symbol associated with it,
16051 make sure that it is of an appropriate type.
16053 Relocations against symbols without type can happen.
16054 Gcc -feliminate-dwarf2-dups may generate symbols
16055 without type for debug info.
16057 Icc generates relocations against function symbols
16058 instead of local labels.
16060 Relocations against object symbols can happen, eg when
16061 referencing a global array. For an example of this see
16062 the _clz.o binary in libgcc.a. */
16064 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
16065 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
16067 warn (_("skipping unexpected symbol type %s in section %s relocation %tu\n"),
16068 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
16069 printable_section_name (filedata
, relsec
),
16076 addend
+= rp
->r_addend
;
16077 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
16078 partial_inplace. */
16080 || (filedata
->file_header
.e_machine
== EM_XTENSA
16081 && reloc_type
== 1)
16082 || ((filedata
->file_header
.e_machine
== EM_PJ
16083 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
16084 && reloc_type
== 1)
16085 || ((filedata
->file_header
.e_machine
== EM_D30V
16086 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
16087 && reloc_type
== 12)
16090 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
16091 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
16093 addend
+= byte_get (rloc
, reloc_size
);
16096 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
16097 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
16099 /* On HPPA, all pc-relative relocations are biased by 8. */
16100 if (filedata
->file_header
.e_machine
== EM_PARISC
)
16102 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
16105 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
16106 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
)
16107 || is_6bit_inplace_add_reloc (filedata
, reloc_type
))
16109 if (reloc_subtract
)
16110 addend
-= sym
->st_value
;
16112 addend
+= sym
->st_value
;
16113 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
16114 byte_put (rloc
, addend
, reloc_size
);
16116 else if (reloc_subtract
)
16117 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
16119 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
16123 /* Let the target specific reloc processing code know that
16124 we have finished with these relocs. */
16125 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
16129 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
16130 * num_relocs_return
= num_relocs
;
16141 #ifdef SUPPORT_DISASSEMBLY
16143 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
16145 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
16147 /* FIXME: XXX -- to be done --- XXX */
16153 /* Reads in the contents of SECTION from FILE, returning a pointer
16154 to a malloc'ed buffer or NULL if something went wrong. */
16157 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
16159 uint64_t num_bytes
= section
->sh_size
;
16161 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
16163 printf (_("Section '%s' has no data to dump.\n"),
16164 printable_section_name (filedata
, section
));
16168 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
16169 _("section contents"));
16172 /* Uncompresses a section that was compressed using zlib/zstd, in place. */
16175 uncompress_section_contents (bool is_zstd
,
16176 unsigned char ** buffer
,
16177 uint64_t uncompressed_size
,
16179 uint64_t file_size
)
16181 uint64_t compressed_size
= *size
;
16182 unsigned char *compressed_buffer
= *buffer
;
16183 unsigned char *uncompressed_buffer
= NULL
;
16187 /* Similar to bfd_section_size_insane() in the BFD library we expect an
16188 upper limit of ~10x compression. Any compression larger than that is
16189 thought to be due to fuzzing of the compression header. */
16190 if (uncompressed_size
> file_size
* 10)
16192 error (_("Uncompressed section size is suspiciously large: 0x%" PRIu64
"\n"),
16193 uncompressed_size
);
16197 uncompressed_buffer
= xmalloc (uncompressed_size
);
16202 size_t ret
= ZSTD_decompress (uncompressed_buffer
, uncompressed_size
,
16203 compressed_buffer
, compressed_size
);
16204 if (ZSTD_isError (ret
))
16210 /* It is possible the section consists of several compressed
16211 buffers concatenated together, so we uncompress in a loop. */
16212 /* PR 18313: The state field in the z_stream structure is supposed
16213 to be invisible to the user (ie us), but some compilers will
16214 still complain about it being used without initialisation. So
16215 we first zero the entire z_stream structure and then set the fields
16217 memset (&strm
, 0, sizeof strm
);
16218 strm
.avail_in
= compressed_size
;
16219 strm
.next_in
= (Bytef
*)compressed_buffer
;
16220 strm
.avail_out
= uncompressed_size
;
16222 rc
= inflateInit (&strm
);
16223 while (strm
.avail_in
> 0)
16227 strm
.next_out
= ((Bytef
*)uncompressed_buffer
16228 + (uncompressed_size
- strm
.avail_out
));
16229 rc
= inflate (&strm
, Z_FINISH
);
16230 if (rc
!= Z_STREAM_END
)
16232 rc
= inflateReset (&strm
);
16234 if (inflateEnd (&strm
) != Z_OK
|| rc
!= Z_OK
|| strm
.avail_out
!= 0)
16238 *buffer
= uncompressed_buffer
;
16239 *size
= uncompressed_size
;
16243 free (uncompressed_buffer
);
16244 /* Indicate decompression failure. */
16250 maybe_expand_or_relocate_section (Elf_Internal_Shdr
* section
,
16251 Filedata
* filedata
,
16252 unsigned char ** start_ptr
,
16255 uint64_t section_size
= section
->sh_size
;
16256 unsigned char * start
= * start_ptr
;
16258 if (decompress_dumps
)
16260 uint64_t new_size
= section_size
;
16261 uint64_t uncompressed_size
= 0;
16262 bool is_zstd
= false;
16264 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
16266 Elf_Internal_Chdr chdr
;
16267 unsigned int compression_header_size
16268 = get_compression_header (& chdr
, start
, section_size
);
16270 if (compression_header_size
== 0)
16271 /* An error message will have already been generated
16272 by get_compression_header. */
16273 return (uint64_t) -1;
16275 if (chdr
.ch_type
== ch_compress_zlib
)
16278 else if (chdr
.ch_type
== ch_compress_zstd
)
16283 warn (_("section '%s' has unsupported compress type: %d\n"),
16284 printable_section_name (filedata
, section
), chdr
.ch_type
);
16285 return (uint64_t) -1;
16288 uncompressed_size
= chdr
.ch_size
;
16289 start
+= compression_header_size
;
16290 new_size
-= compression_header_size
;
16292 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
16294 /* Read the zlib header. In this case, it should be "ZLIB"
16295 followed by the uncompressed section size, 8 bytes in
16296 big-endian order. */
16297 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
16298 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
16299 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
16300 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
16301 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
16302 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
16303 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
16304 uncompressed_size
+= start
[11];
16309 if (uncompressed_size
)
16311 if (uncompress_section_contents (is_zstd
, &start
, uncompressed_size
,
16312 &new_size
, filedata
->file_size
))
16313 section_size
= new_size
;
16316 error (_("Unable to decompress section %s\n"),
16317 printable_section_name (filedata
, section
));
16318 return (uint64_t) -1;
16322 start
= * start_ptr
;
16324 else if (((section
->sh_flags
& SHF_COMPRESSED
) != 0)
16325 || (section_size
> 12 && streq ((char *) start
, "ZLIB")))
16327 printf (_(" NOTE: This section is compressed, but its contents have NOT been expanded for this dump.\n"));
16332 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
16333 return (uint64_t) -1;
16337 Elf_Internal_Shdr
*relsec
;
16339 /* If the section being dumped has relocations against it the user might
16340 be expecting these relocations to have been applied. Check for this
16341 case and issue a warning message in order to avoid confusion.
16342 FIXME: Maybe we ought to have an option that dumps a section with
16343 relocs applied ? */
16344 for (relsec
= filedata
->section_headers
;
16345 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
16348 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
16349 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
16350 || filedata
->section_headers
+ relsec
->sh_info
!= section
16351 || relsec
->sh_size
== 0
16352 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
16355 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
16360 * start_ptr
= start
;
16361 return section_size
;
16365 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
16367 uint64_t num_bytes
;
16368 unsigned char *data
;
16369 unsigned char *end
;
16370 unsigned char *real_start
;
16371 unsigned char *start
;
16372 bool some_strings_shown
;
16374 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
16376 /* PR 21820: Do not fail if the section was empty. */
16377 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
16379 num_bytes
= section
->sh_size
;
16381 if (filedata
->is_separate
)
16382 printf (_("\nString dump of section '%s' in linked file %s:\n"),
16383 printable_section_name (filedata
, section
),
16384 filedata
->file_name
);
16386 printf (_("\nString dump of section '%s':\n"),
16387 printable_section_name (filedata
, section
));
16389 num_bytes
= maybe_expand_or_relocate_section (section
, filedata
, & start
, false);
16390 if (num_bytes
== (uint64_t) -1)
16394 end
= start
+ num_bytes
;
16395 some_strings_shown
= false;
16397 #ifdef HAVE_MBSTATE_T
16399 /* Initialise the multibyte conversion state. */
16400 memset (& state
, 0, sizeof (state
));
16403 bool continuing
= false;
16407 while (!ISPRINT (* data
))
16408 if (++ data
>= end
)
16413 size_t maxlen
= end
- data
;
16418 continuing
= false;
16422 printf (" [%6tx] ", data
- start
);
16436 /* PR 25543: Treat new-lines as string-ending characters. */
16445 /* Do not print control characters directly as they can affect terminal
16446 settings. Such characters usually appear in the names generated
16447 by the assembler for local labels. */
16450 printf ("^%c", c
+ 0x40);
16452 else if (ISPRINT (c
))
16459 #ifdef HAVE_MBSTATE_T
16462 /* Let printf do the hard work of displaying multibyte characters. */
16463 printf ("%.1s", data
- 1);
16464 #ifdef HAVE_MBSTATE_T
16465 /* Try to find out how many bytes made up the character that was
16466 just printed. Advance the symbol pointer past the bytes that
16468 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
16472 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
16482 printf (_("<corrupt>\n"));
16485 some_strings_shown
= true;
16489 if (! some_strings_shown
)
16490 printf (_(" No strings found in this section."));
16503 dump_section_as_bytes (Elf_Internal_Shdr
*section
,
16504 Filedata
*filedata
,
16508 uint64_t section_size
;
16510 unsigned char *data
;
16511 unsigned char *real_start
;
16512 unsigned char *start
;
16514 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
16516 /* PR 21820: Do not fail if the section was empty. */
16517 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
16519 section_size
= section
->sh_size
;
16521 if (filedata
->is_separate
)
16522 printf (_("\nHex dump of section '%s' in linked file %s:\n"),
16523 printable_section_name (filedata
, section
),
16524 filedata
->file_name
);
16526 printf (_("\nHex dump of section '%s':\n"),
16527 printable_section_name (filedata
, section
));
16529 section_size
= maybe_expand_or_relocate_section (section
, filedata
, & start
, relocate
);
16530 if (section_size
== (uint64_t) -1)
16533 addr
= section
->sh_addr
;
16534 bytes
= section_size
;
16543 lbytes
= (bytes
> 16 ? 16 : bytes
);
16545 printf (" 0x%8.8" PRIx64
" ", addr
);
16547 for (j
= 0; j
< 16; j
++)
16550 printf ("%2.2x", data
[j
]);
16558 for (j
= 0; j
< lbytes
; j
++)
16561 if (k
>= ' ' && k
< 0x7f)
16584 #ifdef ENABLE_LIBCTF
16585 static ctf_sect_t
*
16586 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
16588 buf
->cts_name
= printable_section_name (filedata
, shdr
);
16589 buf
->cts_size
= shdr
->sh_size
;
16590 buf
->cts_entsize
= shdr
->sh_entsize
;
16595 /* Formatting callback function passed to ctf_dump. Returns either the pointer
16596 it is passed, or a pointer to newly-allocated storage, in which case
16597 dump_ctf() will free it when it no longer needs it. */
16600 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
16601 char *s
, void *arg
)
16603 const char *blanks
= arg
;
16606 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
16611 /* Dump CTF errors/warnings. */
16613 dump_ctf_errs (ctf_dict_t
*fp
)
16615 ctf_next_t
*it
= NULL
;
16620 /* Dump accumulated errors and warnings. */
16621 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
16623 error (_("%s: %s"), is_warning
? _("warning"): _("error"),
16627 if (err
!= ECTF_NEXT_END
)
16628 error (_("CTF error: cannot get CTF errors: `%s'"), ctf_errmsg (err
));
16631 /* Dump one CTF archive member. */
16634 dump_ctf_archive_member (ctf_dict_t
*ctf
, const char *name
, ctf_dict_t
*parent
,
16637 const char *things
[] = {"Header", "Labels", "Data objects",
16638 "Function objects", "Variables", "Types", "Strings",
16640 const char **thing
;
16643 /* Don't print out the name of the default-named archive member if it appears
16644 first in the list. The name .ctf appears everywhere, even for things that
16645 aren't really archives, so printing it out is liable to be confusing; also,
16646 the common case by far is for only one archive member to exist, and hiding
16647 it in that case seems worthwhile. */
16649 if (strcmp (name
, ".ctf") != 0 || member
!= 0)
16650 printf (_("\nCTF archive member: %s:\n"), name
);
16652 if (ctf_parent_name (ctf
) != NULL
)
16653 ctf_import (ctf
, parent
);
16655 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
16657 ctf_dump_state_t
*s
= NULL
;
16660 printf ("\n %s:\n", *thing
);
16661 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
16662 (void *) " ")) != NULL
)
16664 printf ("%s\n", item
);
16668 if (ctf_errno (ctf
))
16670 error (_("Iteration failed: %s, %s\n"), *thing
,
16671 ctf_errmsg (ctf_errno (ctf
)));
16676 dump_ctf_errs (ctf
);
16680 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
16682 Elf_Internal_Shdr
* symtab_sec
= NULL
;
16683 Elf_Internal_Shdr
* strtab_sec
= NULL
;
16684 void * data
= NULL
;
16685 void * symdata
= NULL
;
16686 void * strdata
= NULL
;
16687 ctf_sect_t ctfsect
, symsect
, strsect
;
16688 ctf_sect_t
* symsectp
= NULL
;
16689 ctf_sect_t
* strsectp
= NULL
;
16690 ctf_archive_t
* ctfa
= NULL
;
16691 ctf_dict_t
* parent
= NULL
;
16694 ctf_next_t
*i
= NULL
;
16700 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
16701 data
= get_section_contents (section
, filedata
);
16702 ctfsect
.cts_data
= data
;
16704 if (!dump_ctf_symtab_name
)
16705 dump_ctf_symtab_name
= strdup (".dynsym");
16707 if (!dump_ctf_strtab_name
)
16708 dump_ctf_strtab_name
= strdup (".dynstr");
16710 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
16712 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
16714 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
16717 if ((symdata
= (void *) get_data (NULL
, filedata
,
16718 symtab_sec
->sh_offset
, 1,
16719 symtab_sec
->sh_size
,
16720 _("symbols"))) == NULL
)
16722 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
16723 symsect
.cts_data
= symdata
;
16726 if (dump_ctf_strtab_name
&& dump_ctf_strtab_name
[0] != 0)
16728 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
16730 error (_("No string table section named %s\n"),
16731 dump_ctf_strtab_name
);
16734 if ((strdata
= (void *) get_data (NULL
, filedata
,
16735 strtab_sec
->sh_offset
, 1,
16736 strtab_sec
->sh_size
,
16737 _("strings"))) == NULL
)
16739 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
16740 strsect
.cts_data
= strdata
;
16743 /* Load the CTF file and dump it. It may be a raw CTF section, or an archive:
16744 libctf papers over the difference, so we can pretend it is always an
16747 if ((ctfa
= ctf_arc_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
16749 dump_ctf_errs (NULL
);
16750 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
16754 ctf_arc_symsect_endianness (ctfa
, filedata
->file_header
.e_ident
[EI_DATA
]
16757 /* Preload the parent dict, since it will need to be imported into every
16759 if ((parent
= ctf_dict_open (ctfa
, dump_ctf_parent_name
, &err
)) == NULL
)
16761 dump_ctf_errs (NULL
);
16762 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
16768 if (filedata
->is_separate
)
16769 printf (_("\nDump of CTF section '%s' in linked file %s:\n"),
16770 printable_section_name (filedata
, section
),
16771 filedata
->file_name
);
16773 printf (_("\nDump of CTF section '%s':\n"),
16774 printable_section_name (filedata
, section
));
16776 while ((fp
= ctf_archive_next (ctfa
, &i
, &name
, 0, &err
)) != NULL
)
16777 dump_ctf_archive_member (fp
, name
, parent
, member
++);
16778 if (err
!= ECTF_NEXT_END
)
16780 dump_ctf_errs (NULL
);
16781 error (_("CTF member open failure: %s\n"), ctf_errmsg (err
));
16786 ctf_dict_close (parent
);
16796 dump_section_as_sframe (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
16798 void * data
= NULL
;
16799 sframe_decoder_ctx
*sfd_ctx
= NULL
;
16800 const char *print_name
= printable_section_name (filedata
, section
);
16806 if (strcmp (print_name
, "") == 0)
16808 error (_("Section name must be provided \n"));
16813 data
= get_section_contents (section
, filedata
);
16814 sf_size
= section
->sh_size
;
16815 /* Decode the contents of the section. */
16816 sfd_ctx
= sframe_decode ((const char*)data
, sf_size
, &err
);
16820 error (_("SFrame decode failure: %s\n"), sframe_errmsg (err
));
16824 printf (_("Contents of the SFrame section %s:"), print_name
);
16825 /* Dump the contents as text. */
16826 dump_sframe (sfd_ctx
, section
->sh_addr
);
16834 load_specific_debug_section (enum dwarf_section_display_enum debug
,
16835 const Elf_Internal_Shdr
* sec
,
16838 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
16840 Filedata
* filedata
= (Filedata
*) data
;
16842 if (section
->start
!= NULL
)
16844 /* If it is already loaded, do nothing. */
16845 if (streq (section
->filename
, filedata
->file_name
))
16847 free (section
->start
);
16850 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
16851 section
->address
= sec
->sh_addr
;
16852 section
->filename
= filedata
->file_name
;
16853 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
16855 sec
->sh_size
, buf
);
16856 if (section
->start
== NULL
)
16860 unsigned char *start
= section
->start
;
16861 uint64_t size
= sec
->sh_size
;
16862 uint64_t uncompressed_size
= 0;
16863 bool is_zstd
= false;
16865 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
16867 Elf_Internal_Chdr chdr
;
16868 unsigned int compression_header_size
;
16870 if (size
< (is_32bit_elf
16871 ? sizeof (Elf32_External_Chdr
)
16872 : sizeof (Elf64_External_Chdr
)))
16874 warn (_("compressed section %s is too small to contain a compression header\n"),
16879 compression_header_size
= get_compression_header (&chdr
, start
, size
);
16880 if (compression_header_size
== 0)
16881 /* An error message will have already been generated
16882 by get_compression_header. */
16885 if (chdr
.ch_type
== ch_compress_zlib
)
16888 else if (chdr
.ch_type
== ch_compress_zstd
)
16893 warn (_("section '%s' has unsupported compress type: %d\n"),
16894 section
->name
, chdr
.ch_type
);
16897 uncompressed_size
= chdr
.ch_size
;
16898 start
+= compression_header_size
;
16899 size
-= compression_header_size
;
16901 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
16903 /* Read the zlib header. In this case, it should be "ZLIB"
16904 followed by the uncompressed section size, 8 bytes in
16905 big-endian order. */
16906 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
16907 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
16908 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
16909 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
16910 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
16911 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
16912 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
16913 uncompressed_size
+= start
[11];
16918 if (uncompressed_size
)
16920 if (uncompress_section_contents (is_zstd
, &start
, uncompressed_size
,
16921 &size
, filedata
->file_size
))
16923 /* Free the compressed buffer, update the section buffer
16924 and the section size if uncompress is successful. */
16925 free (section
->start
);
16926 section
->start
= start
;
16930 error (_("Unable to decompress section %s\n"),
16931 printable_section_name (filedata
, sec
));
16936 section
->size
= size
;
16939 if (section
->start
== NULL
)
16942 if (debug_displays
[debug
].relocate
)
16944 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
16945 & section
->reloc_info
, & section
->num_relocs
))
16950 section
->reloc_info
= NULL
;
16951 section
->num_relocs
= 0;
16957 #if HAVE_LIBDEBUGINFOD
16958 /* Return a hex string representation of the build-id. */
16960 get_build_id (void * data
)
16962 Filedata
* filedata
= (Filedata
*) data
;
16963 Elf_Internal_Shdr
* shdr
;
16966 /* Iterate through notes to find note.gnu.build-id.
16967 FIXME: Only the first note in any note section is examined. */
16968 for (i
= 0, shdr
= filedata
->section_headers
;
16969 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
16972 if (shdr
->sh_type
!= SHT_NOTE
)
16977 size_t data_remaining
;
16979 Elf_External_Note
* enote
;
16980 Elf_Internal_Note inote
;
16982 uint64_t offset
= shdr
->sh_offset
;
16983 uint64_t align
= shdr
->sh_addralign
;
16984 uint64_t length
= shdr
->sh_size
;
16986 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
16992 else if (align
!= 4 && align
!= 8)
16998 end
= (char *) enote
+ length
;
16999 data_remaining
= end
- (char *) enote
;
17001 if (!is_ia64_vms (filedata
))
17003 min_notesz
= offsetof (Elf_External_Note
, name
);
17004 if (data_remaining
< min_notesz
)
17007 malformed note encountered in section %s whilst scanning for build-id note\n"),
17008 printable_section_name (filedata
, shdr
));
17012 data_remaining
-= min_notesz
;
17014 inote
.type
= BYTE_GET (enote
->type
);
17015 inote
.namesz
= BYTE_GET (enote
->namesz
);
17016 inote
.namedata
= enote
->name
;
17017 inote
.descsz
= BYTE_GET (enote
->descsz
);
17018 inote
.descdata
= ((char *) enote
17019 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
17020 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
17021 next
= ((char *) enote
17022 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
17026 Elf64_External_VMS_Note
*vms_enote
;
17028 /* PR binutils/15191
17029 Make sure that there is enough data to read. */
17030 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
17031 if (data_remaining
< min_notesz
)
17034 malformed note encountered in section %s whilst scanning for build-id note\n"),
17035 printable_section_name (filedata
, shdr
));
17039 data_remaining
-= min_notesz
;
17041 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
17042 inote
.type
= BYTE_GET (vms_enote
->type
);
17043 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
17044 inote
.namedata
= vms_enote
->name
;
17045 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
17046 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
17047 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
17048 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
17051 /* Skip malformed notes. */
17052 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
17053 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
17054 || (size_t) (next
- inote
.descdata
) < inote
.descsz
17055 || ((size_t) (next
- inote
.descdata
)
17056 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
17059 malformed note encountered in section %s whilst scanning for build-id note\n"),
17060 printable_section_name (filedata
, shdr
));
17065 /* Check if this is the build-id note. If so then convert the build-id
17066 bytes to a hex string. */
17067 if (inote
.namesz
> 0
17068 && startswith (inote
.namedata
, "GNU")
17069 && inote
.type
== NT_GNU_BUILD_ID
)
17074 build_id
= malloc (inote
.descsz
* 2 + 1);
17075 if (build_id
== NULL
)
17081 for (j
= 0; j
< inote
.descsz
; ++j
)
17082 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
17083 build_id
[inote
.descsz
* 2] = '\0';
17086 return (unsigned char *) build_id
;
17093 #endif /* HAVE_LIBDEBUGINFOD */
17095 /* If this is not NULL, load_debug_section will only look for sections
17096 within the list of sections given here. */
17097 static unsigned int * section_subset
= NULL
;
17100 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
17102 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
17103 Elf_Internal_Shdr
* sec
;
17104 Filedata
* filedata
= (Filedata
*) data
;
17106 if (!dump_any_debugging
)
17109 /* Without section headers we cannot find any sections. */
17110 if (filedata
->section_headers
== NULL
)
17113 if (filedata
->string_table
== NULL
17114 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
17115 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
17117 Elf_Internal_Shdr
* strs
;
17119 /* Read in the string table, so that we have section names to scan. */
17120 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
17122 if (strs
!= NULL
&& strs
->sh_size
!= 0)
17124 filedata
->string_table
17125 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
17126 1, strs
->sh_size
, _("string table"));
17128 filedata
->string_table_length
17129 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
17133 /* Locate the debug section. */
17134 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
17136 section
->name
= section
->uncompressed_name
;
17139 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
17141 section
->name
= section
->compressed_name
;
17146 /* If we're loading from a subset of sections, and we've loaded
17147 a section matching this name before, it's likely that it's a
17149 if (section_subset
!= NULL
)
17150 free_debug_section (debug
);
17152 return load_specific_debug_section (debug
, sec
, data
);
17156 free_debug_section (enum dwarf_section_display_enum debug
)
17158 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
17160 if (section
->start
== NULL
)
17163 free ((char *) section
->start
);
17164 section
->start
= NULL
;
17165 section
->address
= 0;
17168 free (section
->reloc_info
);
17169 section
->reloc_info
= NULL
;
17170 section
->num_relocs
= 0;
17174 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
17176 const char *name
= (section_name_valid (filedata
, section
)
17177 ? section_name (filedata
, section
) : "");
17178 const char *print_name
= printable_section_name (filedata
, section
);
17180 bool result
= true;
17183 length
= section
->sh_size
;
17186 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
17189 if (section
->sh_type
== SHT_NOBITS
)
17191 /* There is no point in dumping the contents of a debugging section
17192 which has the NOBITS type - the bits in the file will be random.
17193 This can happen when a file containing a .eh_frame section is
17194 stripped with the --only-keep-debug command line option. */
17195 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
17200 if (startswith (name
, ".gnu.linkonce.wi."))
17201 name
= ".debug_info";
17203 /* See if we know how to display the contents of this section. */
17204 for (i
= 0; i
< max
; i
++)
17206 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
17207 struct dwarf_section_display
* display
= debug_displays
+ i
;
17208 struct dwarf_section
* sec
= & display
->section
;
17210 if (streq (sec
->uncompressed_name
, name
)
17211 || (id
== line
&& startswith (name
, ".debug_line."))
17212 || streq (sec
->compressed_name
, name
))
17214 bool secondary
= (section
!= find_section (filedata
, name
));
17217 free_debug_section (id
);
17219 if (i
== line
&& startswith (name
, ".debug_line."))
17221 else if (streq (sec
->uncompressed_name
, name
))
17222 sec
->name
= sec
->uncompressed_name
;
17224 sec
->name
= sec
->compressed_name
;
17226 if (load_specific_debug_section (id
, section
, filedata
))
17228 /* If this debug section is part of a CU/TU set in a .dwp file,
17229 restrict load_debug_section to the sections in that set. */
17230 section_subset
= find_cu_tu_set (filedata
, shndx
);
17232 result
&= display
->display (sec
, filedata
);
17234 section_subset
= NULL
;
17236 if (secondary
|| (id
!= info
&& id
!= abbrev
&& id
!= debug_addr
))
17237 free_debug_section (id
);
17245 printf (_("Unrecognized debug section: %s\n"), print_name
);
17252 /* Set DUMP_SECTS for all sections where dumps were requested
17253 based on section name. */
17256 initialise_dumps_byname (Filedata
* filedata
)
17258 struct dump_list_entry
* cur
;
17260 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
17265 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
17266 if (section_name_valid (filedata
, filedata
->section_headers
+ i
)
17267 && streq (section_name (filedata
, filedata
->section_headers
+ i
),
17270 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
17274 if (!any
&& !filedata
->is_separate
)
17275 warn (_("Section '%s' was not dumped because it does not exist\n"),
17281 process_section_contents (Filedata
* filedata
)
17283 Elf_Internal_Shdr
* section
;
17290 initialise_dumps_byname (filedata
);
17292 for (i
= 0, section
= filedata
->section_headers
;
17293 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
17296 dump_type dump
= filedata
->dump
.dump_sects
[i
];
17298 if (filedata
->is_separate
&& ! process_links
)
17299 dump
&= DEBUG_DUMP
;
17301 if (dump
& AUTO_DUMP
)
17303 switch (section
->sh_type
)
17306 /* FIXME: There are lots of different type of section that have
17307 SHT_PROGBITS set in their header - code, debug info, etc. So
17308 we should check the section's name and interpret its contents
17309 that way, rather than just defaulting to a byte dump. */
17310 #ifdef SUPPORT_DISASSEMBLY
17311 res
&= disassemble_section (section
, filedata
);
17313 res
&= dump_section_as_bytes (section
, filedata
, false);
17319 res
&= dump_symbol_section (section
, filedata
);
17323 res
&= dump_section_as_strings (section
, filedata
);
17329 res
&= display_relocations (section
, filedata
);
17333 res
&= process_notes_at (filedata
, section
, section
->sh_offset
,
17334 section
->sh_size
, section
->sh_addralign
);
17338 inform (_("Unable to display section %d - it has a NULL type\n"), i
);
17342 inform (_("Unable to display section %d - it has no contents\n"), i
);
17348 case SHT_GNU_ATTRIBUTES
:
17349 /* FIXME: Implement these. */
17350 /* Fall through. */
17352 /* FIXME: Add Proc and OS specific section types ? */
17353 warn (_("Unable to determine how to dump section %d (type %#x)\n"),
17354 i
, section
->sh_type
);
17360 #ifdef SUPPORT_DISASSEMBLY
17361 if (dump
& DISASS_DUMP
)
17363 if (! disassemble_section (section
, filedata
))
17367 if (dump
& HEX_DUMP
)
17369 if (! dump_section_as_bytes (section
, filedata
, false))
17373 if (dump
& RELOC_DUMP
)
17375 if (! dump_section_as_bytes (section
, filedata
, true))
17379 if (dump
& STRING_DUMP
)
17381 if (! dump_section_as_strings (section
, filedata
))
17385 if (dump
& DEBUG_DUMP
)
17387 if (! display_debug_section (i
, section
, filedata
))
17391 #ifdef ENABLE_LIBCTF
17392 if (dump
& CTF_DUMP
)
17394 if (! dump_section_as_ctf (section
, filedata
))
17398 if (dump
& SFRAME_DUMP
)
17400 if (! dump_section_as_sframe (section
, filedata
))
17405 if (! filedata
->is_separate
)
17407 /* Check to see if the user requested a
17408 dump of a section that does not exist. */
17409 for (; i
< filedata
->dump
.num_dump_sects
; i
++)
17410 if (filedata
->dump
.dump_sects
[i
])
17412 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
17421 process_mips_fpe_exception (int mask
)
17427 if (mask
& OEX_FPU_INEX
)
17428 fputs ("INEX", stdout
), first
= false;
17429 if (mask
& OEX_FPU_UFLO
)
17430 printf ("%sUFLO", first
? "" : "|"), first
= false;
17431 if (mask
& OEX_FPU_OFLO
)
17432 printf ("%sOFLO", first
? "" : "|"), first
= false;
17433 if (mask
& OEX_FPU_DIV0
)
17434 printf ("%sDIV0", first
? "" : "|"), first
= false;
17435 if (mask
& OEX_FPU_INVAL
)
17436 printf ("%sINVAL", first
? "" : "|");
17439 fputs ("0", stdout
);
17442 /* Display's the value of TAG at location P. If TAG is
17443 greater than 0 it is assumed to be an unknown tag, and
17444 a message is printed to this effect. Otherwise it is
17445 assumed that a message has already been printed.
17447 If the bottom bit of TAG is set it assumed to have a
17448 string value, otherwise it is assumed to have an integer
17451 Returns an updated P pointing to the first unread byte
17452 beyond the end of TAG's value.
17454 Reads at or beyond END will not be made. */
17456 static unsigned char *
17457 display_tag_value (signed int tag
,
17459 const unsigned char * const end
)
17464 printf (" Tag_unknown_%d: ", tag
);
17468 warn (_("<corrupt tag>\n"));
17472 /* PR 17531 file: 027-19978-0.004. */
17473 size_t maxlen
= (end
- p
) - 1;
17478 print_symbol_name ((int) maxlen
, (const char *) p
);
17479 p
+= strnlen ((char *) p
, maxlen
) + 1;
17483 printf (_("<corrupt string tag>"));
17484 p
= (unsigned char *) end
;
17490 READ_ULEB (val
, p
, end
);
17491 printf ("%" PRId64
" (0x%" PRIx64
")\n", val
, val
);
17498 /* ARC ABI attributes section. */
17500 static unsigned char *
17501 display_arc_attribute (unsigned char * p
,
17502 const unsigned char * const end
)
17507 READ_ULEB (tag
, p
, end
);
17511 case Tag_ARC_PCS_config
:
17512 READ_ULEB (val
, p
, end
);
17513 printf (" Tag_ARC_PCS_config: ");
17517 printf (_("Absent/Non standard\n"));
17520 printf (_("Bare metal/mwdt\n"));
17523 printf (_("Bare metal/newlib\n"));
17526 printf (_("Linux/uclibc\n"));
17529 printf (_("Linux/glibc\n"));
17532 printf (_("Unknown\n"));
17537 case Tag_ARC_CPU_base
:
17538 READ_ULEB (val
, p
, end
);
17539 printf (" Tag_ARC_CPU_base: ");
17544 printf (_("Absent\n"));
17546 case TAG_CPU_ARC6xx
:
17547 printf ("ARC6xx\n");
17549 case TAG_CPU_ARC7xx
:
17550 printf ("ARC7xx\n");
17552 case TAG_CPU_ARCEM
:
17553 printf ("ARCEM\n");
17555 case TAG_CPU_ARCHS
:
17556 printf ("ARCHS\n");
17561 case Tag_ARC_CPU_variation
:
17562 READ_ULEB (val
, p
, end
);
17563 printf (" Tag_ARC_CPU_variation: ");
17567 if (val
> 0 && val
< 16)
17568 printf ("Core%d\n", val
);
17570 printf ("Unknown\n");
17574 printf (_("Absent\n"));
17579 case Tag_ARC_CPU_name
:
17580 printf (" Tag_ARC_CPU_name: ");
17581 p
= display_tag_value (-1, p
, end
);
17584 case Tag_ARC_ABI_rf16
:
17585 READ_ULEB (val
, p
, end
);
17586 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
17589 case Tag_ARC_ABI_osver
:
17590 READ_ULEB (val
, p
, end
);
17591 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
17594 case Tag_ARC_ABI_pic
:
17595 case Tag_ARC_ABI_sda
:
17596 READ_ULEB (val
, p
, end
);
17597 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
17598 : " Tag_ARC_ABI_pic: ");
17602 printf (_("Absent\n"));
17611 printf (_("Unknown\n"));
17616 case Tag_ARC_ABI_tls
:
17617 READ_ULEB (val
, p
, end
);
17618 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
17621 case Tag_ARC_ABI_enumsize
:
17622 READ_ULEB (val
, p
, end
);
17623 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
17627 case Tag_ARC_ABI_exceptions
:
17628 READ_ULEB (val
, p
, end
);
17629 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
17633 case Tag_ARC_ABI_double_size
:
17634 READ_ULEB (val
, p
, end
);
17635 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
17638 case Tag_ARC_ISA_config
:
17639 printf (" Tag_ARC_ISA_config: ");
17640 p
= display_tag_value (-1, p
, end
);
17643 case Tag_ARC_ISA_apex
:
17644 printf (" Tag_ARC_ISA_apex: ");
17645 p
= display_tag_value (-1, p
, end
);
17648 case Tag_ARC_ISA_mpy_option
:
17649 READ_ULEB (val
, p
, end
);
17650 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
17653 case Tag_ARC_ATR_version
:
17654 READ_ULEB (val
, p
, end
);
17655 printf (" Tag_ARC_ATR_version: %d\n", val
);
17659 return display_tag_value (tag
& 1, p
, end
);
17665 /* ARM EABI attributes section. */
17670 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
17672 const char *const *table
;
17673 } arm_attr_public_tag
;
17675 static const char *const arm_attr_tag_CPU_arch
[] =
17676 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
17677 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
17678 "v8-M.mainline", "v8.1-A", "v8.2-A", "v8.3-A",
17679 "v8.1-M.mainline", "v9"};
17680 static const char *const arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
17681 static const char *const arm_attr_tag_THUMB_ISA_use
[] =
17682 {"No", "Thumb-1", "Thumb-2", "Yes"};
17683 static const char *const arm_attr_tag_FP_arch
[] =
17684 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
17685 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
17686 static const char *const arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
17687 static const char *const arm_attr_tag_Advanced_SIMD_arch
[] =
17688 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
17689 "NEON for ARMv8.1"};
17690 static const char *const arm_attr_tag_PCS_config
[] =
17691 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
17692 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
17693 static const char *const arm_attr_tag_ABI_PCS_R9_use
[] =
17694 {"V6", "SB", "TLS", "Unused"};
17695 static const char *const arm_attr_tag_ABI_PCS_RW_data
[] =
17696 {"Absolute", "PC-relative", "SB-relative", "None"};
17697 static const char *const arm_attr_tag_ABI_PCS_RO_data
[] =
17698 {"Absolute", "PC-relative", "None"};
17699 static const char *const arm_attr_tag_ABI_PCS_GOT_use
[] =
17700 {"None", "direct", "GOT-indirect"};
17701 static const char *const arm_attr_tag_ABI_PCS_wchar_t
[] =
17702 {"None", "??? 1", "2", "??? 3", "4"};
17703 static const char *const arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
17704 static const char *const arm_attr_tag_ABI_FP_denormal
[] =
17705 {"Unused", "Needed", "Sign only"};
17706 static const char *const arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
17707 static const char *const arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
17708 static const char *const arm_attr_tag_ABI_FP_number_model
[] =
17709 {"Unused", "Finite", "RTABI", "IEEE 754"};
17710 static const char *const arm_attr_tag_ABI_enum_size
[] =
17711 {"Unused", "small", "int", "forced to int"};
17712 static const char *const arm_attr_tag_ABI_HardFP_use
[] =
17713 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
17714 static const char *const arm_attr_tag_ABI_VFP_args
[] =
17715 {"AAPCS", "VFP registers", "custom", "compatible"};
17716 static const char *const arm_attr_tag_ABI_WMMX_args
[] =
17717 {"AAPCS", "WMMX registers", "custom"};
17718 static const char *const arm_attr_tag_ABI_optimization_goals
[] =
17719 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
17720 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
17721 static const char *const arm_attr_tag_ABI_FP_optimization_goals
[] =
17722 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
17723 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
17724 static const char *const arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
17725 static const char *const arm_attr_tag_FP_HP_extension
[] =
17726 {"Not Allowed", "Allowed"};
17727 static const char *const arm_attr_tag_ABI_FP_16bit_format
[] =
17728 {"None", "IEEE 754", "Alternative Format"};
17729 static const char *const arm_attr_tag_DSP_extension
[] =
17730 {"Follow architecture", "Allowed"};
17731 static const char *const arm_attr_tag_MPextension_use
[] =
17732 {"Not Allowed", "Allowed"};
17733 static const char *const arm_attr_tag_DIV_use
[] =
17734 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
17735 "Allowed in v7-A with integer division extension"};
17736 static const char *const arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
17737 static const char *const arm_attr_tag_Virtualization_use
[] =
17738 {"Not Allowed", "TrustZone", "Virtualization Extensions",
17739 "TrustZone and Virtualization Extensions"};
17740 static const char *const arm_attr_tag_MPextension_use_legacy
[] =
17741 {"Not Allowed", "Allowed"};
17743 static const char *const arm_attr_tag_MVE_arch
[] =
17744 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
17746 static const char * arm_attr_tag_PAC_extension
[] =
17747 {"No PAC/AUT instructions",
17748 "PAC/AUT instructions permitted in the NOP space",
17749 "PAC/AUT instructions permitted in the NOP and in the non-NOP space"};
17751 static const char * arm_attr_tag_BTI_extension
[] =
17752 {"BTI instructions not permitted",
17753 "BTI instructions permitted in the NOP space",
17754 "BTI instructions permitted in the NOP and in the non-NOP space"};
17756 static const char * arm_attr_tag_BTI_use
[] =
17757 {"Compiled without branch target enforcement",
17758 "Compiled with branch target enforcement"};
17760 static const char * arm_attr_tag_PACRET_use
[] =
17761 {"Compiled without return address signing and authentication",
17762 "Compiled with return address signing and authentication"};
17764 #define LOOKUP(id, name) \
17765 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
17766 static arm_attr_public_tag arm_attr_public_tags
[] =
17768 {4, "CPU_raw_name", 1, NULL
},
17769 {5, "CPU_name", 1, NULL
},
17770 LOOKUP(6, CPU_arch
),
17771 {7, "CPU_arch_profile", 0, NULL
},
17772 LOOKUP(8, ARM_ISA_use
),
17773 LOOKUP(9, THUMB_ISA_use
),
17774 LOOKUP(10, FP_arch
),
17775 LOOKUP(11, WMMX_arch
),
17776 LOOKUP(12, Advanced_SIMD_arch
),
17777 LOOKUP(13, PCS_config
),
17778 LOOKUP(14, ABI_PCS_R9_use
),
17779 LOOKUP(15, ABI_PCS_RW_data
),
17780 LOOKUP(16, ABI_PCS_RO_data
),
17781 LOOKUP(17, ABI_PCS_GOT_use
),
17782 LOOKUP(18, ABI_PCS_wchar_t
),
17783 LOOKUP(19, ABI_FP_rounding
),
17784 LOOKUP(20, ABI_FP_denormal
),
17785 LOOKUP(21, ABI_FP_exceptions
),
17786 LOOKUP(22, ABI_FP_user_exceptions
),
17787 LOOKUP(23, ABI_FP_number_model
),
17788 {24, "ABI_align_needed", 0, NULL
},
17789 {25, "ABI_align_preserved", 0, NULL
},
17790 LOOKUP(26, ABI_enum_size
),
17791 LOOKUP(27, ABI_HardFP_use
),
17792 LOOKUP(28, ABI_VFP_args
),
17793 LOOKUP(29, ABI_WMMX_args
),
17794 LOOKUP(30, ABI_optimization_goals
),
17795 LOOKUP(31, ABI_FP_optimization_goals
),
17796 {32, "compatibility", 0, NULL
},
17797 LOOKUP(34, CPU_unaligned_access
),
17798 LOOKUP(36, FP_HP_extension
),
17799 LOOKUP(38, ABI_FP_16bit_format
),
17800 LOOKUP(42, MPextension_use
),
17801 LOOKUP(44, DIV_use
),
17802 LOOKUP(46, DSP_extension
),
17803 LOOKUP(48, MVE_arch
),
17804 LOOKUP(50, PAC_extension
),
17805 LOOKUP(52, BTI_extension
),
17806 LOOKUP(74, BTI_use
),
17807 LOOKUP(76, PACRET_use
),
17808 {64, "nodefaults", 0, NULL
},
17809 {65, "also_compatible_with", 0, NULL
},
17810 LOOKUP(66, T2EE_use
),
17811 {67, "conformance", 1, NULL
},
17812 LOOKUP(68, Virtualization_use
),
17813 LOOKUP(70, MPextension_use_legacy
)
17817 static unsigned char *
17818 display_arm_attribute (unsigned char * p
,
17819 const unsigned char * const end
)
17823 arm_attr_public_tag
* attr
;
17827 READ_ULEB (tag
, p
, end
);
17829 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
17831 if (arm_attr_public_tags
[i
].tag
== tag
)
17833 attr
= &arm_attr_public_tags
[i
];
17840 printf (" Tag_%s: ", attr
->name
);
17841 switch (attr
->type
)
17846 case 7: /* Tag_CPU_arch_profile. */
17847 READ_ULEB (val
, p
, end
);
17850 case 0: printf (_("None\n")); break;
17851 case 'A': printf (_("Application\n")); break;
17852 case 'R': printf (_("Realtime\n")); break;
17853 case 'M': printf (_("Microcontroller\n")); break;
17854 case 'S': printf (_("Application or Realtime\n")); break;
17855 default: printf ("??? (%d)\n", val
); break;
17859 case 24: /* Tag_align_needed. */
17860 READ_ULEB (val
, p
, end
);
17863 case 0: printf (_("None\n")); break;
17864 case 1: printf (_("8-byte\n")); break;
17865 case 2: printf (_("4-byte\n")); break;
17866 case 3: printf ("??? 3\n"); break;
17869 printf (_("8-byte and up to %d-byte extended\n"),
17872 printf ("??? (%d)\n", val
);
17877 case 25: /* Tag_align_preserved. */
17878 READ_ULEB (val
, p
, end
);
17881 case 0: printf (_("None\n")); break;
17882 case 1: printf (_("8-byte, except leaf SP\n")); break;
17883 case 2: printf (_("8-byte\n")); break;
17884 case 3: printf ("??? 3\n"); break;
17887 printf (_("8-byte and up to %d-byte extended\n"),
17890 printf ("??? (%d)\n", val
);
17895 case 32: /* Tag_compatibility. */
17897 READ_ULEB (val
, p
, end
);
17898 printf (_("flag = %d, vendor = "), val
);
17901 size_t maxlen
= (end
- p
) - 1;
17903 print_symbol_name ((int) maxlen
, (const char *) p
);
17904 p
+= strnlen ((char *) p
, maxlen
) + 1;
17908 printf (_("<corrupt>"));
17909 p
= (unsigned char *) end
;
17915 case 64: /* Tag_nodefaults. */
17916 /* PR 17531: file: 001-505008-0.01. */
17919 printf (_("True\n"));
17922 case 65: /* Tag_also_compatible_with. */
17923 READ_ULEB (val
, p
, end
);
17924 if (val
== 6 /* Tag_CPU_arch. */)
17926 READ_ULEB (val
, p
, end
);
17927 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
17928 printf ("??? (%d)\n", val
);
17930 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
17934 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
17939 printf (_("<unknown: %d>\n"), tag
);
17945 return display_tag_value (-1, p
, end
);
17947 return display_tag_value (0, p
, end
);
17950 assert (attr
->type
& 0x80);
17951 READ_ULEB (val
, p
, end
);
17952 type
= attr
->type
& 0x7f;
17954 printf ("??? (%d)\n", val
);
17956 printf ("%s\n", attr
->table
[val
]);
17961 return display_tag_value (tag
, p
, end
);
17964 static unsigned char *
17965 display_gnu_attribute (unsigned char * p
,
17966 unsigned char * (* display_proc_gnu_attribute
)
17967 (unsigned char *, unsigned int, const unsigned char * const),
17968 const unsigned char * const end
)
17973 READ_ULEB (tag
, p
, end
);
17975 /* Tag_compatibility is the only generic GNU attribute defined at
17979 READ_ULEB (val
, p
, end
);
17981 printf (_("flag = %d, vendor = "), val
);
17984 printf (_("<corrupt>\n"));
17985 warn (_("corrupt vendor attribute\n"));
17991 size_t maxlen
= (end
- p
) - 1;
17993 print_symbol_name ((int) maxlen
, (const char *) p
);
17994 p
+= strnlen ((char *) p
, maxlen
) + 1;
17998 printf (_("<corrupt>"));
17999 p
= (unsigned char *) end
;
18006 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
18007 return display_proc_gnu_attribute (p
, tag
, end
);
18009 return display_tag_value (tag
, p
, end
);
18012 static unsigned char *
18013 display_m68k_gnu_attribute (unsigned char * p
,
18015 const unsigned char * const end
)
18019 if (tag
== Tag_GNU_M68K_ABI_FP
)
18021 printf (" Tag_GNU_M68K_ABI_FP: ");
18024 printf (_("<corrupt>\n"));
18027 READ_ULEB (val
, p
, end
);
18030 printf ("(%#x), ", val
);
18035 printf (_("unspecified hard/soft float\n"));
18038 printf (_("hard float\n"));
18041 printf (_("soft float\n"));
18047 return display_tag_value (tag
& 1, p
, end
);
18050 static unsigned char *
18051 display_power_gnu_attribute (unsigned char * p
,
18053 const unsigned char * const end
)
18057 if (tag
== Tag_GNU_Power_ABI_FP
)
18059 printf (" Tag_GNU_Power_ABI_FP: ");
18062 printf (_("<corrupt>\n"));
18065 READ_ULEB (val
, p
, end
);
18068 printf ("(%#x), ", val
);
18073 printf (_("unspecified hard/soft float, "));
18076 printf (_("hard float, "));
18079 printf (_("soft float, "));
18082 printf (_("single-precision hard float, "));
18089 printf (_("unspecified long double\n"));
18092 printf (_("128-bit IBM long double\n"));
18095 printf (_("64-bit long double\n"));
18098 printf (_("128-bit IEEE long double\n"));
18104 if (tag
== Tag_GNU_Power_ABI_Vector
)
18106 printf (" Tag_GNU_Power_ABI_Vector: ");
18109 printf (_("<corrupt>\n"));
18112 READ_ULEB (val
, p
, end
);
18115 printf ("(%#x), ", val
);
18120 printf (_("unspecified\n"));
18123 printf (_("generic\n"));
18126 printf ("AltiVec\n");
18135 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
18137 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
18140 printf (_("<corrupt>\n"));
18143 READ_ULEB (val
, p
, end
);
18146 printf ("(%#x), ", val
);
18151 printf (_("unspecified\n"));
18154 printf ("r3/r4\n");
18157 printf (_("memory\n"));
18166 return display_tag_value (tag
& 1, p
, end
);
18169 static unsigned char *
18170 display_s390_gnu_attribute (unsigned char * p
,
18172 const unsigned char * const end
)
18176 if (tag
== Tag_GNU_S390_ABI_Vector
)
18178 printf (" Tag_GNU_S390_ABI_Vector: ");
18179 READ_ULEB (val
, p
, end
);
18184 printf (_("any\n"));
18187 printf (_("software\n"));
18190 printf (_("hardware\n"));
18193 printf ("??? (%d)\n", val
);
18199 return display_tag_value (tag
& 1, p
, end
);
18203 display_sparc_hwcaps (unsigned int mask
)
18209 if (mask
& ELF_SPARC_HWCAP_MUL32
)
18210 fputs ("mul32", stdout
), first
= false;
18211 if (mask
& ELF_SPARC_HWCAP_DIV32
)
18212 printf ("%sdiv32", first
? "" : "|"), first
= false;
18213 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
18214 printf ("%sfsmuld", first
? "" : "|"), first
= false;
18215 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
18216 printf ("%sv8plus", first
? "" : "|"), first
= false;
18217 if (mask
& ELF_SPARC_HWCAP_POPC
)
18218 printf ("%spopc", first
? "" : "|"), first
= false;
18219 if (mask
& ELF_SPARC_HWCAP_VIS
)
18220 printf ("%svis", first
? "" : "|"), first
= false;
18221 if (mask
& ELF_SPARC_HWCAP_VIS2
)
18222 printf ("%svis2", first
? "" : "|"), first
= false;
18223 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
18224 printf ("%sASIBlkInit", first
? "" : "|"), first
= false;
18225 if (mask
& ELF_SPARC_HWCAP_FMAF
)
18226 printf ("%sfmaf", first
? "" : "|"), first
= false;
18227 if (mask
& ELF_SPARC_HWCAP_VIS3
)
18228 printf ("%svis3", first
? "" : "|"), first
= false;
18229 if (mask
& ELF_SPARC_HWCAP_HPC
)
18230 printf ("%shpc", first
? "" : "|"), first
= false;
18231 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
18232 printf ("%srandom", first
? "" : "|"), first
= false;
18233 if (mask
& ELF_SPARC_HWCAP_TRANS
)
18234 printf ("%strans", first
? "" : "|"), first
= false;
18235 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
18236 printf ("%sfjfmau", first
? "" : "|"), first
= false;
18237 if (mask
& ELF_SPARC_HWCAP_IMA
)
18238 printf ("%sima", first
? "" : "|"), first
= false;
18239 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
18240 printf ("%scspare", first
? "" : "|"), first
= false;
18243 fputc ('0', stdout
);
18244 fputc ('\n', stdout
);
18248 display_sparc_hwcaps2 (unsigned int mask
)
18254 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
18255 fputs ("fjathplus", stdout
), first
= false;
18256 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
18257 printf ("%svis3b", first
? "" : "|"), first
= false;
18258 if (mask
& ELF_SPARC_HWCAP2_ADP
)
18259 printf ("%sadp", first
? "" : "|"), first
= false;
18260 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
18261 printf ("%ssparc5", first
? "" : "|"), first
= false;
18262 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
18263 printf ("%smwait", first
? "" : "|"), first
= false;
18264 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
18265 printf ("%sxmpmul", first
? "" : "|"), first
= false;
18266 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
18267 printf ("%sxmont2", first
? "" : "|"), first
= false;
18268 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
18269 printf ("%snsec", first
? "" : "|"), first
= false;
18270 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
18271 printf ("%sfjathhpc", first
? "" : "|"), first
= false;
18272 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
18273 printf ("%sfjdes", first
? "" : "|"), first
= false;
18274 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
18275 printf ("%sfjaes", first
? "" : "|"), first
= false;
18278 fputc ('0', stdout
);
18279 fputc ('\n', stdout
);
18282 static unsigned char *
18283 display_sparc_gnu_attribute (unsigned char * p
,
18285 const unsigned char * const end
)
18289 if (tag
== Tag_GNU_Sparc_HWCAPS
)
18291 READ_ULEB (val
, p
, end
);
18292 printf (" Tag_GNU_Sparc_HWCAPS: ");
18293 display_sparc_hwcaps (val
);
18296 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
18298 READ_ULEB (val
, p
, end
);
18299 printf (" Tag_GNU_Sparc_HWCAPS2: ");
18300 display_sparc_hwcaps2 (val
);
18304 return display_tag_value (tag
, p
, end
);
18308 print_mips_fp_abi_value (unsigned int val
)
18312 case Val_GNU_MIPS_ABI_FP_ANY
:
18313 printf (_("Hard or soft float\n"));
18315 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
18316 printf (_("Hard float (double precision)\n"));
18318 case Val_GNU_MIPS_ABI_FP_SINGLE
:
18319 printf (_("Hard float (single precision)\n"));
18321 case Val_GNU_MIPS_ABI_FP_SOFT
:
18322 printf (_("Soft float\n"));
18324 case Val_GNU_MIPS_ABI_FP_OLD_64
:
18325 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
18327 case Val_GNU_MIPS_ABI_FP_XX
:
18328 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
18330 case Val_GNU_MIPS_ABI_FP_64
:
18331 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
18333 case Val_GNU_MIPS_ABI_FP_64A
:
18334 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
18336 case Val_GNU_MIPS_ABI_FP_NAN2008
:
18337 printf (_("NaN 2008 compatibility\n"));
18340 printf ("??? (%d)\n", val
);
18345 static unsigned char *
18346 display_mips_gnu_attribute (unsigned char * p
,
18348 const unsigned char * const end
)
18350 if (tag
== Tag_GNU_MIPS_ABI_FP
)
18354 printf (" Tag_GNU_MIPS_ABI_FP: ");
18355 READ_ULEB (val
, p
, end
);
18356 print_mips_fp_abi_value (val
);
18360 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
18364 printf (" Tag_GNU_MIPS_ABI_MSA: ");
18365 READ_ULEB (val
, p
, end
);
18369 case Val_GNU_MIPS_ABI_MSA_ANY
:
18370 printf (_("Any MSA or not\n"));
18372 case Val_GNU_MIPS_ABI_MSA_128
:
18373 printf (_("128-bit MSA\n"));
18376 printf ("??? (%d)\n", val
);
18382 return display_tag_value (tag
& 1, p
, end
);
18385 static unsigned char *
18386 display_tic6x_attribute (unsigned char * p
,
18387 const unsigned char * const end
)
18392 READ_ULEB (tag
, p
, end
);
18397 printf (" Tag_ISA: ");
18398 READ_ULEB (val
, p
, end
);
18402 case C6XABI_Tag_ISA_none
:
18403 printf (_("None\n"));
18405 case C6XABI_Tag_ISA_C62X
:
18408 case C6XABI_Tag_ISA_C67X
:
18411 case C6XABI_Tag_ISA_C67XP
:
18412 printf ("C67x+\n");
18414 case C6XABI_Tag_ISA_C64X
:
18417 case C6XABI_Tag_ISA_C64XP
:
18418 printf ("C64x+\n");
18420 case C6XABI_Tag_ISA_C674X
:
18421 printf ("C674x\n");
18424 printf ("??? (%d)\n", val
);
18429 case Tag_ABI_wchar_t
:
18430 printf (" Tag_ABI_wchar_t: ");
18431 READ_ULEB (val
, p
, end
);
18435 printf (_("Not used\n"));
18438 printf (_("2 bytes\n"));
18441 printf (_("4 bytes\n"));
18444 printf ("??? (%d)\n", val
);
18449 case Tag_ABI_stack_align_needed
:
18450 printf (" Tag_ABI_stack_align_needed: ");
18451 READ_ULEB (val
, p
, end
);
18455 printf (_("8-byte\n"));
18458 printf (_("16-byte\n"));
18461 printf ("??? (%d)\n", val
);
18466 case Tag_ABI_stack_align_preserved
:
18467 READ_ULEB (val
, p
, end
);
18468 printf (" Tag_ABI_stack_align_preserved: ");
18472 printf (_("8-byte\n"));
18475 printf (_("16-byte\n"));
18478 printf ("??? (%d)\n", val
);
18484 READ_ULEB (val
, p
, end
);
18485 printf (" Tag_ABI_DSBT: ");
18489 printf (_("DSBT addressing not used\n"));
18492 printf (_("DSBT addressing used\n"));
18495 printf ("??? (%d)\n", val
);
18501 READ_ULEB (val
, p
, end
);
18502 printf (" Tag_ABI_PID: ");
18506 printf (_("Data addressing position-dependent\n"));
18509 printf (_("Data addressing position-independent, GOT near DP\n"));
18512 printf (_("Data addressing position-independent, GOT far from DP\n"));
18515 printf ("??? (%d)\n", val
);
18521 READ_ULEB (val
, p
, end
);
18522 printf (" Tag_ABI_PIC: ");
18526 printf (_("Code addressing position-dependent\n"));
18529 printf (_("Code addressing position-independent\n"));
18532 printf ("??? (%d)\n", val
);
18537 case Tag_ABI_array_object_alignment
:
18538 READ_ULEB (val
, p
, end
);
18539 printf (" Tag_ABI_array_object_alignment: ");
18543 printf (_("8-byte\n"));
18546 printf (_("4-byte\n"));
18549 printf (_("16-byte\n"));
18552 printf ("??? (%d)\n", val
);
18557 case Tag_ABI_array_object_align_expected
:
18558 READ_ULEB (val
, p
, end
);
18559 printf (" Tag_ABI_array_object_align_expected: ");
18563 printf (_("8-byte\n"));
18566 printf (_("4-byte\n"));
18569 printf (_("16-byte\n"));
18572 printf ("??? (%d)\n", val
);
18577 case Tag_ABI_compatibility
:
18579 READ_ULEB (val
, p
, end
);
18580 printf (" Tag_ABI_compatibility: ");
18581 printf (_("flag = %d, vendor = "), val
);
18584 size_t maxlen
= (end
- p
) - 1;
18586 print_symbol_name ((int) maxlen
, (const char *) p
);
18587 p
+= strnlen ((char *) p
, maxlen
) + 1;
18591 printf (_("<corrupt>"));
18592 p
= (unsigned char *) end
;
18598 case Tag_ABI_conformance
:
18600 printf (" Tag_ABI_conformance: \"");
18603 size_t maxlen
= (end
- p
) - 1;
18605 print_symbol_name ((int) maxlen
, (const char *) p
);
18606 p
+= strnlen ((char *) p
, maxlen
) + 1;
18610 printf (_("<corrupt>"));
18611 p
= (unsigned char *) end
;
18618 return display_tag_value (tag
, p
, end
);
18622 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
18625 size_t bytes
= end
- p
;
18632 int lbytes
= (bytes
> 16 ? 16 : bytes
);
18634 printf (" 0x%8.8" PRIx64
" ", addr
);
18636 for (j
= 0; j
< 16; j
++)
18639 printf ("%2.2x", p
[j
]);
18647 for (j
= 0; j
< lbytes
; j
++)
18650 if (k
>= ' ' && k
< 0x7f)
18666 static unsigned char *
18667 display_msp430_attribute (unsigned char * p
,
18668 const unsigned char * const end
)
18673 READ_ULEB (tag
, p
, end
);
18677 case OFBA_MSPABI_Tag_ISA
:
18678 printf (" Tag_ISA: ");
18679 READ_ULEB (val
, p
, end
);
18682 case 0: printf (_("None\n")); break;
18683 case 1: printf (_("MSP430\n")); break;
18684 case 2: printf (_("MSP430X\n")); break;
18685 default: printf ("??? (%" PRId64
")\n", val
); break;
18689 case OFBA_MSPABI_Tag_Code_Model
:
18690 printf (" Tag_Code_Model: ");
18691 READ_ULEB (val
, p
, end
);
18694 case 0: printf (_("None\n")); break;
18695 case 1: printf (_("Small\n")); break;
18696 case 2: printf (_("Large\n")); break;
18697 default: printf ("??? (%" PRId64
")\n", val
); break;
18701 case OFBA_MSPABI_Tag_Data_Model
:
18702 printf (" Tag_Data_Model: ");
18703 READ_ULEB (val
, p
, end
);
18706 case 0: printf (_("None\n")); break;
18707 case 1: printf (_("Small\n")); break;
18708 case 2: printf (_("Large\n")); break;
18709 case 3: printf (_("Restricted Large\n")); break;
18710 default: printf ("??? (%" PRId64
")\n", val
); break;
18715 printf (_(" <unknown tag %" PRId64
">: "), tag
);
18722 size_t maxlen
= (end
- p
) - 1;
18724 print_symbol_name ((int) maxlen
, (const char *) p
);
18725 p
+= strnlen ((char *) p
, maxlen
) + 1;
18729 printf (_("<corrupt>"));
18730 p
= (unsigned char *) end
;
18736 READ_ULEB (val
, p
, end
);
18737 printf ("%" PRId64
" (0x%" PRIx64
")\n", val
, val
);
18746 static unsigned char *
18747 display_msp430_gnu_attribute (unsigned char * p
,
18749 const unsigned char * const end
)
18751 if (tag
== Tag_GNU_MSP430_Data_Region
)
18755 printf (" Tag_GNU_MSP430_Data_Region: ");
18756 READ_ULEB (val
, p
, end
);
18760 case Val_GNU_MSP430_Data_Region_Any
:
18761 printf (_("Any Region\n"));
18763 case Val_GNU_MSP430_Data_Region_Lower
:
18764 printf (_("Lower Region Only\n"));
18767 printf ("??? (%" PRIu64
")\n", val
);
18771 return display_tag_value (tag
& 1, p
, end
);
18774 struct riscv_attr_tag_t
{
18779 static struct riscv_attr_tag_t riscv_attr_tag
[] =
18781 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
18784 T(priv_spec_minor
),
18785 T(priv_spec_revision
),
18786 T(unaligned_access
),
18791 static unsigned char *
18792 display_riscv_attribute (unsigned char *p
,
18793 const unsigned char * const end
)
18797 struct riscv_attr_tag_t
*attr
= NULL
;
18800 READ_ULEB (tag
, p
, end
);
18802 /* Find the name of attribute. */
18803 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
18805 if (riscv_attr_tag
[i
].tag
== tag
)
18807 attr
= &riscv_attr_tag
[i
];
18813 printf (" %s: ", attr
->name
);
18815 return display_tag_value (tag
, p
, end
);
18819 case Tag_RISCV_priv_spec
:
18820 case Tag_RISCV_priv_spec_minor
:
18821 case Tag_RISCV_priv_spec_revision
:
18822 READ_ULEB (val
, p
, end
);
18823 printf ("%" PRIu64
"\n", val
);
18825 case Tag_RISCV_unaligned_access
:
18826 READ_ULEB (val
, p
, end
);
18830 printf (_("No unaligned access\n"));
18833 printf (_("Unaligned access\n"));
18837 case Tag_RISCV_stack_align
:
18838 READ_ULEB (val
, p
, end
);
18839 printf (_("%" PRIu64
"-bytes\n"), val
);
18841 case Tag_RISCV_arch
:
18842 p
= display_tag_value (-1, p
, end
);
18845 return display_tag_value (tag
, p
, end
);
18851 static unsigned char *
18852 display_csky_attribute (unsigned char * p
,
18853 const unsigned char * const end
)
18857 READ_ULEB (tag
, p
, end
);
18859 if (tag
>= Tag_CSKY_MAX
)
18861 return display_tag_value (-1, p
, end
);
18866 case Tag_CSKY_ARCH_NAME
:
18867 printf (" Tag_CSKY_ARCH_NAME:\t\t");
18868 return display_tag_value (-1, p
, end
);
18869 case Tag_CSKY_CPU_NAME
:
18870 printf (" Tag_CSKY_CPU_NAME:\t\t");
18871 return display_tag_value (-1, p
, end
);
18873 case Tag_CSKY_ISA_FLAGS
:
18874 printf (" Tag_CSKY_ISA_FLAGS:\t\t");
18875 return display_tag_value (0, p
, end
);
18876 case Tag_CSKY_ISA_EXT_FLAGS
:
18877 printf (" Tag_CSKY_ISA_EXT_FLAGS:\t");
18878 return display_tag_value (0, p
, end
);
18880 case Tag_CSKY_DSP_VERSION
:
18881 printf (" Tag_CSKY_DSP_VERSION:\t\t");
18882 READ_ULEB (val
, p
, end
);
18883 if (val
== VAL_CSKY_DSP_VERSION_EXTENSION
)
18884 printf ("DSP Extension\n");
18885 else if (val
== VAL_CSKY_DSP_VERSION_2
)
18886 printf ("DSP 2.0\n");
18889 case Tag_CSKY_VDSP_VERSION
:
18890 printf (" Tag_CSKY_VDSP_VERSION:\t");
18891 READ_ULEB (val
, p
, end
);
18892 printf ("VDSP Version %" PRId64
"\n", val
);
18895 case Tag_CSKY_FPU_VERSION
:
18896 printf (" Tag_CSKY_FPU_VERSION:\t\t");
18897 READ_ULEB (val
, p
, end
);
18898 if (val
== VAL_CSKY_FPU_VERSION_1
)
18899 printf ("ABIV1 FPU Version 1\n");
18900 else if (val
== VAL_CSKY_FPU_VERSION_2
)
18901 printf ("FPU Version 2\n");
18904 case Tag_CSKY_FPU_ABI
:
18905 printf (" Tag_CSKY_FPU_ABI:\t\t");
18906 READ_ULEB (val
, p
, end
);
18907 if (val
== VAL_CSKY_FPU_ABI_HARD
)
18909 else if (val
== VAL_CSKY_FPU_ABI_SOFTFP
)
18910 printf ("SoftFP\n");
18911 else if (val
== VAL_CSKY_FPU_ABI_SOFT
)
18914 case Tag_CSKY_FPU_ROUNDING
:
18915 READ_ULEB (val
, p
, end
);
18918 printf (" Tag_CSKY_FPU_ROUNDING:\t");
18919 printf ("Needed\n");
18922 case Tag_CSKY_FPU_DENORMAL
:
18923 READ_ULEB (val
, p
, end
);
18926 printf (" Tag_CSKY_FPU_DENORMAL:\t");
18927 printf ("Needed\n");
18930 case Tag_CSKY_FPU_Exception
:
18931 READ_ULEB (val
, p
, end
);
18934 printf (" Tag_CSKY_FPU_Exception:\t");
18935 printf ("Needed\n");
18938 case Tag_CSKY_FPU_NUMBER_MODULE
:
18939 printf (" Tag_CSKY_FPU_NUMBER_MODULE:\t");
18940 return display_tag_value (-1, p
, end
);
18941 case Tag_CSKY_FPU_HARDFP
:
18942 printf (" Tag_CSKY_FPU_HARDFP:\t\t");
18943 READ_ULEB (val
, p
, end
);
18944 if (val
& VAL_CSKY_FPU_HARDFP_HALF
)
18946 if (val
& VAL_CSKY_FPU_HARDFP_SINGLE
)
18947 printf (" Single");
18948 if (val
& VAL_CSKY_FPU_HARDFP_DOUBLE
)
18949 printf (" Double");
18953 return display_tag_value (tag
, p
, end
);
18959 process_attributes (Filedata
* filedata
,
18960 const char * public_name
,
18961 unsigned int proc_type
,
18962 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
18963 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
18965 Elf_Internal_Shdr
* sect
;
18969 /* Find the section header so that we get the size. */
18970 for (i
= 0, sect
= filedata
->section_headers
;
18971 i
< filedata
->file_header
.e_shnum
;
18974 unsigned char * contents
;
18977 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
18980 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
18981 sect
->sh_size
, _("attributes"));
18982 if (contents
== NULL
)
18989 /* The first character is the version of the attributes.
18990 Currently only version 1, (aka 'A') is recognised here. */
18993 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
18998 uint64_t section_len
;
19000 section_len
= sect
->sh_size
- 1;
19003 while (section_len
> 0)
19006 unsigned int namelen
;
19007 bool public_section
;
19010 if (section_len
<= 4)
19012 error (_("Tag section ends prematurely\n"));
19016 attr_len
= byte_get (p
, 4);
19019 if (attr_len
> section_len
)
19021 error (_("Bad attribute length (%u > %u)\n"),
19022 (unsigned) attr_len
, (unsigned) section_len
);
19023 attr_len
= section_len
;
19026 /* PR 17531: file: 001-101425-0.004 */
19027 else if (attr_len
< 5)
19029 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
19034 section_len
-= attr_len
;
19037 namelen
= strnlen ((char *) p
, attr_len
) + 1;
19038 if (namelen
== 0 || namelen
>= attr_len
)
19040 error (_("Corrupt attribute section name\n"));
19045 printf (_("Attribute Section: "));
19046 print_symbol_name (INT_MAX
, (const char *) p
);
19049 if (public_name
&& streq ((char *) p
, public_name
))
19050 public_section
= true;
19052 public_section
= false;
19054 if (streq ((char *) p
, "gnu"))
19055 gnu_section
= true;
19057 gnu_section
= false;
19060 attr_len
-= namelen
;
19062 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
19067 unsigned char * end
;
19069 /* PR binutils/17531: Safe handling of corrupt files. */
19072 error (_("Unused bytes at end of section\n"));
19079 size
= byte_get (p
, 4);
19080 if (size
> attr_len
)
19082 error (_("Bad subsection length (%u > %u)\n"),
19083 (unsigned) size
, (unsigned) attr_len
);
19087 /* PR binutils/17531: Safe handling of corrupt files. */
19090 error (_("Bad subsection length (%u < 6)\n"),
19098 end
= p
+ size
- 1;
19099 assert (end
<= contents
+ sect
->sh_size
);
19105 printf (_("File Attributes\n"));
19108 printf (_("Section Attributes:"));
19111 printf (_("Symbol Attributes:"));
19112 /* Fall through. */
19116 READ_ULEB (val
, p
, end
);
19119 printf (" %d", val
);
19124 printf (_("Unknown tag: %d\n"), tag
);
19125 public_section
= false;
19129 if (public_section
&& display_pub_attribute
!= NULL
)
19132 p
= display_pub_attribute (p
, end
);
19135 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
19138 p
= display_gnu_attribute (p
,
19139 display_proc_gnu_attribute
,
19145 printf (_(" Unknown attribute:\n"));
19146 display_raw_attribute (p
, end
);
19161 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
19162 Print the Address, Access and Initial fields of an entry at VMA ADDR
19163 and return the VMA of the next entry, or -1 if there was a problem.
19164 Does not read from DATA_END or beyond. */
19167 print_mips_got_entry (unsigned char * data
, uint64_t pltgot
, uint64_t addr
,
19168 unsigned char * data_end
)
19171 print_vma (addr
, LONG_HEX
);
19173 if (addr
< pltgot
+ 0xfff0)
19174 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
19176 printf ("%10s", "");
19179 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
19183 unsigned char * from
= data
+ addr
- pltgot
;
19185 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
19187 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
19188 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
19189 return (uint64_t) -1;
19193 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
19194 print_vma (entry
, LONG_HEX
);
19197 return addr
+ (is_32bit_elf
? 4 : 8);
19200 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
19201 PLTGOT. Print the Address and Initial fields of an entry at VMA
19202 ADDR and return the VMA of the next entry. */
19205 print_mips_pltgot_entry (unsigned char * data
, uint64_t pltgot
, uint64_t addr
)
19208 print_vma (addr
, LONG_HEX
);
19211 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
19216 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
19217 print_vma (entry
, LONG_HEX
);
19219 return addr
+ (is_32bit_elf
? 4 : 8);
19223 print_mips_ases (unsigned int mask
)
19225 if (mask
& AFL_ASE_DSP
)
19226 fputs ("\n\tDSP ASE", stdout
);
19227 if (mask
& AFL_ASE_DSPR2
)
19228 fputs ("\n\tDSP R2 ASE", stdout
);
19229 if (mask
& AFL_ASE_DSPR3
)
19230 fputs ("\n\tDSP R3 ASE", stdout
);
19231 if (mask
& AFL_ASE_EVA
)
19232 fputs ("\n\tEnhanced VA Scheme", stdout
);
19233 if (mask
& AFL_ASE_MCU
)
19234 fputs ("\n\tMCU (MicroController) ASE", stdout
);
19235 if (mask
& AFL_ASE_MDMX
)
19236 fputs ("\n\tMDMX ASE", stdout
);
19237 if (mask
& AFL_ASE_MIPS3D
)
19238 fputs ("\n\tMIPS-3D ASE", stdout
);
19239 if (mask
& AFL_ASE_MT
)
19240 fputs ("\n\tMT ASE", stdout
);
19241 if (mask
& AFL_ASE_SMARTMIPS
)
19242 fputs ("\n\tSmartMIPS ASE", stdout
);
19243 if (mask
& AFL_ASE_VIRT
)
19244 fputs ("\n\tVZ ASE", stdout
);
19245 if (mask
& AFL_ASE_MSA
)
19246 fputs ("\n\tMSA ASE", stdout
);
19247 if (mask
& AFL_ASE_MIPS16
)
19248 fputs ("\n\tMIPS16 ASE", stdout
);
19249 if (mask
& AFL_ASE_MICROMIPS
)
19250 fputs ("\n\tMICROMIPS ASE", stdout
);
19251 if (mask
& AFL_ASE_XPA
)
19252 fputs ("\n\tXPA ASE", stdout
);
19253 if (mask
& AFL_ASE_MIPS16E2
)
19254 fputs ("\n\tMIPS16e2 ASE", stdout
);
19255 if (mask
& AFL_ASE_CRC
)
19256 fputs ("\n\tCRC ASE", stdout
);
19257 if (mask
& AFL_ASE_GINV
)
19258 fputs ("\n\tGINV ASE", stdout
);
19259 if (mask
& AFL_ASE_LOONGSON_MMI
)
19260 fputs ("\n\tLoongson MMI ASE", stdout
);
19261 if (mask
& AFL_ASE_LOONGSON_CAM
)
19262 fputs ("\n\tLoongson CAM ASE", stdout
);
19263 if (mask
& AFL_ASE_LOONGSON_EXT
)
19264 fputs ("\n\tLoongson EXT ASE", stdout
);
19265 if (mask
& AFL_ASE_LOONGSON_EXT2
)
19266 fputs ("\n\tLoongson EXT2 ASE", stdout
);
19268 fprintf (stdout
, "\n\t%s", _("None"));
19269 else if ((mask
& ~AFL_ASE_MASK
) != 0)
19270 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
19274 print_mips_isa_ext (unsigned int isa_ext
)
19279 fputs (_("None"), stdout
);
19282 fputs ("RMI XLR", stdout
);
19284 case AFL_EXT_OCTEON3
:
19285 fputs ("Cavium Networks Octeon3", stdout
);
19287 case AFL_EXT_OCTEON2
:
19288 fputs ("Cavium Networks Octeon2", stdout
);
19290 case AFL_EXT_OCTEONP
:
19291 fputs ("Cavium Networks OcteonP", stdout
);
19293 case AFL_EXT_OCTEON
:
19294 fputs ("Cavium Networks Octeon", stdout
);
19297 fputs ("Toshiba R5900", stdout
);
19300 fputs ("MIPS R4650", stdout
);
19303 fputs ("LSI R4010", stdout
);
19306 fputs ("NEC VR4100", stdout
);
19309 fputs ("Toshiba R3900", stdout
);
19311 case AFL_EXT_10000
:
19312 fputs ("MIPS R10000", stdout
);
19315 fputs ("Broadcom SB-1", stdout
);
19318 fputs ("NEC VR4111/VR4181", stdout
);
19321 fputs ("NEC VR4120", stdout
);
19324 fputs ("NEC VR5400", stdout
);
19327 fputs ("NEC VR5500", stdout
);
19329 case AFL_EXT_LOONGSON_2E
:
19330 fputs ("ST Microelectronics Loongson 2E", stdout
);
19332 case AFL_EXT_LOONGSON_2F
:
19333 fputs ("ST Microelectronics Loongson 2F", stdout
);
19335 case AFL_EXT_INTERAPTIV_MR2
:
19336 fputs ("Imagination interAptiv MR2", stdout
);
19339 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
19344 get_mips_reg_size (int reg_size
)
19346 return (reg_size
== AFL_REG_NONE
) ? 0
19347 : (reg_size
== AFL_REG_32
) ? 32
19348 : (reg_size
== AFL_REG_64
) ? 64
19349 : (reg_size
== AFL_REG_128
) ? 128
19354 process_mips_specific (Filedata
* filedata
)
19356 Elf_Internal_Dyn
* entry
;
19357 Elf_Internal_Shdr
*sect
= NULL
;
19358 size_t liblist_offset
= 0;
19359 size_t liblistno
= 0;
19360 size_t conflictsno
= 0;
19361 size_t options_offset
= 0;
19362 size_t conflicts_offset
= 0;
19363 size_t pltrelsz
= 0;
19365 uint64_t pltgot
= 0;
19366 uint64_t mips_pltgot
= 0;
19367 uint64_t jmprel
= 0;
19368 uint64_t local_gotno
= 0;
19369 uint64_t gotsym
= 0;
19370 uint64_t symtabno
= 0;
19373 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19374 display_mips_gnu_attribute
))
19377 sect
= find_section (filedata
, ".MIPS.abiflags");
19381 Elf_External_ABIFlags_v0
*abiflags_ext
;
19382 Elf_Internal_ABIFlags_v0 abiflags_in
;
19384 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
19386 error (_("Corrupt MIPS ABI Flags section.\n"));
19391 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
19392 sect
->sh_size
, _("MIPS ABI Flags section"));
19395 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
19396 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
19397 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
19398 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
19399 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
19400 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
19401 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
19402 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
19403 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
19404 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
19405 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
19407 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
19408 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
19409 if (abiflags_in
.isa_rev
> 1)
19410 printf ("r%d", abiflags_in
.isa_rev
);
19411 printf ("\nGPR size: %d",
19412 get_mips_reg_size (abiflags_in
.gpr_size
));
19413 printf ("\nCPR1 size: %d",
19414 get_mips_reg_size (abiflags_in
.cpr1_size
));
19415 printf ("\nCPR2 size: %d",
19416 get_mips_reg_size (abiflags_in
.cpr2_size
));
19417 fputs ("\nFP ABI: ", stdout
);
19418 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
19419 fputs ("ISA Extension: ", stdout
);
19420 print_mips_isa_ext (abiflags_in
.isa_ext
);
19421 fputs ("\nASEs:", stdout
);
19422 print_mips_ases (abiflags_in
.ases
);
19423 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
19424 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
19425 fputc ('\n', stdout
);
19426 free (abiflags_ext
);
19431 /* We have a lot of special sections. Thanks SGI! */
19432 if (filedata
->dynamic_section
== NULL
)
19434 /* No dynamic information available. See if there is static GOT. */
19435 sect
= find_section (filedata
, ".got");
19438 unsigned char *data_end
;
19439 unsigned char *data
;
19443 pltgot
= sect
->sh_addr
;
19446 addr_size
= (is_32bit_elf
? 4 : 8);
19447 end
= pltgot
+ sect
->sh_size
;
19449 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
19451 _("Global Offset Table data"));
19452 /* PR 12855: Null data is handled gracefully throughout. */
19453 data_end
= data
+ (end
- pltgot
);
19455 printf (_("\nStatic GOT:\n"));
19456 printf (_(" Canonical gp value: "));
19457 print_vma (ent
+ 0x7ff0, LONG_HEX
);
19460 /* In a dynamic binary GOT[0] is reserved for the dynamic
19461 loader to store the lazy resolver pointer, however in
19462 a static binary it may well have been omitted and GOT
19463 reduced to a table of addresses.
19464 PR 21344: Check for the entry being fully available
19465 before fetching it. */
19467 && data
+ ent
- pltgot
+ addr_size
<= data_end
19468 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
19470 printf (_(" Reserved entries:\n"));
19471 printf (_(" %*s %10s %*s\n"),
19472 addr_size
* 2, _("Address"), _("Access"),
19473 addr_size
* 2, _("Value"));
19474 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19476 if (ent
== (uint64_t) -1)
19477 goto sgot_print_fail
;
19479 /* Check for the MSB of GOT[1] being set, identifying a
19480 GNU object. This entry will be used by some runtime
19481 loaders, to store the module pointer. Otherwise this
19482 is an ordinary local entry.
19483 PR 21344: Check for the entry being fully available
19484 before fetching it. */
19486 && data
+ ent
- pltgot
+ addr_size
<= data_end
19487 && (byte_get (data
+ ent
- pltgot
, addr_size
)
19488 >> (addr_size
* 8 - 1)) != 0)
19490 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19492 if (ent
== (uint64_t) -1)
19493 goto sgot_print_fail
;
19498 if (data
!= NULL
&& ent
< end
)
19500 printf (_(" Local entries:\n"));
19501 printf (" %*s %10s %*s\n",
19502 addr_size
* 2, _("Address"), _("Access"),
19503 addr_size
* 2, _("Value"));
19506 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19508 if (ent
== (uint64_t) -1)
19509 goto sgot_print_fail
;
19520 for (entry
= filedata
->dynamic_section
;
19521 /* PR 17531 file: 012-50589-0.004. */
19522 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
19523 && entry
->d_tag
!= DT_NULL
);
19525 switch (entry
->d_tag
)
19527 case DT_MIPS_LIBLIST
:
19529 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
19530 liblistno
* sizeof (Elf32_External_Lib
));
19532 case DT_MIPS_LIBLISTNO
:
19533 liblistno
= entry
->d_un
.d_val
;
19535 case DT_MIPS_OPTIONS
:
19536 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
19538 case DT_MIPS_CONFLICT
:
19540 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
19541 conflictsno
* sizeof (Elf32_External_Conflict
));
19543 case DT_MIPS_CONFLICTNO
:
19544 conflictsno
= entry
->d_un
.d_val
;
19547 pltgot
= entry
->d_un
.d_ptr
;
19549 case DT_MIPS_LOCAL_GOTNO
:
19550 local_gotno
= entry
->d_un
.d_val
;
19552 case DT_MIPS_GOTSYM
:
19553 gotsym
= entry
->d_un
.d_val
;
19555 case DT_MIPS_SYMTABNO
:
19556 symtabno
= entry
->d_un
.d_val
;
19558 case DT_MIPS_PLTGOT
:
19559 mips_pltgot
= entry
->d_un
.d_ptr
;
19562 pltrel
= entry
->d_un
.d_val
;
19565 pltrelsz
= entry
->d_un
.d_val
;
19568 jmprel
= entry
->d_un
.d_ptr
;
19574 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
19576 Elf32_External_Lib
* elib
;
19579 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
19580 sizeof (Elf32_External_Lib
),
19582 _("liblist section data"));
19585 printf (ngettext ("\nSection '.liblist' contains %zu entry:\n",
19586 "\nSection '.liblist' contains %zu entries:\n",
19589 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
19592 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
19599 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
19600 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
19601 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
19602 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
19603 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
19605 tmp
= gmtime (&atime
);
19606 snprintf (timebuf
, sizeof (timebuf
),
19607 "%04u-%02u-%02uT%02u:%02u:%02u",
19608 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
19609 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
19611 printf ("%3zu: ", cnt
);
19612 if (valid_dynamic_name (filedata
, liblist
.l_name
))
19613 print_symbol_name (20, get_dynamic_name (filedata
, liblist
.l_name
));
19615 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
19616 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
19617 liblist
.l_version
);
19619 if (liblist
.l_flags
== 0)
19623 static const struct
19630 { " EXACT_MATCH", LL_EXACT_MATCH
},
19631 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
19632 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
19633 { " EXPORTS", LL_EXPORTS
},
19634 { " DELAY_LOAD", LL_DELAY_LOAD
},
19635 { " DELTA", LL_DELTA
}
19637 int flags
= liblist
.l_flags
;
19640 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
19641 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
19643 fputs (l_flags_vals
[fcnt
].name
, stdout
);
19644 flags
^= l_flags_vals
[fcnt
].bit
;
19647 printf (" %#x", (unsigned int) flags
);
19659 if (options_offset
!= 0)
19661 Elf_External_Options
* eopt
;
19665 /* Find the section header so that we get the size. */
19666 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
19667 /* PR 17533 file: 012-277276-0.004. */
19670 error (_("No MIPS_OPTIONS header found\n"));
19674 if (sect
->sh_size
< sizeof (* eopt
))
19676 error (_("The MIPS options section is too small.\n"));
19680 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
19681 sect
->sh_size
, _("options"));
19684 Elf_Internal_Options option
;
19687 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
19689 Elf_External_Options
* eoption
;
19690 unsigned int optsize
;
19692 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
19694 optsize
= BYTE_GET (eoption
->size
);
19696 /* PR 17531: file: ffa0fa3b. */
19697 if (optsize
< sizeof (* eopt
)
19698 || optsize
> sect
->sh_size
- offset
)
19700 error (_("Invalid size (%u) for MIPS option\n"),
19709 printf (ngettext ("\nSection '%s' contains %d entry:\n",
19710 "\nSection '%s' contains %d entries:\n",
19712 printable_section_name (filedata
, sect
), cnt
);
19718 Elf_External_Options
* eoption
;
19720 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
19722 option
.kind
= BYTE_GET (eoption
->kind
);
19723 option
.size
= BYTE_GET (eoption
->size
);
19724 option
.section
= BYTE_GET (eoption
->section
);
19725 option
.info
= BYTE_GET (eoption
->info
);
19727 switch (option
.kind
)
19730 /* This shouldn't happen. */
19731 printf (" NULL %" PRId16
" %" PRIx32
,
19732 option
.section
, option
.info
);
19736 printf (" REGINFO ");
19737 if (filedata
->file_header
.e_machine
== EM_MIPS
)
19739 Elf32_External_RegInfo
* ereg
;
19740 Elf32_RegInfo reginfo
;
19743 if (option
.size
< (sizeof (Elf_External_Options
)
19744 + sizeof (Elf32_External_RegInfo
)))
19746 printf (_("<corrupt>\n"));
19747 error (_("Truncated MIPS REGINFO option\n"));
19752 ereg
= (Elf32_External_RegInfo
*) (eoption
+ 1);
19754 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
19755 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
19756 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
19757 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
19758 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
19759 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
19761 printf ("GPR %08" PRIx32
" GP 0x%" PRIx32
"\n",
19762 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
19764 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
19765 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
19766 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
19767 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
19772 Elf64_External_RegInfo
* ereg
;
19773 Elf64_Internal_RegInfo reginfo
;
19775 if (option
.size
< (sizeof (Elf_External_Options
)
19776 + sizeof (Elf64_External_RegInfo
)))
19778 printf (_("<corrupt>\n"));
19779 error (_("Truncated MIPS REGINFO option\n"));
19784 ereg
= (Elf64_External_RegInfo
*) (eoption
+ 1);
19785 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
19786 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
19787 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
19788 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
19789 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
19790 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
19792 printf ("GPR %08" PRIx32
" GP 0x%" PRIx64
"\n",
19793 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
19795 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
19796 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
19797 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
19798 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
19800 offset
+= option
.size
;
19803 case ODK_EXCEPTIONS
:
19804 fputs (" EXCEPTIONS fpe_min(", stdout
);
19805 process_mips_fpe_exception (option
.info
& OEX_FPU_MIN
);
19806 fputs (") fpe_max(", stdout
);
19807 process_mips_fpe_exception ((option
.info
& OEX_FPU_MAX
) >> 8);
19808 fputs (")", stdout
);
19810 if (option
.info
& OEX_PAGE0
)
19811 fputs (" PAGE0", stdout
);
19812 if (option
.info
& OEX_SMM
)
19813 fputs (" SMM", stdout
);
19814 if (option
.info
& OEX_FPDBUG
)
19815 fputs (" FPDBUG", stdout
);
19816 if (option
.info
& OEX_DISMISS
)
19817 fputs (" DISMISS", stdout
);
19821 fputs (" PAD ", stdout
);
19822 if (option
.info
& OPAD_PREFIX
)
19823 fputs (" PREFIX", stdout
);
19824 if (option
.info
& OPAD_POSTFIX
)
19825 fputs (" POSTFIX", stdout
);
19826 if (option
.info
& OPAD_SYMBOL
)
19827 fputs (" SYMBOL", stdout
);
19831 fputs (" HWPATCH ", stdout
);
19832 if (option
.info
& OHW_R4KEOP
)
19833 fputs (" R4KEOP", stdout
);
19834 if (option
.info
& OHW_R8KPFETCH
)
19835 fputs (" R8KPFETCH", stdout
);
19836 if (option
.info
& OHW_R5KEOP
)
19837 fputs (" R5KEOP", stdout
);
19838 if (option
.info
& OHW_R5KCVTL
)
19839 fputs (" R5KCVTL", stdout
);
19843 fputs (" FILL ", stdout
);
19844 /* XXX Print content of info word? */
19848 fputs (" TAGS ", stdout
);
19849 /* XXX Print content of info word? */
19853 fputs (" HWAND ", stdout
);
19854 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
19855 fputs (" R4KEOP_CHECKED", stdout
);
19856 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
19857 fputs (" R4KEOP_CLEAN", stdout
);
19861 fputs (" HWOR ", stdout
);
19862 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
19863 fputs (" R4KEOP_CHECKED", stdout
);
19864 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
19865 fputs (" R4KEOP_CLEAN", stdout
);
19869 printf (" GP_GROUP %#06x self-contained %#06x",
19870 option
.info
& OGP_GROUP
,
19871 (option
.info
& OGP_SELF
) >> 16);
19875 printf (" IDENT %#06x self-contained %#06x",
19876 option
.info
& OGP_GROUP
,
19877 (option
.info
& OGP_SELF
) >> 16);
19881 /* This shouldn't happen. */
19882 printf (" %3d ??? %" PRId16
" %" PRIx32
,
19883 option
.kind
, option
.section
, option
.info
);
19887 len
= sizeof (* eopt
);
19888 while (len
< option
.size
)
19890 unsigned char datum
= *((unsigned char *) eoption
+ len
);
19892 if (ISPRINT (datum
))
19893 printf ("%c", datum
);
19895 printf ("\\%03o", datum
);
19898 fputs ("\n", stdout
);
19900 offset
+= option
.size
;
19908 if (conflicts_offset
!= 0 && conflictsno
!= 0)
19910 Elf32_Conflict
* iconf
;
19913 if (filedata
->dynamic_symbols
== NULL
)
19915 error (_("conflict list found without a dynamic symbol table\n"));
19919 /* PR 21345 - print a slightly more helpful error message
19920 if we are sure that the cmalloc will fail. */
19921 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
19923 error (_("Overlarge number of conflicts detected: %zx\n"),
19928 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
19931 error (_("Out of memory allocating space for dynamic conflicts\n"));
19937 Elf32_External_Conflict
* econf32
;
19939 econf32
= (Elf32_External_Conflict
*)
19940 get_data (NULL
, filedata
, conflicts_offset
,
19941 sizeof (*econf32
), conflictsno
, _("conflict"));
19948 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
19949 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
19955 Elf64_External_Conflict
* econf64
;
19957 econf64
= (Elf64_External_Conflict
*)
19958 get_data (NULL
, filedata
, conflicts_offset
,
19959 sizeof (*econf64
), conflictsno
, _("conflict"));
19966 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
19967 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
19972 printf (ngettext ("\nSection '.conflict' contains %zu entry:\n",
19973 "\nSection '.conflict' contains %zu entries:\n",
19976 puts (_(" Num: Index Value Name"));
19978 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
19980 printf ("%5zu: %8lu ", cnt
, iconf
[cnt
]);
19982 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
19983 printf (_("<corrupt symbol index>"));
19986 Elf_Internal_Sym
* psym
;
19988 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
19989 print_vma (psym
->st_value
, FULL_HEX
);
19991 if (valid_dynamic_name (filedata
, psym
->st_name
))
19992 print_symbol_name (25, get_dynamic_name (filedata
, psym
->st_name
));
19994 printf (_("<corrupt: %14ld>"), psym
->st_name
);
20002 if (pltgot
!= 0 && local_gotno
!= 0)
20004 uint64_t ent
, local_end
, global_end
;
20006 unsigned char * data
;
20007 unsigned char * data_end
;
20011 addr_size
= (is_32bit_elf
? 4 : 8);
20012 local_end
= pltgot
+ local_gotno
* addr_size
;
20014 /* PR binutils/17533 file: 012-111227-0.004 */
20015 if (symtabno
< gotsym
)
20017 error (_("The GOT symbol offset (%" PRIu64
20018 ") is greater than the symbol table size (%" PRIu64
")\n"),
20023 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
20024 /* PR 17531: file: 54c91a34. */
20025 if (global_end
< local_end
)
20027 error (_("Too many GOT symbols: %" PRIu64
"\n"), symtabno
);
20031 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
20032 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
20033 global_end
- pltgot
, 1,
20034 _("Global Offset Table data"));
20035 /* PR 12855: Null data is handled gracefully throughout. */
20036 data_end
= data
+ (global_end
- pltgot
);
20038 printf (_("\nPrimary GOT:\n"));
20039 printf (_(" Canonical gp value: "));
20040 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
20043 printf (_(" Reserved entries:\n"));
20044 printf (_(" %*s %10s %*s Purpose\n"),
20045 addr_size
* 2, _("Address"), _("Access"),
20046 addr_size
* 2, _("Initial"));
20047 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
20048 printf (_(" Lazy resolver\n"));
20049 if (ent
== (uint64_t) -1)
20050 goto got_print_fail
;
20052 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
20053 This entry will be used by some runtime loaders, to store the
20054 module pointer. Otherwise this is an ordinary local entry.
20055 PR 21344: Check for the entry being fully available before
20058 && data
+ ent
- pltgot
+ addr_size
<= data_end
20059 && (byte_get (data
+ ent
- pltgot
, addr_size
)
20060 >> (addr_size
* 8 - 1)) != 0)
20062 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
20063 printf (_(" Module pointer (GNU extension)\n"));
20064 if (ent
== (uint64_t) -1)
20065 goto got_print_fail
;
20069 if (data
!= NULL
&& ent
< local_end
)
20071 printf (_(" Local entries:\n"));
20072 printf (" %*s %10s %*s\n",
20073 addr_size
* 2, _("Address"), _("Access"),
20074 addr_size
* 2, _("Initial"));
20075 while (ent
< local_end
)
20077 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
20079 if (ent
== (uint64_t) -1)
20080 goto got_print_fail
;
20085 if (data
!= NULL
&& gotsym
< symtabno
)
20089 printf (_(" Global entries:\n"));
20090 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
20091 addr_size
* 2, _("Address"),
20093 addr_size
* 2, _("Initial"),
20094 addr_size
* 2, _("Sym.Val."),
20096 /* Note for translators: "Ndx" = abbreviated form of "Index". */
20097 _("Ndx"), _("Name"));
20099 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
20101 for (i
= gotsym
; i
< symtabno
; i
++)
20103 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
20106 if (filedata
->dynamic_symbols
== NULL
)
20107 printf (_("<no dynamic symbols>"));
20108 else if (i
< filedata
->num_dynamic_syms
)
20110 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
20112 print_vma (psym
->st_value
, LONG_HEX
);
20113 printf (" %-7s ", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
20116 const char * s
= printable_section_name_from_index (filedata
, psym
->st_shndx
, & is_special
);
20118 printf ("%3s ", s
);
20120 printf ("%3u ", psym
->st_shndx
);
20122 if (valid_dynamic_name (filedata
, psym
->st_name
))
20123 print_symbol_name (sym_width
,
20124 get_dynamic_name (filedata
, psym
->st_name
));
20126 printf (_("<corrupt: %14ld>"), psym
->st_name
);
20129 printf (_("<symbol index %zu exceeds number of dynamic symbols>"),
20133 if (ent
== (uint64_t) -1)
20143 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
20146 uint64_t offset
, rel_offset
;
20148 unsigned char * data
;
20149 int addr_size
, sym_width
;
20150 Elf_Internal_Rela
* rels
;
20152 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
20153 if (pltrel
== DT_RELA
)
20155 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
20160 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
20165 addr_size
= (is_32bit_elf
? 4 : 8);
20166 end
= mips_pltgot
+ (2 + count
) * addr_size
;
20168 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
20169 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
20170 1, _("Procedure Linkage Table data"));
20177 printf ("\nPLT GOT:\n\n");
20178 printf (_(" Reserved entries:\n"));
20179 printf (_(" %*s %*s Purpose\n"),
20180 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
20181 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
20182 printf (_(" PLT lazy resolver\n"));
20183 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
20184 printf (_(" Module pointer\n"));
20187 printf (_(" Entries:\n"));
20188 printf (" %*s %*s %*s %-7s %3s %s\n",
20189 addr_size
* 2, _("Address"),
20190 addr_size
* 2, _("Initial"),
20191 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
20192 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
20193 for (i
= 0; i
< count
; i
++)
20195 uint64_t idx
= get_reloc_symindex (rels
[i
].r_info
);
20197 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
20200 if (idx
>= filedata
->num_dynamic_syms
)
20201 printf (_("<corrupt symbol index: %" PRIu64
">"), idx
);
20204 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
20206 print_vma (psym
->st_value
, LONG_HEX
);
20207 printf (" %-7s %3s ",
20208 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
20209 printable_section_name_from_index (filedata
, psym
->st_shndx
, NULL
));
20210 if (valid_dynamic_name (filedata
, psym
->st_name
))
20211 print_symbol_name (sym_width
,
20212 get_dynamic_name (filedata
, psym
->st_name
));
20214 printf (_("<corrupt: %14ld>"), psym
->st_name
);
20228 process_nds32_specific (Filedata
* filedata
)
20230 Elf_Internal_Shdr
*sect
= NULL
;
20232 sect
= find_section (filedata
, ".nds32_e_flags");
20233 if (sect
!= NULL
&& sect
->sh_size
>= 4)
20235 unsigned char *buf
;
20238 printf ("\nNDS32 elf flags section:\n");
20239 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
20240 _("NDS32 elf flags section"));
20245 flag
= byte_get (buf
, 4);
20247 switch (flag
& 0x3)
20250 printf ("(VEC_SIZE):\tNo entry.\n");
20253 printf ("(VEC_SIZE):\t4 bytes\n");
20256 printf ("(VEC_SIZE):\t16 bytes\n");
20259 printf ("(VEC_SIZE):\treserved\n");
20268 process_gnu_liblist (Filedata
* filedata
)
20270 Elf_Internal_Shdr
* section
;
20271 Elf_Internal_Shdr
* string_sec
;
20272 Elf32_External_Lib
* elib
;
20274 size_t strtab_size
;
20276 uint64_t num_liblist
;
20283 for (i
= 0, section
= filedata
->section_headers
;
20284 i
< filedata
->file_header
.e_shnum
;
20287 switch (section
->sh_type
)
20289 case SHT_GNU_LIBLIST
:
20290 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
20293 elib
= (Elf32_External_Lib
*)
20294 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
20295 _("liblist section data"));
20303 string_sec
= filedata
->section_headers
+ section
->sh_link
;
20304 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
20305 string_sec
->sh_size
,
20306 _("liblist string table"));
20308 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
20315 strtab_size
= string_sec
->sh_size
;
20317 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
20318 printf (ngettext ("\nLibrary list section '%s' contains %" PRIu64
20320 "\nLibrary list section '%s' contains %" PRIu64
20323 printable_section_name (filedata
, section
),
20326 puts (_(" Library Time Stamp Checksum Version Flags"));
20328 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
20336 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
20337 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
20338 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
20339 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
20340 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
20342 tmp
= gmtime (&atime
);
20343 snprintf (timebuf
, sizeof (timebuf
),
20344 "%04u-%02u-%02uT%02u:%02u:%02u",
20345 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
20346 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
20348 printf ("%3zu: ", cnt
);
20350 printf ("%-20s", liblist
.l_name
< strtab_size
20351 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
20353 printf ("%-20.20s", liblist
.l_name
< strtab_size
20354 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
20355 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
20356 liblist
.l_version
, liblist
.l_flags
);
20367 static const char *
20368 get_note_type (Filedata
* filedata
, unsigned e_type
)
20370 static char buff
[64];
20372 if (filedata
->file_header
.e_type
== ET_CORE
)
20376 return _("NT_AUXV (auxiliary vector)");
20378 return _("NT_PRSTATUS (prstatus structure)");
20380 return _("NT_FPREGSET (floating point registers)");
20382 return _("NT_PRPSINFO (prpsinfo structure)");
20383 case NT_TASKSTRUCT
:
20384 return _("NT_TASKSTRUCT (task structure)");
20386 return _("NT_GDB_TDESC (GDB XML target description)");
20388 return _("NT_PRXFPREG (user_xfpregs structure)");
20390 return _("NT_PPC_VMX (ppc Altivec registers)");
20392 return _("NT_PPC_VSX (ppc VSX registers)");
20394 return _("NT_PPC_TAR (ppc TAR register)");
20396 return _("NT_PPC_PPR (ppc PPR register)");
20398 return _("NT_PPC_DSCR (ppc DSCR register)");
20400 return _("NT_PPC_EBB (ppc EBB registers)");
20402 return _("NT_PPC_PMU (ppc PMU registers)");
20403 case NT_PPC_TM_CGPR
:
20404 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
20405 case NT_PPC_TM_CFPR
:
20406 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
20407 case NT_PPC_TM_CVMX
:
20408 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
20409 case NT_PPC_TM_CVSX
:
20410 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
20411 case NT_PPC_TM_SPR
:
20412 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
20413 case NT_PPC_TM_CTAR
:
20414 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
20415 case NT_PPC_TM_CPPR
:
20416 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
20417 case NT_PPC_TM_CDSCR
:
20418 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
20420 return _("NT_386_TLS (x86 TLS information)");
20421 case NT_386_IOPERM
:
20422 return _("NT_386_IOPERM (x86 I/O permissions)");
20423 case NT_X86_XSTATE
:
20424 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
20426 return _("NT_X86_CET (x86 CET state)");
20428 return _("NT_X86_SHSTK (x86 SHSTK state)");
20429 case NT_S390_HIGH_GPRS
:
20430 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
20431 case NT_S390_TIMER
:
20432 return _("NT_S390_TIMER (s390 timer register)");
20433 case NT_S390_TODCMP
:
20434 return _("NT_S390_TODCMP (s390 TOD comparator register)");
20435 case NT_S390_TODPREG
:
20436 return _("NT_S390_TODPREG (s390 TOD programmable register)");
20438 return _("NT_S390_CTRS (s390 control registers)");
20439 case NT_S390_PREFIX
:
20440 return _("NT_S390_PREFIX (s390 prefix register)");
20441 case NT_S390_LAST_BREAK
:
20442 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
20443 case NT_S390_SYSTEM_CALL
:
20444 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
20446 return _("NT_S390_TDB (s390 transaction diagnostic block)");
20447 case NT_S390_VXRS_LOW
:
20448 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
20449 case NT_S390_VXRS_HIGH
:
20450 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
20451 case NT_S390_GS_CB
:
20452 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
20453 case NT_S390_GS_BC
:
20454 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
20456 return _("NT_ARM_VFP (arm VFP registers)");
20458 return _("NT_ARM_TLS (AArch TLS registers)");
20459 case NT_ARM_HW_BREAK
:
20460 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
20461 case NT_ARM_HW_WATCH
:
20462 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
20463 case NT_ARM_SYSTEM_CALL
:
20464 return _("NT_ARM_SYSTEM_CALL (AArch system call number)");
20466 return _("NT_ARM_SVE (AArch SVE registers)");
20467 case NT_ARM_PAC_MASK
:
20468 return _("NT_ARM_PAC_MASK (AArch pointer authentication code masks)");
20469 case NT_ARM_PACA_KEYS
:
20470 return _("NT_ARM_PACA_KEYS (ARM pointer authentication address keys)");
20471 case NT_ARM_PACG_KEYS
:
20472 return _("NT_ARM_PACG_KEYS (ARM pointer authentication generic keys)");
20473 case NT_ARM_TAGGED_ADDR_CTRL
:
20474 return _("NT_ARM_TAGGED_ADDR_CTRL (AArch tagged address control)");
20476 return _("NT_ARM_SSVE (AArch64 streaming SVE registers)");
20478 return _("NT_ARM_ZA (AArch64 SME ZA register)");
20480 return _("NT_ARM_ZT (AArch64 SME2 ZT registers)");
20481 case NT_ARM_PAC_ENABLED_KEYS
:
20482 return _("NT_ARM_PAC_ENABLED_KEYS (AArch64 pointer authentication enabled keys)");
20484 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
20486 return _("NT_RISCV_CSR (RISC-V control and status registers)");
20488 return _("NT_PSTATUS (pstatus structure)");
20490 return _("NT_FPREGS (floating point registers)");
20492 return _("NT_PSINFO (psinfo structure)");
20494 return _("NT_LWPSTATUS (lwpstatus_t structure)");
20496 return _("NT_LWPSINFO (lwpsinfo_t structure)");
20497 case NT_WIN32PSTATUS
:
20498 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
20500 return _("NT_SIGINFO (siginfo_t data)");
20502 return _("NT_FILE (mapped files)");
20510 return _("NT_VERSION (version)");
20512 return _("NT_ARCH (architecture)");
20513 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
20515 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
20517 case NT_GO_BUILDID
:
20518 return _("GO BUILDID");
20519 case FDO_PACKAGING_METADATA
:
20520 return _("FDO_PACKAGING_METADATA");
20525 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
20530 print_core_note (Elf_Internal_Note
*pnote
)
20532 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
20533 uint64_t count
, page_size
;
20534 unsigned char *descdata
, *filenames
, *descend
;
20536 if (pnote
->type
!= NT_FILE
)
20543 if (pnote
->descsz
< 2 * addr_size
)
20545 error (_(" Malformed note - too short for header\n"));
20549 descdata
= (unsigned char *) pnote
->descdata
;
20550 descend
= descdata
+ pnote
->descsz
;
20552 if (descdata
[pnote
->descsz
- 1] != '\0')
20554 error (_(" Malformed note - does not end with \\0\n"));
20558 count
= byte_get (descdata
, addr_size
);
20559 descdata
+= addr_size
;
20561 page_size
= byte_get (descdata
, addr_size
);
20562 descdata
+= addr_size
;
20564 if (count
> ((uint64_t) -1 - 2 * addr_size
) / (3 * addr_size
)
20565 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
20567 error (_(" Malformed note - too short for supplied file count\n"));
20571 printf (_(" Page size: "));
20572 print_vma (page_size
, DEC
);
20575 printf (_(" %*s%*s%*s\n"),
20576 (int) (2 + 2 * addr_size
), _("Start"),
20577 (int) (4 + 2 * addr_size
), _("End"),
20578 (int) (4 + 2 * addr_size
), _("Page Offset"));
20579 filenames
= descdata
+ count
* 3 * addr_size
;
20580 while (count
-- > 0)
20582 uint64_t start
, end
, file_ofs
;
20584 if (filenames
== descend
)
20586 error (_(" Malformed note - filenames end too early\n"));
20590 start
= byte_get (descdata
, addr_size
);
20591 descdata
+= addr_size
;
20592 end
= byte_get (descdata
, addr_size
);
20593 descdata
+= addr_size
;
20594 file_ofs
= byte_get (descdata
, addr_size
);
20595 descdata
+= addr_size
;
20598 print_vma (start
, FULL_HEX
);
20600 print_vma (end
, FULL_HEX
);
20602 print_vma (file_ofs
, FULL_HEX
);
20603 printf ("\n %s\n", filenames
);
20605 filenames
+= 1 + strlen ((char *) filenames
);
20611 static const char *
20612 get_gnu_elf_note_type (unsigned e_type
)
20614 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
20617 case NT_GNU_ABI_TAG
:
20618 return _("NT_GNU_ABI_TAG (ABI version tag)");
20620 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
20621 case NT_GNU_BUILD_ID
:
20622 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
20623 case NT_GNU_GOLD_VERSION
:
20624 return _("NT_GNU_GOLD_VERSION (gold version)");
20625 case NT_GNU_PROPERTY_TYPE_0
:
20626 return _("NT_GNU_PROPERTY_TYPE_0");
20627 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
20628 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
20629 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
20630 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
20633 static char buff
[64];
20635 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
20642 decode_x86_compat_isa (unsigned int bitmask
)
20646 unsigned int bit
= bitmask
& (- bitmask
);
20651 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
20654 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
20657 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
20660 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
20663 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
20666 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
20669 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
20672 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
20675 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
20678 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
20681 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
20684 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
20685 printf ("AVX512F");
20687 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
20688 printf ("AVX512CD");
20690 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
20691 printf ("AVX512ER");
20693 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
20694 printf ("AVX512PF");
20696 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
20697 printf ("AVX512VL");
20699 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
20700 printf ("AVX512DQ");
20702 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
20703 printf ("AVX512BW");
20706 printf (_("<unknown: %x>"), bit
);
20715 decode_x86_compat_2_isa (unsigned int bitmask
)
20719 printf (_("<None>"));
20725 unsigned int bit
= bitmask
& (- bitmask
);
20730 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_CMOV
:
20733 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE
:
20736 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE2
:
20739 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE3
:
20742 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSSE3
:
20745 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_1
:
20748 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_2
:
20751 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX
:
20754 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX2
:
20757 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_FMA
:
20760 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512F
:
20761 printf ("AVX512F");
20763 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512CD
:
20764 printf ("AVX512CD");
20766 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512ER
:
20767 printf ("AVX512ER");
20769 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512PF
:
20770 printf ("AVX512PF");
20772 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512VL
:
20773 printf ("AVX512VL");
20775 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512DQ
:
20776 printf ("AVX512DQ");
20778 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512BW
:
20779 printf ("AVX512BW");
20781 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4FMAPS
:
20782 printf ("AVX512_4FMAPS");
20784 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4VNNIW
:
20785 printf ("AVX512_4VNNIW");
20787 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BITALG
:
20788 printf ("AVX512_BITALG");
20790 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_IFMA
:
20791 printf ("AVX512_IFMA");
20793 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI
:
20794 printf ("AVX512_VBMI");
20796 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI2
:
20797 printf ("AVX512_VBMI2");
20799 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VNNI
:
20800 printf ("AVX512_VNNI");
20802 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BF16
:
20803 printf ("AVX512_BF16");
20806 printf (_("<unknown: %x>"), bit
);
20814 static const char *
20815 get_amdgpu_elf_note_type (unsigned int e_type
)
20819 case NT_AMDGPU_METADATA
:
20820 return _("NT_AMDGPU_METADATA (code object metadata)");
20823 static char buf
[64];
20824 snprintf (buf
, sizeof (buf
), _("Unknown note type: (0x%08x)"), e_type
);
20831 decode_x86_isa (unsigned int bitmask
)
20835 unsigned int bit
= bitmask
& (- bitmask
);
20840 case GNU_PROPERTY_X86_ISA_1_BASELINE
:
20841 printf ("x86-64-baseline");
20843 case GNU_PROPERTY_X86_ISA_1_V2
:
20844 printf ("x86-64-v2");
20846 case GNU_PROPERTY_X86_ISA_1_V3
:
20847 printf ("x86-64-v3");
20849 case GNU_PROPERTY_X86_ISA_1_V4
:
20850 printf ("x86-64-v4");
20853 printf (_("<unknown: %x>"), bit
);
20862 decode_x86_feature_1 (unsigned int bitmask
)
20866 printf (_("<None>"));
20872 unsigned int bit
= bitmask
& (- bitmask
);
20877 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
20880 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
20883 case GNU_PROPERTY_X86_FEATURE_1_LAM_U48
:
20884 printf ("LAM_U48");
20886 case GNU_PROPERTY_X86_FEATURE_1_LAM_U57
:
20887 printf ("LAM_U57");
20890 printf (_("<unknown: %x>"), bit
);
20899 decode_x86_feature_2 (unsigned int bitmask
)
20903 printf (_("<None>"));
20909 unsigned int bit
= bitmask
& (- bitmask
);
20914 case GNU_PROPERTY_X86_FEATURE_2_X86
:
20917 case GNU_PROPERTY_X86_FEATURE_2_X87
:
20920 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
20923 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
20926 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
20929 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
20932 case GNU_PROPERTY_X86_FEATURE_2_TMM
:
20935 case GNU_PROPERTY_X86_FEATURE_2_MASK
:
20938 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
20941 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
20944 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
20945 printf ("XSAVEOPT");
20947 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
20951 printf (_("<unknown: %x>"), bit
);
20960 decode_aarch64_feature_1_and (unsigned int bitmask
)
20964 unsigned int bit
= bitmask
& (- bitmask
);
20969 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
20973 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
20978 printf (_("<unknown: %x>"), bit
);
20987 decode_1_needed (unsigned int bitmask
)
20991 unsigned int bit
= bitmask
& (- bitmask
);
20996 case GNU_PROPERTY_1_NEEDED_INDIRECT_EXTERN_ACCESS
:
20997 printf ("indirect external access");
21000 printf (_("<unknown: %x>"), bit
);
21009 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
21011 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
21012 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
21013 unsigned int size
= is_32bit_elf
? 4 : 8;
21015 printf (_(" Properties: "));
21017 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
21019 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
21023 while (ptr
< ptr_end
)
21027 unsigned int datasz
;
21029 if ((size_t) (ptr_end
- ptr
) < 8)
21031 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
21035 type
= byte_get (ptr
, 4);
21036 datasz
= byte_get (ptr
+ 4, 4);
21040 if (datasz
> (size_t) (ptr_end
- ptr
))
21042 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
21047 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
21049 if (filedata
->file_header
.e_machine
== EM_X86_64
21050 || filedata
->file_header
.e_machine
== EM_IAMCU
21051 || filedata
->file_header
.e_machine
== EM_386
)
21053 unsigned int bitmask
;
21056 bitmask
= byte_get (ptr
, 4);
21062 case GNU_PROPERTY_X86_ISA_1_USED
:
21064 printf (_("x86 ISA used: <corrupt length: %#x> "),
21068 printf ("x86 ISA used: ");
21069 decode_x86_isa (bitmask
);
21073 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
21075 printf (_("x86 ISA needed: <corrupt length: %#x> "),
21079 printf ("x86 ISA needed: ");
21080 decode_x86_isa (bitmask
);
21084 case GNU_PROPERTY_X86_FEATURE_1_AND
:
21086 printf (_("x86 feature: <corrupt length: %#x> "),
21090 printf ("x86 feature: ");
21091 decode_x86_feature_1 (bitmask
);
21095 case GNU_PROPERTY_X86_FEATURE_2_USED
:
21097 printf (_("x86 feature used: <corrupt length: %#x> "),
21101 printf ("x86 feature used: ");
21102 decode_x86_feature_2 (bitmask
);
21106 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
21108 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
21111 printf ("x86 feature needed: ");
21112 decode_x86_feature_2 (bitmask
);
21116 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
21118 printf (_("x86 ISA used: <corrupt length: %#x> "),
21122 printf ("x86 ISA used: ");
21123 decode_x86_compat_isa (bitmask
);
21127 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
21129 printf (_("x86 ISA needed: <corrupt length: %#x> "),
21133 printf ("x86 ISA needed: ");
21134 decode_x86_compat_isa (bitmask
);
21138 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_USED
:
21140 printf (_("x86 ISA used: <corrupt length: %#x> "),
21144 printf ("x86 ISA used: ");
21145 decode_x86_compat_2_isa (bitmask
);
21149 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_NEEDED
:
21151 printf (_("x86 ISA needed: <corrupt length: %#x> "),
21155 printf ("x86 ISA needed: ");
21156 decode_x86_compat_2_isa (bitmask
);
21164 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
21166 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
21168 printf ("AArch64 feature: ");
21170 printf (_("<corrupt length: %#x> "), datasz
);
21172 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
21181 case GNU_PROPERTY_STACK_SIZE
:
21182 printf (_("stack size: "));
21183 if (datasz
!= size
)
21184 printf (_("<corrupt length: %#x> "), datasz
);
21186 printf ("%#" PRIx64
, byte_get (ptr
, size
));
21189 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
21190 printf ("no copy on protected ");
21192 printf (_("<corrupt length: %#x> "), datasz
);
21196 if ((type
>= GNU_PROPERTY_UINT32_AND_LO
21197 && type
<= GNU_PROPERTY_UINT32_AND_HI
)
21198 || (type
>= GNU_PROPERTY_UINT32_OR_LO
21199 && type
<= GNU_PROPERTY_UINT32_OR_HI
))
21203 case GNU_PROPERTY_1_NEEDED
:
21205 printf (_("1_needed: <corrupt length: %#x> "),
21209 unsigned int bitmask
= byte_get (ptr
, 4);
21210 printf ("1_needed: ");
21211 decode_1_needed (bitmask
);
21218 if (type
<= GNU_PROPERTY_UINT32_AND_HI
)
21219 printf (_("UINT32_AND (%#x): "), type
);
21221 printf (_("UINT32_OR (%#x): "), type
);
21223 printf (_("<corrupt length: %#x> "), datasz
);
21225 printf ("%#x", (unsigned int) byte_get (ptr
, 4));
21232 if (type
< GNU_PROPERTY_LOPROC
)
21233 printf (_("<unknown type %#x data: "), type
);
21234 else if (type
< GNU_PROPERTY_LOUSER
)
21235 printf (_("<processor-specific type %#x data: "), type
);
21237 printf (_("<application-specific type %#x data: "), type
);
21238 for (j
= 0; j
< datasz
; ++j
)
21239 printf ("%02x ", ptr
[j
] & 0xff);
21243 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
21244 if (ptr
== ptr_end
)
21257 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
21259 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
21260 switch (pnote
->type
)
21262 case NT_GNU_BUILD_ID
:
21266 printf (_(" Build ID: "));
21267 for (i
= 0; i
< pnote
->descsz
; ++i
)
21268 printf ("%02x", pnote
->descdata
[i
] & 0xff);
21273 case NT_GNU_ABI_TAG
:
21275 unsigned int os
, major
, minor
, subminor
;
21276 const char *osname
;
21278 /* PR 17531: file: 030-599401-0.004. */
21279 if (pnote
->descsz
< 16)
21281 printf (_(" <corrupt GNU_ABI_TAG>\n"));
21285 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
21286 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
21287 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
21288 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
21292 case GNU_ABI_TAG_LINUX
:
21295 case GNU_ABI_TAG_HURD
:
21298 case GNU_ABI_TAG_SOLARIS
:
21299 osname
= "Solaris";
21301 case GNU_ABI_TAG_FREEBSD
:
21302 osname
= "FreeBSD";
21304 case GNU_ABI_TAG_NETBSD
:
21307 case GNU_ABI_TAG_SYLLABLE
:
21308 osname
= "Syllable";
21310 case GNU_ABI_TAG_NACL
:
21314 osname
= "Unknown";
21318 printf (_(" OS: %s, ABI: %d.%d.%d\n"), osname
,
21319 major
, minor
, subminor
);
21323 case NT_GNU_GOLD_VERSION
:
21327 printf (_(" Version: "));
21328 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
21329 printf ("%c", pnote
->descdata
[i
]);
21336 unsigned int num_entries
, mask
;
21338 /* Hardware capabilities information. Word 0 is the number of entries.
21339 Word 1 is a bitmask of enabled entries. The rest of the descriptor
21340 is a series of entries, where each entry is a single byte followed
21341 by a nul terminated string. The byte gives the bit number to test
21342 if enabled in the bitmask. */
21343 printf (_(" Hardware Capabilities: "));
21344 if (pnote
->descsz
< 8)
21346 error (_("<corrupt GNU_HWCAP>\n"));
21349 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
21350 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
21351 printf (_("num entries: %d, enabled mask: %x\n"), num_entries
, mask
);
21352 /* FIXME: Add code to display the entries... */
21356 case NT_GNU_PROPERTY_TYPE_0
:
21357 print_gnu_property_note (filedata
, pnote
);
21361 /* Handle unrecognised types. An error message should have already been
21362 created by get_gnu_elf_note_type(), so all that we need to do is to
21363 display the data. */
21367 printf (_(" Description data: "));
21368 for (i
= 0; i
< pnote
->descsz
; ++i
)
21369 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
21378 static const char *
21379 get_v850_elf_note_type (enum v850_notes n_type
)
21381 static char buff
[64];
21385 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
21386 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
21387 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
21388 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
21389 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
21390 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
21392 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
21398 print_v850_note (Elf_Internal_Note
* pnote
)
21402 if (pnote
->descsz
!= 4)
21405 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
21409 printf (_("not set\n"));
21413 switch (pnote
->type
)
21415 case V850_NOTE_ALIGNMENT
:
21418 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return true;
21419 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return true;
21423 case V850_NOTE_DATA_SIZE
:
21426 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return true;
21427 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return true;
21431 case V850_NOTE_FPU_INFO
:
21434 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return true;
21435 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return true;
21439 case V850_NOTE_MMU_INFO
:
21440 case V850_NOTE_CACHE_INFO
:
21441 case V850_NOTE_SIMD_INFO
:
21442 if (val
== EF_RH850_SIMD
)
21444 printf (_("yes\n"));
21450 /* An 'unknown note type' message will already have been displayed. */
21454 printf (_("unknown value: %x\n"), val
);
21459 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
21461 unsigned int version
;
21463 switch (pnote
->type
)
21465 case NT_NETBSD_IDENT
:
21466 if (pnote
->descsz
< 1)
21468 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
21469 if ((version
/ 10000) % 100)
21470 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
21471 version
, version
/ 100000000, (version
/ 1000000) % 100,
21472 (version
/ 10000) % 100 > 26 ? "Z" : "",
21473 'A' + (version
/ 10000) % 26);
21475 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
21476 version
, version
/ 100000000, (version
/ 1000000) % 100,
21477 (version
/ 100) % 100);
21480 case NT_NETBSD_MARCH
:
21481 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
21485 case NT_NETBSD_PAX
:
21486 if (pnote
->descsz
< 1)
21488 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
21489 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
21490 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
21491 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
21492 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
21493 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
21494 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
21495 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
21499 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
21500 pnote
->descsz
, pnote
->type
);
21504 static const char *
21505 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
21509 case NT_FREEBSD_THRMISC
:
21510 return _("NT_THRMISC (thrmisc structure)");
21511 case NT_FREEBSD_PROCSTAT_PROC
:
21512 return _("NT_PROCSTAT_PROC (proc data)");
21513 case NT_FREEBSD_PROCSTAT_FILES
:
21514 return _("NT_PROCSTAT_FILES (files data)");
21515 case NT_FREEBSD_PROCSTAT_VMMAP
:
21516 return _("NT_PROCSTAT_VMMAP (vmmap data)");
21517 case NT_FREEBSD_PROCSTAT_GROUPS
:
21518 return _("NT_PROCSTAT_GROUPS (groups data)");
21519 case NT_FREEBSD_PROCSTAT_UMASK
:
21520 return _("NT_PROCSTAT_UMASK (umask data)");
21521 case NT_FREEBSD_PROCSTAT_RLIMIT
:
21522 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
21523 case NT_FREEBSD_PROCSTAT_OSREL
:
21524 return _("NT_PROCSTAT_OSREL (osreldate data)");
21525 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
21526 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
21527 case NT_FREEBSD_PROCSTAT_AUXV
:
21528 return _("NT_PROCSTAT_AUXV (auxv data)");
21529 case NT_FREEBSD_PTLWPINFO
:
21530 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
21531 case NT_FREEBSD_X86_SEGBASES
:
21532 return _("NT_X86_SEGBASES (x86 segment base registers)");
21534 return get_note_type (filedata
, e_type
);
21537 static const char *
21538 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
21540 static char buff
[64];
21544 case NT_NETBSDCORE_PROCINFO
:
21545 /* NetBSD core "procinfo" structure. */
21546 return _("NetBSD procinfo structure");
21548 case NT_NETBSDCORE_AUXV
:
21549 return _("NetBSD ELF auxiliary vector data");
21551 case NT_NETBSDCORE_LWPSTATUS
:
21552 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
21555 /* As of Jan 2020 there are no other machine-independent notes
21556 defined for NetBSD core files. If the note type is less
21557 than the start of the machine-dependent note types, we don't
21560 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
21562 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
21568 switch (filedata
->file_header
.e_machine
)
21570 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
21571 and PT_GETFPREGS == mach+2. */
21576 case EM_SPARC32PLUS
:
21580 case NT_NETBSDCORE_FIRSTMACH
+ 0:
21581 return _("PT_GETREGS (reg structure)");
21582 case NT_NETBSDCORE_FIRSTMACH
+ 2:
21583 return _("PT_GETFPREGS (fpreg structure)");
21589 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
21590 There's also old PT___GETREGS40 == mach + 1 for old reg
21591 structure which lacks GBR. */
21595 case NT_NETBSDCORE_FIRSTMACH
+ 1:
21596 return _("PT___GETREGS40 (old reg structure)");
21597 case NT_NETBSDCORE_FIRSTMACH
+ 3:
21598 return _("PT_GETREGS (reg structure)");
21599 case NT_NETBSDCORE_FIRSTMACH
+ 5:
21600 return _("PT_GETFPREGS (fpreg structure)");
21606 /* On all other arch's, PT_GETREGS == mach+1 and
21607 PT_GETFPREGS == mach+3. */
21611 case NT_NETBSDCORE_FIRSTMACH
+ 1:
21612 return _("PT_GETREGS (reg structure)");
21613 case NT_NETBSDCORE_FIRSTMACH
+ 3:
21614 return _("PT_GETFPREGS (fpreg structure)");
21620 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
21621 e_type
- NT_NETBSDCORE_FIRSTMACH
);
21625 static const char *
21626 get_openbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
21630 case NT_OPENBSD_PROCINFO
:
21631 return _("OpenBSD procinfo structure");
21632 case NT_OPENBSD_AUXV
:
21633 return _("OpenBSD ELF auxiliary vector data");
21634 case NT_OPENBSD_REGS
:
21635 return _("OpenBSD regular registers");
21636 case NT_OPENBSD_FPREGS
:
21637 return _("OpenBSD floating point registers");
21638 case NT_OPENBSD_WCOOKIE
:
21639 return _("OpenBSD window cookie");
21642 return get_note_type (filedata
, e_type
);
21645 static const char *
21646 get_qnx_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
21650 case QNT_DEBUG_FULLPATH
:
21651 return _("QNX debug fullpath");
21652 case QNT_DEBUG_RELOC
:
21653 return _("QNX debug relocation");
21655 return _("QNX stack");
21656 case QNT_GENERATOR
:
21657 return _("QNX generator");
21658 case QNT_DEFAULT_LIB
:
21659 return _("QNX default library");
21660 case QNT_CORE_SYSINFO
:
21661 return _("QNX core sysinfo");
21662 case QNT_CORE_INFO
:
21663 return _("QNX core info");
21664 case QNT_CORE_STATUS
:
21665 return _("QNX core status");
21666 case QNT_CORE_GREG
:
21667 return _("QNX general registers");
21668 case QNT_CORE_FPREG
:
21669 return _("QNX floating point registers");
21671 return _("QNX link map");
21674 return get_note_type (filedata
, e_type
);
21677 static const char *
21678 get_stapsdt_note_type (unsigned e_type
)
21680 static char buff
[64];
21685 return _("NT_STAPSDT (SystemTap probe descriptors)");
21691 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
21696 print_stapsdt_note (Elf_Internal_Note
*pnote
)
21698 size_t len
, maxlen
;
21699 size_t addr_size
= is_32bit_elf
? 4 : 8;
21700 char *data
= pnote
->descdata
;
21701 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
21702 uint64_t pc
, base_addr
, semaphore
;
21703 char *provider
, *probe
, *arg_fmt
;
21705 if (pnote
->descsz
< (addr_size
* 3))
21706 goto stapdt_note_too_small
;
21708 pc
= byte_get ((unsigned char *) data
, addr_size
);
21711 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
21714 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
21717 if (data
>= data_end
)
21718 goto stapdt_note_too_small
;
21719 maxlen
= data_end
- data
;
21720 len
= strnlen (data
, maxlen
);
21727 goto stapdt_note_too_small
;
21729 if (data
>= data_end
)
21730 goto stapdt_note_too_small
;
21731 maxlen
= data_end
- data
;
21732 len
= strnlen (data
, maxlen
);
21739 goto stapdt_note_too_small
;
21741 if (data
>= data_end
)
21742 goto stapdt_note_too_small
;
21743 maxlen
= data_end
- data
;
21744 len
= strnlen (data
, maxlen
);
21751 goto stapdt_note_too_small
;
21753 printf (_(" Provider: %s\n"), provider
);
21754 printf (_(" Name: %s\n"), probe
);
21755 printf (_(" Location: "));
21756 print_vma (pc
, FULL_HEX
);
21757 printf (_(", Base: "));
21758 print_vma (base_addr
, FULL_HEX
);
21759 printf (_(", Semaphore: "));
21760 print_vma (semaphore
, FULL_HEX
);
21762 printf (_(" Arguments: %s\n"), arg_fmt
);
21764 return data
== data_end
;
21766 stapdt_note_too_small
:
21767 printf (_(" <corrupt - note is too small>\n"));
21768 error (_("corrupt stapdt note - the data size is too small\n"));
21773 print_fdo_note (Elf_Internal_Note
* pnote
)
21775 if (pnote
->descsz
> 0 && pnote
->type
== FDO_PACKAGING_METADATA
)
21777 printf (_(" Packaging Metadata: %.*s\n"), (int) pnote
->descsz
, pnote
->descdata
);
21783 static const char *
21784 get_ia64_vms_note_type (unsigned e_type
)
21786 static char buff
[64];
21791 return _("NT_VMS_MHD (module header)");
21793 return _("NT_VMS_LNM (language name)");
21795 return _("NT_VMS_SRC (source files)");
21797 return "NT_VMS_TITLE";
21799 return _("NT_VMS_EIDC (consistency check)");
21800 case NT_VMS_FPMODE
:
21801 return _("NT_VMS_FPMODE (FP mode)");
21802 case NT_VMS_LINKTIME
:
21803 return "NT_VMS_LINKTIME";
21804 case NT_VMS_IMGNAM
:
21805 return _("NT_VMS_IMGNAM (image name)");
21807 return _("NT_VMS_IMGID (image id)");
21808 case NT_VMS_LINKID
:
21809 return _("NT_VMS_LINKID (link id)");
21810 case NT_VMS_IMGBID
:
21811 return _("NT_VMS_IMGBID (build id)");
21812 case NT_VMS_GSTNAM
:
21813 return _("NT_VMS_GSTNAM (sym table name)");
21814 case NT_VMS_ORIG_DYN
:
21815 return "NT_VMS_ORIG_DYN";
21816 case NT_VMS_PATCHTIME
:
21817 return "NT_VMS_PATCHTIME";
21819 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
21825 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
21827 unsigned int maxlen
= pnote
->descsz
;
21829 if (maxlen
< 2 || maxlen
!= pnote
->descsz
)
21830 goto desc_size_fail
;
21832 switch (pnote
->type
)
21836 goto desc_size_fail
;
21838 size_t l
= strnlen (pnote
->descdata
+ 34, maxlen
- 34);
21840 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
21841 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
21842 if (l
+ 34 < maxlen
)
21844 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
21845 if (l
+ 35 < maxlen
)
21846 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
21848 printf (_(" Module version : <missing>\n"));
21852 printf (_(" Module name : <missing>\n"));
21853 printf (_(" Module version : <missing>\n"));
21858 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
21861 case NT_VMS_FPMODE
:
21862 printf (_(" Floating Point mode: "));
21864 goto desc_size_fail
;
21865 /* FIXME: Generate an error if descsz > 8 ? */
21867 printf ("0x%016" PRIx64
"\n",
21868 byte_get ((unsigned char *) pnote
->descdata
, 8));
21871 case NT_VMS_LINKTIME
:
21872 printf (_(" Link time: "));
21874 goto desc_size_fail
;
21875 /* FIXME: Generate an error if descsz > 8 ? */
21877 print_vms_time (byte_get ((unsigned char *) pnote
->descdata
, 8));
21881 case NT_VMS_PATCHTIME
:
21882 printf (_(" Patch time: "));
21884 goto desc_size_fail
;
21885 /* FIXME: Generate an error if descsz > 8 ? */
21887 print_vms_time (byte_get ((unsigned char *) pnote
->descdata
, 8));
21891 case NT_VMS_ORIG_DYN
:
21893 goto desc_size_fail
;
21895 printf (_(" Major id: %u, minor id: %u\n"),
21896 (unsigned) byte_get ((unsigned char *) pnote
->descdata
, 4),
21897 (unsigned) byte_get ((unsigned char *) pnote
->descdata
+ 4, 4));
21898 printf (_(" Last modified : "));
21899 print_vms_time (byte_get ((unsigned char *) pnote
->descdata
+ 8, 8));
21900 printf (_("\n Link flags : "));
21901 printf ("0x%016" PRIx64
"\n",
21902 byte_get ((unsigned char *) pnote
->descdata
+ 16, 8));
21903 printf (_(" Header flags: 0x%08x\n"),
21904 (unsigned) byte_get ((unsigned char *) pnote
->descdata
+ 24, 4));
21905 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
21908 case NT_VMS_IMGNAM
:
21909 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
21912 case NT_VMS_GSTNAM
:
21913 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
21917 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
21920 case NT_VMS_LINKID
:
21921 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
21931 printf (_(" <corrupt - data size is too small>\n"));
21932 error (_("corrupt IA64 note: data size is too small\n"));
21936 struct build_attr_cache
{
21937 Filedata
*filedata
;
21939 uint64_t strtablen
;
21940 Elf_Internal_Sym
*symtab
;
21944 /* Find the symbol associated with a build attribute that is attached
21945 to address OFFSET. If PNAME is non-NULL then store the name of
21946 the symbol (if found) in the provided pointer, Returns NULL if a
21947 symbol could not be found. */
21949 static Elf_Internal_Sym
*
21950 get_symbol_for_build_attribute (Filedata
*filedata
,
21953 const char **pname
)
21955 Elf_Internal_Sym
*saved_sym
= NULL
;
21956 Elf_Internal_Sym
*sym
;
21958 if (filedata
->section_headers
!= NULL
21959 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
21961 Elf_Internal_Shdr
* symsec
;
21963 free (ba_cache
.strtab
);
21964 ba_cache
.strtab
= NULL
;
21965 free (ba_cache
.symtab
);
21966 ba_cache
.symtab
= NULL
;
21968 /* Load the symbol and string sections. */
21969 for (symsec
= filedata
->section_headers
;
21970 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
21973 if (symsec
->sh_type
== SHT_SYMTAB
21974 && get_symtab (filedata
, symsec
,
21975 &ba_cache
.symtab
, &ba_cache
.nsyms
,
21976 &ba_cache
.strtab
, &ba_cache
.strtablen
))
21979 ba_cache
.filedata
= filedata
;
21982 if (ba_cache
.symtab
== NULL
)
21985 /* Find a symbol whose value matches offset. */
21986 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
21987 if (sym
->st_value
== offset
)
21989 if (sym
->st_name
>= ba_cache
.strtablen
)
21990 /* Huh ? This should not happen. */
21993 if (ba_cache
.strtab
[sym
->st_name
] == 0)
21996 /* The AArch64, ARM and RISC-V architectures define mapping symbols
21997 (eg $d, $x, $t) which we want to ignore. */
21998 if (ba_cache
.strtab
[sym
->st_name
] == '$'
21999 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
22000 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
22005 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
22006 and FILE or OBJECT symbols over NOTYPE symbols. We skip
22007 FUNC symbols entirely. */
22008 switch (ELF_ST_TYPE (sym
->st_info
))
22015 /* If the symbol has a size associated
22016 with it then we can stop searching. */
22017 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
22022 /* Ignore function symbols. */
22029 switch (ELF_ST_BIND (sym
->st_info
))
22032 if (saved_sym
== NULL
22033 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
22038 if (saved_sym
== NULL
)
22048 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
22056 if (saved_sym
&& pname
)
22057 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
22062 /* Returns true iff addr1 and addr2 are in the same section. */
22065 same_section (Filedata
* filedata
, uint64_t addr1
, uint64_t addr2
)
22067 Elf_Internal_Shdr
* a1
;
22068 Elf_Internal_Shdr
* a2
;
22070 a1
= find_section_by_address (filedata
, addr1
);
22071 a2
= find_section_by_address (filedata
, addr2
);
22073 return a1
== a2
&& a1
!= NULL
;
22077 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
22078 Filedata
* filedata
)
22080 static uint64_t global_offset
= 0;
22081 static uint64_t global_end
= 0;
22082 static uint64_t func_offset
= 0;
22083 static uint64_t func_end
= 0;
22085 Elf_Internal_Sym
*sym
;
22089 bool is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
22091 switch (pnote
->descsz
)
22094 /* A zero-length description means that the range of
22095 the previous note of the same type should be used. */
22098 if (global_end
> global_offset
)
22099 printf (_(" Applies to region from %#" PRIx64
22100 " to %#" PRIx64
"\n"), global_offset
, global_end
);
22102 printf (_(" Applies to region from %#" PRIx64
22103 "\n"), global_offset
);
22107 if (func_end
> func_offset
)
22108 printf (_(" Applies to region from %#" PRIx64
22109 " to %#" PRIx64
"\n"), func_offset
, func_end
);
22111 printf (_(" Applies to region from %#" PRIx64
22112 "\n"), func_offset
);
22117 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
22122 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
22123 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
22127 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
22128 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
22132 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
22133 printf (_(" <invalid descsz>"));
22138 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
22139 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
22140 in order to avoid them being confused with the start address of the
22141 first function in the file... */
22142 if (sym
== NULL
&& is_open_attr
)
22143 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
22146 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
22147 end
= start
+ sym
->st_size
;
22151 /* FIXME: Need to properly allow for section alignment.
22152 16 is just the alignment used on x86_64. */
22154 && start
> BFD_ALIGN (global_end
, 16)
22155 /* Build notes are not guaranteed to be organised in order of
22156 increasing address, but we should find the all of the notes
22157 for one section in the same place. */
22158 && same_section (filedata
, start
, global_end
))
22159 warn (_("Gap in build notes detected from %#" PRIx64
22160 " to %#" PRIx64
"\n"),
22161 global_end
+ 1, start
- 1);
22163 printf (_(" Applies to region from %#" PRIx64
), start
);
22164 global_offset
= start
;
22168 printf (_(" to %#" PRIx64
), end
);
22174 printf (_(" Applies to region from %#" PRIx64
), start
);
22175 func_offset
= start
;
22179 printf (_(" to %#" PRIx64
), end
);
22185 printf (_(" (%s)"), name
);
22192 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
22194 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
22195 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
22196 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
22198 char name_attribute
;
22199 const char * expected_types
;
22200 const char * name
= pnote
->namedata
;
22204 if (name
== NULL
|| pnote
->namesz
< 2)
22206 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
22207 print_symbol_name (-20, _(" <corrupt name>"));
22216 /* Version 2 of the spec adds a "GA" prefix to the name field. */
22217 if (name
[0] == 'G' && name
[1] == 'A')
22219 if (pnote
->namesz
< 4)
22221 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
22222 print_symbol_name (-20, _(" <corrupt name>"));
22231 switch ((name_type
= * name
))
22233 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
22234 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
22235 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
22236 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
22237 printf ("%c", * name
);
22241 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
22242 print_symbol_name (-20, _("<unknown name type>"));
22249 switch ((name_attribute
= * name
))
22251 case GNU_BUILD_ATTRIBUTE_VERSION
:
22252 text
= _("<version>");
22253 expected_types
= string_expected
;
22256 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
22257 text
= _("<stack prot>");
22258 expected_types
= "!+*";
22261 case GNU_BUILD_ATTRIBUTE_RELRO
:
22262 text
= _("<relro>");
22263 expected_types
= bool_expected
;
22266 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
22267 text
= _("<stack size>");
22268 expected_types
= number_expected
;
22271 case GNU_BUILD_ATTRIBUTE_TOOL
:
22272 text
= _("<tool>");
22273 expected_types
= string_expected
;
22276 case GNU_BUILD_ATTRIBUTE_ABI
:
22278 expected_types
= "$*";
22281 case GNU_BUILD_ATTRIBUTE_PIC
:
22283 expected_types
= number_expected
;
22286 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
22287 text
= _("<short enum>");
22288 expected_types
= bool_expected
;
22292 if (ISPRINT (* name
))
22294 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
22296 if (len
> left
&& ! do_wide
)
22298 printf ("%.*s:", len
, name
);
22304 static char tmpbuf
[128];
22306 error (_("unrecognised byte in name field: %d\n"), * name
);
22307 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
22311 expected_types
= "*$!+";
22316 left
-= printf ("%s", text
);
22318 if (strchr (expected_types
, name_type
) == NULL
)
22319 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
22321 if ((size_t) (name
- pnote
->namedata
) > pnote
->namesz
)
22323 error (_("corrupt name field: namesz: %lu but parsing gets to %td\n"),
22325 name
- pnote
->namedata
);
22329 if (left
< 1 && ! do_wide
)
22334 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
22336 unsigned int bytes
;
22338 unsigned int shift
= 0;
22339 char *decoded
= NULL
;
22341 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
22343 /* The -1 is because the name field is always 0 terminated, and we
22344 want to be able to ensure that the shift in the while loop below
22345 will not overflow. */
22348 if (bytes
> sizeof (val
))
22350 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
22352 bytes
= sizeof (val
);
22354 /* We do not bother to warn if bytes == 0 as this can
22355 happen with some early versions of the gcc plugin. */
22359 uint64_t byte
= *name
++ & 0xff;
22361 val
|= byte
<< shift
;
22365 switch (name_attribute
)
22367 case GNU_BUILD_ATTRIBUTE_PIC
:
22370 case 0: decoded
= "static"; break;
22371 case 1: decoded
= "pic"; break;
22372 case 2: decoded
= "PIC"; break;
22373 case 3: decoded
= "pie"; break;
22374 case 4: decoded
= "PIE"; break;
22378 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
22381 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
22382 case 0: decoded
= "off"; break;
22383 case 1: decoded
= "on"; break;
22384 case 2: decoded
= "all"; break;
22385 case 3: decoded
= "strong"; break;
22386 case 4: decoded
= "explicit"; break;
22394 if (decoded
!= NULL
)
22396 print_symbol_name (-left
, decoded
);
22407 left
-= printf ("0x%" PRIx64
, val
);
22409 left
-= printf ("0x%-.*" PRIx64
, left
, val
);
22413 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
22414 left
-= print_symbol_name (- left
, name
);
22416 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
22417 left
-= print_symbol_name (- left
, "true");
22419 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
22420 left
-= print_symbol_name (- left
, "false");
22424 if (do_wide
&& left
> 0)
22425 printf ("%-*s", left
, " ");
22430 /* Print the contents of PNOTE as hex. */
22433 print_note_contents_hex (Elf_Internal_Note
*pnote
)
22439 printf (_(" description data: "));
22440 for (i
= 0; i
< pnote
->descsz
; i
++)
22441 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
22450 #if defined HAVE_MSGPACK
22453 print_indents (int n
)
22457 for (int i
= 0; i
< n
; i
++)
22461 /* Print OBJ in human-readable form. */
22464 dump_msgpack_obj (const msgpack_object
*obj
, int indent
)
22468 case MSGPACK_OBJECT_NIL
:
22472 case MSGPACK_OBJECT_BOOLEAN
:
22473 printf ("%s", obj
->via
.boolean
? "true" : "false");
22476 case MSGPACK_OBJECT_POSITIVE_INTEGER
:
22477 printf ("%" PRIu64
, obj
->via
.u64
);
22480 case MSGPACK_OBJECT_NEGATIVE_INTEGER
:
22481 printf ("%" PRIi64
, obj
->via
.i64
);
22484 case MSGPACK_OBJECT_FLOAT32
:
22485 case MSGPACK_OBJECT_FLOAT64
:
22486 printf ("%f", obj
->via
.f64
);
22489 case MSGPACK_OBJECT_STR
:
22490 printf ("\"%.*s\"", obj
->via
.str
.size
, obj
->via
.str
.ptr
);
22493 case MSGPACK_OBJECT_ARRAY
:
22495 const msgpack_object_array
*array
= &obj
->via
.array
;
22500 for (uint32_t i
= 0; i
< array
->size
; ++i
)
22502 const msgpack_object
*item
= &array
->ptr
[i
];
22504 print_indents (indent
);
22505 dump_msgpack_obj (item
, indent
);
22510 print_indents (indent
);
22516 case MSGPACK_OBJECT_MAP
:
22518 const msgpack_object_map
*map
= &obj
->via
.map
;
22523 for (uint32_t i
= 0; i
< map
->size
; ++i
)
22525 const msgpack_object_kv
*kv
= &map
->ptr
[i
];
22526 const msgpack_object
*key
= &kv
->key
;
22527 const msgpack_object
*val
= &kv
->val
;
22529 print_indents (indent
);
22530 dump_msgpack_obj (key
, indent
);
22532 dump_msgpack_obj (val
, indent
);
22538 print_indents (indent
);
22544 case MSGPACK_OBJECT_BIN
:
22548 case MSGPACK_OBJECT_EXT
:
22555 dump_msgpack (const msgpack_unpacked
*msg
)
22558 dump_msgpack_obj (&msg
->data
, 0);
22562 #endif /* defined HAVE_MSGPACK */
22565 print_amdgpu_note (Elf_Internal_Note
*pnote
)
22567 #if defined HAVE_MSGPACK
22568 /* If msgpack is available, decode and dump the note's content. */
22570 msgpack_unpacked msg
;
22571 msgpack_unpack_return msgpack_ret
;
22573 assert (pnote
->type
== NT_AMDGPU_METADATA
);
22575 msgpack_unpacked_init (&msg
);
22576 msgpack_ret
= msgpack_unpack_next (&msg
, pnote
->descdata
, pnote
->descsz
,
22579 switch (msgpack_ret
)
22581 case MSGPACK_UNPACK_SUCCESS
:
22582 dump_msgpack (&msg
);
22587 error (_("failed to unpack msgpack contents in NT_AMDGPU_METADATA note"));
22592 msgpack_unpacked_destroy (&msg
);
22595 /* msgpack is not available, dump contents as hex. */
22596 print_note_contents_hex (pnote
);
22602 print_qnx_note (Elf_Internal_Note
*pnote
)
22604 switch (pnote
->type
)
22607 if (pnote
->descsz
!= 12)
22608 goto desc_size_fail
;
22610 printf (_(" Stack Size: 0x%" PRIx32
"\n"),
22611 (unsigned) byte_get ((unsigned char *) pnote
->descdata
, 4));
22612 printf (_(" Stack allocated: %" PRIx32
"\n"),
22613 (unsigned) byte_get ((unsigned char *) pnote
->descdata
+ 4, 4));
22614 printf (_(" Executable: %s\n"),
22615 ((unsigned) byte_get ((unsigned char *) pnote
->descdata
+ 8, 1)) ? "no": "yes");
22619 print_note_contents_hex(pnote
);
22624 printf (_(" <corrupt - data size is too small>\n"));
22625 error (_("corrupt QNX note: data size is too small\n"));
22630 /* Note that by the ELF standard, the name field is already null byte
22631 terminated, and namesz includes the terminating null byte.
22632 I.E. the value of namesz for the name "FSF" is 4.
22634 If the value of namesz is zero, there is no name present. */
22637 process_note (Elf_Internal_Note
* pnote
,
22638 Filedata
* filedata
)
22640 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
22643 if (pnote
->namesz
== 0)
22644 /* If there is no note name, then use the default set of
22645 note type strings. */
22646 nt
= get_note_type (filedata
, pnote
->type
);
22648 else if (startswith (pnote
->namedata
, "GNU"))
22649 /* GNU-specific object file notes. */
22650 nt
= get_gnu_elf_note_type (pnote
->type
);
22652 else if (startswith (pnote
->namedata
, "AMDGPU"))
22653 /* AMDGPU-specific object file notes. */
22654 nt
= get_amdgpu_elf_note_type (pnote
->type
);
22656 else if (startswith (pnote
->namedata
, "FreeBSD"))
22657 /* FreeBSD-specific core file notes. */
22658 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
22660 else if (startswith (pnote
->namedata
, "NetBSD-CORE"))
22661 /* NetBSD-specific core file notes. */
22662 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
22664 else if (startswith (pnote
->namedata
, "NetBSD"))
22665 /* NetBSD-specific core file notes. */
22666 return process_netbsd_elf_note (pnote
);
22668 else if (startswith (pnote
->namedata
, "PaX"))
22669 /* NetBSD-specific core file notes. */
22670 return process_netbsd_elf_note (pnote
);
22672 else if (startswith (pnote
->namedata
, "OpenBSD"))
22673 /* OpenBSD-specific core file notes. */
22674 nt
= get_openbsd_elfcore_note_type (filedata
, pnote
->type
);
22676 else if (startswith (pnote
->namedata
, "QNX"))
22677 /* QNX-specific core file notes. */
22678 nt
= get_qnx_elfcore_note_type (filedata
, pnote
->type
);
22680 else if (startswith (pnote
->namedata
, "SPU/"))
22682 /* SPU-specific core file notes. */
22683 nt
= pnote
->namedata
+ 4;
22687 else if (startswith (pnote
->namedata
, "IPF/VMS"))
22688 /* VMS/ia64-specific file notes. */
22689 nt
= get_ia64_vms_note_type (pnote
->type
);
22691 else if (startswith (pnote
->namedata
, "stapsdt"))
22692 nt
= get_stapsdt_note_type (pnote
->type
);
22695 /* Don't recognize this note name; just use the default set of
22696 note type strings. */
22697 nt
= get_note_type (filedata
, pnote
->type
);
22701 if (((startswith (pnote
->namedata
, "GA")
22702 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
22703 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
22704 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
22705 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
22706 print_gnu_build_attribute_name (pnote
);
22708 print_symbol_name (-20, name
);
22711 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
22713 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
22715 if (startswith (pnote
->namedata
, "IPF/VMS"))
22716 return print_ia64_vms_note (pnote
);
22717 else if (startswith (pnote
->namedata
, "GNU"))
22718 return print_gnu_note (filedata
, pnote
);
22719 else if (startswith (pnote
->namedata
, "stapsdt"))
22720 return print_stapsdt_note (pnote
);
22721 else if (startswith (pnote
->namedata
, "CORE"))
22722 return print_core_note (pnote
);
22723 else if (startswith (pnote
->namedata
, "FDO"))
22724 return print_fdo_note (pnote
);
22725 else if (((startswith (pnote
->namedata
, "GA")
22726 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
22727 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
22728 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
22729 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
22730 return print_gnu_build_attribute_description (pnote
, filedata
);
22731 else if (startswith (pnote
->namedata
, "AMDGPU")
22732 && pnote
->type
== NT_AMDGPU_METADATA
)
22733 return print_amdgpu_note (pnote
);
22734 else if (startswith (pnote
->namedata
, "QNX"))
22735 return print_qnx_note (pnote
);
22737 print_note_contents_hex (pnote
);
22742 process_notes_at (Filedata
* filedata
,
22743 Elf_Internal_Shdr
* section
,
22748 Elf_External_Note
*pnotes
;
22749 Elf_External_Note
*external
;
22758 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
22761 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
22769 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
22772 if (pnotes
== NULL
)
22777 if (filedata
->is_separate
)
22778 printf (_("In linked file '%s': "), filedata
->file_name
);
22782 printf (_("Displaying notes found in: %s\n"), printable_section_name (filedata
, section
));
22784 printf (_("Displaying notes found at file offset 0x%08" PRIx64
22785 " with length 0x%08" PRIx64
":\n"),
22788 /* NB: Some note sections may have alignment value of 0 or 1. gABI
22789 specifies that notes should be aligned to 4 bytes in 32-bit
22790 objects and to 8 bytes in 64-bit objects. As a Linux extension,
22791 we also support 4 byte alignment in 64-bit objects. If section
22792 alignment is less than 4, we treate alignment as 4 bytes. */
22795 else if (align
!= 4 && align
!= 8)
22797 warn (_("Corrupt note: alignment %" PRId64
", expecting 4 or 8\n"),
22803 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
22805 end
= (char *) pnotes
+ length
;
22806 while ((char *) external
< end
)
22808 Elf_Internal_Note inote
;
22811 char * temp
= NULL
;
22812 size_t data_remaining
= end
- (char *) external
;
22814 if (!is_ia64_vms (filedata
))
22816 /* PR binutils/15191
22817 Make sure that there is enough data to read. */
22818 min_notesz
= offsetof (Elf_External_Note
, name
);
22819 if (data_remaining
< min_notesz
)
22821 warn (ngettext ("Corrupt note: only %zd byte remains, "
22822 "not enough for a full note\n",
22823 "Corrupt note: only %zd bytes remain, "
22824 "not enough for a full note\n",
22829 data_remaining
-= min_notesz
;
22831 inote
.type
= BYTE_GET (external
->type
);
22832 inote
.namesz
= BYTE_GET (external
->namesz
);
22833 inote
.namedata
= external
->name
;
22834 inote
.descsz
= BYTE_GET (external
->descsz
);
22835 inote
.descdata
= ((char *) external
22836 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
22837 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
22838 next
= ((char *) external
22839 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
22843 Elf64_External_VMS_Note
*vms_external
;
22845 /* PR binutils/15191
22846 Make sure that there is enough data to read. */
22847 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
22848 if (data_remaining
< min_notesz
)
22850 warn (ngettext ("Corrupt note: only %zd byte remains, "
22851 "not enough for a full note\n",
22852 "Corrupt note: only %zd bytes remain, "
22853 "not enough for a full note\n",
22858 data_remaining
-= min_notesz
;
22860 vms_external
= (Elf64_External_VMS_Note
*) external
;
22861 inote
.type
= BYTE_GET (vms_external
->type
);
22862 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
22863 inote
.namedata
= vms_external
->name
;
22864 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
22865 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
22866 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
22867 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
22870 /* PR 17531: file: 3443835e. */
22871 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
22872 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
22873 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
22874 || (size_t) (next
- inote
.descdata
) < inote
.descsz
22875 || ((size_t) (next
- inote
.descdata
)
22876 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
22878 warn (_("note with invalid namesz and/or descsz found at offset %#tx\n"),
22879 (char *) external
- (char *) pnotes
);
22880 warn (_(" type: %#lx, namesize: %#lx, descsize: %#lx, alignment: %u\n"),
22881 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
22885 external
= (Elf_External_Note
*) next
;
22887 /* Verify that name is null terminated. It appears that at least
22888 one version of Linux (RedHat 6.0) generates corefiles that don't
22889 comply with the ELF spec by failing to include the null byte in
22891 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
22893 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
22895 temp
= (char *) malloc (inote
.namesz
+ 1);
22898 error (_("Out of memory allocating space for inote name\n"));
22903 memcpy (temp
, inote
.namedata
, inote
.namesz
);
22904 inote
.namedata
= temp
;
22906 inote
.namedata
[inote
.namesz
] = 0;
22909 if (! process_note (& inote
, filedata
))
22922 process_corefile_note_segments (Filedata
* filedata
)
22924 Elf_Internal_Phdr
*segment
;
22928 if (! get_program_headers (filedata
))
22931 for (i
= 0, segment
= filedata
->program_headers
;
22932 i
< filedata
->file_header
.e_phnum
;
22935 if (segment
->p_type
== PT_NOTE
)
22936 if (! process_notes_at (filedata
, NULL
, segment
->p_offset
,
22937 segment
->p_filesz
, segment
->p_align
))
22945 process_v850_notes (Filedata
* filedata
, uint64_t offset
, uint64_t length
)
22947 Elf_External_Note
* pnotes
;
22948 Elf_External_Note
* external
;
22955 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
22957 if (pnotes
== NULL
)
22961 end
= (char*) pnotes
+ length
;
22963 printf (_("\nDisplaying contents of Renesas V850 notes section at offset"
22964 " %#" PRIx64
" with length %#" PRIx64
":\n"),
22967 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
22969 Elf_External_Note
* next
;
22970 Elf_Internal_Note inote
;
22972 inote
.type
= BYTE_GET (external
->type
);
22973 inote
.namesz
= BYTE_GET (external
->namesz
);
22974 inote
.namedata
= external
->name
;
22975 inote
.descsz
= BYTE_GET (external
->descsz
);
22976 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
22977 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
22979 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
22981 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
22982 inote
.descdata
= inote
.namedata
;
22986 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
22988 if ( ((char *) next
> end
)
22989 || ((char *) next
< (char *) pnotes
))
22991 warn (_("corrupt descsz found in note at offset %#tx\n"),
22992 (char *) external
- (char *) pnotes
);
22993 warn (_(" type: %#lx, namesize: %#lx, descsize: %#lx\n"),
22994 inote
.type
, inote
.namesz
, inote
.descsz
);
23000 /* Prevent out-of-bounds indexing. */
23001 if ( inote
.namedata
+ inote
.namesz
> end
23002 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
23004 warn (_("corrupt namesz found in note at offset %#zx\n"),
23005 (char *) external
- (char *) pnotes
);
23006 warn (_(" type: %#lx, namesize: %#lx, descsize: %#lx\n"),
23007 inote
.type
, inote
.namesz
, inote
.descsz
);
23011 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
23013 if (! print_v850_note (& inote
))
23016 printf ("<corrupt sizes: namesz: %#lx, descsz: %#lx>\n",
23017 inote
.namesz
, inote
.descsz
);
23027 process_note_sections (Filedata
* filedata
)
23029 Elf_Internal_Shdr
*section
;
23031 unsigned int n
= 0;
23034 for (i
= 0, section
= filedata
->section_headers
;
23035 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
23038 if (section
->sh_type
== SHT_NOTE
)
23040 if (! process_notes_at (filedata
, section
, section
->sh_offset
,
23041 section
->sh_size
, section
->sh_addralign
))
23046 if (( filedata
->file_header
.e_machine
== EM_V800
23047 || filedata
->file_header
.e_machine
== EM_V850
23048 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
23049 && section
->sh_type
== SHT_RENESAS_INFO
)
23051 if (! process_v850_notes (filedata
, section
->sh_offset
,
23059 /* Try processing NOTE segments instead. */
23060 return process_corefile_note_segments (filedata
);
23066 process_notes (Filedata
* filedata
)
23068 /* If we have not been asked to display the notes then do nothing. */
23072 if (filedata
->file_header
.e_type
!= ET_CORE
)
23073 return process_note_sections (filedata
);
23075 /* No program headers means no NOTE segment. */
23076 if (filedata
->file_header
.e_phnum
> 0)
23077 return process_corefile_note_segments (filedata
);
23079 if (filedata
->is_separate
)
23080 printf (_("No notes found in linked file '%s'.\n"),
23081 filedata
->file_name
);
23083 printf (_("No notes found file.\n"));
23088 static unsigned char *
23089 display_public_gnu_attributes (unsigned char * start
,
23090 const unsigned char * const end
)
23092 printf (_(" Unknown GNU attribute: %s\n"), start
);
23094 start
+= strnlen ((char *) start
, end
- start
);
23095 display_raw_attribute (start
, end
);
23097 return (unsigned char *) end
;
23100 static unsigned char *
23101 display_generic_attribute (unsigned char * start
,
23103 const unsigned char * const end
)
23106 return (unsigned char *) end
;
23108 return display_tag_value (tag
, start
, end
);
23112 process_arch_specific (Filedata
* filedata
)
23117 switch (filedata
->file_header
.e_machine
)
23120 case EM_ARC_COMPACT
:
23121 case EM_ARC_COMPACT2
:
23122 case EM_ARC_COMPACT3
:
23123 case EM_ARC_COMPACT3_64
:
23124 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
23125 display_arc_attribute
,
23126 display_generic_attribute
);
23128 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
23129 display_arm_attribute
,
23130 display_generic_attribute
);
23133 case EM_MIPS_RS3_LE
:
23134 return process_mips_specific (filedata
);
23137 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
23138 display_msp430_attribute
,
23139 display_msp430_gnu_attribute
);
23142 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
23143 display_riscv_attribute
,
23144 display_generic_attribute
);
23147 return process_nds32_specific (filedata
);
23150 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
23151 display_m68k_gnu_attribute
);
23155 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
23156 display_power_gnu_attribute
);
23160 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
23161 display_s390_gnu_attribute
);
23164 case EM_SPARC32PLUS
:
23166 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
23167 display_sparc_gnu_attribute
);
23170 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
23171 display_tic6x_attribute
,
23172 display_generic_attribute
);
23175 return process_attributes (filedata
, "csky", SHT_CSKY_ATTRIBUTES
,
23176 display_csky_attribute
, NULL
);
23179 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
23180 display_public_gnu_attributes
,
23181 display_generic_attribute
);
23186 get_file_header (Filedata
* filedata
)
23188 /* Read in the identity array. */
23189 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
23192 /* Determine how to read the rest of the header. */
23193 switch (filedata
->file_header
.e_ident
[EI_DATA
])
23198 byte_get
= byte_get_little_endian
;
23199 byte_put
= byte_put_little_endian
;
23202 byte_get
= byte_get_big_endian
;
23203 byte_put
= byte_put_big_endian
;
23207 /* For now we only support 32 bit and 64 bit ELF files. */
23208 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
23210 /* Read in the rest of the header. */
23213 Elf32_External_Ehdr ehdr32
;
23215 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
23218 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
23219 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
23220 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
23221 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
23222 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
23223 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
23224 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
23225 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
23226 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
23227 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
23228 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
23229 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
23230 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
23234 Elf64_External_Ehdr ehdr64
;
23236 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
23239 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
23240 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
23241 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
23242 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
23243 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
23244 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
23245 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
23246 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
23247 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
23248 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
23249 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
23250 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
23251 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
23258 free_filedata (Filedata
*filedata
)
23260 free (filedata
->program_interpreter
);
23261 free (filedata
->program_headers
);
23262 free (filedata
->section_headers
);
23263 free (filedata
->string_table
);
23264 free (filedata
->dump
.dump_sects
);
23265 free (filedata
->dynamic_strings
);
23266 free (filedata
->dynamic_symbols
);
23267 free (filedata
->dynamic_syminfo
);
23268 free (filedata
->dynamic_section
);
23270 while (filedata
->symtab_shndx_list
!= NULL
)
23272 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
23273 free (filedata
->symtab_shndx_list
);
23274 filedata
->symtab_shndx_list
= next
;
23277 free (filedata
->section_headers_groups
);
23279 if (filedata
->section_groups
)
23282 struct group_list
* g
;
23283 struct group_list
* next
;
23285 for (i
= 0; i
< filedata
->group_count
; i
++)
23287 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
23294 free (filedata
->section_groups
);
23296 memset (&filedata
->section_headers
, 0,
23297 sizeof (Filedata
) - offsetof (Filedata
, section_headers
));
23301 close_file (Filedata
* filedata
)
23305 if (filedata
->handle
)
23306 fclose (filedata
->handle
);
23312 close_debug_file (void * data
)
23314 free_filedata ((Filedata
*) data
);
23315 close_file ((Filedata
*) data
);
23319 open_file (const char * pathname
, bool is_separate
)
23321 struct stat statbuf
;
23322 Filedata
* filedata
= NULL
;
23324 if (stat (pathname
, & statbuf
) < 0
23325 || ! S_ISREG (statbuf
.st_mode
))
23328 filedata
= calloc (1, sizeof * filedata
);
23329 if (filedata
== NULL
)
23332 filedata
->handle
= fopen (pathname
, "rb");
23333 if (filedata
->handle
== NULL
)
23336 filedata
->file_size
= statbuf
.st_size
;
23337 filedata
->file_name
= pathname
;
23338 filedata
->is_separate
= is_separate
;
23340 if (! get_file_header (filedata
))
23343 if (!get_section_headers (filedata
, false))
23351 if (filedata
->handle
)
23352 fclose (filedata
->handle
);
23359 open_debug_file (const char * pathname
)
23361 return open_file (pathname
, true);
23365 initialise_dump_sects (Filedata
* filedata
)
23367 /* Initialise the dump_sects array from the cmdline_dump_sects array.
23368 Note we do this even if cmdline_dump_sects is empty because we
23369 must make sure that the dump_sets array is zeroed out before each
23370 object file is processed. */
23371 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
23372 memset (filedata
->dump
.dump_sects
, 0,
23373 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
23375 if (cmdline
.num_dump_sects
> 0)
23377 if (filedata
->dump
.num_dump_sects
== 0)
23378 /* A sneaky way of allocating the dump_sects array. */
23379 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
23381 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
23382 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
23383 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
23388 might_need_separate_debug_info (Filedata
* filedata
)
23390 /* Debuginfo files do not need further separate file loading. */
23391 if (filedata
->file_header
.e_shstrndx
== SHN_UNDEF
)
23394 /* Since do_follow_links might be enabled by default, only treat it as an
23395 indication that separate files should be loaded if setting it was a
23396 deliberate user action. */
23397 if (DEFAULT_FOR_FOLLOW_LINKS
== 0 && do_follow_links
)
23400 if (process_links
|| do_syms
|| do_unwind
23401 || dump_any_debugging
|| do_dump
|| do_debugging
)
23407 /* Process one ELF object file according to the command line options.
23408 This file may actually be stored in an archive. The file is
23409 positioned at the start of the ELF object. Returns TRUE if no
23410 problems were encountered, FALSE otherwise. */
23413 process_object (Filedata
* filedata
)
23415 bool have_separate_files
;
23419 if (! get_file_header (filedata
))
23421 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
23425 /* Initialise per file variables. */
23426 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
23427 filedata
->version_info
[i
] = 0;
23429 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
23430 filedata
->dynamic_info
[i
] = 0;
23431 filedata
->dynamic_info_DT_GNU_HASH
= 0;
23432 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
23434 /* Process the file. */
23436 printf (_("\nFile: %s\n"), filedata
->file_name
);
23438 initialise_dump_sects (filedata
);
23440 /* There may be some extensions in the first section header. Don't
23441 bomb if we can't read it. */
23442 get_section_headers (filedata
, true);
23444 if (! process_file_header (filedata
))
23450 /* Throw away the single section header read above, so that we
23451 re-read the entire set. */
23452 free (filedata
->section_headers
);
23453 filedata
->section_headers
= NULL
;
23455 if (! process_section_headers (filedata
))
23457 /* Without loaded section headers we cannot process lots of things. */
23458 do_unwind
= do_version
= do_dump
= do_arch
= false;
23460 if (! do_using_dynamic
)
23461 do_syms
= do_dyn_syms
= do_reloc
= false;
23464 if (! process_section_groups (filedata
))
23465 /* Without loaded section groups we cannot process unwind. */
23468 process_program_headers (filedata
);
23470 res
= process_dynamic_section (filedata
);
23472 if (! process_relocs (filedata
))
23475 if (! process_unwind (filedata
))
23478 if (! process_symbol_table (filedata
))
23481 if (! process_lto_symbol_tables (filedata
))
23484 if (! process_syminfo (filedata
))
23487 if (! process_version_sections (filedata
))
23490 if (might_need_separate_debug_info (filedata
))
23491 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
23493 have_separate_files
= false;
23495 if (! process_section_contents (filedata
))
23498 if (have_separate_files
)
23502 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
23504 initialise_dump_sects (d
->handle
);
23506 if (process_links
&& ! process_file_header (d
->handle
))
23508 else if (! process_section_headers (d
->handle
))
23510 else if (! process_section_contents (d
->handle
))
23512 else if (process_links
)
23514 if (! process_section_groups (d
->handle
))
23516 process_program_headers (d
->handle
);
23517 if (! process_dynamic_section (d
->handle
))
23519 if (! process_relocs (d
->handle
))
23521 if (! process_unwind (d
->handle
))
23523 if (! process_symbol_table (d
->handle
))
23525 if (! process_lto_symbol_tables (d
->handle
))
23527 if (! process_syminfo (d
->handle
))
23529 if (! process_version_sections (d
->handle
))
23531 if (! process_notes (d
->handle
))
23536 /* The file handles are closed by the call to free_debug_memory() below. */
23539 if (! process_notes (filedata
))
23542 if (! process_gnu_liblist (filedata
))
23545 if (! process_arch_specific (filedata
))
23549 free_filedata (filedata
);
23551 free_debug_memory ();
23556 /* Process an ELF archive.
23557 On entry the file is positioned just after the ARMAG string.
23558 Returns TRUE upon success, FALSE otherwise. */
23561 process_archive (Filedata
* filedata
, bool is_thin_archive
)
23563 struct archive_info arch
;
23564 struct archive_info nested_arch
;
23570 /* The ARCH structure is used to hold information about this archive. */
23571 arch
.file_name
= NULL
;
23573 arch
.index_array
= NULL
;
23574 arch
.sym_table
= NULL
;
23575 arch
.longnames
= NULL
;
23577 /* The NESTED_ARCH structure is used as a single-item cache of information
23578 about a nested archive (when members of a thin archive reside within
23579 another regular archive file). */
23580 nested_arch
.file_name
= NULL
;
23581 nested_arch
.file
= NULL
;
23582 nested_arch
.index_array
= NULL
;
23583 nested_arch
.sym_table
= NULL
;
23584 nested_arch
.longnames
= NULL
;
23586 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
23587 filedata
->file_size
, is_thin_archive
,
23588 do_archive_index
) != 0)
23594 if (do_archive_index
)
23596 if (arch
.sym_table
== NULL
)
23597 error (_("%s: unable to dump the index as none was found\n"),
23598 filedata
->file_name
);
23602 uint64_t current_pos
;
23604 printf (_("Index of archive %s: (%" PRIu64
" entries,"
23605 " %#" PRIx64
" bytes in the symbol table)\n"),
23606 filedata
->file_name
, arch
.index_num
,
23609 current_pos
= ftell (filedata
->handle
);
23611 for (i
= l
= 0; i
< arch
.index_num
; i
++)
23614 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
23617 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
23620 if (member_name
!= NULL
)
23622 char * qualified_name
23623 = make_qualified_name (&arch
, &nested_arch
,
23626 if (qualified_name
!= NULL
)
23628 printf (_("Contents of binary %s at offset "),
23630 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
23632 free (qualified_name
);
23634 free (member_name
);
23638 if (l
>= arch
.sym_size
)
23640 error (_("%s: end of the symbol table reached "
23641 "before the end of the index\n"),
23642 filedata
->file_name
);
23646 /* PR 17531: file: 0b6630b2. */
23647 printf ("\t%.*s\n",
23648 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
23649 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
23652 if (arch
.uses_64bit_indices
)
23657 if (l
< arch
.sym_size
)
23659 error (ngettext ("%s: %" PRId64
" byte remains in the symbol table, "
23660 "but without corresponding entries in "
23661 "the index table\n",
23662 "%s: %" PRId64
" bytes remain in the symbol table, "
23663 "but without corresponding entries in "
23664 "the index table\n",
23665 arch
.sym_size
- l
),
23666 filedata
->file_name
, arch
.sym_size
- l
);
23670 if (fseek64 (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
23672 error (_("%s: failed to seek back to start of object files "
23673 "in the archive\n"),
23674 filedata
->file_name
);
23680 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
23681 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
23682 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
23683 && !do_section_groups
&& !do_dyn_syms
)
23685 ret
= true; /* Archive index only. */
23694 char * qualified_name
;
23696 /* Read the next archive header. */
23697 if (fseek64 (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
23699 error (_("%s: failed to seek to next archive header\n"),
23704 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
23705 if (got
!= sizeof arch
.arhdr
)
23709 /* PR 24049 - we cannot use filedata->file_name as this will
23710 have already been freed. */
23711 error (_("%s: failed to read archive header\n"), arch
.file_name
);
23716 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
23718 error (_("%s: did not find a valid archive header\n"),
23724 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
23726 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
23728 name
= get_archive_member_name (&arch
, &nested_arch
);
23731 error (_("%s: bad archive file name\n"), arch
.file_name
);
23735 namelen
= strlen (name
);
23737 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
23738 if (qualified_name
== NULL
)
23740 error (_("%s: bad archive file name\n"), arch
.file_name
);
23746 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
23748 /* This is a proxy for an external member of a thin archive. */
23749 Filedata
* member_filedata
;
23750 char * member_file_name
= adjust_relative_path
23751 (filedata
->file_name
, name
, namelen
);
23754 if (member_file_name
== NULL
)
23756 free (qualified_name
);
23761 member_filedata
= open_file (member_file_name
, false);
23762 if (member_filedata
== NULL
)
23764 error (_("Input file '%s' is not readable.\n"), member_file_name
);
23765 free (member_file_name
);
23766 free (qualified_name
);
23771 filedata
->archive_file_offset
= arch
.nested_member_origin
;
23772 member_filedata
->file_name
= qualified_name
;
23774 /* The call to process_object() expects the file to be at the beginning. */
23775 rewind (member_filedata
->handle
);
23777 if (! process_object (member_filedata
))
23780 close_file (member_filedata
);
23781 free (member_file_name
);
23783 else if (is_thin_archive
)
23785 Filedata thin_filedata
;
23787 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
23789 /* PR 15140: Allow for corrupt thin archives. */
23790 if (nested_arch
.file
== NULL
)
23792 error (_("%s: contains corrupt thin archive: %s\n"),
23793 qualified_name
, name
);
23794 free (qualified_name
);
23801 /* This is a proxy for a member of a nested archive. */
23802 filedata
->archive_file_offset
23803 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
23805 /* The nested archive file will have been opened and setup by
23806 get_archive_member_name. */
23807 if (fseek64 (nested_arch
.file
, filedata
->archive_file_offset
,
23810 error (_("%s: failed to seek to archive member.\n"),
23811 nested_arch
.file_name
);
23812 free (qualified_name
);
23817 thin_filedata
.handle
= nested_arch
.file
;
23818 thin_filedata
.file_name
= qualified_name
;
23820 if (! process_object (& thin_filedata
))
23826 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
23827 filedata
->file_name
= qualified_name
;
23828 if (! process_object (filedata
))
23830 arch
.next_arhdr_offset
+= (filedata
->archive_file_size
+ 1) & -2;
23831 /* Stop looping with "negative" archive_file_size. */
23832 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
23833 arch
.next_arhdr_offset
= -1ul;
23836 free (qualified_name
);
23840 if (nested_arch
.file
!= NULL
)
23841 fclose (nested_arch
.file
);
23842 release_archive (&nested_arch
);
23843 release_archive (&arch
);
23849 process_file (char * file_name
)
23851 Filedata
* filedata
= NULL
;
23852 struct stat statbuf
;
23853 char armag
[SARMAG
];
23856 if (stat (file_name
, &statbuf
) < 0)
23858 if (errno
== ENOENT
)
23859 error (_("'%s': No such file\n"), file_name
);
23861 error (_("Could not locate '%s'. System error message: %s\n"),
23862 file_name
, strerror (errno
));
23866 if (! S_ISREG (statbuf
.st_mode
))
23868 error (_("'%s' is not an ordinary file\n"), file_name
);
23872 filedata
= calloc (1, sizeof * filedata
);
23873 if (filedata
== NULL
)
23875 error (_("Out of memory allocating file data structure\n"));
23879 filedata
->file_name
= file_name
;
23880 filedata
->handle
= fopen (file_name
, "rb");
23881 if (filedata
->handle
== NULL
)
23883 error (_("Input file '%s' is not readable.\n"), file_name
);
23888 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
23890 error (_("%s: Failed to read file's magic number\n"), file_name
);
23891 fclose (filedata
->handle
);
23896 filedata
->file_size
= statbuf
.st_size
;
23897 filedata
->is_separate
= false;
23899 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
23901 if (! process_archive (filedata
, false))
23904 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
23906 if ( ! process_archive (filedata
, true))
23911 if (do_archive_index
&& !check_all
)
23912 error (_("File %s is not an archive so its index cannot be displayed.\n"),
23915 rewind (filedata
->handle
);
23916 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
23918 if (! process_object (filedata
))
23922 fclose (filedata
->handle
);
23923 free (filedata
->section_headers
);
23924 free (filedata
->program_headers
);
23925 free (filedata
->string_table
);
23926 free (filedata
->dump
.dump_sects
);
23929 free (ba_cache
.strtab
);
23930 ba_cache
.strtab
= NULL
;
23931 free (ba_cache
.symtab
);
23932 ba_cache
.symtab
= NULL
;
23933 ba_cache
.filedata
= NULL
;
23938 #ifdef SUPPORT_DISASSEMBLY
23939 /* Needed by the i386 disassembler. For extra credit, someone could
23940 fix this so that we insert symbolic addresses here, esp for GOT/PLT
23944 print_address (unsigned int addr
, FILE * outfile
)
23946 fprintf (outfile
,"0x%8.8x", addr
);
23949 /* Needed by the i386 disassembler. */
23952 db_task_printsym (unsigned int addr
)
23954 print_address (addr
, stderr
);
23959 main (int argc
, char ** argv
)
23963 #ifdef HAVE_LC_MESSAGES
23964 setlocale (LC_MESSAGES
, "");
23966 setlocale (LC_CTYPE
, "");
23967 bindtextdomain (PACKAGE
, LOCALEDIR
);
23968 textdomain (PACKAGE
);
23970 expandargv (&argc
, &argv
);
23972 parse_args (& cmdline
, argc
, argv
);
23974 if (optind
< (argc
- 1))
23975 /* When displaying information for more than one file,
23976 prefix the information with the file name. */
23978 else if (optind
>= argc
)
23980 /* Ensure that the warning is always displayed. */
23983 warn (_("Nothing to do.\n"));
23988 while (optind
< argc
)
23989 if (! process_file (argv
[optind
++]))
23992 free (cmdline
.dump_sects
);
23994 free (dump_ctf_symtab_name
);
23995 free (dump_ctf_strtab_name
);
23996 free (dump_ctf_parent_name
);
23998 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;