1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2023 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
52 #if defined HAVE_MSGPACK
56 /* Define BFD64 here, even if our default architecture is 32 bit ELF
57 as this will allow us to read in and parse 64bit and 32bit ELF files. */
63 #include "demanguse.h"
66 #include "sframe-api.h"
69 #include "elf/common.h"
70 #include "elf/external.h"
71 #include "elf/internal.h"
74 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
75 we can obtain the H8 reloc numbers. We need these for the
76 get_reloc_size() function. We include h8.h again after defining
77 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
82 /* Undo the effects of #including reloc-macros.h. */
84 #undef START_RELOC_NUMBERS
88 #undef END_RELOC_NUMBERS
89 #undef _RELOC_MACROS_H
91 /* The following headers use the elf/reloc-macros.h file to
92 automatically generate relocation recognition functions
93 such as elf_mips_reloc_type() */
95 #define RELOC_MACROS_GEN_FUNC
97 #include "elf/aarch64.h"
98 #include "elf/alpha.h"
99 #include "elf/amdgpu.h"
103 #include "elf/bfin.h"
104 #include "elf/cr16.h"
105 #include "elf/cris.h"
107 #include "elf/csky.h"
108 #include "elf/d10v.h"
109 #include "elf/d30v.h"
112 #include "elf/epiphany.h"
113 #include "elf/fr30.h"
115 #include "elf/ft32.h"
117 #include "elf/hppa.h"
118 #include "elf/i386.h"
119 #include "elf/i370.h"
120 #include "elf/i860.h"
121 #include "elf/i960.h"
122 #include "elf/ia64.h"
123 #include "elf/ip2k.h"
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 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
192 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
193 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
194 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
195 #define CTF_DUMP (1 << 5) /* The --ctf command line switch. */
196 #define SFRAME_DUMP (1 << 6) /* The --sframe command line switch. */
198 typedef unsigned char dump_type
;
200 /* A linked list of the section names for which dumps were requested. */
201 struct dump_list_entry
205 struct dump_list_entry
* next
;
208 /* A dynamic array of flags indicating for which sections a dump
209 has been requested via command line switches. */
212 dump_type
* dump_sects
;
213 unsigned int num_dump_sects
;
216 static struct dump_data cmdline
;
218 static struct dump_list_entry
* dump_sects_byname
;
220 char * program_name
= "readelf";
222 static bool show_name
= false;
223 static bool do_dynamic
= false;
224 static bool do_syms
= false;
225 static bool do_dyn_syms
= false;
226 static bool do_lto_syms
= false;
227 static bool do_reloc
= false;
228 static bool do_sections
= false;
229 static bool do_section_groups
= false;
230 static bool do_section_details
= false;
231 static bool do_segments
= false;
232 static bool do_unwind
= false;
233 static bool do_using_dynamic
= false;
234 static bool do_header
= false;
235 static bool do_dump
= false;
236 static bool do_version
= false;
237 static bool do_histogram
= false;
238 static bool do_debugging
= false;
239 static bool do_ctf
= false;
240 static bool do_sframe
= false;
241 static bool do_arch
= false;
242 static bool do_notes
= false;
243 static bool do_archive_index
= false;
244 static bool check_all
= false;
245 static bool is_32bit_elf
= false;
246 static bool decompress_dumps
= false;
247 static bool do_not_show_symbol_truncation
= false;
248 static bool do_demangle
= false; /* Pretty print C++ symbol names. */
249 static bool process_links
= false;
250 static bool dump_any_debugging
= false;
251 static bool extra_sym_info
= false;
252 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
253 static int sym_base
= 0;
255 static char *dump_ctf_parent_name
;
256 static char *dump_ctf_symtab_name
;
257 static char *dump_ctf_strtab_name
;
261 struct group_list
* next
;
262 unsigned int section_index
;
267 struct group_list
* root
;
268 unsigned int group_index
;
271 typedef struct filedata
273 const char * file_name
;
277 Elf_Internal_Ehdr file_header
;
278 uint64_t archive_file_offset
;
279 uint64_t archive_file_size
;
280 /* Everything below this point is cleared out by free_filedata. */
281 Elf_Internal_Shdr
* section_headers
;
282 Elf_Internal_Phdr
* program_headers
;
284 uint64_t string_table_length
;
285 uint64_t dynamic_addr
;
286 uint64_t dynamic_size
;
287 uint64_t dynamic_nent
;
288 Elf_Internal_Dyn
* dynamic_section
;
289 Elf_Internal_Shdr
* dynamic_strtab_section
;
290 char * dynamic_strings
;
291 uint64_t dynamic_strings_length
;
292 Elf_Internal_Shdr
* dynamic_symtab_section
;
293 uint64_t num_dynamic_syms
;
294 Elf_Internal_Sym
* dynamic_symbols
;
295 uint64_t version_info
[16];
296 unsigned int dynamic_syminfo_nent
;
297 Elf_Internal_Syminfo
* dynamic_syminfo
;
298 uint64_t dynamic_syminfo_offset
;
303 uint64_t ngnubuckets
;
305 uint64_t * gnubuckets
;
306 uint64_t * gnuchains
;
309 char * program_interpreter
;
310 uint64_t dynamic_info
[DT_RELRENT
+ 1];
311 uint64_t dynamic_info_DT_GNU_HASH
;
312 uint64_t dynamic_info_DT_MIPS_XHASH
;
313 elf_section_list
* symtab_shndx_list
;
315 struct group
* section_groups
;
316 struct group
** section_headers_groups
;
317 /* A dynamic array of flags indicating for which sections a dump of
318 some kind has been requested. It is reset on a per-object file
319 basis and then initialised from the cmdline_dump_sects array,
320 the results of interpreting the -w switch, and the
321 dump_sects_byname list. */
322 struct dump_data dump
;
325 /* How to print a vma value. */
326 typedef enum print_mode
343 typedef enum unicode_display_type
351 } unicode_display_type
;
353 static unicode_display_type unicode_display
= unicode_default
;
363 /* Versioned symbol info. */
364 enum versioned_symbol_info
372 fseek64 (FILE *stream
, int64_t offset
, int whence
)
374 #if defined (HAVE_FSEEKO64)
381 return fseeko64 (stream
, o
, whence
);
382 #elif defined (HAVE_FSEEKO)
389 return fseeko (stream
, o
, whence
);
397 return fseek (stream
, o
, whence
);
401 static const char * get_symbol_version_string
402 (Filedata
*, bool, const char *, size_t, unsigned,
403 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
407 static inline const char *
408 section_name (const Filedata
*filedata
, const Elf_Internal_Shdr
*hdr
)
410 return filedata
->string_table
+ hdr
->sh_name
;
414 section_name_valid (const Filedata
*filedata
, const Elf_Internal_Shdr
*hdr
)
416 return (filedata
!= NULL
418 && filedata
->string_table
!= NULL
419 && hdr
->sh_name
< filedata
->string_table_length
);
422 /* Returns true if the given index is real/valid. Note: "real" here
423 means "references a real section in the section header" and not
424 "is a valid section index as per the ELF standard". */
427 section_index_real (const Filedata
*filedata
, unsigned int ndx
)
429 return (filedata
!= NULL
430 && filedata
->section_headers
!= NULL
431 && ndx
< filedata
->file_header
.e_shnum
435 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
438 valid_symbol_name (const char *strtab
, size_t strtab_size
, uint64_t offset
)
440 return strtab
!= NULL
&& offset
< strtab_size
;
444 valid_dynamic_name (const Filedata
*filedata
, uint64_t offset
)
446 return valid_symbol_name (filedata
->dynamic_strings
,
447 filedata
->dynamic_strings_length
, offset
);
450 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
451 already been called and verified that the string exists. */
452 static inline const char *
453 get_dynamic_name (const Filedata
*filedata
, size_t offset
)
455 return filedata
->dynamic_strings
+ offset
;
458 #define REMOVE_ARCH_BITS(ADDR) \
461 if (filedata->file_header.e_machine == EM_ARM) \
466 /* Get the correct GNU hash section name. */
467 #define GNU_HASH_SECTION_NAME(filedata) \
468 filedata->dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
470 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
471 OFFSET + the offset of the current archive member, if we are examining an
472 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
473 allocate a buffer using malloc and fill that. In either case return the
474 pointer to the start of the retrieved data or NULL if something went wrong.
475 If something does go wrong and REASON is not NULL then emit an error
476 message using REASON as part of the context. */
487 uint64_t amt
= size
* nmemb
;
489 if (size
== 0 || nmemb
== 0)
492 /* If size_t is smaller than uint64_t, eg because you are building
493 on a 32-bit host, then make sure that when the sizes are cast to
494 size_t no information is lost. */
495 if ((size_t) size
!= size
496 || (size_t) nmemb
!= nmemb
497 || (size_t) amt
!= amt
498 || amt
/ size
!= nmemb
499 || (size_t) amt
+ 1 == 0)
502 error (_("Size overflow prevents reading %" PRIu64
503 " elements of size %" PRIu64
" for %s\n"),
504 nmemb
, size
, reason
);
508 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
509 attempting to allocate memory when the read is bound to fail. */
510 if (filedata
->archive_file_offset
> filedata
->file_size
511 || offset
> filedata
->file_size
- filedata
->archive_file_offset
512 || amt
> filedata
->file_size
- filedata
->archive_file_offset
- offset
)
515 error (_("Reading %" PRIu64
" bytes extends past end of file for %s\n"),
520 if (fseek64 (filedata
->handle
, filedata
->archive_file_offset
+ offset
,
524 error (_("Unable to seek to %#" PRIx64
" for %s\n"),
525 filedata
->archive_file_offset
+ offset
, reason
);
532 /* + 1 so that we can '\0' terminate invalid string table sections. */
533 mvar
= malloc ((size_t) amt
+ 1);
538 error (_("Out of memory allocating %" PRIu64
" bytes for %s\n"),
543 ((char *) mvar
)[amt
] = '\0';
546 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
549 error (_("Unable to read in %" PRIu64
" bytes of %s\n"),
559 /* Print a VMA value in the MODE specified.
560 Returns the number of characters displayed. */
563 print_vma (uint64_t vma
, print_mode mode
)
574 return nc
+ printf ("%16.16" PRIx64
, vma
);
575 return nc
+ printf ("%8.8" PRIx64
, vma
);
579 return printf ("%5" PRId64
, vma
);
585 return nc
+ printf ("%" PRIx64
, vma
);
591 return nc
+ printf ("%05" PRIx64
, vma
);
594 return printf ("%" PRId64
, vma
);
597 return printf ("%" PRIu64
, vma
);
600 return printf ("%5" PRIu64
, vma
);
603 return printf ("%" PRIo64
, vma
);
606 return printf ("%5" PRIo64
, vma
);
609 /* FIXME: Report unrecognised mode ? */
615 /* Display a symbol on stdout. Handles the display of control characters and
616 multibye characters (assuming the host environment supports them).
618 Display at most abs(WIDTH) characters, truncating as necessary,
619 unless do_wide or extra_sym_info is true.
621 If truncation will happen and do_not_show_symbol_truncation is FALSE then display
622 abs(WIDTH) - 5 characters followed by "[...]".
624 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
625 padding as necessary.
627 Returns the number of emitted characters. */
630 print_symbol_name (signed int width
, const char * symbol
)
632 bool extra_padding
= false;
633 bool do_dots
= false;
634 signed int num_printed
= 0;
635 #ifdef HAVE_MBSTATE_T
638 unsigned int width_remaining
;
639 const void * alloced_symbol
= NULL
;
643 /* Keep the width positive. This helps the code below. */
645 extra_padding
= true;
650 if (do_wide
|| extra_sym_info
)
651 /* Set the remaining width to a very large value.
652 This simplifies the code below. */
653 width_remaining
= INT_MAX
;
656 width_remaining
= width
;
658 if (! do_not_show_symbol_truncation
659 && (int) strlen (symbol
) > width
)
661 width_remaining
-= 5;
662 if ((int) width_remaining
< 0)
668 #ifdef HAVE_MBSTATE_T
669 /* Initialise the multibyte conversion state. */
670 memset (& state
, 0, sizeof (state
));
673 if (do_demangle
&& *symbol
)
675 const char * res
= cplus_demangle (symbol
, demangle_flags
);
678 alloced_symbol
= symbol
= res
;
681 while (width_remaining
)
684 const char c
= *symbol
++;
695 else if (ISCNTRL (c
))
697 /* Do not print control characters directly as they can affect terminal
698 settings. Such characters usually appear in the names generated
699 by the assembler for local labels. */
701 if (width_remaining
< 2)
704 printf ("^%c", c
+ 0x40);
705 width_remaining
-= 2;
710 if (width_remaining
< 5)
713 width_remaining
-= 5;
716 else if (unicode_display
!= unicode_locale
717 && unicode_display
!= unicode_default
)
719 /* Display unicode characters as something else. */
720 unsigned char bytes
[4];
733 bytes
[1] = *symbol
++;
735 if ((bytes
[1] & 0xc0) != 0x80)
738 /* Do not consume this character. It may only
739 be the first byte in the sequence that was
744 else if ((bytes
[0] & 0x20) == 0)
751 bytes
[2] = *symbol
++;
753 if ((bytes
[2] & 0xc0) != 0x80)
759 else if ((bytes
[0] & 0x10) == 0)
766 bytes
[3] = *symbol
++;
770 if ((bytes
[3] & 0xc0) != 0x80)
782 if (unicode_display
== unicode_invalid
)
785 if (unicode_display
== unicode_hex
|| ! is_utf8
)
789 if (width_remaining
< (nbytes
* 2) + 2)
792 putchar (is_utf8
? '<' : '{');
794 for (i
= 0; i
< nbytes
; i
++)
795 printf ("%02x", bytes
[i
]);
796 putchar (is_utf8
? '>' : '}');
800 if (unicode_display
== unicode_highlight
&& isatty (1))
801 printf ("\x1B[31;47m"); /* Red. */
806 if (width_remaining
< 6)
808 printf ("\\u%02x%02x",
809 (bytes
[0] & 0x1c) >> 2,
810 ((bytes
[0] & 0x03) << 6) | (bytes
[1] & 0x3f));
813 if (width_remaining
< 6)
815 printf ("\\u%02x%02x",
816 ((bytes
[0] & 0x0f) << 4) | ((bytes
[1] & 0x3c) >> 2),
817 ((bytes
[1] & 0x03) << 6) | (bytes
[2] & 0x3f));
820 if (width_remaining
< 8)
822 printf ("\\u%02x%02x%02x",
823 ((bytes
[0] & 0x07) << 6) | ((bytes
[1] & 0x3c) >> 2),
824 ((bytes
[1] & 0x03) << 6) | ((bytes
[2] & 0x3c) >> 2),
825 ((bytes
[2] & 0x03) << 6) | (bytes
[3] & 0x3f));
833 if (unicode_display
== unicode_highlight
&& isatty (1))
834 printf ("\033[0m"); /* Default colour. */
837 if (bytes
[nbytes
- 1] == 0)
842 #ifdef HAVE_MBSTATE_T
845 /* Let printf do the hard work of displaying multibyte characters. */
846 printf ("%.1s", symbol
- 1);
850 #ifdef HAVE_MBSTATE_T
851 /* Try to find out how many bytes made up the character that was
852 just printed. Advance the symbol pointer past the bytes that
854 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
858 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
864 num_printed
+= printf ("[...]");
866 if (extra_padding
&& num_printed
< width
)
868 /* Fill in the remaining spaces. */
869 printf ("%-*s", width
- num_printed
, " ");
873 free ((void *) alloced_symbol
);
877 /* Returns a pointer to a static buffer containing a printable version of
878 the given section's name. Like print_symbol, except that it does not try
879 to print multibyte characters, it just interprets them as hex values. */
882 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
884 #define NUM_SEC_NAME_BUFS 5
885 #define MAX_PRINT_SEC_NAME_LEN 256
887 static int sec_name_buf_index
= 0;
888 /* We use a rotating array of static buffers, so that multiple successive calls
889 to printable_section_name() will still work. eg when used in a printf. */
890 static char sec_name_buf
[NUM_SEC_NAME_BUFS
][MAX_PRINT_SEC_NAME_LEN
+ 1];
896 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
898 /* Validate the input parameters. */
899 if (filedata
== NULL
)
900 return _("<internal error>");
903 if (filedata
->string_table
== NULL
)
904 return _("<no-strings>");
905 if (sec
->sh_name
>= filedata
->string_table_length
)
906 return _("<corrupt>");
908 /* Select a buffer to use. */
909 buf_start
= buf
= sec_name_buf
[sec_name_buf_index
];
910 if (++sec_name_buf_index
>= NUM_SEC_NAME_BUFS
)
911 sec_name_buf_index
= 0;
913 name
= section_name (filedata
, sec
);
915 while ((c
= * name
++) != 0)
926 else if (ISPRINT (c
))
933 static char hex
[17] = "0123456789ABCDEF";
938 * buf
++ = hex
[(c
& 0xf0) >> 4];
939 * buf
++ = hex
[c
& 0x0f];
952 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
953 This OS has so many departures from the ELF standard that we test it at
957 is_ia64_vms (Filedata
* filedata
)
959 return filedata
->file_header
.e_machine
== EM_IA_64
960 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
964 printable_section_name_from_index (Filedata
* filedata
,
968 if (is_special
!= NULL
)
973 case SHN_UNDEF
: return "UND";
974 case SHN_ABS
: return "ABS";
975 case SHN_COMMON
: return "COM";
979 if (filedata
!= NULL
)
981 switch (filedata
->file_header
.e_machine
)
984 if (ndx
== SHN_MIPS_SCOMMON
)
986 if (ndx
== SHN_MIPS_SUNDEFINED
)
991 if (ndx
== SHN_TIC6X_SCOMMON
)
998 if (ndx
== SHN_X86_64_LCOMMON
)
1003 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1004 && ndx
== SHN_IA_64_ANSI_COMMON
)
1007 if (is_ia64_vms (filedata
) && ndx
== SHN_IA_64_VMS_SYMVEC
)
1008 return "VMS_SYMVEC";
1015 if (filedata
->section_headers
!= NULL
1016 && ndx
< filedata
->file_header
.e_shnum
)
1020 res
= printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
1021 if (is_special
!= NULL
)
1022 * is_special
= (res
[0] == '<');
1028 static char name_buf
[40];
1029 unsigned int short_ndx
= (unsigned int) (ndx
& 0xffff);
1031 if (ndx
>= SHN_LOPROC
&& ndx
<= SHN_HIPROC
)
1032 sprintf (name_buf
, "PRC[0x%04x]", short_ndx
);
1033 else if (ndx
>= SHN_LOOS
&& ndx
<= SHN_HIOS
)
1034 sprintf (name_buf
, "OS [0x%04x]", short_ndx
);
1035 else if (ndx
>= SHN_LORESERVE
)
1036 sprintf (name_buf
, "RSV[0x%04x]", short_ndx
);
1037 else if (filedata
->file_header
.e_shnum
!= 0
1038 && ndx
>= filedata
->file_header
.e_shnum
)
1039 sprintf (name_buf
, _("BAD[0x%lx]"), (long) ndx
);
1041 sprintf (name_buf
, "<section 0x%lx>", (long) ndx
);
1046 /* Return a pointer to section NAME, or NULL if no such section exists. */
1048 static Elf_Internal_Shdr
*
1049 find_section (Filedata
* filedata
, const char * name
)
1053 if (filedata
->section_headers
== NULL
)
1056 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
1057 if (section_name_valid (filedata
, filedata
->section_headers
+ i
)
1058 && streq (section_name (filedata
, filedata
->section_headers
+ i
),
1060 return filedata
->section_headers
+ i
;
1065 /* Return a pointer to a section containing ADDR, or NULL if no such
1068 static Elf_Internal_Shdr
*
1069 find_section_by_address (Filedata
* filedata
, uint64_t addr
)
1073 if (filedata
->section_headers
== NULL
)
1076 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
1078 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
1080 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
1087 static Elf_Internal_Shdr
*
1088 find_section_by_type (Filedata
* filedata
, unsigned int type
)
1092 if (filedata
->section_headers
== NULL
)
1095 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
1097 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
1099 if (sec
->sh_type
== type
)
1106 /* Return a pointer to section NAME, or NULL if no such section exists,
1107 restricted to the list of sections given in SET. */
1109 static Elf_Internal_Shdr
*
1110 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
1114 if (filedata
->section_headers
== NULL
)
1119 while ((i
= *set
++) > 0)
1121 /* See PR 21156 for a reproducer. */
1122 if (i
>= filedata
->file_header
.e_shnum
)
1123 continue; /* FIXME: Should we issue an error message ? */
1125 if (section_name_valid (filedata
, filedata
->section_headers
+ i
)
1126 && streq (section_name (filedata
, filedata
->section_headers
+ i
),
1128 return filedata
->section_headers
+ i
;
1132 return find_section (filedata
, name
);
1135 /* Guess the relocation size commonly used by the specific machines. */
1138 guess_is_rela (unsigned int e_machine
)
1142 /* Targets that use REL relocations. */
1148 case EM_CYGNUS_D10V
:
1151 case EM_MIPS_RS3_LE
:
1152 case EM_CYGNUS_M32R
:
1159 /* Targets that use RELA relocations. */
1163 case EM_ADAPTEVA_EPIPHANY
:
1165 case EM_ALTERA_NIOS2
:
1167 case EM_ARC_COMPACT
:
1168 case EM_ARC_COMPACT2
:
1169 case EM_ARC_COMPACT3
:
1170 case EM_ARC_COMPACT3_64
:
1179 case EM_CYGNUS_D30V
:
1182 case EM_CYGNUS_FR30
:
1192 case EM_LATTICEMICO32
:
1201 case EM_CYGNUS_MN10200
:
1203 case EM_CYGNUS_MN10300
:
1221 case EM_SPARC32PLUS
:
1229 case EM_CYGNUS_V850
:
1239 case EM_MICROBLAZE_OLD
:
1240 case EM_WEBASSEMBLY
:
1261 warn (_("Don't know about relocations on this machine architecture\n"));
1266 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1267 Returns TRUE upon success, FALSE otherwise. If successful then a
1268 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
1269 and the number of relocs loaded is placed in *NRELASP. It is the caller's
1270 responsibility to free the allocated buffer. */
1273 slurp_rela_relocs (Filedata
*filedata
,
1274 uint64_t rel_offset
,
1276 Elf_Internal_Rela
**relasp
,
1279 Elf_Internal_Rela
* relas
;
1285 Elf32_External_Rela
* erelas
;
1287 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
1288 rel_size
, _("32-bit relocation data"));
1292 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
1294 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
1295 sizeof (Elf_Internal_Rela
));
1300 error (_("out of memory parsing relocs\n"));
1304 for (i
= 0; i
< nrelas
; i
++)
1306 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
1307 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
1308 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
1315 Elf64_External_Rela
* erelas
;
1317 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
1318 rel_size
, _("64-bit relocation data"));
1322 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
1324 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
1325 sizeof (Elf_Internal_Rela
));
1330 error (_("out of memory parsing relocs\n"));
1334 for (i
= 0; i
< nrelas
; i
++)
1336 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
1337 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
1338 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
1340 if (filedata
->file_header
.e_machine
== EM_MIPS
1341 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1343 /* In little-endian objects, r_info isn't really a
1344 64-bit little-endian value: it has a 32-bit
1345 little-endian symbol index followed by four
1346 individual byte fields. Reorder INFO
1348 uint64_t inf
= relas
[i
].r_info
;
1349 inf
= (((inf
& 0xffffffff) << 32)
1350 | ((inf
>> 56) & 0xff)
1351 | ((inf
>> 40) & 0xff00)
1352 | ((inf
>> 24) & 0xff0000)
1353 | ((inf
>> 8) & 0xff000000));
1354 relas
[i
].r_info
= inf
;
1366 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1367 Returns TRUE upon success, FALSE otherwise. If successful then a
1368 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1369 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1370 responsibility to free the allocated buffer. */
1373 slurp_rel_relocs (Filedata
*filedata
,
1374 uint64_t rel_offset
,
1376 Elf_Internal_Rela
**relsp
,
1379 Elf_Internal_Rela
* rels
;
1385 Elf32_External_Rel
* erels
;
1387 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1388 rel_size
, _("32-bit relocation data"));
1392 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1394 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1399 error (_("out of memory parsing relocs\n"));
1403 for (i
= 0; i
< nrels
; i
++)
1405 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1406 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1407 rels
[i
].r_addend
= 0;
1414 Elf64_External_Rel
* erels
;
1416 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1417 rel_size
, _("64-bit relocation data"));
1421 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1423 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1428 error (_("out of memory parsing relocs\n"));
1432 for (i
= 0; i
< nrels
; i
++)
1434 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1435 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1436 rels
[i
].r_addend
= 0;
1438 if (filedata
->file_header
.e_machine
== EM_MIPS
1439 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1441 /* In little-endian objects, r_info isn't really a
1442 64-bit little-endian value: it has a 32-bit
1443 little-endian symbol index followed by four
1444 individual byte fields. Reorder INFO
1446 uint64_t inf
= rels
[i
].r_info
;
1447 inf
= (((inf
& 0xffffffff) << 32)
1448 | ((inf
>> 56) & 0xff)
1449 | ((inf
>> 40) & 0xff00)
1450 | ((inf
>> 24) & 0xff0000)
1451 | ((inf
>> 8) & 0xff000000));
1452 rels
[i
].r_info
= inf
;
1465 slurp_relr_relocs (Filedata
*filedata
,
1466 uint64_t relr_offset
,
1472 size_t size
= 0, nentries
, i
;
1473 uint64_t base
= 0, addr
, entry
;
1475 relrs
= get_data (NULL
, filedata
, relr_offset
, 1, relr_size
,
1476 _("RELR relocation data"));
1481 nentries
= relr_size
/ sizeof (Elf32_External_Relr
);
1483 nentries
= relr_size
/ sizeof (Elf64_External_Relr
);
1484 for (i
= 0; i
< nentries
; i
++)
1487 entry
= BYTE_GET (((Elf32_External_Relr
*)relrs
)[i
].r_data
);
1489 entry
= BYTE_GET (((Elf64_External_Relr
*)relrs
)[i
].r_data
);
1490 if ((entry
& 1) == 0)
1493 while ((entry
>>= 1) != 0)
1494 if ((entry
& 1) == 1)
1498 *relrsp
= malloc (size
* sizeof (**relrsp
));
1499 if (*relrsp
== NULL
)
1502 error (_("out of memory parsing relocs\n"));
1507 for (i
= 0; i
< nentries
; i
++)
1509 const uint64_t entry_bytes
= is_32bit_elf
? 4 : 8;
1512 entry
= BYTE_GET (((Elf32_External_Relr
*)relrs
)[i
].r_data
);
1514 entry
= BYTE_GET (((Elf64_External_Relr
*)relrs
)[i
].r_data
);
1515 if ((entry
& 1) == 0)
1517 (*relrsp
)[size
++] = entry
;
1518 base
= entry
+ entry_bytes
;
1522 for (addr
= base
; (entry
>>= 1) != 0; addr
+= entry_bytes
)
1523 if ((entry
& 1) != 0)
1524 (*relrsp
)[size
++] = addr
;
1525 base
+= entry_bytes
* (entry_bytes
* CHAR_BIT
- 1);
1534 /* Returns the reloc type extracted from the reloc info field. */
1537 get_reloc_type (Filedata
* filedata
, uint64_t reloc_info
)
1540 return ELF32_R_TYPE (reloc_info
);
1542 switch (filedata
->file_header
.e_machine
)
1545 /* Note: We assume that reloc_info has already been adjusted for us. */
1546 return ELF64_MIPS_R_TYPE (reloc_info
);
1549 return ELF64_R_TYPE_ID (reloc_info
);
1552 return ELF64_R_TYPE (reloc_info
);
1556 /* Return the symbol index extracted from the reloc info field. */
1559 get_reloc_symindex (uint64_t reloc_info
)
1561 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1565 uses_msp430x_relocs (Filedata
* filedata
)
1568 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1569 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1570 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1571 /* TI compiler uses ELFOSABI_NONE. */
1572 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1575 /* Display the contents of the relocation data found at the specified
1579 dump_relocations (Filedata
*filedata
,
1580 uint64_t rel_offset
,
1582 Elf_Internal_Sym
*symtab
,
1586 relocation_type rel_type
,
1590 Elf_Internal_Rela
* rels
;
1593 if (rel_type
== reltype_unknown
)
1594 rel_type
= guess_is_rela (filedata
->file_header
.e_machine
) ? reltype_rela
: reltype_rel
;
1596 if (rel_type
== reltype_rela
)
1598 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1601 else if (rel_type
== reltype_rel
)
1603 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1606 else if (rel_type
== reltype_relr
)
1610 = is_32bit_elf
? "%08" PRIx64
"\n" : "%016" PRIx64
"\n";
1612 if (!slurp_relr_relocs (filedata
, rel_offset
, rel_size
, &relrs
,
1616 printf (ngettext (" %" PRIu64
" offset\n",
1617 " %" PRIu64
" offsets\n", rel_size
),
1619 for (i
= 0; i
< rel_size
; i
++)
1620 printf (format
, relrs
[i
]);
1627 if (rel_type
== reltype_rela
)
1630 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1632 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1637 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1639 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1644 if (rel_type
== reltype_rela
)
1647 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1649 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1654 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1656 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1660 for (i
= 0; i
< rel_size
; i
++)
1665 uint64_t symtab_index
;
1668 offset
= rels
[i
].r_offset
;
1669 inf
= rels
[i
].r_info
;
1671 type
= get_reloc_type (filedata
, inf
);
1672 symtab_index
= get_reloc_symindex (inf
);
1676 printf ("%8.8lx %8.8lx ",
1677 (unsigned long) offset
& 0xffffffff,
1678 (unsigned long) inf
& 0xffffffff);
1683 ? "%16.16" PRIx64
" %16.16" PRIx64
" "
1684 : "%12.12" PRIx64
" %12.12" PRIx64
" ",
1688 switch (filedata
->file_header
.e_machine
)
1695 rtype
= elf_aarch64_reloc_type (type
);
1699 case EM_CYGNUS_M32R
:
1700 rtype
= elf_m32r_reloc_type (type
);
1705 rtype
= elf_i386_reloc_type (type
);
1710 rtype
= elf_m68hc11_reloc_type (type
);
1714 rtype
= elf_s12z_reloc_type (type
);
1718 rtype
= elf_m68k_reloc_type (type
);
1722 rtype
= elf_i960_reloc_type (type
);
1727 rtype
= elf_avr_reloc_type (type
);
1730 case EM_OLD_SPARCV9
:
1731 case EM_SPARC32PLUS
:
1734 rtype
= elf_sparc_reloc_type (type
);
1738 rtype
= elf_spu_reloc_type (type
);
1742 rtype
= v800_reloc_type (type
);
1745 case EM_CYGNUS_V850
:
1746 rtype
= v850_reloc_type (type
);
1750 case EM_CYGNUS_D10V
:
1751 rtype
= elf_d10v_reloc_type (type
);
1755 case EM_CYGNUS_D30V
:
1756 rtype
= elf_d30v_reloc_type (type
);
1760 rtype
= elf_dlx_reloc_type (type
);
1764 rtype
= elf_sh_reloc_type (type
);
1768 case EM_CYGNUS_MN10300
:
1769 rtype
= elf_mn10300_reloc_type (type
);
1773 case EM_CYGNUS_MN10200
:
1774 rtype
= elf_mn10200_reloc_type (type
);
1778 case EM_CYGNUS_FR30
:
1779 rtype
= elf_fr30_reloc_type (type
);
1783 rtype
= elf_frv_reloc_type (type
);
1787 rtype
= elf_csky_reloc_type (type
);
1791 rtype
= elf_ft32_reloc_type (type
);
1795 rtype
= elf_mcore_reloc_type (type
);
1799 rtype
= elf_mmix_reloc_type (type
);
1803 rtype
= elf_moxie_reloc_type (type
);
1807 if (uses_msp430x_relocs (filedata
))
1809 rtype
= elf_msp430x_reloc_type (type
);
1814 rtype
= elf_msp430_reloc_type (type
);
1818 rtype
= elf_nds32_reloc_type (type
);
1822 rtype
= elf_ppc_reloc_type (type
);
1826 rtype
= elf_ppc64_reloc_type (type
);
1830 case EM_MIPS_RS3_LE
:
1831 rtype
= elf_mips_reloc_type (type
);
1835 rtype
= elf_riscv_reloc_type (type
);
1839 rtype
= elf_alpha_reloc_type (type
);
1843 rtype
= elf_arm_reloc_type (type
);
1847 case EM_ARC_COMPACT
:
1848 case EM_ARC_COMPACT2
:
1849 case EM_ARC_COMPACT3
:
1850 case EM_ARC_COMPACT3_64
:
1851 rtype
= elf_arc_reloc_type (type
);
1855 rtype
= elf_hppa_reloc_type (type
);
1861 rtype
= elf_h8_reloc_type (type
);
1865 rtype
= elf_or1k_reloc_type (type
);
1870 rtype
= elf_pj_reloc_type (type
);
1873 rtype
= elf_ia64_reloc_type (type
);
1877 rtype
= elf_kvx_reloc_type (type
);
1881 rtype
= elf_cris_reloc_type (type
);
1885 rtype
= elf_i860_reloc_type (type
);
1891 rtype
= elf_x86_64_reloc_type (type
);
1895 rtype
= i370_reloc_type (type
);
1900 rtype
= elf_s390_reloc_type (type
);
1904 rtype
= elf_score_reloc_type (type
);
1908 rtype
= elf_xstormy16_reloc_type (type
);
1912 rtype
= elf_crx_reloc_type (type
);
1916 rtype
= elf_vax_reloc_type (type
);
1920 rtype
= elf_visium_reloc_type (type
);
1924 rtype
= elf_bpf_reloc_type (type
);
1927 case EM_ADAPTEVA_EPIPHANY
:
1928 rtype
= elf_epiphany_reloc_type (type
);
1933 rtype
= elf_ip2k_reloc_type (type
);
1937 rtype
= elf_iq2000_reloc_type (type
);
1942 rtype
= elf_xtensa_reloc_type (type
);
1945 case EM_LATTICEMICO32
:
1946 rtype
= elf_lm32_reloc_type (type
);
1951 rtype
= elf_m32c_reloc_type (type
);
1955 rtype
= elf_mt_reloc_type (type
);
1959 rtype
= elf_bfin_reloc_type (type
);
1963 rtype
= elf_mep_reloc_type (type
);
1967 rtype
= elf_cr16_reloc_type (type
);
1971 case EM_MICROBLAZE_OLD
:
1972 rtype
= elf_microblaze_reloc_type (type
);
1976 rtype
= elf_rl78_reloc_type (type
);
1980 rtype
= elf_rx_reloc_type (type
);
1984 rtype
= elf_metag_reloc_type (type
);
1988 rtype
= elf_tic6x_reloc_type (type
);
1992 rtype
= elf_tilegx_reloc_type (type
);
1996 rtype
= elf_tilepro_reloc_type (type
);
1999 case EM_WEBASSEMBLY
:
2000 rtype
= elf_wasm32_reloc_type (type
);
2004 rtype
= elf_xgate_reloc_type (type
);
2007 case EM_ALTERA_NIOS2
:
2008 rtype
= elf_nios2_reloc_type (type
);
2012 rtype
= elf_pru_reloc_type (type
);
2016 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
2017 rtype
= elf_nfp3200_reloc_type (type
);
2019 rtype
= elf_nfp_reloc_type (type
);
2023 rtype
= elf_z80_reloc_type (type
);
2027 rtype
= elf_loongarch_reloc_type (type
);
2031 rtype
= elf_amdgpu_reloc_type (type
);
2036 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
2038 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
2040 if (filedata
->file_header
.e_machine
== EM_ALPHA
2042 && streq (rtype
, "R_ALPHA_LITUSE")
2043 && rel_type
== reltype_rela
)
2045 switch (rels
[i
].r_addend
)
2047 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
2048 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
2049 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
2050 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
2051 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
2052 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
2053 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
2054 default: rtype
= NULL
;
2058 printf (" (%s)", rtype
);
2062 printf (_("<unknown addend: %" PRIx64
">"),
2067 else if (symtab_index
)
2069 if (symtab
== NULL
|| symtab_index
>= nsyms
)
2071 error (_(" bad symbol index: %08lx in reloc\n"),
2072 (unsigned long) symtab_index
);
2077 Elf_Internal_Sym
* psym
;
2078 const char * version_string
;
2079 enum versioned_symbol_info sym_info
;
2080 unsigned short vna_other
;
2082 psym
= symtab
+ symtab_index
;
2085 = get_symbol_version_string (filedata
, is_dynsym
,
2094 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
2098 unsigned int width
= is_32bit_elf
? 8 : 14;
2100 /* Relocations against GNU_IFUNC symbols do not use the value
2101 of the symbol as the address to relocate against. Instead
2102 they invoke the function named by the symbol and use its
2103 result as the address for relocation.
2105 To indicate this to the user, do not display the value of
2106 the symbol in the "Symbols's Value" field. Instead show
2107 its name followed by () as a hint that the symbol is
2111 || psym
->st_name
== 0
2112 || psym
->st_name
>= strtablen
)
2115 name
= strtab
+ psym
->st_name
;
2117 len
= print_symbol_name (width
, name
);
2119 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
2121 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
2125 print_vma (psym
->st_value
, LONG_HEX
);
2127 printf (is_32bit_elf
? " " : " ");
2130 if (psym
->st_name
== 0)
2132 const char * sec_name
= "<null>";
2134 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
2135 sec_name
= printable_section_name_from_index
2136 (filedata
, psym
->st_shndx
, NULL
);
2138 print_symbol_name (22, sec_name
);
2140 else if (strtab
== NULL
)
2141 printf (_("<string table index: %3ld>"), psym
->st_name
);
2142 else if (psym
->st_name
>= strtablen
)
2144 error (_("<corrupt string table index: %3ld>\n"),
2150 print_symbol_name (22, strtab
+ psym
->st_name
);
2152 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
2156 if (rel_type
== reltype_rela
)
2158 uint64_t off
= rels
[i
].r_addend
;
2160 if ((int64_t) off
< 0)
2161 printf (" - %" PRIx64
, -off
);
2163 printf (" + %" PRIx64
, off
);
2167 else if (rel_type
== reltype_rela
)
2169 uint64_t off
= rels
[i
].r_addend
;
2171 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
2172 if ((int64_t) off
< 0)
2173 printf ("-%" PRIx64
, -off
);
2175 printf ("%" PRIx64
, off
);
2178 if (filedata
->file_header
.e_machine
== EM_SPARCV9
2180 && streq (rtype
, "R_SPARC_OLO10"))
2181 printf (" + %" PRIx64
, ELF64_R_TYPE_DATA (inf
));
2185 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
2187 uint64_t type2
= ELF64_MIPS_R_TYPE2 (inf
);
2188 uint64_t type3
= ELF64_MIPS_R_TYPE3 (inf
);
2189 const char * rtype2
= elf_mips_reloc_type (type2
);
2190 const char * rtype3
= elf_mips_reloc_type (type3
);
2192 printf (" Type2: ");
2195 printf (_("unrecognized: %-7lx"),
2196 (unsigned long) type2
& 0xffffffff);
2198 printf ("%-17.17s", rtype2
);
2200 printf ("\n Type3: ");
2203 printf (_("unrecognized: %-7lx"),
2204 (unsigned long) type3
& 0xffffffff);
2206 printf ("%-17.17s", rtype3
);
2218 get_aarch64_dynamic_type (unsigned long type
)
2222 case DT_AARCH64_BTI_PLT
: return "AARCH64_BTI_PLT";
2223 case DT_AARCH64_PAC_PLT
: return "AARCH64_PAC_PLT";
2224 case DT_AARCH64_VARIANT_PCS
: return "AARCH64_VARIANT_PCS";
2231 get_mips_dynamic_type (unsigned long type
)
2235 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
2236 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
2237 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
2238 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
2239 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
2240 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
2241 case DT_MIPS_MSYM
: return "MIPS_MSYM";
2242 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2243 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2244 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
2245 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
2246 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
2247 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
2248 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
2249 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
2250 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
2251 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
2252 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
2253 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
2254 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
2255 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
2256 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
2257 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
2258 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
2259 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
2260 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
2261 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
2262 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
2263 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
2264 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
2265 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2266 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
2267 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
2268 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
2269 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
2270 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2271 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
2272 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
2273 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
2274 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
2275 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
2276 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
2277 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
2278 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
2279 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
2280 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
2281 case DT_MIPS_XHASH
: return "MIPS_XHASH";
2288 get_sparc64_dynamic_type (unsigned long type
)
2292 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
2299 get_ppc_dynamic_type (unsigned long type
)
2303 case DT_PPC_GOT
: return "PPC_GOT";
2304 case DT_PPC_OPT
: return "PPC_OPT";
2311 get_ppc64_dynamic_type (unsigned long type
)
2315 case DT_PPC64_GLINK
: return "PPC64_GLINK";
2316 case DT_PPC64_OPD
: return "PPC64_OPD";
2317 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
2318 case DT_PPC64_OPT
: return "PPC64_OPT";
2325 get_parisc_dynamic_type (unsigned long type
)
2329 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
2330 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
2331 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
2332 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
2333 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
2334 case DT_HP_PREINIT
: return "HP_PREINIT";
2335 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
2336 case DT_HP_NEEDED
: return "HP_NEEDED";
2337 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
2338 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
2339 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
2340 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
2341 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
2342 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
2343 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
2344 case DT_HP_FILTERED
: return "HP_FILTERED";
2345 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
2346 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
2347 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
2348 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
2349 case DT_PLT
: return "PLT";
2350 case DT_PLT_SIZE
: return "PLT_SIZE";
2351 case DT_DLT
: return "DLT";
2352 case DT_DLT_SIZE
: return "DLT_SIZE";
2359 get_ia64_dynamic_type (unsigned long type
)
2363 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
2364 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
2365 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
2366 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
2367 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
2368 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
2369 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
2370 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
2371 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
2372 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
2373 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
2374 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
2375 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
2376 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
2377 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
2378 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
2379 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
2380 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
2381 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
2382 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
2383 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
2384 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
2385 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
2386 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
2387 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
2388 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
2389 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
2390 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
2391 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
2392 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
2393 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
2400 get_solaris_section_type (unsigned long type
)
2404 case 0x6fffffee: return "SUNW_ancillary";
2405 case 0x6fffffef: return "SUNW_capchain";
2406 case 0x6ffffff0: return "SUNW_capinfo";
2407 case 0x6ffffff1: return "SUNW_symsort";
2408 case 0x6ffffff2: return "SUNW_tlssort";
2409 case 0x6ffffff3: return "SUNW_LDYNSYM";
2410 case 0x6ffffff4: return "SUNW_dof";
2411 case 0x6ffffff5: return "SUNW_cap";
2412 case 0x6ffffff6: return "SUNW_SIGNATURE";
2413 case 0x6ffffff7: return "SUNW_ANNOTATE";
2414 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2415 case 0x6ffffff9: return "SUNW_DEBUG";
2416 case 0x6ffffffa: return "SUNW_move";
2417 case 0x6ffffffb: return "SUNW_COMDAT";
2418 case 0x6ffffffc: return "SUNW_syminfo";
2419 case 0x6ffffffd: return "SUNW_verdef";
2420 case 0x6ffffffe: return "SUNW_verneed";
2421 case 0x6fffffff: return "SUNW_versym";
2422 case 0x70000000: return "SPARC_GOTDATA";
2423 default: return NULL
;
2428 get_alpha_dynamic_type (unsigned long type
)
2432 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2433 default: return NULL
;
2438 get_score_dynamic_type (unsigned long type
)
2442 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2443 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2444 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2445 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2446 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2447 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2448 default: return NULL
;
2453 get_tic6x_dynamic_type (unsigned long type
)
2457 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2458 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2459 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2460 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2461 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2462 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2463 default: return NULL
;
2468 get_nios2_dynamic_type (unsigned long type
)
2472 case DT_NIOS2_GP
: return "NIOS2_GP";
2473 default: return NULL
;
2478 get_solaris_dynamic_type (unsigned long type
)
2482 case 0x6000000d: return "SUNW_AUXILIARY";
2483 case 0x6000000e: return "SUNW_RTLDINF";
2484 case 0x6000000f: return "SUNW_FILTER";
2485 case 0x60000010: return "SUNW_CAP";
2486 case 0x60000011: return "SUNW_SYMTAB";
2487 case 0x60000012: return "SUNW_SYMSZ";
2488 case 0x60000013: return "SUNW_SORTENT";
2489 case 0x60000014: return "SUNW_SYMSORT";
2490 case 0x60000015: return "SUNW_SYMSORTSZ";
2491 case 0x60000016: return "SUNW_TLSSORT";
2492 case 0x60000017: return "SUNW_TLSSORTSZ";
2493 case 0x60000018: return "SUNW_CAPINFO";
2494 case 0x60000019: return "SUNW_STRPAD";
2495 case 0x6000001a: return "SUNW_CAPCHAIN";
2496 case 0x6000001b: return "SUNW_LDMACH";
2497 case 0x6000001d: return "SUNW_CAPCHAINENT";
2498 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2499 case 0x60000021: return "SUNW_PARENT";
2500 case 0x60000023: return "SUNW_ASLR";
2501 case 0x60000025: return "SUNW_RELAX";
2502 case 0x60000029: return "SUNW_NXHEAP";
2503 case 0x6000002b: return "SUNW_NXSTACK";
2505 case 0x70000001: return "SPARC_REGISTER";
2506 case 0x7ffffffd: return "AUXILIARY";
2507 case 0x7ffffffe: return "USED";
2508 case 0x7fffffff: return "FILTER";
2510 default: return NULL
;
2515 get_riscv_dynamic_type (unsigned long type
)
2519 case DT_RISCV_VARIANT_CC
: return "RISCV_VARIANT_CC";
2526 get_x86_64_dynamic_type (unsigned long type
)
2531 return "DT_X86_64_PLT";
2532 case DT_X86_64_PLTSZ
:
2533 return "DT_X86_64_PLTSZ";
2534 case DT_X86_64_PLTENT
:
2535 return "DT_X86_64_PLTENT";
2542 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2544 static char buff
[64];
2548 case DT_NULL
: return "NULL";
2549 case DT_NEEDED
: return "NEEDED";
2550 case DT_PLTRELSZ
: return "PLTRELSZ";
2551 case DT_PLTGOT
: return "PLTGOT";
2552 case DT_HASH
: return "HASH";
2553 case DT_STRTAB
: return "STRTAB";
2554 case DT_SYMTAB
: return "SYMTAB";
2555 case DT_RELA
: return "RELA";
2556 case DT_RELASZ
: return "RELASZ";
2557 case DT_RELAENT
: return "RELAENT";
2558 case DT_STRSZ
: return "STRSZ";
2559 case DT_SYMENT
: return "SYMENT";
2560 case DT_INIT
: return "INIT";
2561 case DT_FINI
: return "FINI";
2562 case DT_SONAME
: return "SONAME";
2563 case DT_RPATH
: return "RPATH";
2564 case DT_SYMBOLIC
: return "SYMBOLIC";
2565 case DT_REL
: return "REL";
2566 case DT_RELSZ
: return "RELSZ";
2567 case DT_RELENT
: return "RELENT";
2568 case DT_RELR
: return "RELR";
2569 case DT_RELRSZ
: return "RELRSZ";
2570 case DT_RELRENT
: return "RELRENT";
2571 case DT_PLTREL
: return "PLTREL";
2572 case DT_DEBUG
: return "DEBUG";
2573 case DT_TEXTREL
: return "TEXTREL";
2574 case DT_JMPREL
: return "JMPREL";
2575 case DT_BIND_NOW
: return "BIND_NOW";
2576 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2577 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2578 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2579 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2580 case DT_RUNPATH
: return "RUNPATH";
2581 case DT_FLAGS
: return "FLAGS";
2583 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2584 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2585 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2587 case DT_CHECKSUM
: return "CHECKSUM";
2588 case DT_PLTPADSZ
: return "PLTPADSZ";
2589 case DT_MOVEENT
: return "MOVEENT";
2590 case DT_MOVESZ
: return "MOVESZ";
2591 case DT_FEATURE
: return "FEATURE";
2592 case DT_POSFLAG_1
: return "POSFLAG_1";
2593 case DT_SYMINSZ
: return "SYMINSZ";
2594 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2596 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2597 case DT_CONFIG
: return "CONFIG";
2598 case DT_DEPAUDIT
: return "DEPAUDIT";
2599 case DT_AUDIT
: return "AUDIT";
2600 case DT_PLTPAD
: return "PLTPAD";
2601 case DT_MOVETAB
: return "MOVETAB";
2602 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2604 case DT_VERSYM
: return "VERSYM";
2606 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2607 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2608 case DT_RELACOUNT
: return "RELACOUNT";
2609 case DT_RELCOUNT
: return "RELCOUNT";
2610 case DT_FLAGS_1
: return "FLAGS_1";
2611 case DT_VERDEF
: return "VERDEF";
2612 case DT_VERDEFNUM
: return "VERDEFNUM";
2613 case DT_VERNEED
: return "VERNEED";
2614 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2616 case DT_AUXILIARY
: return "AUXILIARY";
2617 case DT_USED
: return "USED";
2618 case DT_FILTER
: return "FILTER";
2620 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2621 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2622 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2623 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2624 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2625 case DT_GNU_HASH
: return "GNU_HASH";
2626 case DT_GNU_FLAGS_1
: return "GNU_FLAGS_1";
2629 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2631 const char * result
;
2633 switch (filedata
->file_header
.e_machine
)
2636 result
= get_aarch64_dynamic_type (type
);
2639 case EM_MIPS_RS3_LE
:
2640 result
= get_mips_dynamic_type (type
);
2643 result
= get_sparc64_dynamic_type (type
);
2646 result
= get_ppc_dynamic_type (type
);
2649 result
= get_ppc64_dynamic_type (type
);
2652 result
= get_ia64_dynamic_type (type
);
2655 result
= get_alpha_dynamic_type (type
);
2658 result
= get_score_dynamic_type (type
);
2661 result
= get_tic6x_dynamic_type (type
);
2663 case EM_ALTERA_NIOS2
:
2664 result
= get_nios2_dynamic_type (type
);
2667 result
= get_riscv_dynamic_type (type
);
2670 result
= get_x86_64_dynamic_type (type
);
2673 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2674 result
= get_solaris_dynamic_type (type
);
2683 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2685 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2686 || (filedata
->file_header
.e_machine
== EM_PARISC
2687 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2689 const char * result
;
2691 switch (filedata
->file_header
.e_machine
)
2694 result
= get_parisc_dynamic_type (type
);
2697 result
= get_ia64_dynamic_type (type
);
2700 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2701 result
= get_solaris_dynamic_type (type
);
2710 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2714 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2720 static bool get_program_headers (Filedata
*);
2721 static bool get_dynamic_section (Filedata
*);
2724 locate_dynamic_section (Filedata
*filedata
)
2726 uint64_t dynamic_addr
= 0;
2727 uint64_t dynamic_size
= 0;
2729 if (filedata
->file_header
.e_phnum
!= 0
2730 && get_program_headers (filedata
))
2732 Elf_Internal_Phdr
*segment
;
2735 for (i
= 0, segment
= filedata
->program_headers
;
2736 i
< filedata
->file_header
.e_phnum
;
2739 if (segment
->p_type
== PT_DYNAMIC
)
2741 dynamic_addr
= segment
->p_offset
;
2742 dynamic_size
= segment
->p_filesz
;
2744 if (filedata
->section_headers
!= NULL
)
2746 Elf_Internal_Shdr
*sec
;
2748 sec
= find_section (filedata
, ".dynamic");
2751 if (sec
->sh_size
== 0
2752 || sec
->sh_type
== SHT_NOBITS
)
2759 dynamic_addr
= sec
->sh_offset
;
2760 dynamic_size
= sec
->sh_size
;
2765 if (dynamic_addr
> filedata
->file_size
2766 || (dynamic_size
> filedata
->file_size
- dynamic_addr
))
2775 filedata
->dynamic_addr
= dynamic_addr
;
2776 filedata
->dynamic_size
= dynamic_size
? dynamic_size
: 1;
2780 is_pie (Filedata
*filedata
)
2782 Elf_Internal_Dyn
*entry
;
2784 if (filedata
->dynamic_size
== 0)
2785 locate_dynamic_section (filedata
);
2786 if (filedata
->dynamic_size
<= 1)
2789 if (!get_dynamic_section (filedata
))
2792 for (entry
= filedata
->dynamic_section
;
2793 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
2796 if (entry
->d_tag
== DT_FLAGS_1
)
2798 if ((entry
->d_un
.d_val
& DF_1_PIE
) != 0)
2807 get_file_type (Filedata
*filedata
)
2809 unsigned e_type
= filedata
->file_header
.e_type
;
2810 static char buff
[64];
2814 case ET_NONE
: return _("NONE (None)");
2815 case ET_REL
: return _("REL (Relocatable file)");
2816 case ET_EXEC
: return _("EXEC (Executable file)");
2818 if (is_pie (filedata
))
2819 return _("DYN (Position-Independent Executable file)");
2821 return _("DYN (Shared object file)");
2822 case ET_CORE
: return _("CORE (Core file)");
2825 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2826 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2827 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2828 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2830 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2836 get_machine_name (unsigned e_machine
)
2838 static char buff
[64]; /* XXX */
2842 /* Please keep this switch table sorted by increasing EM_ value. */
2844 case EM_NONE
: return _("None");
2845 case EM_M32
: return "WE32100";
2846 case EM_SPARC
: return "Sparc";
2847 case EM_386
: return "Intel 80386";
2848 case EM_68K
: return "MC68000";
2849 case EM_88K
: return "MC88000";
2850 case EM_IAMCU
: return "Intel MCU";
2851 case EM_860
: return "Intel 80860";
2852 case EM_MIPS
: return "MIPS R3000";
2853 case EM_S370
: return "IBM System/370";
2855 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2856 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2857 case EM_PARISC
: return "HPPA";
2858 case EM_VPP550
: return "Fujitsu VPP500";
2859 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2860 case EM_960
: return "Intel 80960";
2861 case EM_PPC
: return "PowerPC";
2863 case EM_PPC64
: return "PowerPC64";
2865 case EM_S390
: return "IBM S/390";
2866 case EM_SPU
: return "SPU";
2868 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2869 case EM_FR20
: return "Fujitsu FR20";
2870 case EM_RH32
: return "TRW RH32";
2871 case EM_MCORE
: return "MCORE";
2873 case EM_ARM
: return "ARM";
2874 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2875 case EM_SH
: return "Renesas / SuperH SH";
2876 case EM_SPARCV9
: return "Sparc v9";
2877 case EM_TRICORE
: return "Siemens Tricore";
2878 case EM_ARC
: return "ARC";
2879 case EM_H8_300
: return "Renesas H8/300";
2880 case EM_H8_300H
: return "Renesas H8/300H";
2881 case EM_H8S
: return "Renesas H8S";
2882 case EM_H8_500
: return "Renesas H8/500";
2884 case EM_IA_64
: return "Intel IA-64";
2885 case EM_MIPS_X
: return "Stanford MIPS-X";
2886 case EM_COLDFIRE
: return "Motorola Coldfire";
2887 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2888 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2889 case EM_PCP
: return "Siemens PCP";
2890 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2891 case EM_NDR1
: return "Denso NDR1 microprocessor";
2892 case EM_STARCORE
: return "Motorola Star*Core processor";
2893 case EM_ME16
: return "Toyota ME16 processor";
2895 case EM_ST100
: return "STMicroelectronics ST100 processor";
2896 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2897 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2898 case EM_PDSP
: return "Sony DSP processor";
2899 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2900 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2901 case EM_FX66
: return "Siemens FX66 microcontroller";
2902 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2903 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2904 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2906 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2907 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2908 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2909 case EM_SVX
: return "Silicon Graphics SVx";
2910 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2911 case EM_VAX
: return "Digital VAX";
2912 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2913 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2914 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2915 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2917 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2918 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2919 case EM_PRISM
: return "Vitesse Prism";
2921 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2922 case EM_CYGNUS_FR30
:
2923 case EM_FR30
: return "Fujitsu FR30";
2924 case EM_CYGNUS_D10V
:
2925 case EM_D10V
: return "d10v";
2926 case EM_CYGNUS_D30V
:
2927 case EM_D30V
: return "d30v";
2928 case EM_CYGNUS_V850
:
2929 case EM_V850
: return "Renesas V850";
2930 case EM_CYGNUS_M32R
:
2931 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2932 case EM_CYGNUS_MN10300
:
2933 case EM_MN10300
: return "mn10300";
2935 case EM_CYGNUS_MN10200
:
2936 case EM_MN10200
: return "mn10200";
2937 case EM_PJ
: return "picoJava";
2938 case EM_OR1K
: return "OpenRISC 1000";
2939 case EM_ARC_COMPACT
: return "ARCompact";
2941 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2942 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2943 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2944 case EM_NS32K
: return "National Semiconductor 32000 series";
2945 case EM_TPC
: return "Tenor Network TPC processor";
2946 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2948 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2950 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2951 case EM_MAX
: return "MAX Processor";
2952 case EM_CR
: return "National Semiconductor CompactRISC";
2953 case EM_F2MC16
: return "Fujitsu F2MC16";
2954 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2955 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2956 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2957 case EM_SEP
: return "Sharp embedded microprocessor";
2958 case EM_ARCA
: return "Arca RISC microprocessor";
2960 case EM_UNICORE
: return "Unicore";
2961 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2962 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2963 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2964 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2965 case EM_XGATE
: return "Motorola XGATE embedded processor";
2967 case EM_XC16X
: return "Infineon Technologies xc16x";
2968 case EM_M16C
: return "Renesas M16C series microprocessors";
2969 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2970 case EM_CE
: return "Freescale Communication Engine RISC core";
2972 case EM_M32C
: return "Renesas M32c";
2974 case EM_TSK3000
: return "Altium TSK3000 core";
2975 case EM_RS08
: return "Freescale RS08 embedded processor";
2976 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2977 case EM_SCORE
: return "SUNPLUS S+Core";
2978 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2979 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2980 case EM_LATTICEMICO32
: return "Lattice Mico32";
2981 case EM_SE_C17
: return "Seiko Epson C17 family";
2983 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2984 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2985 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2986 case EM_TI_PRU
: return "TI PRU I/O processor";
2988 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2989 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2990 case EM_R32C
: return "Renesas R32C series microprocessors";
2991 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2992 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2993 case EM_8051
: return "Intel 8051 and variants";
2994 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2995 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2996 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2997 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2999 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
3000 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
3001 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
3002 case EM_RX
: return "Renesas RX";
3003 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
3004 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
3005 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
3008 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
3009 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
3010 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
3012 case EM_L1OM
: return "Intel L1OM";
3013 case EM_K1OM
: return "Intel K1OM";
3014 case EM_INTEL182
: return "Intel (reserved)";
3015 case EM_AARCH64
: return "AArch64";
3016 case EM_ARM184
: return "ARM (reserved)";
3017 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
3018 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
3019 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
3020 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
3022 case EM_CUDA
: return "NVIDIA CUDA architecture";
3023 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
3024 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
3025 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
3026 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
3027 case EM_ARC_COMPACT2
: return "ARCv2";
3028 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
3029 case EM_RL78
: return "Renesas RL78";
3030 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
3031 case EM_78K0R
: return "Renesas 78K0R";
3033 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
3034 case EM_BA1
: return "Beyond BA1 CPU architecture";
3035 case EM_BA2
: return "Beyond BA2 CPU architecture";
3036 case EM_XCORE
: return "XMOS xCORE processor family";
3037 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
3038 case EM_INTELGT
: return "Intel Graphics Technology";
3040 case EM_KM32
: return "KM211 KM32 32-bit processor";
3041 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
3042 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
3043 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
3044 case EM_KVARC
: return "KM211 KVARC processor";
3045 case EM_CDP
: return "Paneve CDP architecture family";
3046 case EM_COGE
: return "Cognitive Smart Memory Processor";
3047 case EM_COOL
: return "Bluechip Systems CoolEngine";
3048 case EM_NORC
: return "Nanoradio Optimized RISC";
3049 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
3051 case EM_Z80
: return "Zilog Z80";
3052 case EM_VISIUM
: return "CDS VISIUMcore processor";
3053 case EM_FT32
: return "FTDI Chip FT32";
3054 case EM_MOXIE
: return "Moxie";
3055 case EM_AMDGPU
: return "AMD GPU";
3056 /* 230 (all reserved) */
3058 case EM_RISCV
: return "RISC-V";
3059 case EM_LANAI
: return "Lanai 32-bit processor";
3060 case EM_CEVA
: return "CEVA Processor Architecture Family";
3061 case EM_CEVA_X2
: return "CEVA X2 Processor Family";
3062 case EM_BPF
: return "Linux BPF";
3063 case EM_GRAPHCORE_IPU
: return "Graphcore Intelligent Processing Unit";
3064 case EM_IMG1
: return "Imagination Technologies";
3066 case EM_NFP
: return "Netronome Flow Processor";
3067 case EM_VE
: return "NEC Vector Engine";
3068 case EM_CSKY
: return "C-SKY";
3069 case EM_ARC_COMPACT3_64
: return "Synopsys ARCv3 64-bit processor";
3070 case EM_MCS6502
: return "MOS Technology MCS 6502 processor";
3071 case EM_ARC_COMPACT3
: return "Synopsys ARCv3 32-bit processor";
3072 case EM_KVX
: return "Kalray VLIW core of the MPPA processor family";
3073 case EM_65816
: return "WDC 65816/65C816";
3074 case EM_LOONGARCH
: return "LoongArch";
3075 case EM_KF32
: return "ChipON KungFu32";
3077 /* Large numbers... */
3078 case EM_MT
: return "Morpho Techologies MT processor";
3079 case EM_ALPHA
: return "Alpha";
3080 case EM_WEBASSEMBLY
: return "Web Assembly";
3081 case EM_DLX
: return "OpenDLX";
3082 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
3083 case EM_IQ2000
: return "Vitesse IQ2000";
3085 case EM_NIOS32
: return "Altera Nios";
3086 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
3087 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
3088 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
3089 case EM_S12Z
: return "Freescale S12Z";
3092 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
3098 decode_ARC_machine_flags (char *out
, unsigned e_flags
, unsigned e_machine
)
3100 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
3101 other compilers don't specify an architecture type in the e_flags, and
3102 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
3103 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
3106 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
3107 but also sets a specific architecture type in the e_flags field.
3109 However, when decoding the flags we don't worry if we see an
3110 unexpected pairing, for example EM_ARC_COMPACT machine type, with
3111 ARCEM architecture type. */
3113 switch (e_flags
& EF_ARC_MACH_MSK
)
3115 /* We only expect these to occur for EM_ARC_COMPACT2. */
3116 case EF_ARC_CPU_ARCV2EM
:
3117 out
= stpcpy (out
, ", ARC EM");
3119 case EF_ARC_CPU_ARCV2HS
:
3120 out
= stpcpy (out
, ", ARC HS");
3123 /* We only expect these to occur for EM_ARC_COMPACT. */
3124 case E_ARC_MACH_ARC600
:
3125 out
= stpcpy (out
, ", ARC600");
3127 case E_ARC_MACH_ARC601
:
3128 out
= stpcpy (out
, ", ARC601");
3130 case E_ARC_MACH_ARC700
:
3131 out
= stpcpy (out
, ", ARC700");
3134 /* The only times we should end up here are (a) A corrupt ELF, (b) A
3135 new ELF with new architecture being read by an old version of
3136 readelf, or (c) An ELF built with non-GNU compiler that does not
3137 set the architecture in the e_flags. */
3139 if (e_machine
== EM_ARC_COMPACT
)
3140 out
= stpcpy (out
, ", Unknown ARCompact");
3142 out
= stpcpy (out
, ", Unknown ARC");
3146 switch (e_flags
& EF_ARC_OSABI_MSK
)
3148 case E_ARC_OSABI_ORIG
:
3149 out
= stpcpy (out
, ", (ABI:legacy)");
3151 case E_ARC_OSABI_V2
:
3152 out
= stpcpy (out
, ", (ABI:v2)");
3154 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
3155 case E_ARC_OSABI_V3
:
3156 out
= stpcpy (out
, ", v3 no-legacy-syscalls ABI");
3158 case E_ARC_OSABI_V4
:
3159 out
= stpcpy (out
, ", v4 ABI");
3162 out
= stpcpy (out
, ", unrecognised ARC OSABI flag");
3169 decode_ARM_machine_flags (char *out
, unsigned e_flags
)
3172 bool unknown
= false;
3174 eabi
= EF_ARM_EABI_VERSION (e_flags
);
3175 e_flags
&= ~ EF_ARM_EABIMASK
;
3177 /* Handle "generic" ARM flags. */
3178 if (e_flags
& EF_ARM_RELEXEC
)
3180 out
= stpcpy (out
, ", relocatable executable");
3181 e_flags
&= ~ EF_ARM_RELEXEC
;
3184 if (e_flags
& EF_ARM_PIC
)
3186 out
= stpcpy (out
, ", position independent");
3187 e_flags
&= ~ EF_ARM_PIC
;
3190 /* Now handle EABI specific flags. */
3194 out
= stpcpy (out
, ", <unrecognized EABI>");
3199 case EF_ARM_EABI_VER1
:
3200 out
= stpcpy (out
, ", Version1 EABI");
3205 /* Process flags one bit at a time. */
3206 flag
= e_flags
& - e_flags
;
3211 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
3212 out
= stpcpy (out
, ", sorted symbol tables");
3222 case EF_ARM_EABI_VER2
:
3223 out
= stpcpy (out
, ", Version2 EABI");
3228 /* Process flags one bit at a time. */
3229 flag
= e_flags
& - e_flags
;
3234 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
3235 out
= stpcpy (out
, ", sorted symbol tables");
3238 case EF_ARM_DYNSYMSUSESEGIDX
:
3239 out
= stpcpy (out
, ", dynamic symbols use segment index");
3242 case EF_ARM_MAPSYMSFIRST
:
3243 out
= stpcpy (out
, ", mapping symbols precede others");
3253 case EF_ARM_EABI_VER3
:
3254 out
= stpcpy (out
, ", Version3 EABI");
3257 case EF_ARM_EABI_VER4
:
3258 out
= stpcpy (out
, ", Version4 EABI");
3263 /* Process flags one bit at a time. */
3264 flag
= e_flags
& - e_flags
;
3270 out
= stpcpy (out
, ", BE8");
3274 out
= stpcpy (out
, ", LE8");
3284 case EF_ARM_EABI_VER5
:
3285 out
= stpcpy (out
, ", Version5 EABI");
3290 /* Process flags one bit at a time. */
3291 flag
= e_flags
& - e_flags
;
3297 out
= stpcpy (out
, ", BE8");
3301 out
= stpcpy (out
, ", LE8");
3304 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
3305 out
= stpcpy (out
, ", soft-float ABI");
3308 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
3309 out
= stpcpy (out
, ", hard-float ABI");
3319 case EF_ARM_EABI_UNKNOWN
:
3320 out
= stpcpy (out
, ", GNU EABI");
3325 /* Process flags one bit at a time. */
3326 flag
= e_flags
& - e_flags
;
3331 case EF_ARM_INTERWORK
:
3332 out
= stpcpy (out
, ", interworking enabled");
3335 case EF_ARM_APCS_26
:
3336 out
= stpcpy (out
, ", uses APCS/26");
3339 case EF_ARM_APCS_FLOAT
:
3340 out
= stpcpy (out
, ", uses APCS/float");
3344 out
= stpcpy (out
, ", position independent");
3348 out
= stpcpy (out
, ", 8 bit structure alignment");
3351 case EF_ARM_NEW_ABI
:
3352 out
= stpcpy (out
, ", uses new ABI");
3355 case EF_ARM_OLD_ABI
:
3356 out
= stpcpy (out
, ", uses old ABI");
3359 case EF_ARM_SOFT_FLOAT
:
3360 out
= stpcpy (out
, ", software FP");
3363 case EF_ARM_VFP_FLOAT
:
3364 out
= stpcpy (out
, ", VFP");
3367 case EF_ARM_MAVERICK_FLOAT
:
3368 out
= stpcpy (out
, ", Maverick FP");
3379 out
= stpcpy (out
,_(", <unknown>"));
3384 decode_AVR_machine_flags (char *out
, unsigned e_flags
)
3386 switch (e_flags
& EF_AVR_MACH
)
3388 case E_AVR_MACH_AVR1
:
3389 out
= stpcpy (out
, ", avr:1");
3391 case E_AVR_MACH_AVR2
:
3392 out
= stpcpy (out
, ", avr:2");
3394 case E_AVR_MACH_AVR25
:
3395 out
= stpcpy (out
, ", avr:25");
3397 case E_AVR_MACH_AVR3
:
3398 out
= stpcpy (out
, ", avr:3");
3400 case E_AVR_MACH_AVR31
:
3401 out
= stpcpy (out
, ", avr:31");
3403 case E_AVR_MACH_AVR35
:
3404 out
= stpcpy (out
, ", avr:35");
3406 case E_AVR_MACH_AVR4
:
3407 out
= stpcpy (out
, ", avr:4");
3409 case E_AVR_MACH_AVR5
:
3410 out
= stpcpy (out
, ", avr:5");
3412 case E_AVR_MACH_AVR51
:
3413 out
= stpcpy (out
, ", avr:51");
3415 case E_AVR_MACH_AVR6
:
3416 out
= stpcpy (out
, ", avr:6");
3418 case E_AVR_MACH_AVRTINY
:
3419 out
= stpcpy (out
, ", avr:100");
3421 case E_AVR_MACH_XMEGA1
:
3422 out
= stpcpy (out
, ", avr:101");
3424 case E_AVR_MACH_XMEGA2
:
3425 out
= stpcpy (out
, ", avr:102");
3427 case E_AVR_MACH_XMEGA3
:
3428 out
= stpcpy (out
, ", avr:103");
3430 case E_AVR_MACH_XMEGA4
:
3431 out
= stpcpy (out
, ", avr:104");
3433 case E_AVR_MACH_XMEGA5
:
3434 out
= stpcpy (out
, ", avr:105");
3436 case E_AVR_MACH_XMEGA6
:
3437 out
= stpcpy (out
, ", avr:106");
3439 case E_AVR_MACH_XMEGA7
:
3440 out
= stpcpy (out
, ", avr:107");
3443 out
= stpcpy (out
, ", avr:<unknown>");
3447 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
3448 out
= stpcpy (out
, ", link-relax");
3453 decode_BLACKFIN_machine_flags (char *out
, unsigned e_flags
)
3455 if (e_flags
& EF_BFIN_PIC
)
3456 out
= stpcpy (out
, ", PIC");
3458 if (e_flags
& EF_BFIN_FDPIC
)
3459 out
= stpcpy (out
, ", FDPIC");
3461 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3462 out
= stpcpy (out
, ", code in L1");
3464 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3465 out
= stpcpy (out
, ", data in L1");
3470 decode_FRV_machine_flags (char *out
, unsigned e_flags
)
3472 switch (e_flags
& EF_FRV_CPU_MASK
)
3474 case EF_FRV_CPU_GENERIC
:
3478 out
= stpcpy (out
, ", fr???");
3481 case EF_FRV_CPU_FR300
:
3482 out
= stpcpy (out
, ", fr300");
3485 case EF_FRV_CPU_FR400
:
3486 out
= stpcpy (out
, ", fr400");
3488 case EF_FRV_CPU_FR405
:
3489 out
= stpcpy (out
, ", fr405");
3492 case EF_FRV_CPU_FR450
:
3493 out
= stpcpy (out
, ", fr450");
3496 case EF_FRV_CPU_FR500
:
3497 out
= stpcpy (out
, ", fr500");
3499 case EF_FRV_CPU_FR550
:
3500 out
= stpcpy (out
, ", fr550");
3503 case EF_FRV_CPU_SIMPLE
:
3504 out
= stpcpy (out
, ", simple");
3506 case EF_FRV_CPU_TOMCAT
:
3507 out
= stpcpy (out
, ", tomcat");
3514 decode_IA64_machine_flags (char *out
, unsigned e_flags
, Filedata
*filedata
)
3516 if ((e_flags
& EF_IA_64_ABI64
))
3517 out
= stpcpy (out
, ", 64-bit");
3519 out
= stpcpy (out
, ", 32-bit");
3520 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3521 out
= stpcpy (out
, ", reduced fp model");
3522 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3523 out
= stpcpy (out
, ", no function descriptors, constant gp");
3524 else if ((e_flags
& EF_IA_64_CONS_GP
))
3525 out
= stpcpy (out
, ", constant gp");
3526 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3527 out
= stpcpy (out
, ", absolute");
3528 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3530 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3531 out
= stpcpy (out
, ", vms_linkages");
3532 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3534 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3536 case EF_IA_64_VMS_COMCOD_WARNING
:
3537 out
= stpcpy (out
, ", warning");
3539 case EF_IA_64_VMS_COMCOD_ERROR
:
3540 out
= stpcpy (out
, ", error");
3542 case EF_IA_64_VMS_COMCOD_ABORT
:
3543 out
= stpcpy (out
, ", abort");
3546 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3547 e_flags
& EF_IA_64_VMS_COMCOD
);
3548 out
= stpcpy (out
, ", <unknown>");
3555 decode_LOONGARCH_machine_flags (char *out
, unsigned int e_flags
)
3557 if (EF_LOONGARCH_IS_SOFT_FLOAT (e_flags
))
3558 out
= stpcpy (out
, ", SOFT-FLOAT");
3559 else if (EF_LOONGARCH_IS_SINGLE_FLOAT (e_flags
))
3560 out
= stpcpy (out
, ", SINGLE-FLOAT");
3561 else if (EF_LOONGARCH_IS_DOUBLE_FLOAT (e_flags
))
3562 out
= stpcpy (out
, ", DOUBLE-FLOAT");
3564 if (EF_LOONGARCH_IS_OBJ_V0 (e_flags
))
3565 out
= stpcpy (out
, ", OBJ-v0");
3566 else if (EF_LOONGARCH_IS_OBJ_V1 (e_flags
))
3567 out
= stpcpy (out
, ", OBJ-v1");
3572 decode_M68K_machine_flags (char *out
, unsigned int e_flags
)
3574 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3575 out
= stpcpy (out
, ", m68000");
3576 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3577 out
= stpcpy (out
, ", cpu32");
3578 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3579 out
= stpcpy (out
, ", fido_a");
3582 char const *isa
= _("unknown");
3583 char const *mac
= _("unknown mac");
3584 char const *additional
= NULL
;
3586 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3588 case EF_M68K_CF_ISA_A_NODIV
:
3590 additional
= ", nodiv";
3592 case EF_M68K_CF_ISA_A
:
3595 case EF_M68K_CF_ISA_A_PLUS
:
3598 case EF_M68K_CF_ISA_B_NOUSP
:
3600 additional
= ", nousp";
3602 case EF_M68K_CF_ISA_B
:
3605 case EF_M68K_CF_ISA_C
:
3608 case EF_M68K_CF_ISA_C_NODIV
:
3610 additional
= ", nodiv";
3613 out
= stpcpy (out
, ", cf, isa ");
3614 out
= stpcpy (out
, isa
);
3616 out
= stpcpy (out
, additional
);
3617 if (e_flags
& EF_M68K_CF_FLOAT
)
3618 out
= stpcpy (out
, ", float");
3619 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3624 case EF_M68K_CF_MAC
:
3627 case EF_M68K_CF_EMAC
:
3630 case EF_M68K_CF_EMAC_B
:
3636 out
= stpcpy (out
, ", ");
3637 out
= stpcpy (out
, mac
);
3644 decode_MeP_machine_flags (char *out
, unsigned int e_flags
)
3646 switch (e_flags
& EF_MEP_CPU_MASK
)
3648 case EF_MEP_CPU_MEP
:
3649 out
= stpcpy (out
, ", generic MeP");
3652 out
= stpcpy (out
, ", MeP C2");
3655 out
= stpcpy (out
, ", MeP C3");
3658 out
= stpcpy (out
, ", MeP C4");
3661 out
= stpcpy (out
, ", MeP C5");
3664 out
= stpcpy (out
, ", MeP H1");
3667 out
= stpcpy (out
, _(", <unknown MeP cpu type>"));
3671 switch (e_flags
& EF_MEP_COP_MASK
)
3673 case EF_MEP_COP_NONE
:
3675 case EF_MEP_COP_AVC
:
3676 out
= stpcpy (out
, ", AVC coprocessor");
3678 case EF_MEP_COP_AVC2
:
3679 out
= stpcpy (out
, ", AVC2 coprocessor");
3681 case EF_MEP_COP_FMAX
:
3682 out
= stpcpy (out
, ", FMAX coprocessor");
3684 case EF_MEP_COP_IVC2
:
3685 out
= stpcpy (out
, ", IVC2 coprocessor");
3688 out
= stpcpy (out
, _("<unknown MeP copro type>"));
3692 if (e_flags
& EF_MEP_LIBRARY
)
3693 out
= stpcpy (out
, ", Built for Library");
3695 if (e_flags
& EF_MEP_INDEX_MASK
)
3696 out
+= sprintf (out
, ", Configuration Index: %#x",
3697 e_flags
& EF_MEP_INDEX_MASK
);
3699 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3700 out
+= sprintf (out
, _(", unknown flags bits: %#x"),
3701 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3706 decode_MIPS_machine_flags (char *out
, unsigned int e_flags
)
3708 if (e_flags
& EF_MIPS_NOREORDER
)
3709 out
= stpcpy (out
, ", noreorder");
3711 if (e_flags
& EF_MIPS_PIC
)
3712 out
= stpcpy (out
, ", pic");
3714 if (e_flags
& EF_MIPS_CPIC
)
3715 out
= stpcpy (out
, ", cpic");
3717 if (e_flags
& EF_MIPS_UCODE
)
3718 out
= stpcpy (out
, ", ugen_reserved");
3720 if (e_flags
& EF_MIPS_ABI2
)
3721 out
= stpcpy (out
, ", abi2");
3723 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3724 out
= stpcpy (out
, ", odk first");
3726 if (e_flags
& EF_MIPS_32BITMODE
)
3727 out
= stpcpy (out
, ", 32bitmode");
3729 if (e_flags
& EF_MIPS_NAN2008
)
3730 out
= stpcpy (out
, ", nan2008");
3732 if (e_flags
& EF_MIPS_FP64
)
3733 out
= stpcpy (out
, ", fp64");
3735 switch ((e_flags
& EF_MIPS_MACH
))
3737 case E_MIPS_MACH_3900
:
3738 out
= stpcpy (out
, ", 3900");
3740 case E_MIPS_MACH_4010
:
3741 out
= stpcpy (out
, ", 4010");
3743 case E_MIPS_MACH_4100
:
3744 out
= stpcpy (out
, ", 4100");
3746 case E_MIPS_MACH_4111
:
3747 out
= stpcpy (out
, ", 4111");
3749 case E_MIPS_MACH_4120
:
3750 out
= stpcpy (out
, ", 4120");
3752 case E_MIPS_MACH_4650
:
3753 out
= stpcpy (out
, ", 4650");
3755 case E_MIPS_MACH_5400
:
3756 out
= stpcpy (out
, ", 5400");
3758 case E_MIPS_MACH_5500
:
3759 out
= stpcpy (out
, ", 5500");
3761 case E_MIPS_MACH_5900
:
3762 out
= stpcpy (out
, ", 5900");
3764 case E_MIPS_MACH_SB1
:
3765 out
= stpcpy (out
, ", sb1");
3767 case E_MIPS_MACH_9000
:
3768 out
= stpcpy (out
, ", 9000");
3770 case E_MIPS_MACH_LS2E
:
3771 out
= stpcpy (out
, ", loongson-2e");
3773 case E_MIPS_MACH_LS2F
:
3774 out
= stpcpy (out
, ", loongson-2f");
3776 case E_MIPS_MACH_GS464
:
3777 out
= stpcpy (out
, ", gs464");
3779 case E_MIPS_MACH_GS464E
:
3780 out
= stpcpy (out
, ", gs464e");
3782 case E_MIPS_MACH_GS264E
:
3783 out
= stpcpy (out
, ", gs264e");
3785 case E_MIPS_MACH_OCTEON
:
3786 out
= stpcpy (out
, ", octeon");
3788 case E_MIPS_MACH_OCTEON2
:
3789 out
= stpcpy (out
, ", octeon2");
3791 case E_MIPS_MACH_OCTEON3
:
3792 out
= stpcpy (out
, ", octeon3");
3794 case E_MIPS_MACH_XLR
:
3795 out
= stpcpy (out
, ", xlr");
3797 case E_MIPS_MACH_IAMR2
:
3798 out
= stpcpy (out
, ", interaptiv-mr2");
3800 case E_MIPS_MACH_ALLEGREX
:
3801 out
= stpcpy (out
, ", allegrex");
3804 /* We simply ignore the field in this case to avoid confusion:
3805 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3809 out
= stpcpy (out
, _(", unknown CPU"));
3813 switch ((e_flags
& EF_MIPS_ABI
))
3815 case E_MIPS_ABI_O32
:
3816 out
= stpcpy (out
, ", o32");
3818 case E_MIPS_ABI_O64
:
3819 out
= stpcpy (out
, ", o64");
3821 case E_MIPS_ABI_EABI32
:
3822 out
= stpcpy (out
, ", eabi32");
3824 case E_MIPS_ABI_EABI64
:
3825 out
= stpcpy (out
, ", eabi64");
3828 /* We simply ignore the field in this case to avoid confusion:
3829 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3830 This means it is likely to be an o32 file, but not for
3834 out
= stpcpy (out
, _(", unknown ABI"));
3838 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3839 out
= stpcpy (out
, ", mdmx");
3841 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3842 out
= stpcpy (out
, ", mips16");
3844 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3845 out
= stpcpy (out
, ", micromips");
3847 switch ((e_flags
& EF_MIPS_ARCH
))
3850 out
= stpcpy (out
, ", mips1");
3853 out
= stpcpy (out
, ", mips2");
3856 out
= stpcpy (out
, ", mips3");
3859 out
= stpcpy (out
, ", mips4");
3862 out
= stpcpy (out
, ", mips5");
3864 case E_MIPS_ARCH_32
:
3865 out
= stpcpy (out
, ", mips32");
3867 case E_MIPS_ARCH_32R2
:
3868 out
= stpcpy (out
, ", mips32r2");
3870 case E_MIPS_ARCH_32R6
:
3871 out
= stpcpy (out
, ", mips32r6");
3873 case E_MIPS_ARCH_64
:
3874 out
= stpcpy (out
, ", mips64");
3876 case E_MIPS_ARCH_64R2
:
3877 out
= stpcpy (out
, ", mips64r2");
3879 case E_MIPS_ARCH_64R6
:
3880 out
= stpcpy (out
, ", mips64r6");
3883 out
= stpcpy (out
, _(", unknown ISA"));
3890 decode_MSP430_machine_flags (char *out
, unsigned e_flags
)
3892 out
= stpcpy (out
, _(": architecture variant: "));
3893 switch (e_flags
& EF_MSP430_MACH
)
3895 case E_MSP430_MACH_MSP430x11
:
3896 out
= stpcpy (out
, "MSP430x11");
3898 case E_MSP430_MACH_MSP430x11x1
:
3899 out
= stpcpy (out
, "MSP430x11x1 ");
3901 case E_MSP430_MACH_MSP430x12
:
3902 out
= stpcpy (out
, "MSP430x12");
3904 case E_MSP430_MACH_MSP430x13
:
3905 out
= stpcpy (out
, "MSP430x13");
3907 case E_MSP430_MACH_MSP430x14
:
3908 out
= stpcpy (out
, "MSP430x14");
3910 case E_MSP430_MACH_MSP430x15
:
3911 out
= stpcpy (out
, "MSP430x15");
3913 case E_MSP430_MACH_MSP430x16
:
3914 out
= stpcpy (out
, "MSP430x16");
3916 case E_MSP430_MACH_MSP430x31
:
3917 out
= stpcpy (out
, "MSP430x31");
3919 case E_MSP430_MACH_MSP430x32
:
3920 out
= stpcpy (out
, "MSP430x32");
3922 case E_MSP430_MACH_MSP430x33
:
3923 out
= stpcpy (out
, "MSP430x33");
3925 case E_MSP430_MACH_MSP430x41
:
3926 out
= stpcpy (out
, "MSP430x41");
3928 case E_MSP430_MACH_MSP430x42
:
3929 out
= stpcpy (out
, "MSP430x42");
3931 case E_MSP430_MACH_MSP430x43
:
3932 out
= stpcpy (out
, "MSP430x43");
3934 case E_MSP430_MACH_MSP430x44
:
3935 out
= stpcpy (out
, "MSP430x44");
3937 case E_MSP430_MACH_MSP430X
:
3938 out
= stpcpy (out
, "MSP430X");
3941 out
= stpcpy (out
, _(": unknown"));
3945 if (e_flags
& ~ EF_MSP430_MACH
)
3946 out
= stpcpy (out
, _(": unknown extra flag bits also present"));
3951 decode_NDS32_machine_flags (char *out
, unsigned e_flags
)
3957 bool has_fpu
= false;
3959 static const char *ABI_STRINGS
[] =
3961 "ABI v0", /* use r5 as return register; only used in N1213HC */
3962 "ABI v1", /* use r0 as return register */
3963 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
3964 "ABI v2fp", /* for FPU */
3968 static const char *VER_STRINGS
[] =
3970 "Andes ELF V1.3 or older",
3974 static const char *ARCH_STRINGS
[] =
3983 abi
= EF_NDS_ABI
& e_flags
;
3984 arch
= EF_NDS_ARCH
& e_flags
;
3985 config
= EF_NDS_INST
& e_flags
;
3986 version
= EF_NDS32_ELF_VERSION
& e_flags
;
3993 case E_NDS_ABI_V2FP
:
3994 case E_NDS_ABI_AABI
:
3995 case E_NDS_ABI_V2FP_PLUS
:
3996 /* In case there are holes in the array. */
3997 out
+= sprintf (out
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
4001 out
= stpcpy (out
, ", <unrecognized ABI>");
4007 case E_NDS32_ELF_VER_1_2
:
4008 case E_NDS32_ELF_VER_1_3
:
4009 case E_NDS32_ELF_VER_1_4
:
4010 out
+= sprintf (out
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
4014 out
= stpcpy (out
, ", <unrecognized ELF version number>");
4018 if (E_NDS_ABI_V0
== abi
)
4020 /* OLD ABI; only used in N1213HC, has performance extension 1. */
4021 out
= stpcpy (out
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
4022 if (arch
== E_NDS_ARCH_STAR_V1_0
)
4023 out
= stpcpy (out
, ", 16b"); /* has 16-bit instructions */
4029 case E_NDS_ARCH_STAR_V1_0
:
4030 case E_NDS_ARCH_STAR_V2_0
:
4031 case E_NDS_ARCH_STAR_V3_0
:
4032 case E_NDS_ARCH_STAR_V3_M
:
4033 out
+= sprintf (out
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
4037 out
= stpcpy (out
, ", <unrecognized architecture>");
4038 /* ARCH version determines how the e_flags are interpreted.
4039 If it is unknown, we cannot proceed. */
4043 /* Newer ABI; Now handle architecture specific flags. */
4044 if (arch
== E_NDS_ARCH_STAR_V1_0
)
4046 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
4047 out
= stpcpy (out
, ", MFUSR_PC");
4049 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
4050 out
= stpcpy (out
, ", MAC");
4052 if (config
& E_NDS32_HAS_DIV_INST
)
4053 out
= stpcpy (out
, ", DIV");
4055 if (config
& E_NDS32_HAS_16BIT_INST
)
4056 out
= stpcpy (out
, ", 16b");
4060 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
4062 if (version
<= E_NDS32_ELF_VER_1_3
)
4063 out
= stpcpy (out
, ", [B8]");
4065 out
= stpcpy (out
, ", EX9");
4068 if (config
& E_NDS32_HAS_MAC_DX_INST
)
4069 out
= stpcpy (out
, ", MAC_DX");
4071 if (config
& E_NDS32_HAS_DIV_DX_INST
)
4072 out
= stpcpy (out
, ", DIV_DX");
4074 if (config
& E_NDS32_HAS_16BIT_INST
)
4076 if (version
<= E_NDS32_ELF_VER_1_3
)
4077 out
= stpcpy (out
, ", 16b");
4079 out
= stpcpy (out
, ", IFC");
4083 if (config
& E_NDS32_HAS_EXT_INST
)
4084 out
= stpcpy (out
, ", PERF1");
4086 if (config
& E_NDS32_HAS_EXT2_INST
)
4087 out
= stpcpy (out
, ", PERF2");
4089 if (config
& E_NDS32_HAS_FPU_INST
)
4092 out
= stpcpy (out
, ", FPU_SP");
4095 if (config
& E_NDS32_HAS_FPU_DP_INST
)
4098 out
= stpcpy (out
, ", FPU_DP");
4101 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
4104 out
= stpcpy (out
, ", FPU_MAC");
4109 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
4111 case E_NDS32_FPU_REG_8SP_4DP
:
4112 out
= stpcpy (out
, ", FPU_REG:8/4");
4114 case E_NDS32_FPU_REG_16SP_8DP
:
4115 out
= stpcpy (out
, ", FPU_REG:16/8");
4117 case E_NDS32_FPU_REG_32SP_16DP
:
4118 out
= stpcpy (out
, ", FPU_REG:32/16");
4120 case E_NDS32_FPU_REG_32SP_32DP
:
4121 out
= stpcpy (out
, ", FPU_REG:32/32");
4126 if (config
& E_NDS32_HAS_AUDIO_INST
)
4127 out
= stpcpy (out
, ", AUDIO");
4129 if (config
& E_NDS32_HAS_STRING_INST
)
4130 out
= stpcpy (out
, ", STR");
4132 if (config
& E_NDS32_HAS_REDUCED_REGS
)
4133 out
= stpcpy (out
, ", 16REG");
4135 if (config
& E_NDS32_HAS_VIDEO_INST
)
4137 if (version
<= E_NDS32_ELF_VER_1_3
)
4138 out
= stpcpy (out
, ", VIDEO");
4140 out
= stpcpy (out
, ", SATURATION");
4143 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
4144 out
= stpcpy (out
, ", ENCRP");
4146 if (config
& E_NDS32_HAS_L2C_INST
)
4147 out
= stpcpy (out
, ", L2C");
4153 decode_PARISC_machine_flags (char *out
, unsigned e_flags
)
4155 switch (e_flags
& EF_PARISC_ARCH
)
4157 case EFA_PARISC_1_0
:
4158 out
= stpcpy (out
, ", PA-RISC 1.0");
4160 case EFA_PARISC_1_1
:
4161 out
= stpcpy (out
, ", PA-RISC 1.1");
4163 case EFA_PARISC_2_0
:
4164 out
= stpcpy (out
, ", PA-RISC 2.0");
4169 if (e_flags
& EF_PARISC_TRAPNIL
)
4170 out
= stpcpy (out
, ", trapnil");
4171 if (e_flags
& EF_PARISC_EXT
)
4172 out
= stpcpy (out
, ", ext");
4173 if (e_flags
& EF_PARISC_LSB
)
4174 out
= stpcpy (out
, ", lsb");
4175 if (e_flags
& EF_PARISC_WIDE
)
4176 out
= stpcpy (out
, ", wide");
4177 if (e_flags
& EF_PARISC_NO_KABP
)
4178 out
= stpcpy (out
, ", no kabp");
4179 if (e_flags
& EF_PARISC_LAZYSWAP
)
4180 out
= stpcpy (out
, ", lazyswap");
4185 decode_RISCV_machine_flags (char *out
, unsigned e_flags
)
4187 if (e_flags
& EF_RISCV_RVC
)
4188 out
= stpcpy (out
, ", RVC");
4190 if (e_flags
& EF_RISCV_RVE
)
4191 out
= stpcpy (out
, ", RVE");
4193 if (e_flags
& EF_RISCV_TSO
)
4194 out
= stpcpy (out
, ", TSO");
4196 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
4198 case EF_RISCV_FLOAT_ABI_SOFT
:
4199 out
= stpcpy (out
, ", soft-float ABI");
4202 case EF_RISCV_FLOAT_ABI_SINGLE
:
4203 out
= stpcpy (out
, ", single-float ABI");
4206 case EF_RISCV_FLOAT_ABI_DOUBLE
:
4207 out
= stpcpy (out
, ", double-float ABI");
4210 case EF_RISCV_FLOAT_ABI_QUAD
:
4211 out
= stpcpy (out
, ", quad-float ABI");
4218 decode_RL78_machine_flags (char *out
, unsigned e_flags
)
4220 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
4222 case E_FLAG_RL78_ANY_CPU
:
4224 case E_FLAG_RL78_G10
:
4225 out
= stpcpy (out
, ", G10");
4227 case E_FLAG_RL78_G13
:
4228 out
= stpcpy (out
, ", G13");
4230 case E_FLAG_RL78_G14
:
4231 out
= stpcpy (out
, ", G14");
4234 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
4235 out
= stpcpy (out
, ", 64-bit doubles");
4240 decode_RX_machine_flags (char *out
, unsigned e_flags
)
4242 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
4243 out
= stpcpy (out
, ", 64-bit doubles");
4244 if (e_flags
& E_FLAG_RX_DSP
)
4245 out
= stpcpy (out
, ", dsp");
4246 if (e_flags
& E_FLAG_RX_PID
)
4247 out
= stpcpy (out
, ", pid");
4248 if (e_flags
& E_FLAG_RX_ABI
)
4249 out
= stpcpy (out
, ", RX ABI");
4250 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
4251 out
= stpcpy (out
, (e_flags
& E_FLAG_RX_SINSNS_YES
4252 ? ", uses String instructions"
4253 : ", bans String instructions"));
4254 if (e_flags
& E_FLAG_RX_V2
)
4255 out
= stpcpy (out
, ", V2");
4256 if (e_flags
& E_FLAG_RX_V3
)
4257 out
= stpcpy (out
, ", V3");
4262 decode_SH_machine_flags (char *out
, unsigned e_flags
)
4264 switch ((e_flags
& EF_SH_MACH_MASK
))
4267 out
= stpcpy (out
, ", sh1");
4270 out
= stpcpy (out
, ", sh2");
4273 out
= stpcpy (out
, ", sh3");
4276 out
= stpcpy (out
, ", sh-dsp");
4279 out
= stpcpy (out
, ", sh3-dsp");
4282 out
= stpcpy (out
, ", sh4al-dsp");
4285 out
= stpcpy (out
, ", sh3e");
4288 out
= stpcpy (out
, ", sh4");
4291 out
= stpcpy (out
, ", sh5");
4294 out
= stpcpy (out
, ", sh2e");
4297 out
= stpcpy (out
, ", sh4a");
4300 out
= stpcpy (out
, ", sh2a");
4303 out
= stpcpy (out
, ", sh4-nofpu");
4306 out
= stpcpy (out
, ", sh4a-nofpu");
4309 out
= stpcpy (out
, ", sh2a-nofpu");
4312 out
= stpcpy (out
, ", sh3-nommu");
4314 case EF_SH4_NOMMU_NOFPU
:
4315 out
= stpcpy (out
, ", sh4-nommu-nofpu");
4317 case EF_SH2A_SH4_NOFPU
:
4318 out
= stpcpy (out
, ", sh2a-nofpu-or-sh4-nommu-nofpu");
4320 case EF_SH2A_SH3_NOFPU
:
4321 out
= stpcpy (out
, ", sh2a-nofpu-or-sh3-nommu");
4324 out
= stpcpy (out
, ", sh2a-or-sh4");
4327 out
= stpcpy (out
, ", sh2a-or-sh3e");
4330 out
= stpcpy (out
, _(", unknown ISA"));
4334 if (e_flags
& EF_SH_PIC
)
4335 out
= stpcpy (out
, ", pic");
4337 if (e_flags
& EF_SH_FDPIC
)
4338 out
= stpcpy (out
, ", fdpic");
4343 decode_SPARC_machine_flags (char *out
, unsigned e_flags
)
4345 if (e_flags
& EF_SPARC_32PLUS
)
4346 out
= stpcpy (out
, ", v8+");
4348 if (e_flags
& EF_SPARC_SUN_US1
)
4349 out
= stpcpy (out
, ", ultrasparcI");
4351 if (e_flags
& EF_SPARC_SUN_US3
)
4352 out
= stpcpy (out
, ", ultrasparcIII");
4354 if (e_flags
& EF_SPARC_HAL_R1
)
4355 out
= stpcpy (out
, ", halr1");
4357 if (e_flags
& EF_SPARC_LEDATA
)
4358 out
= stpcpy (out
, ", ledata");
4360 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
4361 out
= stpcpy (out
, ", tso");
4363 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
4364 out
= stpcpy (out
, ", pso");
4366 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
4367 out
= stpcpy (out
, ", rmo");
4372 decode_V800_machine_flags (char *out
, unsigned int e_flags
)
4374 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
4375 out
= stpcpy (out
, ", RH850 ABI");
4377 if (e_flags
& EF_V800_850E3
)
4378 out
= stpcpy (out
, ", V3 architecture");
4380 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
4381 out
= stpcpy (out
, ", FPU not used");
4383 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
4384 out
= stpcpy (out
, ", regmode: COMMON");
4386 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
4387 out
= stpcpy (out
, ", r4 not used");
4389 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
4390 out
= stpcpy (out
, ", r30 not used");
4392 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
4393 out
= stpcpy (out
, ", r5 not used");
4395 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
4396 out
= stpcpy (out
, ", r2 not used");
4398 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
4400 switch (e_flags
& - e_flags
)
4402 case EF_RH850_FPU_DOUBLE
:
4403 out
= stpcpy (out
, ", double precision FPU");
4405 case EF_RH850_FPU_SINGLE
:
4406 out
= stpcpy (out
, ", single precision FPU");
4408 case EF_RH850_REGMODE22
:
4409 out
= stpcpy (out
, ", regmode:22");
4411 case EF_RH850_REGMODE32
:
4412 out
= stpcpy (out
, ", regmode:23");
4414 case EF_RH850_GP_FIX
:
4415 out
= stpcpy (out
, ", r4 fixed");
4417 case EF_RH850_GP_NOFIX
:
4418 out
= stpcpy (out
, ", r4 free");
4420 case EF_RH850_EP_FIX
:
4421 out
= stpcpy (out
, ", r30 fixed");
4423 case EF_RH850_EP_NOFIX
:
4424 out
= stpcpy (out
, ", r30 free");
4426 case EF_RH850_TP_FIX
:
4427 out
= stpcpy (out
, ", r5 fixed");
4429 case EF_RH850_TP_NOFIX
:
4430 out
= stpcpy (out
, ", r5 free");
4432 case EF_RH850_REG2_RESERVE
:
4433 out
= stpcpy (out
, ", r2 fixed");
4435 case EF_RH850_REG2_NORESERVE
:
4436 out
= stpcpy (out
, ", r2 free");
4446 decode_V850_machine_flags (char *out
, unsigned int e_flags
)
4448 switch (e_flags
& EF_V850_ARCH
)
4450 case E_V850E3V5_ARCH
:
4451 out
= stpcpy (out
, ", v850e3v5");
4453 case E_V850E2V3_ARCH
:
4454 out
= stpcpy (out
, ", v850e2v3");
4457 out
= stpcpy (out
, ", v850e2");
4460 out
= stpcpy (out
, ", v850e1");
4463 out
= stpcpy (out
, ", v850e");
4466 out
= stpcpy (out
, ", v850");
4469 out
= stpcpy (out
, _(", unknown v850 architecture variant"));
4476 decode_Z80_machine_flags (char *out
, unsigned int e_flags
)
4478 switch (e_flags
& EF_Z80_MACH_MSK
)
4480 case EF_Z80_MACH_Z80
:
4481 out
= stpcpy (out
, ", Z80");
4483 case EF_Z80_MACH_Z180
:
4484 out
= stpcpy (out
, ", Z180");
4486 case EF_Z80_MACH_R800
:
4487 out
= stpcpy (out
, ", R800");
4489 case EF_Z80_MACH_EZ80_Z80
:
4490 out
= stpcpy (out
, ", EZ80");
4492 case EF_Z80_MACH_EZ80_ADL
:
4493 out
= stpcpy (out
, ", EZ80, ADL");
4495 case EF_Z80_MACH_GBZ80
:
4496 out
= stpcpy (out
, ", GBZ80");
4498 case EF_Z80_MACH_Z80N
:
4499 out
= stpcpy (out
, ", Z80N");
4502 out
= stpcpy (out
, _(", unknown"));
4509 decode_AMDGPU_machine_flags (char *out
, unsigned int e_flags
, Filedata
*filedata
)
4511 unsigned char *e_ident
= filedata
->file_header
.e_ident
;
4512 unsigned char osabi
= e_ident
[EI_OSABI
];
4513 unsigned char abiversion
= e_ident
[EI_ABIVERSION
];
4516 /* HSA OS ABI v2 used a different encoding, but we don't need to support it,
4517 it has been deprecated for a while.
4519 The PAL, MESA3D and NONE OS ABIs are not properly versioned, at the time
4520 of writing, they use the same flags as HSA v3, so the code below uses that
4522 if (osabi
== ELFOSABI_AMDGPU_HSA
&& abiversion
< ELFABIVERSION_AMDGPU_HSA_V3
)
4525 mach
= e_flags
& EF_AMDGPU_MACH
;
4528 #define AMDGPU_CASE(code, string) \
4529 case code: out = stpcpy (out, ", " string); break;
4530 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX600
, "gfx600")
4531 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX601
, "gfx601")
4532 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX700
, "gfx700")
4533 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX701
, "gfx701")
4534 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX702
, "gfx702")
4535 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX703
, "gfx703")
4536 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX704
, "gfx704")
4537 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX801
, "gfx801")
4538 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX802
, "gfx802")
4539 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX803
, "gfx803")
4540 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX810
, "gfx810")
4541 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX900
, "gfx900")
4542 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX902
, "gfx902")
4543 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX904
, "gfx904")
4544 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX906
, "gfx906")
4545 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX908
, "gfx908")
4546 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX909
, "gfx909")
4547 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX90C
, "gfx90c")
4548 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1010
, "gfx1010")
4549 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1011
, "gfx1011")
4550 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1012
, "gfx1012")
4551 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1030
, "gfx1030")
4552 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1031
, "gfx1031")
4553 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1032
, "gfx1032")
4554 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1033
, "gfx1033")
4555 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX602
, "gfx602")
4556 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX705
, "gfx705")
4557 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX805
, "gfx805")
4558 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1035
, "gfx1035")
4559 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1034
, "gfx1034")
4560 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX90A
, "gfx90a")
4561 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX940
, "gfx940")
4562 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1013
, "gfx1013")
4563 AMDGPU_CASE (EF_AMDGPU_MACH_AMDGCN_GFX1036
, "gfx1036")
4565 out
+= sprintf (out
, _(", <unknown AMDGPU GPU type: %#x>"), mach
);
4570 e_flags
&= ~EF_AMDGPU_MACH
;
4572 if ((osabi
== ELFOSABI_AMDGPU_HSA
4573 && abiversion
== ELFABIVERSION_AMDGPU_HSA_V3
)
4574 || osabi
!= ELFOSABI_AMDGPU_HSA
)
4576 /* For HSA v3 and other OS ABIs. */
4577 if (e_flags
& EF_AMDGPU_FEATURE_XNACK_V3
)
4579 out
= stpcpy (out
, ", xnack on");
4580 e_flags
&= ~EF_AMDGPU_FEATURE_XNACK_V3
;
4583 if (e_flags
& EF_AMDGPU_FEATURE_SRAMECC_V3
)
4585 out
= stpcpy (out
, ", sramecc on");
4586 e_flags
&= ~EF_AMDGPU_FEATURE_SRAMECC_V3
;
4594 xnack
= e_flags
& EF_AMDGPU_FEATURE_XNACK_V4
;
4597 case EF_AMDGPU_FEATURE_XNACK_UNSUPPORTED_V4
:
4600 case EF_AMDGPU_FEATURE_XNACK_ANY_V4
:
4601 out
= stpcpy (out
, ", xnack any");
4604 case EF_AMDGPU_FEATURE_XNACK_OFF_V4
:
4605 out
= stpcpy (out
, ", xnack off");
4608 case EF_AMDGPU_FEATURE_XNACK_ON_V4
:
4609 out
= stpcpy (out
, ", xnack on");
4613 out
+= sprintf (out
, _(", <unknown xnack value: %#x>"), xnack
);
4617 e_flags
&= ~EF_AMDGPU_FEATURE_XNACK_V4
;
4619 sramecc
= e_flags
& EF_AMDGPU_FEATURE_SRAMECC_V4
;
4622 case EF_AMDGPU_FEATURE_SRAMECC_UNSUPPORTED_V4
:
4625 case EF_AMDGPU_FEATURE_SRAMECC_ANY_V4
:
4626 out
= stpcpy (out
, ", sramecc any");
4629 case EF_AMDGPU_FEATURE_SRAMECC_OFF_V4
:
4630 out
= stpcpy (out
, ", sramecc off");
4633 case EF_AMDGPU_FEATURE_SRAMECC_ON_V4
:
4634 out
= stpcpy (out
, ", sramecc on");
4638 out
+= sprintf (out
, _(", <unknown sramecc value: %#x>"), sramecc
);
4642 e_flags
&= ~EF_AMDGPU_FEATURE_SRAMECC_V4
;
4646 out
+= sprintf (out
, _(", unknown flags bits: %#x"), e_flags
);
4651 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
4653 static char buf
[1024];
4665 case EM_ARC_COMPACT3
:
4666 out
= stpcpy (out
, ", HS5x");
4669 case EM_ARC_COMPACT3_64
:
4670 out
= stpcpy (out
, ", HS6x");
4673 case EM_ARC_COMPACT2
:
4674 case EM_ARC_COMPACT
:
4675 out
= decode_ARC_machine_flags (out
, e_flags
, e_machine
);
4679 out
= decode_ARM_machine_flags (out
, e_flags
);
4683 out
= decode_AVR_machine_flags (out
, e_flags
);
4687 out
= decode_BLACKFIN_machine_flags (out
, e_flags
);
4691 out
= decode_FRV_machine_flags (out
, e_flags
);
4695 out
= decode_M68K_machine_flags (out
, e_flags
);
4699 out
= decode_AMDGPU_machine_flags (out
, e_flags
, filedata
);
4703 out
= decode_MeP_machine_flags (out
, e_flags
);
4707 if (e_flags
& EF_PPC_EMB
)
4708 out
= stpcpy (out
, ", emb");
4710 if (e_flags
& EF_PPC_RELOCATABLE
)
4711 out
= stpcpy (out
, _(", relocatable"));
4713 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
4714 out
= stpcpy (out
, _(", relocatable-lib"));
4718 if (e_flags
& EF_PPC64_ABI
)
4719 out
+= sprintf (out
, ", abiv%d", e_flags
& EF_PPC64_ABI
);
4723 out
= decode_V800_machine_flags (out
, e_flags
);
4727 case EM_CYGNUS_V850
:
4728 out
= decode_V850_machine_flags (out
, e_flags
);
4732 case EM_CYGNUS_M32R
:
4733 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
4734 out
= stpcpy (out
, ", m32r");
4738 case EM_MIPS_RS3_LE
:
4739 out
= decode_MIPS_machine_flags (out
, e_flags
);
4743 out
= decode_NDS32_machine_flags (out
, e_flags
);
4747 switch (EF_NFP_MACH (e_flags
))
4749 case E_NFP_MACH_3200
:
4750 out
= stpcpy (out
, ", NFP-32xx");
4752 case E_NFP_MACH_6000
:
4753 out
= stpcpy (out
, ", NFP-6xxx");
4759 out
= decode_RISCV_machine_flags (out
, e_flags
);
4763 out
= decode_SH_machine_flags (out
, e_flags
);
4767 if (e_flags
& EF_OR1K_NODELAY
)
4768 out
= stpcpy (out
, ", no delay");
4772 out
+= sprintf (out
, ", CPU Version: %u", e_flags
& EF_BPF_CPUVER
);
4776 out
= decode_SPARC_machine_flags (out
, e_flags
);
4780 out
= decode_PARISC_machine_flags (out
, e_flags
);
4785 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
4786 out
= stpcpy (out
, ", new calling convention");
4788 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
4789 out
= stpcpy (out
, ", gnu calling convention");
4793 out
= decode_IA64_machine_flags (out
, e_flags
, filedata
);
4797 if ((e_flags
& EF_VAX_NONPIC
))
4798 out
= stpcpy (out
, ", non-PIC");
4799 if ((e_flags
& EF_VAX_DFLOAT
))
4800 out
= stpcpy (out
, ", D-Float");
4801 if ((e_flags
& EF_VAX_GFLOAT
))
4802 out
= stpcpy (out
, ", G-Float");
4806 if (e_flags
& EF_VISIUM_ARCH_MCM
)
4807 out
= stpcpy (out
, ", mcm");
4808 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
4809 out
= stpcpy (out
, ", mcm24");
4810 if (e_flags
& EF_VISIUM_ARCH_GR6
)
4811 out
= stpcpy (out
, ", gr6");
4815 out
= decode_RL78_machine_flags (out
, e_flags
);
4819 out
= decode_RX_machine_flags (out
, e_flags
);
4823 if (e_flags
& EF_S390_HIGH_GPRS
)
4824 out
= stpcpy (out
, ", highgprs");
4828 if ((e_flags
& EF_C6000_REL
))
4829 out
= stpcpy (out
, ", relocatable module");
4833 if ((e_flags
& (ELF_KVX_CORE_MAJOR_MASK
| ELF_KVX_CORE_MINOR_MASK
)) == ELF_KVX_CORE_KV3_1
)
4834 strcat (buf
, ", Kalray VLIW kv3-1");
4835 else if ((e_flags
& (ELF_KVX_CORE_MAJOR_MASK
| ELF_KVX_CORE_MINOR_MASK
)) == ELF_KVX_CORE_KV3_2
)
4836 strcat (buf
, ", Kalray VLIW kv3-2");
4837 else if ((e_flags
& (ELF_KVX_CORE_MAJOR_MASK
| ELF_KVX_CORE_MINOR_MASK
)) == ELF_KVX_CORE_KV4_1
)
4838 strcat (buf
, ", Kalray VLIW kv4-1");
4840 strcat (buf
, ", unknown KVX MPPA");
4844 out
= decode_MSP430_machine_flags (out
, e_flags
);
4848 out
= decode_Z80_machine_flags (out
, e_flags
);
4852 out
= decode_LOONGARCH_machine_flags (out
, e_flags
);
4861 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
4863 static char buff
[32];
4867 case ELFOSABI_NONE
: return "UNIX - System V";
4868 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
4869 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
4870 case ELFOSABI_GNU
: return "UNIX - GNU";
4871 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
4872 case ELFOSABI_AIX
: return "UNIX - AIX";
4873 case ELFOSABI_IRIX
: return "UNIX - IRIX";
4874 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
4875 case ELFOSABI_TRU64
: return "UNIX - TRU64";
4876 case ELFOSABI_MODESTO
: return "Novell - Modesto";
4877 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
4878 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
4879 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
4880 case ELFOSABI_AROS
: return "AROS";
4881 case ELFOSABI_FENIXOS
: return "FenixOS";
4882 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
4883 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
4886 switch (filedata
->file_header
.e_machine
)
4891 case ELFOSABI_AMDGPU_HSA
: return "AMD HSA";
4892 case ELFOSABI_AMDGPU_PAL
: return "AMD PAL";
4893 case ELFOSABI_AMDGPU_MESA3D
: return "AMD Mesa3D";
4902 case ELFOSABI_ARM
: return "ARM";
4903 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
4914 case ELFOSABI_STANDALONE
: return _("Standalone App");
4923 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
4924 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
4933 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
4939 get_aarch64_segment_type (unsigned long type
)
4943 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
4944 case PT_AARCH64_MEMTAG_MTE
: return "AARCH64_MEMTAG_MTE";
4945 default: return NULL
;
4950 get_arm_segment_type (unsigned long type
)
4954 case PT_ARM_EXIDX
: return "EXIDX";
4955 default: return NULL
;
4960 get_s390_segment_type (unsigned long type
)
4964 case PT_S390_PGSTE
: return "S390_PGSTE";
4965 default: return NULL
;
4970 get_mips_segment_type (unsigned long type
)
4974 case PT_MIPS_REGINFO
: return "REGINFO";
4975 case PT_MIPS_RTPROC
: return "RTPROC";
4976 case PT_MIPS_OPTIONS
: return "OPTIONS";
4977 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
4978 default: return NULL
;
4983 get_parisc_segment_type (unsigned long type
)
4987 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
4988 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
4989 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
4990 default: return NULL
;
4995 get_ia64_segment_type (unsigned long type
)
4999 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
5000 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
5001 default: return NULL
;
5006 get_tic6x_segment_type (unsigned long type
)
5010 case PT_C6000_PHATTR
: return "C6000_PHATTR";
5011 default: return NULL
;
5016 get_riscv_segment_type (unsigned long type
)
5020 case PT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
5021 default: return NULL
;
5026 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
5028 if (e_machine
== EM_PARISC
)
5031 case PT_HP_TLS
: return "HP_TLS";
5032 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
5033 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
5034 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
5035 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
5036 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
5037 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
5038 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
5039 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
5040 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
5041 case PT_HP_PARALLEL
: return "HP_PARALLEL";
5042 case PT_HP_FASTBIND
: return "HP_FASTBIND";
5043 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
5044 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
5045 case PT_HP_STACK
: return "HP_STACK";
5046 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
5047 default: return NULL
;
5050 if (e_machine
== EM_IA_64
)
5053 case PT_HP_TLS
: return "HP_TLS";
5054 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
5055 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
5056 case PT_IA_64_HP_STACK
: return "HP_STACK";
5057 default: return NULL
;
5064 get_solaris_segment_type (unsigned long type
)
5068 case 0x6464e550: return "PT_SUNW_UNWIND";
5069 case 0x6474e550: return "PT_SUNW_EH_FRAME";
5070 case 0x6ffffff7: return "PT_LOSUNW";
5071 case 0x6ffffffa: return "PT_SUNWBSS";
5072 case 0x6ffffffb: return "PT_SUNWSTACK";
5073 case 0x6ffffffc: return "PT_SUNWDTRACE";
5074 case 0x6ffffffd: return "PT_SUNWCAP";
5075 case 0x6fffffff: return "PT_HISUNW";
5076 default: return NULL
;
5081 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
5083 static char buff
[32];
5087 case PT_NULL
: return "NULL";
5088 case PT_LOAD
: return "LOAD";
5089 case PT_DYNAMIC
: return "DYNAMIC";
5090 case PT_INTERP
: return "INTERP";
5091 case PT_NOTE
: return "NOTE";
5092 case PT_SHLIB
: return "SHLIB";
5093 case PT_PHDR
: return "PHDR";
5094 case PT_TLS
: return "TLS";
5095 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
5096 case PT_GNU_STACK
: return "GNU_STACK";
5097 case PT_GNU_RELRO
: return "GNU_RELRO";
5098 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
5099 case PT_GNU_SFRAME
: return "GNU_SFRAME";
5101 case PT_OPENBSD_MUTABLE
: return "OPENBSD_MUTABLE";
5102 case PT_OPENBSD_RANDOMIZE
: return "OPENBSD_RANDOMIZE";
5103 case PT_OPENBSD_WXNEEDED
: return "OPENBSD_WXNEEDED";
5104 case PT_OPENBSD_NOBTCFI
: return "OPENBSD_NOBTCFI";
5105 case PT_OPENBSD_BOOTDATA
: return "OPENBSD_BOOTDATA";
5108 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
5110 const char * result
;
5112 switch (filedata
->file_header
.e_machine
)
5115 result
= get_aarch64_segment_type (p_type
);
5118 result
= get_arm_segment_type (p_type
);
5121 case EM_MIPS_RS3_LE
:
5122 result
= get_mips_segment_type (p_type
);
5125 result
= get_parisc_segment_type (p_type
);
5128 result
= get_ia64_segment_type (p_type
);
5131 result
= get_tic6x_segment_type (p_type
);
5135 result
= get_s390_segment_type (p_type
);
5138 result
= get_riscv_segment_type (p_type
);
5148 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
5150 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
5152 const char * result
= NULL
;
5154 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
5157 case ELFOSABI_FREEBSD
:
5158 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
5160 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
5165 result
= get_hpux_segment_type (p_type
,
5166 filedata
->file_header
.e_machine
);
5168 case ELFOSABI_SOLARIS
:
5169 result
= get_solaris_segment_type (p_type
);
5177 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
5180 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
5187 get_arc_section_type_name (unsigned int sh_type
)
5191 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
5199 get_mips_section_type_name (unsigned int sh_type
)
5203 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
5204 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
5205 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
5206 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
5207 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
5208 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
5209 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
5210 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
5211 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
5212 case SHT_MIPS_RELD
: return "MIPS_RELD";
5213 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
5214 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
5215 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
5216 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
5217 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
5218 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
5219 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
5220 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
5221 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
5222 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
5223 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
5224 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
5225 case SHT_MIPS_LINE
: return "MIPS_LINE";
5226 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
5227 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
5228 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
5229 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
5230 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
5231 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
5232 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
5233 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
5234 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
5235 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
5236 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
5237 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
5238 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
5239 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
5240 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
5241 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
5242 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
5243 case SHT_MIPS_XHASH
: return "MIPS_XHASH";
5251 get_parisc_section_type_name (unsigned int sh_type
)
5255 case SHT_PARISC_EXT
: return "PARISC_EXT";
5256 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
5257 case SHT_PARISC_DOC
: return "PARISC_DOC";
5258 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
5259 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
5260 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
5261 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
5262 default: return NULL
;
5267 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
5269 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
5270 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
5271 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
5275 case SHT_IA_64_EXT
: return "IA_64_EXT";
5276 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
5277 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
5278 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
5279 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
5280 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
5281 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
5282 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
5283 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
5284 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
5292 get_x86_64_section_type_name (unsigned int sh_type
)
5296 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
5297 default: return NULL
;
5302 get_aarch64_section_type_name (unsigned int sh_type
)
5306 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
5307 default: return NULL
;
5312 get_arm_section_type_name (unsigned int sh_type
)
5316 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
5317 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
5318 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
5319 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
5320 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
5321 default: return NULL
;
5326 get_tic6x_section_type_name (unsigned int sh_type
)
5330 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
5331 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
5332 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
5333 case SHT_TI_ICODE
: return "TI_ICODE";
5334 case SHT_TI_XREF
: return "TI_XREF";
5335 case SHT_TI_HANDLER
: return "TI_HANDLER";
5336 case SHT_TI_INITINFO
: return "TI_INITINFO";
5337 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
5338 default: return NULL
;
5343 get_msp430_section_type_name (unsigned int sh_type
)
5347 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
5348 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
5349 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
5350 default: return NULL
;
5355 get_nfp_section_type_name (unsigned int sh_type
)
5359 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
5360 case SHT_NFP_INITREG
: return "NFP_INITREG";
5361 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
5362 default: return NULL
;
5367 get_v850_section_type_name (unsigned int sh_type
)
5371 case SHT_V850_SCOMMON
: return "V850 Small Common";
5372 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
5373 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
5374 case SHT_RENESAS_IOP
: return "RENESAS IOP";
5375 case SHT_RENESAS_INFO
: return "RENESAS INFO";
5376 default: return NULL
;
5381 get_riscv_section_type_name (unsigned int sh_type
)
5385 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
5386 default: return NULL
;
5391 get_csky_section_type_name (unsigned int sh_type
)
5395 case SHT_CSKY_ATTRIBUTES
: return "CSKY_ATTRIBUTES";
5396 default: return NULL
;
5401 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
5403 static char buff
[32];
5404 const char * result
;
5408 case SHT_NULL
: return "NULL";
5409 case SHT_PROGBITS
: return "PROGBITS";
5410 case SHT_SYMTAB
: return "SYMTAB";
5411 case SHT_STRTAB
: return "STRTAB";
5412 case SHT_RELA
: return "RELA";
5413 case SHT_RELR
: return "RELR";
5414 case SHT_HASH
: return "HASH";
5415 case SHT_DYNAMIC
: return "DYNAMIC";
5416 case SHT_NOTE
: return "NOTE";
5417 case SHT_NOBITS
: return "NOBITS";
5418 case SHT_REL
: return "REL";
5419 case SHT_SHLIB
: return "SHLIB";
5420 case SHT_DYNSYM
: return "DYNSYM";
5421 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
5422 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
5423 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
5424 case SHT_GNU_HASH
: return "GNU_HASH";
5425 case SHT_GROUP
: return "GROUP";
5426 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
5427 case SHT_GNU_verdef
: return "VERDEF";
5428 case SHT_GNU_verneed
: return "VERNEED";
5429 case SHT_GNU_versym
: return "VERSYM";
5430 case 0x6ffffff0: return "VERSYM";
5431 case 0x6ffffffc: return "VERDEF";
5432 case 0x7ffffffd: return "AUXILIARY";
5433 case 0x7fffffff: return "FILTER";
5434 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
5437 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
5439 switch (filedata
->file_header
.e_machine
)
5442 case EM_ARC_COMPACT
:
5443 case EM_ARC_COMPACT2
:
5444 case EM_ARC_COMPACT3
:
5445 case EM_ARC_COMPACT3_64
:
5446 result
= get_arc_section_type_name (sh_type
);
5449 case EM_MIPS_RS3_LE
:
5450 result
= get_mips_section_type_name (sh_type
);
5453 result
= get_parisc_section_type_name (sh_type
);
5456 result
= get_ia64_section_type_name (filedata
, sh_type
);
5461 result
= get_x86_64_section_type_name (sh_type
);
5464 result
= get_aarch64_section_type_name (sh_type
);
5467 result
= get_arm_section_type_name (sh_type
);
5470 result
= get_tic6x_section_type_name (sh_type
);
5473 result
= get_msp430_section_type_name (sh_type
);
5476 result
= get_nfp_section_type_name (sh_type
);
5480 case EM_CYGNUS_V850
:
5481 result
= get_v850_section_type_name (sh_type
);
5484 result
= get_riscv_section_type_name (sh_type
);
5487 result
= get_csky_section_type_name (sh_type
);
5497 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
5499 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
5501 switch (filedata
->file_header
.e_machine
)
5504 result
= get_ia64_section_type_name (filedata
, sh_type
);
5507 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
5508 result
= get_solaris_section_type (sh_type
);
5513 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
5514 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
5515 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
5516 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
5528 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
5530 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
5532 switch (filedata
->file_header
.e_machine
)
5536 case EM_CYGNUS_V850
:
5537 result
= get_v850_section_type_name (sh_type
);
5547 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
5550 /* This message is probably going to be displayed in a 15
5551 character wide field, so put the hex value first. */
5552 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
5558 enum long_option_values
5560 OPTION_DEBUG_DUMP
= 512,
5571 OPTION_WITH_SYMBOL_VERSIONS
,
5572 OPTION_RECURSE_LIMIT
,
5573 OPTION_NO_RECURSE_LIMIT
,
5574 OPTION_NO_DEMANGLING
,
5575 OPTION_NO_EXTRA_SYM_INFO
,
5579 static struct option options
[] =
5581 /* Note - This table is alpha-sorted on the 'val'
5582 field in order to make adding new options easier. */
5583 {"arch-specific", no_argument
, 0, 'A'},
5584 {"all", no_argument
, 0, 'a'},
5585 {"demangle", optional_argument
, 0, 'C'},
5586 {"archive-index", no_argument
, 0, 'c'},
5587 {"use-dynamic", no_argument
, 0, 'D'},
5588 {"dynamic", no_argument
, 0, 'd'},
5589 {"headers", no_argument
, 0, 'e'},
5590 {"section-groups", no_argument
, 0, 'g'},
5591 {"help", no_argument
, 0, 'H'},
5592 {"file-header", no_argument
, 0, 'h'},
5593 {"histogram", no_argument
, 0, 'I'},
5594 {"lint", no_argument
, 0, 'L'},
5595 {"enable-checks", no_argument
, 0, 'L'},
5596 {"program-headers", no_argument
, 0, 'l'},
5597 {"segments", no_argument
, 0, 'l'},
5598 {"full-section-name",no_argument
, 0, 'N'},
5599 {"notes", no_argument
, 0, 'n'},
5600 {"process-links", no_argument
, 0, 'P'},
5601 {"string-dump", required_argument
, 0, 'p'},
5602 {"relocated-dump", required_argument
, 0, 'R'},
5603 {"relocs", no_argument
, 0, 'r'},
5604 {"section-headers", no_argument
, 0, 'S'},
5605 {"sections", no_argument
, 0, 'S'},
5606 {"symbols", no_argument
, 0, 's'},
5607 {"syms", no_argument
, 0, 's'},
5608 {"silent-truncation",no_argument
, 0, 'T'},
5609 {"section-details", no_argument
, 0, 't'},
5610 {"unicode", required_argument
, NULL
, 'U'},
5611 {"unwind", no_argument
, 0, 'u'},
5612 {"version-info", no_argument
, 0, 'V'},
5613 {"version", no_argument
, 0, 'v'},
5614 {"wide", no_argument
, 0, 'W'},
5615 {"extra-sym-info", no_argument
, 0, 'X'},
5616 {"hex-dump", required_argument
, 0, 'x'},
5617 {"decompress", no_argument
, 0, 'z'},
5619 {"no-demangle", no_argument
, 0, OPTION_NO_DEMANGLING
},
5620 {"no-extra-sym-info",no_argument
, 0, OPTION_NO_EXTRA_SYM_INFO
},
5621 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
5622 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
5623 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
5624 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
5625 {"lto-syms", no_argument
, 0, OPTION_LTO_SYMS
},
5626 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
5627 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
5628 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
5629 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
5630 #ifdef ENABLE_LIBCTF
5631 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
5632 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
5633 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
5634 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
5636 {"sframe", optional_argument
, 0, OPTION_SFRAME_DUMP
},
5637 {"sym-base", optional_argument
, 0, OPTION_SYM_BASE
},
5639 {0, no_argument
, 0, 0}
5643 usage (FILE * stream
)
5645 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
5646 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
5647 fprintf (stream
, _(" Options are:\n"));
5648 fprintf (stream
, _("\
5649 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
5650 fprintf (stream
, _("\
5651 -h --file-header Display the ELF file header\n"));
5652 fprintf (stream
, _("\
5653 -l --program-headers Display the program headers\n"));
5654 fprintf (stream
, _("\
5655 --segments An alias for --program-headers\n"));
5656 fprintf (stream
, _("\
5657 -S --section-headers Display the sections' header\n"));
5658 fprintf (stream
, _("\
5659 --sections An alias for --section-headers\n"));
5660 fprintf (stream
, _("\
5661 -g --section-groups Display the section groups\n"));
5662 fprintf (stream
, _("\
5663 -t --section-details Display the section details\n"));
5664 fprintf (stream
, _("\
5665 -e --headers Equivalent to: -h -l -S\n"));
5666 fprintf (stream
, _("\
5667 -s --syms Display the symbol table\n"));
5668 fprintf (stream
, _("\
5669 --symbols An alias for --syms\n"));
5670 fprintf (stream
, _("\
5671 --dyn-syms Display the dynamic symbol table\n"));
5672 fprintf (stream
, _("\
5673 --lto-syms Display LTO symbol tables\n"));
5674 fprintf (stream
, _("\
5675 --sym-base=[0|8|10|16] \n\
5676 Force base for symbol sizes. The options are \n\
5677 mixed (the default), octal, decimal, hexadecimal.\n"));
5678 fprintf (stream
, _("\
5679 -C --demangle[=STYLE] Decode mangled/processed symbol names\n"));
5680 display_demangler_styles (stream
, _("\
5682 fprintf (stream
, _("\
5683 --no-demangle Do not demangle low-level symbol names. (default)\n"));
5684 fprintf (stream
, _("\
5685 --recurse-limit Enable a demangling recursion limit. (default)\n"));
5686 fprintf (stream
, _("\
5687 --no-recurse-limit Disable a demangling recursion limit\n"));
5688 fprintf (stream
, _("\
5689 -U[dlexhi] --unicode=[default|locale|escape|hex|highlight|invalid]\n\
5690 Display unicode characters as determined by the current locale\n\
5691 (default), escape sequences, \"<hex sequences>\", highlighted\n\
5692 escape sequences, or treat them as invalid and display as\n\
5693 \"{hex sequences}\"\n"));
5694 fprintf (stream
, _("\
5695 -X --extra-sym-info Display extra information when showing symbols\n"));
5696 fprintf (stream
, _("\
5697 --no-extra-sym-info Do not display extra information when showing symbols (default)\n"));
5698 fprintf (stream
, _("\
5699 -n --notes Display the contents of note sections (if present)\n"));
5700 fprintf (stream
, _("\
5701 -r --relocs Display the relocations (if present)\n"));
5702 fprintf (stream
, _("\
5703 -u --unwind Display the unwind info (if present)\n"));
5704 fprintf (stream
, _("\
5705 -d --dynamic Display the dynamic section (if present)\n"));
5706 fprintf (stream
, _("\
5707 -V --version-info Display the version sections (if present)\n"));
5708 fprintf (stream
, _("\
5709 -A --arch-specific Display architecture specific information (if any)\n"));
5710 fprintf (stream
, _("\
5711 -c --archive-index Display the symbol/file index in an archive\n"));
5712 fprintf (stream
, _("\
5713 -D --use-dynamic Use the dynamic section info when displaying symbols\n"));
5714 fprintf (stream
, _("\
5715 -L --lint|--enable-checks\n\
5716 Display warning messages for possible problems\n"));
5717 fprintf (stream
, _("\
5718 -x --hex-dump=<number|name>\n\
5719 Dump the contents of section <number|name> as bytes\n"));
5720 fprintf (stream
, _("\
5721 -p --string-dump=<number|name>\n\
5722 Dump the contents of section <number|name> as strings\n"));
5723 fprintf (stream
, _("\
5724 -R --relocated-dump=<number|name>\n\
5725 Dump the relocated contents of section <number|name>\n"));
5726 fprintf (stream
, _("\
5727 -z --decompress Decompress section before dumping it\n"));
5728 fprintf (stream
, _("\
5729 -w --debug-dump[a/=abbrev, A/=addr, r/=aranges, c/=cu_index, L/=decodedline,\n\
5730 f/=frames, F/=frames-interp, g/=gdb_index, i/=info, o/=loc,\n\
5731 m/=macro, p/=pubnames, t/=pubtypes, R/=Ranges, l/=rawline,\n\
5732 s/=str, O/=str-offsets, u/=trace_abbrev, T/=trace_aranges,\n\
5734 Display the contents of DWARF debug sections\n"));
5735 fprintf (stream
, _("\
5736 -wk --debug-dump=links Display the contents of sections that link to separate\n\
5737 debuginfo files\n"));
5738 fprintf (stream
, _("\
5739 -P --process-links Display the contents of non-debug sections in separate\n\
5740 debuginfo files. (Implies -wK)\n"));
5741 #if DEFAULT_FOR_FOLLOW_LINKS
5742 fprintf (stream
, _("\
5743 -wK --debug-dump=follow-links\n\
5744 Follow links to separate debug info files (default)\n"));
5745 fprintf (stream
, _("\
5746 -wN --debug-dump=no-follow-links\n\
5747 Do not follow links to separate debug info files\n"));
5749 fprintf (stream
, _("\
5750 -wK --debug-dump=follow-links\n\
5751 Follow links to separate debug info files\n"));
5752 fprintf (stream
, _("\
5753 -wN --debug-dump=no-follow-links\n\
5754 Do not follow links to separate debug info files\n\
5757 #if HAVE_LIBDEBUGINFOD
5758 fprintf (stream
, _("\
5759 -wD --debug-dump=use-debuginfod\n\
5760 When following links, also query debuginfod servers (default)\n"));
5761 fprintf (stream
, _("\
5762 -wE --debug-dump=do-not-use-debuginfod\n\
5763 When following links, do not query debuginfod servers\n"));
5765 fprintf (stream
, _("\
5766 --dwarf-depth=N Do not display DIEs at depth N or greater\n"));
5767 fprintf (stream
, _("\
5768 --dwarf-start=N Display DIEs starting at offset N\n"));
5769 #ifdef ENABLE_LIBCTF
5770 fprintf (stream
, _("\
5771 --ctf=<number|name> Display CTF info from section <number|name>\n"));
5772 fprintf (stream
, _("\
5773 --ctf-parent=<name> Use CTF archive member <name> as the CTF parent\n"));
5774 fprintf (stream
, _("\
5775 --ctf-symbols=<number|name>\n\
5776 Use section <number|name> as the CTF external symtab\n"));
5777 fprintf (stream
, _("\
5778 --ctf-strings=<number|name>\n\
5779 Use section <number|name> as the CTF external strtab\n"));
5781 fprintf (stream
, _("\
5782 --sframe[=NAME] Display SFrame info from section NAME, (default '.sframe')\n"));
5784 #ifdef SUPPORT_DISASSEMBLY
5785 fprintf (stream
, _("\
5786 -i --instruction-dump=<number|name>\n\
5787 Disassemble the contents of section <number|name>\n"));
5789 fprintf (stream
, _("\
5790 -I --histogram Display histogram of bucket list lengths\n"));
5791 fprintf (stream
, _("\
5792 -W --wide Allow output width to exceed 80 characters\n"));
5793 fprintf (stream
, _("\
5794 -T --silent-truncation If a symbol name is truncated, do not add [...] suffix\n"));
5795 fprintf (stream
, _("\
5796 @<file> Read options from <file>\n"));
5797 fprintf (stream
, _("\
5798 -H --help Display this information\n"));
5799 fprintf (stream
, _("\
5800 -v --version Display the version number of readelf\n"));
5802 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
5803 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
5805 exit (stream
== stdout
? 0 : 1);
5808 /* Record the fact that the user wants the contents of section number
5809 SECTION to be displayed using the method(s) encoded as flags bits
5810 in TYPE. Note, TYPE can be zero if we are creating the array for
5814 request_dump_bynumber (struct dump_data
*dumpdata
,
5815 unsigned int section
, dump_type type
)
5817 if (section
>= dumpdata
->num_dump_sects
)
5819 dump_type
* new_dump_sects
;
5821 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
5822 sizeof (* new_dump_sects
));
5824 if (new_dump_sects
== NULL
)
5825 error (_("Out of memory allocating dump request table.\n"));
5828 if (dumpdata
->dump_sects
)
5830 /* Copy current flag settings. */
5831 memcpy (new_dump_sects
, dumpdata
->dump_sects
,
5832 dumpdata
->num_dump_sects
* sizeof (* new_dump_sects
));
5834 free (dumpdata
->dump_sects
);
5837 dumpdata
->dump_sects
= new_dump_sects
;
5838 dumpdata
->num_dump_sects
= section
+ 1;
5842 if (dumpdata
->dump_sects
)
5843 dumpdata
->dump_sects
[section
] |= type
;
5846 /* Request a dump by section name. */
5849 request_dump_byname (const char * section
, dump_type type
)
5851 struct dump_list_entry
* new_request
;
5853 new_request
= (struct dump_list_entry
*)
5854 malloc (sizeof (struct dump_list_entry
));
5856 error (_("Out of memory allocating dump request table.\n"));
5858 new_request
->name
= strdup (section
);
5859 if (!new_request
->name
)
5860 error (_("Out of memory allocating dump request table.\n"));
5862 new_request
->type
= type
;
5864 new_request
->next
= dump_sects_byname
;
5865 dump_sects_byname
= new_request
;
5869 request_dump (struct dump_data
*dumpdata
, dump_type type
)
5875 section
= strtoul (optarg
, & cp
, 0);
5877 if (! *cp
&& section
>= 0)
5878 request_dump_bynumber (dumpdata
, section
, type
);
5880 request_dump_byname (optarg
, type
);
5884 parse_args (struct dump_data
*dumpdata
, int argc
, char ** argv
)
5891 while ((c
= getopt_long
5892 (argc
, argv
, "ACDHILNPR:STU:VWXacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
5910 do_section_groups
= true;
5913 do_histogram
= true;
5919 do_section_groups
= true;
5924 do_section_details
= true;
5935 do_using_dynamic
= true;
5959 do_histogram
= true;
5965 do_archive_index
= true;
5971 process_links
= true;
5972 do_follow_links
= true;
5973 dump_any_debugging
= true;
5976 request_dump (dumpdata
, HEX_DUMP
);
5979 request_dump (dumpdata
, STRING_DUMP
);
5982 request_dump (dumpdata
, RELOC_DUMP
);
5985 decompress_dumps
= true;
5990 do_debugging
= true;
5992 dump_any_debugging
= true;
5993 dwarf_select_sections_all ();
5997 do_debugging
= false;
5998 if (dwarf_select_sections_by_letters (optarg
))
6001 dump_any_debugging
= true;
6005 case OPTION_DEBUG_DUMP
:
6009 do_debugging
= true;
6010 dump_any_debugging
= true;
6011 dwarf_select_sections_all ();
6015 do_debugging
= false;
6016 if (dwarf_select_sections_by_names (optarg
))
6019 dump_any_debugging
= true;
6023 case OPTION_DWARF_DEPTH
:
6027 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
6030 case OPTION_DWARF_START
:
6034 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
6037 case OPTION_DWARF_CHECK
:
6040 case OPTION_CTF_DUMP
:
6042 request_dump (dumpdata
, CTF_DUMP
);
6044 case OPTION_CTF_SYMBOLS
:
6045 free (dump_ctf_symtab_name
);
6046 dump_ctf_symtab_name
= strdup (optarg
);
6048 case OPTION_CTF_STRINGS
:
6049 free (dump_ctf_strtab_name
);
6050 dump_ctf_strtab_name
= strdup (optarg
);
6052 case OPTION_CTF_PARENT
:
6053 free (dump_ctf_parent_name
);
6054 dump_ctf_parent_name
= strdup (optarg
);
6056 case OPTION_SFRAME_DUMP
:
6058 /* Providing section name is optional. request_dump (), however,
6059 thrives on non NULL optarg. Handle it explicitly here. */
6061 request_dump (dumpdata
, SFRAME_DUMP
);
6065 const char *sframe_sec_name
= strdup (".sframe");
6066 request_dump_byname (sframe_sec_name
, SFRAME_DUMP
);
6069 case OPTION_DYN_SYMS
:
6072 case OPTION_LTO_SYMS
:
6076 extra_sym_info
= true;
6078 case OPTION_NO_EXTRA_SYM_INFO
:
6079 extra_sym_info
= false;
6082 #ifdef SUPPORT_DISASSEMBLY
6084 request_dump (dumpdata
, DISASS_DUMP
);
6088 print_version (program_name
);
6097 do_not_show_symbol_truncation
= true;
6103 enum demangling_styles style
;
6105 style
= cplus_demangle_name_to_style (optarg
);
6106 if (style
== unknown_demangling
)
6107 error (_("unknown demangling style `%s'"), optarg
);
6109 cplus_demangle_set_style (style
);
6112 case OPTION_NO_DEMANGLING
:
6113 do_demangle
= false;
6115 case OPTION_RECURSE_LIMIT
:
6116 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
6118 case OPTION_NO_RECURSE_LIMIT
:
6119 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
6121 case OPTION_WITH_SYMBOL_VERSIONS
:
6122 /* Ignored for backward compatibility. */
6127 error (_("Missing arg to -U/--unicode")); /* Can this happen ? */
6128 else if (streq (optarg
, "default") || streq (optarg
, "d"))
6129 unicode_display
= unicode_default
;
6130 else if (streq (optarg
, "locale") || streq (optarg
, "l"))
6131 unicode_display
= unicode_locale
;
6132 else if (streq (optarg
, "escape") || streq (optarg
, "e"))
6133 unicode_display
= unicode_escape
;
6134 else if (streq (optarg
, "invalid") || streq (optarg
, "i"))
6135 unicode_display
= unicode_invalid
;
6136 else if (streq (optarg
, "hex") || streq (optarg
, "x"))
6137 unicode_display
= unicode_hex
;
6138 else if (streq (optarg
, "highlight") || streq (optarg
, "h"))
6139 unicode_display
= unicode_highlight
;
6141 error (_("invalid argument to -U/--unicode: %s"), optarg
);
6144 case OPTION_SYM_BASE
:
6148 sym_base
= strtoul (optarg
, NULL
, 0);
6165 /* xgettext:c-format */
6166 error (_("Invalid option '-%c'\n"), c
);
6173 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
6174 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
6175 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
6176 && !do_section_groups
&& !do_archive_index
6177 && !do_dyn_syms
&& !do_lto_syms
)
6182 do_dynamic
= do_syms
= do_reloc
= do_unwind
= do_sections
= true;
6183 do_segments
= do_header
= do_dump
= do_version
= true;
6184 do_histogram
= do_debugging
= do_arch
= do_notes
= true;
6185 do_section_groups
= do_archive_index
= do_dyn_syms
= true;
6194 get_elf_class (unsigned int elf_class
)
6196 static char buff
[32];
6200 case ELFCLASSNONE
: return _("none");
6201 case ELFCLASS32
: return "ELF32";
6202 case ELFCLASS64
: return "ELF64";
6204 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
6210 get_data_encoding (unsigned int encoding
)
6212 static char buff
[32];
6216 case ELFDATANONE
: return _("none");
6217 case ELFDATA2LSB
: return _("2's complement, little endian");
6218 case ELFDATA2MSB
: return _("2's complement, big endian");
6220 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
6226 check_magic_number (Filedata
* filedata
, Elf_Internal_Ehdr
* header
)
6228 if (header
->e_ident
[EI_MAG0
] == ELFMAG0
6229 && header
->e_ident
[EI_MAG1
] == ELFMAG1
6230 && header
->e_ident
[EI_MAG2
] == ELFMAG2
6231 && header
->e_ident
[EI_MAG3
] == ELFMAG3
)
6234 /* Some compilers produce object files that are not in the ELF file format.
6235 As an aid to users of readelf, try to identify these cases and suggest
6238 FIXME: It is not clear if all four bytes are used as constant magic
6239 valus by all compilers. It may be necessary to recode this function if
6240 different tools use different length sequences. */
6244 unsigned char magic
[4];
6245 const char * obj_message
;
6246 const char * ar_message
;
6250 { { 'B', 'C', 0xc0, 0xde },
6251 N_("This is a LLVM bitcode file - try using llvm-bcanalyzer\n"),
6252 N_("This is a LLVM bitcode file - try extracting and then using llvm-bcanalyzer\n")
6254 { { 'g', 'o', ' ', 'o' },
6255 N_("This is a GO binary file - try using 'go tool objdump' or 'go tool nm'\n"),
6261 for (i
= ARRAY_SIZE (known_magic
); i
--;)
6263 if (header
->e_ident
[EI_MAG0
] == known_magic
[i
].magic
[0]
6264 && header
->e_ident
[EI_MAG1
] == known_magic
[i
].magic
[1]
6265 && header
->e_ident
[EI_MAG2
] == known_magic
[i
].magic
[2]
6266 && header
->e_ident
[EI_MAG3
] == known_magic
[i
].magic
[3])
6268 /* Some compiler's analyzer tools do not handle archives,
6269 so we provide two different kinds of error message. */
6270 if (filedata
->archive_file_size
> 0
6271 && known_magic
[i
].ar_message
!= NULL
)
6272 error ("%s", known_magic
[i
].ar_message
);
6274 error ("%s", known_magic
[i
].obj_message
);
6279 error (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
6283 /* Decode the data held in 'filedata->file_header'. */
6286 process_file_header (Filedata
* filedata
)
6288 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
6290 if (! check_magic_number (filedata
, header
))
6293 if (! filedata
->is_separate
)
6294 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
6300 if (filedata
->is_separate
)
6301 printf (_("ELF Header in linked file '%s':\n"), filedata
->file_name
);
6303 printf (_("ELF Header:\n"));
6304 printf (_(" Magic: "));
6305 for (i
= 0; i
< EI_NIDENT
; i
++)
6306 printf ("%2.2x ", header
->e_ident
[i
]);
6308 printf (_(" Class: %s\n"),
6309 get_elf_class (header
->e_ident
[EI_CLASS
]));
6310 printf (_(" Data: %s\n"),
6311 get_data_encoding (header
->e_ident
[EI_DATA
]));
6312 printf (_(" Version: %d%s\n"),
6313 header
->e_ident
[EI_VERSION
],
6314 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
6316 : (header
->e_ident
[EI_VERSION
] != EV_NONE
6319 printf (_(" OS/ABI: %s\n"),
6320 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
6321 printf (_(" ABI Version: %d\n"),
6322 header
->e_ident
[EI_ABIVERSION
]);
6323 printf (_(" Type: %s\n"),
6324 get_file_type (filedata
));
6325 printf (_(" Machine: %s\n"),
6326 get_machine_name (header
->e_machine
));
6327 printf (_(" Version: 0x%lx\n"),
6330 printf (_(" Entry point address: "));
6331 print_vma (header
->e_entry
, PREFIX_HEX
);
6332 printf (_("\n Start of program headers: "));
6333 print_vma (header
->e_phoff
, DEC
);
6334 printf (_(" (bytes into file)\n Start of section headers: "));
6335 print_vma (header
->e_shoff
, DEC
);
6336 printf (_(" (bytes into file)\n"));
6338 printf (_(" Flags: 0x%lx%s\n"),
6340 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
6341 printf (_(" Size of this header: %u (bytes)\n"),
6343 printf (_(" Size of program headers: %u (bytes)\n"),
6344 header
->e_phentsize
);
6345 printf (_(" Number of program headers: %u"),
6347 if (filedata
->section_headers
!= NULL
6348 && header
->e_phnum
== PN_XNUM
6349 && filedata
->section_headers
[0].sh_info
!= 0)
6350 printf (" (%u)", filedata
->section_headers
[0].sh_info
);
6351 putc ('\n', stdout
);
6352 printf (_(" Size of section headers: %u (bytes)\n"),
6353 header
->e_shentsize
);
6354 printf (_(" Number of section headers: %u"),
6356 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
6358 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
6359 printf (" (%u)", header
->e_shnum
);
6361 putc ('\n', stdout
);
6362 printf (_(" Section header string table index: %u"),
6363 header
->e_shstrndx
);
6364 if (filedata
->section_headers
!= NULL
6365 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
6367 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
6368 printf (" (%u)", header
->e_shstrndx
);
6370 if (header
->e_shstrndx
!= SHN_UNDEF
6371 && header
->e_shstrndx
>= header
->e_shnum
)
6373 header
->e_shstrndx
= SHN_UNDEF
;
6374 printf (_(" <corrupt: out of range>"));
6376 putc ('\n', stdout
);
6379 if (filedata
->section_headers
!= NULL
)
6381 if (header
->e_phnum
== PN_XNUM
6382 && filedata
->section_headers
[0].sh_info
!= 0)
6384 /* Throw away any cached read of PN_XNUM headers. */
6385 free (filedata
->program_headers
);
6386 filedata
->program_headers
= NULL
;
6387 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
6389 if (header
->e_shnum
== SHN_UNDEF
)
6390 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
6391 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
6392 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
6393 if (header
->e_shstrndx
>= header
->e_shnum
)
6394 header
->e_shstrndx
= SHN_UNDEF
;
6400 /* Read in the program headers from FILEDATA and store them in PHEADERS.
6401 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
6404 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
6406 Elf32_External_Phdr
* phdrs
;
6407 Elf32_External_Phdr
* external
;
6408 Elf_Internal_Phdr
* internal
;
6410 unsigned int size
= filedata
->file_header
.e_phentsize
;
6411 unsigned int num
= filedata
->file_header
.e_phnum
;
6413 /* PR binutils/17531: Cope with unexpected section header sizes. */
6414 if (size
== 0 || num
== 0)
6416 if (size
< sizeof * phdrs
)
6418 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
6421 if (size
> sizeof * phdrs
)
6422 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
6424 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
6425 size
, num
, _("program headers"));
6429 for (i
= 0, internal
= pheaders
, external
= phdrs
;
6430 i
< filedata
->file_header
.e_phnum
;
6431 i
++, internal
++, external
++)
6433 internal
->p_type
= BYTE_GET (external
->p_type
);
6434 internal
->p_offset
= BYTE_GET (external
->p_offset
);
6435 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
6436 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
6437 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
6438 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
6439 internal
->p_flags
= BYTE_GET (external
->p_flags
);
6440 internal
->p_align
= BYTE_GET (external
->p_align
);
6447 /* Read in the program headers from FILEDATA and store them in PHEADERS.
6448 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
6451 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
6453 Elf64_External_Phdr
* phdrs
;
6454 Elf64_External_Phdr
* external
;
6455 Elf_Internal_Phdr
* internal
;
6457 unsigned int size
= filedata
->file_header
.e_phentsize
;
6458 unsigned int num
= filedata
->file_header
.e_phnum
;
6460 /* PR binutils/17531: Cope with unexpected section header sizes. */
6461 if (size
== 0 || num
== 0)
6463 if (size
< sizeof * phdrs
)
6465 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
6468 if (size
> sizeof * phdrs
)
6469 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
6471 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
6472 size
, num
, _("program headers"));
6476 for (i
= 0, internal
= pheaders
, external
= phdrs
;
6477 i
< filedata
->file_header
.e_phnum
;
6478 i
++, internal
++, external
++)
6480 internal
->p_type
= BYTE_GET (external
->p_type
);
6481 internal
->p_flags
= BYTE_GET (external
->p_flags
);
6482 internal
->p_offset
= BYTE_GET (external
->p_offset
);
6483 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
6484 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
6485 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
6486 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
6487 internal
->p_align
= BYTE_GET (external
->p_align
);
6494 /* Returns TRUE if the program headers were read into `program_headers'. */
6497 get_program_headers (Filedata
* filedata
)
6499 Elf_Internal_Phdr
* phdrs
;
6501 /* Check cache of prior read. */
6502 if (filedata
->program_headers
!= NULL
)
6505 /* Be kind to memory checkers by looking for
6506 e_phnum values which we know must be invalid. */
6507 if (filedata
->file_header
.e_phnum
6508 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
6509 >= filedata
->file_size
)
6511 error (_("Too many program headers - %#x - the file is not that big\n"),
6512 filedata
->file_header
.e_phnum
);
6516 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
6517 sizeof (Elf_Internal_Phdr
));
6520 error (_("Out of memory reading %u program headers\n"),
6521 filedata
->file_header
.e_phnum
);
6526 ? get_32bit_program_headers (filedata
, phdrs
)
6527 : get_64bit_program_headers (filedata
, phdrs
))
6529 filedata
->program_headers
= phdrs
;
6537 /* Print program header info and locate dynamic section. */
6540 process_program_headers (Filedata
* filedata
)
6542 Elf_Internal_Phdr
* segment
;
6544 Elf_Internal_Phdr
* previous_load
= NULL
;
6546 if (filedata
->file_header
.e_phnum
== 0)
6548 /* PR binutils/12467. */
6549 if (filedata
->file_header
.e_phoff
!= 0)
6550 warn (_("possibly corrupt ELF header - it has a non-zero program"
6551 " header offset, but no program headers\n"));
6552 else if (do_segments
)
6554 if (filedata
->is_separate
)
6555 printf (_("\nThere are no program headers in linked file '%s'.\n"),
6556 filedata
->file_name
);
6558 printf (_("\nThere are no program headers in this file.\n"));
6563 if (do_segments
&& !do_header
)
6565 if (filedata
->is_separate
)
6566 printf ("\nIn linked file '%s' the ELF file type is %s\n",
6567 filedata
->file_name
, get_file_type (filedata
));
6569 printf (_("\nElf file type is %s\n"), get_file_type (filedata
));
6570 printf (_("Entry point 0x%" PRIx64
"\n"),
6571 filedata
->file_header
.e_entry
);
6572 printf (ngettext ("There is %d program header,"
6573 " starting at offset %" PRIu64
"\n",
6574 "There are %d program headers,"
6575 " starting at offset %" PRIu64
"\n",
6576 filedata
->file_header
.e_phnum
),
6577 filedata
->file_header
.e_phnum
,
6578 filedata
->file_header
.e_phoff
);
6581 if (! get_program_headers (filedata
))
6586 if (filedata
->file_header
.e_phnum
> 1)
6587 printf (_("\nProgram Headers:\n"));
6589 printf (_("\nProgram Headers:\n"));
6593 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
6596 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
6600 (_(" Type Offset VirtAddr PhysAddr\n"));
6602 (_(" FileSiz MemSiz Flags Align\n"));
6606 uint64_t dynamic_addr
= 0;
6607 uint64_t dynamic_size
= 0;
6608 for (i
= 0, segment
= filedata
->program_headers
;
6609 i
< filedata
->file_header
.e_phnum
;
6614 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
6618 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
6619 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
6620 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
6621 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
6622 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
6624 (segment
->p_flags
& PF_R
? 'R' : ' '),
6625 (segment
->p_flags
& PF_W
? 'W' : ' '),
6626 (segment
->p_flags
& PF_X
? 'E' : ' '));
6627 printf ("%#lx", (unsigned long) segment
->p_align
);
6631 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
6632 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
6635 print_vma (segment
->p_offset
, FULL_HEX
);
6639 print_vma (segment
->p_vaddr
, FULL_HEX
);
6641 print_vma (segment
->p_paddr
, FULL_HEX
);
6644 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
6645 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
6648 print_vma (segment
->p_filesz
, FULL_HEX
);
6652 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
6653 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
6656 print_vma (segment
->p_memsz
, FULL_HEX
);
6660 (segment
->p_flags
& PF_R
? 'R' : ' '),
6661 (segment
->p_flags
& PF_W
? 'W' : ' '),
6662 (segment
->p_flags
& PF_X
? 'E' : ' '));
6664 if ((unsigned long) segment
->p_align
== segment
->p_align
)
6665 printf ("%#lx", (unsigned long) segment
->p_align
);
6668 print_vma (segment
->p_align
, PREFIX_HEX
);
6673 print_vma (segment
->p_offset
, FULL_HEX
);
6675 print_vma (segment
->p_vaddr
, FULL_HEX
);
6677 print_vma (segment
->p_paddr
, FULL_HEX
);
6679 print_vma (segment
->p_filesz
, FULL_HEX
);
6681 print_vma (segment
->p_memsz
, FULL_HEX
);
6683 (segment
->p_flags
& PF_R
? 'R' : ' '),
6684 (segment
->p_flags
& PF_W
? 'W' : ' '),
6685 (segment
->p_flags
& PF_X
? 'E' : ' '));
6686 print_vma (segment
->p_align
, PREFIX_HEX
);
6689 putc ('\n', stdout
);
6692 switch (segment
->p_type
)
6695 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
6696 required by the ELF standard, several programs, including the Linux
6697 kernel, make use of non-ordered segments. */
6699 && previous_load
->p_vaddr
> segment
->p_vaddr
)
6700 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
6702 if (segment
->p_memsz
< segment
->p_filesz
)
6703 error (_("the segment's file size is larger than its memory size\n"));
6704 previous_load
= segment
;
6708 /* PR 20815 - Verify that the program header is loaded into memory. */
6709 if (i
> 0 && previous_load
!= NULL
)
6710 error (_("the PHDR segment must occur before any LOAD segment\n"));
6711 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
6715 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
6717 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
6718 if (load
->p_type
== PT_LOAD
6719 && load
->p_offset
<= segment
->p_offset
6720 && (load
->p_offset
+ load
->p_filesz
6721 >= segment
->p_offset
+ segment
->p_filesz
)
6722 && load
->p_vaddr
<= segment
->p_vaddr
6723 && (load
->p_vaddr
+ load
->p_filesz
6724 >= segment
->p_vaddr
+ segment
->p_filesz
))
6727 if (j
== filedata
->file_header
.e_phnum
)
6728 error (_("the PHDR segment is not covered by a LOAD segment\n"));
6734 error (_("more than one dynamic segment\n"));
6736 /* By default, assume that the .dynamic section is the first
6737 section in the DYNAMIC segment. */
6738 dynamic_addr
= segment
->p_offset
;
6739 dynamic_size
= segment
->p_filesz
;
6741 /* Try to locate the .dynamic section. If there is
6742 a section header table, we can easily locate it. */
6743 if (filedata
->section_headers
!= NULL
)
6745 Elf_Internal_Shdr
* sec
;
6747 sec
= find_section (filedata
, ".dynamic");
6748 if (sec
== NULL
|| sec
->sh_size
== 0)
6750 /* A corresponding .dynamic section is expected, but on
6751 IA-64/OpenVMS it is OK for it to be missing. */
6752 if (!is_ia64_vms (filedata
))
6753 error (_("no .dynamic section in the dynamic segment\n"));
6757 if (sec
->sh_type
== SHT_NOBITS
)
6764 dynamic_addr
= sec
->sh_offset
;
6765 dynamic_size
= sec
->sh_size
;
6767 /* The PT_DYNAMIC segment, which is used by the run-time
6768 loader, should exactly match the .dynamic section. */
6770 && (dynamic_addr
!= segment
->p_offset
6771 || dynamic_size
!= segment
->p_filesz
))
6773 the .dynamic section is not the same as the dynamic segment\n"));
6776 /* PR binutils/17512: Avoid corrupt dynamic section info in the
6777 segment. Check this after matching against the section headers
6778 so we don't warn on debuginfo file (which have NOBITS .dynamic
6780 if (dynamic_addr
> filedata
->file_size
6781 || (dynamic_size
> filedata
->file_size
- dynamic_addr
))
6783 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
6790 if (segment
->p_offset
>= filedata
->file_size
6791 || segment
->p_filesz
> filedata
->file_size
- segment
->p_offset
6792 || segment
->p_filesz
- 1 >= (size_t) -2
6793 || fseek64 (filedata
->handle
,
6794 filedata
->archive_file_offset
+ segment
->p_offset
,
6796 error (_("Unable to find program interpreter name\n"));
6799 size_t len
= segment
->p_filesz
;
6800 free (filedata
->program_interpreter
);
6801 filedata
->program_interpreter
= xmalloc (len
+ 1);
6802 len
= fread (filedata
->program_interpreter
, 1, len
,
6804 filedata
->program_interpreter
[len
] = 0;
6807 printf (_(" [Requesting program interpreter: %s]\n"),
6808 filedata
->program_interpreter
);
6815 && filedata
->section_headers
!= NULL
6816 && filedata
->string_table
!= NULL
)
6818 printf (_("\n Section to Segment mapping:\n"));
6819 printf (_(" Segment Sections...\n"));
6821 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
6824 Elf_Internal_Shdr
* section
;
6826 segment
= filedata
->program_headers
+ i
;
6827 section
= filedata
->section_headers
+ 1;
6829 printf (" %2.2d ", i
);
6831 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
6833 if (!ELF_TBSS_SPECIAL (section
, segment
)
6834 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
6835 printf ("%s ", printable_section_name (filedata
, section
));
6842 filedata
->dynamic_addr
= dynamic_addr
;
6843 filedata
->dynamic_size
= dynamic_size
? dynamic_size
: 1;
6847 filedata
->dynamic_addr
= 0;
6848 filedata
->dynamic_size
= 1;
6852 /* Find the file offset corresponding to VMA by using the program headers. */
6855 offset_from_vma (Filedata
* filedata
, uint64_t vma
, uint64_t size
)
6857 Elf_Internal_Phdr
* seg
;
6859 if (! get_program_headers (filedata
))
6861 warn (_("Cannot interpret virtual addresses without program headers.\n"));
6865 for (seg
= filedata
->program_headers
;
6866 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
6869 if (seg
->p_type
!= PT_LOAD
)
6872 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
6873 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
6874 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
6877 warn (_("Virtual address %#" PRIx64
6878 " not located in any PT_LOAD segment.\n"), vma
);
6883 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
6884 If PROBE is true, this is just a probe and we do not generate any error
6885 messages if the load fails. */
6888 get_32bit_section_headers (Filedata
* filedata
, bool probe
)
6890 Elf32_External_Shdr
* shdrs
;
6891 Elf_Internal_Shdr
* internal
;
6893 unsigned int size
= filedata
->file_header
.e_shentsize
;
6894 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
6896 /* PR binutils/17531: Cope with unexpected section header sizes. */
6897 if (size
== 0 || num
== 0)
6900 /* The section header cannot be at the start of the file - that is
6901 where the ELF file header is located. A file with absolutely no
6902 sections in it will use a shoff of 0. */
6903 if (filedata
->file_header
.e_shoff
== 0)
6906 if (size
< sizeof * shdrs
)
6909 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
6912 if (!probe
&& size
> sizeof * shdrs
)
6913 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
6915 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
6917 probe
? NULL
: _("section headers"));
6921 filedata
->section_headers
= (Elf_Internal_Shdr
*)
6922 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
6923 if (filedata
->section_headers
== NULL
)
6926 error (_("Out of memory reading %u section headers\n"), num
);
6931 for (i
= 0, internal
= filedata
->section_headers
;
6935 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
6936 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
6937 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
6938 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
6939 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
6940 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
6941 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
6942 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
6943 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
6944 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
6945 if (!probe
&& internal
->sh_link
> num
)
6946 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
6947 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
6948 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
6955 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
6958 get_64bit_section_headers (Filedata
* filedata
, bool probe
)
6960 Elf64_External_Shdr
* shdrs
;
6961 Elf_Internal_Shdr
* internal
;
6963 unsigned int size
= filedata
->file_header
.e_shentsize
;
6964 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
6966 /* PR binutils/17531: Cope with unexpected section header sizes. */
6967 if (size
== 0 || num
== 0)
6970 /* The section header cannot be at the start of the file - that is
6971 where the ELF file header is located. A file with absolutely no
6972 sections in it will use a shoff of 0. */
6973 if (filedata
->file_header
.e_shoff
== 0)
6976 if (size
< sizeof * shdrs
)
6979 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
6983 if (! probe
&& size
> sizeof * shdrs
)
6984 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
6986 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
6987 filedata
->file_header
.e_shoff
,
6989 probe
? NULL
: _("section headers"));
6993 filedata
->section_headers
= (Elf_Internal_Shdr
*)
6994 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
6995 if (filedata
->section_headers
== NULL
)
6998 error (_("Out of memory reading %u section headers\n"), num
);
7003 for (i
= 0, internal
= filedata
->section_headers
;
7007 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
7008 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
7009 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
7010 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
7011 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
7012 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
7013 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
7014 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
7015 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
7016 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
7017 if (!probe
&& internal
->sh_link
> num
)
7018 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
7019 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
7020 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
7028 get_section_headers (Filedata
*filedata
, bool probe
)
7030 if (filedata
->section_headers
!= NULL
)
7034 return get_32bit_section_headers (filedata
, probe
);
7036 return get_64bit_section_headers (filedata
, probe
);
7039 static Elf_Internal_Sym
*
7040 get_32bit_elf_symbols (Filedata
*filedata
,
7041 Elf_Internal_Shdr
*section
,
7042 uint64_t *num_syms_return
)
7044 uint64_t number
= 0;
7045 Elf32_External_Sym
* esyms
= NULL
;
7046 Elf_External_Sym_Shndx
* shndx
= NULL
;
7047 Elf_Internal_Sym
* isyms
= NULL
;
7048 Elf_Internal_Sym
* psym
;
7050 elf_section_list
* entry
;
7052 if (section
->sh_size
== 0)
7054 if (num_syms_return
!= NULL
)
7055 * num_syms_return
= 0;
7059 /* Run some sanity checks first. */
7060 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
7062 error (_("Section %s has an invalid sh_entsize of %#" PRIx64
"\n"),
7063 printable_section_name (filedata
, section
),
7064 section
->sh_entsize
);
7068 if (section
->sh_size
> filedata
->file_size
)
7070 error (_("Section %s has an invalid sh_size of %#" PRIx64
"\n"),
7071 printable_section_name (filedata
, section
),
7076 number
= section
->sh_size
/ section
->sh_entsize
;
7078 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
7080 error (_("Size (%#" PRIx64
") of section %s "
7081 "is not a multiple of its sh_entsize (%#" PRIx64
")\n"),
7083 printable_section_name (filedata
, section
),
7084 section
->sh_entsize
);
7088 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
7089 section
->sh_size
, _("symbols"));
7094 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
7096 if (entry
->hdr
->sh_link
!= (size_t) (section
- filedata
->section_headers
))
7101 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
7105 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
7106 entry
->hdr
->sh_offset
,
7107 1, entry
->hdr
->sh_size
,
7108 _("symbol table section indices"));
7112 /* PR17531: file: heap-buffer-overflow */
7113 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
7115 error (_("Index section %s has an sh_size of %#" PRIx64
" - expected %#" PRIx64
"\n"),
7116 printable_section_name (filedata
, entry
->hdr
),
7117 entry
->hdr
->sh_size
,
7123 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
7127 error (_("Out of memory reading %" PRIu64
" symbols\n"), number
);
7131 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
7133 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
7134 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
7135 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
7136 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
7137 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
7139 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
7140 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
7141 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
7142 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
7143 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
7150 if (num_syms_return
!= NULL
)
7151 * num_syms_return
= isyms
== NULL
? 0 : number
;
7156 static Elf_Internal_Sym
*
7157 get_64bit_elf_symbols (Filedata
*filedata
,
7158 Elf_Internal_Shdr
*section
,
7159 uint64_t *num_syms_return
)
7161 uint64_t number
= 0;
7162 Elf64_External_Sym
* esyms
= NULL
;
7163 Elf_External_Sym_Shndx
* shndx
= NULL
;
7164 Elf_Internal_Sym
* isyms
= NULL
;
7165 Elf_Internal_Sym
* psym
;
7167 elf_section_list
* entry
;
7169 if (section
->sh_size
== 0)
7171 if (num_syms_return
!= NULL
)
7172 * num_syms_return
= 0;
7176 /* Run some sanity checks first. */
7177 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
7179 error (_("Section %s has an invalid sh_entsize of %#" PRIx64
"\n"),
7180 printable_section_name (filedata
, section
),
7181 section
->sh_entsize
);
7185 if (section
->sh_size
> filedata
->file_size
)
7187 error (_("Section %s has an invalid sh_size of %#" PRIx64
"\n"),
7188 printable_section_name (filedata
, section
),
7193 number
= section
->sh_size
/ section
->sh_entsize
;
7195 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
7197 error (_("Size (%#" PRIx64
") of section %s "
7198 "is not a multiple of its sh_entsize (%#" PRIx64
")\n"),
7200 printable_section_name (filedata
, section
),
7201 section
->sh_entsize
);
7205 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
7206 section
->sh_size
, _("symbols"));
7211 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
7213 if (entry
->hdr
->sh_link
!= (size_t) (section
- filedata
->section_headers
))
7218 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
7222 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
7223 entry
->hdr
->sh_offset
,
7224 1, entry
->hdr
->sh_size
,
7225 _("symbol table section indices"));
7229 /* PR17531: file: heap-buffer-overflow */
7230 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
7232 error (_("Index section %s has an sh_size of %#" PRIx64
" - expected %#" PRIx64
"\n"),
7233 printable_section_name (filedata
, entry
->hdr
),
7234 entry
->hdr
->sh_size
,
7240 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
7244 error (_("Out of memory reading %" PRIu64
" symbols\n"), number
);
7248 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
7250 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
7251 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
7252 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
7253 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
7255 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
7257 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
7258 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
7259 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
7261 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
7262 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
7269 if (num_syms_return
!= NULL
)
7270 * num_syms_return
= isyms
== NULL
? 0 : number
;
7275 static Elf_Internal_Sym
*
7276 get_elf_symbols (Filedata
*filedata
,
7277 Elf_Internal_Shdr
*section
,
7278 uint64_t *num_syms_return
)
7281 return get_32bit_elf_symbols (filedata
, section
, num_syms_return
);
7283 return get_64bit_elf_symbols (filedata
, section
, num_syms_return
);
7287 get_elf_section_flags (Filedata
* filedata
, uint64_t sh_flags
)
7289 static char buff
[1024];
7291 unsigned int field_size
= is_32bit_elf
? 8 : 16;
7293 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
7294 uint64_t os_flags
= 0;
7295 uint64_t proc_flags
= 0;
7296 uint64_t unknown_flags
= 0;
7304 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
7305 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
7306 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
7307 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
7308 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
7309 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
7310 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
7311 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
7312 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
7313 /* 9 */ { STRING_COMMA_LEN ("TLS") },
7314 /* IA-64 specific. */
7315 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
7316 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
7317 /* IA-64 OpenVMS specific. */
7318 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
7319 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
7320 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
7321 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
7322 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
7323 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
7325 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
7326 /* SPARC specific. */
7327 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
7328 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
7330 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
7331 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
7332 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
7334 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
7336 /* 25 */ { STRING_COMMA_LEN ("VLE") },
7338 /* 26 */ { STRING_COMMA_LEN ("GNU_RETAIN") },
7341 if (do_section_details
)
7342 p
+= sprintf (p
, "[%*.*lx]: ",
7343 field_size
, field_size
, (unsigned long) sh_flags
);
7349 flag
= sh_flags
& - sh_flags
;
7352 if (do_section_details
)
7356 case SHF_WRITE
: sindex
= 0; break;
7357 case SHF_ALLOC
: sindex
= 1; break;
7358 case SHF_EXECINSTR
: sindex
= 2; break;
7359 case SHF_MERGE
: sindex
= 3; break;
7360 case SHF_STRINGS
: sindex
= 4; break;
7361 case SHF_INFO_LINK
: sindex
= 5; break;
7362 case SHF_LINK_ORDER
: sindex
= 6; break;
7363 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
7364 case SHF_GROUP
: sindex
= 8; break;
7365 case SHF_TLS
: sindex
= 9; break;
7366 case SHF_EXCLUDE
: sindex
= 18; break;
7367 case SHF_COMPRESSED
: sindex
= 20; break;
7371 switch (filedata
->file_header
.e_machine
)
7374 if (flag
== SHF_IA_64_SHORT
)
7376 else if (flag
== SHF_IA_64_NORECOV
)
7378 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
7381 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
7382 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
7383 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
7384 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
7385 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
7386 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
7396 case EM_OLD_SPARCV9
:
7397 case EM_SPARC32PLUS
:
7400 if (flag
== SHF_ORDERED
)
7407 case SHF_ENTRYSECT
: sindex
= 21; break;
7408 case SHF_ARM_PURECODE
: sindex
= 22; break;
7409 case SHF_COMDEF
: sindex
= 23; break;
7414 if (flag
== SHF_PPC_VLE
)
7421 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
7424 case ELFOSABI_FREEBSD
:
7425 if (flag
== SHF_GNU_RETAIN
)
7429 if (flag
== SHF_GNU_MBIND
)
7430 /* We should not recognize SHF_GNU_MBIND for
7431 ELFOSABI_NONE, but binutils as of 2019-07-23 did
7432 not set the EI_OSABI header byte. */
7443 if (p
!= buff
+ field_size
+ 4)
7445 if (size
< (10 + 2))
7447 warn (_("Internal error: not enough buffer room for section flag info"));
7448 return _("<unknown>");
7455 size
-= flags
[sindex
].len
;
7456 p
= stpcpy (p
, flags
[sindex
].str
);
7458 else if (flag
& SHF_MASKOS
)
7460 else if (flag
& SHF_MASKPROC
)
7463 unknown_flags
|= flag
;
7469 case SHF_WRITE
: *p
= 'W'; break;
7470 case SHF_ALLOC
: *p
= 'A'; break;
7471 case SHF_EXECINSTR
: *p
= 'X'; break;
7472 case SHF_MERGE
: *p
= 'M'; break;
7473 case SHF_STRINGS
: *p
= 'S'; break;
7474 case SHF_INFO_LINK
: *p
= 'I'; break;
7475 case SHF_LINK_ORDER
: *p
= 'L'; break;
7476 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
7477 case SHF_GROUP
: *p
= 'G'; break;
7478 case SHF_TLS
: *p
= 'T'; break;
7479 case SHF_EXCLUDE
: *p
= 'E'; break;
7480 case SHF_COMPRESSED
: *p
= 'C'; break;
7483 if ((filedata
->file_header
.e_machine
== EM_X86_64
7484 || filedata
->file_header
.e_machine
== EM_L1OM
7485 || filedata
->file_header
.e_machine
== EM_K1OM
)
7486 && flag
== SHF_X86_64_LARGE
)
7488 else if (filedata
->file_header
.e_machine
== EM_ARM
7489 && flag
== SHF_ARM_PURECODE
)
7491 else if (filedata
->file_header
.e_machine
== EM_PPC
7492 && flag
== SHF_PPC_VLE
)
7494 else if (flag
& SHF_MASKOS
)
7496 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
7499 case ELFOSABI_FREEBSD
:
7500 if (flag
== SHF_GNU_RETAIN
)
7507 if (flag
== SHF_GNU_MBIND
)
7509 /* We should not recognize SHF_GNU_MBIND for
7510 ELFOSABI_NONE, but binutils as of 2019-07-23 did
7511 not set the EI_OSABI header byte. */
7518 sh_flags
&= ~SHF_MASKOS
;
7522 else if (flag
& SHF_MASKPROC
)
7525 sh_flags
&= ~ SHF_MASKPROC
;
7535 if (do_section_details
)
7539 if (p
!= buff
+ field_size
+ 4)
7541 if (size
< 2 + 5 + field_size
+ 1)
7543 warn (_("Internal error: not enough buffer room for section flag info"));
7544 return _("<unknown>");
7550 size
-= 5 + field_size
;
7551 p
+= sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
7552 (unsigned long) os_flags
);
7556 if (p
!= buff
+ field_size
+ 4)
7558 if (size
< 2 + 7 + field_size
+ 1)
7560 warn (_("Internal error: not enough buffer room for section flag info"));
7561 return _("<unknown>");
7567 size
-= 7 + field_size
;
7568 p
+= sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
7569 (unsigned long) proc_flags
);
7573 if (p
!= buff
+ field_size
+ 4)
7575 if (size
< 2 + 10 + field_size
+ 1)
7577 warn (_("Internal error: not enough buffer room for section flag info"));
7578 return _("<unknown>");
7584 size
-= 10 + field_size
;
7585 p
+= sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
7586 (unsigned long) unknown_flags
);
7594 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
7595 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
,
7600 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
7602 if (size
< sizeof (* echdr
))
7604 error (_("Compressed section is too small even for a compression header\n"));
7608 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
7609 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
7610 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
7611 return sizeof (*echdr
);
7615 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
7617 if (size
< sizeof (* echdr
))
7619 error (_("Compressed section is too small even for a compression header\n"));
7623 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
7624 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
7625 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
7626 return sizeof (*echdr
);
7631 process_section_headers (Filedata
* filedata
)
7633 Elf_Internal_Shdr
* section
;
7636 if (filedata
->file_header
.e_shnum
== 0)
7638 /* PR binutils/12467. */
7639 if (filedata
->file_header
.e_shoff
!= 0)
7641 warn (_("possibly corrupt ELF file header - it has a non-zero"
7642 " section header offset, but no section headers\n"));
7645 else if (do_sections
)
7646 printf (_("\nThere are no sections in this file.\n"));
7651 if (do_sections
&& !do_header
)
7653 if (filedata
->is_separate
&& process_links
)
7654 printf (_("In linked file '%s': "), filedata
->file_name
);
7655 if (! filedata
->is_separate
|| process_links
)
7656 printf (ngettext ("There is %d section header, "
7657 "starting at offset %#" PRIx64
":\n",
7658 "There are %d section headers, "
7659 "starting at offset %#" PRIx64
":\n",
7660 filedata
->file_header
.e_shnum
),
7661 filedata
->file_header
.e_shnum
,
7662 filedata
->file_header
.e_shoff
);
7665 if (!get_section_headers (filedata
, false))
7668 /* Read in the string table, so that we have names to display. */
7669 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
7670 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
7672 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
7674 if (section
->sh_size
!= 0)
7676 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
7677 1, section
->sh_size
,
7680 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
7684 /* Scan the sections for the dynamic symbol table
7685 and dynamic string table and debug sections. */
7686 eh_addr_size
= is_32bit_elf
? 4 : 8;
7687 switch (filedata
->file_header
.e_machine
)
7690 case EM_MIPS_RS3_LE
:
7691 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
7692 FDE addresses. However, the ABI also has a semi-official ILP32
7693 variant for which the normal FDE address size rules apply.
7695 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
7696 section, where XX is the size of longs in bits. Unfortunately,
7697 earlier compilers provided no way of distinguishing ILP32 objects
7698 from LP64 objects, so if there's any doubt, we should assume that
7699 the official LP64 form is being used. */
7700 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
7701 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
7707 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
7709 case E_H8_MACH_H8300
:
7710 case E_H8_MACH_H8300HN
:
7711 case E_H8_MACH_H8300SN
:
7712 case E_H8_MACH_H8300SXN
:
7715 case E_H8_MACH_H8300H
:
7716 case E_H8_MACH_H8300S
:
7717 case E_H8_MACH_H8300SX
:
7725 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
7727 case EF_M32C_CPU_M16C
:
7734 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
7737 uint64_t expected_entsize = is_32bit_elf ? size32 : size64; \
7738 if (section->sh_entsize != expected_entsize) \
7740 error (_("Section %d has invalid sh_entsize of %" PRIx64 "\n"), \
7741 i, section->sh_entsize); \
7742 error (_("(Using the expected size of %" PRIx64 " for the rest of this dump)\n"), \
7743 expected_entsize); \
7744 section->sh_entsize = expected_entsize; \
7749 #define CHECK_ENTSIZE(section, i, type) \
7750 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
7751 sizeof (Elf64_External_##type))
7753 for (i
= 0, section
= filedata
->section_headers
;
7754 i
< filedata
->file_header
.e_shnum
;
7757 const char *name
= printable_section_name (filedata
, section
);
7759 /* Run some sanity checks on the headers and
7760 possibly fill in some file data as well. */
7761 switch (section
->sh_type
)
7764 if (filedata
->dynamic_symbols
!= NULL
)
7766 error (_("File contains multiple dynamic symbol tables\n"));
7770 CHECK_ENTSIZE (section
, i
, Sym
);
7771 filedata
->dynamic_symbols
7772 = get_elf_symbols (filedata
, section
, &filedata
->num_dynamic_syms
);
7773 filedata
->dynamic_symtab_section
= section
;
7777 if (streq (name
, ".dynstr"))
7779 if (filedata
->dynamic_strings
!= NULL
)
7781 error (_("File contains multiple dynamic string tables\n"));
7785 filedata
->dynamic_strings
7786 = (char *) get_data (NULL
, filedata
, section
->sh_offset
,
7787 1, section
->sh_size
, _("dynamic strings"));
7788 filedata
->dynamic_strings_length
7789 = filedata
->dynamic_strings
== NULL
? 0 : section
->sh_size
;
7790 filedata
->dynamic_strtab_section
= section
;
7794 case SHT_SYMTAB_SHNDX
:
7796 elf_section_list
* entry
= xmalloc (sizeof * entry
);
7798 entry
->hdr
= section
;
7799 entry
->next
= filedata
->symtab_shndx_list
;
7800 filedata
->symtab_shndx_list
= entry
;
7805 CHECK_ENTSIZE (section
, i
, Sym
);
7809 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
7813 CHECK_ENTSIZE (section
, i
, Rel
);
7814 if (do_checks
&& section
->sh_size
== 0)
7815 warn (_("Section '%s': zero-sized relocation section\n"), name
);
7819 CHECK_ENTSIZE (section
, i
, Rela
);
7820 if (do_checks
&& section
->sh_size
== 0)
7821 warn (_("Section '%s': zero-sized relocation section\n"), name
);
7825 CHECK_ENTSIZE (section
, i
, Relr
);
7830 /* Having a zero sized section is not illegal according to the
7831 ELF standard, but it might be an indication that something
7832 is wrong. So issue a warning if we are running in lint mode. */
7833 if (do_checks
&& section
->sh_size
== 0)
7834 warn (_("Section '%s': has a size of zero - is this intended ?\n"), name
);
7841 if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
7842 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
7843 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
7844 || do_debug_str
|| do_debug_str_offsets
|| do_debug_loc
7846 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
7847 && (startswith (name
, ".debug_")
7848 || startswith (name
, ".zdebug_")))
7851 name
+= sizeof (".zdebug_") - 1;
7853 name
+= sizeof (".debug_") - 1;
7856 || (do_debug_info
&& startswith (name
, "info"))
7857 || (do_debug_info
&& startswith (name
, "types"))
7858 || (do_debug_abbrevs
&& startswith (name
, "abbrev"))
7859 || (do_debug_lines
&& strcmp (name
, "line") == 0)
7860 || (do_debug_lines
&& startswith (name
, "line."))
7861 || (do_debug_pubnames
&& startswith (name
, "pubnames"))
7862 || (do_debug_pubtypes
&& startswith (name
, "pubtypes"))
7863 || (do_debug_pubnames
&& startswith (name
, "gnu_pubnames"))
7864 || (do_debug_pubtypes
&& startswith (name
, "gnu_pubtypes"))
7865 || (do_debug_aranges
&& startswith (name
, "aranges"))
7866 || (do_debug_ranges
&& startswith (name
, "ranges"))
7867 || (do_debug_ranges
&& startswith (name
, "rnglists"))
7868 || (do_debug_frames
&& startswith (name
, "frame"))
7869 || (do_debug_macinfo
&& startswith (name
, "macinfo"))
7870 || (do_debug_macinfo
&& startswith (name
, "macro"))
7871 || (do_debug_str
&& startswith (name
, "str"))
7872 || (do_debug_links
&& startswith (name
, "sup"))
7873 || (do_debug_str_offsets
&& startswith (name
, "str_offsets"))
7874 || (do_debug_loc
&& startswith (name
, "loc"))
7875 || (do_debug_loc
&& startswith (name
, "loclists"))
7876 || (do_debug_addr
&& startswith (name
, "addr"))
7877 || (do_debug_cu_index
&& startswith (name
, "cu_index"))
7878 || (do_debug_cu_index
&& startswith (name
, "tu_index"))
7880 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7882 /* Linkonce section to be combined with .debug_info at link time. */
7883 else if ((do_debugging
|| do_debug_info
)
7884 && startswith (name
, ".gnu.linkonce.wi."))
7885 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7886 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
7887 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7888 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
7889 || streq (name
, ".debug_names")))
7890 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7891 /* Trace sections for Itanium VMS. */
7892 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
7893 || do_trace_aranges
)
7894 && startswith (name
, ".trace_"))
7896 name
+= sizeof (".trace_") - 1;
7899 || (do_trace_info
&& streq (name
, "info"))
7900 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
7901 || (do_trace_aranges
&& streq (name
, "aranges"))
7903 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7905 else if ((do_debugging
|| do_debug_links
)
7906 && (startswith (name
, ".gnu_debuglink")
7907 || startswith (name
, ".gnu_debugaltlink")))
7908 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7914 if (filedata
->is_separate
&& ! process_links
)
7917 if (filedata
->is_separate
)
7918 printf (_("\nSection Headers in linked file '%s':\n"), filedata
->file_name
);
7919 else if (filedata
->file_header
.e_shnum
> 1)
7920 printf (_("\nSection Headers:\n"));
7922 printf (_("\nSection Header:\n"));
7926 if (do_section_details
)
7928 printf (_(" [Nr] Name\n"));
7929 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
7933 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
7937 if (do_section_details
)
7939 printf (_(" [Nr] Name\n"));
7940 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
7944 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
7948 if (do_section_details
)
7950 printf (_(" [Nr] Name\n"));
7951 printf (_(" Type Address Offset Link\n"));
7952 printf (_(" Size EntSize Info Align\n"));
7956 printf (_(" [Nr] Name Type Address Offset\n"));
7957 printf (_(" Size EntSize Flags Link Info Align\n"));
7961 if (do_section_details
)
7962 printf (_(" Flags\n"));
7964 for (i
= 0, section
= filedata
->section_headers
;
7965 i
< filedata
->file_header
.e_shnum
;
7968 /* Run some sanity checks on the section header. */
7970 /* Check the sh_link field. */
7971 switch (section
->sh_type
)
7975 if (section
->sh_link
== 0
7976 && (filedata
->file_header
.e_type
== ET_EXEC
7977 || filedata
->file_header
.e_type
== ET_DYN
))
7978 /* A dynamic relocation section where all entries use a
7979 zero symbol index need not specify a symtab section. */
7982 case SHT_SYMTAB_SHNDX
:
7986 case SHT_GNU_versym
:
7987 if (section
->sh_link
== 0
7988 || section
->sh_link
>= filedata
->file_header
.e_shnum
7989 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
7990 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
7991 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
7992 i
, section
->sh_link
);
7998 case SHT_GNU_verneed
:
7999 case SHT_GNU_verdef
:
8000 case SHT_GNU_LIBLIST
:
8001 if (section
->sh_link
== 0
8002 || section
->sh_link
>= filedata
->file_header
.e_shnum
8003 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
8004 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
8005 i
, section
->sh_link
);
8008 case SHT_INIT_ARRAY
:
8009 case SHT_FINI_ARRAY
:
8010 case SHT_PREINIT_ARRAY
:
8011 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
8012 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
8013 i
, section
->sh_link
);
8017 /* FIXME: Add support for target specific section types. */
8018 #if 0 /* Currently we do not check other section types as there are too
8019 many special cases. Stab sections for example have a type
8020 of SHT_PROGBITS but an sh_link field that links to the .stabstr
8022 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
8023 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
8024 i
, section
->sh_link
);
8029 /* Check the sh_info field. */
8030 switch (section
->sh_type
)
8034 if (section
->sh_info
== 0
8035 && (filedata
->file_header
.e_type
== ET_EXEC
8036 || filedata
->file_header
.e_type
== ET_DYN
))
8037 /* Dynamic relocations apply to segments, so they do not
8038 need to specify the section they relocate. */
8040 if (section
->sh_info
== 0
8041 || section
->sh_info
>= filedata
->file_header
.e_shnum
8042 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
8043 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
8044 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
8045 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
8046 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
8047 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
8048 /* FIXME: Are other section types valid ? */
8049 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
8050 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
8051 i
, section
->sh_info
);
8056 case SHT_SYMTAB_SHNDX
:
8057 case SHT_INIT_ARRAY
:
8058 case SHT_FINI_ARRAY
:
8059 case SHT_PREINIT_ARRAY
:
8060 if (section
->sh_info
!= 0)
8061 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
8062 i
, section
->sh_info
);
8068 /* A symbol index - we assume that it is valid. */
8072 /* FIXME: Add support for target specific section types. */
8073 if (section
->sh_type
== SHT_NOBITS
)
8074 /* NOBITS section headers with non-zero sh_info fields can be
8075 created when a binary is stripped of everything but its debug
8076 information. The stripped sections have their headers
8077 preserved but their types set to SHT_NOBITS. So do not check
8078 this type of section. */
8080 else if (section
->sh_flags
& SHF_INFO_LINK
)
8082 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
8083 warn (_("[%2u]: Expected link to another section in info field"), i
);
8085 else if (section
->sh_type
< SHT_LOOS
8086 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
8087 && section
->sh_info
!= 0)
8088 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
8089 i
, section
->sh_info
);
8093 /* Check the sh_size field. */
8094 if (section
->sh_size
> filedata
->file_size
8095 && section
->sh_type
!= SHT_NOBITS
8096 && section
->sh_type
!= SHT_NULL
8097 && section
->sh_type
< SHT_LOOS
)
8098 warn (_("Size of section %u is larger than the entire file!\n"), i
);
8100 printf (" [%2u] ", i
);
8101 if (do_section_details
)
8102 printf ("%s\n ", printable_section_name (filedata
, section
));
8104 print_symbol_name (-17, printable_section_name (filedata
, section
));
8106 printf (do_wide
? " %-15s " : " %-15.15s ",
8107 get_section_type_name (filedata
, section
->sh_type
));
8111 const char * link_too_big
= NULL
;
8113 print_vma (section
->sh_addr
, LONG_HEX
);
8115 printf ( " %6.6lx %6.6lx %2.2lx",
8116 (unsigned long) section
->sh_offset
,
8117 (unsigned long) section
->sh_size
,
8118 (unsigned long) section
->sh_entsize
);
8120 if (do_section_details
)
8121 fputs (" ", stdout
);
8123 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
8125 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
8128 /* The sh_link value is out of range. Normally this indicates
8129 an error but it can have special values in Solaris binaries. */
8130 switch (filedata
->file_header
.e_machine
)
8137 case EM_OLD_SPARCV9
:
8138 case EM_SPARC32PLUS
:
8141 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
8142 link_too_big
= "BEFORE";
8143 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
8144 link_too_big
= "AFTER";
8151 if (do_section_details
)
8153 if (link_too_big
!= NULL
&& * link_too_big
)
8154 printf ("<%s> ", link_too_big
);
8156 printf ("%2u ", section
->sh_link
);
8157 printf ("%3u %2lu\n", section
->sh_info
,
8158 (unsigned long) section
->sh_addralign
);
8161 printf ("%2u %3u %2lu\n",
8164 (unsigned long) section
->sh_addralign
);
8166 if (link_too_big
&& ! * link_too_big
)
8167 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
8168 i
, section
->sh_link
);
8172 print_vma (section
->sh_addr
, LONG_HEX
);
8174 if ((long) section
->sh_offset
== section
->sh_offset
)
8175 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
8179 print_vma (section
->sh_offset
, LONG_HEX
);
8182 if ((unsigned long) section
->sh_size
== section
->sh_size
)
8183 printf (" %6.6lx", (unsigned long) section
->sh_size
);
8187 print_vma (section
->sh_size
, LONG_HEX
);
8190 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
8191 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
8195 print_vma (section
->sh_entsize
, LONG_HEX
);
8198 if (do_section_details
)
8199 fputs (" ", stdout
);
8201 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
8203 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
8205 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
8206 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
8209 print_vma (section
->sh_addralign
, DEC
);
8213 else if (do_section_details
)
8216 print_vma (section
->sh_addr
, LONG_HEX
);
8217 if ((long) section
->sh_offset
== section
->sh_offset
)
8218 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
8222 print_vma (section
->sh_offset
, LONG_HEX
);
8224 printf (" %u\n ", section
->sh_link
);
8225 print_vma (section
->sh_size
, LONG_HEX
);
8227 print_vma (section
->sh_entsize
, LONG_HEX
);
8229 printf (" %-16u %lu\n",
8231 (unsigned long) section
->sh_addralign
);
8236 print_vma (section
->sh_addr
, LONG_HEX
);
8237 if ((long) section
->sh_offset
== section
->sh_offset
)
8238 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
8242 print_vma (section
->sh_offset
, LONG_HEX
);
8245 print_vma (section
->sh_size
, LONG_HEX
);
8247 print_vma (section
->sh_entsize
, LONG_HEX
);
8249 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
8251 printf (" %2u %3u %lu\n",
8254 (unsigned long) section
->sh_addralign
);
8257 if (do_section_details
)
8259 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
8260 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
8262 /* Minimum section size is 12 bytes for 32-bit compression
8263 header + 12 bytes for compressed data header. */
8264 unsigned char buf
[24];
8266 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
8267 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
8268 sizeof (buf
), _("compression header")))
8270 Elf_Internal_Chdr chdr
;
8272 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
8273 printf (_(" [<corrupt>]\n"));
8276 if (chdr
.ch_type
== ch_compress_zlib
)
8278 else if (chdr
.ch_type
== ch_compress_zstd
)
8281 printf (_(" [<unknown>: 0x%x], "),
8283 print_vma (chdr
.ch_size
, LONG_HEX
);
8284 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
8291 if (!do_section_details
)
8293 /* The ordering of the letters shown here matches the ordering of the
8294 corresponding SHF_xxx values, and hence the order in which these
8295 letters will be displayed to the user. */
8296 printf (_("Key to Flags:\n\
8297 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
8298 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
8299 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
8300 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
8303 case ELFOSABI_FREEBSD
:
8304 printf (_("R (retain), "));
8307 printf (_("D (mbind), "));
8312 if (filedata
->file_header
.e_machine
== EM_X86_64
8313 || filedata
->file_header
.e_machine
== EM_L1OM
8314 || filedata
->file_header
.e_machine
== EM_K1OM
)
8315 printf (_("l (large), "));
8316 else if (filedata
->file_header
.e_machine
== EM_ARM
)
8317 printf (_("y (purecode), "));
8318 else if (filedata
->file_header
.e_machine
== EM_PPC
)
8319 printf (_("v (VLE), "));
8320 printf ("p (processor specific)\n");
8327 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
8328 Elf_Internal_Sym
**symtab
, uint64_t *nsyms
,
8329 char **strtab
, uint64_t *strtablen
)
8333 *symtab
= get_elf_symbols (filedata
, symsec
, nsyms
);
8335 if (*symtab
== NULL
)
8338 if (symsec
->sh_link
!= 0)
8340 Elf_Internal_Shdr
*strsec
;
8342 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
8344 error (_("Bad sh_link in symbol table section\n"));
8351 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
8353 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
8354 1, strsec
->sh_size
, _("string table"));
8355 if (*strtab
== NULL
)
8362 *strtablen
= strsec
->sh_size
;
8368 get_group_flags (unsigned int flags
)
8370 static char buff
[128];
8374 else if (flags
== GRP_COMDAT
)
8377 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
8379 flags
& GRP_MASKOS
? _("<OS specific>") : "",
8380 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
8381 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
8382 ? _("<unknown>") : ""));
8388 process_section_groups (Filedata
* filedata
)
8390 Elf_Internal_Shdr
* section
;
8392 struct group
* group
;
8393 Elf_Internal_Shdr
* symtab_sec
;
8394 Elf_Internal_Shdr
* strtab_sec
;
8395 Elf_Internal_Sym
* symtab
;
8400 /* Don't process section groups unless needed. */
8401 if (!do_unwind
&& !do_section_groups
)
8404 if (filedata
->file_header
.e_shnum
== 0)
8406 if (do_section_groups
)
8408 if (filedata
->is_separate
)
8409 printf (_("\nThere are no sections group in linked file '%s'.\n"),
8410 filedata
->file_name
);
8412 printf (_("\nThere are no section groups in this file.\n"));
8417 if (filedata
->section_headers
== NULL
)
8419 error (_("Section headers are not available!\n"));
8420 /* PR 13622: This can happen with a corrupt ELF header. */
8424 filedata
->section_headers_groups
8425 = (struct group
**) calloc (filedata
->file_header
.e_shnum
,
8426 sizeof (struct group
*));
8428 if (filedata
->section_headers_groups
== NULL
)
8430 error (_("Out of memory reading %u section group headers\n"),
8431 filedata
->file_header
.e_shnum
);
8435 /* Scan the sections for the group section. */
8436 filedata
->group_count
= 0;
8437 for (i
= 0, section
= filedata
->section_headers
;
8438 i
< filedata
->file_header
.e_shnum
;
8440 if (section
->sh_type
== SHT_GROUP
)
8441 filedata
->group_count
++;
8443 if (filedata
->group_count
== 0)
8445 if (do_section_groups
)
8447 if (filedata
->is_separate
)
8448 printf (_("\nThere are no section groups in linked file '%s'.\n"),
8449 filedata
->file_name
);
8451 printf (_("\nThere are no section groups in this file.\n"));
8457 filedata
->section_groups
= (struct group
*) calloc (filedata
->group_count
,
8458 sizeof (struct group
));
8460 if (filedata
->section_groups
== NULL
)
8462 error (_("Out of memory reading %zu groups\n"), filedata
->group_count
);
8473 if (filedata
->is_separate
)
8474 printf (_("Section groups in linked file '%s'\n"), filedata
->file_name
);
8476 for (i
= 0, section
= filedata
->section_headers
, group
= filedata
->section_groups
;
8477 i
< filedata
->file_header
.e_shnum
;
8480 if (section
->sh_type
== SHT_GROUP
)
8482 const char * name
= printable_section_name (filedata
, section
);
8483 const char * group_name
;
8484 unsigned char * start
;
8485 unsigned char * indices
;
8486 unsigned int entry
, j
, size
;
8487 Elf_Internal_Shdr
* sec
;
8488 Elf_Internal_Sym
* sym
;
8490 /* Get the symbol table. */
8491 if (section
->sh_link
>= filedata
->file_header
.e_shnum
8492 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
8495 error (_("Bad sh_link in group section `%s'\n"), name
);
8499 if (symtab_sec
!= sec
)
8503 symtab
= get_elf_symbols (filedata
, symtab_sec
, & num_syms
);
8508 error (_("Corrupt header in group section `%s'\n"), name
);
8512 if (section
->sh_info
>= num_syms
)
8514 error (_("Bad sh_info in group section `%s'\n"), name
);
8518 sym
= symtab
+ section
->sh_info
;
8520 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
8522 if (sym
->st_shndx
== 0
8523 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
8525 error (_("Bad sh_info in group section `%s'\n"), name
);
8529 group_name
= printable_section_name (filedata
,
8530 filedata
->section_headers
8539 /* Get the string table. */
8540 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
8548 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
8553 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
8554 1, strtab_sec
->sh_size
,
8556 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
8558 group_name
= sym
->st_name
< strtab_size
8559 ? strtab
+ sym
->st_name
: _("<corrupt>");
8562 /* PR 17531: file: loop. */
8563 if (section
->sh_entsize
> section
->sh_size
)
8565 error (_("Section %s has sh_entsize (%#" PRIx64
")"
8566 " which is larger than its size (%#" PRIx64
")\n"),
8567 printable_section_name (filedata
, section
),
8568 section
->sh_entsize
,
8573 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
8574 1, section
->sh_size
,
8580 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
8581 entry
= byte_get (indices
, 4);
8584 if (do_section_groups
)
8586 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
8587 get_group_flags (entry
), i
, name
, group_name
, size
);
8589 printf (_(" [Index] Name\n"));
8592 group
->group_index
= i
;
8594 for (j
= 0; j
< size
; j
++)
8596 struct group_list
* g
;
8598 entry
= byte_get (indices
, 4);
8601 if (entry
>= filedata
->file_header
.e_shnum
)
8603 static unsigned num_group_errors
= 0;
8605 if (num_group_errors
++ < 10)
8607 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
8608 entry
, i
, filedata
->file_header
.e_shnum
- 1);
8609 if (num_group_errors
== 10)
8610 warn (_("Further error messages about overlarge group section indices suppressed\n"));
8615 if (filedata
->section_headers_groups
[entry
] != NULL
)
8619 static unsigned num_errs
= 0;
8621 if (num_errs
++ < 10)
8623 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
8625 filedata
->section_headers_groups
[entry
]->group_index
);
8627 warn (_("Further error messages about already contained group sections suppressed\n"));
8633 /* Intel C/C++ compiler may put section 0 in a
8634 section group. We just warn it the first time
8635 and ignore it afterwards. */
8636 static bool warned
= false;
8639 error (_("section 0 in group section [%5u]\n"),
8640 filedata
->section_headers_groups
[entry
]->group_index
);
8646 filedata
->section_headers_groups
[entry
] = group
;
8648 if (do_section_groups
)
8650 sec
= filedata
->section_headers
+ entry
;
8651 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
8654 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
8655 g
->section_index
= entry
;
8656 g
->next
= group
->root
;
8671 /* Data used to display dynamic fixups. */
8673 struct ia64_vms_dynfixup
8675 uint64_t needed_ident
; /* Library ident number. */
8676 uint64_t needed
; /* Index in the dstrtab of the library name. */
8677 uint64_t fixup_needed
; /* Index of the library. */
8678 uint64_t fixup_rela_cnt
; /* Number of fixups. */
8679 uint64_t fixup_rela_off
; /* Fixups offset in the dynamic segment. */
8682 /* Data used to display dynamic relocations. */
8684 struct ia64_vms_dynimgrela
8686 uint64_t img_rela_cnt
; /* Number of relocations. */
8687 uint64_t img_rela_off
; /* Reloc offset in the dynamic segment. */
8690 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
8694 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
8695 struct ia64_vms_dynfixup
* fixup
,
8696 const char * strtab
,
8697 unsigned int strtab_sz
)
8699 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
8701 const char * lib_name
;
8703 imfs
= get_data (NULL
, filedata
,
8704 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
8705 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
8706 _("dynamic section image fixups"));
8710 if (fixup
->needed
< strtab_sz
)
8711 lib_name
= strtab
+ fixup
->needed
;
8714 warn (_("corrupt library name index of %#" PRIx64
8715 " found in dynamic entry"), fixup
->needed
);
8719 printf (_("\nImage fixups for needed library #%" PRId64
8720 ": %s - ident: %" PRIx64
"\n"),
8721 fixup
->fixup_needed
, lib_name
, fixup
->needed_ident
);
8723 (_("Seg Offset Type SymVec DataType\n"));
8725 for (i
= 0; i
< (size_t) fixup
->fixup_rela_cnt
; i
++)
8730 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
8731 printf ("%016" PRIx64
" ", BYTE_GET (imfs
[i
].fixup_offset
));
8732 type
= BYTE_GET (imfs
[i
].type
);
8733 rtype
= elf_ia64_reloc_type (type
);
8735 printf ("0x%08x ", type
);
8737 printf ("%-32s ", rtype
);
8738 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
8739 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
8746 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
8749 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
8751 Elf64_External_VMS_IMAGE_RELA
*imrs
;
8754 imrs
= get_data (NULL
, filedata
,
8755 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
8756 sizeof (*imrs
), imgrela
->img_rela_cnt
,
8757 _("dynamic section image relocations"));
8761 printf (_("\nImage relocs\n"));
8763 (_("Seg Offset Type Addend Seg Sym Off\n"));
8765 for (i
= 0; i
< (size_t) imgrela
->img_rela_cnt
; i
++)
8770 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
8771 printf ("%08" PRIx64
" ", BYTE_GET (imrs
[i
].rela_offset
));
8772 type
= BYTE_GET (imrs
[i
].type
);
8773 rtype
= elf_ia64_reloc_type (type
);
8775 printf ("0x%08x ", type
);
8777 printf ("%-31s ", rtype
);
8778 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
8779 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
8780 printf ("%08" PRIx64
"\n", BYTE_GET (imrs
[i
].sym_offset
));
8787 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
8790 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
8792 struct ia64_vms_dynfixup fixup
;
8793 struct ia64_vms_dynimgrela imgrela
;
8794 Elf_Internal_Dyn
*entry
;
8795 uint64_t strtab_off
= 0;
8796 uint64_t strtab_sz
= 0;
8797 char *strtab
= NULL
;
8800 memset (&fixup
, 0, sizeof (fixup
));
8801 memset (&imgrela
, 0, sizeof (imgrela
));
8803 /* Note: the order of the entries is specified by the OpenVMS specs. */
8804 for (entry
= filedata
->dynamic_section
;
8805 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
8808 switch (entry
->d_tag
)
8810 case DT_IA_64_VMS_STRTAB_OFFSET
:
8811 strtab_off
= entry
->d_un
.d_val
;
8814 strtab_sz
= entry
->d_un
.d_val
;
8816 strtab
= get_data (NULL
, filedata
,
8817 filedata
->dynamic_addr
+ strtab_off
,
8818 1, strtab_sz
, _("dynamic string section"));
8823 case DT_IA_64_VMS_NEEDED_IDENT
:
8824 fixup
.needed_ident
= entry
->d_un
.d_val
;
8827 fixup
.needed
= entry
->d_un
.d_val
;
8829 case DT_IA_64_VMS_FIXUP_NEEDED
:
8830 fixup
.fixup_needed
= entry
->d_un
.d_val
;
8832 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
8833 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
8835 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
8836 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
8837 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
8840 case DT_IA_64_VMS_IMG_RELA_CNT
:
8841 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
8843 case DT_IA_64_VMS_IMG_RELA_OFF
:
8844 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
8845 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
8864 relocation_type rel_type
;
8866 dynamic_relocations
[] =
8868 { "REL", DT_REL
, DT_RELSZ
, reltype_rel
},
8869 { "RELA", DT_RELA
, DT_RELASZ
, reltype_rela
},
8870 { "RELR", DT_RELR
, DT_RELRSZ
, reltype_relr
},
8871 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, reltype_unknown
}
8874 /* Process the reloc section. */
8877 process_relocs (Filedata
* filedata
)
8880 uint64_t rel_offset
;
8885 if (do_using_dynamic
)
8887 relocation_type rel_type
;
8889 bool has_dynamic_reloc
;
8892 has_dynamic_reloc
= false;
8894 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
8896 rel_type
= dynamic_relocations
[i
].rel_type
;
8897 name
= dynamic_relocations
[i
].name
;
8898 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
8899 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
8902 has_dynamic_reloc
= true;
8904 if (rel_type
== reltype_unknown
)
8906 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
8907 switch (filedata
->dynamic_info
[DT_PLTREL
])
8910 rel_type
= reltype_rel
;
8913 rel_type
= reltype_rela
;
8920 if (filedata
->is_separate
)
8922 (_("\nIn linked file '%s' section '%s' at offset %#" PRIx64
8923 " contains %" PRId64
" bytes:\n"),
8924 filedata
->file_name
, name
, rel_offset
, rel_size
);
8927 (_("\n'%s' relocation section at offset %#" PRIx64
8928 " contains %" PRId64
" bytes:\n"),
8929 name
, rel_offset
, rel_size
);
8931 dump_relocations (filedata
,
8932 offset_from_vma (filedata
, rel_offset
, rel_size
),
8934 filedata
->dynamic_symbols
,
8935 filedata
->num_dynamic_syms
,
8936 filedata
->dynamic_strings
,
8937 filedata
->dynamic_strings_length
,
8938 rel_type
, true /* is_dynamic */);
8942 if (is_ia64_vms (filedata
))
8943 if (process_ia64_vms_dynamic_relocs (filedata
))
8944 has_dynamic_reloc
= true;
8946 if (! has_dynamic_reloc
)
8948 if (filedata
->is_separate
)
8949 printf (_("\nThere are no dynamic relocations in linked file '%s'.\n"),
8950 filedata
->file_name
);
8952 printf (_("\nThere are no dynamic relocations in this file.\n"));
8957 Elf_Internal_Shdr
* section
;
8961 for (i
= 0, section
= filedata
->section_headers
;
8962 i
< filedata
->file_header
.e_shnum
;
8965 if ( section
->sh_type
!= SHT_RELA
8966 && section
->sh_type
!= SHT_REL
8967 && section
->sh_type
!= SHT_RELR
)
8970 rel_offset
= section
->sh_offset
;
8971 rel_size
= section
->sh_size
;
8975 relocation_type rel_type
;
8978 if (filedata
->is_separate
)
8979 printf (_("\nIn linked file '%s' relocation section "),
8980 filedata
->file_name
);
8982 printf (_("\nRelocation section "));
8984 if (filedata
->string_table
== NULL
)
8985 printf ("%d", section
->sh_name
);
8987 printf ("'%s'", printable_section_name (filedata
, section
));
8989 num_rela
= rel_size
/ section
->sh_entsize
;
8990 printf (ngettext (" at offset %#" PRIx64
8991 " contains %" PRIu64
" entry:\n",
8992 " at offset %#" PRIx64
8993 " contains %" PRId64
" entries:\n",
8995 rel_offset
, num_rela
);
8997 rel_type
= section
->sh_type
== SHT_RELA
? reltype_rela
:
8998 section
->sh_type
== SHT_REL
? reltype_rel
: reltype_relr
;
9000 if (section
->sh_link
!= 0
9001 && section
->sh_link
< filedata
->file_header
.e_shnum
)
9003 Elf_Internal_Shdr
*symsec
;
9004 Elf_Internal_Sym
*symtab
;
9006 uint64_t strtablen
= 0;
9007 char *strtab
= NULL
;
9009 symsec
= filedata
->section_headers
+ section
->sh_link
;
9010 if (symsec
->sh_type
!= SHT_SYMTAB
9011 && symsec
->sh_type
!= SHT_DYNSYM
)
9014 if (!get_symtab (filedata
, symsec
,
9015 &symtab
, &nsyms
, &strtab
, &strtablen
))
9018 dump_relocations (filedata
, rel_offset
, rel_size
,
9019 symtab
, nsyms
, strtab
, strtablen
,
9021 symsec
->sh_type
== SHT_DYNSYM
);
9026 dump_relocations (filedata
, rel_offset
, rel_size
,
9027 NULL
, 0, NULL
, 0, rel_type
, false /* is_dynamic */);
9035 /* Users sometimes forget the -D option, so try to be helpful. */
9036 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
9038 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
9040 if (filedata
->is_separate
)
9041 printf (_("\nThere are no static relocations in linked file '%s'."),
9042 filedata
->file_name
);
9044 printf (_("\nThere are no static relocations in this file."));
9045 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
9050 if (i
== ARRAY_SIZE (dynamic_relocations
))
9052 if (filedata
->is_separate
)
9053 printf (_("\nThere are no relocations in linked file '%s'.\n"),
9054 filedata
->file_name
);
9056 printf (_("\nThere are no relocations in this file.\n"));
9064 /* An absolute address consists of a section and an offset. If the
9065 section is NULL, the offset itself is the address, otherwise, the
9066 address equals to LOAD_ADDRESS(section) + offset. */
9070 unsigned short section
;
9074 /* Find the nearest symbol at or below ADDR. Returns the symbol
9075 name, if found, and the offset from the symbol to ADDR. */
9078 find_symbol_for_address (Filedata
*filedata
,
9079 Elf_Internal_Sym
*symtab
,
9082 uint64_t strtab_size
,
9083 struct absaddr addr
,
9084 const char **symname
,
9087 uint64_t dist
= 0x100000;
9088 Elf_Internal_Sym
* sym
;
9089 Elf_Internal_Sym
* beg
;
9090 Elf_Internal_Sym
* end
;
9091 Elf_Internal_Sym
* best
= NULL
;
9093 REMOVE_ARCH_BITS (addr
.offset
);
9095 end
= symtab
+ nsyms
;
9101 sym
= beg
+ (end
- beg
) / 2;
9103 value
= sym
->st_value
;
9104 REMOVE_ARCH_BITS (value
);
9106 if (sym
->st_name
!= 0
9107 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
9108 && addr
.offset
>= value
9109 && addr
.offset
- value
< dist
)
9112 dist
= addr
.offset
- value
;
9117 if (addr
.offset
< value
)
9125 *symname
= (best
->st_name
>= strtab_size
9126 ? _("<corrupt>") : strtab
+ best
->st_name
);
9132 *offset
= addr
.offset
;
9135 static /* signed */ int
9136 symcmp (const void *p
, const void *q
)
9138 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
9139 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
9141 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
9144 /* Process the unwind section. */
9146 #include "unwind-ia64.h"
9148 struct ia64_unw_table_entry
9150 struct absaddr start
;
9152 struct absaddr info
;
9155 struct ia64_unw_aux_info
9157 struct ia64_unw_table_entry
* table
; /* Unwind table. */
9158 uint64_t table_len
; /* Length of unwind table. */
9159 unsigned char * info
; /* Unwind info. */
9160 uint64_t info_size
; /* Size of unwind info. */
9161 uint64_t info_addr
; /* Starting address of unwind info. */
9162 uint64_t seg_base
; /* Starting address of segment. */
9163 Elf_Internal_Sym
* symtab
; /* The symbol table. */
9164 uint64_t nsyms
; /* Number of symbols. */
9165 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
9166 uint64_t nfuns
; /* Number of entries in funtab. */
9167 char * strtab
; /* The string table. */
9168 uint64_t strtab_size
; /* Size of string table. */
9172 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
9174 struct ia64_unw_table_entry
* tp
;
9179 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9180 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9181 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9182 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9184 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9186 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
9190 const unsigned char * dp
;
9191 const unsigned char * head
;
9192 const unsigned char * end
;
9193 const char * procname
;
9195 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
9196 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
9198 fputs ("\n<", stdout
);
9202 fputs (procname
, stdout
);
9205 printf ("+%" PRIx64
, offset
);
9208 fputs (">: [", stdout
);
9209 print_vma (tp
->start
.offset
, PREFIX_HEX
);
9210 fputc ('-', stdout
);
9211 print_vma (tp
->end
.offset
, PREFIX_HEX
);
9212 printf ("], info at +0x%" PRIx64
"\n",
9213 tp
->info
.offset
- aux
->seg_base
);
9215 /* PR 17531: file: 86232b32. */
9216 if (aux
->info
== NULL
)
9219 offset
= tp
->info
.offset
;
9220 if (tp
->info
.section
)
9222 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
9224 warn (_("Invalid section %u in table entry %td\n"),
9225 tp
->info
.section
, tp
- aux
->table
);
9229 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
9231 offset
-= aux
->info_addr
;
9232 /* PR 17531: file: 0997b4d1. */
9233 if (offset
>= aux
->info_size
9234 || aux
->info_size
- offset
< 8)
9236 warn (_("Invalid offset %" PRIx64
" in table entry %td\n"),
9237 tp
->info
.offset
, tp
- aux
->table
);
9242 head
= aux
->info
+ offset
;
9243 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
9245 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
9246 (unsigned) UNW_VER (stamp
),
9247 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
9248 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
9249 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
9250 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
9252 if (UNW_VER (stamp
) != 1)
9254 printf (_("\tUnknown version.\n"));
9259 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
9260 /* PR 17531: file: 16ceda89. */
9261 if (end
> aux
->info
+ aux
->info_size
)
9262 end
= aux
->info
+ aux
->info_size
;
9263 for (dp
= head
+ 8; dp
< end
;)
9264 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
9273 slurp_ia64_unwind_table (Filedata
* filedata
,
9274 struct ia64_unw_aux_info
* aux
,
9275 Elf_Internal_Shdr
* sec
)
9277 uint64_t size
, nrelas
, i
;
9278 Elf_Internal_Phdr
* seg
;
9279 struct ia64_unw_table_entry
* tep
;
9280 Elf_Internal_Shdr
* relsec
;
9281 Elf_Internal_Rela
* rela
;
9282 Elf_Internal_Rela
* rp
;
9283 unsigned char * table
;
9285 Elf_Internal_Sym
* sym
;
9286 const char * relname
;
9290 /* First, find the starting address of the segment that includes
9293 if (filedata
->file_header
.e_phnum
)
9295 if (! get_program_headers (filedata
))
9298 for (seg
= filedata
->program_headers
;
9299 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
9302 if (seg
->p_type
!= PT_LOAD
)
9305 if (sec
->sh_addr
>= seg
->p_vaddr
9306 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
9308 aux
->seg_base
= seg
->p_vaddr
;
9314 /* Second, build the unwind table from the contents of the unwind section: */
9315 size
= sec
->sh_size
;
9316 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
9321 aux
->table_len
= size
/ (3 * eh_addr_size
);
9322 aux
->table
= (struct ia64_unw_table_entry
*)
9323 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
9326 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
9328 tep
->start
.section
= SHN_UNDEF
;
9329 tep
->end
.section
= SHN_UNDEF
;
9330 tep
->info
.section
= SHN_UNDEF
;
9331 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
9332 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
9333 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
9334 tep
->start
.offset
+= aux
->seg_base
;
9335 tep
->end
.offset
+= aux
->seg_base
;
9336 tep
->info
.offset
+= aux
->seg_base
;
9340 /* Third, apply any relocations to the unwind table: */
9341 for (relsec
= filedata
->section_headers
;
9342 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
9345 if (relsec
->sh_type
!= SHT_RELA
9346 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
9347 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
9350 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
9359 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
9361 unsigned int sym_ndx
;
9362 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
9363 relname
= elf_ia64_reloc_type (r_type
);
9365 /* PR 17531: file: 9fa67536. */
9366 if (relname
== NULL
)
9368 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
9372 if (! startswith (relname
, "R_IA64_SEGREL"))
9374 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
9378 i
= rp
->r_offset
/ (3 * eh_addr_size
);
9380 /* PR 17531: file: 5bc8d9bf. */
9381 if (i
>= aux
->table_len
)
9383 warn (_("Skipping reloc with overlarge offset: %#" PRIx64
"\n"),
9388 sym_ndx
= get_reloc_symindex (rp
->r_info
);
9389 if (sym_ndx
>= aux
->nsyms
)
9391 warn (_("Skipping reloc with invalid symbol index: %u\n"),
9395 sym
= aux
->symtab
+ sym_ndx
;
9397 switch (rp
->r_offset
/ eh_addr_size
% 3)
9400 aux
->table
[i
].start
.section
= sym
->st_shndx
;
9401 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
9404 aux
->table
[i
].end
.section
= sym
->st_shndx
;
9405 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
9408 aux
->table
[i
].info
.section
= sym
->st_shndx
;
9409 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
9423 ia64_process_unwind (Filedata
* filedata
)
9425 Elf_Internal_Shdr
* sec
;
9426 Elf_Internal_Shdr
* unwsec
= NULL
;
9427 uint64_t i
, unwcount
= 0, unwstart
= 0;
9428 struct ia64_unw_aux_info aux
;
9431 memset (& aux
, 0, sizeof (aux
));
9433 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9435 if (sec
->sh_type
== SHT_SYMTAB
)
9439 error (_("Multiple symbol tables encountered\n"));
9445 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9446 &aux
.strtab
, &aux
.strtab_size
))
9449 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
9454 printf (_("\nThere are no unwind sections in this file.\n"));
9456 while (unwcount
-- > 0)
9461 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
9462 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9463 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
9468 /* We have already counted the number of SHT_IA64_UNWIND
9469 sections so the loop above should never fail. */
9470 assert (unwsec
!= NULL
);
9473 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
9475 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
9477 /* We need to find which section group it is in. */
9478 struct group_list
* g
;
9480 if (filedata
->section_headers_groups
== NULL
9481 || filedata
->section_headers_groups
[i
] == NULL
)
9482 i
= filedata
->file_header
.e_shnum
;
9485 g
= filedata
->section_headers_groups
[i
]->root
;
9487 for (; g
!= NULL
; g
= g
->next
)
9489 sec
= filedata
->section_headers
+ g
->section_index
;
9491 if (section_name_valid (filedata
, sec
)
9492 && streq (section_name (filedata
, sec
),
9493 ELF_STRING_ia64_unwind_info
))
9498 i
= filedata
->file_header
.e_shnum
;
9501 else if (section_name_valid (filedata
, unwsec
)
9502 && startswith (section_name (filedata
, unwsec
),
9503 ELF_STRING_ia64_unwind_once
))
9505 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
9506 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
9507 suffix
= section_name (filedata
, unwsec
) + len
;
9508 for (i
= 0, sec
= filedata
->section_headers
;
9509 i
< filedata
->file_header
.e_shnum
;
9511 if (section_name_valid (filedata
, sec
)
9512 && startswith (section_name (filedata
, sec
),
9513 ELF_STRING_ia64_unwind_info_once
)
9514 && streq (section_name (filedata
, sec
) + len2
, suffix
))
9519 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
9520 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
9521 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
9522 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
9524 if (section_name_valid (filedata
, unwsec
)
9525 && startswith (section_name (filedata
, unwsec
),
9526 ELF_STRING_ia64_unwind
))
9527 suffix
= section_name (filedata
, unwsec
) + len
;
9528 for (i
= 0, sec
= filedata
->section_headers
;
9529 i
< filedata
->file_header
.e_shnum
;
9531 if (section_name_valid (filedata
, sec
)
9532 && startswith (section_name (filedata
, sec
),
9533 ELF_STRING_ia64_unwind_info
)
9534 && streq (section_name (filedata
, sec
) + len2
, suffix
))
9538 if (i
== filedata
->file_header
.e_shnum
)
9540 printf (_("\nCould not find unwind info section for "));
9542 if (filedata
->string_table
== NULL
)
9543 printf ("%d", unwsec
->sh_name
);
9545 printf ("'%s'", printable_section_name (filedata
, unwsec
));
9549 aux
.info_addr
= sec
->sh_addr
;
9550 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
9553 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
9555 printf (_("\nUnwind section "));
9557 if (filedata
->string_table
== NULL
)
9558 printf ("%d", unwsec
->sh_name
);
9560 printf ("'%s'", printable_section_name (filedata
, unwsec
));
9562 printf (_(" at offset %#" PRIx64
" contains %" PRIu64
" entries:\n"),
9564 unwsec
->sh_size
/ (3 * eh_addr_size
));
9566 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
9567 && aux
.table_len
> 0)
9568 dump_ia64_unwind (filedata
, & aux
);
9570 free ((char *) aux
.table
);
9571 free ((char *) aux
.info
);
9578 free ((char *) aux
.strtab
);
9583 struct hppa_unw_table_entry
9585 struct absaddr start
;
9587 unsigned int Cannot_unwind
:1; /* 0 */
9588 unsigned int Millicode
:1; /* 1 */
9589 unsigned int Millicode_save_sr0
:1; /* 2 */
9590 unsigned int Region_description
:2; /* 3..4 */
9591 unsigned int reserved1
:1; /* 5 */
9592 unsigned int Entry_SR
:1; /* 6 */
9593 unsigned int Entry_FR
:4; /* Number saved 7..10 */
9594 unsigned int Entry_GR
:5; /* Number saved 11..15 */
9595 unsigned int Args_stored
:1; /* 16 */
9596 unsigned int Variable_Frame
:1; /* 17 */
9597 unsigned int Separate_Package_Body
:1; /* 18 */
9598 unsigned int Frame_Extension_Millicode
:1; /* 19 */
9599 unsigned int Stack_Overflow_Check
:1; /* 20 */
9600 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
9601 unsigned int Ada_Region
:1; /* 22 */
9602 unsigned int cxx_info
:1; /* 23 */
9603 unsigned int cxx_try_catch
:1; /* 24 */
9604 unsigned int sched_entry_seq
:1; /* 25 */
9605 unsigned int reserved2
:1; /* 26 */
9606 unsigned int Save_SP
:1; /* 27 */
9607 unsigned int Save_RP
:1; /* 28 */
9608 unsigned int Save_MRP_in_frame
:1; /* 29 */
9609 unsigned int extn_ptr_defined
:1; /* 30 */
9610 unsigned int Cleanup_defined
:1; /* 31 */
9612 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
9613 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
9614 unsigned int Large_frame
:1; /* 2 */
9615 unsigned int Pseudo_SP_Set
:1; /* 3 */
9616 unsigned int reserved4
:1; /* 4 */
9617 unsigned int Total_frame_size
:27; /* 5..31 */
9620 struct hppa_unw_aux_info
9622 struct hppa_unw_table_entry
* table
; /* Unwind table. */
9623 uint64_t table_len
; /* Length of unwind table. */
9624 uint64_t seg_base
; /* Starting address of segment. */
9625 Elf_Internal_Sym
* symtab
; /* The symbol table. */
9626 uint64_t nsyms
; /* Number of symbols. */
9627 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
9628 uint64_t nfuns
; /* Number of entries in funtab. */
9629 char * strtab
; /* The string table. */
9630 uint64_t strtab_size
; /* Size of string table. */
9634 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
9636 struct hppa_unw_table_entry
* tp
;
9640 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9641 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9642 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9643 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9645 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9647 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
9650 const char * procname
;
9652 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
9653 aux
->strtab_size
, tp
->start
, &procname
,
9656 fputs ("\n<", stdout
);
9660 fputs (procname
, stdout
);
9663 printf ("+%" PRIx64
, offset
);
9666 fputs (">: [", stdout
);
9667 print_vma (tp
->start
.offset
, PREFIX_HEX
);
9668 fputc ('-', stdout
);
9669 print_vma (tp
->end
.offset
, PREFIX_HEX
);
9672 #define PF(_m) if (tp->_m) printf (#_m " ");
9673 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
9676 PF(Millicode_save_sr0
);
9677 /* PV(Region_description); */
9683 PF(Separate_Package_Body
);
9684 PF(Frame_Extension_Millicode
);
9685 PF(Stack_Overflow_Check
);
9686 PF(Two_Instruction_SP_Increment
);
9690 PF(sched_entry_seq
);
9693 PF(Save_MRP_in_frame
);
9694 PF(extn_ptr_defined
);
9695 PF(Cleanup_defined
);
9696 PF(MPE_XL_interrupt_marker
);
9697 PF(HP_UX_interrupt_marker
);
9700 PV(Total_frame_size
);
9713 slurp_hppa_unwind_table (Filedata
* filedata
,
9714 struct hppa_unw_aux_info
* aux
,
9715 Elf_Internal_Shdr
* sec
)
9717 uint64_t size
, unw_ent_size
, nentries
, nrelas
, i
;
9718 Elf_Internal_Phdr
* seg
;
9719 struct hppa_unw_table_entry
* tep
;
9720 Elf_Internal_Shdr
* relsec
;
9721 Elf_Internal_Rela
* rela
;
9722 Elf_Internal_Rela
* rp
;
9723 unsigned char * table
;
9725 Elf_Internal_Sym
* sym
;
9726 const char * relname
;
9728 /* First, find the starting address of the segment that includes
9730 if (filedata
->file_header
.e_phnum
)
9732 if (! get_program_headers (filedata
))
9735 for (seg
= filedata
->program_headers
;
9736 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
9739 if (seg
->p_type
!= PT_LOAD
)
9742 if (sec
->sh_addr
>= seg
->p_vaddr
9743 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
9745 aux
->seg_base
= seg
->p_vaddr
;
9751 /* Second, build the unwind table from the contents of the unwind
9753 size
= sec
->sh_size
;
9754 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
9760 nentries
= size
/ unw_ent_size
;
9761 size
= unw_ent_size
* nentries
;
9763 aux
->table_len
= nentries
;
9764 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
9765 xcmalloc (nentries
, sizeof (aux
->table
[0]));
9767 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
9769 unsigned int tmp1
, tmp2
;
9771 tep
->start
.section
= SHN_UNDEF
;
9772 tep
->end
.section
= SHN_UNDEF
;
9774 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
9775 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
9776 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
9777 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
9779 tep
->start
.offset
+= aux
->seg_base
;
9780 tep
->end
.offset
+= aux
->seg_base
;
9782 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
9783 tep
->Millicode
= (tmp1
>> 30) & 0x1;
9784 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
9785 tep
->Region_description
= (tmp1
>> 27) & 0x3;
9786 tep
->reserved1
= (tmp1
>> 26) & 0x1;
9787 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
9788 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
9789 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
9790 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
9791 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
9792 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
9793 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
9794 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
9795 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
9796 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
9797 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
9798 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
9799 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
9800 tep
->reserved2
= (tmp1
>> 5) & 0x1;
9801 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
9802 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
9803 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
9804 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
9805 tep
->Cleanup_defined
= tmp1
& 0x1;
9807 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
9808 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
9809 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
9810 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
9811 tep
->reserved4
= (tmp2
>> 27) & 0x1;
9812 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
9816 /* Third, apply any relocations to the unwind table. */
9817 for (relsec
= filedata
->section_headers
;
9818 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
9821 if (relsec
->sh_type
!= SHT_RELA
9822 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
9823 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
9826 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
9830 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
9832 unsigned int sym_ndx
;
9833 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
9834 relname
= elf_hppa_reloc_type (r_type
);
9836 if (relname
== NULL
)
9838 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
9842 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
9843 if (! startswith (relname
, "R_PARISC_SEGREL"))
9845 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
9849 i
= rp
->r_offset
/ unw_ent_size
;
9850 if (i
>= aux
->table_len
)
9852 warn (_("Skipping reloc with overlarge offset: %#" PRIx64
"\n"),
9857 sym_ndx
= get_reloc_symindex (rp
->r_info
);
9858 if (sym_ndx
>= aux
->nsyms
)
9860 warn (_("Skipping reloc with invalid symbol index: %u\n"),
9864 sym
= aux
->symtab
+ sym_ndx
;
9866 switch ((rp
->r_offset
% unw_ent_size
) / 4)
9869 aux
->table
[i
].start
.section
= sym
->st_shndx
;
9870 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
9873 aux
->table
[i
].end
.section
= sym
->st_shndx
;
9874 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
9888 hppa_process_unwind (Filedata
* filedata
)
9890 struct hppa_unw_aux_info aux
;
9891 Elf_Internal_Shdr
* unwsec
= NULL
;
9892 Elf_Internal_Shdr
* sec
;
9896 if (filedata
->string_table
== NULL
)
9899 memset (& aux
, 0, sizeof (aux
));
9901 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9903 if (sec
->sh_type
== SHT_SYMTAB
)
9907 error (_("Multiple symbol tables encountered\n"));
9913 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9914 &aux
.strtab
, &aux
.strtab_size
))
9917 else if (section_name_valid (filedata
, sec
)
9918 && streq (section_name (filedata
, sec
), ".PARISC.unwind"))
9923 printf (_("\nThere are no unwind sections in this file.\n"));
9925 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9927 if (section_name_valid (filedata
, sec
)
9928 && streq (section_name (filedata
, sec
), ".PARISC.unwind"))
9930 uint64_t num_unwind
= sec
->sh_size
/ 16;
9932 printf (ngettext ("\nUnwind section '%s' at offset %#" PRIx64
" "
9933 "contains %" PRIu64
" entry:\n",
9934 "\nUnwind section '%s' at offset %#" PRIx64
" "
9935 "contains %" PRIu64
" entries:\n",
9937 printable_section_name (filedata
, sec
),
9941 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
9944 if (res
&& aux
.table_len
> 0)
9946 if (! dump_hppa_unwind (filedata
, &aux
))
9950 free ((char *) aux
.table
);
9956 free ((char *) aux
.strtab
);
9963 unsigned char * data
; /* The unwind data. */
9964 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
9965 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
9966 uint64_t nrelas
; /* The number of relocations. */
9967 unsigned int rel_type
; /* REL or RELA ? */
9968 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
9971 struct arm_unw_aux_info
9973 Filedata
* filedata
; /* The file containing the unwind sections. */
9974 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
9975 uint64_t nsyms
; /* Number of symbols. */
9976 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
9977 uint64_t nfuns
; /* Number of these symbols. */
9978 char * strtab
; /* The file's string table. */
9979 uint64_t strtab_size
; /* Size of string table. */
9983 arm_print_vma_and_name (Filedata
* filedata
,
9984 struct arm_unw_aux_info
* aux
,
9986 struct absaddr addr
)
9988 const char *procname
;
9989 uint64_t sym_offset
;
9991 if (addr
.section
== SHN_UNDEF
)
9994 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
9995 aux
->strtab_size
, addr
, &procname
,
9998 print_vma (fn
, PREFIX_HEX
);
10002 fputs (" <", stdout
);
10003 fputs (procname
, stdout
);
10006 printf ("+0x%" PRIx64
, sym_offset
);
10007 fputc ('>', stdout
);
10014 arm_free_section (struct arm_section
*arm_sec
)
10016 free (arm_sec
->data
);
10017 free (arm_sec
->rela
);
10020 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
10021 cached section and install SEC instead.
10022 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
10023 and return its valued in * WORDP, relocating if necessary.
10024 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
10025 relocation's offset in ADDR.
10026 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
10027 into the string table of the symbol associated with the reloc. If no
10028 reloc was applied store -1 there.
10029 5) Return TRUE upon success, FALSE otherwise. */
10032 get_unwind_section_word (Filedata
* filedata
,
10033 struct arm_unw_aux_info
* aux
,
10034 struct arm_section
* arm_sec
,
10035 Elf_Internal_Shdr
* sec
,
10036 uint64_t word_offset
,
10037 unsigned int * wordp
,
10038 struct absaddr
* addr
,
10039 uint64_t * sym_name
)
10041 Elf_Internal_Rela
*rp
;
10042 Elf_Internal_Sym
*sym
;
10043 const char * relname
;
10047 if (sec
== NULL
|| arm_sec
== NULL
)
10050 addr
->section
= SHN_UNDEF
;
10053 if (sym_name
!= NULL
)
10054 *sym_name
= (uint64_t) -1;
10056 /* If necessary, update the section cache. */
10057 if (sec
!= arm_sec
->sec
)
10059 Elf_Internal_Shdr
*relsec
;
10061 arm_free_section (arm_sec
);
10063 arm_sec
->sec
= sec
;
10064 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
10065 sec
->sh_size
, _("unwind data"));
10066 arm_sec
->rela
= NULL
;
10067 arm_sec
->nrelas
= 0;
10069 for (relsec
= filedata
->section_headers
;
10070 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
10073 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
10074 || filedata
->section_headers
+ relsec
->sh_info
!= sec
10075 /* PR 15745: Check the section type as well. */
10076 || (relsec
->sh_type
!= SHT_REL
10077 && relsec
->sh_type
!= SHT_RELA
))
10080 arm_sec
->rel_type
= relsec
->sh_type
;
10081 if (relsec
->sh_type
== SHT_REL
)
10083 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
10085 & arm_sec
->rela
, & arm_sec
->nrelas
))
10088 else /* relsec->sh_type == SHT_RELA */
10090 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
10092 & arm_sec
->rela
, & arm_sec
->nrelas
))
10098 arm_sec
->next_rela
= arm_sec
->rela
;
10101 /* If there is no unwind data we can do nothing. */
10102 if (arm_sec
->data
== NULL
)
10105 /* If the offset is invalid then fail. */
10106 if (/* PR 21343 *//* PR 18879 */
10108 || word_offset
> sec
->sh_size
- 4)
10111 /* Get the word at the required offset. */
10112 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
10114 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
10115 if (arm_sec
->rela
== NULL
)
10121 /* Look through the relocs to find the one that applies to the provided offset. */
10123 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
10125 uint64_t prelval
, offset
;
10127 if (rp
->r_offset
> word_offset
&& !wrapped
)
10129 rp
= arm_sec
->rela
;
10132 if (rp
->r_offset
> word_offset
)
10135 if (rp
->r_offset
& 3)
10137 warn (_("Skipping unexpected relocation at offset %#" PRIx64
"\n"),
10142 if (rp
->r_offset
< word_offset
)
10145 /* PR 17531: file: 027-161405-0.004 */
10146 if (aux
->symtab
== NULL
)
10149 if (arm_sec
->rel_type
== SHT_REL
)
10151 offset
= word
& 0x7fffffff;
10152 if (offset
& 0x40000000)
10153 offset
|= ~ (uint64_t) 0x7fffffff;
10155 else if (arm_sec
->rel_type
== SHT_RELA
)
10156 offset
= rp
->r_addend
;
10159 error (_("Unknown section relocation type %d encountered\n"),
10160 arm_sec
->rel_type
);
10164 /* PR 17531 file: 027-1241568-0.004. */
10165 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
10167 error (_("Bad symbol index in unwind relocation "
10168 "(%" PRIu64
" > %" PRIu64
")\n"),
10169 ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
10173 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
10174 offset
+= sym
->st_value
;
10175 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
10177 /* Check that we are processing the expected reloc type. */
10178 if (filedata
->file_header
.e_machine
== EM_ARM
)
10180 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
10181 if (relname
== NULL
)
10183 warn (_("Skipping unknown ARM relocation type: %d\n"),
10184 (int) ELF32_R_TYPE (rp
->r_info
));
10188 if (streq (relname
, "R_ARM_NONE"))
10191 if (! streq (relname
, "R_ARM_PREL31"))
10193 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
10197 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
10199 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
10200 if (relname
== NULL
)
10202 warn (_("Skipping unknown C6000 relocation type: %d\n"),
10203 (int) ELF32_R_TYPE (rp
->r_info
));
10207 if (streq (relname
, "R_C6000_NONE"))
10210 if (! streq (relname
, "R_C6000_PREL31"))
10212 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
10220 /* This function currently only supports ARM and TI unwinders. */
10221 warn (_("Only TI and ARM unwinders are currently supported\n"));
10225 word
= (word
& ~ (uint64_t) 0x7fffffff) | (prelval
& 0x7fffffff);
10226 addr
->section
= sym
->st_shndx
;
10227 addr
->offset
= offset
;
10230 * sym_name
= sym
->st_name
;
10235 arm_sec
->next_rela
= rp
;
10240 static const char *tic6x_unwind_regnames
[16] =
10242 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
10243 "A14", "A13", "A12", "A11", "A10",
10244 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
10248 decode_tic6x_unwind_regmask (unsigned int mask
)
10252 for (i
= 12; mask
; mask
>>= 1, i
--)
10256 fputs (tic6x_unwind_regnames
[i
], stdout
);
10258 fputs (", ", stdout
);
10264 if (remaining == 0 && more_words) \
10266 data_offset += 4; \
10267 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
10268 data_offset, & word, & addr, NULL)) \
10274 #define GET_OP(OP) \
10279 (OP) = word >> 24; \
10284 printf (_("[Truncated opcode]\n")); \
10287 printf ("0x%02x ", OP)
10290 decode_arm_unwind_bytecode (Filedata
* filedata
,
10291 struct arm_unw_aux_info
* aux
,
10293 unsigned int remaining
,
10294 unsigned int more_words
,
10295 uint64_t data_offset
,
10296 Elf_Internal_Shdr
* data_sec
,
10297 struct arm_section
* data_arm_sec
)
10299 struct absaddr addr
;
10302 /* Decode the unwinding instructions. */
10305 unsigned int op
, op2
;
10308 if (remaining
== 0)
10314 printf (" 0x%02x ", op
);
10316 if ((op
& 0xc0) == 0x00)
10318 int offset
= ((op
& 0x3f) << 2) + 4;
10320 printf (" vsp = vsp + %d", offset
);
10322 else if ((op
& 0xc0) == 0x40)
10324 int offset
= ((op
& 0x3f) << 2) + 4;
10326 printf (" vsp = vsp - %d", offset
);
10328 else if ((op
& 0xf0) == 0x80)
10331 if (op
== 0x80 && op2
== 0)
10332 printf (_("Refuse to unwind"));
10335 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
10340 for (i
= 0; i
< 12; i
++)
10341 if (mask
& (1 << i
))
10347 printf ("r%d", 4 + i
);
10352 else if ((op
& 0xf0) == 0x90)
10354 if (op
== 0x9d || op
== 0x9f)
10355 printf (_(" [Reserved]"));
10357 printf (" vsp = r%d", op
& 0x0f);
10359 else if ((op
& 0xf0) == 0xa0)
10361 int end
= 4 + (op
& 0x07);
10366 for (i
= 4; i
<= end
; i
++)
10382 else if (op
== 0xb0)
10383 printf (_(" finish"));
10384 else if (op
== 0xb1)
10387 if (op2
== 0 || (op2
& 0xf0) != 0)
10388 printf (_("[Spare]"));
10391 unsigned int mask
= op2
& 0x0f;
10396 for (i
= 0; i
< 12; i
++)
10397 if (mask
& (1 << i
))
10408 else if (op
== 0xb2)
10410 unsigned char buf
[9];
10411 unsigned int i
, len
;
10414 for (i
= 0; i
< sizeof (buf
); i
++)
10417 if ((buf
[i
] & 0x80) == 0)
10420 if (i
== sizeof (buf
))
10422 error (_("corrupt change to vsp\n"));
10427 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
10428 assert (len
== i
+ 1);
10429 offset
= offset
* 4 + 0x204;
10430 printf ("vsp = vsp + %" PRId64
, offset
);
10433 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
10435 unsigned int first
, last
;
10441 first
= first
+ 16;
10442 printf ("pop {D%d", first
);
10444 printf ("-D%d", first
+ last
);
10447 else if (op
== 0xb4)
10448 printf (_(" pop {ra_auth_code}"));
10449 else if (op
== 0xb5)
10450 printf (_(" vsp as modifier for PAC validation"));
10451 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
10453 unsigned int count
= op
& 0x07;
10455 printf ("pop {D8");
10457 printf ("-D%d", 8 + count
);
10460 else if (op
>= 0xc0 && op
<= 0xc5)
10462 unsigned int count
= op
& 0x07;
10464 printf (" pop {wR10");
10466 printf ("-wR%d", 10 + count
);
10469 else if (op
== 0xc6)
10471 unsigned int first
, last
;
10476 printf ("pop {wR%d", first
);
10478 printf ("-wR%d", first
+ last
);
10481 else if (op
== 0xc7)
10484 if (op2
== 0 || (op2
& 0xf0) != 0)
10485 printf (_("[Spare]"));
10488 unsigned int mask
= op2
& 0x0f;
10493 for (i
= 0; i
< 4; i
++)
10494 if (mask
& (1 << i
))
10500 printf ("wCGR%d", i
);
10507 printf (_(" [unsupported opcode]"));
10518 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
10519 struct arm_unw_aux_info
* aux
,
10521 unsigned int remaining
,
10522 unsigned int more_words
,
10523 uint64_t data_offset
,
10524 Elf_Internal_Shdr
* data_sec
,
10525 struct arm_section
* data_arm_sec
)
10527 struct absaddr addr
;
10529 /* Decode the unwinding instructions. */
10532 unsigned int op
, op2
;
10535 if (remaining
== 0)
10541 printf (" 0x%02x ", op
);
10543 if ((op
& 0xc0) == 0x00)
10545 int offset
= ((op
& 0x3f) << 3) + 8;
10546 printf (" sp = sp + %d", offset
);
10548 else if ((op
& 0xc0) == 0x80)
10551 if (op
== 0x80 && op2
== 0)
10552 printf (_("Refuse to unwind"));
10555 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
10557 printf ("pop compact {");
10561 decode_tic6x_unwind_regmask (mask
);
10565 else if ((op
& 0xf0) == 0xc0)
10568 unsigned int nregs
;
10573 unsigned int offset
;
10577 /* Scan entire instruction first so that GET_OP output is not
10578 interleaved with disassembly. */
10580 for (i
= 0; nregs
< (op
& 0xf); i
++)
10586 regpos
[nregs
].offset
= i
* 2;
10587 regpos
[nregs
].reg
= reg
;
10594 regpos
[nregs
].offset
= i
* 2 + 1;
10595 regpos
[nregs
].reg
= reg
;
10600 printf (_("pop frame {"));
10603 printf (_("*corrupt* - no registers specified"));
10608 for (i
= i
* 2; i
> 0; i
--)
10610 if (regpos
[reg
].offset
== i
- 1)
10612 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
10619 fputs (name
, stdout
);
10627 else if (op
== 0xd0)
10628 printf (" MOV FP, SP");
10629 else if (op
== 0xd1)
10630 printf (" __c6xabi_pop_rts");
10631 else if (op
== 0xd2)
10633 unsigned char buf
[9];
10634 unsigned int i
, len
;
10637 for (i
= 0; i
< sizeof (buf
); i
++)
10640 if ((buf
[i
] & 0x80) == 0)
10643 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
10644 if (i
== sizeof (buf
))
10646 warn (_("Corrupt stack pointer adjustment detected\n"));
10650 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
10651 assert (len
== i
+ 1);
10652 offset
= offset
* 8 + 0x408;
10653 printf (_("sp = sp + %" PRId64
), offset
);
10655 else if ((op
& 0xf0) == 0xe0)
10657 if ((op
& 0x0f) == 7)
10658 printf (" RETURN");
10660 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
10664 printf (_(" [unsupported opcode]"));
10673 arm_expand_prel31 (Filedata
* filedata
, uint64_t word
, uint64_t where
)
10677 offset
= word
& 0x7fffffff;
10678 if (offset
& 0x40000000)
10679 offset
|= ~ (uint64_t) 0x7fffffff;
10681 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
10684 return offset
+ where
;
10688 decode_arm_unwind (Filedata
* filedata
,
10689 struct arm_unw_aux_info
* aux
,
10691 unsigned int remaining
,
10692 uint64_t data_offset
,
10693 Elf_Internal_Shdr
* data_sec
,
10694 struct arm_section
* data_arm_sec
)
10697 unsigned int more_words
= 0;
10698 struct absaddr addr
;
10699 uint64_t sym_name
= (uint64_t) -1;
10702 if (remaining
== 0)
10704 /* Fetch the first word.
10705 Note - when decoding an object file the address extracted
10706 here will always be 0. So we also pass in the sym_name
10707 parameter so that we can find the symbol associated with
10708 the personality routine. */
10709 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
10710 & word
, & addr
, & sym_name
))
10717 addr
.section
= SHN_UNDEF
;
10721 if ((word
& 0x80000000) == 0)
10723 /* Expand prel31 for personality routine. */
10725 const char *procname
;
10727 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
10728 printf (_(" Personality routine: "));
10730 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
10731 && sym_name
!= (uint64_t) -1 && sym_name
< aux
->strtab_size
)
10733 procname
= aux
->strtab
+ sym_name
;
10734 print_vma (fn
, PREFIX_HEX
);
10737 fputs (" <", stdout
);
10738 fputs (procname
, stdout
);
10739 fputc ('>', stdout
);
10743 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
10744 fputc ('\n', stdout
);
10746 /* The GCC personality routines use the standard compact
10747 encoding, starting with one byte giving the number of
10749 if (procname
!= NULL
10750 && (startswith (procname
, "__gcc_personality_v0")
10751 || startswith (procname
, "__gxx_personality_v0")
10752 || startswith (procname
, "__gcj_personality_v0")
10753 || startswith (procname
, "__gnu_objc_personality_v0")))
10760 printf (_(" [Truncated data]\n"));
10763 more_words
= word
>> 24;
10773 /* ARM EHABI Section 6.3:
10775 An exception-handling table entry for the compact model looks like:
10777 31 30-28 27-24 23-0
10778 -- ----- ----- ----
10779 1 0 index Data for personalityRoutine[index] */
10781 if (filedata
->file_header
.e_machine
== EM_ARM
10782 && (word
& 0x70000000))
10784 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
10788 per_index
= (word
>> 24) & 0x7f;
10789 printf (_(" Compact model index: %d\n"), per_index
);
10790 if (per_index
== 0)
10796 else if (per_index
< 3)
10798 more_words
= (word
>> 16) & 0xff;
10804 switch (filedata
->file_header
.e_machine
)
10809 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
10810 data_offset
, data_sec
, data_arm_sec
))
10815 warn (_("Unknown ARM compact model index encountered\n"));
10816 printf (_(" [reserved]\n"));
10824 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
10825 data_offset
, data_sec
, data_arm_sec
))
10828 else if (per_index
< 5)
10830 if (((word
>> 17) & 0x7f) == 0x7f)
10831 printf (_(" Restore stack from frame pointer\n"));
10833 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
10834 printf (_(" Registers restored: "));
10835 if (per_index
== 4)
10836 printf (" (compact) ");
10837 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
10839 printf (_(" Return register: %s\n"),
10840 tic6x_unwind_regnames
[word
& 0xf]);
10843 printf (_(" [reserved (%d)]\n"), per_index
);
10847 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
10848 filedata
->file_header
.e_machine
);
10852 /* Decode the descriptors. Not implemented. */
10858 dump_arm_unwind (Filedata
* filedata
,
10859 struct arm_unw_aux_info
* aux
,
10860 Elf_Internal_Shdr
* exidx_sec
)
10862 struct arm_section exidx_arm_sec
, extab_arm_sec
;
10863 unsigned int i
, exidx_len
;
10867 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
10868 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
10869 exidx_len
= exidx_sec
->sh_size
/ 8;
10871 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
10872 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
10873 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
10874 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
10875 aux
->nfuns
= nfuns
;
10876 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
10878 for (i
= 0; i
< exidx_len
; i
++)
10880 unsigned int exidx_fn
, exidx_entry
;
10881 struct absaddr fn_addr
, entry_addr
;
10884 fputc ('\n', stdout
);
10886 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
10887 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
10888 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
10889 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
10891 free (aux
->funtab
);
10892 arm_free_section (& exidx_arm_sec
);
10893 arm_free_section (& extab_arm_sec
);
10897 /* ARM EHABI, Section 5:
10898 An index table entry consists of 2 words.
10899 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
10900 if (exidx_fn
& 0x80000000)
10902 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
10906 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
10908 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
10909 fputs (": ", stdout
);
10911 if (exidx_entry
== 1)
10913 print_vma (exidx_entry
, PREFIX_HEX
);
10914 fputs (" [cantunwind]\n", stdout
);
10916 else if (exidx_entry
& 0x80000000)
10918 print_vma (exidx_entry
, PREFIX_HEX
);
10919 fputc ('\n', stdout
);
10920 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
10924 uint64_t table
, table_offset
= 0;
10925 Elf_Internal_Shdr
*table_sec
;
10927 fputs ("@", stdout
);
10928 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
10929 print_vma (table
, PREFIX_HEX
);
10932 /* Locate the matching .ARM.extab. */
10933 if (entry_addr
.section
!= SHN_UNDEF
10934 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
10936 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
10937 table_offset
= entry_addr
.offset
;
10939 if (table_offset
> table_sec
->sh_size
)
10941 warn (_("Unwind entry contains corrupt offset (%#" PRIx64
") into section %s\n"),
10943 printable_section_name (filedata
, table_sec
));
10950 table_sec
= find_section_by_address (filedata
, table
);
10951 if (table_sec
!= NULL
)
10952 table_offset
= table
- table_sec
->sh_addr
;
10955 if (table_sec
== NULL
)
10957 warn (_("Could not locate .ARM.extab section containing %#" PRIx64
".\n"),
10963 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
10971 free (aux
->funtab
);
10972 arm_free_section (&exidx_arm_sec
);
10973 arm_free_section (&extab_arm_sec
);
10978 /* Used for both ARM and C6X unwinding tables. */
10981 arm_process_unwind (Filedata
* filedata
)
10983 struct arm_unw_aux_info aux
;
10984 Elf_Internal_Shdr
*unwsec
= NULL
;
10985 Elf_Internal_Shdr
*sec
;
10987 unsigned int sec_type
;
10990 switch (filedata
->file_header
.e_machine
)
10993 sec_type
= SHT_ARM_EXIDX
;
10997 sec_type
= SHT_C6000_UNWIND
;
11001 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
11002 filedata
->file_header
.e_machine
);
11006 if (filedata
->string_table
== NULL
)
11009 memset (& aux
, 0, sizeof (aux
));
11010 aux
.filedata
= filedata
;
11012 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
11014 if (sec
->sh_type
== SHT_SYMTAB
)
11018 error (_("Multiple symbol tables encountered\n"));
11024 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
11025 &aux
.strtab
, &aux
.strtab_size
))
11028 else if (sec
->sh_type
== sec_type
)
11032 if (unwsec
== NULL
)
11033 printf (_("\nThere are no unwind sections in this file.\n"));
11035 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
11037 if (sec
->sh_type
== sec_type
)
11039 uint64_t num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
11040 printf (ngettext ("\nUnwind section '%s' at offset %#" PRIx64
" "
11041 "contains %" PRIu64
" entry:\n",
11042 "\nUnwind section '%s' at offset %#" PRIx64
" "
11043 "contains %" PRIu64
" entries:\n",
11045 printable_section_name (filedata
, sec
),
11049 if (! dump_arm_unwind (filedata
, &aux
, sec
))
11055 free ((char *) aux
.strtab
);
11061 no_processor_specific_unwind (Filedata
* filedata ATTRIBUTE_UNUSED
)
11063 printf (_("No processor specific unwind information to decode\n"));
11068 process_unwind (Filedata
* filedata
)
11070 struct unwind_handler
11072 unsigned int machtype
;
11073 bool (* handler
)(Filedata
*);
11076 { EM_ARM
, arm_process_unwind
},
11077 { EM_IA_64
, ia64_process_unwind
},
11078 { EM_PARISC
, hppa_process_unwind
},
11079 { EM_TI_C6000
, arm_process_unwind
},
11080 { EM_386
, no_processor_specific_unwind
},
11081 { EM_X86_64
, no_processor_specific_unwind
},
11089 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
11090 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
11091 return handlers
[i
].handler (filedata
);
11093 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
11094 get_machine_name (filedata
->file_header
.e_machine
));
11099 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
11101 switch (entry
->d_tag
)
11103 case DT_AARCH64_BTI_PLT
:
11104 case DT_AARCH64_PAC_PLT
:
11107 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
11114 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
11116 switch (entry
->d_tag
)
11118 case DT_MIPS_FLAGS
:
11119 if (entry
->d_un
.d_val
== 0)
11120 printf (_("NONE"));
11123 static const char * opts
[] =
11125 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
11126 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
11127 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
11128 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
11134 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
11135 if (entry
->d_un
.d_val
& (1 << cnt
))
11137 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
11143 case DT_MIPS_IVERSION
:
11144 if (valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
11145 printf (_("Interface Version: %s"),
11146 get_dynamic_name (filedata
, entry
->d_un
.d_val
));
11148 printf (_("Interface Version: <corrupt: %" PRIx64
">"),
11149 entry
->d_un
.d_ptr
);
11152 case DT_MIPS_TIME_STAMP
:
11156 time_t atime
= entry
->d_un
.d_val
;
11158 tmp
= gmtime (&atime
);
11159 /* PR 17531: file: 6accc532. */
11161 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
11163 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
11164 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11165 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11166 printf (_("Time Stamp: %s"), timebuf
);
11170 case DT_MIPS_RLD_VERSION
:
11171 case DT_MIPS_LOCAL_GOTNO
:
11172 case DT_MIPS_CONFLICTNO
:
11173 case DT_MIPS_LIBLISTNO
:
11174 case DT_MIPS_SYMTABNO
:
11175 case DT_MIPS_UNREFEXTNO
:
11176 case DT_MIPS_HIPAGENO
:
11177 case DT_MIPS_DELTA_CLASS_NO
:
11178 case DT_MIPS_DELTA_INSTANCE_NO
:
11179 case DT_MIPS_DELTA_RELOC_NO
:
11180 case DT_MIPS_DELTA_SYM_NO
:
11181 case DT_MIPS_DELTA_CLASSSYM_NO
:
11182 case DT_MIPS_COMPACT_SIZE
:
11183 print_vma (entry
->d_un
.d_val
, DEC
);
11186 case DT_MIPS_XHASH
:
11187 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
11188 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11189 /* Falls through. */
11192 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
11198 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
11200 switch (entry
->d_tag
)
11202 case DT_HP_DLD_FLAGS
:
11211 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
11212 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
11213 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
11214 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
11215 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
11216 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
11217 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
11218 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
11219 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
11220 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
11221 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
11222 { DT_HP_GST
, "HP_GST" },
11223 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
11224 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
11225 { DT_HP_NODELETE
, "HP_NODELETE" },
11226 { DT_HP_GROUP
, "HP_GROUP" },
11227 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
11231 uint64_t val
= entry
->d_un
.d_val
;
11233 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
11234 if (val
& flags
[cnt
].bit
)
11238 fputs (flags
[cnt
].str
, stdout
);
11240 val
^= flags
[cnt
].bit
;
11243 if (val
!= 0 || first
)
11247 print_vma (val
, HEX
);
11253 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
11259 /* VMS vs Unix time offset and factor. */
11261 #define VMS_EPOCH_OFFSET 35067168000000000LL
11262 #define VMS_GRANULARITY_FACTOR 10000000
11264 #define INT64_MIN (-9223372036854775807LL - 1)
11267 /* Display a VMS time in a human readable format. */
11270 print_vms_time (int64_t vmstime
)
11272 struct tm
*tm
= NULL
;
11275 if (vmstime
>= INT64_MIN
+ VMS_EPOCH_OFFSET
)
11277 vmstime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
11279 if (unxtime
== vmstime
)
11280 tm
= gmtime (&unxtime
);
11283 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
11284 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
11285 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
11289 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
11291 switch (entry
->d_tag
)
11293 case DT_IA_64_PLT_RESERVE
:
11294 /* First 3 slots reserved. */
11295 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
11297 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
11300 case DT_IA_64_VMS_LINKTIME
:
11301 print_vms_time (entry
->d_un
.d_val
);
11304 case DT_IA_64_VMS_LNKFLAGS
:
11305 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
11306 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
11307 printf (" CALL_DEBUG");
11308 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
11309 printf (" NOP0BUFS");
11310 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
11311 printf (" P0IMAGE");
11312 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
11313 printf (" MKTHREADS");
11314 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
11315 printf (" UPCALLS");
11316 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
11317 printf (" IMGSTA");
11318 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
11319 printf (" INITIALIZE");
11320 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
11322 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
11323 printf (" EXE_INIT");
11324 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
11325 printf (" TBK_IN_IMG");
11326 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
11327 printf (" DBG_IN_IMG");
11328 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
11329 printf (" TBK_IN_DSF");
11330 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
11331 printf (" DBG_IN_DSF");
11332 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
11333 printf (" SIGNATURES");
11334 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
11335 printf (" REL_SEG_OFF");
11339 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
11346 get_32bit_dynamic_section (Filedata
* filedata
)
11348 Elf32_External_Dyn
* edyn
;
11349 Elf32_External_Dyn
* ext
;
11350 Elf_Internal_Dyn
* entry
;
11352 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
11353 filedata
->dynamic_addr
, 1,
11354 filedata
->dynamic_size
,
11355 _("dynamic section"));
11359 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
11360 might not have the luxury of section headers. Look for the DT_NULL
11361 terminator to determine the number of entries. */
11362 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
11363 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
11366 filedata
->dynamic_nent
++;
11367 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
11371 filedata
->dynamic_section
11372 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
11373 if (filedata
->dynamic_section
== NULL
)
11375 error (_("Out of memory allocating space for %" PRIu64
" dynamic entries\n"),
11376 filedata
->dynamic_nent
);
11381 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
11382 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11385 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
11386 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
11395 get_64bit_dynamic_section (Filedata
* filedata
)
11397 Elf64_External_Dyn
* edyn
;
11398 Elf64_External_Dyn
* ext
;
11399 Elf_Internal_Dyn
* entry
;
11401 /* Read in the data. */
11402 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
11403 filedata
->dynamic_addr
, 1,
11404 filedata
->dynamic_size
,
11405 _("dynamic section"));
11409 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
11410 might not have the luxury of section headers. Look for the DT_NULL
11411 terminator to determine the number of entries. */
11412 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
11413 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
11414 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
11417 filedata
->dynamic_nent
++;
11418 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
11422 filedata
->dynamic_section
11423 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
11424 if (filedata
->dynamic_section
== NULL
)
11426 error (_("Out of memory allocating space for %" PRIu64
" dynamic entries\n"),
11427 filedata
->dynamic_nent
);
11432 /* Convert from external to internal formats. */
11433 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
11434 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11437 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
11438 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
11447 get_dynamic_section (Filedata
*filedata
)
11449 if (filedata
->dynamic_section
)
11453 return get_32bit_dynamic_section (filedata
);
11455 return get_64bit_dynamic_section (filedata
);
11459 print_dynamic_flags (uint64_t flags
)
11467 flag
= flags
& - flags
;
11473 putc (' ', stdout
);
11477 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
11478 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
11479 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
11480 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
11481 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
11482 default: fputs (_("unknown"), stdout
); break;
11489 get_dynamic_data (Filedata
* filedata
, uint64_t number
, unsigned int ent_size
)
11491 unsigned char * e_data
;
11494 /* If size_t is smaller than uint64_t, eg because you are building
11495 on a 32-bit host, then make sure that when number is cast to
11496 size_t no information is lost. */
11497 if ((size_t) number
!= number
11498 || ent_size
* number
/ ent_size
!= number
)
11500 error (_("Size overflow prevents reading %" PRIu64
11501 " elements of size %u\n"),
11506 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
11507 attempting to allocate memory when the read is bound to fail. */
11508 if (ent_size
* number
> filedata
->file_size
)
11510 error (_("Invalid number of dynamic entries: %" PRIu64
"\n"),
11515 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11516 if (e_data
== NULL
)
11518 error (_("Out of memory reading %" PRIu64
" dynamic entries\n"),
11523 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11525 error (_("Unable to read in %" PRIu64
" bytes of dynamic data\n"),
11526 number
* ent_size
);
11531 i_data
= (uint64_t *) cmalloc ((size_t) number
, sizeof (*i_data
));
11532 if (i_data
== NULL
)
11534 error (_("Out of memory allocating space for %" PRIu64
" dynamic entries\n"),
11541 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11549 get_num_dynamic_syms (Filedata
* filedata
)
11551 uint64_t num_of_syms
= 0;
11553 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
11554 return num_of_syms
;
11556 if (filedata
->dynamic_info
[DT_HASH
])
11558 unsigned char nb
[8];
11559 unsigned char nc
[8];
11560 unsigned int hash_ent_size
= 4;
11562 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11563 || filedata
->file_header
.e_machine
== EM_S390
11564 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11565 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11568 if (fseek64 (filedata
->handle
,
11569 (filedata
->archive_file_offset
11570 + offset_from_vma (filedata
,
11571 filedata
->dynamic_info
[DT_HASH
],
11572 sizeof nb
+ sizeof nc
)),
11575 error (_("Unable to seek to start of dynamic information\n"));
11579 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11581 error (_("Failed to read in number of buckets\n"));
11585 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11587 error (_("Failed to read in number of chains\n"));
11591 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
11592 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
11594 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
11596 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
11598 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
11601 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
11602 num_of_syms
= filedata
->nchains
;
11605 if (num_of_syms
== 0)
11607 free (filedata
->buckets
);
11608 filedata
->buckets
= NULL
;
11609 free (filedata
->chains
);
11610 filedata
->chains
= NULL
;
11611 filedata
->nbuckets
= 0;
11615 if (filedata
->dynamic_info_DT_GNU_HASH
)
11617 unsigned char nb
[16];
11618 uint64_t i
, maxchain
= 0xffffffff, bitmaskwords
;
11619 uint64_t buckets_vma
;
11622 if (fseek64 (filedata
->handle
,
11623 (filedata
->archive_file_offset
11624 + offset_from_vma (filedata
,
11625 filedata
->dynamic_info_DT_GNU_HASH
,
11629 error (_("Unable to seek to start of dynamic information\n"));
11633 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11635 error (_("Failed to read in number of buckets\n"));
11639 filedata
->ngnubuckets
= byte_get (nb
, 4);
11640 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
11641 bitmaskwords
= byte_get (nb
+ 8, 4);
11642 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
11644 buckets_vma
+= bitmaskwords
* 4;
11646 buckets_vma
+= bitmaskwords
* 8;
11648 if (fseek64 (filedata
->handle
,
11649 (filedata
->archive_file_offset
11650 + offset_from_vma (filedata
, buckets_vma
, 4)),
11653 error (_("Unable to seek to start of dynamic information\n"));
11657 filedata
->gnubuckets
11658 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
11660 if (filedata
->gnubuckets
== NULL
)
11663 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
11664 if (filedata
->gnubuckets
[i
] != 0)
11666 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
11669 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
11670 maxchain
= filedata
->gnubuckets
[i
];
11673 if (maxchain
== 0xffffffff)
11676 maxchain
-= filedata
->gnusymidx
;
11678 if (fseek64 (filedata
->handle
,
11679 (filedata
->archive_file_offset
11680 + offset_from_vma (filedata
,
11681 buckets_vma
+ 4 * (filedata
->ngnubuckets
11686 error (_("Unable to seek to start of dynamic information\n"));
11692 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11694 error (_("Failed to determine last chain length\n"));
11698 if (maxchain
+ 1 == 0)
11703 while ((byte_get (nb
, 4) & 1) == 0);
11705 if (fseek64 (filedata
->handle
,
11706 (filedata
->archive_file_offset
11707 + offset_from_vma (filedata
, (buckets_vma
11708 + 4 * filedata
->ngnubuckets
),
11712 error (_("Unable to seek to start of dynamic information\n"));
11716 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11717 filedata
->ngnuchains
= maxchain
;
11719 if (filedata
->gnuchains
== NULL
)
11722 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
11724 if (fseek64 (filedata
->handle
,
11725 (filedata
->archive_file_offset
11726 + offset_from_vma (filedata
, (buckets_vma
11727 + 4 * (filedata
->ngnubuckets
11731 error (_("Unable to seek to start of dynamic information\n"));
11735 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
11736 if (filedata
->mipsxlat
== NULL
)
11740 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
11741 if (filedata
->gnubuckets
[hn
] != 0)
11743 uint64_t si
= filedata
->gnubuckets
[hn
];
11744 uint64_t off
= si
- filedata
->gnusymidx
;
11748 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
11750 if (off
< filedata
->ngnuchains
11751 && filedata
->mipsxlat
[off
] >= num_of_syms
)
11752 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
11756 if (si
>= num_of_syms
)
11757 num_of_syms
= si
+ 1;
11761 while (off
< filedata
->ngnuchains
11762 && (filedata
->gnuchains
[off
++] & 1) == 0);
11765 if (num_of_syms
== 0)
11768 free (filedata
->mipsxlat
);
11769 filedata
->mipsxlat
= NULL
;
11770 free (filedata
->gnuchains
);
11771 filedata
->gnuchains
= NULL
;
11772 free (filedata
->gnubuckets
);
11773 filedata
->gnubuckets
= NULL
;
11774 filedata
->ngnubuckets
= 0;
11775 filedata
->ngnuchains
= 0;
11779 return num_of_syms
;
11782 /* Parse and display the contents of the dynamic section. */
11785 process_dynamic_section (Filedata
* filedata
)
11787 Elf_Internal_Dyn
* entry
;
11789 if (filedata
->dynamic_size
<= 1)
11793 if (filedata
->is_separate
)
11794 printf (_("\nThere is no dynamic section in linked file '%s'.\n"),
11795 filedata
->file_name
);
11797 printf (_("\nThere is no dynamic section in this file.\n"));
11803 if (!get_dynamic_section (filedata
))
11806 /* Find the appropriate symbol table. */
11807 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
11809 uint64_t num_of_syms
;
11811 for (entry
= filedata
->dynamic_section
;
11812 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11814 if (entry
->d_tag
== DT_SYMTAB
)
11815 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
11816 else if (entry
->d_tag
== DT_SYMENT
)
11817 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
11818 else if (entry
->d_tag
== DT_HASH
)
11819 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
11820 else if (entry
->d_tag
== DT_GNU_HASH
)
11821 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11822 else if ((filedata
->file_header
.e_machine
== EM_MIPS
11823 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
11824 && entry
->d_tag
== DT_MIPS_XHASH
)
11826 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
11827 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11830 num_of_syms
= get_num_dynamic_syms (filedata
);
11832 if (num_of_syms
!= 0
11833 && filedata
->dynamic_symbols
== NULL
11834 && filedata
->dynamic_info
[DT_SYMTAB
]
11835 && filedata
->dynamic_info
[DT_SYMENT
])
11837 Elf_Internal_Phdr
*seg
;
11838 uint64_t vma
= filedata
->dynamic_info
[DT_SYMTAB
];
11840 if (! get_program_headers (filedata
))
11842 error (_("Cannot interpret virtual addresses "
11843 "without program headers.\n"));
11847 for (seg
= filedata
->program_headers
;
11848 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
11851 if (seg
->p_type
!= PT_LOAD
)
11854 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
11856 /* See PR 21379 for a reproducer. */
11857 error (_("Invalid PT_LOAD entry\n"));
11861 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
11862 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
11864 /* Since we do not know how big the symbol table is,
11865 we default to reading in up to the end of PT_LOAD
11866 segment and processing that. This is overkill, I
11867 know, but it should work. */
11868 Elf_Internal_Shdr section
;
11869 section
.sh_offset
= (vma
- seg
->p_vaddr
11871 section
.sh_size
= (num_of_syms
11872 * filedata
->dynamic_info
[DT_SYMENT
]);
11873 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
11876 && filedata
->dynamic_symtab_section
!= NULL
11877 && ((filedata
->dynamic_symtab_section
->sh_offset
11878 != section
.sh_offset
)
11879 || (filedata
->dynamic_symtab_section
->sh_size
11880 != section
.sh_size
)
11881 || (filedata
->dynamic_symtab_section
->sh_entsize
11882 != section
.sh_entsize
)))
11884 the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
11886 section
.sh_name
= filedata
->string_table_length
;
11887 filedata
->dynamic_symbols
11888 = get_elf_symbols (filedata
, §ion
,
11889 &filedata
->num_dynamic_syms
);
11890 if (filedata
->dynamic_symbols
== NULL
11891 || filedata
->num_dynamic_syms
!= num_of_syms
)
11893 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
11902 /* Similarly find a string table. */
11903 if (filedata
->dynamic_strings
== NULL
)
11904 for (entry
= filedata
->dynamic_section
;
11905 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11908 if (entry
->d_tag
== DT_STRTAB
)
11909 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
11911 if (entry
->d_tag
== DT_STRSZ
)
11912 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
11914 if (filedata
->dynamic_info
[DT_STRTAB
]
11915 && filedata
->dynamic_info
[DT_STRSZ
])
11918 uint64_t str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
11920 offset
= offset_from_vma (filedata
,
11921 filedata
->dynamic_info
[DT_STRTAB
],
11924 && filedata
->dynamic_strtab_section
11925 && ((filedata
->dynamic_strtab_section
->sh_offset
11926 != (file_ptr
) offset
)
11927 || (filedata
->dynamic_strtab_section
->sh_size
11930 the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
11932 filedata
->dynamic_strings
11933 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
11934 _("dynamic string table"));
11935 if (filedata
->dynamic_strings
== NULL
)
11937 error (_("Corrupt DT_STRTAB dynamic entry\n"));
11941 filedata
->dynamic_strings_length
= str_tab_len
;
11946 /* And find the syminfo section if available. */
11947 if (filedata
->dynamic_syminfo
== NULL
)
11949 uint64_t syminsz
= 0;
11951 for (entry
= filedata
->dynamic_section
;
11952 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11955 if (entry
->d_tag
== DT_SYMINENT
)
11957 /* Note: these braces are necessary to avoid a syntax
11958 error from the SunOS4 C compiler. */
11959 /* PR binutils/17531: A corrupt file can trigger this test.
11960 So do not use an assert, instead generate an error message. */
11961 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
11962 error (_("Bad value (%d) for SYMINENT entry\n"),
11963 (int) entry
->d_un
.d_val
);
11965 else if (entry
->d_tag
== DT_SYMINSZ
)
11966 syminsz
= entry
->d_un
.d_val
;
11967 else if (entry
->d_tag
== DT_SYMINFO
)
11968 filedata
->dynamic_syminfo_offset
11969 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
11972 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
11974 Elf_External_Syminfo
* extsyminfo
;
11975 Elf_External_Syminfo
* extsym
;
11976 Elf_Internal_Syminfo
* syminfo
;
11978 /* There is a syminfo section. Read the data. */
11979 extsyminfo
= (Elf_External_Syminfo
*)
11980 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
11981 1, syminsz
, _("symbol information"));
11985 if (filedata
->dynamic_syminfo
!= NULL
)
11987 error (_("Multiple dynamic symbol information sections found\n"));
11988 free (filedata
->dynamic_syminfo
);
11990 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
11991 if (filedata
->dynamic_syminfo
== NULL
)
11993 error (_("Out of memory allocating %" PRIu64
11994 " bytes for dynamic symbol info\n"),
11999 filedata
->dynamic_syminfo_nent
12000 = syminsz
/ sizeof (Elf_External_Syminfo
);
12001 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
12002 syminfo
< (filedata
->dynamic_syminfo
12003 + filedata
->dynamic_syminfo_nent
);
12004 ++syminfo
, ++extsym
)
12006 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
12007 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
12014 if (do_dynamic
&& filedata
->dynamic_addr
)
12016 if (filedata
->is_separate
)
12017 printf (ngettext ("\nIn linked file '%s' the dynamic section at offset %#" PRIx64
" contains %" PRIu64
" entry:\n",
12018 "\nIn linked file '%s' the dynamic section at offset %#" PRIx64
" contains %" PRIu64
" entries:\n",
12019 filedata
->dynamic_nent
),
12020 filedata
->file_name
,
12021 filedata
->dynamic_addr
,
12022 filedata
->dynamic_nent
);
12024 printf (ngettext ("\nDynamic section at offset %#" PRIx64
" contains %" PRIu64
" entry:\n",
12025 "\nDynamic section at offset %#" PRIx64
" contains %" PRIu64
" entries:\n",
12026 filedata
->dynamic_nent
),
12027 filedata
->dynamic_addr
,
12028 filedata
->dynamic_nent
);
12031 printf (_(" Tag Type Name/Value\n"));
12033 for (entry
= filedata
->dynamic_section
;
12034 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
12039 const char * dtype
;
12042 print_vma (entry
->d_tag
, FULL_HEX
);
12043 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
12044 printf (" (%s)%*s", dtype
,
12045 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
12048 switch (entry
->d_tag
)
12052 print_dynamic_flags (entry
->d_un
.d_val
);
12062 switch (entry
->d_tag
)
12065 printf (_("Auxiliary library"));
12069 printf (_("Filter library"));
12073 printf (_("Configuration file"));
12077 printf (_("Dependency audit library"));
12081 printf (_("Audit library"));
12085 if (valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
12086 printf (": [%s]\n",
12087 get_dynamic_name (filedata
, entry
->d_un
.d_val
));
12091 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12100 printf (_("Flags:"));
12102 if (entry
->d_un
.d_val
== 0)
12103 printf (_(" None\n"));
12106 uint64_t val
= entry
->d_un
.d_val
;
12108 if (val
& DTF_1_PARINIT
)
12110 printf (" PARINIT");
12111 val
^= DTF_1_PARINIT
;
12113 if (val
& DTF_1_CONFEXP
)
12115 printf (" CONFEXP");
12116 val
^= DTF_1_CONFEXP
;
12119 printf (" %" PRIx64
, val
);
12128 printf (_("Flags:"));
12130 if (entry
->d_un
.d_val
== 0)
12131 printf (_(" None\n"));
12134 uint64_t val
= entry
->d_un
.d_val
;
12136 if (val
& DF_P1_LAZYLOAD
)
12138 printf (" LAZYLOAD");
12139 val
^= DF_P1_LAZYLOAD
;
12141 if (val
& DF_P1_GROUPPERM
)
12143 printf (" GROUPPERM");
12144 val
^= DF_P1_GROUPPERM
;
12147 printf (" %" PRIx64
, val
);
12156 printf (_("Flags:"));
12157 if (entry
->d_un
.d_val
== 0)
12158 printf (_(" None\n"));
12161 uint64_t val
= entry
->d_un
.d_val
;
12163 if (val
& DF_1_NOW
)
12168 if (val
& DF_1_GLOBAL
)
12170 printf (" GLOBAL");
12171 val
^= DF_1_GLOBAL
;
12173 if (val
& DF_1_GROUP
)
12178 if (val
& DF_1_NODELETE
)
12180 printf (" NODELETE");
12181 val
^= DF_1_NODELETE
;
12183 if (val
& DF_1_LOADFLTR
)
12185 printf (" LOADFLTR");
12186 val
^= DF_1_LOADFLTR
;
12188 if (val
& DF_1_INITFIRST
)
12190 printf (" INITFIRST");
12191 val
^= DF_1_INITFIRST
;
12193 if (val
& DF_1_NOOPEN
)
12195 printf (" NOOPEN");
12196 val
^= DF_1_NOOPEN
;
12198 if (val
& DF_1_ORIGIN
)
12200 printf (" ORIGIN");
12201 val
^= DF_1_ORIGIN
;
12203 if (val
& DF_1_DIRECT
)
12205 printf (" DIRECT");
12206 val
^= DF_1_DIRECT
;
12208 if (val
& DF_1_TRANS
)
12213 if (val
& DF_1_INTERPOSE
)
12215 printf (" INTERPOSE");
12216 val
^= DF_1_INTERPOSE
;
12218 if (val
& DF_1_NODEFLIB
)
12220 printf (" NODEFLIB");
12221 val
^= DF_1_NODEFLIB
;
12223 if (val
& DF_1_NODUMP
)
12225 printf (" NODUMP");
12226 val
^= DF_1_NODUMP
;
12228 if (val
& DF_1_CONFALT
)
12230 printf (" CONFALT");
12231 val
^= DF_1_CONFALT
;
12233 if (val
& DF_1_ENDFILTEE
)
12235 printf (" ENDFILTEE");
12236 val
^= DF_1_ENDFILTEE
;
12238 if (val
& DF_1_DISPRELDNE
)
12240 printf (" DISPRELDNE");
12241 val
^= DF_1_DISPRELDNE
;
12243 if (val
& DF_1_DISPRELPND
)
12245 printf (" DISPRELPND");
12246 val
^= DF_1_DISPRELPND
;
12248 if (val
& DF_1_NODIRECT
)
12250 printf (" NODIRECT");
12251 val
^= DF_1_NODIRECT
;
12253 if (val
& DF_1_IGNMULDEF
)
12255 printf (" IGNMULDEF");
12256 val
^= DF_1_IGNMULDEF
;
12258 if (val
& DF_1_NOKSYMS
)
12260 printf (" NOKSYMS");
12261 val
^= DF_1_NOKSYMS
;
12263 if (val
& DF_1_NOHDR
)
12268 if (val
& DF_1_EDITED
)
12270 printf (" EDITED");
12271 val
^= DF_1_EDITED
;
12273 if (val
& DF_1_NORELOC
)
12275 printf (" NORELOC");
12276 val
^= DF_1_NORELOC
;
12278 if (val
& DF_1_SYMINTPOSE
)
12280 printf (" SYMINTPOSE");
12281 val
^= DF_1_SYMINTPOSE
;
12283 if (val
& DF_1_GLOBAUDIT
)
12285 printf (" GLOBAUDIT");
12286 val
^= DF_1_GLOBAUDIT
;
12288 if (val
& DF_1_SINGLETON
)
12290 printf (" SINGLETON");
12291 val
^= DF_1_SINGLETON
;
12293 if (val
& DF_1_STUB
)
12298 if (val
& DF_1_PIE
)
12303 if (val
& DF_1_KMOD
)
12308 if (val
& DF_1_WEAKFILTER
)
12310 printf (" WEAKFILTER");
12311 val
^= DF_1_WEAKFILTER
;
12313 if (val
& DF_1_NOCOMMON
)
12315 printf (" NOCOMMON");
12316 val
^= DF_1_NOCOMMON
;
12319 printf (" %" PRIx64
, val
);
12326 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
12328 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
12349 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
12355 if (valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
12356 name
= get_dynamic_name (filedata
, entry
->d_un
.d_val
);
12362 switch (entry
->d_tag
)
12365 printf (_("Shared library: [%s]"), name
);
12367 if (filedata
->program_interpreter
12368 && streq (name
, filedata
->program_interpreter
))
12369 printf (_(" program interpreter"));
12373 printf (_("Library soname: [%s]"), name
);
12377 printf (_("Library rpath: [%s]"), name
);
12381 printf (_("Library runpath: [%s]"), name
);
12385 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12390 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12405 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
12406 /* Fall through. */
12410 case DT_PREINIT_ARRAYSZ
:
12411 case DT_INIT_ARRAYSZ
:
12412 case DT_FINI_ARRAYSZ
:
12413 case DT_GNU_CONFLICTSZ
:
12414 case DT_GNU_LIBLISTSZ
:
12417 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
12418 printf (_(" (bytes)\n"));
12423 case DT_VERNEEDNUM
:
12428 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
12437 case DT_INIT_ARRAY
:
12438 case DT_FINI_ARRAY
:
12441 if (entry
->d_tag
== DT_USED
12442 && valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
12445 = get_dynamic_name (filedata
, entry
->d_un
.d_val
);
12449 printf (_("Not needed object: [%s]\n"), name
);
12454 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12460 /* The value of this entry is ignored. */
12465 case DT_GNU_PRELINKED
:
12469 time_t atime
= entry
->d_un
.d_val
;
12471 tmp
= gmtime (&atime
);
12472 /* PR 17533 file: 041-1244816-0.004. */
12474 printf (_("<corrupt time val: %" PRIx64
),
12477 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
12478 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
12479 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
12485 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
12488 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12493 case DT_GNU_FLAGS_1
:
12496 printf (_("Flags:"));
12497 if (entry
->d_un
.d_val
== 0)
12498 printf (_(" None\n"));
12501 uint64_t val
= entry
->d_un
.d_val
;
12503 if (val
& DF_GNU_1_UNIQUE
)
12505 printf (" UNIQUE");
12506 val
^= DF_GNU_1_UNIQUE
;
12509 printf (" %" PRIx64
, val
);
12516 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
12517 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
12518 = entry
->d_un
.d_val
;
12522 switch (filedata
->file_header
.e_machine
)
12525 dynamic_section_aarch64_val (entry
);
12528 case EM_MIPS_RS3_LE
:
12529 dynamic_section_mips_val (filedata
, entry
);
12532 dynamic_section_parisc_val (entry
);
12535 dynamic_section_ia64_val (entry
);
12538 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
12550 get_ver_flags (unsigned int flags
)
12552 static char buff
[128];
12559 if (flags
& VER_FLG_BASE
)
12560 strcat (buff
, "BASE");
12562 if (flags
& VER_FLG_WEAK
)
12564 if (flags
& VER_FLG_BASE
)
12565 strcat (buff
, " | ");
12567 strcat (buff
, "WEAK");
12570 if (flags
& VER_FLG_INFO
)
12572 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
12573 strcat (buff
, " | ");
12575 strcat (buff
, "INFO");
12578 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
12580 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
12581 strcat (buff
, " | ");
12583 strcat (buff
, _("<unknown>"));
12589 /* Display the contents of the version sections. */
12592 process_version_sections (Filedata
* filedata
)
12594 Elf_Internal_Shdr
* section
;
12596 bool found
= false;
12601 for (i
= 0, section
= filedata
->section_headers
;
12602 i
< filedata
->file_header
.e_shnum
;
12605 switch (section
->sh_type
)
12607 case SHT_GNU_verdef
:
12609 Elf_External_Verdef
* edefs
;
12616 if (filedata
->is_separate
)
12617 printf (ngettext ("\nIn linked file '%s' the version definition section '%s' contains %u entry:\n",
12618 "\nIn linked file '%s' the version definition section '%s' contains %u entries:\n",
12620 filedata
->file_name
,
12621 printable_section_name (filedata
, section
),
12624 printf (ngettext ("\nVersion definition section '%s' "
12625 "contains %u entry:\n",
12626 "\nVersion definition section '%s' "
12627 "contains %u entries:\n",
12629 printable_section_name (filedata
, section
),
12632 printf (_(" Addr: 0x%016" PRIx64
), section
->sh_addr
);
12633 printf (_(" Offset: 0x%08" PRIx64
" Link: %u (%s)\n"),
12634 section
->sh_offset
, section
->sh_link
,
12635 printable_section_name_from_index (filedata
, section
->sh_link
, NULL
));
12637 edefs
= (Elf_External_Verdef
*)
12638 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
12639 _("version definition section"));
12642 endbuf
= (char *) edefs
+ section
->sh_size
;
12644 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
12647 Elf_External_Verdef
* edef
;
12648 Elf_Internal_Verdef ent
;
12649 Elf_External_Verdaux
* eaux
;
12650 Elf_Internal_Verdaux aux
;
12654 vstart
= ((char *) edefs
) + idx
;
12655 if (vstart
+ sizeof (*edef
) > endbuf
)
12658 edef
= (Elf_External_Verdef
*) vstart
;
12660 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
12661 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
12662 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
12663 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
12664 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
12665 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
12666 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
12668 printf (_(" %#06zx: Rev: %d Flags: %s"),
12669 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
12671 printf (_(" Index: %d Cnt: %d "),
12672 ent
.vd_ndx
, ent
.vd_cnt
);
12674 /* Check for overflow. */
12675 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
12678 vstart
+= ent
.vd_aux
;
12680 if (vstart
+ sizeof (*eaux
) > endbuf
)
12682 eaux
= (Elf_External_Verdaux
*) vstart
;
12684 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
12685 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
12687 if (valid_dynamic_name (filedata
, aux
.vda_name
))
12688 printf (_("Name: %s\n"),
12689 get_dynamic_name (filedata
, aux
.vda_name
));
12691 printf (_("Name index: %ld\n"), aux
.vda_name
);
12693 isum
= idx
+ ent
.vd_aux
;
12695 for (j
= 1; j
< ent
.vd_cnt
; j
++)
12697 if (aux
.vda_next
< sizeof (*eaux
)
12698 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
12700 warn (_("Invalid vda_next field of %lx\n"),
12705 /* Check for overflow. */
12706 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
12709 isum
+= aux
.vda_next
;
12710 vstart
+= aux
.vda_next
;
12712 if (vstart
+ sizeof (*eaux
) > endbuf
)
12714 eaux
= (Elf_External_Verdaux
*) vstart
;
12716 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
12717 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
12719 if (valid_dynamic_name (filedata
, aux
.vda_name
))
12720 printf (_(" %#06zx: Parent %d: %s\n"),
12722 get_dynamic_name (filedata
, aux
.vda_name
));
12724 printf (_(" %#06zx: Parent %d, name index: %ld\n"),
12725 isum
, j
, aux
.vda_name
);
12728 if (j
< ent
.vd_cnt
)
12729 printf (_(" Version def aux past end of section\n"));
12732 file: id:000001,src:000172+005151,op:splice,rep:2. */
12733 if (ent
.vd_next
< sizeof (*edef
)
12734 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
12736 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
12737 cnt
= section
->sh_info
;
12740 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
12743 idx
+= ent
.vd_next
;
12746 if (cnt
< section
->sh_info
)
12747 printf (_(" Version definition past end of section\n"));
12753 case SHT_GNU_verneed
:
12755 Elf_External_Verneed
* eneed
;
12762 if (filedata
->is_separate
)
12763 printf (ngettext ("\nIn linked file '%s' the version needs section '%s' contains %u entry:\n",
12764 "\nIn linked file '%s' the version needs section '%s' contains %u entries:\n",
12766 filedata
->file_name
,
12767 printable_section_name (filedata
, section
),
12770 printf (ngettext ("\nVersion needs section '%s' "
12771 "contains %u entry:\n",
12772 "\nVersion needs section '%s' "
12773 "contains %u entries:\n",
12775 printable_section_name (filedata
, section
),
12778 printf (_(" Addr: 0x%016" PRIx64
), section
->sh_addr
);
12779 printf (_(" Offset: 0x%08" PRIx64
" Link: %u (%s)\n"),
12780 section
->sh_offset
, section
->sh_link
,
12781 printable_section_name_from_index (filedata
, section
->sh_link
, NULL
));
12783 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
12784 section
->sh_offset
, 1,
12786 _("Version Needs section"));
12789 endbuf
= (char *) eneed
+ section
->sh_size
;
12791 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
12793 Elf_External_Verneed
* entry
;
12794 Elf_Internal_Verneed ent
;
12799 vstart
= ((char *) eneed
) + idx
;
12800 if (vstart
+ sizeof (*entry
) > endbuf
)
12803 entry
= (Elf_External_Verneed
*) vstart
;
12805 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
12806 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
12807 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
12808 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
12809 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
12811 printf (_(" %#06zx: Version: %d"), idx
, ent
.vn_version
);
12813 if (valid_dynamic_name (filedata
, ent
.vn_file
))
12814 printf (_(" File: %s"),
12815 get_dynamic_name (filedata
, ent
.vn_file
));
12817 printf (_(" File: %lx"), ent
.vn_file
);
12819 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
12821 /* Check for overflow. */
12822 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
12824 vstart
+= ent
.vn_aux
;
12826 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
12828 Elf_External_Vernaux
* eaux
;
12829 Elf_Internal_Vernaux aux
;
12831 if (vstart
+ sizeof (*eaux
) > endbuf
)
12833 eaux
= (Elf_External_Vernaux
*) vstart
;
12835 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
12836 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
12837 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
12838 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
12839 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
12841 if (valid_dynamic_name (filedata
, aux
.vna_name
))
12842 printf (_(" %#06zx: Name: %s"),
12843 isum
, get_dynamic_name (filedata
, aux
.vna_name
));
12845 printf (_(" %#06zx: Name index: %lx"),
12846 isum
, aux
.vna_name
);
12848 printf (_(" Flags: %s Version: %d\n"),
12849 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
12851 if (aux
.vna_next
< sizeof (*eaux
)
12852 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
12854 warn (_("Invalid vna_next field of %lx\n"),
12859 /* Check for overflow. */
12860 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
12862 isum
+= aux
.vna_next
;
12863 vstart
+= aux
.vna_next
;
12866 if (j
< ent
.vn_cnt
)
12867 warn (_("Missing Version Needs auxiliary information\n"));
12869 if (ent
.vn_next
< sizeof (*entry
)
12870 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
12872 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
12873 cnt
= section
->sh_info
;
12876 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
12878 idx
+= ent
.vn_next
;
12881 if (cnt
< section
->sh_info
)
12882 warn (_("Missing Version Needs information\n"));
12888 case SHT_GNU_versym
:
12890 Elf_Internal_Shdr
* link_section
;
12893 unsigned char * edata
;
12894 unsigned short * data
;
12896 Elf_Internal_Sym
* symbols
;
12897 Elf_Internal_Shdr
* string_sec
;
12901 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
12904 link_section
= filedata
->section_headers
+ section
->sh_link
;
12905 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
12907 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
12912 symbols
= get_elf_symbols (filedata
, link_section
, & num_syms
);
12913 if (symbols
== NULL
)
12916 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
12918 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
12919 string_sec
->sh_size
,
12920 _("version string table"));
12927 if (filedata
->is_separate
)
12928 printf (ngettext ("\nIn linked file '%s' the version symbols section '%s' contains %" PRIu64
" entry:\n",
12929 "\nIn linked file '%s' the version symbols section '%s' contains %" PRIu64
" entries:\n",
12931 filedata
->file_name
,
12932 printable_section_name (filedata
, section
),
12935 printf (ngettext ("\nVersion symbols section '%s' "
12936 "contains %" PRIu64
" entry:\n",
12937 "\nVersion symbols section '%s' "
12938 "contains %" PRIu64
" entries:\n",
12940 printable_section_name (filedata
, section
),
12943 printf (_(" Addr: 0x%016" PRIx64
), section
->sh_addr
);
12944 printf (_(" Offset: 0x%08" PRIx64
" Link: %u (%s)\n"),
12945 section
->sh_offset
, section
->sh_link
,
12946 printable_section_name (filedata
, link_section
));
12948 off
= offset_from_vma (filedata
,
12949 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
12950 total
* sizeof (short));
12951 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
12952 sizeof (short), total
,
12953 _("version symbol data"));
12961 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
12963 for (cnt
= total
; cnt
--;)
12964 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
12969 for (cnt
= 0; cnt
< total
; cnt
+= 4)
12973 char *invalid
= _("*invalid*");
12975 printf (" %03x:", cnt
);
12977 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
12978 switch (data
[cnt
+ j
])
12981 fputs (_(" 0 (*local*) "), stdout
);
12985 fputs (_(" 1 (*global*) "), stdout
);
12989 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
12990 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
12992 /* If this index value is greater than the size of the symbols
12993 array, break to avoid an out-of-bounds read. */
12994 if (cnt
+ j
>= num_syms
)
12996 warn (_("invalid index into symbol array\n"));
13001 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
13003 Elf_Internal_Verneed ivn
;
13006 offset
= offset_from_vma
13008 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
13009 sizeof (Elf_External_Verneed
));
13013 Elf_Internal_Vernaux ivna
;
13014 Elf_External_Verneed evn
;
13015 Elf_External_Vernaux evna
;
13018 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
13019 _("version need")) == NULL
)
13022 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
13023 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
13025 a_off
= offset
+ ivn
.vn_aux
;
13029 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
13030 1, _("version need aux (2)")) == NULL
)
13033 ivna
.vna_other
= 0;
13037 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
13038 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
13041 a_off
+= ivna
.vna_next
;
13043 while (ivna
.vna_other
!= data
[cnt
+ j
]
13044 && ivna
.vna_next
!= 0);
13046 if (ivna
.vna_other
== data
[cnt
+ j
])
13048 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
13050 if (ivna
.vna_name
>= string_sec
->sh_size
)
13053 name
= strtab
+ ivna
.vna_name
;
13057 offset
+= ivn
.vn_next
;
13059 while (ivn
.vn_next
);
13062 if (data
[cnt
+ j
] != 0x8001
13063 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
13065 Elf_Internal_Verdef ivd
;
13066 Elf_External_Verdef evd
;
13069 offset
= offset_from_vma
13071 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
13076 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
13077 _("version def")) == NULL
)
13080 /* PR 17531: file: 046-1082287-0.004. */
13081 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
13086 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
13087 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
13090 offset
+= ivd
.vd_next
;
13092 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
13093 && ivd
.vd_next
!= 0);
13095 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
13097 Elf_External_Verdaux evda
;
13098 Elf_Internal_Verdaux ivda
;
13100 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
13102 if (get_data (&evda
, filedata
,
13103 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
13105 _("version def aux")) == NULL
)
13108 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
13110 if (ivda
.vda_name
>= string_sec
->sh_size
)
13112 else if (name
!= NULL
&& name
!= invalid
)
13113 name
= _("*both*");
13115 name
= strtab
+ ivda
.vda_name
;
13119 nn
+= printf ("(%s%-*s",
13121 12 - (int) strlen (name
),
13125 printf ("%*c", 18 - nn
, ' ');
13144 if (filedata
->is_separate
)
13145 printf (_("\nNo version information found in linked file '%s'.\n"),
13146 filedata
->file_name
);
13148 printf (_("\nNo version information found in this file.\n"));
13154 static const char *
13155 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
13157 static char buff
[64];
13161 case STB_LOCAL
: return "LOCAL";
13162 case STB_GLOBAL
: return "GLOBAL";
13163 case STB_WEAK
: return "WEAK";
13165 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
13166 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
13168 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
13170 if (binding
== STB_GNU_UNIQUE
13171 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
13173 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
13176 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
13181 static const char *
13182 get_symbol_type (Filedata
* filedata
, unsigned int type
)
13184 static char buff
[64];
13188 case STT_NOTYPE
: return "NOTYPE";
13189 case STT_OBJECT
: return "OBJECT";
13190 case STT_FUNC
: return "FUNC";
13191 case STT_SECTION
: return "SECTION";
13192 case STT_FILE
: return "FILE";
13193 case STT_COMMON
: return "COMMON";
13194 case STT_TLS
: return "TLS";
13195 case STT_RELC
: return "RELC";
13196 case STT_SRELC
: return "SRELC";
13198 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
13200 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
13201 return "THUMB_FUNC";
13203 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
13206 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
13207 return "PARISC_MILLI";
13209 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
13211 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
13213 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13215 if (type
== STT_HP_OPAQUE
)
13216 return "HP_OPAQUE";
13217 if (type
== STT_HP_STUB
)
13221 if (type
== STT_GNU_IFUNC
13222 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
13223 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
13226 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
13229 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
13234 static const char *
13235 get_symbol_visibility (unsigned int visibility
)
13237 switch (visibility
)
13239 case STV_DEFAULT
: return "DEFAULT";
13240 case STV_INTERNAL
: return "INTERNAL";
13241 case STV_HIDDEN
: return "HIDDEN";
13242 case STV_PROTECTED
: return "PROTECTED";
13244 error (_("Unrecognized visibility value: %u\n"), visibility
);
13245 return _("<unknown>");
13249 static const char *
13250 get_alpha_symbol_other (unsigned int other
)
13254 case STO_ALPHA_NOPV
: return "NOPV";
13255 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
13257 error (_("Unrecognized alpha specific other value: %u\n"), other
);
13258 return _("<unknown>");
13262 static const char *
13263 get_solaris_symbol_visibility (unsigned int visibility
)
13265 switch (visibility
)
13267 case 4: return "EXPORTED";
13268 case 5: return "SINGLETON";
13269 case 6: return "ELIMINATE";
13270 default: return get_symbol_visibility (visibility
);
13274 static const char *
13275 get_aarch64_symbol_other (unsigned int other
)
13277 static char buf
[32];
13279 if (other
& STO_AARCH64_VARIANT_PCS
)
13281 other
&= ~STO_AARCH64_VARIANT_PCS
;
13283 return "VARIANT_PCS";
13284 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
13290 static const char *
13291 get_mips_symbol_other (unsigned int other
)
13295 case STO_OPTIONAL
: return "OPTIONAL";
13296 case STO_MIPS_PLT
: return "MIPS PLT";
13297 case STO_MIPS_PIC
: return "MIPS PIC";
13298 case STO_MICROMIPS
: return "MICROMIPS";
13299 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
13300 case STO_MIPS16
: return "MIPS16";
13301 default: return NULL
;
13305 static const char *
13306 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
13308 if (is_ia64_vms (filedata
))
13310 static char res
[32];
13314 /* Function types is for images and .STB files only. */
13315 switch (filedata
->file_header
.e_type
)
13319 switch (VMS_ST_FUNC_TYPE (other
))
13321 case VMS_SFT_CODE_ADDR
:
13322 strcat (res
, " CA");
13324 case VMS_SFT_SYMV_IDX
:
13325 strcat (res
, " VEC");
13328 strcat (res
, " FD");
13330 case VMS_SFT_RESERVE
:
13331 strcat (res
, " RSV");
13334 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
13335 VMS_ST_FUNC_TYPE (other
));
13336 strcat (res
, " <unknown>");
13343 switch (VMS_ST_LINKAGE (other
))
13345 case VMS_STL_IGNORE
:
13346 strcat (res
, " IGN");
13348 case VMS_STL_RESERVE
:
13349 strcat (res
, " RSV");
13352 strcat (res
, " STD");
13355 strcat (res
, " LNK");
13358 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
13359 VMS_ST_LINKAGE (other
));
13360 strcat (res
, " <unknown>");
13372 static const char *
13373 get_ppc64_symbol_other (unsigned int other
)
13375 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
13378 other
>>= STO_PPC64_LOCAL_BIT
;
13381 static char buf
[64];
13383 other
= ppc64_decode_local_entry (other
);
13384 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
13390 static const char *
13391 get_riscv_symbol_other (unsigned int other
)
13393 static char buf
[32];
13396 if (other
& STO_RISCV_VARIANT_CC
)
13398 strcat (buf
, _(" VARIANT_CC"));
13399 other
&= ~STO_RISCV_VARIANT_CC
;
13403 snprintf (buf
, sizeof buf
, " %x", other
);
13412 static const char *
13413 get_symbol_other (Filedata
* filedata
, unsigned int other
)
13415 const char * result
= NULL
;
13416 static char buff
[64];
13421 switch (filedata
->file_header
.e_machine
)
13424 result
= get_alpha_symbol_other (other
);
13427 result
= get_aarch64_symbol_other (other
);
13430 result
= get_mips_symbol_other (other
);
13433 result
= get_ia64_symbol_other (filedata
, other
);
13436 result
= get_ppc64_symbol_other (other
);
13439 result
= get_riscv_symbol_other (other
);
13449 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
13453 static const char *
13454 get_symbol_version_string (Filedata
*filedata
,
13456 const char *strtab
,
13457 size_t strtab_size
,
13459 Elf_Internal_Sym
*psym
,
13460 enum versioned_symbol_info
*sym_info
,
13461 unsigned short *vna_other
)
13463 unsigned char data
[2];
13464 unsigned short vers_data
;
13466 unsigned short max_vd_ndx
;
13469 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
13472 offset
= offset_from_vma (filedata
,
13473 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
13474 sizeof data
+ si
* sizeof (vers_data
));
13476 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
13477 sizeof (data
), 1, _("version data")) == NULL
)
13480 vers_data
= byte_get (data
, 2);
13482 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
13485 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
13488 /* Usually we'd only see verdef for defined symbols, and verneed for
13489 undefined symbols. However, symbols defined by the linker in
13490 .dynbss for variables copied from a shared library in order to
13491 avoid text relocations are defined yet have verneed. We could
13492 use a heuristic to detect the special case, for example, check
13493 for verneed first on symbols defined in SHT_NOBITS sections, but
13494 it is simpler and more reliable to just look for both verdef and
13495 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
13497 if (psym
->st_shndx
!= SHN_UNDEF
13498 && vers_data
!= 0x8001
13499 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
13501 Elf_Internal_Verdef ivd
;
13502 Elf_Internal_Verdaux ivda
;
13503 Elf_External_Verdaux evda
;
13506 off
= offset_from_vma (filedata
,
13507 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
13508 sizeof (Elf_External_Verdef
));
13512 Elf_External_Verdef evd
;
13514 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
13515 _("version def")) == NULL
)
13524 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
13525 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
13526 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
13527 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
13530 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
13531 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
13533 off
+= ivd
.vd_next
;
13535 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
13537 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
13539 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
13542 off
-= ivd
.vd_next
;
13545 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
13546 _("version def aux")) != NULL
)
13548 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
13550 if (psym
->st_name
!= ivda
.vda_name
)
13551 return (ivda
.vda_name
< strtab_size
13552 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
13557 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
13559 Elf_External_Verneed evn
;
13560 Elf_Internal_Verneed ivn
;
13561 Elf_Internal_Vernaux ivna
;
13563 offset
= offset_from_vma (filedata
,
13564 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
13570 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
13571 _("version need")) == NULL
)
13574 ivna
.vna_other
= 0;
13579 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
13580 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
13582 vna_off
= offset
+ ivn
.vn_aux
;
13586 Elf_External_Vernaux evna
;
13588 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
13589 _("version need aux (3)")) == NULL
)
13592 ivna
.vna_other
= 0;
13597 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
13598 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
13599 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
13602 vna_off
+= ivna
.vna_next
;
13604 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
13606 if (ivna
.vna_other
== vers_data
)
13609 offset
+= ivn
.vn_next
;
13611 while (ivn
.vn_next
!= 0);
13613 if (ivna
.vna_other
== vers_data
)
13615 *sym_info
= symbol_undefined
;
13616 *vna_other
= ivna
.vna_other
;
13617 return (ivna
.vna_name
< strtab_size
13618 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
13620 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
13621 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
13622 return _("<corrupt>");
13627 /* Display a symbol size on stdout. Format is based on --sym-base setting. */
13629 static unsigned int
13630 print_symbol_size (uint64_t vma
, int base
)
13635 return print_vma (vma
, OCTAL_5
);
13638 return print_vma (vma
, UNSIGNED_5
);
13641 return print_vma (vma
, PREFIX_HEX_5
);
13645 return print_vma (vma
, DEC_5
);
13649 /* Print information on a single symbol. */
13652 print_symbol (Filedata
* filedata
,
13653 uint64_t symbol_index
,
13654 Elf_Internal_Sym
* symtab
,
13655 Elf_Internal_Shdr
* section
,
13657 size_t strtab_size
)
13659 const char *version_string
;
13660 enum versioned_symbol_info sym_info
;
13661 unsigned short vna_other
;
13663 Elf_Internal_Sym
*psym
= symtab
+ symbol_index
;
13665 /* FIXME: We should have a table of field widths,
13666 rather than using hard coded constants. */
13667 printf ("%6" PRId64
": ", symbol_index
);
13668 print_vma (psym
->st_value
, LONG_HEX
);
13670 print_symbol_size (psym
->st_size
, sym_base
);
13671 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
13672 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
13673 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
13674 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
13677 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
13679 printf (" %-7s", get_symbol_visibility (vis
));
13681 /* Check to see if any other bits in the st_other field are set.
13682 FIXME: Displaying this information here disrupts the layout
13683 of the table being generated. */
13684 if (psym
->st_other
^ vis
)
13685 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
13690 sstr
= printable_section_name_from_index (filedata
, psym
->st_shndx
, & is_special
);
13692 /* Print the symbol's section index. If the index is special
13693 then print the index's name rather than its number. */
13698 /* Special case: If there are no section headers, and the printable
13699 name is "<section 0x...." then just display the section number
13700 as a decimal. This happens when objcopy --strip -section-headers
13702 if (filedata
->file_header
.e_shnum
== 0 && startswith (sstr
, "<section"))
13703 printed
= printf (" %4d ", psym
->st_shndx
);
13705 printed
= printf (" %4s ", sstr
);
13707 if (extra_sym_info
&& printed
< 16)
13708 printf ("%*s", 16 - printed
, "");
13712 printf (" %4u ", psym
->st_shndx
);
13714 if (extra_sym_info
)
13716 /* Display the section name referenced by the section index. */
13717 int printed
= printf ("(%s) ", sstr
);
13719 printf ("%*s", 10 - printed
, "");
13723 /* Get the symbol's name. For section symbols without a
13724 specific name use the (already computed) section name. */
13725 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
13726 && section_index_real (filedata
, psym
->st_shndx
)
13727 && psym
->st_name
== 0)
13735 is_valid
= valid_symbol_name (strtab
, strtab_size
, psym
->st_name
);
13736 sstr
= is_valid
? strtab
+ psym
->st_name
: _("<corrupt>");
13740 = get_symbol_version_string (filedata
,
13742 || section
->sh_type
== SHT_DYNSYM
),
13743 strtab
, strtab_size
, symbol_index
,
13744 psym
, &sym_info
, &vna_other
);
13746 int len_avail
= 21;
13747 if (! do_wide
&& version_string
!= NULL
)
13751 len_avail
-= 1 + strlen (version_string
);
13753 if (sym_info
== symbol_undefined
)
13754 len_avail
-= sprintf (buffer
," (%d)", vna_other
);
13755 else if (sym_info
!= symbol_hidden
)
13759 print_symbol_name (len_avail
, sstr
);
13761 if (version_string
)
13763 if (sym_info
== symbol_undefined
)
13764 printf ("@%s (%d)", version_string
, vna_other
);
13766 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
13772 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
13774 && symbol_index
>= section
->sh_info
13775 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
13776 && filedata
->file_header
.e_machine
!= EM_MIPS
13777 /* Solaris binaries have been found to violate this requirement as
13778 well. Not sure if this is a bug or an ABI requirement. */
13779 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
13780 warn (_("local symbol %" PRIu64
" found at index >= %s's sh_info value of %u\n"),
13781 symbol_index
, printable_section_name (filedata
, section
), section
->sh_info
);
13784 static const char *
13785 get_lto_kind (unsigned int kind
)
13789 case 0: return "DEF";
13790 case 1: return "WEAKDEF";
13791 case 2: return "UNDEF";
13792 case 3: return "WEAKUNDEF";
13793 case 4: return "COMMON";
13798 static char buffer
[30];
13799 error (_("Unknown LTO symbol definition encountered: %u\n"), kind
);
13800 sprintf (buffer
, "<unknown: %u>", kind
);
13804 static const char *
13805 get_lto_visibility (unsigned int visibility
)
13807 switch (visibility
)
13809 case 0: return "DEFAULT";
13810 case 1: return "PROTECTED";
13811 case 2: return "INTERNAL";
13812 case 3: return "HIDDEN";
13817 static char buffer
[30];
13818 error (_("Unknown LTO symbol visibility encountered: %u\n"), visibility
);
13819 sprintf (buffer
, "<unknown: %u>", visibility
);
13823 static const char *
13824 get_lto_sym_type (unsigned int sym_type
)
13828 case 0: return "UNKNOWN";
13829 case 1: return "FUNCTION";
13830 case 2: return "VARIABLE";
13835 static char buffer
[30];
13836 error (_("Unknown LTO symbol type encountered: %u\n"), sym_type
);
13837 sprintf (buffer
, "<unknown: %u>", sym_type
);
13841 /* Display an LTO format symbol table.
13842 FIXME: The format of LTO symbol tables is not formalized.
13843 So this code could need changing in the future. */
13846 display_lto_symtab (Filedata
* filedata
,
13847 Elf_Internal_Shdr
* section
)
13849 if (section
->sh_size
== 0)
13851 if (filedata
->is_separate
)
13852 printf (_("\nThe LTO Symbol table section '%s' in linked file '%s' is empty!\n"),
13853 printable_section_name (filedata
, section
),
13854 filedata
->file_name
);
13856 printf (_("\nLTO Symbol table '%s' is empty!\n"),
13857 printable_section_name (filedata
, section
));
13862 if (section
->sh_size
> filedata
->file_size
)
13864 error (_("Section %s has an invalid sh_size of %#" PRIx64
"\n"),
13865 printable_section_name (filedata
, section
),
13870 void * alloced_data
= get_data (NULL
, filedata
, section
->sh_offset
,
13871 section
->sh_size
, 1, _("LTO symbols"));
13872 if (alloced_data
== NULL
)
13875 /* Look for extended data for the symbol table. */
13876 Elf_Internal_Shdr
* ext
= NULL
;
13877 void * ext_data_orig
= NULL
;
13878 char * ext_data
= NULL
;
13879 char * ext_data_end
= NULL
;
13880 char * ext_name
= NULL
;
13882 if (asprintf (& ext_name
, ".gnu.lto_.ext_symtab.%s",
13883 (section_name (filedata
, section
)
13884 + sizeof (".gnu.lto_.symtab.") - 1)) > 0
13885 && ext_name
!= NULL
/* Paranoia. */
13886 && (ext
= find_section (filedata
, ext_name
)) != NULL
)
13888 if (ext
->sh_size
< 3)
13889 error (_("LTO Symbol extension table '%s' is empty!\n"),
13890 printable_section_name (filedata
, ext
));
13893 ext_data_orig
= ext_data
= get_data (NULL
, filedata
, ext
->sh_offset
,
13895 _("LTO ext symbol data"));
13896 if (ext_data
!= NULL
)
13898 ext_data_end
= ext_data
+ ext
->sh_size
;
13899 if (* ext_data
++ != 1)
13900 error (_("Unexpected version number in symbol extension table\n"));
13905 const unsigned char * data
= (const unsigned char *) alloced_data
;
13906 const unsigned char * end
= data
+ section
->sh_size
;
13908 if (filedata
->is_separate
)
13909 printf (_("\nIn linked file '%s': "), filedata
->file_name
);
13913 if (ext_data_orig
!= NULL
)
13916 printf (_("LTO Symbol table '%s' and extension table '%s' contain:\n"),
13917 printable_section_name (filedata
, section
),
13918 printable_section_name (filedata
, ext
));
13921 printf (_("LTO Symbol table '%s'\n"),
13922 printable_section_name (filedata
, section
));
13923 printf (_(" and extension table '%s' contain:\n"),
13924 printable_section_name (filedata
, ext
));
13928 printf (_("LTO Symbol table '%s' contains:\n"),
13929 printable_section_name (filedata
, section
));
13931 /* FIXME: Add a wide version. */
13932 if (ext_data_orig
!= NULL
)
13933 printf (_(" Comdat_Key Kind Visibility Size Slot Type Section Name\n"));
13935 printf (_(" Comdat_Key Kind Visibility Size Slot Name\n"));
13937 /* FIXME: We do not handle style prefixes. */
13941 const unsigned char * sym_name
= data
;
13942 data
+= strnlen ((const char *) sym_name
, end
- data
) + 1;
13946 const unsigned char * comdat_key
= data
;
13947 data
+= strnlen ((const char *) comdat_key
, end
- data
) + 1;
13951 if (data
+ 2 + 8 + 4 > end
)
13954 unsigned int kind
= *data
++;
13955 unsigned int visibility
= *data
++;
13957 uint64_t size
= byte_get (data
, 8);
13960 uint64_t slot
= byte_get (data
, 4);
13963 if (ext_data
!= NULL
)
13965 if (ext_data
< (ext_data_end
- 1))
13967 unsigned int sym_type
= * ext_data
++;
13968 unsigned int sec_kind
= * ext_data
++;
13970 printf (" %10s %10s %11s %08" PRIx64
" %08" PRIx64
" %9s %08x _",
13971 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
13972 get_lto_kind (kind
),
13973 get_lto_visibility (visibility
),
13976 get_lto_sym_type (sym_type
),
13978 print_symbol_name (6, (const char *) sym_name
);
13982 error (_("Ran out of LTO symbol extension data\n"));
13984 /* FIXME: return FAIL result ? */
13989 printf (" %10s %10s %11s %08" PRIx64
" %08" PRIx64
" _",
13990 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
13991 get_lto_kind (kind
),
13992 get_lto_visibility (visibility
),
13995 print_symbol_name (21, (const char *) sym_name
);
14000 if (ext_data
!= NULL
&& ext_data
< ext_data_end
)
14002 error (_("Data remains in the LTO symbol extension table\n"));
14006 free (alloced_data
);
14007 free (ext_data_orig
);
14012 error (_("Buffer overrun encountered whilst decoding LTO symbol table\n"));
14013 free (alloced_data
);
14014 free (ext_data_orig
);
14019 /* Display LTO symbol tables. */
14022 process_lto_symbol_tables (Filedata
* filedata
)
14024 Elf_Internal_Shdr
* section
;
14031 if (filedata
->section_headers
== NULL
)
14034 for (i
= 0, section
= filedata
->section_headers
;
14035 i
< filedata
->file_header
.e_shnum
;
14037 if (section_name_valid (filedata
, section
)
14038 && startswith (section_name (filedata
, section
), ".gnu.lto_.symtab."))
14039 res
&= display_lto_symtab (filedata
, section
);
14045 print_symbol_table_heading (void)
14047 /* FIXME: We should store the size of each field in the display in a table and
14048 then use the values inside print_symbol(), instead of that function using
14049 hard coded constants. */
14052 if (extra_sym_info
)
14054 printf (_(" Num: Value Size Type Bind Vis+Other Ndx(SecName) Name [+ Version Info]\n"));
14055 /* |--6-|: |--8---| |-5-| |--7--| |-6--| |--7--| |---8--| |----13.....| |........... */
14056 /* eg: 5: 00000000 14 FUNC LOCAL DEFAULT 1 (.text) get_sections */
14060 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
14061 /* |--6-|: |--8---| |-5-| |--7--| |-6--| |--7--| |-4| |........... */
14062 /* eg: 5: 00000000 14 FUNC LOCAL DEFAULT 1 get_sections */
14066 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
14067 /* |--6-|: |--8---| |-5-| |--7--| |-6--| |--7--| |-4| |------------29-------------| */
14068 /* eg: 5: 00000000 14 FUNC LOCAL DEFAULT 1 get_sections */
14073 if (extra_sym_info
)
14075 printf (_(" Num: Value Size Type Bind Vis+Other Ndx(SecName) Name [+ Version Info]\n"));
14076 /* |--6-|: |------16------| |-5-| |--7--| |-6--| |--7--| |-------14---| |..... */
14077 /* eg: 2: 0000000000000000 0 FUNC LOCAL DEFAULT 1 (.text) .very_long_function_name */
14082 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
14083 /* |--6-|: |------16------| |-5-| |--7--| |-6--| |--7--| |-4| |........... */
14084 /* eg: 5: 0000000000000000 14 FUNC LOCAL DEFAULT 1 very_long_function_name */
14088 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
14089 /* |--6-|: |------16------| |-5-| |--7--| |-6--| |--7--| |-4| |--------21---------| */
14090 /* eg: 5: 0000000000000000 14 FUNC LOCAL DEFAULT 1 very_long_functi[...] */
14095 /* Dump the symbol table. */
14098 process_symbol_table (Filedata
* filedata
)
14100 Elf_Internal_Shdr
* section
;
14102 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
14105 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
14107 && do_using_dynamic
14108 && filedata
->dynamic_strings
!= NULL
14109 && filedata
->dynamic_symbols
!= NULL
)
14113 if (filedata
->is_separate
)
14115 printf (ngettext ("\nIn linked file '%s' the dynamic symbol table"
14116 " contains %" PRIu64
" entry:\n",
14117 "\nIn linked file '%s' the dynamic symbol table"
14118 " contains %" PRIu64
" entries:\n",
14119 filedata
->num_dynamic_syms
),
14120 filedata
->file_name
,
14121 filedata
->num_dynamic_syms
);
14125 printf (ngettext ("\nSymbol table for image contains %" PRIu64
14127 "\nSymbol table for image contains %" PRIu64
14129 filedata
->num_dynamic_syms
),
14130 filedata
->num_dynamic_syms
);
14133 print_symbol_table_heading ();
14135 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
14136 print_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
14137 filedata
->dynamic_strings
,
14138 filedata
->dynamic_strings_length
);
14140 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
14141 && filedata
->section_headers
!= NULL
)
14145 for (i
= 0, section
= filedata
->section_headers
;
14146 i
< filedata
->file_header
.e_shnum
;
14149 char * strtab
= NULL
;
14150 uint64_t strtab_size
= 0;
14151 Elf_Internal_Sym
* symtab
;
14152 uint64_t si
, num_syms
;
14154 if ((section
->sh_type
!= SHT_SYMTAB
14155 && section
->sh_type
!= SHT_DYNSYM
)
14157 && section
->sh_type
== SHT_SYMTAB
))
14160 if (section
->sh_entsize
== 0)
14162 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
14163 printable_section_name (filedata
, section
));
14167 num_syms
= section
->sh_size
/ section
->sh_entsize
;
14169 if (filedata
->is_separate
)
14170 printf (ngettext ("\nIn linked file '%s' symbol section '%s'"
14171 " contains %" PRIu64
" entry:\n",
14172 "\nIn linked file '%s' symbol section '%s'"
14173 " contains %" PRIu64
" entries:\n",
14175 filedata
->file_name
,
14176 printable_section_name (filedata
, section
),
14179 printf (ngettext ("\nSymbol table '%s' contains %" PRIu64
14181 "\nSymbol table '%s' contains %" PRIu64
14184 printable_section_name (filedata
, section
),
14187 print_symbol_table_heading ();
14189 symtab
= get_elf_symbols (filedata
, section
, & num_syms
);
14190 if (symtab
== NULL
)
14193 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
14195 strtab
= filedata
->string_table
;
14196 strtab_size
= filedata
->string_table_length
;
14198 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
14200 Elf_Internal_Shdr
* string_sec
;
14202 string_sec
= filedata
->section_headers
+ section
->sh_link
;
14204 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
14205 1, string_sec
->sh_size
,
14206 _("string table"));
14207 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
14210 for (si
= 0; si
< num_syms
; si
++)
14211 print_symbol (filedata
, si
, symtab
, section
,
14212 strtab
, strtab_size
);
14215 if (strtab
!= filedata
->string_table
)
14221 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
14223 if (do_histogram
&& filedata
->buckets
!= NULL
)
14229 uint64_t maxlength
= 0;
14230 uint64_t nzero_counts
= 0;
14231 uint64_t nsyms
= 0;
14234 printf (ngettext ("\nHistogram for bucket list length "
14235 "(total of %" PRIu64
" bucket):\n",
14236 "\nHistogram for bucket list length "
14237 "(total of %" PRIu64
" buckets):\n",
14238 filedata
->nbuckets
),
14239 filedata
->nbuckets
);
14241 lengths
= calloc (filedata
->nbuckets
, sizeof (*lengths
));
14242 if (lengths
== NULL
)
14244 error (_("Out of memory allocating space for histogram buckets\n"));
14247 visited
= xcmalloc (filedata
->nchains
, 1);
14248 memset (visited
, 0, filedata
->nchains
);
14250 printf (_(" Length Number %% of total Coverage\n"));
14251 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
14253 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
14256 if (maxlength
< ++lengths
[hn
])
14258 if (si
>= filedata
->nchains
|| visited
[si
])
14260 error (_("histogram chain is corrupt\n"));
14268 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
14269 if (counts
== NULL
)
14272 error (_("Out of memory allocating space for histogram counts\n"));
14276 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
14277 ++counts
[lengths
[hn
]];
14279 if (filedata
->nbuckets
> 0)
14282 printf (" 0 %-10" PRIu64
" (%5.1f%%)\n",
14283 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
14284 for (i
= 1; i
<= maxlength
; ++i
)
14286 nzero_counts
+= counts
[i
] * i
;
14287 printf ("%7" PRIu64
" %-10" PRIu64
" (%5.1f%%) %5.1f%%\n",
14288 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
14289 (nzero_counts
* 100.0) / nsyms
);
14297 free (filedata
->buckets
);
14298 filedata
->buckets
= NULL
;
14299 filedata
->nbuckets
= 0;
14300 free (filedata
->chains
);
14301 filedata
->chains
= NULL
;
14303 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
14308 uint64_t maxlength
= 0;
14309 uint64_t nzero_counts
= 0;
14310 uint64_t nsyms
= 0;
14312 printf (ngettext ("\nHistogram for `%s' bucket list length "
14313 "(total of %" PRIu64
" bucket):\n",
14314 "\nHistogram for `%s' bucket list length "
14315 "(total of %" PRIu64
" buckets):\n",
14316 filedata
->ngnubuckets
),
14317 GNU_HASH_SECTION_NAME (filedata
),
14318 filedata
->ngnubuckets
);
14320 lengths
= calloc (filedata
->ngnubuckets
, sizeof (*lengths
));
14321 if (lengths
== NULL
)
14323 error (_("Out of memory allocating space for gnu histogram buckets\n"));
14327 printf (_(" Length Number %% of total Coverage\n"));
14329 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
14330 if (filedata
->gnubuckets
[hn
] != 0)
14332 uint64_t off
, length
= 1;
14334 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
14335 /* PR 17531 file: 010-77222-0.004. */
14336 off
< filedata
->ngnuchains
14337 && (filedata
->gnuchains
[off
] & 1) == 0;
14340 lengths
[hn
] = length
;
14341 if (length
> maxlength
)
14342 maxlength
= length
;
14346 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
14347 if (counts
== NULL
)
14350 error (_("Out of memory allocating space for gnu histogram counts\n"));
14354 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
14355 ++counts
[lengths
[hn
]];
14357 if (filedata
->ngnubuckets
> 0)
14360 printf (" 0 %-10" PRIu64
" (%5.1f%%)\n",
14361 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
14362 for (j
= 1; j
<= maxlength
; ++j
)
14364 nzero_counts
+= counts
[j
] * j
;
14365 printf ("%7" PRIu64
" %-10" PRIu64
" (%5.1f%%) %5.1f%%\n",
14366 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
14367 (nzero_counts
* 100.0) / nsyms
);
14374 free (filedata
->gnubuckets
);
14375 filedata
->gnubuckets
= NULL
;
14376 filedata
->ngnubuckets
= 0;
14377 free (filedata
->gnuchains
);
14378 filedata
->gnuchains
= NULL
;
14379 filedata
->ngnuchains
= 0;
14380 free (filedata
->mipsxlat
);
14381 filedata
->mipsxlat
= NULL
;
14385 free (filedata
->gnubuckets
);
14386 filedata
->gnubuckets
= NULL
;
14387 filedata
->ngnubuckets
= 0;
14388 free (filedata
->gnuchains
);
14389 filedata
->gnuchains
= NULL
;
14390 filedata
->ngnuchains
= 0;
14391 free (filedata
->mipsxlat
);
14392 filedata
->mipsxlat
= NULL
;
14393 free (filedata
->buckets
);
14394 filedata
->buckets
= NULL
;
14395 filedata
->nbuckets
= 0;
14396 free (filedata
->chains
);
14397 filedata
->chains
= NULL
;
14402 process_syminfo (Filedata
* filedata
)
14406 if (filedata
->dynamic_syminfo
== NULL
14408 /* No syminfo, this is ok. */
14411 /* There better should be a dynamic symbol section. */
14412 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
14415 if (filedata
->is_separate
)
14416 printf (ngettext ("\nIn linked file '%s: the dynamic info segment at offset %#" PRIx64
" contains %d entry:\n",
14417 "\nIn linked file '%s: the dynamic info segment at offset %#" PRIx64
" contains %d entries:\n",
14418 filedata
->dynamic_syminfo_nent
),
14419 filedata
->file_name
,
14420 filedata
->dynamic_syminfo_offset
,
14421 filedata
->dynamic_syminfo_nent
);
14423 printf (ngettext ("\nDynamic info segment at offset %#" PRIx64
14424 " contains %d entry:\n",
14425 "\nDynamic info segment at offset %#" PRIx64
14426 " contains %d entries:\n",
14427 filedata
->dynamic_syminfo_nent
),
14428 filedata
->dynamic_syminfo_offset
,
14429 filedata
->dynamic_syminfo_nent
);
14431 printf (_(" Num: Name BoundTo Flags\n"));
14432 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
14434 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
14436 printf ("%4d: ", i
);
14437 if (i
>= filedata
->num_dynamic_syms
)
14438 printf (_("<corrupt index>"));
14439 else if (valid_dynamic_name (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
14440 print_symbol_name (30, get_dynamic_name (filedata
,
14441 filedata
->dynamic_symbols
[i
].st_name
));
14443 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
14446 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
14448 case SYMINFO_BT_SELF
:
14449 fputs ("SELF ", stdout
);
14451 case SYMINFO_BT_PARENT
:
14452 fputs ("PARENT ", stdout
);
14455 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
14456 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
14457 && valid_dynamic_name (filedata
,
14458 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
14460 print_symbol_name (10, get_dynamic_name (filedata
,
14461 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
14465 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
14469 if (flags
& SYMINFO_FLG_DIRECT
)
14470 printf (" DIRECT");
14471 if (flags
& SYMINFO_FLG_PASSTHRU
)
14472 printf (" PASSTHRU");
14473 if (flags
& SYMINFO_FLG_COPY
)
14475 if (flags
& SYMINFO_FLG_LAZYLOAD
)
14476 printf (" LAZYLOAD");
14484 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
14485 is contained by the region START .. END. The types of ADDR, START
14486 and END should all be the same. Note both ADDR + NELEM and END
14487 point to just beyond the end of the regions that are being tested. */
14488 #define IN_RANGE(START,END,ADDR,NELEM) \
14489 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
14491 /* Check to see if the given reloc needs to be handled in a target specific
14492 manner. If so then process the reloc and return TRUE otherwise return
14495 If called with reloc == NULL, then this is a signal that reloc processing
14496 for the current section has finished, and any saved state should be
14500 target_specific_reloc_handling (Filedata
*filedata
,
14501 Elf_Internal_Rela
*reloc
,
14502 unsigned char *start
,
14503 unsigned char *end
,
14504 Elf_Internal_Sym
*symtab
,
14507 unsigned int reloc_type
= 0;
14508 uint64_t sym_index
= 0;
14512 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
14513 sym_index
= get_reloc_symindex (reloc
->r_info
);
14516 switch (filedata
->file_header
.e_machine
)
14520 switch (reloc_type
)
14522 /* For .uleb128 .LFE1-.LFB1, loongarch write 0 to object file
14523 at assembly time. */
14524 case 107: /* R_LARCH_ADD_ULEB128. */
14525 case 108: /* R_LARCH_SUB_ULEB128. */
14527 uint64_t value
= 0;
14528 unsigned int reloc_size
= 0;
14531 if (reloc
->r_offset
< (size_t) (end
- start
))
14532 value
= read_leb128 (start
+ reloc
->r_offset
, end
, false,
14533 &reloc_size
, &leb_ret
);
14534 if (leb_ret
!= 0 || reloc_size
== 0 || reloc_size
> 8)
14535 error (_("LoongArch ULEB128 field at 0x%lx contains invalid "
14536 "ULEB128 value\n"),
14537 (long) reloc
->r_offset
);
14539 else if (sym_index
>= num_syms
)
14540 error (_("%s reloc contains invalid symbol index "
14543 ? "R_LARCH_ADD_ULEB128"
14544 : "R_LARCH_SUB_ULEB128"),
14548 if (reloc_type
== 107)
14549 value
+= reloc
->r_addend
+ symtab
[sym_index
].st_value
;
14551 value
-= reloc
->r_addend
+ symtab
[sym_index
].st_value
;
14553 /* Write uleb128 value to p. */
14554 bfd_byte
*p
= start
+ reloc
->r_offset
;
14557 bfd_byte c
= value
& 0x7f;
14559 if (--reloc_size
!= 0)
14563 while (reloc_size
);
14573 case EM_MSP430_OLD
:
14575 static Elf_Internal_Sym
* saved_sym
= NULL
;
14583 switch (reloc_type
)
14585 case 10: /* R_MSP430_SYM_DIFF */
14586 case 12: /* R_MSP430_GNU_SUB_ULEB128 */
14587 if (uses_msp430x_relocs (filedata
))
14589 /* Fall through. */
14590 case 21: /* R_MSP430X_SYM_DIFF */
14591 case 23: /* R_MSP430X_GNU_SUB_ULEB128 */
14593 if (sym_index
>= num_syms
)
14594 error (_("%s reloc contains invalid symbol index "
14595 "%" PRIu64
"\n"), "MSP430 SYM_DIFF", sym_index
);
14597 saved_sym
= symtab
+ sym_index
;
14600 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
14601 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
14602 goto handle_sym_diff
;
14604 case 5: /* R_MSP430_16_BYTE */
14605 case 9: /* R_MSP430_8 */
14606 case 11: /* R_MSP430_GNU_SET_ULEB128 */
14607 if (uses_msp430x_relocs (filedata
))
14609 goto handle_sym_diff
;
14611 case 2: /* R_MSP430_ABS16 */
14612 case 15: /* R_MSP430X_ABS16 */
14613 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
14614 if (! uses_msp430x_relocs (filedata
))
14616 goto handle_sym_diff
;
14619 if (saved_sym
!= NULL
)
14622 unsigned int reloc_size
= 0;
14624 switch (reloc_type
)
14626 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
14629 case 11: /* R_MSP430_GNU_SET_ULEB128 */
14630 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
14631 if (reloc
->r_offset
< (size_t) (end
- start
))
14632 read_leb128 (start
+ reloc
->r_offset
, end
, false,
14633 &reloc_size
, &leb_ret
);
14640 if (leb_ret
!= 0 || reloc_size
== 0 || reloc_size
> 8)
14641 error (_("MSP430 ULEB128 field at %#" PRIx64
14642 " contains invalid ULEB128 value\n"),
14644 else if (sym_index
>= num_syms
)
14645 error (_("%s reloc contains invalid symbol index "
14646 "%" PRIu64
"\n"), "MSP430", sym_index
);
14649 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
14650 - saved_sym
->st_value
);
14652 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
14653 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
14656 error (_("MSP430 sym diff reloc contains invalid offset: "
14667 if (saved_sym
!= NULL
)
14668 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
14675 case EM_CYGNUS_MN10300
:
14677 static Elf_Internal_Sym
* saved_sym
= NULL
;
14685 switch (reloc_type
)
14687 case 34: /* R_MN10300_ALIGN */
14689 case 33: /* R_MN10300_SYM_DIFF */
14690 if (sym_index
>= num_syms
)
14691 error (_("%s reloc contains invalid symbol index "
14692 "%" PRIu64
"\n"), "MN10300_SYM_DIFF", sym_index
);
14694 saved_sym
= symtab
+ sym_index
;
14697 case 1: /* R_MN10300_32 */
14698 case 2: /* R_MN10300_16 */
14699 if (saved_sym
!= NULL
)
14701 int reloc_size
= reloc_type
== 1 ? 4 : 2;
14704 if (sym_index
>= num_syms
)
14705 error (_("%s reloc contains invalid symbol index "
14706 "%" PRIu64
"\n"), "MN10300", sym_index
);
14709 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
14710 - saved_sym
->st_value
);
14712 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
14713 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
14715 error (_("MN10300 sym diff reloc contains invalid offset:"
14716 " %#" PRIx64
"\n"),
14725 if (saved_sym
!= NULL
)
14726 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
14734 static uint64_t saved_sym1
= 0;
14735 static uint64_t saved_sym2
= 0;
14736 static uint64_t value
;
14740 saved_sym1
= saved_sym2
= 0;
14744 switch (reloc_type
)
14746 case 0x80: /* R_RL78_SYM. */
14747 saved_sym1
= saved_sym2
;
14748 if (sym_index
>= num_syms
)
14749 error (_("%s reloc contains invalid symbol index "
14750 "%" PRIu64
"\n"), "RL78_SYM", sym_index
);
14753 saved_sym2
= symtab
[sym_index
].st_value
;
14754 saved_sym2
+= reloc
->r_addend
;
14758 case 0x83: /* R_RL78_OPsub. */
14759 value
= saved_sym1
- saved_sym2
;
14760 saved_sym2
= saved_sym1
= 0;
14764 case 0x41: /* R_RL78_ABS32. */
14765 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
14766 byte_put (start
+ reloc
->r_offset
, value
, 4);
14768 error (_("RL78 sym diff reloc contains invalid offset: "
14774 case 0x43: /* R_RL78_ABS16. */
14775 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
14776 byte_put (start
+ reloc
->r_offset
, value
, 2);
14778 error (_("RL78 sym diff reloc contains invalid offset: "
14794 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
14795 DWARF debug sections. This is a target specific test. Note - we do not
14796 go through the whole including-target-headers-multiple-times route, (as
14797 we have already done with <elf/h8.h>) because this would become very
14798 messy and even then this function would have to contain target specific
14799 information (the names of the relocs instead of their numeric values).
14800 FIXME: This is not the correct way to solve this problem. The proper way
14801 is to have target specific reloc sizing and typing functions created by
14802 the reloc-macros.h header, in the same way that it already creates the
14803 reloc naming functions. */
14806 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14808 /* Please keep this table alpha-sorted for ease of visual lookup. */
14809 switch (filedata
->file_header
.e_machine
)
14813 return reloc_type
== 1; /* R_386_32. */
14815 return reloc_type
== 1; /* R_68K_32. */
14817 return reloc_type
== 1; /* R_860_32. */
14819 return reloc_type
== 2; /* R_960_32. */
14821 return (reloc_type
== 258
14822 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
14824 return reloc_type
== 11; /* R_BPF_DATA_32 */
14825 case EM_ADAPTEVA_EPIPHANY
:
14826 return reloc_type
== 3;
14828 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
14830 return reloc_type
== 1; /* R_ARC_32. */
14831 case EM_ARC_COMPACT
:
14832 case EM_ARC_COMPACT2
:
14833 case EM_ARC_COMPACT3
:
14834 case EM_ARC_COMPACT3_64
:
14835 return reloc_type
== 4; /* R_ARC_32. */
14837 return reloc_type
== 2; /* R_ARM_ABS32 */
14840 return reloc_type
== 1;
14842 return reloc_type
== 0x12; /* R_byte4_data. */
14844 return reloc_type
== 3; /* R_CRIS_32. */
14846 return reloc_type
== 3; /* R_CR16_NUM32. */
14848 return reloc_type
== 15; /* R_CRX_NUM32. */
14850 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
14851 case EM_CYGNUS_FRV
:
14852 return reloc_type
== 1;
14853 case EM_CYGNUS_D10V
:
14855 return reloc_type
== 6; /* R_D10V_32. */
14856 case EM_CYGNUS_D30V
:
14858 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
14860 return reloc_type
== 3; /* R_DLX_RELOC_32. */
14861 case EM_CYGNUS_FR30
:
14863 return reloc_type
== 3; /* R_FR30_32. */
14865 return reloc_type
== 1; /* R_FT32_32. */
14869 return reloc_type
== 1; /* R_H8_DIR32. */
14871 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
14872 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
14873 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
14874 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
14877 return reloc_type
== 2; /* R_IP2K_32. */
14879 return reloc_type
== 2; /* R_IQ2000_32. */
14881 return reloc_type
== 2; /* R_KVX_32. */
14882 case EM_LATTICEMICO32
:
14883 return reloc_type
== 3; /* R_LM32_32. */
14885 return reloc_type
== 1; /* R_LARCH_32. */
14888 return reloc_type
== 3; /* R_M32C_32. */
14890 return reloc_type
== 34; /* R_M32R_32_RELA. */
14893 return reloc_type
== 6; /* R_M68HC11_32. */
14895 return reloc_type
== 7 || /* R_S12Z_EXT32 */
14896 reloc_type
== 6; /* R_S12Z_CW32. */
14898 return reloc_type
== 1; /* R_MCORE_ADDR32. */
14899 case EM_CYGNUS_MEP
:
14900 return reloc_type
== 4; /* R_MEP_32. */
14902 return reloc_type
== 2; /* R_METAG_ADDR32. */
14903 case EM_MICROBLAZE
:
14904 return reloc_type
== 1; /* R_MICROBLAZE_32. */
14906 return reloc_type
== 2; /* R_MIPS_32. */
14908 return reloc_type
== 4; /* R_MMIX_32. */
14909 case EM_CYGNUS_MN10200
:
14911 return reloc_type
== 1; /* R_MN10200_32. */
14912 case EM_CYGNUS_MN10300
:
14914 return reloc_type
== 1; /* R_MN10300_32. */
14916 return reloc_type
== 1; /* R_MOXIE_32. */
14917 case EM_MSP430_OLD
:
14919 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
14921 return reloc_type
== 2; /* R_MT_32. */
14923 return reloc_type
== 20; /* R_NDS32_32_RELA. */
14924 case EM_ALTERA_NIOS2
:
14925 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
14927 return reloc_type
== 1; /* R_NIOS_32. */
14929 return reloc_type
== 1; /* R_OR1K_32. */
14931 return (reloc_type
== 1 /* R_PARISC_DIR32. */
14932 || reloc_type
== 2 /* R_PARISC_DIR21L. */
14933 || reloc_type
== 41); /* R_PARISC_SECREL32. */
14936 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
14938 return reloc_type
== 1; /* R_PPC64_ADDR32. */
14940 return reloc_type
== 1; /* R_PPC_ADDR32. */
14942 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
14944 return reloc_type
== 1; /* R_RISCV_32. */
14946 return reloc_type
== 1; /* R_RL78_DIR32. */
14948 return reloc_type
== 1; /* R_RX_DIR32. */
14950 return reloc_type
== 1; /* R_I370_ADDR31. */
14953 return reloc_type
== 4; /* R_S390_32. */
14955 return reloc_type
== 8; /* R_SCORE_ABS32. */
14957 return reloc_type
== 1; /* R_SH_DIR32. */
14958 case EM_SPARC32PLUS
:
14961 return reloc_type
== 3 /* R_SPARC_32. */
14962 || reloc_type
== 23; /* R_SPARC_UA32. */
14964 return reloc_type
== 6; /* R_SPU_ADDR32 */
14966 return reloc_type
== 1; /* R_C6000_ABS32. */
14968 return reloc_type
== 2; /* R_TILEGX_32. */
14970 return reloc_type
== 1; /* R_TILEPRO_32. */
14971 case EM_CYGNUS_V850
:
14973 return reloc_type
== 6; /* R_V850_ABS32. */
14975 return reloc_type
== 0x33; /* R_V810_WORD. */
14977 return reloc_type
== 1; /* R_VAX_32. */
14979 return reloc_type
== 3; /* R_VISIUM_32. */
14980 case EM_WEBASSEMBLY
:
14981 return reloc_type
== 1; /* R_WASM32_32. */
14985 return reloc_type
== 10; /* R_X86_64_32. */
14987 return reloc_type
== 4; /* R_XGATE_32. */
14989 return reloc_type
== 1; /* R_XSTROMY16_32. */
14990 case EM_XTENSA_OLD
:
14992 return reloc_type
== 1; /* R_XTENSA_32. */
14994 return reloc_type
== 6; /* R_Z80_32. */
14997 static unsigned int prev_warn
= 0;
14999 /* Avoid repeating the same warning multiple times. */
15000 if (prev_warn
!= filedata
->file_header
.e_machine
)
15001 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
15002 filedata
->file_header
.e_machine
);
15003 prev_warn
= filedata
->file_header
.e_machine
;
15009 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15010 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
15013 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15015 switch (filedata
->file_header
.e_machine
)
15016 /* Please keep this table alpha-sorted for ease of visual lookup. */
15020 return reloc_type
== 2; /* R_386_PC32. */
15022 return reloc_type
== 4; /* R_68K_PC32. */
15024 return reloc_type
== 261; /* R_AARCH64_PREL32 */
15025 case EM_ADAPTEVA_EPIPHANY
:
15026 return reloc_type
== 6;
15028 return reloc_type
== 10; /* R_ALPHA_SREL32. */
15029 case EM_ARC_COMPACT
:
15030 case EM_ARC_COMPACT2
:
15031 case EM_ARC_COMPACT3
:
15032 case EM_ARC_COMPACT3_64
:
15033 return reloc_type
== 49; /* R_ARC_32_PCREL. */
15035 return reloc_type
== 3; /* R_ARM_REL32 */
15038 return reloc_type
== 36; /* R_AVR_32_PCREL. */
15040 return reloc_type
== 99; /* R_LARCH_32_PCREL. */
15041 case EM_MICROBLAZE
:
15042 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
15044 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
15046 return reloc_type
== 9; /* R_PARISC_PCREL32. */
15048 return reloc_type
== 26; /* R_PPC_REL32. */
15050 return reloc_type
== 26; /* R_PPC64_REL32. */
15052 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
15055 return reloc_type
== 5; /* R_390_PC32. */
15057 return reloc_type
== 2; /* R_SH_REL32. */
15058 case EM_SPARC32PLUS
:
15061 return reloc_type
== 6; /* R_SPARC_DISP32. */
15063 return reloc_type
== 13; /* R_SPU_REL32. */
15065 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
15067 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
15069 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
15073 return reloc_type
== 2; /* R_X86_64_PC32. */
15075 return reloc_type
== 4; /* R_VAX_PCREL32. */
15076 case EM_XTENSA_OLD
:
15078 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
15080 return reloc_type
== 7; /* R_KVX_32_PCREL */
15082 /* Do not abort or issue an error message here. Not all targets use
15083 pc-relative 32-bit relocs in their DWARF debug information and we
15084 have already tested for target coverage in is_32bit_abs_reloc. A
15085 more helpful warning message will be generated by apply_relocations
15086 anyway, so just return. */
15091 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15092 a 64-bit absolute RELA relocation used in DWARF debug sections. */
15095 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15097 switch (filedata
->file_header
.e_machine
)
15100 return reloc_type
== 257; /* R_AARCH64_ABS64. */
15101 case EM_ARC_COMPACT3_64
:
15102 return reloc_type
== 5; /* R_ARC_64. */
15104 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
15106 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
15107 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
15109 return reloc_type
== 2; /* R_LARCH_64 */
15111 return reloc_type
== 80; /* R_PARISC_DIR64. */
15113 return reloc_type
== 38; /* R_PPC64_ADDR64. */
15115 return reloc_type
== 2; /* R_RISCV_64. */
15116 case EM_SPARC32PLUS
:
15119 return reloc_type
== 32 /* R_SPARC_64. */
15120 || reloc_type
== 54; /* R_SPARC_UA64. */
15124 return reloc_type
== 1; /* R_X86_64_64. */
15127 return reloc_type
== 22; /* R_S390_64. */
15129 return reloc_type
== 1; /* R_TILEGX_64. */
15131 return reloc_type
== 18; /* R_MIPS_64. */
15133 return reloc_type
== 3; /* R_KVX_64 */
15139 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
15140 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
15143 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15145 switch (filedata
->file_header
.e_machine
)
15148 return reloc_type
== 260; /* R_AARCH64_PREL64. */
15150 return reloc_type
== 11; /* R_ALPHA_SREL64. */
15152 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
15153 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
15155 return reloc_type
== 72; /* R_PARISC_PCREL64. */
15157 return reloc_type
== 44; /* R_PPC64_REL64. */
15158 case EM_SPARC32PLUS
:
15161 return reloc_type
== 46; /* R_SPARC_DISP64. */
15165 return reloc_type
== 24; /* R_X86_64_PC64. */
15168 return reloc_type
== 23; /* R_S390_PC64. */
15170 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
15176 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15177 a 24-bit absolute RELA relocation used in DWARF debug sections. */
15180 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15182 switch (filedata
->file_header
.e_machine
)
15184 case EM_CYGNUS_MN10200
:
15186 return reloc_type
== 4; /* R_MN10200_24. */
15188 return reloc_type
== 5; /* R_FT32_20. */
15190 return reloc_type
== 5; /* R_Z80_24. */
15196 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15197 a 16-bit absolute RELA relocation used in DWARF debug sections. */
15200 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15202 /* Please keep this table alpha-sorted for ease of visual lookup. */
15203 switch (filedata
->file_header
.e_machine
)
15206 case EM_ARC_COMPACT
:
15207 case EM_ARC_COMPACT2
:
15208 case EM_ARC_COMPACT3
:
15209 case EM_ARC_COMPACT3_64
:
15210 return reloc_type
== 2; /* R_ARC_16. */
15211 case EM_ADAPTEVA_EPIPHANY
:
15212 return reloc_type
== 5;
15215 return reloc_type
== 4; /* R_AVR_16. */
15216 case EM_CYGNUS_D10V
:
15218 return reloc_type
== 3; /* R_D10V_16. */
15220 return reloc_type
== 2; /* R_FT32_16. */
15224 return reloc_type
== R_H8_DIR16
;
15227 return reloc_type
== 1; /* R_IP2K_16. */
15230 return reloc_type
== 1; /* R_M32C_16 */
15231 case EM_CYGNUS_MN10200
:
15233 return reloc_type
== 2; /* R_MN10200_16. */
15234 case EM_CYGNUS_MN10300
:
15236 return reloc_type
== 2; /* R_MN10300_16. */
15238 return reloc_type
== 1; /* R_KVX_16 */
15240 if (uses_msp430x_relocs (filedata
))
15241 return reloc_type
== 2; /* R_MSP430_ABS16. */
15242 /* Fall through. */
15243 case EM_MSP430_OLD
:
15244 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
15246 return reloc_type
== 19; /* R_NDS32_16_RELA. */
15247 case EM_ALTERA_NIOS2
:
15248 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
15250 return reloc_type
== 9; /* R_NIOS_16. */
15252 return reloc_type
== 2; /* R_OR1K_16. */
15254 return reloc_type
== 55; /* R_RISCV_SET16. */
15256 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
15258 return reloc_type
== 2; /* R_C6000_ABS16. */
15260 return reloc_type
== 2; /* R_VISIUM_16. */
15262 return reloc_type
== 3; /* R_XGATE_16. */
15264 return reloc_type
== 4; /* R_Z80_16. */
15270 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15271 a 8-bit absolute RELA relocation used in DWARF debug sections. */
15274 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15276 switch (filedata
->file_header
.e_machine
)
15279 return reloc_type
== 54; /* R_RISCV_SET8. */
15281 return reloc_type
== 1; /* R_Z80_8. */
15282 case EM_MICROBLAZE
:
15283 return (reloc_type
== 33 /* R_MICROBLAZE_32_NONE. */
15284 || reloc_type
== 0 /* R_MICROBLAZE_NONE. */
15285 || reloc_type
== 9 /* R_MICROBLAZE_64_NONE. */);
15291 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15292 a 6-bit absolute RELA relocation used in DWARF debug sections. */
15295 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15297 switch (filedata
->file_header
.e_machine
)
15300 return reloc_type
== 53; /* R_RISCV_SET6. */
15306 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15307 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
15310 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15312 /* Please keep this table alpha-sorted for ease of visual lookup. */
15313 switch (filedata
->file_header
.e_machine
)
15316 return reloc_type
== 50; /* R_LARCH_ADD32. */
15318 return reloc_type
== 35; /* R_RISCV_ADD32. */
15324 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15325 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
15328 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15330 /* Please keep this table alpha-sorted for ease of visual lookup. */
15331 switch (filedata
->file_header
.e_machine
)
15334 return reloc_type
== 55; /* R_LARCH_SUB32. */
15336 return reloc_type
== 39; /* R_RISCV_SUB32. */
15342 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15343 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
15346 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15348 /* Please keep this table alpha-sorted for ease of visual lookup. */
15349 switch (filedata
->file_header
.e_machine
)
15352 return reloc_type
== 51; /* R_LARCH_ADD64. */
15354 return reloc_type
== 36; /* R_RISCV_ADD64. */
15360 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15361 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
15364 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15366 /* Please keep this table alpha-sorted for ease of visual lookup. */
15367 switch (filedata
->file_header
.e_machine
)
15370 return reloc_type
== 56; /* R_LARCH_SUB64. */
15372 return reloc_type
== 40; /* R_RISCV_SUB64. */
15378 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15379 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
15382 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15384 /* Please keep this table alpha-sorted for ease of visual lookup. */
15385 switch (filedata
->file_header
.e_machine
)
15388 return reloc_type
== 48; /* R_LARCH_ADD16. */
15390 return reloc_type
== 34; /* R_RISCV_ADD16. */
15396 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15397 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
15400 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15402 /* Please keep this table alpha-sorted for ease of visual lookup. */
15403 switch (filedata
->file_header
.e_machine
)
15406 return reloc_type
== 53; /* R_LARCH_SUB16. */
15408 return reloc_type
== 38; /* R_RISCV_SUB16. */
15414 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15415 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
15418 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15420 /* Please keep this table alpha-sorted for ease of visual lookup. */
15421 switch (filedata
->file_header
.e_machine
)
15424 return reloc_type
== 47; /* R_LARCH_ADD8. */
15426 return reloc_type
== 33; /* R_RISCV_ADD8. */
15432 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15433 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
15436 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15438 /* Please keep this table alpha-sorted for ease of visual lookup. */
15439 switch (filedata
->file_header
.e_machine
)
15442 return reloc_type
== 52; /* R_LARCH_SUB8. */
15444 return reloc_type
== 37; /* R_RISCV_SUB8. */
15450 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15451 a 6-bit inplace add RELA relocation used in DWARF debug sections. */
15454 is_6bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15456 switch (filedata
->file_header
.e_machine
)
15459 return reloc_type
== 105; /* R_LARCH_ADD6. */
15465 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
15466 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
15469 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15471 switch (filedata
->file_header
.e_machine
)
15474 return reloc_type
== 106; /* R_LARCH_SUB6. */
15476 return reloc_type
== 52; /* R_RISCV_SUB6. */
15482 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
15483 relocation entries (possibly formerly used for SHT_GROUP sections). */
15486 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
15488 switch (filedata
->file_header
.e_machine
)
15490 case EM_386
: /* R_386_NONE. */
15491 case EM_68K
: /* R_68K_NONE. */
15492 case EM_ADAPTEVA_EPIPHANY
:
15493 case EM_ALPHA
: /* R_ALPHA_NONE. */
15494 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
15495 case EM_ARC
: /* R_ARC_NONE. */
15496 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
15497 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
15498 case EM_ARC_COMPACT3
: /* R_ARC_NONE. */
15499 case EM_ARC_COMPACT3_64
: /* R_ARC_NONE. */
15500 case EM_ARM
: /* R_ARM_NONE. */
15501 case EM_CRIS
: /* R_CRIS_NONE. */
15502 case EM_FT32
: /* R_FT32_NONE. */
15503 case EM_IA_64
: /* R_IA64_NONE. */
15504 case EM_K1OM
: /* R_X86_64_NONE. */
15505 case EM_KVX
: /* R_KVX_NONE. */
15506 case EM_L1OM
: /* R_X86_64_NONE. */
15507 case EM_M32R
: /* R_M32R_NONE. */
15508 case EM_MIPS
: /* R_MIPS_NONE. */
15509 case EM_MN10300
: /* R_MN10300_NONE. */
15510 case EM_MOXIE
: /* R_MOXIE_NONE. */
15511 case EM_NIOS32
: /* R_NIOS_NONE. */
15512 case EM_OR1K
: /* R_OR1K_NONE. */
15513 case EM_PARISC
: /* R_PARISC_NONE. */
15514 case EM_PPC64
: /* R_PPC64_NONE. */
15515 case EM_PPC
: /* R_PPC_NONE. */
15516 case EM_RISCV
: /* R_RISCV_NONE. */
15517 case EM_S390
: /* R_390_NONE. */
15519 case EM_SH
: /* R_SH_NONE. */
15520 case EM_SPARC32PLUS
:
15521 case EM_SPARC
: /* R_SPARC_NONE. */
15523 case EM_TILEGX
: /* R_TILEGX_NONE. */
15524 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
15525 case EM_TI_C6000
:/* R_C6000_NONE. */
15526 case EM_X86_64
: /* R_X86_64_NONE. */
15527 case EM_Z80
: /* R_Z80_NONE. */
15528 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
15529 return reloc_type
== 0;
15532 return reloc_type
== 0 || reloc_type
== 256;
15535 return (reloc_type
== 0 /* R_AVR_NONE. */
15536 || reloc_type
== 30 /* R_AVR_DIFF8. */
15537 || reloc_type
== 31 /* R_AVR_DIFF16. */
15538 || reloc_type
== 32 /* R_AVR_DIFF32. */);
15540 return reloc_type
== 3; /* R_METAG_NONE. */
15542 return (reloc_type
== 0 /* R_NDS32_NONE. */
15543 || reloc_type
== 205 /* R_NDS32_DIFF8. */
15544 || reloc_type
== 206 /* R_NDS32_DIFF16. */
15545 || reloc_type
== 207 /* R_NDS32_DIFF32. */
15546 || reloc_type
== 208 /* R_NDS32_DIFF_ULEB128. */);
15548 return (reloc_type
== 0 /* R_PRU_NONE. */
15549 || reloc_type
== 65 /* R_PRU_DIFF8. */
15550 || reloc_type
== 66 /* R_PRU_DIFF16. */
15551 || reloc_type
== 67 /* R_PRU_DIFF32. */);
15552 case EM_XTENSA_OLD
:
15554 return (reloc_type
== 0 /* R_XTENSA_NONE. */
15555 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
15556 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
15557 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
15558 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
15559 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
15560 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
15561 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
15562 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
15563 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
15568 /* Returns TRUE if there is a relocation against
15569 section NAME at OFFSET bytes. */
15572 reloc_at (struct dwarf_section
* dsec
, uint64_t offset
)
15574 Elf_Internal_Rela
* relocs
;
15575 Elf_Internal_Rela
* rp
;
15577 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
15580 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
15582 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
15583 if (rp
->r_offset
== offset
)
15589 /* Apply relocations to a section.
15590 Returns TRUE upon success, FALSE otherwise.
15591 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
15592 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
15593 will be set to the number of relocs loaded.
15595 Note: So far support has been added only for those relocations
15596 which can be found in debug sections. FIXME: Add support for
15597 more relocations ? */
15600 apply_relocations (Filedata
*filedata
,
15601 const Elf_Internal_Shdr
*section
,
15602 unsigned char *start
,
15604 void **relocs_return
,
15605 uint64_t *num_relocs_return
)
15607 Elf_Internal_Shdr
* relsec
;
15608 unsigned char * end
= start
+ size
;
15610 if (relocs_return
!= NULL
)
15612 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
15613 * num_relocs_return
= 0;
15616 if (filedata
->file_header
.e_type
!= ET_REL
)
15617 /* No relocs to apply. */
15620 /* Find the reloc section associated with the section. */
15621 for (relsec
= filedata
->section_headers
;
15622 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
15626 uint64_t num_relocs
;
15627 Elf_Internal_Rela
* relocs
;
15628 Elf_Internal_Rela
* rp
;
15629 Elf_Internal_Shdr
* symsec
;
15630 Elf_Internal_Sym
* symtab
;
15632 Elf_Internal_Sym
* sym
;
15634 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
15635 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
15636 || filedata
->section_headers
+ relsec
->sh_info
!= section
15637 || relsec
->sh_size
== 0
15638 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
15641 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
15642 if (symsec
->sh_type
!= SHT_SYMTAB
15643 && symsec
->sh_type
!= SHT_DYNSYM
)
15646 is_rela
= relsec
->sh_type
== SHT_RELA
;
15650 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
15651 relsec
->sh_size
, & relocs
, & num_relocs
))
15656 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
15657 relsec
->sh_size
, & relocs
, & num_relocs
))
15661 /* SH uses RELA but uses in place value instead of the addend field. */
15662 if (filedata
->file_header
.e_machine
== EM_SH
)
15665 symtab
= get_elf_symbols (filedata
, symsec
, & num_syms
);
15667 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
15670 unsigned int reloc_type
;
15671 unsigned int reloc_size
;
15672 bool reloc_inplace
= false;
15673 bool reloc_subtract
= false;
15674 unsigned char *rloc
;
15675 uint64_t sym_index
;
15677 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
15679 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
15681 else if (is_none_reloc (filedata
, reloc_type
))
15683 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
15684 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
15686 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
15687 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
15689 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
15691 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
15693 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
15694 || is_6bit_abs_reloc (filedata
, reloc_type
))
15696 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
15698 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
15701 reloc_inplace
= true;
15703 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
15705 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
15708 reloc_inplace
= true;
15710 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
15712 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
15715 reloc_inplace
= true;
15717 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
15719 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
15722 reloc_inplace
= true;
15724 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
15726 || is_6bit_inplace_add_reloc (filedata
, reloc_type
))
15729 reloc_inplace
= true;
15733 static unsigned int prev_reloc
= 0;
15735 if (reloc_type
!= prev_reloc
)
15736 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
15737 reloc_type
, printable_section_name (filedata
, section
));
15738 prev_reloc
= reloc_type
;
15742 rloc
= start
+ rp
->r_offset
;
15743 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
15745 warn (_("skipping invalid relocation offset %#" PRIx64
15746 " in section %s\n"),
15748 printable_section_name (filedata
, section
));
15752 sym_index
= get_reloc_symindex (rp
->r_info
);
15753 if (sym_index
>= num_syms
)
15755 warn (_("skipping invalid relocation symbol index %#" PRIx64
15756 " in section %s\n"),
15757 sym_index
, printable_section_name (filedata
, section
));
15760 sym
= symtab
+ sym_index
;
15762 /* If the reloc has a symbol associated with it,
15763 make sure that it is of an appropriate type.
15765 Relocations against symbols without type can happen.
15766 Gcc -feliminate-dwarf2-dups may generate symbols
15767 without type for debug info.
15769 Icc generates relocations against function symbols
15770 instead of local labels.
15772 Relocations against object symbols can happen, eg when
15773 referencing a global array. For an example of this see
15774 the _clz.o binary in libgcc.a. */
15776 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
15777 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
15779 warn (_("skipping unexpected symbol type %s in section %s relocation %tu\n"),
15780 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
15781 printable_section_name (filedata
, relsec
),
15788 addend
+= rp
->r_addend
;
15789 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
15790 partial_inplace. */
15792 || (filedata
->file_header
.e_machine
== EM_XTENSA
15793 && reloc_type
== 1)
15794 || ((filedata
->file_header
.e_machine
== EM_PJ
15795 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
15796 && reloc_type
== 1)
15797 || ((filedata
->file_header
.e_machine
== EM_D30V
15798 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
15799 && reloc_type
== 12)
15802 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
15803 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
15805 addend
+= byte_get (rloc
, reloc_size
);
15808 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
15809 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
15811 /* On HPPA, all pc-relative relocations are biased by 8. */
15812 if (filedata
->file_header
.e_machine
== EM_PARISC
)
15814 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
15817 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
15818 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
)
15819 || is_6bit_inplace_add_reloc (filedata
, reloc_type
))
15821 if (reloc_subtract
)
15822 addend
-= sym
->st_value
;
15824 addend
+= sym
->st_value
;
15825 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
15826 byte_put (rloc
, addend
, reloc_size
);
15828 else if (reloc_subtract
)
15829 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
15831 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
15835 /* Let the target specific reloc processing code know that
15836 we have finished with these relocs. */
15837 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
15841 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
15842 * num_relocs_return
= num_relocs
;
15853 #ifdef SUPPORT_DISASSEMBLY
15855 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15857 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
15859 /* FIXME: XXX -- to be done --- XXX */
15865 /* Reads in the contents of SECTION from FILE, returning a pointer
15866 to a malloc'ed buffer or NULL if something went wrong. */
15869 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15871 uint64_t num_bytes
= section
->sh_size
;
15873 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
15875 printf (_("Section '%s' has no data to dump.\n"),
15876 printable_section_name (filedata
, section
));
15880 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
15881 _("section contents"));
15884 /* Uncompresses a section that was compressed using zlib/zstd, in place. */
15887 uncompress_section_contents (bool is_zstd
,
15888 unsigned char ** buffer
,
15889 uint64_t uncompressed_size
,
15891 uint64_t file_size
)
15893 uint64_t compressed_size
= *size
;
15894 unsigned char *compressed_buffer
= *buffer
;
15895 unsigned char *uncompressed_buffer
= NULL
;
15899 /* Similar to _bfd_section_size_insane() in the BFD library we expect an
15900 upper limit of ~10x compression. Any compression larger than that is
15901 thought to be due to fuzzing of the compression header. */
15902 if (uncompressed_size
> file_size
* 10)
15904 error (_("Uncompressed section size is suspiciously large: 0x%" PRIu64
"\n"),
15905 uncompressed_size
);
15909 uncompressed_buffer
= xmalloc (uncompressed_size
);
15914 size_t ret
= ZSTD_decompress (uncompressed_buffer
, uncompressed_size
,
15915 compressed_buffer
, compressed_size
);
15916 if (ZSTD_isError (ret
))
15922 /* It is possible the section consists of several compressed
15923 buffers concatenated together, so we uncompress in a loop. */
15924 /* PR 18313: The state field in the z_stream structure is supposed
15925 to be invisible to the user (ie us), but some compilers will
15926 still complain about it being used without initialisation. So
15927 we first zero the entire z_stream structure and then set the fields
15929 memset (&strm
, 0, sizeof strm
);
15930 strm
.avail_in
= compressed_size
;
15931 strm
.next_in
= (Bytef
*)compressed_buffer
;
15932 strm
.avail_out
= uncompressed_size
;
15934 rc
= inflateInit (&strm
);
15935 while (strm
.avail_in
> 0)
15939 strm
.next_out
= ((Bytef
*)uncompressed_buffer
15940 + (uncompressed_size
- strm
.avail_out
));
15941 rc
= inflate (&strm
, Z_FINISH
);
15942 if (rc
!= Z_STREAM_END
)
15944 rc
= inflateReset (&strm
);
15946 if (inflateEnd (&strm
) != Z_OK
|| rc
!= Z_OK
|| strm
.avail_out
!= 0)
15950 *buffer
= uncompressed_buffer
;
15951 *size
= uncompressed_size
;
15955 free (uncompressed_buffer
);
15956 /* Indicate decompression failure. */
15962 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15964 Elf_Internal_Shdr
*relsec
;
15965 uint64_t num_bytes
;
15966 unsigned char *data
;
15967 unsigned char *end
;
15968 unsigned char *real_start
;
15969 unsigned char *start
;
15970 bool some_strings_shown
;
15972 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
15974 /* PR 21820: Do not fail if the section was empty. */
15975 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
15977 num_bytes
= section
->sh_size
;
15979 if (filedata
->is_separate
)
15980 printf (_("\nString dump of section '%s' in linked file %s:\n"),
15981 printable_section_name (filedata
, section
),
15982 filedata
->file_name
);
15984 printf (_("\nString dump of section '%s':\n"),
15985 printable_section_name (filedata
, section
));
15987 if (decompress_dumps
)
15989 uint64_t new_size
= num_bytes
;
15990 uint64_t uncompressed_size
= 0;
15991 bool is_zstd
= false;
15993 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
15995 Elf_Internal_Chdr chdr
;
15996 unsigned int compression_header_size
15997 = get_compression_header (& chdr
, (unsigned char *) start
,
15999 if (compression_header_size
== 0)
16000 /* An error message will have already been generated
16001 by get_compression_header. */
16004 if (chdr
.ch_type
== ch_compress_zlib
)
16007 else if (chdr
.ch_type
== ch_compress_zstd
)
16012 warn (_("section '%s' has unsupported compress type: %d\n"),
16013 printable_section_name (filedata
, section
), chdr
.ch_type
);
16016 uncompressed_size
= chdr
.ch_size
;
16017 start
+= compression_header_size
;
16018 new_size
-= compression_header_size
;
16020 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
16022 /* Read the zlib header. In this case, it should be "ZLIB"
16023 followed by the uncompressed section size, 8 bytes in
16024 big-endian order. */
16025 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
16026 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
16027 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
16028 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
16029 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
16030 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
16031 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
16032 uncompressed_size
+= start
[11];
16037 if (uncompressed_size
)
16039 if (uncompress_section_contents (is_zstd
, &start
, uncompressed_size
,
16040 &new_size
, filedata
->file_size
))
16041 num_bytes
= new_size
;
16044 error (_("Unable to decompress section %s\n"),
16045 printable_section_name (filedata
, section
));
16050 start
= real_start
;
16053 /* If the section being dumped has relocations against it the user might
16054 be expecting these relocations to have been applied. Check for this
16055 case and issue a warning message in order to avoid confusion.
16056 FIXME: Maybe we ought to have an option that dumps a section with
16057 relocs applied ? */
16058 for (relsec
= filedata
->section_headers
;
16059 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
16062 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
16063 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
16064 || filedata
->section_headers
+ relsec
->sh_info
!= section
16065 || relsec
->sh_size
== 0
16066 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
16069 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
16074 end
= start
+ num_bytes
;
16075 some_strings_shown
= false;
16077 #ifdef HAVE_MBSTATE_T
16079 /* Initialise the multibyte conversion state. */
16080 memset (& state
, 0, sizeof (state
));
16083 bool continuing
= false;
16087 while (!ISPRINT (* data
))
16088 if (++ data
>= end
)
16093 size_t maxlen
= end
- data
;
16098 continuing
= false;
16102 printf (" [%6tx] ", data
- start
);
16116 /* PR 25543: Treat new-lines as string-ending characters. */
16125 /* Do not print control characters directly as they can affect terminal
16126 settings. Such characters usually appear in the names generated
16127 by the assembler for local labels. */
16130 printf ("^%c", c
+ 0x40);
16132 else if (ISPRINT (c
))
16139 #ifdef HAVE_MBSTATE_T
16142 /* Let printf do the hard work of displaying multibyte characters. */
16143 printf ("%.1s", data
- 1);
16144 #ifdef HAVE_MBSTATE_T
16145 /* Try to find out how many bytes made up the character that was
16146 just printed. Advance the symbol pointer past the bytes that
16148 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
16152 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
16162 printf (_("<corrupt>\n"));
16165 some_strings_shown
= true;
16169 if (! some_strings_shown
)
16170 printf (_(" No strings found in this section."));
16183 dump_section_as_bytes (Elf_Internal_Shdr
*section
,
16184 Filedata
*filedata
,
16187 Elf_Internal_Shdr
*relsec
;
16189 uint64_t section_size
;
16191 unsigned char *data
;
16192 unsigned char *real_start
;
16193 unsigned char *start
;
16195 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
16197 /* PR 21820: Do not fail if the section was empty. */
16198 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
16200 section_size
= section
->sh_size
;
16202 if (filedata
->is_separate
)
16203 printf (_("\nHex dump of section '%s' in linked file %s:\n"),
16204 printable_section_name (filedata
, section
),
16205 filedata
->file_name
);
16207 printf (_("\nHex dump of section '%s':\n"),
16208 printable_section_name (filedata
, section
));
16210 if (decompress_dumps
)
16212 uint64_t new_size
= section_size
;
16213 uint64_t uncompressed_size
= 0;
16214 bool is_zstd
= false;
16216 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
16218 Elf_Internal_Chdr chdr
;
16219 unsigned int compression_header_size
16220 = get_compression_header (& chdr
, start
, section_size
);
16222 if (compression_header_size
== 0)
16223 /* An error message will have already been generated
16224 by get_compression_header. */
16227 if (chdr
.ch_type
== ch_compress_zlib
)
16230 else if (chdr
.ch_type
== ch_compress_zstd
)
16235 warn (_("section '%s' has unsupported compress type: %d\n"),
16236 printable_section_name (filedata
, section
), chdr
.ch_type
);
16239 uncompressed_size
= chdr
.ch_size
;
16240 start
+= compression_header_size
;
16241 new_size
-= compression_header_size
;
16243 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
16245 /* Read the zlib header. In this case, it should be "ZLIB"
16246 followed by the uncompressed section size, 8 bytes in
16247 big-endian order. */
16248 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
16249 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
16250 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
16251 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
16252 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
16253 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
16254 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
16255 uncompressed_size
+= start
[11];
16260 if (uncompressed_size
)
16262 if (uncompress_section_contents (is_zstd
, &start
, uncompressed_size
,
16263 &new_size
, filedata
->file_size
))
16265 section_size
= new_size
;
16269 error (_("Unable to decompress section %s\n"),
16270 printable_section_name (filedata
, section
));
16271 /* FIXME: Print the section anyway ? */
16276 start
= real_start
;
16281 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
16286 /* If the section being dumped has relocations against it the user might
16287 be expecting these relocations to have been applied. Check for this
16288 case and issue a warning message in order to avoid confusion.
16289 FIXME: Maybe we ought to have an option that dumps a section with
16290 relocs applied ? */
16291 for (relsec
= filedata
->section_headers
;
16292 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
16295 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
16296 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
16297 || filedata
->section_headers
+ relsec
->sh_info
!= section
16298 || relsec
->sh_size
== 0
16299 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
16302 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
16307 addr
= section
->sh_addr
;
16308 bytes
= section_size
;
16317 lbytes
= (bytes
> 16 ? 16 : bytes
);
16319 printf (" 0x%8.8" PRIx64
" ", addr
);
16321 for (j
= 0; j
< 16; j
++)
16324 printf ("%2.2x", data
[j
]);
16332 for (j
= 0; j
< lbytes
; j
++)
16335 if (k
>= ' ' && k
< 0x7f)
16358 #ifdef ENABLE_LIBCTF
16359 static ctf_sect_t
*
16360 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
16362 buf
->cts_name
= printable_section_name (filedata
, shdr
);
16363 buf
->cts_size
= shdr
->sh_size
;
16364 buf
->cts_entsize
= shdr
->sh_entsize
;
16369 /* Formatting callback function passed to ctf_dump. Returns either the pointer
16370 it is passed, or a pointer to newly-allocated storage, in which case
16371 dump_ctf() will free it when it no longer needs it. */
16374 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
16375 char *s
, void *arg
)
16377 const char *blanks
= arg
;
16380 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
16385 /* Dump CTF errors/warnings. */
16387 dump_ctf_errs (ctf_dict_t
*fp
)
16389 ctf_next_t
*it
= NULL
;
16394 /* Dump accumulated errors and warnings. */
16395 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
16397 error (_("%s: %s"), is_warning
? _("warning"): _("error"),
16401 if (err
!= ECTF_NEXT_END
)
16402 error (_("CTF error: cannot get CTF errors: `%s'"), ctf_errmsg (err
));
16405 /* Dump one CTF archive member. */
16408 dump_ctf_archive_member (ctf_dict_t
*ctf
, const char *name
, ctf_dict_t
*parent
,
16411 const char *things
[] = {"Header", "Labels", "Data objects",
16412 "Function objects", "Variables", "Types", "Strings",
16414 const char **thing
;
16417 /* Don't print out the name of the default-named archive member if it appears
16418 first in the list. The name .ctf appears everywhere, even for things that
16419 aren't really archives, so printing it out is liable to be confusing; also,
16420 the common case by far is for only one archive member to exist, and hiding
16421 it in that case seems worthwhile. */
16423 if (strcmp (name
, ".ctf") != 0 || member
!= 0)
16424 printf (_("\nCTF archive member: %s:\n"), name
);
16426 if (ctf_parent_name (ctf
) != NULL
)
16427 ctf_import (ctf
, parent
);
16429 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
16431 ctf_dump_state_t
*s
= NULL
;
16434 printf ("\n %s:\n", *thing
);
16435 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
16436 (void *) " ")) != NULL
)
16438 printf ("%s\n", item
);
16442 if (ctf_errno (ctf
))
16444 error (_("Iteration failed: %s, %s\n"), *thing
,
16445 ctf_errmsg (ctf_errno (ctf
)));
16450 dump_ctf_errs (ctf
);
16454 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
16456 Elf_Internal_Shdr
* symtab_sec
= NULL
;
16457 Elf_Internal_Shdr
* strtab_sec
= NULL
;
16458 void * data
= NULL
;
16459 void * symdata
= NULL
;
16460 void * strdata
= NULL
;
16461 ctf_sect_t ctfsect
, symsect
, strsect
;
16462 ctf_sect_t
* symsectp
= NULL
;
16463 ctf_sect_t
* strsectp
= NULL
;
16464 ctf_archive_t
* ctfa
= NULL
;
16465 ctf_dict_t
* parent
= NULL
;
16468 ctf_next_t
*i
= NULL
;
16474 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
16475 data
= get_section_contents (section
, filedata
);
16476 ctfsect
.cts_data
= data
;
16478 if (!dump_ctf_symtab_name
)
16479 dump_ctf_symtab_name
= strdup (".dynsym");
16481 if (!dump_ctf_strtab_name
)
16482 dump_ctf_strtab_name
= strdup (".dynstr");
16484 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
16486 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
16488 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
16491 if ((symdata
= (void *) get_data (NULL
, filedata
,
16492 symtab_sec
->sh_offset
, 1,
16493 symtab_sec
->sh_size
,
16494 _("symbols"))) == NULL
)
16496 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
16497 symsect
.cts_data
= symdata
;
16500 if (dump_ctf_strtab_name
&& dump_ctf_strtab_name
[0] != 0)
16502 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
16504 error (_("No string table section named %s\n"),
16505 dump_ctf_strtab_name
);
16508 if ((strdata
= (void *) get_data (NULL
, filedata
,
16509 strtab_sec
->sh_offset
, 1,
16510 strtab_sec
->sh_size
,
16511 _("strings"))) == NULL
)
16513 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
16514 strsect
.cts_data
= strdata
;
16517 /* Load the CTF file and dump it. It may be a raw CTF section, or an archive:
16518 libctf papers over the difference, so we can pretend it is always an
16521 if ((ctfa
= ctf_arc_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
16523 dump_ctf_errs (NULL
);
16524 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
16528 ctf_arc_symsect_endianness (ctfa
, filedata
->file_header
.e_ident
[EI_DATA
]
16531 /* Preload the parent dict, since it will need to be imported into every
16533 if ((parent
= ctf_dict_open (ctfa
, dump_ctf_parent_name
, &err
)) == NULL
)
16535 dump_ctf_errs (NULL
);
16536 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
16542 if (filedata
->is_separate
)
16543 printf (_("\nDump of CTF section '%s' in linked file %s:\n"),
16544 printable_section_name (filedata
, section
),
16545 filedata
->file_name
);
16547 printf (_("\nDump of CTF section '%s':\n"),
16548 printable_section_name (filedata
, section
));
16550 while ((fp
= ctf_archive_next (ctfa
, &i
, &name
, 0, &err
)) != NULL
)
16551 dump_ctf_archive_member (fp
, name
, parent
, member
++);
16552 if (err
!= ECTF_NEXT_END
)
16554 dump_ctf_errs (NULL
);
16555 error (_("CTF member open failure: %s\n"), ctf_errmsg (err
));
16560 ctf_dict_close (parent
);
16570 dump_section_as_sframe (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
16572 void * data
= NULL
;
16573 sframe_decoder_ctx
*sfd_ctx
= NULL
;
16574 const char *print_name
= printable_section_name (filedata
, section
);
16580 if (strcmp (print_name
, "") == 0)
16582 error (_("Section name must be provided \n"));
16587 data
= get_section_contents (section
, filedata
);
16588 sf_size
= section
->sh_size
;
16589 /* Decode the contents of the section. */
16590 sfd_ctx
= sframe_decode ((const char*)data
, sf_size
, &err
);
16594 error (_("SFrame decode failure: %s\n"), sframe_errmsg (err
));
16598 printf (_("Contents of the SFrame section %s:"), print_name
);
16599 /* Dump the contents as text. */
16600 dump_sframe (sfd_ctx
, section
->sh_addr
);
16608 load_specific_debug_section (enum dwarf_section_display_enum debug
,
16609 const Elf_Internal_Shdr
* sec
,
16612 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
16614 Filedata
* filedata
= (Filedata
*) data
;
16616 if (section
->start
!= NULL
)
16618 /* If it is already loaded, do nothing. */
16619 if (streq (section
->filename
, filedata
->file_name
))
16621 free (section
->start
);
16624 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
16625 section
->address
= sec
->sh_addr
;
16626 section
->filename
= filedata
->file_name
;
16627 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
16629 sec
->sh_size
, buf
);
16630 if (section
->start
== NULL
)
16634 unsigned char *start
= section
->start
;
16635 uint64_t size
= sec
->sh_size
;
16636 uint64_t uncompressed_size
= 0;
16637 bool is_zstd
= false;
16639 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
16641 Elf_Internal_Chdr chdr
;
16642 unsigned int compression_header_size
;
16644 if (size
< (is_32bit_elf
16645 ? sizeof (Elf32_External_Chdr
)
16646 : sizeof (Elf64_External_Chdr
)))
16648 warn (_("compressed section %s is too small to contain a compression header\n"),
16653 compression_header_size
= get_compression_header (&chdr
, start
, size
);
16654 if (compression_header_size
== 0)
16655 /* An error message will have already been generated
16656 by get_compression_header. */
16659 if (chdr
.ch_type
== ch_compress_zlib
)
16662 else if (chdr
.ch_type
== ch_compress_zstd
)
16667 warn (_("section '%s' has unsupported compress type: %d\n"),
16668 section
->name
, chdr
.ch_type
);
16671 uncompressed_size
= chdr
.ch_size
;
16672 start
+= compression_header_size
;
16673 size
-= compression_header_size
;
16675 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
16677 /* Read the zlib header. In this case, it should be "ZLIB"
16678 followed by the uncompressed section size, 8 bytes in
16679 big-endian order. */
16680 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
16681 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
16682 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
16683 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
16684 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
16685 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
16686 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
16687 uncompressed_size
+= start
[11];
16692 if (uncompressed_size
)
16694 if (uncompress_section_contents (is_zstd
, &start
, uncompressed_size
,
16695 &size
, filedata
->file_size
))
16697 /* Free the compressed buffer, update the section buffer
16698 and the section size if uncompress is successful. */
16699 free (section
->start
);
16700 section
->start
= start
;
16704 error (_("Unable to decompress section %s\n"),
16705 printable_section_name (filedata
, sec
));
16710 section
->size
= size
;
16713 if (section
->start
== NULL
)
16716 if (debug_displays
[debug
].relocate
)
16718 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
16719 & section
->reloc_info
, & section
->num_relocs
))
16724 section
->reloc_info
= NULL
;
16725 section
->num_relocs
= 0;
16731 #if HAVE_LIBDEBUGINFOD
16732 /* Return a hex string representation of the build-id. */
16734 get_build_id (void * data
)
16736 Filedata
* filedata
= (Filedata
*) data
;
16737 Elf_Internal_Shdr
* shdr
;
16740 /* Iterate through notes to find note.gnu.build-id.
16741 FIXME: Only the first note in any note section is examined. */
16742 for (i
= 0, shdr
= filedata
->section_headers
;
16743 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
16746 if (shdr
->sh_type
!= SHT_NOTE
)
16751 size_t data_remaining
;
16753 Elf_External_Note
* enote
;
16754 Elf_Internal_Note inote
;
16756 uint64_t offset
= shdr
->sh_offset
;
16757 uint64_t align
= shdr
->sh_addralign
;
16758 uint64_t length
= shdr
->sh_size
;
16760 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
16766 else if (align
!= 4 && align
!= 8)
16772 end
= (char *) enote
+ length
;
16773 data_remaining
= end
- (char *) enote
;
16775 if (!is_ia64_vms (filedata
))
16777 min_notesz
= offsetof (Elf_External_Note
, name
);
16778 if (data_remaining
< min_notesz
)
16781 malformed note encountered in section %s whilst scanning for build-id note\n"),
16782 printable_section_name (filedata
, shdr
));
16786 data_remaining
-= min_notesz
;
16788 inote
.type
= BYTE_GET (enote
->type
);
16789 inote
.namesz
= BYTE_GET (enote
->namesz
);
16790 inote
.namedata
= enote
->name
;
16791 inote
.descsz
= BYTE_GET (enote
->descsz
);
16792 inote
.descdata
= ((char *) enote
16793 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
16794 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
16795 next
= ((char *) enote
16796 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
16800 Elf64_External_VMS_Note
*vms_enote
;
16802 /* PR binutils/15191
16803 Make sure that there is enough data to read. */
16804 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
16805 if (data_remaining
< min_notesz
)
16808 malformed note encountered in section %s whilst scanning for build-id note\n"),
16809 printable_section_name (filedata
, shdr
));
16813 data_remaining
-= min_notesz
;
16815 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
16816 inote
.type
= BYTE_GET (vms_enote
->type
);
16817 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
16818 inote
.namedata
= vms_enote
->name
;
16819 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
16820 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
16821 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
16822 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
16825 /* Skip malformed notes. */
16826 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
16827 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
16828 || (size_t) (next
- inote
.descdata
) < inote
.descsz
16829 || ((size_t) (next
- inote
.descdata
)
16830 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
16833 malformed note encountered in section %s whilst scanning for build-id note\n"),
16834 printable_section_name (filedata
, shdr
));
16839 /* Check if this is the build-id note. If so then convert the build-id
16840 bytes to a hex string. */
16841 if (inote
.namesz
> 0
16842 && startswith (inote
.namedata
, "GNU")
16843 && inote
.type
== NT_GNU_BUILD_ID
)
16848 build_id
= malloc (inote
.descsz
* 2 + 1);
16849 if (build_id
== NULL
)
16855 for (j
= 0; j
< inote
.descsz
; ++j
)
16856 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
16857 build_id
[inote
.descsz
* 2] = '\0';
16860 return (unsigned char *) build_id
;
16867 #endif /* HAVE_LIBDEBUGINFOD */
16869 /* If this is not NULL, load_debug_section will only look for sections
16870 within the list of sections given here. */
16871 static unsigned int * section_subset
= NULL
;
16874 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
16876 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
16877 Elf_Internal_Shdr
* sec
;
16878 Filedata
* filedata
= (Filedata
*) data
;
16880 if (!dump_any_debugging
)
16883 /* Without section headers we cannot find any sections. */
16884 if (filedata
->section_headers
== NULL
)
16887 if (filedata
->string_table
== NULL
16888 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
16889 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
16891 Elf_Internal_Shdr
* strs
;
16893 /* Read in the string table, so that we have section names to scan. */
16894 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
16896 if (strs
!= NULL
&& strs
->sh_size
!= 0)
16898 filedata
->string_table
16899 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
16900 1, strs
->sh_size
, _("string table"));
16902 filedata
->string_table_length
16903 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
16907 /* Locate the debug section. */
16908 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
16910 section
->name
= section
->uncompressed_name
;
16913 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
16915 section
->name
= section
->compressed_name
;
16920 /* If we're loading from a subset of sections, and we've loaded
16921 a section matching this name before, it's likely that it's a
16923 if (section_subset
!= NULL
)
16924 free_debug_section (debug
);
16926 return load_specific_debug_section (debug
, sec
, data
);
16930 free_debug_section (enum dwarf_section_display_enum debug
)
16932 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
16934 if (section
->start
== NULL
)
16937 free ((char *) section
->start
);
16938 section
->start
= NULL
;
16939 section
->address
= 0;
16942 free (section
->reloc_info
);
16943 section
->reloc_info
= NULL
;
16944 section
->num_relocs
= 0;
16948 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
16950 const char *name
= (section_name_valid (filedata
, section
)
16951 ? section_name (filedata
, section
) : "");
16952 const char *print_name
= printable_section_name (filedata
, section
);
16954 bool result
= true;
16957 length
= section
->sh_size
;
16960 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
16963 if (section
->sh_type
== SHT_NOBITS
)
16965 /* There is no point in dumping the contents of a debugging section
16966 which has the NOBITS type - the bits in the file will be random.
16967 This can happen when a file containing a .eh_frame section is
16968 stripped with the --only-keep-debug command line option. */
16969 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
16974 if (startswith (name
, ".gnu.linkonce.wi."))
16975 name
= ".debug_info";
16977 /* See if we know how to display the contents of this section. */
16978 for (i
= 0; i
< max
; i
++)
16980 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
16981 struct dwarf_section_display
* display
= debug_displays
+ i
;
16982 struct dwarf_section
* sec
= & display
->section
;
16984 if (streq (sec
->uncompressed_name
, name
)
16985 || (id
== line
&& startswith (name
, ".debug_line."))
16986 || streq (sec
->compressed_name
, name
))
16988 bool secondary
= (section
!= find_section (filedata
, name
));
16991 free_debug_section (id
);
16993 if (i
== line
&& startswith (name
, ".debug_line."))
16995 else if (streq (sec
->uncompressed_name
, name
))
16996 sec
->name
= sec
->uncompressed_name
;
16998 sec
->name
= sec
->compressed_name
;
17000 if (load_specific_debug_section (id
, section
, filedata
))
17002 /* If this debug section is part of a CU/TU set in a .dwp file,
17003 restrict load_debug_section to the sections in that set. */
17004 section_subset
= find_cu_tu_set (filedata
, shndx
);
17006 result
&= display
->display (sec
, filedata
);
17008 section_subset
= NULL
;
17010 if (secondary
|| (id
!= info
&& id
!= abbrev
&& id
!= debug_addr
))
17011 free_debug_section (id
);
17019 printf (_("Unrecognized debug section: %s\n"), print_name
);
17026 /* Set DUMP_SECTS for all sections where dumps were requested
17027 based on section name. */
17030 initialise_dumps_byname (Filedata
* filedata
)
17032 struct dump_list_entry
* cur
;
17034 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
17039 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
17040 if (section_name_valid (filedata
, filedata
->section_headers
+ i
)
17041 && streq (section_name (filedata
, filedata
->section_headers
+ i
),
17044 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
17048 if (!any
&& !filedata
->is_separate
)
17049 warn (_("Section '%s' was not dumped because it does not exist\n"),
17055 process_section_contents (Filedata
* filedata
)
17057 Elf_Internal_Shdr
* section
;
17064 initialise_dumps_byname (filedata
);
17066 for (i
= 0, section
= filedata
->section_headers
;
17067 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
17070 dump_type dump
= filedata
->dump
.dump_sects
[i
];
17072 if (filedata
->is_separate
&& ! process_links
)
17073 dump
&= DEBUG_DUMP
;
17075 #ifdef SUPPORT_DISASSEMBLY
17076 if (dump
& DISASS_DUMP
)
17078 if (! disassemble_section (section
, filedata
))
17082 if (dump
& HEX_DUMP
)
17084 if (! dump_section_as_bytes (section
, filedata
, false))
17088 if (dump
& RELOC_DUMP
)
17090 if (! dump_section_as_bytes (section
, filedata
, true))
17094 if (dump
& STRING_DUMP
)
17096 if (! dump_section_as_strings (section
, filedata
))
17100 if (dump
& DEBUG_DUMP
)
17102 if (! display_debug_section (i
, section
, filedata
))
17106 #ifdef ENABLE_LIBCTF
17107 if (dump
& CTF_DUMP
)
17109 if (! dump_section_as_ctf (section
, filedata
))
17113 if (dump
& SFRAME_DUMP
)
17115 if (! dump_section_as_sframe (section
, filedata
))
17120 if (! filedata
->is_separate
)
17122 /* Check to see if the user requested a
17123 dump of a section that does not exist. */
17124 for (; i
< filedata
->dump
.num_dump_sects
; i
++)
17125 if (filedata
->dump
.dump_sects
[i
])
17127 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
17136 process_mips_fpe_exception (int mask
)
17142 if (mask
& OEX_FPU_INEX
)
17143 fputs ("INEX", stdout
), first
= false;
17144 if (mask
& OEX_FPU_UFLO
)
17145 printf ("%sUFLO", first
? "" : "|"), first
= false;
17146 if (mask
& OEX_FPU_OFLO
)
17147 printf ("%sOFLO", first
? "" : "|"), first
= false;
17148 if (mask
& OEX_FPU_DIV0
)
17149 printf ("%sDIV0", first
? "" : "|"), first
= false;
17150 if (mask
& OEX_FPU_INVAL
)
17151 printf ("%sINVAL", first
? "" : "|");
17154 fputs ("0", stdout
);
17157 /* Display's the value of TAG at location P. If TAG is
17158 greater than 0 it is assumed to be an unknown tag, and
17159 a message is printed to this effect. Otherwise it is
17160 assumed that a message has already been printed.
17162 If the bottom bit of TAG is set it assumed to have a
17163 string value, otherwise it is assumed to have an integer
17166 Returns an updated P pointing to the first unread byte
17167 beyond the end of TAG's value.
17169 Reads at or beyond END will not be made. */
17171 static unsigned char *
17172 display_tag_value (signed int tag
,
17174 const unsigned char * const end
)
17179 printf (" Tag_unknown_%d: ", tag
);
17183 warn (_("<corrupt tag>\n"));
17187 /* PR 17531 file: 027-19978-0.004. */
17188 size_t maxlen
= (end
- p
) - 1;
17193 print_symbol_name ((int) maxlen
, (const char *) p
);
17194 p
+= strnlen ((char *) p
, maxlen
) + 1;
17198 printf (_("<corrupt string tag>"));
17199 p
= (unsigned char *) end
;
17205 READ_ULEB (val
, p
, end
);
17206 printf ("%" PRId64
" (0x%" PRIx64
")\n", val
, val
);
17213 /* ARC ABI attributes section. */
17215 static unsigned char *
17216 display_arc_attribute (unsigned char * p
,
17217 const unsigned char * const end
)
17222 READ_ULEB (tag
, p
, end
);
17226 case Tag_ARC_PCS_config
:
17227 READ_ULEB (val
, p
, end
);
17228 printf (" Tag_ARC_PCS_config: ");
17232 printf (_("Absent/Non standard\n"));
17235 printf (_("Bare metal/mwdt\n"));
17238 printf (_("Bare metal/newlib\n"));
17241 printf (_("Linux/uclibc\n"));
17244 printf (_("Linux/glibc\n"));
17247 printf (_("Unknown\n"));
17252 case Tag_ARC_CPU_base
:
17253 READ_ULEB (val
, p
, end
);
17254 printf (" Tag_ARC_CPU_base: ");
17259 printf (_("Absent\n"));
17261 case TAG_CPU_ARC6xx
:
17262 printf ("ARC6xx\n");
17264 case TAG_CPU_ARC7xx
:
17265 printf ("ARC7xx\n");
17267 case TAG_CPU_ARCEM
:
17268 printf ("ARCEM\n");
17270 case TAG_CPU_ARCHS
:
17271 printf ("ARCHS\n");
17276 case Tag_ARC_CPU_variation
:
17277 READ_ULEB (val
, p
, end
);
17278 printf (" Tag_ARC_CPU_variation: ");
17282 if (val
> 0 && val
< 16)
17283 printf ("Core%d\n", val
);
17285 printf ("Unknown\n");
17289 printf (_("Absent\n"));
17294 case Tag_ARC_CPU_name
:
17295 printf (" Tag_ARC_CPU_name: ");
17296 p
= display_tag_value (-1, p
, end
);
17299 case Tag_ARC_ABI_rf16
:
17300 READ_ULEB (val
, p
, end
);
17301 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
17304 case Tag_ARC_ABI_osver
:
17305 READ_ULEB (val
, p
, end
);
17306 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
17309 case Tag_ARC_ABI_pic
:
17310 case Tag_ARC_ABI_sda
:
17311 READ_ULEB (val
, p
, end
);
17312 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
17313 : " Tag_ARC_ABI_pic: ");
17317 printf (_("Absent\n"));
17326 printf (_("Unknown\n"));
17331 case Tag_ARC_ABI_tls
:
17332 READ_ULEB (val
, p
, end
);
17333 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
17336 case Tag_ARC_ABI_enumsize
:
17337 READ_ULEB (val
, p
, end
);
17338 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
17342 case Tag_ARC_ABI_exceptions
:
17343 READ_ULEB (val
, p
, end
);
17344 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
17348 case Tag_ARC_ABI_double_size
:
17349 READ_ULEB (val
, p
, end
);
17350 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
17353 case Tag_ARC_ISA_config
:
17354 printf (" Tag_ARC_ISA_config: ");
17355 p
= display_tag_value (-1, p
, end
);
17358 case Tag_ARC_ISA_apex
:
17359 printf (" Tag_ARC_ISA_apex: ");
17360 p
= display_tag_value (-1, p
, end
);
17363 case Tag_ARC_ISA_mpy_option
:
17364 READ_ULEB (val
, p
, end
);
17365 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
17368 case Tag_ARC_ATR_version
:
17369 READ_ULEB (val
, p
, end
);
17370 printf (" Tag_ARC_ATR_version: %d\n", val
);
17374 return display_tag_value (tag
& 1, p
, end
);
17380 /* ARM EABI attributes section. */
17385 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
17387 const char *const *table
;
17388 } arm_attr_public_tag
;
17390 static const char *const arm_attr_tag_CPU_arch
[] =
17391 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
17392 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
17393 "v8-M.mainline", "v8.1-A", "v8.2-A", "v8.3-A",
17394 "v8.1-M.mainline", "v9"};
17395 static const char *const arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
17396 static const char *const arm_attr_tag_THUMB_ISA_use
[] =
17397 {"No", "Thumb-1", "Thumb-2", "Yes"};
17398 static const char *const arm_attr_tag_FP_arch
[] =
17399 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
17400 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
17401 static const char *const arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
17402 static const char *const arm_attr_tag_Advanced_SIMD_arch
[] =
17403 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
17404 "NEON for ARMv8.1"};
17405 static const char *const arm_attr_tag_PCS_config
[] =
17406 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
17407 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
17408 static const char *const arm_attr_tag_ABI_PCS_R9_use
[] =
17409 {"V6", "SB", "TLS", "Unused"};
17410 static const char *const arm_attr_tag_ABI_PCS_RW_data
[] =
17411 {"Absolute", "PC-relative", "SB-relative", "None"};
17412 static const char *const arm_attr_tag_ABI_PCS_RO_data
[] =
17413 {"Absolute", "PC-relative", "None"};
17414 static const char *const arm_attr_tag_ABI_PCS_GOT_use
[] =
17415 {"None", "direct", "GOT-indirect"};
17416 static const char *const arm_attr_tag_ABI_PCS_wchar_t
[] =
17417 {"None", "??? 1", "2", "??? 3", "4"};
17418 static const char *const arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
17419 static const char *const arm_attr_tag_ABI_FP_denormal
[] =
17420 {"Unused", "Needed", "Sign only"};
17421 static const char *const arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
17422 static const char *const arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
17423 static const char *const arm_attr_tag_ABI_FP_number_model
[] =
17424 {"Unused", "Finite", "RTABI", "IEEE 754"};
17425 static const char *const arm_attr_tag_ABI_enum_size
[] =
17426 {"Unused", "small", "int", "forced to int"};
17427 static const char *const arm_attr_tag_ABI_HardFP_use
[] =
17428 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
17429 static const char *const arm_attr_tag_ABI_VFP_args
[] =
17430 {"AAPCS", "VFP registers", "custom", "compatible"};
17431 static const char *const arm_attr_tag_ABI_WMMX_args
[] =
17432 {"AAPCS", "WMMX registers", "custom"};
17433 static const char *const arm_attr_tag_ABI_optimization_goals
[] =
17434 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
17435 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
17436 static const char *const arm_attr_tag_ABI_FP_optimization_goals
[] =
17437 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
17438 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
17439 static const char *const arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
17440 static const char *const arm_attr_tag_FP_HP_extension
[] =
17441 {"Not Allowed", "Allowed"};
17442 static const char *const arm_attr_tag_ABI_FP_16bit_format
[] =
17443 {"None", "IEEE 754", "Alternative Format"};
17444 static const char *const arm_attr_tag_DSP_extension
[] =
17445 {"Follow architecture", "Allowed"};
17446 static const char *const arm_attr_tag_MPextension_use
[] =
17447 {"Not Allowed", "Allowed"};
17448 static const char *const arm_attr_tag_DIV_use
[] =
17449 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
17450 "Allowed in v7-A with integer division extension"};
17451 static const char *const arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
17452 static const char *const arm_attr_tag_Virtualization_use
[] =
17453 {"Not Allowed", "TrustZone", "Virtualization Extensions",
17454 "TrustZone and Virtualization Extensions"};
17455 static const char *const arm_attr_tag_MPextension_use_legacy
[] =
17456 {"Not Allowed", "Allowed"};
17458 static const char *const arm_attr_tag_MVE_arch
[] =
17459 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
17461 static const char * arm_attr_tag_PAC_extension
[] =
17462 {"No PAC/AUT instructions",
17463 "PAC/AUT instructions permitted in the NOP space",
17464 "PAC/AUT instructions permitted in the NOP and in the non-NOP space"};
17466 static const char * arm_attr_tag_BTI_extension
[] =
17467 {"BTI instructions not permitted",
17468 "BTI instructions permitted in the NOP space",
17469 "BTI instructions permitted in the NOP and in the non-NOP space"};
17471 static const char * arm_attr_tag_BTI_use
[] =
17472 {"Compiled without branch target enforcement",
17473 "Compiled with branch target enforcement"};
17475 static const char * arm_attr_tag_PACRET_use
[] =
17476 {"Compiled without return address signing and authentication",
17477 "Compiled with return address signing and authentication"};
17479 #define LOOKUP(id, name) \
17480 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
17481 static arm_attr_public_tag arm_attr_public_tags
[] =
17483 {4, "CPU_raw_name", 1, NULL
},
17484 {5, "CPU_name", 1, NULL
},
17485 LOOKUP(6, CPU_arch
),
17486 {7, "CPU_arch_profile", 0, NULL
},
17487 LOOKUP(8, ARM_ISA_use
),
17488 LOOKUP(9, THUMB_ISA_use
),
17489 LOOKUP(10, FP_arch
),
17490 LOOKUP(11, WMMX_arch
),
17491 LOOKUP(12, Advanced_SIMD_arch
),
17492 LOOKUP(13, PCS_config
),
17493 LOOKUP(14, ABI_PCS_R9_use
),
17494 LOOKUP(15, ABI_PCS_RW_data
),
17495 LOOKUP(16, ABI_PCS_RO_data
),
17496 LOOKUP(17, ABI_PCS_GOT_use
),
17497 LOOKUP(18, ABI_PCS_wchar_t
),
17498 LOOKUP(19, ABI_FP_rounding
),
17499 LOOKUP(20, ABI_FP_denormal
),
17500 LOOKUP(21, ABI_FP_exceptions
),
17501 LOOKUP(22, ABI_FP_user_exceptions
),
17502 LOOKUP(23, ABI_FP_number_model
),
17503 {24, "ABI_align_needed", 0, NULL
},
17504 {25, "ABI_align_preserved", 0, NULL
},
17505 LOOKUP(26, ABI_enum_size
),
17506 LOOKUP(27, ABI_HardFP_use
),
17507 LOOKUP(28, ABI_VFP_args
),
17508 LOOKUP(29, ABI_WMMX_args
),
17509 LOOKUP(30, ABI_optimization_goals
),
17510 LOOKUP(31, ABI_FP_optimization_goals
),
17511 {32, "compatibility", 0, NULL
},
17512 LOOKUP(34, CPU_unaligned_access
),
17513 LOOKUP(36, FP_HP_extension
),
17514 LOOKUP(38, ABI_FP_16bit_format
),
17515 LOOKUP(42, MPextension_use
),
17516 LOOKUP(44, DIV_use
),
17517 LOOKUP(46, DSP_extension
),
17518 LOOKUP(48, MVE_arch
),
17519 LOOKUP(50, PAC_extension
),
17520 LOOKUP(52, BTI_extension
),
17521 LOOKUP(74, BTI_use
),
17522 LOOKUP(76, PACRET_use
),
17523 {64, "nodefaults", 0, NULL
},
17524 {65, "also_compatible_with", 0, NULL
},
17525 LOOKUP(66, T2EE_use
),
17526 {67, "conformance", 1, NULL
},
17527 LOOKUP(68, Virtualization_use
),
17528 LOOKUP(70, MPextension_use_legacy
)
17532 static unsigned char *
17533 display_arm_attribute (unsigned char * p
,
17534 const unsigned char * const end
)
17538 arm_attr_public_tag
* attr
;
17542 READ_ULEB (tag
, p
, end
);
17544 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
17546 if (arm_attr_public_tags
[i
].tag
== tag
)
17548 attr
= &arm_attr_public_tags
[i
];
17555 printf (" Tag_%s: ", attr
->name
);
17556 switch (attr
->type
)
17561 case 7: /* Tag_CPU_arch_profile. */
17562 READ_ULEB (val
, p
, end
);
17565 case 0: printf (_("None\n")); break;
17566 case 'A': printf (_("Application\n")); break;
17567 case 'R': printf (_("Realtime\n")); break;
17568 case 'M': printf (_("Microcontroller\n")); break;
17569 case 'S': printf (_("Application or Realtime\n")); break;
17570 default: printf ("??? (%d)\n", val
); break;
17574 case 24: /* Tag_align_needed. */
17575 READ_ULEB (val
, p
, end
);
17578 case 0: printf (_("None\n")); break;
17579 case 1: printf (_("8-byte\n")); break;
17580 case 2: printf (_("4-byte\n")); break;
17581 case 3: printf ("??? 3\n"); break;
17584 printf (_("8-byte and up to %d-byte extended\n"),
17587 printf ("??? (%d)\n", val
);
17592 case 25: /* Tag_align_preserved. */
17593 READ_ULEB (val
, p
, end
);
17596 case 0: printf (_("None\n")); break;
17597 case 1: printf (_("8-byte, except leaf SP\n")); break;
17598 case 2: printf (_("8-byte\n")); break;
17599 case 3: printf ("??? 3\n"); break;
17602 printf (_("8-byte and up to %d-byte extended\n"),
17605 printf ("??? (%d)\n", val
);
17610 case 32: /* Tag_compatibility. */
17612 READ_ULEB (val
, p
, end
);
17613 printf (_("flag = %d, vendor = "), val
);
17616 size_t maxlen
= (end
- p
) - 1;
17618 print_symbol_name ((int) maxlen
, (const char *) p
);
17619 p
+= strnlen ((char *) p
, maxlen
) + 1;
17623 printf (_("<corrupt>"));
17624 p
= (unsigned char *) end
;
17630 case 64: /* Tag_nodefaults. */
17631 /* PR 17531: file: 001-505008-0.01. */
17634 printf (_("True\n"));
17637 case 65: /* Tag_also_compatible_with. */
17638 READ_ULEB (val
, p
, end
);
17639 if (val
== 6 /* Tag_CPU_arch. */)
17641 READ_ULEB (val
, p
, end
);
17642 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
17643 printf ("??? (%d)\n", val
);
17645 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
17649 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
17654 printf (_("<unknown: %d>\n"), tag
);
17660 return display_tag_value (-1, p
, end
);
17662 return display_tag_value (0, p
, end
);
17665 assert (attr
->type
& 0x80);
17666 READ_ULEB (val
, p
, end
);
17667 type
= attr
->type
& 0x7f;
17669 printf ("??? (%d)\n", val
);
17671 printf ("%s\n", attr
->table
[val
]);
17676 return display_tag_value (tag
, p
, end
);
17679 static unsigned char *
17680 display_gnu_attribute (unsigned char * p
,
17681 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
17682 const unsigned char * const end
)
17687 READ_ULEB (tag
, p
, end
);
17689 /* Tag_compatibility is the only generic GNU attribute defined at
17693 READ_ULEB (val
, p
, end
);
17695 printf (_("flag = %d, vendor = "), val
);
17698 printf (_("<corrupt>\n"));
17699 warn (_("corrupt vendor attribute\n"));
17705 size_t maxlen
= (end
- p
) - 1;
17707 print_symbol_name ((int) maxlen
, (const char *) p
);
17708 p
+= strnlen ((char *) p
, maxlen
) + 1;
17712 printf (_("<corrupt>"));
17713 p
= (unsigned char *) end
;
17720 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
17721 return display_proc_gnu_attribute (p
, tag
, end
);
17723 return display_tag_value (tag
, p
, end
);
17726 static unsigned char *
17727 display_m68k_gnu_attribute (unsigned char * p
,
17729 const unsigned char * const end
)
17733 if (tag
== Tag_GNU_M68K_ABI_FP
)
17735 printf (" Tag_GNU_M68K_ABI_FP: ");
17738 printf (_("<corrupt>\n"));
17741 READ_ULEB (val
, p
, end
);
17744 printf ("(%#x), ", val
);
17749 printf (_("unspecified hard/soft float\n"));
17752 printf (_("hard float\n"));
17755 printf (_("soft float\n"));
17761 return display_tag_value (tag
& 1, p
, end
);
17764 static unsigned char *
17765 display_power_gnu_attribute (unsigned char * p
,
17767 const unsigned char * const end
)
17771 if (tag
== Tag_GNU_Power_ABI_FP
)
17773 printf (" Tag_GNU_Power_ABI_FP: ");
17776 printf (_("<corrupt>\n"));
17779 READ_ULEB (val
, p
, end
);
17782 printf ("(%#x), ", val
);
17787 printf (_("unspecified hard/soft float, "));
17790 printf (_("hard float, "));
17793 printf (_("soft float, "));
17796 printf (_("single-precision hard float, "));
17803 printf (_("unspecified long double\n"));
17806 printf (_("128-bit IBM long double\n"));
17809 printf (_("64-bit long double\n"));
17812 printf (_("128-bit IEEE long double\n"));
17818 if (tag
== Tag_GNU_Power_ABI_Vector
)
17820 printf (" Tag_GNU_Power_ABI_Vector: ");
17823 printf (_("<corrupt>\n"));
17826 READ_ULEB (val
, p
, end
);
17829 printf ("(%#x), ", val
);
17834 printf (_("unspecified\n"));
17837 printf (_("generic\n"));
17840 printf ("AltiVec\n");
17849 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
17851 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
17854 printf (_("<corrupt>\n"));
17857 READ_ULEB (val
, p
, end
);
17860 printf ("(%#x), ", val
);
17865 printf (_("unspecified\n"));
17868 printf ("r3/r4\n");
17871 printf (_("memory\n"));
17880 return display_tag_value (tag
& 1, p
, end
);
17883 static unsigned char *
17884 display_s390_gnu_attribute (unsigned char * p
,
17886 const unsigned char * const end
)
17890 if (tag
== Tag_GNU_S390_ABI_Vector
)
17892 printf (" Tag_GNU_S390_ABI_Vector: ");
17893 READ_ULEB (val
, p
, end
);
17898 printf (_("any\n"));
17901 printf (_("software\n"));
17904 printf (_("hardware\n"));
17907 printf ("??? (%d)\n", val
);
17913 return display_tag_value (tag
& 1, p
, end
);
17917 display_sparc_hwcaps (unsigned int mask
)
17923 if (mask
& ELF_SPARC_HWCAP_MUL32
)
17924 fputs ("mul32", stdout
), first
= false;
17925 if (mask
& ELF_SPARC_HWCAP_DIV32
)
17926 printf ("%sdiv32", first
? "" : "|"), first
= false;
17927 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
17928 printf ("%sfsmuld", first
? "" : "|"), first
= false;
17929 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
17930 printf ("%sv8plus", first
? "" : "|"), first
= false;
17931 if (mask
& ELF_SPARC_HWCAP_POPC
)
17932 printf ("%spopc", first
? "" : "|"), first
= false;
17933 if (mask
& ELF_SPARC_HWCAP_VIS
)
17934 printf ("%svis", first
? "" : "|"), first
= false;
17935 if (mask
& ELF_SPARC_HWCAP_VIS2
)
17936 printf ("%svis2", first
? "" : "|"), first
= false;
17937 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
17938 printf ("%sASIBlkInit", first
? "" : "|"), first
= false;
17939 if (mask
& ELF_SPARC_HWCAP_FMAF
)
17940 printf ("%sfmaf", first
? "" : "|"), first
= false;
17941 if (mask
& ELF_SPARC_HWCAP_VIS3
)
17942 printf ("%svis3", first
? "" : "|"), first
= false;
17943 if (mask
& ELF_SPARC_HWCAP_HPC
)
17944 printf ("%shpc", first
? "" : "|"), first
= false;
17945 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
17946 printf ("%srandom", first
? "" : "|"), first
= false;
17947 if (mask
& ELF_SPARC_HWCAP_TRANS
)
17948 printf ("%strans", first
? "" : "|"), first
= false;
17949 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
17950 printf ("%sfjfmau", first
? "" : "|"), first
= false;
17951 if (mask
& ELF_SPARC_HWCAP_IMA
)
17952 printf ("%sima", first
? "" : "|"), first
= false;
17953 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
17954 printf ("%scspare", first
? "" : "|"), first
= false;
17957 fputc ('0', stdout
);
17958 fputc ('\n', stdout
);
17962 display_sparc_hwcaps2 (unsigned int mask
)
17968 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
17969 fputs ("fjathplus", stdout
), first
= false;
17970 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
17971 printf ("%svis3b", first
? "" : "|"), first
= false;
17972 if (mask
& ELF_SPARC_HWCAP2_ADP
)
17973 printf ("%sadp", first
? "" : "|"), first
= false;
17974 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
17975 printf ("%ssparc5", first
? "" : "|"), first
= false;
17976 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
17977 printf ("%smwait", first
? "" : "|"), first
= false;
17978 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
17979 printf ("%sxmpmul", first
? "" : "|"), first
= false;
17980 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
17981 printf ("%sxmont2", first
? "" : "|"), first
= false;
17982 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
17983 printf ("%snsec", first
? "" : "|"), first
= false;
17984 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
17985 printf ("%sfjathhpc", first
? "" : "|"), first
= false;
17986 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
17987 printf ("%sfjdes", first
? "" : "|"), first
= false;
17988 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
17989 printf ("%sfjaes", first
? "" : "|"), first
= false;
17992 fputc ('0', stdout
);
17993 fputc ('\n', stdout
);
17996 static unsigned char *
17997 display_sparc_gnu_attribute (unsigned char * p
,
17999 const unsigned char * const end
)
18003 if (tag
== Tag_GNU_Sparc_HWCAPS
)
18005 READ_ULEB (val
, p
, end
);
18006 printf (" Tag_GNU_Sparc_HWCAPS: ");
18007 display_sparc_hwcaps (val
);
18010 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
18012 READ_ULEB (val
, p
, end
);
18013 printf (" Tag_GNU_Sparc_HWCAPS2: ");
18014 display_sparc_hwcaps2 (val
);
18018 return display_tag_value (tag
, p
, end
);
18022 print_mips_fp_abi_value (unsigned int val
)
18026 case Val_GNU_MIPS_ABI_FP_ANY
:
18027 printf (_("Hard or soft float\n"));
18029 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
18030 printf (_("Hard float (double precision)\n"));
18032 case Val_GNU_MIPS_ABI_FP_SINGLE
:
18033 printf (_("Hard float (single precision)\n"));
18035 case Val_GNU_MIPS_ABI_FP_SOFT
:
18036 printf (_("Soft float\n"));
18038 case Val_GNU_MIPS_ABI_FP_OLD_64
:
18039 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
18041 case Val_GNU_MIPS_ABI_FP_XX
:
18042 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
18044 case Val_GNU_MIPS_ABI_FP_64
:
18045 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
18047 case Val_GNU_MIPS_ABI_FP_64A
:
18048 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
18050 case Val_GNU_MIPS_ABI_FP_NAN2008
:
18051 printf (_("NaN 2008 compatibility\n"));
18054 printf ("??? (%d)\n", val
);
18059 static unsigned char *
18060 display_mips_gnu_attribute (unsigned char * p
,
18062 const unsigned char * const end
)
18064 if (tag
== Tag_GNU_MIPS_ABI_FP
)
18068 printf (" Tag_GNU_MIPS_ABI_FP: ");
18069 READ_ULEB (val
, p
, end
);
18070 print_mips_fp_abi_value (val
);
18074 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
18078 printf (" Tag_GNU_MIPS_ABI_MSA: ");
18079 READ_ULEB (val
, p
, end
);
18083 case Val_GNU_MIPS_ABI_MSA_ANY
:
18084 printf (_("Any MSA or not\n"));
18086 case Val_GNU_MIPS_ABI_MSA_128
:
18087 printf (_("128-bit MSA\n"));
18090 printf ("??? (%d)\n", val
);
18096 return display_tag_value (tag
& 1, p
, end
);
18099 static unsigned char *
18100 display_tic6x_attribute (unsigned char * p
,
18101 const unsigned char * const end
)
18106 READ_ULEB (tag
, p
, end
);
18111 printf (" Tag_ISA: ");
18112 READ_ULEB (val
, p
, end
);
18116 case C6XABI_Tag_ISA_none
:
18117 printf (_("None\n"));
18119 case C6XABI_Tag_ISA_C62X
:
18122 case C6XABI_Tag_ISA_C67X
:
18125 case C6XABI_Tag_ISA_C67XP
:
18126 printf ("C67x+\n");
18128 case C6XABI_Tag_ISA_C64X
:
18131 case C6XABI_Tag_ISA_C64XP
:
18132 printf ("C64x+\n");
18134 case C6XABI_Tag_ISA_C674X
:
18135 printf ("C674x\n");
18138 printf ("??? (%d)\n", val
);
18143 case Tag_ABI_wchar_t
:
18144 printf (" Tag_ABI_wchar_t: ");
18145 READ_ULEB (val
, p
, end
);
18149 printf (_("Not used\n"));
18152 printf (_("2 bytes\n"));
18155 printf (_("4 bytes\n"));
18158 printf ("??? (%d)\n", val
);
18163 case Tag_ABI_stack_align_needed
:
18164 printf (" Tag_ABI_stack_align_needed: ");
18165 READ_ULEB (val
, p
, end
);
18169 printf (_("8-byte\n"));
18172 printf (_("16-byte\n"));
18175 printf ("??? (%d)\n", val
);
18180 case Tag_ABI_stack_align_preserved
:
18181 READ_ULEB (val
, p
, end
);
18182 printf (" Tag_ABI_stack_align_preserved: ");
18186 printf (_("8-byte\n"));
18189 printf (_("16-byte\n"));
18192 printf ("??? (%d)\n", val
);
18198 READ_ULEB (val
, p
, end
);
18199 printf (" Tag_ABI_DSBT: ");
18203 printf (_("DSBT addressing not used\n"));
18206 printf (_("DSBT addressing used\n"));
18209 printf ("??? (%d)\n", val
);
18215 READ_ULEB (val
, p
, end
);
18216 printf (" Tag_ABI_PID: ");
18220 printf (_("Data addressing position-dependent\n"));
18223 printf (_("Data addressing position-independent, GOT near DP\n"));
18226 printf (_("Data addressing position-independent, GOT far from DP\n"));
18229 printf ("??? (%d)\n", val
);
18235 READ_ULEB (val
, p
, end
);
18236 printf (" Tag_ABI_PIC: ");
18240 printf (_("Code addressing position-dependent\n"));
18243 printf (_("Code addressing position-independent\n"));
18246 printf ("??? (%d)\n", val
);
18251 case Tag_ABI_array_object_alignment
:
18252 READ_ULEB (val
, p
, end
);
18253 printf (" Tag_ABI_array_object_alignment: ");
18257 printf (_("8-byte\n"));
18260 printf (_("4-byte\n"));
18263 printf (_("16-byte\n"));
18266 printf ("??? (%d)\n", val
);
18271 case Tag_ABI_array_object_align_expected
:
18272 READ_ULEB (val
, p
, end
);
18273 printf (" Tag_ABI_array_object_align_expected: ");
18277 printf (_("8-byte\n"));
18280 printf (_("4-byte\n"));
18283 printf (_("16-byte\n"));
18286 printf ("??? (%d)\n", val
);
18291 case Tag_ABI_compatibility
:
18293 READ_ULEB (val
, p
, end
);
18294 printf (" Tag_ABI_compatibility: ");
18295 printf (_("flag = %d, vendor = "), val
);
18298 size_t maxlen
= (end
- p
) - 1;
18300 print_symbol_name ((int) maxlen
, (const char *) p
);
18301 p
+= strnlen ((char *) p
, maxlen
) + 1;
18305 printf (_("<corrupt>"));
18306 p
= (unsigned char *) end
;
18312 case Tag_ABI_conformance
:
18314 printf (" Tag_ABI_conformance: \"");
18317 size_t maxlen
= (end
- p
) - 1;
18319 print_symbol_name ((int) maxlen
, (const char *) p
);
18320 p
+= strnlen ((char *) p
, maxlen
) + 1;
18324 printf (_("<corrupt>"));
18325 p
= (unsigned char *) end
;
18332 return display_tag_value (tag
, p
, end
);
18336 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
18339 size_t bytes
= end
- p
;
18346 int lbytes
= (bytes
> 16 ? 16 : bytes
);
18348 printf (" 0x%8.8" PRIx64
" ", addr
);
18350 for (j
= 0; j
< 16; j
++)
18353 printf ("%2.2x", p
[j
]);
18361 for (j
= 0; j
< lbytes
; j
++)
18364 if (k
>= ' ' && k
< 0x7f)
18380 static unsigned char *
18381 display_msp430_attribute (unsigned char * p
,
18382 const unsigned char * const end
)
18387 READ_ULEB (tag
, p
, end
);
18391 case OFBA_MSPABI_Tag_ISA
:
18392 printf (" Tag_ISA: ");
18393 READ_ULEB (val
, p
, end
);
18396 case 0: printf (_("None\n")); break;
18397 case 1: printf (_("MSP430\n")); break;
18398 case 2: printf (_("MSP430X\n")); break;
18399 default: printf ("??? (%" PRId64
")\n", val
); break;
18403 case OFBA_MSPABI_Tag_Code_Model
:
18404 printf (" Tag_Code_Model: ");
18405 READ_ULEB (val
, p
, end
);
18408 case 0: printf (_("None\n")); break;
18409 case 1: printf (_("Small\n")); break;
18410 case 2: printf (_("Large\n")); break;
18411 default: printf ("??? (%" PRId64
")\n", val
); break;
18415 case OFBA_MSPABI_Tag_Data_Model
:
18416 printf (" Tag_Data_Model: ");
18417 READ_ULEB (val
, p
, end
);
18420 case 0: printf (_("None\n")); break;
18421 case 1: printf (_("Small\n")); break;
18422 case 2: printf (_("Large\n")); break;
18423 case 3: printf (_("Restricted Large\n")); break;
18424 default: printf ("??? (%" PRId64
")\n", val
); break;
18429 printf (_(" <unknown tag %" PRId64
">: "), tag
);
18436 size_t maxlen
= (end
- p
) - 1;
18438 print_symbol_name ((int) maxlen
, (const char *) p
);
18439 p
+= strnlen ((char *) p
, maxlen
) + 1;
18443 printf (_("<corrupt>"));
18444 p
= (unsigned char *) end
;
18450 READ_ULEB (val
, p
, end
);
18451 printf ("%" PRId64
" (0x%" PRIx64
")\n", val
, val
);
18460 static unsigned char *
18461 display_msp430_gnu_attribute (unsigned char * p
,
18463 const unsigned char * const end
)
18465 if (tag
== Tag_GNU_MSP430_Data_Region
)
18469 printf (" Tag_GNU_MSP430_Data_Region: ");
18470 READ_ULEB (val
, p
, end
);
18474 case Val_GNU_MSP430_Data_Region_Any
:
18475 printf (_("Any Region\n"));
18477 case Val_GNU_MSP430_Data_Region_Lower
:
18478 printf (_("Lower Region Only\n"));
18481 printf ("??? (%" PRIu64
")\n", val
);
18485 return display_tag_value (tag
& 1, p
, end
);
18488 struct riscv_attr_tag_t
{
18493 static struct riscv_attr_tag_t riscv_attr_tag
[] =
18495 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
18498 T(priv_spec_minor
),
18499 T(priv_spec_revision
),
18500 T(unaligned_access
),
18505 static unsigned char *
18506 display_riscv_attribute (unsigned char *p
,
18507 const unsigned char * const end
)
18511 struct riscv_attr_tag_t
*attr
= NULL
;
18514 READ_ULEB (tag
, p
, end
);
18516 /* Find the name of attribute. */
18517 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
18519 if (riscv_attr_tag
[i
].tag
== tag
)
18521 attr
= &riscv_attr_tag
[i
];
18527 printf (" %s: ", attr
->name
);
18529 return display_tag_value (tag
, p
, end
);
18533 case Tag_RISCV_priv_spec
:
18534 case Tag_RISCV_priv_spec_minor
:
18535 case Tag_RISCV_priv_spec_revision
:
18536 READ_ULEB (val
, p
, end
);
18537 printf ("%" PRIu64
"\n", val
);
18539 case Tag_RISCV_unaligned_access
:
18540 READ_ULEB (val
, p
, end
);
18544 printf (_("No unaligned access\n"));
18547 printf (_("Unaligned access\n"));
18551 case Tag_RISCV_stack_align
:
18552 READ_ULEB (val
, p
, end
);
18553 printf (_("%" PRIu64
"-bytes\n"), val
);
18555 case Tag_RISCV_arch
:
18556 p
= display_tag_value (-1, p
, end
);
18559 return display_tag_value (tag
, p
, end
);
18565 static unsigned char *
18566 display_csky_attribute (unsigned char * p
,
18567 const unsigned char * const end
)
18571 READ_ULEB (tag
, p
, end
);
18573 if (tag
>= Tag_CSKY_MAX
)
18575 return display_tag_value (-1, p
, end
);
18580 case Tag_CSKY_ARCH_NAME
:
18581 printf (" Tag_CSKY_ARCH_NAME:\t\t");
18582 return display_tag_value (-1, p
, end
);
18583 case Tag_CSKY_CPU_NAME
:
18584 printf (" Tag_CSKY_CPU_NAME:\t\t");
18585 return display_tag_value (-1, p
, end
);
18587 case Tag_CSKY_ISA_FLAGS
:
18588 printf (" Tag_CSKY_ISA_FLAGS:\t\t");
18589 return display_tag_value (0, p
, end
);
18590 case Tag_CSKY_ISA_EXT_FLAGS
:
18591 printf (" Tag_CSKY_ISA_EXT_FLAGS:\t");
18592 return display_tag_value (0, p
, end
);
18594 case Tag_CSKY_DSP_VERSION
:
18595 printf (" Tag_CSKY_DSP_VERSION:\t\t");
18596 READ_ULEB (val
, p
, end
);
18597 if (val
== VAL_CSKY_DSP_VERSION_EXTENSION
)
18598 printf ("DSP Extension\n");
18599 else if (val
== VAL_CSKY_DSP_VERSION_2
)
18600 printf ("DSP 2.0\n");
18603 case Tag_CSKY_VDSP_VERSION
:
18604 printf (" Tag_CSKY_VDSP_VERSION:\t");
18605 READ_ULEB (val
, p
, end
);
18606 printf ("VDSP Version %" PRId64
"\n", val
);
18609 case Tag_CSKY_FPU_VERSION
:
18610 printf (" Tag_CSKY_FPU_VERSION:\t\t");
18611 READ_ULEB (val
, p
, end
);
18612 if (val
== VAL_CSKY_FPU_VERSION_1
)
18613 printf ("ABIV1 FPU Version 1\n");
18614 else if (val
== VAL_CSKY_FPU_VERSION_2
)
18615 printf ("FPU Version 2\n");
18618 case Tag_CSKY_FPU_ABI
:
18619 printf (" Tag_CSKY_FPU_ABI:\t\t");
18620 READ_ULEB (val
, p
, end
);
18621 if (val
== VAL_CSKY_FPU_ABI_HARD
)
18623 else if (val
== VAL_CSKY_FPU_ABI_SOFTFP
)
18624 printf ("SoftFP\n");
18625 else if (val
== VAL_CSKY_FPU_ABI_SOFT
)
18628 case Tag_CSKY_FPU_ROUNDING
:
18629 READ_ULEB (val
, p
, end
);
18632 printf (" Tag_CSKY_FPU_ROUNDING:\t");
18633 printf ("Needed\n");
18636 case Tag_CSKY_FPU_DENORMAL
:
18637 READ_ULEB (val
, p
, end
);
18640 printf (" Tag_CSKY_FPU_DENORMAL:\t");
18641 printf ("Needed\n");
18644 case Tag_CSKY_FPU_Exception
:
18645 READ_ULEB (val
, p
, end
);
18648 printf (" Tag_CSKY_FPU_Exception:\t");
18649 printf ("Needed\n");
18652 case Tag_CSKY_FPU_NUMBER_MODULE
:
18653 printf (" Tag_CSKY_FPU_NUMBER_MODULE:\t");
18654 return display_tag_value (-1, p
, end
);
18655 case Tag_CSKY_FPU_HARDFP
:
18656 printf (" Tag_CSKY_FPU_HARDFP:\t\t");
18657 READ_ULEB (val
, p
, end
);
18658 if (val
& VAL_CSKY_FPU_HARDFP_HALF
)
18660 if (val
& VAL_CSKY_FPU_HARDFP_SINGLE
)
18661 printf (" Single");
18662 if (val
& VAL_CSKY_FPU_HARDFP_DOUBLE
)
18663 printf (" Double");
18667 return display_tag_value (tag
, p
, end
);
18673 process_attributes (Filedata
* filedata
,
18674 const char * public_name
,
18675 unsigned int proc_type
,
18676 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
18677 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
18679 Elf_Internal_Shdr
* sect
;
18683 /* Find the section header so that we get the size. */
18684 for (i
= 0, sect
= filedata
->section_headers
;
18685 i
< filedata
->file_header
.e_shnum
;
18688 unsigned char * contents
;
18691 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
18694 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
18695 sect
->sh_size
, _("attributes"));
18696 if (contents
== NULL
)
18703 /* The first character is the version of the attributes.
18704 Currently only version 1, (aka 'A') is recognised here. */
18707 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
18712 uint64_t section_len
;
18714 section_len
= sect
->sh_size
- 1;
18717 while (section_len
> 0)
18720 unsigned int namelen
;
18721 bool public_section
;
18724 if (section_len
<= 4)
18726 error (_("Tag section ends prematurely\n"));
18730 attr_len
= byte_get (p
, 4);
18733 if (attr_len
> section_len
)
18735 error (_("Bad attribute length (%u > %u)\n"),
18736 (unsigned) attr_len
, (unsigned) section_len
);
18737 attr_len
= section_len
;
18740 /* PR 17531: file: 001-101425-0.004 */
18741 else if (attr_len
< 5)
18743 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
18748 section_len
-= attr_len
;
18751 namelen
= strnlen ((char *) p
, attr_len
) + 1;
18752 if (namelen
== 0 || namelen
>= attr_len
)
18754 error (_("Corrupt attribute section name\n"));
18759 printf (_("Attribute Section: "));
18760 print_symbol_name (INT_MAX
, (const char *) p
);
18763 if (public_name
&& streq ((char *) p
, public_name
))
18764 public_section
= true;
18766 public_section
= false;
18768 if (streq ((char *) p
, "gnu"))
18769 gnu_section
= true;
18771 gnu_section
= false;
18774 attr_len
-= namelen
;
18776 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
18781 unsigned char * end
;
18783 /* PR binutils/17531: Safe handling of corrupt files. */
18786 error (_("Unused bytes at end of section\n"));
18793 size
= byte_get (p
, 4);
18794 if (size
> attr_len
)
18796 error (_("Bad subsection length (%u > %u)\n"),
18797 (unsigned) size
, (unsigned) attr_len
);
18801 /* PR binutils/17531: Safe handling of corrupt files. */
18804 error (_("Bad subsection length (%u < 6)\n"),
18812 end
= p
+ size
- 1;
18813 assert (end
<= contents
+ sect
->sh_size
);
18819 printf (_("File Attributes\n"));
18822 printf (_("Section Attributes:"));
18825 printf (_("Symbol Attributes:"));
18826 /* Fall through. */
18830 READ_ULEB (val
, p
, end
);
18833 printf (" %d", val
);
18838 printf (_("Unknown tag: %d\n"), tag
);
18839 public_section
= false;
18843 if (public_section
&& display_pub_attribute
!= NULL
)
18846 p
= display_pub_attribute (p
, end
);
18849 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
18852 p
= display_gnu_attribute (p
,
18853 display_proc_gnu_attribute
,
18859 printf (_(" Unknown attribute:\n"));
18860 display_raw_attribute (p
, end
);
18875 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
18876 Print the Address, Access and Initial fields of an entry at VMA ADDR
18877 and return the VMA of the next entry, or -1 if there was a problem.
18878 Does not read from DATA_END or beyond. */
18881 print_mips_got_entry (unsigned char * data
, uint64_t pltgot
, uint64_t addr
,
18882 unsigned char * data_end
)
18885 print_vma (addr
, LONG_HEX
);
18887 if (addr
< pltgot
+ 0xfff0)
18888 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
18890 printf ("%10s", "");
18893 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
18897 unsigned char * from
= data
+ addr
- pltgot
;
18899 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
18901 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
18902 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
18903 return (uint64_t) -1;
18907 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
18908 print_vma (entry
, LONG_HEX
);
18911 return addr
+ (is_32bit_elf
? 4 : 8);
18914 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
18915 PLTGOT. Print the Address and Initial fields of an entry at VMA
18916 ADDR and return the VMA of the next entry. */
18919 print_mips_pltgot_entry (unsigned char * data
, uint64_t pltgot
, uint64_t addr
)
18922 print_vma (addr
, LONG_HEX
);
18925 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
18930 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
18931 print_vma (entry
, LONG_HEX
);
18933 return addr
+ (is_32bit_elf
? 4 : 8);
18937 print_mips_ases (unsigned int mask
)
18939 if (mask
& AFL_ASE_DSP
)
18940 fputs ("\n\tDSP ASE", stdout
);
18941 if (mask
& AFL_ASE_DSPR2
)
18942 fputs ("\n\tDSP R2 ASE", stdout
);
18943 if (mask
& AFL_ASE_DSPR3
)
18944 fputs ("\n\tDSP R3 ASE", stdout
);
18945 if (mask
& AFL_ASE_EVA
)
18946 fputs ("\n\tEnhanced VA Scheme", stdout
);
18947 if (mask
& AFL_ASE_MCU
)
18948 fputs ("\n\tMCU (MicroController) ASE", stdout
);
18949 if (mask
& AFL_ASE_MDMX
)
18950 fputs ("\n\tMDMX ASE", stdout
);
18951 if (mask
& AFL_ASE_MIPS3D
)
18952 fputs ("\n\tMIPS-3D ASE", stdout
);
18953 if (mask
& AFL_ASE_MT
)
18954 fputs ("\n\tMT ASE", stdout
);
18955 if (mask
& AFL_ASE_SMARTMIPS
)
18956 fputs ("\n\tSmartMIPS ASE", stdout
);
18957 if (mask
& AFL_ASE_VIRT
)
18958 fputs ("\n\tVZ ASE", stdout
);
18959 if (mask
& AFL_ASE_MSA
)
18960 fputs ("\n\tMSA ASE", stdout
);
18961 if (mask
& AFL_ASE_MIPS16
)
18962 fputs ("\n\tMIPS16 ASE", stdout
);
18963 if (mask
& AFL_ASE_MICROMIPS
)
18964 fputs ("\n\tMICROMIPS ASE", stdout
);
18965 if (mask
& AFL_ASE_XPA
)
18966 fputs ("\n\tXPA ASE", stdout
);
18967 if (mask
& AFL_ASE_MIPS16E2
)
18968 fputs ("\n\tMIPS16e2 ASE", stdout
);
18969 if (mask
& AFL_ASE_CRC
)
18970 fputs ("\n\tCRC ASE", stdout
);
18971 if (mask
& AFL_ASE_GINV
)
18972 fputs ("\n\tGINV ASE", stdout
);
18973 if (mask
& AFL_ASE_LOONGSON_MMI
)
18974 fputs ("\n\tLoongson MMI ASE", stdout
);
18975 if (mask
& AFL_ASE_LOONGSON_CAM
)
18976 fputs ("\n\tLoongson CAM ASE", stdout
);
18977 if (mask
& AFL_ASE_LOONGSON_EXT
)
18978 fputs ("\n\tLoongson EXT ASE", stdout
);
18979 if (mask
& AFL_ASE_LOONGSON_EXT2
)
18980 fputs ("\n\tLoongson EXT2 ASE", stdout
);
18982 fprintf (stdout
, "\n\t%s", _("None"));
18983 else if ((mask
& ~AFL_ASE_MASK
) != 0)
18984 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
18988 print_mips_isa_ext (unsigned int isa_ext
)
18993 fputs (_("None"), stdout
);
18996 fputs ("RMI XLR", stdout
);
18998 case AFL_EXT_OCTEON3
:
18999 fputs ("Cavium Networks Octeon3", stdout
);
19001 case AFL_EXT_OCTEON2
:
19002 fputs ("Cavium Networks Octeon2", stdout
);
19004 case AFL_EXT_OCTEONP
:
19005 fputs ("Cavium Networks OcteonP", stdout
);
19007 case AFL_EXT_OCTEON
:
19008 fputs ("Cavium Networks Octeon", stdout
);
19011 fputs ("Toshiba R5900", stdout
);
19014 fputs ("MIPS R4650", stdout
);
19017 fputs ("LSI R4010", stdout
);
19020 fputs ("NEC VR4100", stdout
);
19023 fputs ("Toshiba R3900", stdout
);
19025 case AFL_EXT_10000
:
19026 fputs ("MIPS R10000", stdout
);
19029 fputs ("Broadcom SB-1", stdout
);
19032 fputs ("NEC VR4111/VR4181", stdout
);
19035 fputs ("NEC VR4120", stdout
);
19038 fputs ("NEC VR5400", stdout
);
19041 fputs ("NEC VR5500", stdout
);
19043 case AFL_EXT_LOONGSON_2E
:
19044 fputs ("ST Microelectronics Loongson 2E", stdout
);
19046 case AFL_EXT_LOONGSON_2F
:
19047 fputs ("ST Microelectronics Loongson 2F", stdout
);
19049 case AFL_EXT_INTERAPTIV_MR2
:
19050 fputs ("Imagination interAptiv MR2", stdout
);
19053 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
19058 get_mips_reg_size (int reg_size
)
19060 return (reg_size
== AFL_REG_NONE
) ? 0
19061 : (reg_size
== AFL_REG_32
) ? 32
19062 : (reg_size
== AFL_REG_64
) ? 64
19063 : (reg_size
== AFL_REG_128
) ? 128
19068 process_mips_specific (Filedata
* filedata
)
19070 Elf_Internal_Dyn
* entry
;
19071 Elf_Internal_Shdr
*sect
= NULL
;
19072 size_t liblist_offset
= 0;
19073 size_t liblistno
= 0;
19074 size_t conflictsno
= 0;
19075 size_t options_offset
= 0;
19076 size_t conflicts_offset
= 0;
19077 size_t pltrelsz
= 0;
19079 uint64_t pltgot
= 0;
19080 uint64_t mips_pltgot
= 0;
19081 uint64_t jmprel
= 0;
19082 uint64_t local_gotno
= 0;
19083 uint64_t gotsym
= 0;
19084 uint64_t symtabno
= 0;
19087 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19088 display_mips_gnu_attribute
))
19091 sect
= find_section (filedata
, ".MIPS.abiflags");
19095 Elf_External_ABIFlags_v0
*abiflags_ext
;
19096 Elf_Internal_ABIFlags_v0 abiflags_in
;
19098 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
19100 error (_("Corrupt MIPS ABI Flags section.\n"));
19105 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
19106 sect
->sh_size
, _("MIPS ABI Flags section"));
19109 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
19110 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
19111 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
19112 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
19113 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
19114 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
19115 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
19116 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
19117 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
19118 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
19119 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
19121 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
19122 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
19123 if (abiflags_in
.isa_rev
> 1)
19124 printf ("r%d", abiflags_in
.isa_rev
);
19125 printf ("\nGPR size: %d",
19126 get_mips_reg_size (abiflags_in
.gpr_size
));
19127 printf ("\nCPR1 size: %d",
19128 get_mips_reg_size (abiflags_in
.cpr1_size
));
19129 printf ("\nCPR2 size: %d",
19130 get_mips_reg_size (abiflags_in
.cpr2_size
));
19131 fputs ("\nFP ABI: ", stdout
);
19132 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
19133 fputs ("ISA Extension: ", stdout
);
19134 print_mips_isa_ext (abiflags_in
.isa_ext
);
19135 fputs ("\nASEs:", stdout
);
19136 print_mips_ases (abiflags_in
.ases
);
19137 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
19138 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
19139 fputc ('\n', stdout
);
19140 free (abiflags_ext
);
19145 /* We have a lot of special sections. Thanks SGI! */
19146 if (filedata
->dynamic_section
== NULL
)
19148 /* No dynamic information available. See if there is static GOT. */
19149 sect
= find_section (filedata
, ".got");
19152 unsigned char *data_end
;
19153 unsigned char *data
;
19157 pltgot
= sect
->sh_addr
;
19160 addr_size
= (is_32bit_elf
? 4 : 8);
19161 end
= pltgot
+ sect
->sh_size
;
19163 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
19165 _("Global Offset Table data"));
19166 /* PR 12855: Null data is handled gracefully throughout. */
19167 data_end
= data
+ (end
- pltgot
);
19169 printf (_("\nStatic GOT:\n"));
19170 printf (_(" Canonical gp value: "));
19171 print_vma (ent
+ 0x7ff0, LONG_HEX
);
19174 /* In a dynamic binary GOT[0] is reserved for the dynamic
19175 loader to store the lazy resolver pointer, however in
19176 a static binary it may well have been omitted and GOT
19177 reduced to a table of addresses.
19178 PR 21344: Check for the entry being fully available
19179 before fetching it. */
19181 && data
+ ent
- pltgot
+ addr_size
<= data_end
19182 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
19184 printf (_(" Reserved entries:\n"));
19185 printf (_(" %*s %10s %*s\n"),
19186 addr_size
* 2, _("Address"), _("Access"),
19187 addr_size
* 2, _("Value"));
19188 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19190 if (ent
== (uint64_t) -1)
19191 goto sgot_print_fail
;
19193 /* Check for the MSB of GOT[1] being set, identifying a
19194 GNU object. This entry will be used by some runtime
19195 loaders, to store the module pointer. Otherwise this
19196 is an ordinary local entry.
19197 PR 21344: Check for the entry being fully available
19198 before fetching it. */
19200 && data
+ ent
- pltgot
+ addr_size
<= data_end
19201 && (byte_get (data
+ ent
- pltgot
, addr_size
)
19202 >> (addr_size
* 8 - 1)) != 0)
19204 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19206 if (ent
== (uint64_t) -1)
19207 goto sgot_print_fail
;
19212 if (data
!= NULL
&& ent
< end
)
19214 printf (_(" Local entries:\n"));
19215 printf (" %*s %10s %*s\n",
19216 addr_size
* 2, _("Address"), _("Access"),
19217 addr_size
* 2, _("Value"));
19220 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19222 if (ent
== (uint64_t) -1)
19223 goto sgot_print_fail
;
19234 for (entry
= filedata
->dynamic_section
;
19235 /* PR 17531 file: 012-50589-0.004. */
19236 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
19237 && entry
->d_tag
!= DT_NULL
);
19239 switch (entry
->d_tag
)
19241 case DT_MIPS_LIBLIST
:
19243 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
19244 liblistno
* sizeof (Elf32_External_Lib
));
19246 case DT_MIPS_LIBLISTNO
:
19247 liblistno
= entry
->d_un
.d_val
;
19249 case DT_MIPS_OPTIONS
:
19250 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
19252 case DT_MIPS_CONFLICT
:
19254 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
19255 conflictsno
* sizeof (Elf32_External_Conflict
));
19257 case DT_MIPS_CONFLICTNO
:
19258 conflictsno
= entry
->d_un
.d_val
;
19261 pltgot
= entry
->d_un
.d_ptr
;
19263 case DT_MIPS_LOCAL_GOTNO
:
19264 local_gotno
= entry
->d_un
.d_val
;
19266 case DT_MIPS_GOTSYM
:
19267 gotsym
= entry
->d_un
.d_val
;
19269 case DT_MIPS_SYMTABNO
:
19270 symtabno
= entry
->d_un
.d_val
;
19272 case DT_MIPS_PLTGOT
:
19273 mips_pltgot
= entry
->d_un
.d_ptr
;
19276 pltrel
= entry
->d_un
.d_val
;
19279 pltrelsz
= entry
->d_un
.d_val
;
19282 jmprel
= entry
->d_un
.d_ptr
;
19288 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
19290 Elf32_External_Lib
* elib
;
19293 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
19294 sizeof (Elf32_External_Lib
),
19296 _("liblist section data"));
19299 printf (ngettext ("\nSection '.liblist' contains %zu entry:\n",
19300 "\nSection '.liblist' contains %zu entries:\n",
19303 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
19306 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
19313 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
19314 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
19315 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
19316 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
19317 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
19319 tmp
= gmtime (&atime
);
19320 snprintf (timebuf
, sizeof (timebuf
),
19321 "%04u-%02u-%02uT%02u:%02u:%02u",
19322 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
19323 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
19325 printf ("%3zu: ", cnt
);
19326 if (valid_dynamic_name (filedata
, liblist
.l_name
))
19327 print_symbol_name (20, get_dynamic_name (filedata
, liblist
.l_name
));
19329 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
19330 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
19331 liblist
.l_version
);
19333 if (liblist
.l_flags
== 0)
19337 static const struct
19344 { " EXACT_MATCH", LL_EXACT_MATCH
},
19345 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
19346 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
19347 { " EXPORTS", LL_EXPORTS
},
19348 { " DELAY_LOAD", LL_DELAY_LOAD
},
19349 { " DELTA", LL_DELTA
}
19351 int flags
= liblist
.l_flags
;
19354 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
19355 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
19357 fputs (l_flags_vals
[fcnt
].name
, stdout
);
19358 flags
^= l_flags_vals
[fcnt
].bit
;
19361 printf (" %#x", (unsigned int) flags
);
19373 if (options_offset
!= 0)
19375 Elf_External_Options
* eopt
;
19379 /* Find the section header so that we get the size. */
19380 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
19381 /* PR 17533 file: 012-277276-0.004. */
19384 error (_("No MIPS_OPTIONS header found\n"));
19388 if (sect
->sh_size
< sizeof (* eopt
))
19390 error (_("The MIPS options section is too small.\n"));
19394 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
19395 sect
->sh_size
, _("options"));
19398 Elf_Internal_Options option
;
19401 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
19403 Elf_External_Options
* eoption
;
19404 unsigned int optsize
;
19406 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
19408 optsize
= BYTE_GET (eoption
->size
);
19410 /* PR 17531: file: ffa0fa3b. */
19411 if (optsize
< sizeof (* eopt
)
19412 || optsize
> sect
->sh_size
- offset
)
19414 error (_("Invalid size (%u) for MIPS option\n"),
19423 printf (ngettext ("\nSection '%s' contains %d entry:\n",
19424 "\nSection '%s' contains %d entries:\n",
19426 printable_section_name (filedata
, sect
), cnt
);
19432 Elf_External_Options
* eoption
;
19434 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
19436 option
.kind
= BYTE_GET (eoption
->kind
);
19437 option
.size
= BYTE_GET (eoption
->size
);
19438 option
.section
= BYTE_GET (eoption
->section
);
19439 option
.info
= BYTE_GET (eoption
->info
);
19441 switch (option
.kind
)
19444 /* This shouldn't happen. */
19445 printf (" NULL %" PRId16
" %" PRIx32
,
19446 option
.section
, option
.info
);
19450 printf (" REGINFO ");
19451 if (filedata
->file_header
.e_machine
== EM_MIPS
)
19453 Elf32_External_RegInfo
* ereg
;
19454 Elf32_RegInfo reginfo
;
19457 if (option
.size
< (sizeof (Elf_External_Options
)
19458 + sizeof (Elf32_External_RegInfo
)))
19460 printf (_("<corrupt>\n"));
19461 error (_("Truncated MIPS REGINFO option\n"));
19466 ereg
= (Elf32_External_RegInfo
*) (eoption
+ 1);
19468 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
19469 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
19470 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
19471 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
19472 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
19473 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
19475 printf ("GPR %08" PRIx32
" GP 0x%" PRIx32
"\n",
19476 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
19478 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
19479 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
19480 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
19481 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
19486 Elf64_External_RegInfo
* ereg
;
19487 Elf64_Internal_RegInfo reginfo
;
19489 if (option
.size
< (sizeof (Elf_External_Options
)
19490 + sizeof (Elf64_External_RegInfo
)))
19492 printf (_("<corrupt>\n"));
19493 error (_("Truncated MIPS REGINFO option\n"));
19498 ereg
= (Elf64_External_RegInfo
*) (eoption
+ 1);
19499 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
19500 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
19501 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
19502 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
19503 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
19504 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
19506 printf ("GPR %08" PRIx32
" GP 0x%" PRIx64
"\n",
19507 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
19509 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
19510 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
19511 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
19512 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
19514 offset
+= option
.size
;
19517 case ODK_EXCEPTIONS
:
19518 fputs (" EXCEPTIONS fpe_min(", stdout
);
19519 process_mips_fpe_exception (option
.info
& OEX_FPU_MIN
);
19520 fputs (") fpe_max(", stdout
);
19521 process_mips_fpe_exception ((option
.info
& OEX_FPU_MAX
) >> 8);
19522 fputs (")", stdout
);
19524 if (option
.info
& OEX_PAGE0
)
19525 fputs (" PAGE0", stdout
);
19526 if (option
.info
& OEX_SMM
)
19527 fputs (" SMM", stdout
);
19528 if (option
.info
& OEX_FPDBUG
)
19529 fputs (" FPDBUG", stdout
);
19530 if (option
.info
& OEX_DISMISS
)
19531 fputs (" DISMISS", stdout
);
19535 fputs (" PAD ", stdout
);
19536 if (option
.info
& OPAD_PREFIX
)
19537 fputs (" PREFIX", stdout
);
19538 if (option
.info
& OPAD_POSTFIX
)
19539 fputs (" POSTFIX", stdout
);
19540 if (option
.info
& OPAD_SYMBOL
)
19541 fputs (" SYMBOL", stdout
);
19545 fputs (" HWPATCH ", stdout
);
19546 if (option
.info
& OHW_R4KEOP
)
19547 fputs (" R4KEOP", stdout
);
19548 if (option
.info
& OHW_R8KPFETCH
)
19549 fputs (" R8KPFETCH", stdout
);
19550 if (option
.info
& OHW_R5KEOP
)
19551 fputs (" R5KEOP", stdout
);
19552 if (option
.info
& OHW_R5KCVTL
)
19553 fputs (" R5KCVTL", stdout
);
19557 fputs (" FILL ", stdout
);
19558 /* XXX Print content of info word? */
19562 fputs (" TAGS ", stdout
);
19563 /* XXX Print content of info word? */
19567 fputs (" HWAND ", stdout
);
19568 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
19569 fputs (" R4KEOP_CHECKED", stdout
);
19570 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
19571 fputs (" R4KEOP_CLEAN", stdout
);
19575 fputs (" HWOR ", stdout
);
19576 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
19577 fputs (" R4KEOP_CHECKED", stdout
);
19578 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
19579 fputs (" R4KEOP_CLEAN", stdout
);
19583 printf (" GP_GROUP %#06x self-contained %#06x",
19584 option
.info
& OGP_GROUP
,
19585 (option
.info
& OGP_SELF
) >> 16);
19589 printf (" IDENT %#06x self-contained %#06x",
19590 option
.info
& OGP_GROUP
,
19591 (option
.info
& OGP_SELF
) >> 16);
19595 /* This shouldn't happen. */
19596 printf (" %3d ??? %" PRId16
" %" PRIx32
,
19597 option
.kind
, option
.section
, option
.info
);
19601 len
= sizeof (* eopt
);
19602 while (len
< option
.size
)
19604 unsigned char datum
= *((unsigned char *) eoption
+ len
);
19606 if (ISPRINT (datum
))
19607 printf ("%c", datum
);
19609 printf ("\\%03o", datum
);
19612 fputs ("\n", stdout
);
19614 offset
+= option
.size
;
19622 if (conflicts_offset
!= 0 && conflictsno
!= 0)
19624 Elf32_Conflict
* iconf
;
19627 if (filedata
->dynamic_symbols
== NULL
)
19629 error (_("conflict list found without a dynamic symbol table\n"));
19633 /* PR 21345 - print a slightly more helpful error message
19634 if we are sure that the cmalloc will fail. */
19635 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
19637 error (_("Overlarge number of conflicts detected: %zx\n"),
19642 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
19645 error (_("Out of memory allocating space for dynamic conflicts\n"));
19651 Elf32_External_Conflict
* econf32
;
19653 econf32
= (Elf32_External_Conflict
*)
19654 get_data (NULL
, filedata
, conflicts_offset
,
19655 sizeof (*econf32
), conflictsno
, _("conflict"));
19662 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
19663 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
19669 Elf64_External_Conflict
* econf64
;
19671 econf64
= (Elf64_External_Conflict
*)
19672 get_data (NULL
, filedata
, conflicts_offset
,
19673 sizeof (*econf64
), conflictsno
, _("conflict"));
19680 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
19681 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
19686 printf (ngettext ("\nSection '.conflict' contains %zu entry:\n",
19687 "\nSection '.conflict' contains %zu entries:\n",
19690 puts (_(" Num: Index Value Name"));
19692 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
19694 printf ("%5zu: %8lu ", cnt
, iconf
[cnt
]);
19696 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
19697 printf (_("<corrupt symbol index>"));
19700 Elf_Internal_Sym
* psym
;
19702 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
19703 print_vma (psym
->st_value
, FULL_HEX
);
19705 if (valid_dynamic_name (filedata
, psym
->st_name
))
19706 print_symbol_name (25, get_dynamic_name (filedata
, psym
->st_name
));
19708 printf (_("<corrupt: %14ld>"), psym
->st_name
);
19716 if (pltgot
!= 0 && local_gotno
!= 0)
19718 uint64_t ent
, local_end
, global_end
;
19720 unsigned char * data
;
19721 unsigned char * data_end
;
19725 addr_size
= (is_32bit_elf
? 4 : 8);
19726 local_end
= pltgot
+ local_gotno
* addr_size
;
19728 /* PR binutils/17533 file: 012-111227-0.004 */
19729 if (symtabno
< gotsym
)
19731 error (_("The GOT symbol offset (%" PRIu64
19732 ") is greater than the symbol table size (%" PRIu64
")\n"),
19737 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
19738 /* PR 17531: file: 54c91a34. */
19739 if (global_end
< local_end
)
19741 error (_("Too many GOT symbols: %" PRIu64
"\n"), symtabno
);
19745 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
19746 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
19747 global_end
- pltgot
, 1,
19748 _("Global Offset Table data"));
19749 /* PR 12855: Null data is handled gracefully throughout. */
19750 data_end
= data
+ (global_end
- pltgot
);
19752 printf (_("\nPrimary GOT:\n"));
19753 printf (_(" Canonical gp value: "));
19754 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
19757 printf (_(" Reserved entries:\n"));
19758 printf (_(" %*s %10s %*s Purpose\n"),
19759 addr_size
* 2, _("Address"), _("Access"),
19760 addr_size
* 2, _("Initial"));
19761 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19762 printf (_(" Lazy resolver\n"));
19763 if (ent
== (uint64_t) -1)
19764 goto got_print_fail
;
19766 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
19767 This entry will be used by some runtime loaders, to store the
19768 module pointer. Otherwise this is an ordinary local entry.
19769 PR 21344: Check for the entry being fully available before
19772 && data
+ ent
- pltgot
+ addr_size
<= data_end
19773 && (byte_get (data
+ ent
- pltgot
, addr_size
)
19774 >> (addr_size
* 8 - 1)) != 0)
19776 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19777 printf (_(" Module pointer (GNU extension)\n"));
19778 if (ent
== (uint64_t) -1)
19779 goto got_print_fail
;
19783 if (data
!= NULL
&& ent
< local_end
)
19785 printf (_(" Local entries:\n"));
19786 printf (" %*s %10s %*s\n",
19787 addr_size
* 2, _("Address"), _("Access"),
19788 addr_size
* 2, _("Initial"));
19789 while (ent
< local_end
)
19791 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19793 if (ent
== (uint64_t) -1)
19794 goto got_print_fail
;
19799 if (data
!= NULL
&& gotsym
< symtabno
)
19803 printf (_(" Global entries:\n"));
19804 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
19805 addr_size
* 2, _("Address"),
19807 addr_size
* 2, _("Initial"),
19808 addr_size
* 2, _("Sym.Val."),
19810 /* Note for translators: "Ndx" = abbreviated form of "Index". */
19811 _("Ndx"), _("Name"));
19813 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
19815 for (i
= gotsym
; i
< symtabno
; i
++)
19817 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
19820 if (filedata
->dynamic_symbols
== NULL
)
19821 printf (_("<no dynamic symbols>"));
19822 else if (i
< filedata
->num_dynamic_syms
)
19824 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
19826 print_vma (psym
->st_value
, LONG_HEX
);
19827 printf (" %-7s ", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
19830 const char * s
= printable_section_name_from_index (filedata
, psym
->st_shndx
, & is_special
);
19832 printf ("%3s ", s
);
19834 printf ("%3u ", psym
->st_shndx
);
19836 if (valid_dynamic_name (filedata
, psym
->st_name
))
19837 print_symbol_name (sym_width
,
19838 get_dynamic_name (filedata
, psym
->st_name
));
19840 printf (_("<corrupt: %14ld>"), psym
->st_name
);
19843 printf (_("<symbol index %zu exceeds number of dynamic symbols>"),
19847 if (ent
== (uint64_t) -1)
19857 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
19860 uint64_t offset
, rel_offset
;
19862 unsigned char * data
;
19863 int addr_size
, sym_width
;
19864 Elf_Internal_Rela
* rels
;
19866 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
19867 if (pltrel
== DT_RELA
)
19869 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
19874 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
19879 addr_size
= (is_32bit_elf
? 4 : 8);
19880 end
= mips_pltgot
+ (2 + count
) * addr_size
;
19882 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
19883 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
19884 1, _("Procedure Linkage Table data"));
19891 printf ("\nPLT GOT:\n\n");
19892 printf (_(" Reserved entries:\n"));
19893 printf (_(" %*s %*s Purpose\n"),
19894 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
19895 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
19896 printf (_(" PLT lazy resolver\n"));
19897 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
19898 printf (_(" Module pointer\n"));
19901 printf (_(" Entries:\n"));
19902 printf (" %*s %*s %*s %-7s %3s %s\n",
19903 addr_size
* 2, _("Address"),
19904 addr_size
* 2, _("Initial"),
19905 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
19906 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
19907 for (i
= 0; i
< count
; i
++)
19909 uint64_t idx
= get_reloc_symindex (rels
[i
].r_info
);
19911 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
19914 if (idx
>= filedata
->num_dynamic_syms
)
19915 printf (_("<corrupt symbol index: %" PRIu64
">"), idx
);
19918 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
19920 print_vma (psym
->st_value
, LONG_HEX
);
19921 printf (" %-7s %3s ",
19922 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
19923 printable_section_name_from_index (filedata
, psym
->st_shndx
, NULL
));
19924 if (valid_dynamic_name (filedata
, psym
->st_name
))
19925 print_symbol_name (sym_width
,
19926 get_dynamic_name (filedata
, psym
->st_name
));
19928 printf (_("<corrupt: %14ld>"), psym
->st_name
);
19942 process_nds32_specific (Filedata
* filedata
)
19944 Elf_Internal_Shdr
*sect
= NULL
;
19946 sect
= find_section (filedata
, ".nds32_e_flags");
19947 if (sect
!= NULL
&& sect
->sh_size
>= 4)
19949 unsigned char *buf
;
19952 printf ("\nNDS32 elf flags section:\n");
19953 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
19954 _("NDS32 elf flags section"));
19959 flag
= byte_get (buf
, 4);
19961 switch (flag
& 0x3)
19964 printf ("(VEC_SIZE):\tNo entry.\n");
19967 printf ("(VEC_SIZE):\t4 bytes\n");
19970 printf ("(VEC_SIZE):\t16 bytes\n");
19973 printf ("(VEC_SIZE):\treserved\n");
19982 process_gnu_liblist (Filedata
* filedata
)
19984 Elf_Internal_Shdr
* section
;
19985 Elf_Internal_Shdr
* string_sec
;
19986 Elf32_External_Lib
* elib
;
19988 size_t strtab_size
;
19990 uint64_t num_liblist
;
19997 for (i
= 0, section
= filedata
->section_headers
;
19998 i
< filedata
->file_header
.e_shnum
;
20001 switch (section
->sh_type
)
20003 case SHT_GNU_LIBLIST
:
20004 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
20007 elib
= (Elf32_External_Lib
*)
20008 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
20009 _("liblist section data"));
20017 string_sec
= filedata
->section_headers
+ section
->sh_link
;
20018 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
20019 string_sec
->sh_size
,
20020 _("liblist string table"));
20022 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
20029 strtab_size
= string_sec
->sh_size
;
20031 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
20032 printf (ngettext ("\nLibrary list section '%s' contains %" PRIu64
20034 "\nLibrary list section '%s' contains %" PRIu64
20037 printable_section_name (filedata
, section
),
20040 puts (_(" Library Time Stamp Checksum Version Flags"));
20042 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
20050 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
20051 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
20052 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
20053 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
20054 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
20056 tmp
= gmtime (&atime
);
20057 snprintf (timebuf
, sizeof (timebuf
),
20058 "%04u-%02u-%02uT%02u:%02u:%02u",
20059 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
20060 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
20062 printf ("%3zu: ", cnt
);
20064 printf ("%-20s", liblist
.l_name
< strtab_size
20065 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
20067 printf ("%-20.20s", liblist
.l_name
< strtab_size
20068 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
20069 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
20070 liblist
.l_version
, liblist
.l_flags
);
20081 static const char *
20082 get_note_type (Filedata
* filedata
, unsigned e_type
)
20084 static char buff
[64];
20086 if (filedata
->file_header
.e_type
== ET_CORE
)
20090 return _("NT_AUXV (auxiliary vector)");
20092 return _("NT_PRSTATUS (prstatus structure)");
20094 return _("NT_FPREGSET (floating point registers)");
20096 return _("NT_PRPSINFO (prpsinfo structure)");
20097 case NT_TASKSTRUCT
:
20098 return _("NT_TASKSTRUCT (task structure)");
20100 return _("NT_GDB_TDESC (GDB XML target description)");
20102 return _("NT_PRXFPREG (user_xfpregs structure)");
20104 return _("NT_PPC_VMX (ppc Altivec registers)");
20106 return _("NT_PPC_VSX (ppc VSX registers)");
20108 return _("NT_PPC_TAR (ppc TAR register)");
20110 return _("NT_PPC_PPR (ppc PPR register)");
20112 return _("NT_PPC_DSCR (ppc DSCR register)");
20114 return _("NT_PPC_EBB (ppc EBB registers)");
20116 return _("NT_PPC_PMU (ppc PMU registers)");
20117 case NT_PPC_TM_CGPR
:
20118 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
20119 case NT_PPC_TM_CFPR
:
20120 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
20121 case NT_PPC_TM_CVMX
:
20122 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
20123 case NT_PPC_TM_CVSX
:
20124 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
20125 case NT_PPC_TM_SPR
:
20126 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
20127 case NT_PPC_TM_CTAR
:
20128 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
20129 case NT_PPC_TM_CPPR
:
20130 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
20131 case NT_PPC_TM_CDSCR
:
20132 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
20134 return _("NT_386_TLS (x86 TLS information)");
20135 case NT_386_IOPERM
:
20136 return _("NT_386_IOPERM (x86 I/O permissions)");
20137 case NT_X86_XSTATE
:
20138 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
20140 return _("NT_X86_CET (x86 CET state)");
20141 case NT_S390_HIGH_GPRS
:
20142 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
20143 case NT_S390_TIMER
:
20144 return _("NT_S390_TIMER (s390 timer register)");
20145 case NT_S390_TODCMP
:
20146 return _("NT_S390_TODCMP (s390 TOD comparator register)");
20147 case NT_S390_TODPREG
:
20148 return _("NT_S390_TODPREG (s390 TOD programmable register)");
20150 return _("NT_S390_CTRS (s390 control registers)");
20151 case NT_S390_PREFIX
:
20152 return _("NT_S390_PREFIX (s390 prefix register)");
20153 case NT_S390_LAST_BREAK
:
20154 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
20155 case NT_S390_SYSTEM_CALL
:
20156 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
20158 return _("NT_S390_TDB (s390 transaction diagnostic block)");
20159 case NT_S390_VXRS_LOW
:
20160 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
20161 case NT_S390_VXRS_HIGH
:
20162 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
20163 case NT_S390_GS_CB
:
20164 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
20165 case NT_S390_GS_BC
:
20166 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
20168 return _("NT_ARM_VFP (arm VFP registers)");
20170 return _("NT_ARM_TLS (AArch TLS registers)");
20171 case NT_ARM_HW_BREAK
:
20172 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
20173 case NT_ARM_HW_WATCH
:
20174 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
20175 case NT_ARM_SYSTEM_CALL
:
20176 return _("NT_ARM_SYSTEM_CALL (AArch system call number)");
20178 return _("NT_ARM_SVE (AArch SVE registers)");
20179 case NT_ARM_PAC_MASK
:
20180 return _("NT_ARM_PAC_MASK (AArch pointer authentication code masks)");
20181 case NT_ARM_PACA_KEYS
:
20182 return _("NT_ARM_PACA_KEYS (ARM pointer authentication address keys)");
20183 case NT_ARM_PACG_KEYS
:
20184 return _("NT_ARM_PACG_KEYS (ARM pointer authentication generic keys)");
20185 case NT_ARM_TAGGED_ADDR_CTRL
:
20186 return _("NT_ARM_TAGGED_ADDR_CTRL (AArch tagged address control)");
20188 return _("NT_ARM_SSVE (AArch64 streaming SVE registers)");
20190 return _("NT_ARM_ZA (AArch64 SME ZA register)");
20192 return _("NT_ARM_ZT (AArch64 SME2 ZT registers)");
20193 case NT_ARM_PAC_ENABLED_KEYS
:
20194 return _("NT_ARM_PAC_ENABLED_KEYS (AArch64 pointer authentication enabled keys)");
20196 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
20198 return _("NT_RISCV_CSR (RISC-V control and status registers)");
20200 return _("NT_PSTATUS (pstatus structure)");
20202 return _("NT_FPREGS (floating point registers)");
20204 return _("NT_PSINFO (psinfo structure)");
20206 return _("NT_LWPSTATUS (lwpstatus_t structure)");
20208 return _("NT_LWPSINFO (lwpsinfo_t structure)");
20209 case NT_WIN32PSTATUS
:
20210 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
20212 return _("NT_SIGINFO (siginfo_t data)");
20214 return _("NT_FILE (mapped files)");
20222 return _("NT_VERSION (version)");
20224 return _("NT_ARCH (architecture)");
20225 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
20227 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
20229 case NT_GO_BUILDID
:
20230 return _("GO BUILDID");
20231 case FDO_PACKAGING_METADATA
:
20232 return _("FDO_PACKAGING_METADATA");
20237 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
20242 print_core_note (Elf_Internal_Note
*pnote
)
20244 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
20245 uint64_t count
, page_size
;
20246 unsigned char *descdata
, *filenames
, *descend
;
20248 if (pnote
->type
!= NT_FILE
)
20257 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
20258 /* Still "successful". */
20262 if (pnote
->descsz
< 2 * addr_size
)
20264 error (_(" Malformed note - too short for header\n"));
20268 descdata
= (unsigned char *) pnote
->descdata
;
20269 descend
= descdata
+ pnote
->descsz
;
20271 if (descdata
[pnote
->descsz
- 1] != '\0')
20273 error (_(" Malformed note - does not end with \\0\n"));
20277 count
= byte_get (descdata
, addr_size
);
20278 descdata
+= addr_size
;
20280 page_size
= byte_get (descdata
, addr_size
);
20281 descdata
+= addr_size
;
20283 if (count
> ((uint64_t) -1 - 2 * addr_size
) / (3 * addr_size
)
20284 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
20286 error (_(" Malformed note - too short for supplied file count\n"));
20290 printf (_(" Page size: "));
20291 print_vma (page_size
, DEC
);
20294 printf (_(" %*s%*s%*s\n"),
20295 (int) (2 + 2 * addr_size
), _("Start"),
20296 (int) (4 + 2 * addr_size
), _("End"),
20297 (int) (4 + 2 * addr_size
), _("Page Offset"));
20298 filenames
= descdata
+ count
* 3 * addr_size
;
20299 while (count
-- > 0)
20301 uint64_t start
, end
, file_ofs
;
20303 if (filenames
== descend
)
20305 error (_(" Malformed note - filenames end too early\n"));
20309 start
= byte_get (descdata
, addr_size
);
20310 descdata
+= addr_size
;
20311 end
= byte_get (descdata
, addr_size
);
20312 descdata
+= addr_size
;
20313 file_ofs
= byte_get (descdata
, addr_size
);
20314 descdata
+= addr_size
;
20317 print_vma (start
, FULL_HEX
);
20319 print_vma (end
, FULL_HEX
);
20321 print_vma (file_ofs
, FULL_HEX
);
20322 printf ("\n %s\n", filenames
);
20324 filenames
+= 1 + strlen ((char *) filenames
);
20330 static const char *
20331 get_gnu_elf_note_type (unsigned e_type
)
20333 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
20336 case NT_GNU_ABI_TAG
:
20337 return _("NT_GNU_ABI_TAG (ABI version tag)");
20339 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
20340 case NT_GNU_BUILD_ID
:
20341 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
20342 case NT_GNU_GOLD_VERSION
:
20343 return _("NT_GNU_GOLD_VERSION (gold version)");
20344 case NT_GNU_PROPERTY_TYPE_0
:
20345 return _("NT_GNU_PROPERTY_TYPE_0");
20346 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
20347 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
20348 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
20349 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
20352 static char buff
[64];
20354 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
20361 decode_x86_compat_isa (unsigned int bitmask
)
20365 unsigned int bit
= bitmask
& (- bitmask
);
20370 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
20373 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
20376 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
20379 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
20382 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
20385 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
20388 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
20391 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
20394 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
20397 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
20400 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
20403 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
20404 printf ("AVX512F");
20406 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
20407 printf ("AVX512CD");
20409 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
20410 printf ("AVX512ER");
20412 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
20413 printf ("AVX512PF");
20415 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
20416 printf ("AVX512VL");
20418 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
20419 printf ("AVX512DQ");
20421 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
20422 printf ("AVX512BW");
20425 printf (_("<unknown: %x>"), bit
);
20434 decode_x86_compat_2_isa (unsigned int bitmask
)
20438 printf (_("<None>"));
20444 unsigned int bit
= bitmask
& (- bitmask
);
20449 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_CMOV
:
20452 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE
:
20455 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE2
:
20458 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE3
:
20461 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSSE3
:
20464 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_1
:
20467 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_2
:
20470 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX
:
20473 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX2
:
20476 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_FMA
:
20479 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512F
:
20480 printf ("AVX512F");
20482 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512CD
:
20483 printf ("AVX512CD");
20485 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512ER
:
20486 printf ("AVX512ER");
20488 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512PF
:
20489 printf ("AVX512PF");
20491 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512VL
:
20492 printf ("AVX512VL");
20494 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512DQ
:
20495 printf ("AVX512DQ");
20497 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512BW
:
20498 printf ("AVX512BW");
20500 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4FMAPS
:
20501 printf ("AVX512_4FMAPS");
20503 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4VNNIW
:
20504 printf ("AVX512_4VNNIW");
20506 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BITALG
:
20507 printf ("AVX512_BITALG");
20509 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_IFMA
:
20510 printf ("AVX512_IFMA");
20512 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI
:
20513 printf ("AVX512_VBMI");
20515 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI2
:
20516 printf ("AVX512_VBMI2");
20518 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VNNI
:
20519 printf ("AVX512_VNNI");
20521 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BF16
:
20522 printf ("AVX512_BF16");
20525 printf (_("<unknown: %x>"), bit
);
20533 static const char *
20534 get_amdgpu_elf_note_type (unsigned int e_type
)
20538 case NT_AMDGPU_METADATA
:
20539 return _("NT_AMDGPU_METADATA (code object metadata)");
20542 static char buf
[64];
20543 snprintf (buf
, sizeof (buf
), _("Unknown note type: (0x%08x)"), e_type
);
20550 decode_x86_isa (unsigned int bitmask
)
20554 unsigned int bit
= bitmask
& (- bitmask
);
20559 case GNU_PROPERTY_X86_ISA_1_BASELINE
:
20560 printf ("x86-64-baseline");
20562 case GNU_PROPERTY_X86_ISA_1_V2
:
20563 printf ("x86-64-v2");
20565 case GNU_PROPERTY_X86_ISA_1_V3
:
20566 printf ("x86-64-v3");
20568 case GNU_PROPERTY_X86_ISA_1_V4
:
20569 printf ("x86-64-v4");
20572 printf (_("<unknown: %x>"), bit
);
20581 decode_x86_feature_1 (unsigned int bitmask
)
20585 printf (_("<None>"));
20591 unsigned int bit
= bitmask
& (- bitmask
);
20596 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
20599 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
20602 case GNU_PROPERTY_X86_FEATURE_1_LAM_U48
:
20603 printf ("LAM_U48");
20605 case GNU_PROPERTY_X86_FEATURE_1_LAM_U57
:
20606 printf ("LAM_U57");
20609 printf (_("<unknown: %x>"), bit
);
20618 decode_x86_feature_2 (unsigned int bitmask
)
20622 printf (_("<None>"));
20628 unsigned int bit
= bitmask
& (- bitmask
);
20633 case GNU_PROPERTY_X86_FEATURE_2_X86
:
20636 case GNU_PROPERTY_X86_FEATURE_2_X87
:
20639 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
20642 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
20645 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
20648 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
20651 case GNU_PROPERTY_X86_FEATURE_2_TMM
:
20654 case GNU_PROPERTY_X86_FEATURE_2_MASK
:
20657 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
20660 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
20663 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
20664 printf ("XSAVEOPT");
20666 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
20670 printf (_("<unknown: %x>"), bit
);
20679 decode_aarch64_feature_1_and (unsigned int bitmask
)
20683 unsigned int bit
= bitmask
& (- bitmask
);
20688 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
20692 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
20697 printf (_("<unknown: %x>"), bit
);
20706 decode_1_needed (unsigned int bitmask
)
20710 unsigned int bit
= bitmask
& (- bitmask
);
20715 case GNU_PROPERTY_1_NEEDED_INDIRECT_EXTERN_ACCESS
:
20716 printf ("indirect external access");
20719 printf (_("<unknown: %x>"), bit
);
20728 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
20730 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
20731 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
20732 unsigned int size
= is_32bit_elf
? 4 : 8;
20734 printf (_(" Properties: "));
20736 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
20738 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
20742 while (ptr
< ptr_end
)
20746 unsigned int datasz
;
20748 if ((size_t) (ptr_end
- ptr
) < 8)
20750 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
20754 type
= byte_get (ptr
, 4);
20755 datasz
= byte_get (ptr
+ 4, 4);
20759 if (datasz
> (size_t) (ptr_end
- ptr
))
20761 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
20766 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
20768 if (filedata
->file_header
.e_machine
== EM_X86_64
20769 || filedata
->file_header
.e_machine
== EM_IAMCU
20770 || filedata
->file_header
.e_machine
== EM_386
)
20772 unsigned int bitmask
;
20775 bitmask
= byte_get (ptr
, 4);
20781 case GNU_PROPERTY_X86_ISA_1_USED
:
20783 printf (_("x86 ISA used: <corrupt length: %#x> "),
20787 printf ("x86 ISA used: ");
20788 decode_x86_isa (bitmask
);
20792 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
20794 printf (_("x86 ISA needed: <corrupt length: %#x> "),
20798 printf ("x86 ISA needed: ");
20799 decode_x86_isa (bitmask
);
20803 case GNU_PROPERTY_X86_FEATURE_1_AND
:
20805 printf (_("x86 feature: <corrupt length: %#x> "),
20809 printf ("x86 feature: ");
20810 decode_x86_feature_1 (bitmask
);
20814 case GNU_PROPERTY_X86_FEATURE_2_USED
:
20816 printf (_("x86 feature used: <corrupt length: %#x> "),
20820 printf ("x86 feature used: ");
20821 decode_x86_feature_2 (bitmask
);
20825 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
20827 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
20830 printf ("x86 feature needed: ");
20831 decode_x86_feature_2 (bitmask
);
20835 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
20837 printf (_("x86 ISA used: <corrupt length: %#x> "),
20841 printf ("x86 ISA used: ");
20842 decode_x86_compat_isa (bitmask
);
20846 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
20848 printf (_("x86 ISA needed: <corrupt length: %#x> "),
20852 printf ("x86 ISA needed: ");
20853 decode_x86_compat_isa (bitmask
);
20857 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_USED
:
20859 printf (_("x86 ISA used: <corrupt length: %#x> "),
20863 printf ("x86 ISA used: ");
20864 decode_x86_compat_2_isa (bitmask
);
20868 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_NEEDED
:
20870 printf (_("x86 ISA needed: <corrupt length: %#x> "),
20874 printf ("x86 ISA needed: ");
20875 decode_x86_compat_2_isa (bitmask
);
20883 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
20885 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
20887 printf ("AArch64 feature: ");
20889 printf (_("<corrupt length: %#x> "), datasz
);
20891 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
20900 case GNU_PROPERTY_STACK_SIZE
:
20901 printf (_("stack size: "));
20902 if (datasz
!= size
)
20903 printf (_("<corrupt length: %#x> "), datasz
);
20905 printf ("%#" PRIx64
, byte_get (ptr
, size
));
20908 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
20909 printf ("no copy on protected ");
20911 printf (_("<corrupt length: %#x> "), datasz
);
20915 if ((type
>= GNU_PROPERTY_UINT32_AND_LO
20916 && type
<= GNU_PROPERTY_UINT32_AND_HI
)
20917 || (type
>= GNU_PROPERTY_UINT32_OR_LO
20918 && type
<= GNU_PROPERTY_UINT32_OR_HI
))
20922 case GNU_PROPERTY_1_NEEDED
:
20924 printf (_("1_needed: <corrupt length: %#x> "),
20928 unsigned int bitmask
= byte_get (ptr
, 4);
20929 printf ("1_needed: ");
20930 decode_1_needed (bitmask
);
20937 if (type
<= GNU_PROPERTY_UINT32_AND_HI
)
20938 printf (_("UINT32_AND (%#x): "), type
);
20940 printf (_("UINT32_OR (%#x): "), type
);
20942 printf (_("<corrupt length: %#x> "), datasz
);
20944 printf ("%#x", (unsigned int) byte_get (ptr
, 4));
20951 if (type
< GNU_PROPERTY_LOPROC
)
20952 printf (_("<unknown type %#x data: "), type
);
20953 else if (type
< GNU_PROPERTY_LOUSER
)
20954 printf (_("<processor-specific type %#x data: "), type
);
20956 printf (_("<application-specific type %#x data: "), type
);
20957 for (j
= 0; j
< datasz
; ++j
)
20958 printf ("%02x ", ptr
[j
] & 0xff);
20962 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
20963 if (ptr
== ptr_end
)
20976 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
20978 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
20979 switch (pnote
->type
)
20981 case NT_GNU_BUILD_ID
:
20985 printf (_(" Build ID: "));
20986 for (i
= 0; i
< pnote
->descsz
; ++i
)
20987 printf ("%02x", pnote
->descdata
[i
] & 0xff);
20992 case NT_GNU_ABI_TAG
:
20994 unsigned int os
, major
, minor
, subminor
;
20995 const char *osname
;
20997 /* PR 17531: file: 030-599401-0.004. */
20998 if (pnote
->descsz
< 16)
21000 printf (_(" <corrupt GNU_ABI_TAG>\n"));
21004 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
21005 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
21006 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
21007 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
21011 case GNU_ABI_TAG_LINUX
:
21014 case GNU_ABI_TAG_HURD
:
21017 case GNU_ABI_TAG_SOLARIS
:
21018 osname
= "Solaris";
21020 case GNU_ABI_TAG_FREEBSD
:
21021 osname
= "FreeBSD";
21023 case GNU_ABI_TAG_NETBSD
:
21026 case GNU_ABI_TAG_SYLLABLE
:
21027 osname
= "Syllable";
21029 case GNU_ABI_TAG_NACL
:
21033 osname
= "Unknown";
21037 printf (_(" OS: %s, ABI: %d.%d.%d\n"), osname
,
21038 major
, minor
, subminor
);
21042 case NT_GNU_GOLD_VERSION
:
21046 printf (_(" Version: "));
21047 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
21048 printf ("%c", pnote
->descdata
[i
]);
21055 unsigned int num_entries
, mask
;
21057 /* Hardware capabilities information. Word 0 is the number of entries.
21058 Word 1 is a bitmask of enabled entries. The rest of the descriptor
21059 is a series of entries, where each entry is a single byte followed
21060 by a nul terminated string. The byte gives the bit number to test
21061 if enabled in the bitmask. */
21062 printf (_(" Hardware Capabilities: "));
21063 if (pnote
->descsz
< 8)
21065 error (_("<corrupt GNU_HWCAP>\n"));
21068 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
21069 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
21070 printf (_("num entries: %d, enabled mask: %x\n"), num_entries
, mask
);
21071 /* FIXME: Add code to display the entries... */
21075 case NT_GNU_PROPERTY_TYPE_0
:
21076 print_gnu_property_note (filedata
, pnote
);
21080 /* Handle unrecognised types. An error message should have already been
21081 created by get_gnu_elf_note_type(), so all that we need to do is to
21082 display the data. */
21086 printf (_(" Description data: "));
21087 for (i
= 0; i
< pnote
->descsz
; ++i
)
21088 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
21097 static const char *
21098 get_v850_elf_note_type (enum v850_notes n_type
)
21100 static char buff
[64];
21104 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
21105 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
21106 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
21107 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
21108 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
21109 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
21111 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
21117 print_v850_note (Elf_Internal_Note
* pnote
)
21121 if (pnote
->descsz
!= 4)
21124 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
21128 printf (_("not set\n"));
21132 switch (pnote
->type
)
21134 case V850_NOTE_ALIGNMENT
:
21137 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return true;
21138 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return true;
21142 case V850_NOTE_DATA_SIZE
:
21145 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return true;
21146 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return true;
21150 case V850_NOTE_FPU_INFO
:
21153 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return true;
21154 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return true;
21158 case V850_NOTE_MMU_INFO
:
21159 case V850_NOTE_CACHE_INFO
:
21160 case V850_NOTE_SIMD_INFO
:
21161 if (val
== EF_RH850_SIMD
)
21163 printf (_("yes\n"));
21169 /* An 'unknown note type' message will already have been displayed. */
21173 printf (_("unknown value: %x\n"), val
);
21178 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
21180 unsigned int version
;
21182 switch (pnote
->type
)
21184 case NT_NETBSD_IDENT
:
21185 if (pnote
->descsz
< 1)
21187 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
21188 if ((version
/ 10000) % 100)
21189 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
21190 version
, version
/ 100000000, (version
/ 1000000) % 100,
21191 (version
/ 10000) % 100 > 26 ? "Z" : "",
21192 'A' + (version
/ 10000) % 26);
21194 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
21195 version
, version
/ 100000000, (version
/ 1000000) % 100,
21196 (version
/ 100) % 100);
21199 case NT_NETBSD_MARCH
:
21200 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
21204 case NT_NETBSD_PAX
:
21205 if (pnote
->descsz
< 1)
21207 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
21208 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
21209 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
21210 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
21211 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
21212 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
21213 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
21214 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
21218 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
21219 pnote
->descsz
, pnote
->type
);
21223 static const char *
21224 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
21228 case NT_FREEBSD_THRMISC
:
21229 return _("NT_THRMISC (thrmisc structure)");
21230 case NT_FREEBSD_PROCSTAT_PROC
:
21231 return _("NT_PROCSTAT_PROC (proc data)");
21232 case NT_FREEBSD_PROCSTAT_FILES
:
21233 return _("NT_PROCSTAT_FILES (files data)");
21234 case NT_FREEBSD_PROCSTAT_VMMAP
:
21235 return _("NT_PROCSTAT_VMMAP (vmmap data)");
21236 case NT_FREEBSD_PROCSTAT_GROUPS
:
21237 return _("NT_PROCSTAT_GROUPS (groups data)");
21238 case NT_FREEBSD_PROCSTAT_UMASK
:
21239 return _("NT_PROCSTAT_UMASK (umask data)");
21240 case NT_FREEBSD_PROCSTAT_RLIMIT
:
21241 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
21242 case NT_FREEBSD_PROCSTAT_OSREL
:
21243 return _("NT_PROCSTAT_OSREL (osreldate data)");
21244 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
21245 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
21246 case NT_FREEBSD_PROCSTAT_AUXV
:
21247 return _("NT_PROCSTAT_AUXV (auxv data)");
21248 case NT_FREEBSD_PTLWPINFO
:
21249 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
21250 case NT_FREEBSD_X86_SEGBASES
:
21251 return _("NT_X86_SEGBASES (x86 segment base registers)");
21253 return get_note_type (filedata
, e_type
);
21256 static const char *
21257 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
21259 static char buff
[64];
21263 case NT_NETBSDCORE_PROCINFO
:
21264 /* NetBSD core "procinfo" structure. */
21265 return _("NetBSD procinfo structure");
21267 case NT_NETBSDCORE_AUXV
:
21268 return _("NetBSD ELF auxiliary vector data");
21270 case NT_NETBSDCORE_LWPSTATUS
:
21271 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
21274 /* As of Jan 2020 there are no other machine-independent notes
21275 defined for NetBSD core files. If the note type is less
21276 than the start of the machine-dependent note types, we don't
21279 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
21281 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
21287 switch (filedata
->file_header
.e_machine
)
21289 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
21290 and PT_GETFPREGS == mach+2. */
21295 case EM_SPARC32PLUS
:
21299 case NT_NETBSDCORE_FIRSTMACH
+ 0:
21300 return _("PT_GETREGS (reg structure)");
21301 case NT_NETBSDCORE_FIRSTMACH
+ 2:
21302 return _("PT_GETFPREGS (fpreg structure)");
21308 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
21309 There's also old PT___GETREGS40 == mach + 1 for old reg
21310 structure which lacks GBR. */
21314 case NT_NETBSDCORE_FIRSTMACH
+ 1:
21315 return _("PT___GETREGS40 (old reg structure)");
21316 case NT_NETBSDCORE_FIRSTMACH
+ 3:
21317 return _("PT_GETREGS (reg structure)");
21318 case NT_NETBSDCORE_FIRSTMACH
+ 5:
21319 return _("PT_GETFPREGS (fpreg structure)");
21325 /* On all other arch's, PT_GETREGS == mach+1 and
21326 PT_GETFPREGS == mach+3. */
21330 case NT_NETBSDCORE_FIRSTMACH
+ 1:
21331 return _("PT_GETREGS (reg structure)");
21332 case NT_NETBSDCORE_FIRSTMACH
+ 3:
21333 return _("PT_GETFPREGS (fpreg structure)");
21339 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
21340 e_type
- NT_NETBSDCORE_FIRSTMACH
);
21344 static const char *
21345 get_openbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
21349 case NT_OPENBSD_PROCINFO
:
21350 return _("OpenBSD procinfo structure");
21351 case NT_OPENBSD_AUXV
:
21352 return _("OpenBSD ELF auxiliary vector data");
21353 case NT_OPENBSD_REGS
:
21354 return _("OpenBSD regular registers");
21355 case NT_OPENBSD_FPREGS
:
21356 return _("OpenBSD floating point registers");
21357 case NT_OPENBSD_WCOOKIE
:
21358 return _("OpenBSD window cookie");
21361 return get_note_type (filedata
, e_type
);
21364 static const char *
21365 get_qnx_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
21369 case QNT_DEBUG_FULLPATH
:
21370 return _("QNX debug fullpath");
21371 case QNT_DEBUG_RELOC
:
21372 return _("QNX debug relocation");
21374 return _("QNX stack");
21375 case QNT_GENERATOR
:
21376 return _("QNX generator");
21377 case QNT_DEFAULT_LIB
:
21378 return _("QNX default library");
21379 case QNT_CORE_SYSINFO
:
21380 return _("QNX core sysinfo");
21381 case QNT_CORE_INFO
:
21382 return _("QNX core info");
21383 case QNT_CORE_STATUS
:
21384 return _("QNX core status");
21385 case QNT_CORE_GREG
:
21386 return _("QNX general registers");
21387 case QNT_CORE_FPREG
:
21388 return _("QNX floating point registers");
21390 return _("QNX link map");
21393 return get_note_type (filedata
, e_type
);
21396 static const char *
21397 get_stapsdt_note_type (unsigned e_type
)
21399 static char buff
[64];
21404 return _("NT_STAPSDT (SystemTap probe descriptors)");
21410 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
21415 print_stapsdt_note (Elf_Internal_Note
*pnote
)
21417 size_t len
, maxlen
;
21418 size_t addr_size
= is_32bit_elf
? 4 : 8;
21419 char *data
= pnote
->descdata
;
21420 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
21421 uint64_t pc
, base_addr
, semaphore
;
21422 char *provider
, *probe
, *arg_fmt
;
21424 if (pnote
->descsz
< (addr_size
* 3))
21425 goto stapdt_note_too_small
;
21427 pc
= byte_get ((unsigned char *) data
, addr_size
);
21430 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
21433 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
21436 if (data
>= data_end
)
21437 goto stapdt_note_too_small
;
21438 maxlen
= data_end
- data
;
21439 len
= strnlen (data
, maxlen
);
21446 goto stapdt_note_too_small
;
21448 if (data
>= data_end
)
21449 goto stapdt_note_too_small
;
21450 maxlen
= data_end
- data
;
21451 len
= strnlen (data
, maxlen
);
21458 goto stapdt_note_too_small
;
21460 if (data
>= data_end
)
21461 goto stapdt_note_too_small
;
21462 maxlen
= data_end
- data
;
21463 len
= strnlen (data
, maxlen
);
21470 goto stapdt_note_too_small
;
21472 printf (_(" Provider: %s\n"), provider
);
21473 printf (_(" Name: %s\n"), probe
);
21474 printf (_(" Location: "));
21475 print_vma (pc
, FULL_HEX
);
21476 printf (_(", Base: "));
21477 print_vma (base_addr
, FULL_HEX
);
21478 printf (_(", Semaphore: "));
21479 print_vma (semaphore
, FULL_HEX
);
21481 printf (_(" Arguments: %s\n"), arg_fmt
);
21483 return data
== data_end
;
21485 stapdt_note_too_small
:
21486 printf (_(" <corrupt - note is too small>\n"));
21487 error (_("corrupt stapdt note - the data size is too small\n"));
21492 print_fdo_note (Elf_Internal_Note
* pnote
)
21494 if (pnote
->descsz
> 0 && pnote
->type
== FDO_PACKAGING_METADATA
)
21496 printf (_(" Packaging Metadata: %.*s\n"), (int) pnote
->descsz
, pnote
->descdata
);
21502 static const char *
21503 get_ia64_vms_note_type (unsigned e_type
)
21505 static char buff
[64];
21510 return _("NT_VMS_MHD (module header)");
21512 return _("NT_VMS_LNM (language name)");
21514 return _("NT_VMS_SRC (source files)");
21516 return "NT_VMS_TITLE";
21518 return _("NT_VMS_EIDC (consistency check)");
21519 case NT_VMS_FPMODE
:
21520 return _("NT_VMS_FPMODE (FP mode)");
21521 case NT_VMS_LINKTIME
:
21522 return "NT_VMS_LINKTIME";
21523 case NT_VMS_IMGNAM
:
21524 return _("NT_VMS_IMGNAM (image name)");
21526 return _("NT_VMS_IMGID (image id)");
21527 case NT_VMS_LINKID
:
21528 return _("NT_VMS_LINKID (link id)");
21529 case NT_VMS_IMGBID
:
21530 return _("NT_VMS_IMGBID (build id)");
21531 case NT_VMS_GSTNAM
:
21532 return _("NT_VMS_GSTNAM (sym table name)");
21533 case NT_VMS_ORIG_DYN
:
21534 return "NT_VMS_ORIG_DYN";
21535 case NT_VMS_PATCHTIME
:
21536 return "NT_VMS_PATCHTIME";
21538 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
21544 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
21546 unsigned int maxlen
= pnote
->descsz
;
21548 if (maxlen
< 2 || maxlen
!= pnote
->descsz
)
21549 goto desc_size_fail
;
21551 switch (pnote
->type
)
21555 goto desc_size_fail
;
21557 size_t l
= strnlen (pnote
->descdata
+ 34, maxlen
- 34);
21559 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
21560 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
21561 if (l
+ 34 < maxlen
)
21563 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
21564 if (l
+ 35 < maxlen
)
21565 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
21567 printf (_(" Module version : <missing>\n"));
21571 printf (_(" Module name : <missing>\n"));
21572 printf (_(" Module version : <missing>\n"));
21577 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
21580 case NT_VMS_FPMODE
:
21581 printf (_(" Floating Point mode: "));
21583 goto desc_size_fail
;
21584 /* FIXME: Generate an error if descsz > 8 ? */
21586 printf ("0x%016" PRIx64
"\n",
21587 byte_get ((unsigned char *) pnote
->descdata
, 8));
21590 case NT_VMS_LINKTIME
:
21591 printf (_(" Link time: "));
21593 goto desc_size_fail
;
21594 /* FIXME: Generate an error if descsz > 8 ? */
21596 print_vms_time (byte_get ((unsigned char *) pnote
->descdata
, 8));
21600 case NT_VMS_PATCHTIME
:
21601 printf (_(" Patch time: "));
21603 goto desc_size_fail
;
21604 /* FIXME: Generate an error if descsz > 8 ? */
21606 print_vms_time (byte_get ((unsigned char *) pnote
->descdata
, 8));
21610 case NT_VMS_ORIG_DYN
:
21612 goto desc_size_fail
;
21614 printf (_(" Major id: %u, minor id: %u\n"),
21615 (unsigned) byte_get ((unsigned char *) pnote
->descdata
, 4),
21616 (unsigned) byte_get ((unsigned char *) pnote
->descdata
+ 4, 4));
21617 printf (_(" Last modified : "));
21618 print_vms_time (byte_get ((unsigned char *) pnote
->descdata
+ 8, 8));
21619 printf (_("\n Link flags : "));
21620 printf ("0x%016" PRIx64
"\n",
21621 byte_get ((unsigned char *) pnote
->descdata
+ 16, 8));
21622 printf (_(" Header flags: 0x%08x\n"),
21623 (unsigned) byte_get ((unsigned char *) pnote
->descdata
+ 24, 4));
21624 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
21627 case NT_VMS_IMGNAM
:
21628 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
21631 case NT_VMS_GSTNAM
:
21632 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
21636 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
21639 case NT_VMS_LINKID
:
21640 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
21650 printf (_(" <corrupt - data size is too small>\n"));
21651 error (_("corrupt IA64 note: data size is too small\n"));
21655 struct build_attr_cache
{
21656 Filedata
*filedata
;
21658 uint64_t strtablen
;
21659 Elf_Internal_Sym
*symtab
;
21663 /* Find the symbol associated with a build attribute that is attached
21664 to address OFFSET. If PNAME is non-NULL then store the name of
21665 the symbol (if found) in the provided pointer, Returns NULL if a
21666 symbol could not be found. */
21668 static Elf_Internal_Sym
*
21669 get_symbol_for_build_attribute (Filedata
*filedata
,
21672 const char **pname
)
21674 Elf_Internal_Sym
*saved_sym
= NULL
;
21675 Elf_Internal_Sym
*sym
;
21677 if (filedata
->section_headers
!= NULL
21678 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
21680 Elf_Internal_Shdr
* symsec
;
21682 free (ba_cache
.strtab
);
21683 ba_cache
.strtab
= NULL
;
21684 free (ba_cache
.symtab
);
21685 ba_cache
.symtab
= NULL
;
21687 /* Load the symbol and string sections. */
21688 for (symsec
= filedata
->section_headers
;
21689 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
21692 if (symsec
->sh_type
== SHT_SYMTAB
21693 && get_symtab (filedata
, symsec
,
21694 &ba_cache
.symtab
, &ba_cache
.nsyms
,
21695 &ba_cache
.strtab
, &ba_cache
.strtablen
))
21698 ba_cache
.filedata
= filedata
;
21701 if (ba_cache
.symtab
== NULL
)
21704 /* Find a symbol whose value matches offset. */
21705 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
21706 if (sym
->st_value
== offset
)
21708 if (sym
->st_name
>= ba_cache
.strtablen
)
21709 /* Huh ? This should not happen. */
21712 if (ba_cache
.strtab
[sym
->st_name
] == 0)
21715 /* The AArch64, ARM and RISC-V architectures define mapping symbols
21716 (eg $d, $x, $t) which we want to ignore. */
21717 if (ba_cache
.strtab
[sym
->st_name
] == '$'
21718 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
21719 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
21724 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
21725 and FILE or OBJECT symbols over NOTYPE symbols. We skip
21726 FUNC symbols entirely. */
21727 switch (ELF_ST_TYPE (sym
->st_info
))
21734 /* If the symbol has a size associated
21735 with it then we can stop searching. */
21736 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
21741 /* Ignore function symbols. */
21748 switch (ELF_ST_BIND (sym
->st_info
))
21751 if (saved_sym
== NULL
21752 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
21757 if (saved_sym
== NULL
)
21767 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
21775 if (saved_sym
&& pname
)
21776 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
21781 /* Returns true iff addr1 and addr2 are in the same section. */
21784 same_section (Filedata
* filedata
, uint64_t addr1
, uint64_t addr2
)
21786 Elf_Internal_Shdr
* a1
;
21787 Elf_Internal_Shdr
* a2
;
21789 a1
= find_section_by_address (filedata
, addr1
);
21790 a2
= find_section_by_address (filedata
, addr2
);
21792 return a1
== a2
&& a1
!= NULL
;
21796 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
21797 Filedata
* filedata
)
21799 static uint64_t global_offset
= 0;
21800 static uint64_t global_end
= 0;
21801 static uint64_t func_offset
= 0;
21802 static uint64_t func_end
= 0;
21804 Elf_Internal_Sym
*sym
;
21808 bool is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
21810 switch (pnote
->descsz
)
21813 /* A zero-length description means that the range of
21814 the previous note of the same type should be used. */
21817 if (global_end
> global_offset
)
21818 printf (_(" Applies to region from %#" PRIx64
21819 " to %#" PRIx64
"\n"), global_offset
, global_end
);
21821 printf (_(" Applies to region from %#" PRIx64
21822 "\n"), global_offset
);
21826 if (func_end
> func_offset
)
21827 printf (_(" Applies to region from %#" PRIx64
21828 " to %#" PRIx64
"\n"), func_offset
, func_end
);
21830 printf (_(" Applies to region from %#" PRIx64
21831 "\n"), func_offset
);
21836 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
21841 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
21842 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
21846 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
21847 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
21851 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
21852 printf (_(" <invalid descsz>"));
21857 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
21858 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
21859 in order to avoid them being confused with the start address of the
21860 first function in the file... */
21861 if (sym
== NULL
&& is_open_attr
)
21862 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
21865 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
21866 end
= start
+ sym
->st_size
;
21870 /* FIXME: Need to properly allow for section alignment.
21871 16 is just the alignment used on x86_64. */
21873 && start
> BFD_ALIGN (global_end
, 16)
21874 /* Build notes are not guaranteed to be organised in order of
21875 increasing address, but we should find the all of the notes
21876 for one section in the same place. */
21877 && same_section (filedata
, start
, global_end
))
21878 warn (_("Gap in build notes detected from %#" PRIx64
21879 " to %#" PRIx64
"\n"),
21880 global_end
+ 1, start
- 1);
21882 printf (_(" Applies to region from %#" PRIx64
), start
);
21883 global_offset
= start
;
21887 printf (_(" to %#" PRIx64
), end
);
21893 printf (_(" Applies to region from %#" PRIx64
), start
);
21894 func_offset
= start
;
21898 printf (_(" to %#" PRIx64
), end
);
21904 printf (_(" (%s)"), name
);
21911 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
21913 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
21914 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
21915 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
21917 char name_attribute
;
21918 const char * expected_types
;
21919 const char * name
= pnote
->namedata
;
21923 if (name
== NULL
|| pnote
->namesz
< 2)
21925 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
21926 print_symbol_name (-20, _(" <corrupt name>"));
21935 /* Version 2 of the spec adds a "GA" prefix to the name field. */
21936 if (name
[0] == 'G' && name
[1] == 'A')
21938 if (pnote
->namesz
< 4)
21940 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
21941 print_symbol_name (-20, _(" <corrupt name>"));
21950 switch ((name_type
= * name
))
21952 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
21953 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
21954 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
21955 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
21956 printf ("%c", * name
);
21960 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
21961 print_symbol_name (-20, _("<unknown name type>"));
21968 switch ((name_attribute
= * name
))
21970 case GNU_BUILD_ATTRIBUTE_VERSION
:
21971 text
= _("<version>");
21972 expected_types
= string_expected
;
21975 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
21976 text
= _("<stack prot>");
21977 expected_types
= "!+*";
21980 case GNU_BUILD_ATTRIBUTE_RELRO
:
21981 text
= _("<relro>");
21982 expected_types
= bool_expected
;
21985 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
21986 text
= _("<stack size>");
21987 expected_types
= number_expected
;
21990 case GNU_BUILD_ATTRIBUTE_TOOL
:
21991 text
= _("<tool>");
21992 expected_types
= string_expected
;
21995 case GNU_BUILD_ATTRIBUTE_ABI
:
21997 expected_types
= "$*";
22000 case GNU_BUILD_ATTRIBUTE_PIC
:
22002 expected_types
= number_expected
;
22005 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
22006 text
= _("<short enum>");
22007 expected_types
= bool_expected
;
22011 if (ISPRINT (* name
))
22013 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
22015 if (len
> left
&& ! do_wide
)
22017 printf ("%.*s:", len
, name
);
22023 static char tmpbuf
[128];
22025 error (_("unrecognised byte in name field: %d\n"), * name
);
22026 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
22030 expected_types
= "*$!+";
22035 left
-= printf ("%s", text
);
22037 if (strchr (expected_types
, name_type
) == NULL
)
22038 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
22040 if ((size_t) (name
- pnote
->namedata
) > pnote
->namesz
)
22042 error (_("corrupt name field: namesz: %lu but parsing gets to %td\n"),
22044 name
- pnote
->namedata
);
22048 if (left
< 1 && ! do_wide
)
22053 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
22055 unsigned int bytes
;
22057 unsigned int shift
= 0;
22058 char *decoded
= NULL
;
22060 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
22062 /* The -1 is because the name field is always 0 terminated, and we
22063 want to be able to ensure that the shift in the while loop below
22064 will not overflow. */
22067 if (bytes
> sizeof (val
))
22069 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
22071 bytes
= sizeof (val
);
22073 /* We do not bother to warn if bytes == 0 as this can
22074 happen with some early versions of the gcc plugin. */
22078 uint64_t byte
= *name
++ & 0xff;
22080 val
|= byte
<< shift
;
22084 switch (name_attribute
)
22086 case GNU_BUILD_ATTRIBUTE_PIC
:
22089 case 0: decoded
= "static"; break;
22090 case 1: decoded
= "pic"; break;
22091 case 2: decoded
= "PIC"; break;
22092 case 3: decoded
= "pie"; break;
22093 case 4: decoded
= "PIE"; break;
22097 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
22100 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
22101 case 0: decoded
= "off"; break;
22102 case 1: decoded
= "on"; break;
22103 case 2: decoded
= "all"; break;
22104 case 3: decoded
= "strong"; break;
22105 case 4: decoded
= "explicit"; break;
22113 if (decoded
!= NULL
)
22115 print_symbol_name (-left
, decoded
);
22126 left
-= printf ("0x%" PRIx64
, val
);
22128 left
-= printf ("0x%-.*" PRIx64
, left
, val
);
22132 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
22133 left
-= print_symbol_name (- left
, name
);
22135 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
22136 left
-= print_symbol_name (- left
, "true");
22138 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
22139 left
-= print_symbol_name (- left
, "false");
22143 if (do_wide
&& left
> 0)
22144 printf ("%-*s", left
, " ");
22149 /* Print the contents of PNOTE as hex. */
22152 print_note_contents_hex (Elf_Internal_Note
*pnote
)
22158 printf (_(" description data: "));
22159 for (i
= 0; i
< pnote
->descsz
; i
++)
22160 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
22169 #if defined HAVE_MSGPACK
22172 print_indents (int n
)
22176 for (int i
= 0; i
< n
; i
++)
22180 /* Print OBJ in human-readable form. */
22183 dump_msgpack_obj (const msgpack_object
*obj
, int indent
)
22187 case MSGPACK_OBJECT_NIL
:
22191 case MSGPACK_OBJECT_BOOLEAN
:
22192 printf ("%s", obj
->via
.boolean
? "true" : "false");
22195 case MSGPACK_OBJECT_POSITIVE_INTEGER
:
22196 printf ("%" PRIu64
, obj
->via
.u64
);
22199 case MSGPACK_OBJECT_NEGATIVE_INTEGER
:
22200 printf ("%" PRIi64
, obj
->via
.i64
);
22203 case MSGPACK_OBJECT_FLOAT32
:
22204 case MSGPACK_OBJECT_FLOAT64
:
22205 printf ("%f", obj
->via
.f64
);
22208 case MSGPACK_OBJECT_STR
:
22209 printf ("\"%.*s\"", obj
->via
.str
.size
, obj
->via
.str
.ptr
);
22212 case MSGPACK_OBJECT_ARRAY
:
22214 const msgpack_object_array
*array
= &obj
->via
.array
;
22219 for (uint32_t i
= 0; i
< array
->size
; ++i
)
22221 const msgpack_object
*item
= &array
->ptr
[i
];
22223 print_indents (indent
);
22224 dump_msgpack_obj (item
, indent
);
22229 print_indents (indent
);
22235 case MSGPACK_OBJECT_MAP
:
22237 const msgpack_object_map
*map
= &obj
->via
.map
;
22242 for (uint32_t i
= 0; i
< map
->size
; ++i
)
22244 const msgpack_object_kv
*kv
= &map
->ptr
[i
];
22245 const msgpack_object
*key
= &kv
->key
;
22246 const msgpack_object
*val
= &kv
->val
;
22248 print_indents (indent
);
22249 dump_msgpack_obj (key
, indent
);
22251 dump_msgpack_obj (val
, indent
);
22257 print_indents (indent
);
22263 case MSGPACK_OBJECT_BIN
:
22267 case MSGPACK_OBJECT_EXT
:
22274 dump_msgpack (const msgpack_unpacked
*msg
)
22277 dump_msgpack_obj (&msg
->data
, 0);
22281 #endif /* defined HAVE_MSGPACK */
22284 print_amdgpu_note (Elf_Internal_Note
*pnote
)
22286 #if defined HAVE_MSGPACK
22287 /* If msgpack is available, decode and dump the note's content. */
22289 msgpack_unpacked msg
;
22290 msgpack_unpack_return msgpack_ret
;
22292 assert (pnote
->type
== NT_AMDGPU_METADATA
);
22294 msgpack_unpacked_init (&msg
);
22295 msgpack_ret
= msgpack_unpack_next (&msg
, pnote
->descdata
, pnote
->descsz
,
22298 switch (msgpack_ret
)
22300 case MSGPACK_UNPACK_SUCCESS
:
22301 dump_msgpack (&msg
);
22306 error (_("failed to unpack msgpack contents in NT_AMDGPU_METADATA note"));
22311 msgpack_unpacked_destroy (&msg
);
22314 /* msgpack is not available, dump contents as hex. */
22315 print_note_contents_hex (pnote
);
22321 print_qnx_note (Elf_Internal_Note
*pnote
)
22323 switch (pnote
->type
)
22326 if (pnote
->descsz
!= 12)
22327 goto desc_size_fail
;
22329 printf (_(" Stack Size: 0x%" PRIx32
"\n"),
22330 (unsigned) byte_get ((unsigned char *) pnote
->descdata
, 4));
22331 printf (_(" Stack allocated: %" PRIx32
"\n"),
22332 (unsigned) byte_get ((unsigned char *) pnote
->descdata
+ 4, 4));
22333 printf (_(" Executable: %s\n"),
22334 ((unsigned) byte_get ((unsigned char *) pnote
->descdata
+ 8, 1)) ? "no": "yes");
22338 print_note_contents_hex(pnote
);
22343 printf (_(" <corrupt - data size is too small>\n"));
22344 error (_("corrupt QNX note: data size is too small\n"));
22349 /* Note that by the ELF standard, the name field is already null byte
22350 terminated, and namesz includes the terminating null byte.
22351 I.E. the value of namesz for the name "FSF" is 4.
22353 If the value of namesz is zero, there is no name present. */
22356 process_note (Elf_Internal_Note
* pnote
,
22357 Filedata
* filedata
)
22359 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
22362 if (pnote
->namesz
== 0)
22363 /* If there is no note name, then use the default set of
22364 note type strings. */
22365 nt
= get_note_type (filedata
, pnote
->type
);
22367 else if (startswith (pnote
->namedata
, "GNU"))
22368 /* GNU-specific object file notes. */
22369 nt
= get_gnu_elf_note_type (pnote
->type
);
22371 else if (startswith (pnote
->namedata
, "AMDGPU"))
22372 /* AMDGPU-specific object file notes. */
22373 nt
= get_amdgpu_elf_note_type (pnote
->type
);
22375 else if (startswith (pnote
->namedata
, "FreeBSD"))
22376 /* FreeBSD-specific core file notes. */
22377 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
22379 else if (startswith (pnote
->namedata
, "NetBSD-CORE"))
22380 /* NetBSD-specific core file notes. */
22381 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
22383 else if (startswith (pnote
->namedata
, "NetBSD"))
22384 /* NetBSD-specific core file notes. */
22385 return process_netbsd_elf_note (pnote
);
22387 else if (startswith (pnote
->namedata
, "PaX"))
22388 /* NetBSD-specific core file notes. */
22389 return process_netbsd_elf_note (pnote
);
22391 else if (startswith (pnote
->namedata
, "OpenBSD"))
22392 /* OpenBSD-specific core file notes. */
22393 nt
= get_openbsd_elfcore_note_type (filedata
, pnote
->type
);
22395 else if (startswith (pnote
->namedata
, "QNX"))
22396 /* QNX-specific core file notes. */
22397 nt
= get_qnx_elfcore_note_type (filedata
, pnote
->type
);
22399 else if (startswith (pnote
->namedata
, "SPU/"))
22401 /* SPU-specific core file notes. */
22402 nt
= pnote
->namedata
+ 4;
22406 else if (startswith (pnote
->namedata
, "IPF/VMS"))
22407 /* VMS/ia64-specific file notes. */
22408 nt
= get_ia64_vms_note_type (pnote
->type
);
22410 else if (startswith (pnote
->namedata
, "stapsdt"))
22411 nt
= get_stapsdt_note_type (pnote
->type
);
22414 /* Don't recognize this note name; just use the default set of
22415 note type strings. */
22416 nt
= get_note_type (filedata
, pnote
->type
);
22420 if (((startswith (pnote
->namedata
, "GA")
22421 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
22422 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
22423 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
22424 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
22425 print_gnu_build_attribute_name (pnote
);
22427 print_symbol_name (-20, name
);
22430 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
22432 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
22434 if (startswith (pnote
->namedata
, "IPF/VMS"))
22435 return print_ia64_vms_note (pnote
);
22436 else if (startswith (pnote
->namedata
, "GNU"))
22437 return print_gnu_note (filedata
, pnote
);
22438 else if (startswith (pnote
->namedata
, "stapsdt"))
22439 return print_stapsdt_note (pnote
);
22440 else if (startswith (pnote
->namedata
, "CORE"))
22441 return print_core_note (pnote
);
22442 else if (startswith (pnote
->namedata
, "FDO"))
22443 return print_fdo_note (pnote
);
22444 else if (((startswith (pnote
->namedata
, "GA")
22445 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
22446 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
22447 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
22448 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
22449 return print_gnu_build_attribute_description (pnote
, filedata
);
22450 else if (startswith (pnote
->namedata
, "AMDGPU")
22451 && pnote
->type
== NT_AMDGPU_METADATA
)
22452 return print_amdgpu_note (pnote
);
22453 else if (startswith (pnote
->namedata
, "QNX"))
22454 return print_qnx_note (pnote
);
22456 print_note_contents_hex (pnote
);
22461 process_notes_at (Filedata
* filedata
,
22462 Elf_Internal_Shdr
* section
,
22467 Elf_External_Note
*pnotes
;
22468 Elf_External_Note
*external
;
22477 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
22480 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
22488 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
22491 if (pnotes
== NULL
)
22496 if (filedata
->is_separate
)
22497 printf (_("In linked file '%s': "), filedata
->file_name
);
22501 printf (_("Displaying notes found in: %s\n"), printable_section_name (filedata
, section
));
22503 printf (_("Displaying notes found at file offset 0x%08" PRIx64
22504 " with length 0x%08" PRIx64
":\n"),
22507 /* NB: Some note sections may have alignment value of 0 or 1. gABI
22508 specifies that notes should be aligned to 4 bytes in 32-bit
22509 objects and to 8 bytes in 64-bit objects. As a Linux extension,
22510 we also support 4 byte alignment in 64-bit objects. If section
22511 alignment is less than 4, we treate alignment as 4 bytes. */
22514 else if (align
!= 4 && align
!= 8)
22516 warn (_("Corrupt note: alignment %" PRId64
", expecting 4 or 8\n"),
22522 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
22524 end
= (char *) pnotes
+ length
;
22525 while ((char *) external
< end
)
22527 Elf_Internal_Note inote
;
22530 char * temp
= NULL
;
22531 size_t data_remaining
= end
- (char *) external
;
22533 if (!is_ia64_vms (filedata
))
22535 /* PR binutils/15191
22536 Make sure that there is enough data to read. */
22537 min_notesz
= offsetof (Elf_External_Note
, name
);
22538 if (data_remaining
< min_notesz
)
22540 warn (ngettext ("Corrupt note: only %zd byte remains, "
22541 "not enough for a full note\n",
22542 "Corrupt note: only %zd bytes remain, "
22543 "not enough for a full note\n",
22548 data_remaining
-= min_notesz
;
22550 inote
.type
= BYTE_GET (external
->type
);
22551 inote
.namesz
= BYTE_GET (external
->namesz
);
22552 inote
.namedata
= external
->name
;
22553 inote
.descsz
= BYTE_GET (external
->descsz
);
22554 inote
.descdata
= ((char *) external
22555 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
22556 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
22557 next
= ((char *) external
22558 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
22562 Elf64_External_VMS_Note
*vms_external
;
22564 /* PR binutils/15191
22565 Make sure that there is enough data to read. */
22566 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
22567 if (data_remaining
< min_notesz
)
22569 warn (ngettext ("Corrupt note: only %zd byte remains, "
22570 "not enough for a full note\n",
22571 "Corrupt note: only %zd bytes remain, "
22572 "not enough for a full note\n",
22577 data_remaining
-= min_notesz
;
22579 vms_external
= (Elf64_External_VMS_Note
*) external
;
22580 inote
.type
= BYTE_GET (vms_external
->type
);
22581 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
22582 inote
.namedata
= vms_external
->name
;
22583 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
22584 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
22585 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
22586 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
22589 /* PR 17531: file: 3443835e. */
22590 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
22591 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
22592 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
22593 || (size_t) (next
- inote
.descdata
) < inote
.descsz
22594 || ((size_t) (next
- inote
.descdata
)
22595 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
22597 warn (_("note with invalid namesz and/or descsz found at offset %#tx\n"),
22598 (char *) external
- (char *) pnotes
);
22599 warn (_(" type: %#lx, namesize: %#lx, descsize: %#lx, alignment: %u\n"),
22600 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
22604 external
= (Elf_External_Note
*) next
;
22606 /* Verify that name is null terminated. It appears that at least
22607 one version of Linux (RedHat 6.0) generates corefiles that don't
22608 comply with the ELF spec by failing to include the null byte in
22610 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
22612 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
22614 temp
= (char *) malloc (inote
.namesz
+ 1);
22617 error (_("Out of memory allocating space for inote name\n"));
22622 memcpy (temp
, inote
.namedata
, inote
.namesz
);
22623 inote
.namedata
= temp
;
22625 inote
.namedata
[inote
.namesz
] = 0;
22628 if (! process_note (& inote
, filedata
))
22641 process_corefile_note_segments (Filedata
* filedata
)
22643 Elf_Internal_Phdr
*segment
;
22647 if (! get_program_headers (filedata
))
22650 for (i
= 0, segment
= filedata
->program_headers
;
22651 i
< filedata
->file_header
.e_phnum
;
22654 if (segment
->p_type
== PT_NOTE
)
22655 if (! process_notes_at (filedata
, NULL
, segment
->p_offset
,
22656 segment
->p_filesz
, segment
->p_align
))
22664 process_v850_notes (Filedata
* filedata
, uint64_t offset
, uint64_t length
)
22666 Elf_External_Note
* pnotes
;
22667 Elf_External_Note
* external
;
22674 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
22676 if (pnotes
== NULL
)
22680 end
= (char*) pnotes
+ length
;
22682 printf (_("\nDisplaying contents of Renesas V850 notes section at offset"
22683 " %#" PRIx64
" with length %#" PRIx64
":\n"),
22686 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
22688 Elf_External_Note
* next
;
22689 Elf_Internal_Note inote
;
22691 inote
.type
= BYTE_GET (external
->type
);
22692 inote
.namesz
= BYTE_GET (external
->namesz
);
22693 inote
.namedata
= external
->name
;
22694 inote
.descsz
= BYTE_GET (external
->descsz
);
22695 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
22696 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
22698 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
22700 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
22701 inote
.descdata
= inote
.namedata
;
22705 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
22707 if ( ((char *) next
> end
)
22708 || ((char *) next
< (char *) pnotes
))
22710 warn (_("corrupt descsz found in note at offset %#tx\n"),
22711 (char *) external
- (char *) pnotes
);
22712 warn (_(" type: %#lx, namesize: %#lx, descsize: %#lx\n"),
22713 inote
.type
, inote
.namesz
, inote
.descsz
);
22719 /* Prevent out-of-bounds indexing. */
22720 if ( inote
.namedata
+ inote
.namesz
> end
22721 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
22723 warn (_("corrupt namesz found in note at offset %#zx\n"),
22724 (char *) external
- (char *) pnotes
);
22725 warn (_(" type: %#lx, namesize: %#lx, descsize: %#lx\n"),
22726 inote
.type
, inote
.namesz
, inote
.descsz
);
22730 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
22732 if (! print_v850_note (& inote
))
22735 printf ("<corrupt sizes: namesz: %#lx, descsz: %#lx>\n",
22736 inote
.namesz
, inote
.descsz
);
22746 process_note_sections (Filedata
* filedata
)
22748 Elf_Internal_Shdr
*section
;
22750 unsigned int n
= 0;
22753 for (i
= 0, section
= filedata
->section_headers
;
22754 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
22757 if (section
->sh_type
== SHT_NOTE
)
22759 if (! process_notes_at (filedata
, section
, section
->sh_offset
,
22760 section
->sh_size
, section
->sh_addralign
))
22765 if (( filedata
->file_header
.e_machine
== EM_V800
22766 || filedata
->file_header
.e_machine
== EM_V850
22767 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
22768 && section
->sh_type
== SHT_RENESAS_INFO
)
22770 if (! process_v850_notes (filedata
, section
->sh_offset
,
22778 /* Try processing NOTE segments instead. */
22779 return process_corefile_note_segments (filedata
);
22785 process_notes (Filedata
* filedata
)
22787 /* If we have not been asked to display the notes then do nothing. */
22791 if (filedata
->file_header
.e_type
!= ET_CORE
)
22792 return process_note_sections (filedata
);
22794 /* No program headers means no NOTE segment. */
22795 if (filedata
->file_header
.e_phnum
> 0)
22796 return process_corefile_note_segments (filedata
);
22798 if (filedata
->is_separate
)
22799 printf (_("No notes found in linked file '%s'.\n"),
22800 filedata
->file_name
);
22802 printf (_("No notes found file.\n"));
22807 static unsigned char *
22808 display_public_gnu_attributes (unsigned char * start
,
22809 const unsigned char * const end
)
22811 printf (_(" Unknown GNU attribute: %s\n"), start
);
22813 start
+= strnlen ((char *) start
, end
- start
);
22814 display_raw_attribute (start
, end
);
22816 return (unsigned char *) end
;
22819 static unsigned char *
22820 display_generic_attribute (unsigned char * start
,
22822 const unsigned char * const end
)
22825 return (unsigned char *) end
;
22827 return display_tag_value (tag
, start
, end
);
22831 process_arch_specific (Filedata
* filedata
)
22836 switch (filedata
->file_header
.e_machine
)
22839 case EM_ARC_COMPACT
:
22840 case EM_ARC_COMPACT2
:
22841 case EM_ARC_COMPACT3
:
22842 case EM_ARC_COMPACT3_64
:
22843 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
22844 display_arc_attribute
,
22845 display_generic_attribute
);
22847 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
22848 display_arm_attribute
,
22849 display_generic_attribute
);
22852 case EM_MIPS_RS3_LE
:
22853 return process_mips_specific (filedata
);
22856 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
22857 display_msp430_attribute
,
22858 display_msp430_gnu_attribute
);
22861 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
22862 display_riscv_attribute
,
22863 display_generic_attribute
);
22866 return process_nds32_specific (filedata
);
22869 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22870 display_m68k_gnu_attribute
);
22874 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22875 display_power_gnu_attribute
);
22879 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22880 display_s390_gnu_attribute
);
22883 case EM_SPARC32PLUS
:
22885 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
22886 display_sparc_gnu_attribute
);
22889 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
22890 display_tic6x_attribute
,
22891 display_generic_attribute
);
22894 return process_attributes (filedata
, "csky", SHT_CSKY_ATTRIBUTES
,
22895 display_csky_attribute
, NULL
);
22898 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
22899 display_public_gnu_attributes
,
22900 display_generic_attribute
);
22905 get_file_header (Filedata
* filedata
)
22907 /* Read in the identity array. */
22908 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
22911 /* Determine how to read the rest of the header. */
22912 switch (filedata
->file_header
.e_ident
[EI_DATA
])
22917 byte_get
= byte_get_little_endian
;
22918 byte_put
= byte_put_little_endian
;
22921 byte_get
= byte_get_big_endian
;
22922 byte_put
= byte_put_big_endian
;
22926 /* For now we only support 32 bit and 64 bit ELF files. */
22927 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
22929 /* Read in the rest of the header. */
22932 Elf32_External_Ehdr ehdr32
;
22934 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
22937 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
22938 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
22939 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
22940 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
22941 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
22942 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
22943 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
22944 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
22945 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
22946 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
22947 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
22948 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
22949 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
22953 Elf64_External_Ehdr ehdr64
;
22955 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
22958 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
22959 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
22960 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
22961 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
22962 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
22963 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
22964 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
22965 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
22966 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
22967 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
22968 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
22969 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
22970 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
22977 free_filedata (Filedata
*filedata
)
22979 free (filedata
->program_interpreter
);
22980 free (filedata
->program_headers
);
22981 free (filedata
->section_headers
);
22982 free (filedata
->string_table
);
22983 free (filedata
->dump
.dump_sects
);
22984 free (filedata
->dynamic_strings
);
22985 free (filedata
->dynamic_symbols
);
22986 free (filedata
->dynamic_syminfo
);
22987 free (filedata
->dynamic_section
);
22989 while (filedata
->symtab_shndx_list
!= NULL
)
22991 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
22992 free (filedata
->symtab_shndx_list
);
22993 filedata
->symtab_shndx_list
= next
;
22996 free (filedata
->section_headers_groups
);
22998 if (filedata
->section_groups
)
23001 struct group_list
* g
;
23002 struct group_list
* next
;
23004 for (i
= 0; i
< filedata
->group_count
; i
++)
23006 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
23013 free (filedata
->section_groups
);
23015 memset (&filedata
->section_headers
, 0,
23016 sizeof (Filedata
) - offsetof (Filedata
, section_headers
));
23020 close_file (Filedata
* filedata
)
23024 if (filedata
->handle
)
23025 fclose (filedata
->handle
);
23031 close_debug_file (void * data
)
23033 free_filedata ((Filedata
*) data
);
23034 close_file ((Filedata
*) data
);
23038 open_file (const char * pathname
, bool is_separate
)
23040 struct stat statbuf
;
23041 Filedata
* filedata
= NULL
;
23043 if (stat (pathname
, & statbuf
) < 0
23044 || ! S_ISREG (statbuf
.st_mode
))
23047 filedata
= calloc (1, sizeof * filedata
);
23048 if (filedata
== NULL
)
23051 filedata
->handle
= fopen (pathname
, "rb");
23052 if (filedata
->handle
== NULL
)
23055 filedata
->file_size
= statbuf
.st_size
;
23056 filedata
->file_name
= pathname
;
23057 filedata
->is_separate
= is_separate
;
23059 if (! get_file_header (filedata
))
23062 if (!get_section_headers (filedata
, false))
23070 if (filedata
->handle
)
23071 fclose (filedata
->handle
);
23078 open_debug_file (const char * pathname
)
23080 return open_file (pathname
, true);
23084 initialise_dump_sects (Filedata
* filedata
)
23086 /* Initialise the dump_sects array from the cmdline_dump_sects array.
23087 Note we do this even if cmdline_dump_sects is empty because we
23088 must make sure that the dump_sets array is zeroed out before each
23089 object file is processed. */
23090 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
23091 memset (filedata
->dump
.dump_sects
, 0,
23092 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
23094 if (cmdline
.num_dump_sects
> 0)
23096 if (filedata
->dump
.num_dump_sects
== 0)
23097 /* A sneaky way of allocating the dump_sects array. */
23098 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
23100 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
23101 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
23102 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
23107 might_need_separate_debug_info (Filedata
* filedata
)
23109 /* Debuginfo files do not need further separate file loading. */
23110 if (filedata
->file_header
.e_shstrndx
== SHN_UNDEF
)
23113 /* Since do_follow_links might be enabled by default, only treat it as an
23114 indication that separate files should be loaded if setting it was a
23115 deliberate user action. */
23116 if (DEFAULT_FOR_FOLLOW_LINKS
== 0 && do_follow_links
)
23119 if (process_links
|| do_syms
|| do_unwind
23120 || dump_any_debugging
|| do_dump
|| do_debugging
)
23126 /* Process one ELF object file according to the command line options.
23127 This file may actually be stored in an archive. The file is
23128 positioned at the start of the ELF object. Returns TRUE if no
23129 problems were encountered, FALSE otherwise. */
23132 process_object (Filedata
* filedata
)
23134 bool have_separate_files
;
23138 if (! get_file_header (filedata
))
23140 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
23144 /* Initialise per file variables. */
23145 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
23146 filedata
->version_info
[i
] = 0;
23148 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
23149 filedata
->dynamic_info
[i
] = 0;
23150 filedata
->dynamic_info_DT_GNU_HASH
= 0;
23151 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
23153 /* Process the file. */
23155 printf (_("\nFile: %s\n"), filedata
->file_name
);
23157 initialise_dump_sects (filedata
);
23159 /* There may be some extensions in the first section header. Don't
23160 bomb if we can't read it. */
23161 get_section_headers (filedata
, true);
23163 if (! process_file_header (filedata
))
23169 /* Throw away the single section header read above, so that we
23170 re-read the entire set. */
23171 free (filedata
->section_headers
);
23172 filedata
->section_headers
= NULL
;
23174 if (! process_section_headers (filedata
))
23176 /* Without loaded section headers we cannot process lots of things. */
23177 do_unwind
= do_version
= do_dump
= do_arch
= false;
23179 if (! do_using_dynamic
)
23180 do_syms
= do_dyn_syms
= do_reloc
= false;
23183 if (! process_section_groups (filedata
))
23184 /* Without loaded section groups we cannot process unwind. */
23187 process_program_headers (filedata
);
23189 res
= process_dynamic_section (filedata
);
23191 if (! process_relocs (filedata
))
23194 if (! process_unwind (filedata
))
23197 if (! process_symbol_table (filedata
))
23200 if (! process_lto_symbol_tables (filedata
))
23203 if (! process_syminfo (filedata
))
23206 if (! process_version_sections (filedata
))
23209 if (might_need_separate_debug_info (filedata
))
23210 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
23212 have_separate_files
= false;
23214 if (! process_section_contents (filedata
))
23217 if (have_separate_files
)
23221 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
23223 initialise_dump_sects (d
->handle
);
23225 if (process_links
&& ! process_file_header (d
->handle
))
23227 else if (! process_section_headers (d
->handle
))
23229 else if (! process_section_contents (d
->handle
))
23231 else if (process_links
)
23233 if (! process_section_groups (d
->handle
))
23235 process_program_headers (d
->handle
);
23236 if (! process_dynamic_section (d
->handle
))
23238 if (! process_relocs (d
->handle
))
23240 if (! process_unwind (d
->handle
))
23242 if (! process_symbol_table (d
->handle
))
23244 if (! process_lto_symbol_tables (d
->handle
))
23246 if (! process_syminfo (d
->handle
))
23248 if (! process_version_sections (d
->handle
))
23250 if (! process_notes (d
->handle
))
23255 /* The file handles are closed by the call to free_debug_memory() below. */
23258 if (! process_notes (filedata
))
23261 if (! process_gnu_liblist (filedata
))
23264 if (! process_arch_specific (filedata
))
23268 free_filedata (filedata
);
23270 free_debug_memory ();
23275 /* Process an ELF archive.
23276 On entry the file is positioned just after the ARMAG string.
23277 Returns TRUE upon success, FALSE otherwise. */
23280 process_archive (Filedata
* filedata
, bool is_thin_archive
)
23282 struct archive_info arch
;
23283 struct archive_info nested_arch
;
23289 /* The ARCH structure is used to hold information about this archive. */
23290 arch
.file_name
= NULL
;
23292 arch
.index_array
= NULL
;
23293 arch
.sym_table
= NULL
;
23294 arch
.longnames
= NULL
;
23296 /* The NESTED_ARCH structure is used as a single-item cache of information
23297 about a nested archive (when members of a thin archive reside within
23298 another regular archive file). */
23299 nested_arch
.file_name
= NULL
;
23300 nested_arch
.file
= NULL
;
23301 nested_arch
.index_array
= NULL
;
23302 nested_arch
.sym_table
= NULL
;
23303 nested_arch
.longnames
= NULL
;
23305 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
23306 filedata
->file_size
, is_thin_archive
,
23307 do_archive_index
) != 0)
23313 if (do_archive_index
)
23315 if (arch
.sym_table
== NULL
)
23316 error (_("%s: unable to dump the index as none was found\n"),
23317 filedata
->file_name
);
23321 uint64_t current_pos
;
23323 printf (_("Index of archive %s: (%" PRIu64
" entries,"
23324 " %#" PRIx64
" bytes in the symbol table)\n"),
23325 filedata
->file_name
, arch
.index_num
,
23328 current_pos
= ftell (filedata
->handle
);
23330 for (i
= l
= 0; i
< arch
.index_num
; i
++)
23333 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
23336 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
23339 if (member_name
!= NULL
)
23341 char * qualified_name
23342 = make_qualified_name (&arch
, &nested_arch
,
23345 if (qualified_name
!= NULL
)
23347 printf (_("Contents of binary %s at offset "),
23349 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
23351 free (qualified_name
);
23353 free (member_name
);
23357 if (l
>= arch
.sym_size
)
23359 error (_("%s: end of the symbol table reached "
23360 "before the end of the index\n"),
23361 filedata
->file_name
);
23365 /* PR 17531: file: 0b6630b2. */
23366 printf ("\t%.*s\n",
23367 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
23368 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
23371 if (arch
.uses_64bit_indices
)
23376 if (l
< arch
.sym_size
)
23378 error (ngettext ("%s: %" PRId64
" byte remains in the symbol table, "
23379 "but without corresponding entries in "
23380 "the index table\n",
23381 "%s: %" PRId64
" bytes remain in the symbol table, "
23382 "but without corresponding entries in "
23383 "the index table\n",
23384 arch
.sym_size
- l
),
23385 filedata
->file_name
, arch
.sym_size
- l
);
23389 if (fseek64 (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
23391 error (_("%s: failed to seek back to start of object files "
23392 "in the archive\n"),
23393 filedata
->file_name
);
23399 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
23400 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
23401 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
23402 && !do_section_groups
&& !do_dyn_syms
)
23404 ret
= true; /* Archive index only. */
23413 char * qualified_name
;
23415 /* Read the next archive header. */
23416 if (fseek64 (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
23418 error (_("%s: failed to seek to next archive header\n"),
23423 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
23424 if (got
!= sizeof arch
.arhdr
)
23428 /* PR 24049 - we cannot use filedata->file_name as this will
23429 have already been freed. */
23430 error (_("%s: failed to read archive header\n"), arch
.file_name
);
23435 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
23437 error (_("%s: did not find a valid archive header\n"),
23443 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
23445 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
23447 name
= get_archive_member_name (&arch
, &nested_arch
);
23450 error (_("%s: bad archive file name\n"), arch
.file_name
);
23454 namelen
= strlen (name
);
23456 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
23457 if (qualified_name
== NULL
)
23459 error (_("%s: bad archive file name\n"), arch
.file_name
);
23465 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
23467 /* This is a proxy for an external member of a thin archive. */
23468 Filedata
* member_filedata
;
23469 char * member_file_name
= adjust_relative_path
23470 (filedata
->file_name
, name
, namelen
);
23473 if (member_file_name
== NULL
)
23475 free (qualified_name
);
23480 member_filedata
= open_file (member_file_name
, false);
23481 if (member_filedata
== NULL
)
23483 error (_("Input file '%s' is not readable.\n"), member_file_name
);
23484 free (member_file_name
);
23485 free (qualified_name
);
23490 filedata
->archive_file_offset
= arch
.nested_member_origin
;
23491 member_filedata
->file_name
= qualified_name
;
23493 /* The call to process_object() expects the file to be at the beginning. */
23494 rewind (member_filedata
->handle
);
23496 if (! process_object (member_filedata
))
23499 close_file (member_filedata
);
23500 free (member_file_name
);
23502 else if (is_thin_archive
)
23504 Filedata thin_filedata
;
23506 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
23508 /* PR 15140: Allow for corrupt thin archives. */
23509 if (nested_arch
.file
== NULL
)
23511 error (_("%s: contains corrupt thin archive: %s\n"),
23512 qualified_name
, name
);
23513 free (qualified_name
);
23520 /* This is a proxy for a member of a nested archive. */
23521 filedata
->archive_file_offset
23522 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
23524 /* The nested archive file will have been opened and setup by
23525 get_archive_member_name. */
23526 if (fseek64 (nested_arch
.file
, filedata
->archive_file_offset
,
23529 error (_("%s: failed to seek to archive member.\n"),
23530 nested_arch
.file_name
);
23531 free (qualified_name
);
23536 thin_filedata
.handle
= nested_arch
.file
;
23537 thin_filedata
.file_name
= qualified_name
;
23539 if (! process_object (& thin_filedata
))
23545 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
23546 filedata
->file_name
= qualified_name
;
23547 if (! process_object (filedata
))
23549 arch
.next_arhdr_offset
+= (filedata
->archive_file_size
+ 1) & -2;
23550 /* Stop looping with "negative" archive_file_size. */
23551 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
23552 arch
.next_arhdr_offset
= -1ul;
23555 free (qualified_name
);
23559 if (nested_arch
.file
!= NULL
)
23560 fclose (nested_arch
.file
);
23561 release_archive (&nested_arch
);
23562 release_archive (&arch
);
23568 process_file (char * file_name
)
23570 Filedata
* filedata
= NULL
;
23571 struct stat statbuf
;
23572 char armag
[SARMAG
];
23575 if (stat (file_name
, &statbuf
) < 0)
23577 if (errno
== ENOENT
)
23578 error (_("'%s': No such file\n"), file_name
);
23580 error (_("Could not locate '%s'. System error message: %s\n"),
23581 file_name
, strerror (errno
));
23585 if (! S_ISREG (statbuf
.st_mode
))
23587 error (_("'%s' is not an ordinary file\n"), file_name
);
23591 filedata
= calloc (1, sizeof * filedata
);
23592 if (filedata
== NULL
)
23594 error (_("Out of memory allocating file data structure\n"));
23598 filedata
->file_name
= file_name
;
23599 filedata
->handle
= fopen (file_name
, "rb");
23600 if (filedata
->handle
== NULL
)
23602 error (_("Input file '%s' is not readable.\n"), file_name
);
23607 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
23609 error (_("%s: Failed to read file's magic number\n"), file_name
);
23610 fclose (filedata
->handle
);
23615 filedata
->file_size
= statbuf
.st_size
;
23616 filedata
->is_separate
= false;
23618 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
23620 if (! process_archive (filedata
, false))
23623 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
23625 if ( ! process_archive (filedata
, true))
23630 if (do_archive_index
&& !check_all
)
23631 error (_("File %s is not an archive so its index cannot be displayed.\n"),
23634 rewind (filedata
->handle
);
23635 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
23637 if (! process_object (filedata
))
23641 fclose (filedata
->handle
);
23642 free (filedata
->section_headers
);
23643 free (filedata
->program_headers
);
23644 free (filedata
->string_table
);
23645 free (filedata
->dump
.dump_sects
);
23648 free (ba_cache
.strtab
);
23649 ba_cache
.strtab
= NULL
;
23650 free (ba_cache
.symtab
);
23651 ba_cache
.symtab
= NULL
;
23652 ba_cache
.filedata
= NULL
;
23657 #ifdef SUPPORT_DISASSEMBLY
23658 /* Needed by the i386 disassembler. For extra credit, someone could
23659 fix this so that we insert symbolic addresses here, esp for GOT/PLT
23663 print_address (unsigned int addr
, FILE * outfile
)
23665 fprintf (outfile
,"0x%8.8x", addr
);
23668 /* Needed by the i386 disassembler. */
23671 db_task_printsym (unsigned int addr
)
23673 print_address (addr
, stderr
);
23678 main (int argc
, char ** argv
)
23682 #ifdef HAVE_LC_MESSAGES
23683 setlocale (LC_MESSAGES
, "");
23685 setlocale (LC_CTYPE
, "");
23686 bindtextdomain (PACKAGE
, LOCALEDIR
);
23687 textdomain (PACKAGE
);
23689 expandargv (&argc
, &argv
);
23691 parse_args (& cmdline
, argc
, argv
);
23693 if (optind
< (argc
- 1))
23694 /* When displaying information for more than one file,
23695 prefix the information with the file name. */
23697 else if (optind
>= argc
)
23699 /* Ensure that the warning is always displayed. */
23702 warn (_("Nothing to do.\n"));
23707 while (optind
< argc
)
23708 if (! process_file (argv
[optind
++]))
23711 free (cmdline
.dump_sects
);
23713 free (dump_ctf_symtab_name
);
23714 free (dump_ctf_strtab_name
);
23715 free (dump_ctf_parent_name
);
23717 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;