1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2021 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. */
50 /* Define BFD64 here, even if our default architecture is 32 bit ELF
51 as this will allow us to read in and parse 64bit and 32bit ELF files.
52 Only do this if we believe that the compiler can support a 64 bit
53 data type. For now we only rely on GCC being able to do this. */
64 #include "elf/common.h"
65 #include "elf/external.h"
66 #include "elf/internal.h"
69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
77 /* Undo the effects of #including reloc-macros.h. */
79 #undef START_RELOC_NUMBERS
83 #undef END_RELOC_NUMBERS
84 #undef _RELOC_MACROS_H
86 /* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
90 #define RELOC_MACROS_GEN_FUNC
92 #include "elf/aarch64.h"
93 #include "elf/alpha.h"
101 #include "elf/csky.h"
102 #include "elf/d10v.h"
103 #include "elf/d30v.h"
106 #include "elf/epiphany.h"
107 #include "elf/fr30.h"
109 #include "elf/ft32.h"
111 #include "elf/hppa.h"
112 #include "elf/i386.h"
113 #include "elf/i370.h"
114 #include "elf/i860.h"
115 #include "elf/i960.h"
116 #include "elf/ia64.h"
117 #include "elf/ip2k.h"
118 #include "elf/lm32.h"
119 #include "elf/iq2000.h"
120 #include "elf/m32c.h"
121 #include "elf/m32r.h"
122 #include "elf/m68k.h"
123 #include "elf/m68hc11.h"
124 #include "elf/s12z.h"
125 #include "elf/mcore.h"
127 #include "elf/metag.h"
128 #include "elf/microblaze.h"
129 #include "elf/mips.h"
130 #include "elf/mmix.h"
131 #include "elf/mn10200.h"
132 #include "elf/mn10300.h"
133 #include "elf/moxie.h"
135 #include "elf/msp430.h"
136 #include "elf/nds32.h"
138 #include "elf/nios2.h"
139 #include "elf/or1k.h"
142 #include "elf/ppc64.h"
144 #include "elf/riscv.h"
145 #include "elf/rl78.h"
147 #include "elf/s390.h"
148 #include "elf/score.h"
150 #include "elf/sparc.h"
152 #include "elf/tic6x.h"
153 #include "elf/tilegx.h"
154 #include "elf/tilepro.h"
155 #include "elf/v850.h"
157 #include "elf/visium.h"
158 #include "elf/wasm32.h"
159 #include "elf/x86-64.h"
160 #include "elf/xc16x.h"
161 #include "elf/xgate.h"
162 #include "elf/xstormy16.h"
163 #include "elf/xtensa.h"
165 #include "elf/loongarch.h"
168 #include "libiberty.h"
169 #include "safe-ctype.h"
170 #include "filenames.h"
173 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
176 typedef struct elf_section_list
178 Elf_Internal_Shdr
* hdr
;
179 struct elf_section_list
* next
;
182 /* Flag bits indicating particular types of dump. */
183 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
184 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
185 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
186 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
187 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
188 #define CTF_DUMP (1 << 5) /* The --ctf command line switch. */
190 typedef unsigned char dump_type
;
192 /* A linked list of the section names for which dumps were requested. */
193 struct dump_list_entry
197 struct dump_list_entry
* next
;
200 /* A dynamic array of flags indicating for which sections a dump
201 has been requested via command line switches. */
204 dump_type
* dump_sects
;
205 unsigned int num_dump_sects
;
208 static struct dump_data cmdline
;
210 static struct dump_list_entry
* dump_sects_byname
;
212 char * program_name
= "readelf";
214 static bool show_name
= false;
215 static bool do_dynamic
= false;
216 static bool do_syms
= false;
217 static bool do_dyn_syms
= false;
218 static bool do_lto_syms
= false;
219 static bool do_reloc
= false;
220 static bool do_sections
= false;
221 static bool do_section_groups
= false;
222 static bool do_section_details
= false;
223 static bool do_segments
= false;
224 static bool do_unwind
= false;
225 static bool do_using_dynamic
= false;
226 static bool do_header
= false;
227 static bool do_dump
= false;
228 static bool do_version
= false;
229 static bool do_histogram
= false;
230 static bool do_debugging
= false;
231 static bool do_ctf
= false;
232 static bool do_arch
= false;
233 static bool do_notes
= false;
234 static bool do_archive_index
= false;
235 static bool check_all
= false;
236 static bool is_32bit_elf
= false;
237 static bool decompress_dumps
= false;
238 static bool do_not_show_symbol_truncation
= false;
239 static bool do_demangle
= false; /* Pretty print C++ symbol names. */
240 static bool process_links
= false;
241 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
242 static int sym_base
= 0;
244 static char *dump_ctf_parent_name
;
245 static char *dump_ctf_symtab_name
;
246 static char *dump_ctf_strtab_name
;
250 struct group_list
* next
;
251 unsigned int section_index
;
256 struct group_list
* root
;
257 unsigned int group_index
;
260 typedef struct filedata
262 const char * file_name
;
265 bfd_size_type file_size
;
266 Elf_Internal_Ehdr file_header
;
267 unsigned long archive_file_offset
;
268 unsigned long archive_file_size
;
269 /* Everything below this point is cleared out by free_filedata. */
270 Elf_Internal_Shdr
* section_headers
;
271 Elf_Internal_Phdr
* program_headers
;
273 unsigned long string_table_length
;
274 unsigned long dynamic_addr
;
275 bfd_size_type dynamic_size
;
277 Elf_Internal_Dyn
* dynamic_section
;
278 Elf_Internal_Shdr
* dynamic_strtab_section
;
279 char * dynamic_strings
;
280 unsigned long dynamic_strings_length
;
281 Elf_Internal_Shdr
* dynamic_symtab_section
;
282 unsigned long num_dynamic_syms
;
283 Elf_Internal_Sym
* dynamic_symbols
;
284 bfd_vma version_info
[16];
285 unsigned int dynamic_syminfo_nent
;
286 Elf_Internal_Syminfo
* dynamic_syminfo
;
287 unsigned long dynamic_syminfo_offset
;
288 bfd_size_type nbuckets
;
289 bfd_size_type nchains
;
292 bfd_size_type ngnubuckets
;
293 bfd_size_type ngnuchains
;
294 bfd_vma
* gnubuckets
;
298 char * program_interpreter
;
299 bfd_vma dynamic_info
[DT_ENCODING
];
300 bfd_vma dynamic_info_DT_GNU_HASH
;
301 bfd_vma dynamic_info_DT_MIPS_XHASH
;
302 elf_section_list
* symtab_shndx_list
;
304 struct group
* section_groups
;
305 struct group
** section_headers_groups
;
306 /* A dynamic array of flags indicating for which sections a dump of
307 some kind has been requested. It is reset on a per-object file
308 basis and then initialised from the cmdline_dump_sects array,
309 the results of interpreting the -w switch, and the
310 dump_sects_byname list. */
311 struct dump_data dump
;
314 /* How to print a vma value. */
315 typedef enum print_mode
332 typedef enum unicode_display_type
340 } unicode_display_type
;
342 static unicode_display_type unicode_display
= unicode_default
;
345 /* Versioned symbol info. */
346 enum versioned_symbol_info
353 static const char * get_symbol_version_string
354 (Filedata
*, bool, const char *, unsigned long, unsigned,
355 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
359 static inline const char *
360 section_name (const Filedata
*filedata
, const Elf_Internal_Shdr
*hdr
)
362 return filedata
->string_table
+ hdr
->sh_name
;
366 section_name_valid (const Filedata
*filedata
, const Elf_Internal_Shdr
*hdr
)
369 && filedata
->string_table
!= NULL
370 && hdr
->sh_name
< filedata
->string_table_length
);
373 static inline const char *
374 section_name_print (const Filedata
*filedata
, const Elf_Internal_Shdr
*hdr
)
378 if (filedata
->string_table
== NULL
)
379 return _("<no-strings>");
380 if (hdr
->sh_name
>= filedata
->string_table_length
)
381 return _("<corrupt>");
382 return section_name (filedata
, hdr
);
385 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
388 valid_symbol_name (const char *strtab
, size_t strtab_size
, uint64_t offset
)
390 return strtab
!= NULL
&& offset
< strtab_size
;
394 valid_dynamic_name (const Filedata
*filedata
, uint64_t offset
)
396 return valid_symbol_name (filedata
->dynamic_strings
,
397 filedata
->dynamic_strings_length
, offset
);
400 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
401 already been called and verified that the string exists. */
402 static inline const char *
403 get_dynamic_name (const Filedata
*filedata
, size_t offset
)
405 return filedata
->dynamic_strings
+ offset
;
408 #define REMOVE_ARCH_BITS(ADDR) \
411 if (filedata->file_header.e_machine == EM_ARM) \
416 /* Get the correct GNU hash section name. */
417 #define GNU_HASH_SECTION_NAME(filedata) \
418 filedata->dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
420 /* Print a BFD_VMA to an internal buffer, for use in error messages.
421 BFD_FMA_FMT can't be used in translated strings. */
424 bfd_vmatoa (char *fmtch
, bfd_vma value
)
426 /* bfd_vmatoa is used more then once in a printf call for output.
427 Cycle through an array of buffers. */
428 static int buf_pos
= 0;
429 static struct bfd_vmatoa_buf
436 ret
= buf
[buf_pos
++].place
;
437 buf_pos
%= ARRAY_SIZE (buf
);
439 sprintf (fmt
, "%%%s%s", BFD_VMA_FMT
, fmtch
);
440 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
444 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
445 OFFSET + the offset of the current archive member, if we are examining an
446 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
447 allocate a buffer using malloc and fill that. In either case return the
448 pointer to the start of the retrieved data or NULL if something went wrong.
449 If something does go wrong and REASON is not NULL then emit an error
450 message using REASON as part of the context. */
453 get_data (void * var
,
455 unsigned long offset
,
461 bfd_size_type amt
= size
* nmemb
;
463 if (size
== 0 || nmemb
== 0)
466 /* If the size_t type is smaller than the bfd_size_type, eg because
467 you are building a 32-bit tool on a 64-bit host, then make sure
468 that when the sizes are cast to (size_t) no information is lost. */
469 if ((size_t) size
!= size
470 || (size_t) nmemb
!= nmemb
471 || (size_t) amt
!= amt
)
474 error (_("Size truncation prevents reading %s"
475 " elements of size %s for %s\n"),
476 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
480 /* Check for size overflow. */
481 if (amt
/ size
!= nmemb
|| (size_t) amt
+ 1 == 0)
484 error (_("Size overflow prevents reading %s"
485 " elements of size %s for %s\n"),
486 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
490 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
491 attempting to allocate memory when the read is bound to fail. */
492 if (filedata
->archive_file_offset
> filedata
->file_size
493 || offset
> filedata
->file_size
- filedata
->archive_file_offset
494 || amt
> filedata
->file_size
- filedata
->archive_file_offset
- offset
)
497 error (_("Reading %s bytes extends past end of file for %s\n"),
498 bfd_vmatoa ("u", amt
), reason
);
502 if (fseek (filedata
->handle
, filedata
->archive_file_offset
+ offset
,
506 error (_("Unable to seek to 0x%lx for %s\n"),
507 filedata
->archive_file_offset
+ offset
, reason
);
514 /* + 1 so that we can '\0' terminate invalid string table sections. */
515 mvar
= malloc ((size_t) amt
+ 1);
520 error (_("Out of memory allocating %s bytes for %s\n"),
521 bfd_vmatoa ("u", amt
), reason
);
525 ((char *) mvar
)[amt
] = '\0';
528 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
531 error (_("Unable to read in %s bytes of %s\n"),
532 bfd_vmatoa ("u", amt
), reason
);
541 /* Print a VMA value in the MODE specified.
542 Returns the number of characters displayed. */
545 print_vma (bfd_vma vma
, print_mode mode
)
557 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
564 return printf ("%5" BFD_VMA_FMT
"d", vma
);
570 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
576 return nc
+ printf ("%05" BFD_VMA_FMT
"x", vma
);
579 return printf ("%" BFD_VMA_FMT
"d", vma
);
582 return printf ("%" BFD_VMA_FMT
"u", vma
);
585 return printf ("%5" BFD_VMA_FMT
"u", vma
);
588 return printf ("%" BFD_VMA_FMT
"o", vma
);
591 return printf ("%5" BFD_VMA_FMT
"o", vma
);
594 /* FIXME: Report unrecognised mode ? */
600 /* Display a symbol on stdout. Handles the display of control characters and
601 multibye characters (assuming the host environment supports them).
603 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
605 If truncation will happen and do_not_show_symbol_truncation is FALSE then display
606 abs(WIDTH) - 5 characters followed by "[...]".
608 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
609 padding as necessary.
611 Returns the number of emitted characters. */
614 print_symbol (signed int width
, const char * symbol
)
616 bool extra_padding
= false;
617 bool do_dots
= false;
618 signed int num_printed
= 0;
619 #ifdef HAVE_MBSTATE_T
622 unsigned int width_remaining
;
623 const void * alloced_symbol
= NULL
;
627 /* Keep the width positive. This helps the code below. */
629 extra_padding
= true;
635 /* Set the remaining width to a very large value.
636 This simplifies the code below. */
637 width_remaining
= INT_MAX
;
640 width_remaining
= width
;
641 if (! do_not_show_symbol_truncation
642 && (int) strlen (symbol
) > width
)
644 width_remaining
-= 5;
645 if ((int) width_remaining
< 0)
651 #ifdef HAVE_MBSTATE_T
652 /* Initialise the multibyte conversion state. */
653 memset (& state
, 0, sizeof (state
));
656 if (do_demangle
&& *symbol
)
658 const char * res
= cplus_demangle (symbol
, demangle_flags
);
661 alloced_symbol
= symbol
= res
;
664 while (width_remaining
)
667 const char c
= *symbol
++;
678 else if (ISCNTRL (c
))
680 /* Do not print control characters directly as they can affect terminal
681 settings. Such characters usually appear in the names generated
682 by the assembler for local labels. */
684 if (width_remaining
< 2)
687 printf ("^%c", c
+ 0x40);
688 width_remaining
-= 2;
693 if (width_remaining
< 5)
696 width_remaining
-= 5;
699 else if (unicode_display
!= unicode_locale
700 && unicode_display
!= unicode_default
)
702 /* Display unicode characters as something else. */
703 unsigned char bytes
[4];
716 bytes
[1] = *symbol
++;
718 if ((bytes
[1] & 0xc0) != 0x80)
721 /* Do not consume this character. It may only
722 be the first byte in the sequence that was
727 else if ((bytes
[0] & 0x20) == 0)
734 bytes
[2] = *symbol
++;
736 if ((bytes
[2] & 0xc0) != 0x80)
742 else if ((bytes
[0] & 0x10) == 0)
749 bytes
[3] = *symbol
++;
753 if ((bytes
[3] & 0xc0) != 0x80)
765 if (unicode_display
== unicode_invalid
)
768 if (unicode_display
== unicode_hex
|| ! is_utf8
)
772 if (width_remaining
< (nbytes
* 2) + 2)
775 putchar (is_utf8
? '<' : '{');
777 for (i
= 0; i
< nbytes
; i
++)
778 printf ("%02x", bytes
[i
]);
779 putchar (is_utf8
? '>' : '}');
783 if (unicode_display
== unicode_highlight
&& isatty (1))
784 printf ("\x1B[31;47m"); /* Red. */
789 if (width_remaining
< 6)
791 printf ("\\u%02x%02x",
792 (bytes
[0] & 0x1c) >> 2,
793 ((bytes
[0] & 0x03) << 6) | (bytes
[1] & 0x3f));
796 if (width_remaining
< 6)
798 printf ("\\u%02x%02x",
799 ((bytes
[0] & 0x0f) << 4) | ((bytes
[1] & 0x3c) >> 2),
800 ((bytes
[1] & 0x03) << 6) | (bytes
[2] & 0x3f));
803 if (width_remaining
< 8)
805 printf ("\\u%02x%02x%02x",
806 ((bytes
[0] & 0x07) << 6) | ((bytes
[1] & 0x3c) >> 2),
807 ((bytes
[1] & 0x03) << 6) | ((bytes
[2] & 0x3c) >> 2),
808 ((bytes
[2] & 0x03) << 6) | (bytes
[3] & 0x3f));
816 if (unicode_display
== unicode_highlight
&& isatty (1))
817 printf ("\033[0m"); /* Default colour. */
820 if (bytes
[nbytes
- 1] == 0)
825 #ifdef HAVE_MBSTATE_T
828 /* Let printf do the hard work of displaying multibyte characters. */
829 printf ("%.1s", symbol
- 1);
833 #ifdef HAVE_MBSTATE_T
834 /* Try to find out how many bytes made up the character that was
835 just printed. Advance the symbol pointer past the bytes that
837 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
841 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
847 num_printed
+= printf ("[...]");
849 if (extra_padding
&& num_printed
< width
)
851 /* Fill in the remaining spaces. */
852 printf ("%-*s", width
- num_printed
, " ");
856 free ((void *) alloced_symbol
);
860 /* Returns a pointer to a static buffer containing a printable version of
861 the given section's name. Like print_symbol, except that it does not try
862 to print multibyte characters, it just interprets them as hex values. */
865 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
867 #define MAX_PRINT_SEC_NAME_LEN 256
868 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
869 const char * name
= section_name_print (filedata
, sec
);
870 char * buf
= sec_name_buf
;
872 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
874 while ((c
= * name
++) != 0)
885 else if (ISPRINT (c
))
892 static char hex
[17] = "0123456789ABCDEF";
897 * buf
++ = hex
[(c
& 0xf0) >> 4];
898 * buf
++ = hex
[c
& 0x0f];
912 printable_section_name_from_index (Filedata
* filedata
, unsigned long ndx
)
914 if (ndx
>= filedata
->file_header
.e_shnum
)
915 return _("<corrupt>");
917 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
920 /* Return a pointer to section NAME, or NULL if no such section exists. */
922 static Elf_Internal_Shdr
*
923 find_section (Filedata
* filedata
, const char * name
)
927 if (filedata
->section_headers
== NULL
)
930 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
931 if (section_name_valid (filedata
, filedata
->section_headers
+ i
)
932 && streq (section_name (filedata
, filedata
->section_headers
+ i
),
934 return filedata
->section_headers
+ i
;
939 /* Return a pointer to a section containing ADDR, or NULL if no such
942 static Elf_Internal_Shdr
*
943 find_section_by_address (Filedata
* filedata
, bfd_vma addr
)
947 if (filedata
->section_headers
== NULL
)
950 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
952 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
954 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
961 static Elf_Internal_Shdr
*
962 find_section_by_type (Filedata
* filedata
, unsigned int type
)
966 if (filedata
->section_headers
== NULL
)
969 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
971 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
973 if (sec
->sh_type
== type
)
980 /* Return a pointer to section NAME, or NULL if no such section exists,
981 restricted to the list of sections given in SET. */
983 static Elf_Internal_Shdr
*
984 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
988 if (filedata
->section_headers
== NULL
)
993 while ((i
= *set
++) > 0)
995 /* See PR 21156 for a reproducer. */
996 if (i
>= filedata
->file_header
.e_shnum
)
997 continue; /* FIXME: Should we issue an error message ? */
999 if (section_name_valid (filedata
, filedata
->section_headers
+ i
)
1000 && streq (section_name (filedata
, filedata
->section_headers
+ i
),
1002 return filedata
->section_headers
+ i
;
1006 return find_section (filedata
, name
);
1009 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
1010 This OS has so many departures from the ELF standard that we test it at
1014 is_ia64_vms (Filedata
* filedata
)
1016 return filedata
->file_header
.e_machine
== EM_IA_64
1017 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
1020 /* Guess the relocation size commonly used by the specific machines. */
1023 guess_is_rela (unsigned int e_machine
)
1027 /* Targets that use REL relocations. */
1033 case EM_CYGNUS_D10V
:
1036 case EM_MIPS_RS3_LE
:
1037 case EM_CYGNUS_M32R
:
1044 /* Targets that use RELA relocations. */
1048 case EM_ADAPTEVA_EPIPHANY
:
1050 case EM_ALTERA_NIOS2
:
1052 case EM_ARC_COMPACT
:
1053 case EM_ARC_COMPACT2
:
1062 case EM_CYGNUS_D30V
:
1065 case EM_CYGNUS_FR30
:
1074 case EM_LATTICEMICO32
:
1083 case EM_CYGNUS_MN10200
:
1085 case EM_CYGNUS_MN10300
:
1103 case EM_SPARC32PLUS
:
1111 case EM_CYGNUS_V850
:
1121 case EM_MICROBLAZE_OLD
:
1122 case EM_WEBASSEMBLY
:
1143 warn (_("Don't know about relocations on this machine architecture\n"));
1148 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1149 Returns TRUE upon success, FALSE otherwise. If successful then a
1150 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
1151 and the number of relocs loaded is placed in *NRELASP. It is the caller's
1152 responsibility to free the allocated buffer. */
1155 slurp_rela_relocs (Filedata
* filedata
,
1156 unsigned long rel_offset
,
1157 unsigned long rel_size
,
1158 Elf_Internal_Rela
** relasp
,
1159 unsigned long * nrelasp
)
1161 Elf_Internal_Rela
* relas
;
1167 Elf32_External_Rela
* erelas
;
1169 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
1170 rel_size
, _("32-bit relocation data"));
1174 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
1176 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
1177 sizeof (Elf_Internal_Rela
));
1182 error (_("out of memory parsing relocs\n"));
1186 for (i
= 0; i
< nrelas
; i
++)
1188 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
1189 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
1190 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
1197 Elf64_External_Rela
* erelas
;
1199 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
1200 rel_size
, _("64-bit relocation data"));
1204 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
1206 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
1207 sizeof (Elf_Internal_Rela
));
1212 error (_("out of memory parsing relocs\n"));
1216 for (i
= 0; i
< nrelas
; i
++)
1218 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
1219 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
1220 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
1222 /* The #ifdef BFD64 below is to prevent a compile time
1223 warning. We know that if we do not have a 64 bit data
1224 type that we will never execute this code anyway. */
1226 if (filedata
->file_header
.e_machine
== EM_MIPS
1227 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1229 /* In little-endian objects, r_info isn't really a
1230 64-bit little-endian value: it has a 32-bit
1231 little-endian symbol index followed by four
1232 individual byte fields. Reorder INFO
1234 bfd_vma inf
= relas
[i
].r_info
;
1235 inf
= (((inf
& 0xffffffff) << 32)
1236 | ((inf
>> 56) & 0xff)
1237 | ((inf
>> 40) & 0xff00)
1238 | ((inf
>> 24) & 0xff0000)
1239 | ((inf
>> 8) & 0xff000000));
1240 relas
[i
].r_info
= inf
;
1253 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1254 Returns TRUE upon success, FALSE otherwise. If successful then a
1255 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1256 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1257 responsibility to free the allocated buffer. */
1260 slurp_rel_relocs (Filedata
* filedata
,
1261 unsigned long rel_offset
,
1262 unsigned long rel_size
,
1263 Elf_Internal_Rela
** relsp
,
1264 unsigned long * nrelsp
)
1266 Elf_Internal_Rela
* rels
;
1272 Elf32_External_Rel
* erels
;
1274 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1275 rel_size
, _("32-bit relocation data"));
1279 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1281 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1286 error (_("out of memory parsing relocs\n"));
1290 for (i
= 0; i
< nrels
; i
++)
1292 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1293 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1294 rels
[i
].r_addend
= 0;
1301 Elf64_External_Rel
* erels
;
1303 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1304 rel_size
, _("64-bit relocation data"));
1308 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1310 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1315 error (_("out of memory parsing relocs\n"));
1319 for (i
= 0; i
< nrels
; i
++)
1321 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1322 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1323 rels
[i
].r_addend
= 0;
1325 /* The #ifdef BFD64 below is to prevent a compile time
1326 warning. We know that if we do not have a 64 bit data
1327 type that we will never execute this code anyway. */
1329 if (filedata
->file_header
.e_machine
== EM_MIPS
1330 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1332 /* In little-endian objects, r_info isn't really a
1333 64-bit little-endian value: it has a 32-bit
1334 little-endian symbol index followed by four
1335 individual byte fields. Reorder INFO
1337 bfd_vma inf
= rels
[i
].r_info
;
1338 inf
= (((inf
& 0xffffffff) << 32)
1339 | ((inf
>> 56) & 0xff)
1340 | ((inf
>> 40) & 0xff00)
1341 | ((inf
>> 24) & 0xff0000)
1342 | ((inf
>> 8) & 0xff000000));
1343 rels
[i
].r_info
= inf
;
1356 /* Returns the reloc type extracted from the reloc info field. */
1359 get_reloc_type (Filedata
* filedata
, bfd_vma reloc_info
)
1362 return ELF32_R_TYPE (reloc_info
);
1364 switch (filedata
->file_header
.e_machine
)
1367 /* Note: We assume that reloc_info has already been adjusted for us. */
1368 return ELF64_MIPS_R_TYPE (reloc_info
);
1371 return ELF64_R_TYPE_ID (reloc_info
);
1374 return ELF64_R_TYPE (reloc_info
);
1378 /* Return the symbol index extracted from the reloc info field. */
1381 get_reloc_symindex (bfd_vma reloc_info
)
1383 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1387 uses_msp430x_relocs (Filedata
* filedata
)
1390 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1391 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1392 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1393 /* TI compiler uses ELFOSABI_NONE. */
1394 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1397 /* Display the contents of the relocation data found at the specified
1401 dump_relocations (Filedata
* filedata
,
1402 unsigned long rel_offset
,
1403 unsigned long rel_size
,
1404 Elf_Internal_Sym
* symtab
,
1405 unsigned long nsyms
,
1407 unsigned long strtablen
,
1412 Elf_Internal_Rela
* rels
;
1415 if (is_rela
== UNKNOWN
)
1416 is_rela
= guess_is_rela (filedata
->file_header
.e_machine
);
1420 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1425 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1434 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1436 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1441 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1443 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1451 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1453 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1458 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1460 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1464 for (i
= 0; i
< rel_size
; i
++)
1469 bfd_vma symtab_index
;
1472 offset
= rels
[i
].r_offset
;
1473 inf
= rels
[i
].r_info
;
1475 type
= get_reloc_type (filedata
, inf
);
1476 symtab_index
= get_reloc_symindex (inf
);
1480 printf ("%8.8lx %8.8lx ",
1481 (unsigned long) offset
& 0xffffffff,
1482 (unsigned long) inf
& 0xffffffff);
1487 ? "%16.16" BFD_VMA_FMT
"x %16.16" BFD_VMA_FMT
"x "
1488 : "%12.12" BFD_VMA_FMT
"x %12.12" BFD_VMA_FMT
"x ",
1492 switch (filedata
->file_header
.e_machine
)
1499 rtype
= elf_aarch64_reloc_type (type
);
1503 case EM_CYGNUS_M32R
:
1504 rtype
= elf_m32r_reloc_type (type
);
1509 rtype
= elf_i386_reloc_type (type
);
1514 rtype
= elf_m68hc11_reloc_type (type
);
1518 rtype
= elf_s12z_reloc_type (type
);
1522 rtype
= elf_m68k_reloc_type (type
);
1526 rtype
= elf_i960_reloc_type (type
);
1531 rtype
= elf_avr_reloc_type (type
);
1534 case EM_OLD_SPARCV9
:
1535 case EM_SPARC32PLUS
:
1538 rtype
= elf_sparc_reloc_type (type
);
1542 rtype
= elf_spu_reloc_type (type
);
1546 rtype
= v800_reloc_type (type
);
1549 case EM_CYGNUS_V850
:
1550 rtype
= v850_reloc_type (type
);
1554 case EM_CYGNUS_D10V
:
1555 rtype
= elf_d10v_reloc_type (type
);
1559 case EM_CYGNUS_D30V
:
1560 rtype
= elf_d30v_reloc_type (type
);
1564 rtype
= elf_dlx_reloc_type (type
);
1568 rtype
= elf_sh_reloc_type (type
);
1572 case EM_CYGNUS_MN10300
:
1573 rtype
= elf_mn10300_reloc_type (type
);
1577 case EM_CYGNUS_MN10200
:
1578 rtype
= elf_mn10200_reloc_type (type
);
1582 case EM_CYGNUS_FR30
:
1583 rtype
= elf_fr30_reloc_type (type
);
1587 rtype
= elf_frv_reloc_type (type
);
1591 rtype
= elf_csky_reloc_type (type
);
1595 rtype
= elf_ft32_reloc_type (type
);
1599 rtype
= elf_mcore_reloc_type (type
);
1603 rtype
= elf_mmix_reloc_type (type
);
1607 rtype
= elf_moxie_reloc_type (type
);
1611 if (uses_msp430x_relocs (filedata
))
1613 rtype
= elf_msp430x_reloc_type (type
);
1618 rtype
= elf_msp430_reloc_type (type
);
1622 rtype
= elf_nds32_reloc_type (type
);
1626 rtype
= elf_ppc_reloc_type (type
);
1630 rtype
= elf_ppc64_reloc_type (type
);
1634 case EM_MIPS_RS3_LE
:
1635 rtype
= elf_mips_reloc_type (type
);
1639 rtype
= elf_riscv_reloc_type (type
);
1643 rtype
= elf_alpha_reloc_type (type
);
1647 rtype
= elf_arm_reloc_type (type
);
1651 case EM_ARC_COMPACT
:
1652 case EM_ARC_COMPACT2
:
1653 rtype
= elf_arc_reloc_type (type
);
1657 rtype
= elf_hppa_reloc_type (type
);
1663 rtype
= elf_h8_reloc_type (type
);
1667 rtype
= elf_or1k_reloc_type (type
);
1672 rtype
= elf_pj_reloc_type (type
);
1675 rtype
= elf_ia64_reloc_type (type
);
1679 rtype
= elf_cris_reloc_type (type
);
1683 rtype
= elf_i860_reloc_type (type
);
1689 rtype
= elf_x86_64_reloc_type (type
);
1693 rtype
= i370_reloc_type (type
);
1698 rtype
= elf_s390_reloc_type (type
);
1702 rtype
= elf_score_reloc_type (type
);
1706 rtype
= elf_xstormy16_reloc_type (type
);
1710 rtype
= elf_crx_reloc_type (type
);
1714 rtype
= elf_vax_reloc_type (type
);
1718 rtype
= elf_visium_reloc_type (type
);
1722 rtype
= elf_bpf_reloc_type (type
);
1725 case EM_ADAPTEVA_EPIPHANY
:
1726 rtype
= elf_epiphany_reloc_type (type
);
1731 rtype
= elf_ip2k_reloc_type (type
);
1735 rtype
= elf_iq2000_reloc_type (type
);
1740 rtype
= elf_xtensa_reloc_type (type
);
1743 case EM_LATTICEMICO32
:
1744 rtype
= elf_lm32_reloc_type (type
);
1749 rtype
= elf_m32c_reloc_type (type
);
1753 rtype
= elf_mt_reloc_type (type
);
1757 rtype
= elf_bfin_reloc_type (type
);
1761 rtype
= elf_mep_reloc_type (type
);
1765 rtype
= elf_cr16_reloc_type (type
);
1769 case EM_MICROBLAZE_OLD
:
1770 rtype
= elf_microblaze_reloc_type (type
);
1774 rtype
= elf_rl78_reloc_type (type
);
1778 rtype
= elf_rx_reloc_type (type
);
1782 rtype
= elf_metag_reloc_type (type
);
1787 rtype
= elf_xc16x_reloc_type (type
);
1791 rtype
= elf_tic6x_reloc_type (type
);
1795 rtype
= elf_tilegx_reloc_type (type
);
1799 rtype
= elf_tilepro_reloc_type (type
);
1802 case EM_WEBASSEMBLY
:
1803 rtype
= elf_wasm32_reloc_type (type
);
1807 rtype
= elf_xgate_reloc_type (type
);
1810 case EM_ALTERA_NIOS2
:
1811 rtype
= elf_nios2_reloc_type (type
);
1815 rtype
= elf_pru_reloc_type (type
);
1819 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
1820 rtype
= elf_nfp3200_reloc_type (type
);
1822 rtype
= elf_nfp_reloc_type (type
);
1826 rtype
= elf_z80_reloc_type (type
);
1830 rtype
= elf_loongarch_reloc_type (type
);
1836 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1838 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1840 if (filedata
->file_header
.e_machine
== EM_ALPHA
1842 && streq (rtype
, "R_ALPHA_LITUSE")
1845 switch (rels
[i
].r_addend
)
1847 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1848 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1849 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1850 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1851 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1852 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1853 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1854 default: rtype
= NULL
;
1858 printf (" (%s)", rtype
);
1862 printf (_("<unknown addend: %lx>"),
1863 (unsigned long) rels
[i
].r_addend
);
1867 else if (symtab_index
)
1869 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1871 error (_(" bad symbol index: %08lx in reloc\n"),
1872 (unsigned long) symtab_index
);
1877 Elf_Internal_Sym
* psym
;
1878 const char * version_string
;
1879 enum versioned_symbol_info sym_info
;
1880 unsigned short vna_other
;
1882 psym
= symtab
+ symtab_index
;
1885 = get_symbol_version_string (filedata
, is_dynsym
,
1894 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1898 unsigned int width
= is_32bit_elf
? 8 : 14;
1900 /* Relocations against GNU_IFUNC symbols do not use the value
1901 of the symbol as the address to relocate against. Instead
1902 they invoke the function named by the symbol and use its
1903 result as the address for relocation.
1905 To indicate this to the user, do not display the value of
1906 the symbol in the "Symbols's Value" field. Instead show
1907 its name followed by () as a hint that the symbol is
1911 || psym
->st_name
== 0
1912 || psym
->st_name
>= strtablen
)
1915 name
= strtab
+ psym
->st_name
;
1917 len
= print_symbol (width
, name
);
1919 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1921 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1925 print_vma (psym
->st_value
, LONG_HEX
);
1927 printf (is_32bit_elf
? " " : " ");
1930 if (psym
->st_name
== 0)
1932 const char * sec_name
= "<null>";
1935 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1937 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
1938 && filedata
->section_headers
!= NULL
)
1939 sec_name
= section_name_print (filedata
,
1940 filedata
->section_headers
1942 else if (psym
->st_shndx
== SHN_ABS
)
1944 else if (psym
->st_shndx
== SHN_COMMON
)
1945 sec_name
= "COMMON";
1946 else if ((filedata
->file_header
.e_machine
== EM_MIPS
1947 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1948 || (filedata
->file_header
.e_machine
== EM_TI_C6000
1949 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1950 sec_name
= "SCOMMON";
1951 else if (filedata
->file_header
.e_machine
== EM_MIPS
1952 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1953 sec_name
= "SUNDEF";
1954 else if ((filedata
->file_header
.e_machine
== EM_X86_64
1955 || filedata
->file_header
.e_machine
== EM_L1OM
1956 || filedata
->file_header
.e_machine
== EM_K1OM
)
1957 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1958 sec_name
= "LARGE_COMMON";
1959 else if (filedata
->file_header
.e_machine
== EM_IA_64
1960 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1961 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1962 sec_name
= "ANSI_COM";
1963 else if (is_ia64_vms (filedata
)
1964 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1965 sec_name
= "VMS_SYMVEC";
1968 sprintf (name_buf
, "<section 0x%x>",
1969 (unsigned int) psym
->st_shndx
);
1970 sec_name
= name_buf
;
1973 print_symbol (22, sec_name
);
1975 else if (strtab
== NULL
)
1976 printf (_("<string table index: %3ld>"), psym
->st_name
);
1977 else if (psym
->st_name
>= strtablen
)
1979 error (_("<corrupt string table index: %3ld>\n"),
1985 print_symbol (22, strtab
+ psym
->st_name
);
1987 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1993 bfd_vma off
= rels
[i
].r_addend
;
1995 if ((bfd_signed_vma
) off
< 0)
1996 printf (" - %" BFD_VMA_FMT
"x", - off
);
1998 printf (" + %" BFD_VMA_FMT
"x", off
);
2004 bfd_vma off
= rels
[i
].r_addend
;
2006 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
2007 if ((bfd_signed_vma
) off
< 0)
2008 printf ("-%" BFD_VMA_FMT
"x", - off
);
2010 printf ("%" BFD_VMA_FMT
"x", off
);
2013 if (filedata
->file_header
.e_machine
== EM_SPARCV9
2015 && streq (rtype
, "R_SPARC_OLO10"))
2016 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
2021 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
2023 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
2024 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
2025 const char * rtype2
= elf_mips_reloc_type (type2
);
2026 const char * rtype3
= elf_mips_reloc_type (type3
);
2028 printf (" Type2: ");
2031 printf (_("unrecognized: %-7lx"),
2032 (unsigned long) type2
& 0xffffffff);
2034 printf ("%-17.17s", rtype2
);
2036 printf ("\n Type3: ");
2039 printf (_("unrecognized: %-7lx"),
2040 (unsigned long) type3
& 0xffffffff);
2042 printf ("%-17.17s", rtype3
);
2055 get_aarch64_dynamic_type (unsigned long type
)
2059 case DT_AARCH64_BTI_PLT
: return "AARCH64_BTI_PLT";
2060 case DT_AARCH64_PAC_PLT
: return "AARCH64_PAC_PLT";
2061 case DT_AARCH64_VARIANT_PCS
: return "AARCH64_VARIANT_PCS";
2068 get_mips_dynamic_type (unsigned long type
)
2072 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
2073 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
2074 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
2075 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
2076 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
2077 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
2078 case DT_MIPS_MSYM
: return "MIPS_MSYM";
2079 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2080 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2081 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
2082 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
2083 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
2084 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
2085 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
2086 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
2087 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
2088 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
2089 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
2090 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
2091 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
2092 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
2093 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
2094 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
2095 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
2096 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
2097 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
2098 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
2099 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
2100 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
2101 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
2102 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2103 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
2104 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
2105 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
2106 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
2107 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2108 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
2109 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
2110 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
2111 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
2112 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
2113 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
2114 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
2115 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
2116 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
2117 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
2118 case DT_MIPS_XHASH
: return "MIPS_XHASH";
2125 get_sparc64_dynamic_type (unsigned long type
)
2129 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
2136 get_ppc_dynamic_type (unsigned long type
)
2140 case DT_PPC_GOT
: return "PPC_GOT";
2141 case DT_PPC_OPT
: return "PPC_OPT";
2148 get_ppc64_dynamic_type (unsigned long type
)
2152 case DT_PPC64_GLINK
: return "PPC64_GLINK";
2153 case DT_PPC64_OPD
: return "PPC64_OPD";
2154 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
2155 case DT_PPC64_OPT
: return "PPC64_OPT";
2162 get_parisc_dynamic_type (unsigned long type
)
2166 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
2167 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
2168 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
2169 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
2170 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
2171 case DT_HP_PREINIT
: return "HP_PREINIT";
2172 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
2173 case DT_HP_NEEDED
: return "HP_NEEDED";
2174 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
2175 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
2176 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
2177 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
2178 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
2179 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
2180 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
2181 case DT_HP_FILTERED
: return "HP_FILTERED";
2182 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
2183 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
2184 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
2185 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
2186 case DT_PLT
: return "PLT";
2187 case DT_PLT_SIZE
: return "PLT_SIZE";
2188 case DT_DLT
: return "DLT";
2189 case DT_DLT_SIZE
: return "DLT_SIZE";
2196 get_ia64_dynamic_type (unsigned long type
)
2200 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
2201 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
2202 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
2203 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
2204 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
2205 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
2206 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
2207 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
2208 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
2209 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
2210 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
2211 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
2212 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
2213 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
2214 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
2215 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
2216 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
2217 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
2218 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
2219 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
2220 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
2221 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
2222 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
2223 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
2224 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
2225 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
2226 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
2227 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
2228 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
2229 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
2230 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
2237 get_solaris_section_type (unsigned long type
)
2241 case 0x6fffffee: return "SUNW_ancillary";
2242 case 0x6fffffef: return "SUNW_capchain";
2243 case 0x6ffffff0: return "SUNW_capinfo";
2244 case 0x6ffffff1: return "SUNW_symsort";
2245 case 0x6ffffff2: return "SUNW_tlssort";
2246 case 0x6ffffff3: return "SUNW_LDYNSYM";
2247 case 0x6ffffff4: return "SUNW_dof";
2248 case 0x6ffffff5: return "SUNW_cap";
2249 case 0x6ffffff6: return "SUNW_SIGNATURE";
2250 case 0x6ffffff7: return "SUNW_ANNOTATE";
2251 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2252 case 0x6ffffff9: return "SUNW_DEBUG";
2253 case 0x6ffffffa: return "SUNW_move";
2254 case 0x6ffffffb: return "SUNW_COMDAT";
2255 case 0x6ffffffc: return "SUNW_syminfo";
2256 case 0x6ffffffd: return "SUNW_verdef";
2257 case 0x6ffffffe: return "SUNW_verneed";
2258 case 0x6fffffff: return "SUNW_versym";
2259 case 0x70000000: return "SPARC_GOTDATA";
2260 default: return NULL
;
2265 get_alpha_dynamic_type (unsigned long type
)
2269 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2270 default: return NULL
;
2275 get_score_dynamic_type (unsigned long type
)
2279 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2280 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2281 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2282 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2283 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2284 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2285 default: return NULL
;
2290 get_tic6x_dynamic_type (unsigned long type
)
2294 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2295 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2296 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2297 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2298 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2299 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2300 default: return NULL
;
2305 get_nios2_dynamic_type (unsigned long type
)
2309 case DT_NIOS2_GP
: return "NIOS2_GP";
2310 default: return NULL
;
2315 get_solaris_dynamic_type (unsigned long type
)
2319 case 0x6000000d: return "SUNW_AUXILIARY";
2320 case 0x6000000e: return "SUNW_RTLDINF";
2321 case 0x6000000f: return "SUNW_FILTER";
2322 case 0x60000010: return "SUNW_CAP";
2323 case 0x60000011: return "SUNW_SYMTAB";
2324 case 0x60000012: return "SUNW_SYMSZ";
2325 case 0x60000013: return "SUNW_SORTENT";
2326 case 0x60000014: return "SUNW_SYMSORT";
2327 case 0x60000015: return "SUNW_SYMSORTSZ";
2328 case 0x60000016: return "SUNW_TLSSORT";
2329 case 0x60000017: return "SUNW_TLSSORTSZ";
2330 case 0x60000018: return "SUNW_CAPINFO";
2331 case 0x60000019: return "SUNW_STRPAD";
2332 case 0x6000001a: return "SUNW_CAPCHAIN";
2333 case 0x6000001b: return "SUNW_LDMACH";
2334 case 0x6000001d: return "SUNW_CAPCHAINENT";
2335 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2336 case 0x60000021: return "SUNW_PARENT";
2337 case 0x60000023: return "SUNW_ASLR";
2338 case 0x60000025: return "SUNW_RELAX";
2339 case 0x60000029: return "SUNW_NXHEAP";
2340 case 0x6000002b: return "SUNW_NXSTACK";
2342 case 0x70000001: return "SPARC_REGISTER";
2343 case 0x7ffffffd: return "AUXILIARY";
2344 case 0x7ffffffe: return "USED";
2345 case 0x7fffffff: return "FILTER";
2347 default: return NULL
;
2352 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2354 static char buff
[64];
2358 case DT_NULL
: return "NULL";
2359 case DT_NEEDED
: return "NEEDED";
2360 case DT_PLTRELSZ
: return "PLTRELSZ";
2361 case DT_PLTGOT
: return "PLTGOT";
2362 case DT_HASH
: return "HASH";
2363 case DT_STRTAB
: return "STRTAB";
2364 case DT_SYMTAB
: return "SYMTAB";
2365 case DT_RELA
: return "RELA";
2366 case DT_RELASZ
: return "RELASZ";
2367 case DT_RELAENT
: return "RELAENT";
2368 case DT_STRSZ
: return "STRSZ";
2369 case DT_SYMENT
: return "SYMENT";
2370 case DT_INIT
: return "INIT";
2371 case DT_FINI
: return "FINI";
2372 case DT_SONAME
: return "SONAME";
2373 case DT_RPATH
: return "RPATH";
2374 case DT_SYMBOLIC
: return "SYMBOLIC";
2375 case DT_REL
: return "REL";
2376 case DT_RELSZ
: return "RELSZ";
2377 case DT_RELENT
: return "RELENT";
2378 case DT_RELR
: return "RELR";
2379 case DT_RELRSZ
: return "RELRSZ";
2380 case DT_RELRENT
: return "RELRENT";
2381 case DT_PLTREL
: return "PLTREL";
2382 case DT_DEBUG
: return "DEBUG";
2383 case DT_TEXTREL
: return "TEXTREL";
2384 case DT_JMPREL
: return "JMPREL";
2385 case DT_BIND_NOW
: return "BIND_NOW";
2386 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2387 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2388 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2389 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2390 case DT_RUNPATH
: return "RUNPATH";
2391 case DT_FLAGS
: return "FLAGS";
2393 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2394 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2395 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2397 case DT_CHECKSUM
: return "CHECKSUM";
2398 case DT_PLTPADSZ
: return "PLTPADSZ";
2399 case DT_MOVEENT
: return "MOVEENT";
2400 case DT_MOVESZ
: return "MOVESZ";
2401 case DT_FEATURE
: return "FEATURE";
2402 case DT_POSFLAG_1
: return "POSFLAG_1";
2403 case DT_SYMINSZ
: return "SYMINSZ";
2404 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2406 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2407 case DT_CONFIG
: return "CONFIG";
2408 case DT_DEPAUDIT
: return "DEPAUDIT";
2409 case DT_AUDIT
: return "AUDIT";
2410 case DT_PLTPAD
: return "PLTPAD";
2411 case DT_MOVETAB
: return "MOVETAB";
2412 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2414 case DT_VERSYM
: return "VERSYM";
2416 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2417 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2418 case DT_RELACOUNT
: return "RELACOUNT";
2419 case DT_RELCOUNT
: return "RELCOUNT";
2420 case DT_FLAGS_1
: return "FLAGS_1";
2421 case DT_VERDEF
: return "VERDEF";
2422 case DT_VERDEFNUM
: return "VERDEFNUM";
2423 case DT_VERNEED
: return "VERNEED";
2424 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2426 case DT_AUXILIARY
: return "AUXILIARY";
2427 case DT_USED
: return "USED";
2428 case DT_FILTER
: return "FILTER";
2430 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2431 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2432 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2433 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2434 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2435 case DT_GNU_HASH
: return "GNU_HASH";
2436 case DT_GNU_FLAGS_1
: return "GNU_FLAGS_1";
2439 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2441 const char * result
;
2443 switch (filedata
->file_header
.e_machine
)
2446 result
= get_aarch64_dynamic_type (type
);
2449 case EM_MIPS_RS3_LE
:
2450 result
= get_mips_dynamic_type (type
);
2453 result
= get_sparc64_dynamic_type (type
);
2456 result
= get_ppc_dynamic_type (type
);
2459 result
= get_ppc64_dynamic_type (type
);
2462 result
= get_ia64_dynamic_type (type
);
2465 result
= get_alpha_dynamic_type (type
);
2468 result
= get_score_dynamic_type (type
);
2471 result
= get_tic6x_dynamic_type (type
);
2473 case EM_ALTERA_NIOS2
:
2474 result
= get_nios2_dynamic_type (type
);
2477 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2478 result
= get_solaris_dynamic_type (type
);
2487 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2489 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2490 || (filedata
->file_header
.e_machine
== EM_PARISC
2491 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2493 const char * result
;
2495 switch (filedata
->file_header
.e_machine
)
2498 result
= get_parisc_dynamic_type (type
);
2501 result
= get_ia64_dynamic_type (type
);
2504 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2505 result
= get_solaris_dynamic_type (type
);
2514 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2518 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2524 static bool get_program_headers (Filedata
*);
2525 static bool get_dynamic_section (Filedata
*);
2528 locate_dynamic_section (Filedata
*filedata
)
2530 unsigned long dynamic_addr
= 0;
2531 bfd_size_type dynamic_size
= 0;
2533 if (filedata
->file_header
.e_phnum
!= 0
2534 && get_program_headers (filedata
))
2536 Elf_Internal_Phdr
*segment
;
2539 for (i
= 0, segment
= filedata
->program_headers
;
2540 i
< filedata
->file_header
.e_phnum
;
2543 if (segment
->p_type
== PT_DYNAMIC
)
2545 dynamic_addr
= segment
->p_offset
;
2546 dynamic_size
= segment
->p_filesz
;
2548 if (filedata
->section_headers
!= NULL
)
2550 Elf_Internal_Shdr
*sec
;
2552 sec
= find_section (filedata
, ".dynamic");
2555 if (sec
->sh_size
== 0
2556 || sec
->sh_type
== SHT_NOBITS
)
2563 dynamic_addr
= sec
->sh_offset
;
2564 dynamic_size
= sec
->sh_size
;
2569 if (dynamic_addr
> filedata
->file_size
2570 || (dynamic_size
> filedata
->file_size
- dynamic_addr
))
2579 filedata
->dynamic_addr
= dynamic_addr
;
2580 filedata
->dynamic_size
= dynamic_size
? dynamic_size
: 1;
2584 is_pie (Filedata
*filedata
)
2586 Elf_Internal_Dyn
*entry
;
2588 if (filedata
->dynamic_size
== 0)
2589 locate_dynamic_section (filedata
);
2590 if (filedata
->dynamic_size
<= 1)
2593 if (!get_dynamic_section (filedata
))
2596 for (entry
= filedata
->dynamic_section
;
2597 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
2600 if (entry
->d_tag
== DT_FLAGS_1
)
2602 if ((entry
->d_un
.d_val
& DF_1_PIE
) != 0)
2611 get_file_type (Filedata
*filedata
)
2613 unsigned e_type
= filedata
->file_header
.e_type
;
2614 static char buff
[64];
2618 case ET_NONE
: return _("NONE (None)");
2619 case ET_REL
: return _("REL (Relocatable file)");
2620 case ET_EXEC
: return _("EXEC (Executable file)");
2622 if (is_pie (filedata
))
2623 return _("DYN (Position-Independent Executable file)");
2625 return _("DYN (Shared object file)");
2626 case ET_CORE
: return _("CORE (Core file)");
2629 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2630 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2631 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2632 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2634 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2640 get_machine_name (unsigned e_machine
)
2642 static char buff
[64]; /* XXX */
2646 /* Please keep this switch table sorted by increasing EM_ value. */
2648 case EM_NONE
: return _("None");
2649 case EM_M32
: return "WE32100";
2650 case EM_SPARC
: return "Sparc";
2651 case EM_386
: return "Intel 80386";
2652 case EM_68K
: return "MC68000";
2653 case EM_88K
: return "MC88000";
2654 case EM_IAMCU
: return "Intel MCU";
2655 case EM_860
: return "Intel 80860";
2656 case EM_MIPS
: return "MIPS R3000";
2657 case EM_S370
: return "IBM System/370";
2659 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2660 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2661 case EM_PARISC
: return "HPPA";
2662 case EM_VPP550
: return "Fujitsu VPP500";
2663 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2664 case EM_960
: return "Intel 80960";
2665 case EM_PPC
: return "PowerPC";
2667 case EM_PPC64
: return "PowerPC64";
2669 case EM_S390
: return "IBM S/390";
2670 case EM_SPU
: return "SPU";
2672 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2673 case EM_FR20
: return "Fujitsu FR20";
2674 case EM_RH32
: return "TRW RH32";
2675 case EM_MCORE
: return "MCORE";
2677 case EM_ARM
: return "ARM";
2678 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2679 case EM_SH
: return "Renesas / SuperH SH";
2680 case EM_SPARCV9
: return "Sparc v9";
2681 case EM_TRICORE
: return "Siemens Tricore";
2682 case EM_ARC
: return "ARC";
2683 case EM_H8_300
: return "Renesas H8/300";
2684 case EM_H8_300H
: return "Renesas H8/300H";
2685 case EM_H8S
: return "Renesas H8S";
2686 case EM_H8_500
: return "Renesas H8/500";
2688 case EM_IA_64
: return "Intel IA-64";
2689 case EM_MIPS_X
: return "Stanford MIPS-X";
2690 case EM_COLDFIRE
: return "Motorola Coldfire";
2691 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2692 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2693 case EM_PCP
: return "Siemens PCP";
2694 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2695 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2696 case EM_STARCORE
: return "Motorola Star*Core processor";
2697 case EM_ME16
: return "Toyota ME16 processor";
2699 case EM_ST100
: return "STMicroelectronics ST100 processor";
2700 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2701 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2702 case EM_PDSP
: return "Sony DSP processor";
2703 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2704 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2705 case EM_FX66
: return "Siemens FX66 microcontroller";
2706 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2707 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2708 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2710 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2711 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2712 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2713 case EM_SVX
: return "Silicon Graphics SVx";
2714 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2715 case EM_VAX
: return "Digital VAX";
2716 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2717 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2718 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2719 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2721 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2722 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2723 case EM_PRISM
: return "Vitesse Prism";
2725 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2726 case EM_CYGNUS_FR30
:
2727 case EM_FR30
: return "Fujitsu FR30";
2728 case EM_CYGNUS_D10V
:
2729 case EM_D10V
: return "d10v";
2730 case EM_CYGNUS_D30V
:
2731 case EM_D30V
: return "d30v";
2732 case EM_CYGNUS_V850
:
2733 case EM_V850
: return "Renesas V850";
2734 case EM_CYGNUS_M32R
:
2735 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2736 case EM_CYGNUS_MN10300
:
2737 case EM_MN10300
: return "mn10300";
2739 case EM_CYGNUS_MN10200
:
2740 case EM_MN10200
: return "mn10200";
2741 case EM_PJ
: return "picoJava";
2742 case EM_OR1K
: return "OpenRISC 1000";
2743 case EM_ARC_COMPACT
: return "ARCompact";
2745 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2746 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2747 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2748 case EM_NS32K
: return "National Semiconductor 32000 series";
2749 case EM_TPC
: return "Tenor Network TPC processor";
2750 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2752 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2754 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2755 case EM_MAX
: return "MAX Processor";
2756 case EM_CR
: return "National Semiconductor CompactRISC";
2757 case EM_F2MC16
: return "Fujitsu F2MC16";
2758 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2759 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2760 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2761 case EM_SEP
: return "Sharp embedded microprocessor";
2762 case EM_ARCA
: return "Arca RISC microprocessor";
2764 case EM_UNICORE
: return "Unicore";
2765 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2766 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2767 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2768 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2769 case EM_XGATE
: return "Motorola XGATE embedded processor";
2771 case EM_XC16X
: return "Infineon Technologies xc16x";
2772 case EM_M16C
: return "Renesas M16C series microprocessors";
2773 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2774 case EM_CE
: return "Freescale Communication Engine RISC core";
2776 case EM_M32C
: return "Renesas M32c";
2778 case EM_TSK3000
: return "Altium TSK3000 core";
2779 case EM_RS08
: return "Freescale RS08 embedded processor";
2780 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2781 case EM_SCORE
: return "SUNPLUS S+Core";
2782 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2783 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2784 case EM_LATTICEMICO32
: return "Lattice Mico32";
2785 case EM_SE_C17
: return "Seiko Epson C17 family";
2787 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2788 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2789 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2790 case EM_TI_PRU
: return "TI PRU I/O processor";
2792 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2793 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2794 case EM_R32C
: return "Renesas R32C series microprocessors";
2795 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2796 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2797 case EM_8051
: return "Intel 8051 and variants";
2798 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2799 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2800 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2801 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2803 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2804 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2805 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2806 case EM_RX
: return "Renesas RX";
2807 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2808 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2809 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2812 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2813 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2814 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2816 case EM_L1OM
: return "Intel L1OM";
2817 case EM_K1OM
: return "Intel K1OM";
2818 case EM_INTEL182
: return "Intel (reserved)";
2819 case EM_AARCH64
: return "AArch64";
2820 case EM_ARM184
: return "ARM (reserved)";
2821 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2822 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2823 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2824 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2826 case EM_CUDA
: return "NVIDIA CUDA architecture";
2827 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2828 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2829 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2830 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2831 case EM_ARC_COMPACT2
: return "ARCv2";
2832 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2833 case EM_RL78
: return "Renesas RL78";
2834 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2835 case EM_78K0R
: return "Renesas 78K0R";
2837 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2838 case EM_BA1
: return "Beyond BA1 CPU architecture";
2839 case EM_BA2
: return "Beyond BA2 CPU architecture";
2840 case EM_XCORE
: return "XMOS xCORE processor family";
2841 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2842 case EM_INTELGT
: return "Intel Graphics Technology";
2844 case EM_KM32
: return "KM211 KM32 32-bit processor";
2845 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2846 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2847 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2848 case EM_KVARC
: return "KM211 KVARC processor";
2849 case EM_CDP
: return "Paneve CDP architecture family";
2850 case EM_COGE
: return "Cognitive Smart Memory Processor";
2851 case EM_COOL
: return "Bluechip Systems CoolEngine";
2852 case EM_NORC
: return "Nanoradio Optimized RISC";
2853 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2855 case EM_Z80
: return "Zilog Z80";
2856 case EM_VISIUM
: return "CDS VISIUMcore processor";
2857 case EM_FT32
: return "FTDI Chip FT32";
2858 case EM_MOXIE
: return "Moxie";
2859 case EM_AMDGPU
: return "AMD GPU";
2860 /* 230 (all reserved) */
2862 case EM_RISCV
: return "RISC-V";
2863 case EM_LANAI
: return "Lanai 32-bit processor";
2864 case EM_CEVA
: return "CEVA Processor Architecture Family";
2865 case EM_CEVA_X2
: return "CEVA X2 Processor Family";
2866 case EM_BPF
: return "Linux BPF";
2867 case EM_GRAPHCORE_IPU
: return "Graphcore Intelligent Processing Unit";
2868 case EM_IMG1
: return "Imagination Technologies";
2870 case EM_NFP
: return "Netronome Flow Processor";
2871 case EM_VE
: return "NEC Vector Engine";
2872 case EM_CSKY
: return "C-SKY";
2873 case EM_ARC_COMPACT3_64
: return "Synopsys ARCv2.3 64-bit";
2874 case EM_MCS6502
: return "MOS Technology MCS 6502 processor";
2875 case EM_ARC_COMPACT3
: return "Synopsys ARCv2.3 32-bit";
2876 case EM_KVX
: return "Kalray VLIW core of the MPPA processor family";
2877 case EM_65816
: return "WDC 65816/65C816";
2878 case EM_LOONGARCH
: return "LoongArch";
2879 case EM_KF32
: return "ChipON KungFu32";
2881 /* Large numbers... */
2882 case EM_MT
: return "Morpho Techologies MT processor";
2883 case EM_ALPHA
: return "Alpha";
2884 case EM_WEBASSEMBLY
: return "Web Assembly";
2885 case EM_DLX
: return "OpenDLX";
2886 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2887 case EM_IQ2000
: return "Vitesse IQ2000";
2889 case EM_NIOS32
: return "Altera Nios";
2890 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2891 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2892 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2893 case EM_S12Z
: return "Freescale S12Z";
2896 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2902 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2904 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2905 other compilers don't specify an architecture type in the e_flags, and
2906 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2907 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2910 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2911 but also sets a specific architecture type in the e_flags field.
2913 However, when decoding the flags we don't worry if we see an
2914 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2915 ARCEM architecture type. */
2917 switch (e_flags
& EF_ARC_MACH_MSK
)
2919 /* We only expect these to occur for EM_ARC_COMPACT2. */
2920 case EF_ARC_CPU_ARCV2EM
:
2921 strcat (buf
, ", ARC EM");
2923 case EF_ARC_CPU_ARCV2HS
:
2924 strcat (buf
, ", ARC HS");
2927 /* We only expect these to occur for EM_ARC_COMPACT. */
2928 case E_ARC_MACH_ARC600
:
2929 strcat (buf
, ", ARC600");
2931 case E_ARC_MACH_ARC601
:
2932 strcat (buf
, ", ARC601");
2934 case E_ARC_MACH_ARC700
:
2935 strcat (buf
, ", ARC700");
2938 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2939 new ELF with new architecture being read by an old version of
2940 readelf, or (c) An ELF built with non-GNU compiler that does not
2941 set the architecture in the e_flags. */
2943 if (e_machine
== EM_ARC_COMPACT
)
2944 strcat (buf
, ", Unknown ARCompact");
2946 strcat (buf
, ", Unknown ARC");
2950 switch (e_flags
& EF_ARC_OSABI_MSK
)
2952 case E_ARC_OSABI_ORIG
:
2953 strcat (buf
, ", (ABI:legacy)");
2955 case E_ARC_OSABI_V2
:
2956 strcat (buf
, ", (ABI:v2)");
2958 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2959 case E_ARC_OSABI_V3
:
2960 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2962 case E_ARC_OSABI_V4
:
2963 strcat (buf
, ", v4 ABI");
2966 strcat (buf
, ", unrecognised ARC OSABI flag");
2972 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2975 bool unknown
= false;
2977 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2978 e_flags
&= ~ EF_ARM_EABIMASK
;
2980 /* Handle "generic" ARM flags. */
2981 if (e_flags
& EF_ARM_RELEXEC
)
2983 strcat (buf
, ", relocatable executable");
2984 e_flags
&= ~ EF_ARM_RELEXEC
;
2987 if (e_flags
& EF_ARM_PIC
)
2989 strcat (buf
, ", position independent");
2990 e_flags
&= ~ EF_ARM_PIC
;
2993 /* Now handle EABI specific flags. */
2997 strcat (buf
, ", <unrecognized EABI>");
3002 case EF_ARM_EABI_VER1
:
3003 strcat (buf
, ", Version1 EABI");
3008 /* Process flags one bit at a time. */
3009 flag
= e_flags
& - e_flags
;
3014 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
3015 strcat (buf
, ", sorted symbol tables");
3025 case EF_ARM_EABI_VER2
:
3026 strcat (buf
, ", Version2 EABI");
3031 /* Process flags one bit at a time. */
3032 flag
= e_flags
& - e_flags
;
3037 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
3038 strcat (buf
, ", sorted symbol tables");
3041 case EF_ARM_DYNSYMSUSESEGIDX
:
3042 strcat (buf
, ", dynamic symbols use segment index");
3045 case EF_ARM_MAPSYMSFIRST
:
3046 strcat (buf
, ", mapping symbols precede others");
3056 case EF_ARM_EABI_VER3
:
3057 strcat (buf
, ", Version3 EABI");
3060 case EF_ARM_EABI_VER4
:
3061 strcat (buf
, ", Version4 EABI");
3066 /* Process flags one bit at a time. */
3067 flag
= e_flags
& - e_flags
;
3073 strcat (buf
, ", BE8");
3077 strcat (buf
, ", LE8");
3087 case EF_ARM_EABI_VER5
:
3088 strcat (buf
, ", Version5 EABI");
3093 /* Process flags one bit at a time. */
3094 flag
= e_flags
& - e_flags
;
3100 strcat (buf
, ", BE8");
3104 strcat (buf
, ", LE8");
3107 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
3108 strcat (buf
, ", soft-float ABI");
3111 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
3112 strcat (buf
, ", hard-float ABI");
3122 case EF_ARM_EABI_UNKNOWN
:
3123 strcat (buf
, ", GNU EABI");
3128 /* Process flags one bit at a time. */
3129 flag
= e_flags
& - e_flags
;
3134 case EF_ARM_INTERWORK
:
3135 strcat (buf
, ", interworking enabled");
3138 case EF_ARM_APCS_26
:
3139 strcat (buf
, ", uses APCS/26");
3142 case EF_ARM_APCS_FLOAT
:
3143 strcat (buf
, ", uses APCS/float");
3147 strcat (buf
, ", position independent");
3151 strcat (buf
, ", 8 bit structure alignment");
3154 case EF_ARM_NEW_ABI
:
3155 strcat (buf
, ", uses new ABI");
3158 case EF_ARM_OLD_ABI
:
3159 strcat (buf
, ", uses old ABI");
3162 case EF_ARM_SOFT_FLOAT
:
3163 strcat (buf
, ", software FP");
3166 case EF_ARM_VFP_FLOAT
:
3167 strcat (buf
, ", VFP");
3170 case EF_ARM_MAVERICK_FLOAT
:
3171 strcat (buf
, ", Maverick FP");
3182 strcat (buf
,_(", <unknown>"));
3186 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
3188 --size
; /* Leave space for null terminator. */
3190 switch (e_flags
& EF_AVR_MACH
)
3192 case E_AVR_MACH_AVR1
:
3193 strncat (buf
, ", avr:1", size
);
3195 case E_AVR_MACH_AVR2
:
3196 strncat (buf
, ", avr:2", size
);
3198 case E_AVR_MACH_AVR25
:
3199 strncat (buf
, ", avr:25", size
);
3201 case E_AVR_MACH_AVR3
:
3202 strncat (buf
, ", avr:3", size
);
3204 case E_AVR_MACH_AVR31
:
3205 strncat (buf
, ", avr:31", size
);
3207 case E_AVR_MACH_AVR35
:
3208 strncat (buf
, ", avr:35", size
);
3210 case E_AVR_MACH_AVR4
:
3211 strncat (buf
, ", avr:4", size
);
3213 case E_AVR_MACH_AVR5
:
3214 strncat (buf
, ", avr:5", size
);
3216 case E_AVR_MACH_AVR51
:
3217 strncat (buf
, ", avr:51", size
);
3219 case E_AVR_MACH_AVR6
:
3220 strncat (buf
, ", avr:6", size
);
3222 case E_AVR_MACH_AVRTINY
:
3223 strncat (buf
, ", avr:100", size
);
3225 case E_AVR_MACH_XMEGA1
:
3226 strncat (buf
, ", avr:101", size
);
3228 case E_AVR_MACH_XMEGA2
:
3229 strncat (buf
, ", avr:102", size
);
3231 case E_AVR_MACH_XMEGA3
:
3232 strncat (buf
, ", avr:103", size
);
3234 case E_AVR_MACH_XMEGA4
:
3235 strncat (buf
, ", avr:104", size
);
3237 case E_AVR_MACH_XMEGA5
:
3238 strncat (buf
, ", avr:105", size
);
3240 case E_AVR_MACH_XMEGA6
:
3241 strncat (buf
, ", avr:106", size
);
3243 case E_AVR_MACH_XMEGA7
:
3244 strncat (buf
, ", avr:107", size
);
3247 strncat (buf
, ", avr:<unknown>", size
);
3251 size
-= strlen (buf
);
3252 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
3253 strncat (buf
, ", link-relax", size
);
3257 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
3263 bool has_fpu
= false;
3266 static const char *ABI_STRINGS
[] =
3268 "ABI v0", /* use r5 as return register; only used in N1213HC */
3269 "ABI v1", /* use r0 as return register */
3270 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
3271 "ABI v2fp", /* for FPU */
3275 static const char *VER_STRINGS
[] =
3277 "Andes ELF V1.3 or older",
3281 static const char *ARCH_STRINGS
[] =
3290 abi
= EF_NDS_ABI
& e_flags
;
3291 arch
= EF_NDS_ARCH
& e_flags
;
3292 config
= EF_NDS_INST
& e_flags
;
3293 version
= EF_NDS32_ELF_VERSION
& e_flags
;
3295 memset (buf
, 0, size
);
3302 case E_NDS_ABI_V2FP
:
3303 case E_NDS_ABI_AABI
:
3304 case E_NDS_ABI_V2FP_PLUS
:
3305 /* In case there are holes in the array. */
3306 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
3310 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
3316 case E_NDS32_ELF_VER_1_2
:
3317 case E_NDS32_ELF_VER_1_3
:
3318 case E_NDS32_ELF_VER_1_4
:
3319 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
3323 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
3327 if (E_NDS_ABI_V0
== abi
)
3329 /* OLD ABI; only used in N1213HC, has performance extension 1. */
3330 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
3331 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3332 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
3338 case E_NDS_ARCH_STAR_V1_0
:
3339 case E_NDS_ARCH_STAR_V2_0
:
3340 case E_NDS_ARCH_STAR_V3_0
:
3341 case E_NDS_ARCH_STAR_V3_M
:
3342 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
3346 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
3347 /* ARCH version determines how the e_flags are interpreted.
3348 If it is unknown, we cannot proceed. */
3352 /* Newer ABI; Now handle architecture specific flags. */
3353 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3355 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3356 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
3358 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
3359 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
3361 if (config
& E_NDS32_HAS_DIV_INST
)
3362 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
3364 if (config
& E_NDS32_HAS_16BIT_INST
)
3365 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3369 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3371 if (version
<= E_NDS32_ELF_VER_1_3
)
3372 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
3374 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
3377 if (config
& E_NDS32_HAS_MAC_DX_INST
)
3378 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
3380 if (config
& E_NDS32_HAS_DIV_DX_INST
)
3381 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
3383 if (config
& E_NDS32_HAS_16BIT_INST
)
3385 if (version
<= E_NDS32_ELF_VER_1_3
)
3386 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3388 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3392 if (config
& E_NDS32_HAS_EXT_INST
)
3393 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3395 if (config
& E_NDS32_HAS_EXT2_INST
)
3396 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3398 if (config
& E_NDS32_HAS_FPU_INST
)
3401 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3404 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3407 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3410 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3413 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3418 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3420 case E_NDS32_FPU_REG_8SP_4DP
:
3421 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3423 case E_NDS32_FPU_REG_16SP_8DP
:
3424 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3426 case E_NDS32_FPU_REG_32SP_16DP
:
3427 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3429 case E_NDS32_FPU_REG_32SP_32DP
:
3430 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3435 if (config
& E_NDS32_HAS_AUDIO_INST
)
3436 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3438 if (config
& E_NDS32_HAS_STRING_INST
)
3439 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3441 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3442 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3444 if (config
& E_NDS32_HAS_VIDEO_INST
)
3446 if (version
<= E_NDS32_ELF_VER_1_3
)
3447 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3449 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3452 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3453 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3455 if (config
& E_NDS32_HAS_L2C_INST
)
3456 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3460 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3462 static char buf
[1024];
3473 case EM_ARC_COMPACT2
:
3474 case EM_ARC_COMPACT
:
3475 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3479 decode_ARM_machine_flags (e_flags
, buf
);
3483 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3487 if (e_flags
& EF_BFIN_PIC
)
3488 strcat (buf
, ", PIC");
3490 if (e_flags
& EF_BFIN_FDPIC
)
3491 strcat (buf
, ", FDPIC");
3493 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3494 strcat (buf
, ", code in L1");
3496 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3497 strcat (buf
, ", data in L1");
3502 switch (e_flags
& EF_FRV_CPU_MASK
)
3504 case EF_FRV_CPU_GENERIC
:
3508 strcat (buf
, ", fr???");
3511 case EF_FRV_CPU_FR300
:
3512 strcat (buf
, ", fr300");
3515 case EF_FRV_CPU_FR400
:
3516 strcat (buf
, ", fr400");
3518 case EF_FRV_CPU_FR405
:
3519 strcat (buf
, ", fr405");
3522 case EF_FRV_CPU_FR450
:
3523 strcat (buf
, ", fr450");
3526 case EF_FRV_CPU_FR500
:
3527 strcat (buf
, ", fr500");
3529 case EF_FRV_CPU_FR550
:
3530 strcat (buf
, ", fr550");
3533 case EF_FRV_CPU_SIMPLE
:
3534 strcat (buf
, ", simple");
3536 case EF_FRV_CPU_TOMCAT
:
3537 strcat (buf
, ", tomcat");
3543 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3544 strcat (buf
, ", m68000");
3545 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3546 strcat (buf
, ", cpu32");
3547 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3548 strcat (buf
, ", fido_a");
3551 char const * isa
= _("unknown");
3552 char const * mac
= _("unknown mac");
3553 char const * additional
= NULL
;
3555 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3557 case EF_M68K_CF_ISA_A_NODIV
:
3559 additional
= ", nodiv";
3561 case EF_M68K_CF_ISA_A
:
3564 case EF_M68K_CF_ISA_A_PLUS
:
3567 case EF_M68K_CF_ISA_B_NOUSP
:
3569 additional
= ", nousp";
3571 case EF_M68K_CF_ISA_B
:
3574 case EF_M68K_CF_ISA_C
:
3577 case EF_M68K_CF_ISA_C_NODIV
:
3579 additional
= ", nodiv";
3582 strcat (buf
, ", cf, isa ");
3585 strcat (buf
, additional
);
3586 if (e_flags
& EF_M68K_CF_FLOAT
)
3587 strcat (buf
, ", float");
3588 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3593 case EF_M68K_CF_MAC
:
3596 case EF_M68K_CF_EMAC
:
3599 case EF_M68K_CF_EMAC_B
:
3612 switch (e_flags
& EF_MEP_CPU_MASK
)
3614 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3615 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3616 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3617 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3618 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3619 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3620 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3623 switch (e_flags
& EF_MEP_COP_MASK
)
3625 case EF_MEP_COP_NONE
: break;
3626 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3627 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3628 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3629 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3630 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3633 if (e_flags
& EF_MEP_LIBRARY
)
3634 strcat (buf
, ", Built for Library");
3636 if (e_flags
& EF_MEP_INDEX_MASK
)
3637 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3638 e_flags
& EF_MEP_INDEX_MASK
);
3640 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3641 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3642 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3646 if (e_flags
& EF_PPC_EMB
)
3647 strcat (buf
, ", emb");
3649 if (e_flags
& EF_PPC_RELOCATABLE
)
3650 strcat (buf
, _(", relocatable"));
3652 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3653 strcat (buf
, _(", relocatable-lib"));
3657 if (e_flags
& EF_PPC64_ABI
)
3659 char abi
[] = ", abiv0";
3661 abi
[6] += e_flags
& EF_PPC64_ABI
;
3667 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3668 strcat (buf
, ", RH850 ABI");
3670 if (e_flags
& EF_V800_850E3
)
3671 strcat (buf
, ", V3 architecture");
3673 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3674 strcat (buf
, ", FPU not used");
3676 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3677 strcat (buf
, ", regmode: COMMON");
3679 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3680 strcat (buf
, ", r4 not used");
3682 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3683 strcat (buf
, ", r30 not used");
3685 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3686 strcat (buf
, ", r5 not used");
3688 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3689 strcat (buf
, ", r2 not used");
3691 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3693 switch (e_flags
& - e_flags
)
3695 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3696 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3697 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3698 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3699 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3700 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3701 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3702 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3703 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3704 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3705 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3706 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3713 case EM_CYGNUS_V850
:
3714 switch (e_flags
& EF_V850_ARCH
)
3716 case E_V850E3V5_ARCH
:
3717 strcat (buf
, ", v850e3v5");
3719 case E_V850E2V3_ARCH
:
3720 strcat (buf
, ", v850e2v3");
3723 strcat (buf
, ", v850e2");
3726 strcat (buf
, ", v850e1");
3729 strcat (buf
, ", v850e");
3732 strcat (buf
, ", v850");
3735 strcat (buf
, _(", unknown v850 architecture variant"));
3741 case EM_CYGNUS_M32R
:
3742 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3743 strcat (buf
, ", m32r");
3747 case EM_MIPS_RS3_LE
:
3748 if (e_flags
& EF_MIPS_NOREORDER
)
3749 strcat (buf
, ", noreorder");
3751 if (e_flags
& EF_MIPS_PIC
)
3752 strcat (buf
, ", pic");
3754 if (e_flags
& EF_MIPS_CPIC
)
3755 strcat (buf
, ", cpic");
3757 if (e_flags
& EF_MIPS_UCODE
)
3758 strcat (buf
, ", ugen_reserved");
3760 if (e_flags
& EF_MIPS_ABI2
)
3761 strcat (buf
, ", abi2");
3763 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3764 strcat (buf
, ", odk first");
3766 if (e_flags
& EF_MIPS_32BITMODE
)
3767 strcat (buf
, ", 32bitmode");
3769 if (e_flags
& EF_MIPS_NAN2008
)
3770 strcat (buf
, ", nan2008");
3772 if (e_flags
& EF_MIPS_FP64
)
3773 strcat (buf
, ", fp64");
3775 switch ((e_flags
& EF_MIPS_MACH
))
3777 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3778 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3779 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3780 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3781 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3782 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3783 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3784 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3785 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3786 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3787 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3788 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3789 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3790 case E_MIPS_MACH_GS464
: strcat (buf
, ", gs464"); break;
3791 case E_MIPS_MACH_GS464E
: strcat (buf
, ", gs464e"); break;
3792 case E_MIPS_MACH_GS264E
: strcat (buf
, ", gs264e"); break;
3793 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3794 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3795 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3796 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3797 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3799 /* We simply ignore the field in this case to avoid confusion:
3800 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3803 default: strcat (buf
, _(", unknown CPU")); break;
3806 switch ((e_flags
& EF_MIPS_ABI
))
3808 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3809 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3810 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3811 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3813 /* We simply ignore the field in this case to avoid confusion:
3814 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3815 This means it is likely to be an o32 file, but not for
3818 default: strcat (buf
, _(", unknown ABI")); break;
3821 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3822 strcat (buf
, ", mdmx");
3824 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3825 strcat (buf
, ", mips16");
3827 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3828 strcat (buf
, ", micromips");
3830 switch ((e_flags
& EF_MIPS_ARCH
))
3832 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3833 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3834 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3835 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3836 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3837 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3838 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3839 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3840 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3841 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3842 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3843 default: strcat (buf
, _(", unknown ISA")); break;
3848 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3852 switch (EF_NFP_MACH (e_flags
))
3854 case E_NFP_MACH_3200
:
3855 strcat (buf
, ", NFP-32xx");
3857 case E_NFP_MACH_6000
:
3858 strcat (buf
, ", NFP-6xxx");
3864 if (e_flags
& EF_RISCV_RVC
)
3865 strcat (buf
, ", RVC");
3867 if (e_flags
& EF_RISCV_RVE
)
3868 strcat (buf
, ", RVE");
3870 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3872 case EF_RISCV_FLOAT_ABI_SOFT
:
3873 strcat (buf
, ", soft-float ABI");
3876 case EF_RISCV_FLOAT_ABI_SINGLE
:
3877 strcat (buf
, ", single-float ABI");
3880 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3881 strcat (buf
, ", double-float ABI");
3884 case EF_RISCV_FLOAT_ABI_QUAD
:
3885 strcat (buf
, ", quad-float ABI");
3891 switch ((e_flags
& EF_SH_MACH_MASK
))
3893 case EF_SH1
: strcat (buf
, ", sh1"); break;
3894 case EF_SH2
: strcat (buf
, ", sh2"); break;
3895 case EF_SH3
: strcat (buf
, ", sh3"); break;
3896 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3897 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3898 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3899 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3900 case EF_SH4
: strcat (buf
, ", sh4"); break;
3901 case EF_SH5
: strcat (buf
, ", sh5"); break;
3902 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3903 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3904 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3905 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3906 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3907 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3908 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3909 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3910 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3911 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3912 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3913 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3914 default: strcat (buf
, _(", unknown ISA")); break;
3917 if (e_flags
& EF_SH_PIC
)
3918 strcat (buf
, ", pic");
3920 if (e_flags
& EF_SH_FDPIC
)
3921 strcat (buf
, ", fdpic");
3925 if (e_flags
& EF_OR1K_NODELAY
)
3926 strcat (buf
, ", no delay");
3930 if (e_flags
& EF_SPARC_32PLUS
)
3931 strcat (buf
, ", v8+");
3933 if (e_flags
& EF_SPARC_SUN_US1
)
3934 strcat (buf
, ", ultrasparcI");
3936 if (e_flags
& EF_SPARC_SUN_US3
)
3937 strcat (buf
, ", ultrasparcIII");
3939 if (e_flags
& EF_SPARC_HAL_R1
)
3940 strcat (buf
, ", halr1");
3942 if (e_flags
& EF_SPARC_LEDATA
)
3943 strcat (buf
, ", ledata");
3945 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3946 strcat (buf
, ", tso");
3948 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3949 strcat (buf
, ", pso");
3951 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3952 strcat (buf
, ", rmo");
3956 switch (e_flags
& EF_PARISC_ARCH
)
3958 case EFA_PARISC_1_0
:
3959 strcpy (buf
, ", PA-RISC 1.0");
3961 case EFA_PARISC_1_1
:
3962 strcpy (buf
, ", PA-RISC 1.1");
3964 case EFA_PARISC_2_0
:
3965 strcpy (buf
, ", PA-RISC 2.0");
3970 if (e_flags
& EF_PARISC_TRAPNIL
)
3971 strcat (buf
, ", trapnil");
3972 if (e_flags
& EF_PARISC_EXT
)
3973 strcat (buf
, ", ext");
3974 if (e_flags
& EF_PARISC_LSB
)
3975 strcat (buf
, ", lsb");
3976 if (e_flags
& EF_PARISC_WIDE
)
3977 strcat (buf
, ", wide");
3978 if (e_flags
& EF_PARISC_NO_KABP
)
3979 strcat (buf
, ", no kabp");
3980 if (e_flags
& EF_PARISC_LAZYSWAP
)
3981 strcat (buf
, ", lazyswap");
3986 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3987 strcat (buf
, ", new calling convention");
3989 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3990 strcat (buf
, ", gnu calling convention");
3994 if ((e_flags
& EF_IA_64_ABI64
))
3995 strcat (buf
, ", 64-bit");
3997 strcat (buf
, ", 32-bit");
3998 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3999 strcat (buf
, ", reduced fp model");
4000 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
4001 strcat (buf
, ", no function descriptors, constant gp");
4002 else if ((e_flags
& EF_IA_64_CONS_GP
))
4003 strcat (buf
, ", constant gp");
4004 if ((e_flags
& EF_IA_64_ABSOLUTE
))
4005 strcat (buf
, ", absolute");
4006 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4008 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
4009 strcat (buf
, ", vms_linkages");
4010 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
4012 case EF_IA_64_VMS_COMCOD_SUCCESS
:
4014 case EF_IA_64_VMS_COMCOD_WARNING
:
4015 strcat (buf
, ", warning");
4017 case EF_IA_64_VMS_COMCOD_ERROR
:
4018 strcat (buf
, ", error");
4020 case EF_IA_64_VMS_COMCOD_ABORT
:
4021 strcat (buf
, ", abort");
4024 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
4025 e_flags
& EF_IA_64_VMS_COMCOD
);
4026 strcat (buf
, ", <unknown>");
4032 if ((e_flags
& EF_VAX_NONPIC
))
4033 strcat (buf
, ", non-PIC");
4034 if ((e_flags
& EF_VAX_DFLOAT
))
4035 strcat (buf
, ", D-Float");
4036 if ((e_flags
& EF_VAX_GFLOAT
))
4037 strcat (buf
, ", G-Float");
4041 if (e_flags
& EF_VISIUM_ARCH_MCM
)
4042 strcat (buf
, ", mcm");
4043 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
4044 strcat (buf
, ", mcm24");
4045 if (e_flags
& EF_VISIUM_ARCH_GR6
)
4046 strcat (buf
, ", gr6");
4050 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
4052 case E_FLAG_RL78_ANY_CPU
: break;
4053 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
4054 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
4055 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
4057 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
4058 strcat (buf
, ", 64-bit doubles");
4062 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
4063 strcat (buf
, ", 64-bit doubles");
4064 if (e_flags
& E_FLAG_RX_DSP
)
4065 strcat (buf
, ", dsp");
4066 if (e_flags
& E_FLAG_RX_PID
)
4067 strcat (buf
, ", pid");
4068 if (e_flags
& E_FLAG_RX_ABI
)
4069 strcat (buf
, ", RX ABI");
4070 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
4071 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
4072 ? ", uses String instructions" : ", bans String instructions");
4073 if (e_flags
& E_FLAG_RX_V2
)
4074 strcat (buf
, ", V2");
4075 if (e_flags
& E_FLAG_RX_V3
)
4076 strcat (buf
, ", V3");
4080 if (e_flags
& EF_S390_HIGH_GPRS
)
4081 strcat (buf
, ", highgprs");
4085 if ((e_flags
& EF_C6000_REL
))
4086 strcat (buf
, ", relocatable module");
4090 strcat (buf
, _(": architecture variant: "));
4091 switch (e_flags
& EF_MSP430_MACH
)
4093 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
4094 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
4095 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
4096 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
4097 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
4098 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
4099 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
4100 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
4101 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
4102 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
4103 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
4104 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
4105 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
4106 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
4107 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
4109 strcat (buf
, _(": unknown")); break;
4112 if (e_flags
& ~ EF_MSP430_MACH
)
4113 strcat (buf
, _(": unknown extra flag bits also present"));
4117 switch (e_flags
& EF_Z80_MACH_MSK
)
4119 case EF_Z80_MACH_Z80
: strcat (buf
, ", Z80"); break;
4120 case EF_Z80_MACH_Z180
: strcat (buf
, ", Z180"); break;
4121 case EF_Z80_MACH_R800
: strcat (buf
, ", R800"); break;
4122 case EF_Z80_MACH_EZ80_Z80
: strcat (buf
, ", EZ80"); break;
4123 case EF_Z80_MACH_EZ80_ADL
: strcat (buf
, ", EZ80, ADL"); break;
4124 case EF_Z80_MACH_GBZ80
: strcat (buf
, ", GBZ80"); break;
4125 case EF_Z80_MACH_Z80N
: strcat (buf
, ", Z80N"); break;
4127 strcat (buf
, _(", unknown")); break;
4131 if (EF_LOONGARCH_IS_LP64 (e_flags
))
4132 strcat (buf
, ", LP64");
4133 else if (EF_LOONGARCH_IS_ILP32 (e_flags
))
4134 strcat (buf
, ", ILP32");
4136 if (EF_LOONGARCH_IS_SOFT_FLOAT (e_flags
))
4137 strcat (buf
, ", SOFT-FLOAT");
4138 else if (EF_LOONGARCH_IS_SINGLE_FLOAT (e_flags
))
4139 strcat (buf
, ", SINGLE-FLOAT");
4140 else if (EF_LOONGARCH_IS_DOUBLE_FLOAT (e_flags
))
4141 strcat (buf
, ", DOUBLE-FLOAT");
4151 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
4153 static char buff
[32];
4157 case ELFOSABI_NONE
: return "UNIX - System V";
4158 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
4159 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
4160 case ELFOSABI_GNU
: return "UNIX - GNU";
4161 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
4162 case ELFOSABI_AIX
: return "UNIX - AIX";
4163 case ELFOSABI_IRIX
: return "UNIX - IRIX";
4164 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
4165 case ELFOSABI_TRU64
: return "UNIX - TRU64";
4166 case ELFOSABI_MODESTO
: return "Novell - Modesto";
4167 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
4168 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
4169 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
4170 case ELFOSABI_AROS
: return "AROS";
4171 case ELFOSABI_FENIXOS
: return "FenixOS";
4172 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
4173 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
4176 switch (filedata
->file_header
.e_machine
)
4181 case ELFOSABI_ARM
: return "ARM";
4182 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
4193 case ELFOSABI_STANDALONE
: return _("Standalone App");
4202 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
4203 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
4212 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
4218 get_aarch64_segment_type (unsigned long type
)
4222 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
4223 default: return NULL
;
4228 get_arm_segment_type (unsigned long type
)
4232 case PT_ARM_EXIDX
: return "EXIDX";
4233 default: return NULL
;
4238 get_s390_segment_type (unsigned long type
)
4242 case PT_S390_PGSTE
: return "S390_PGSTE";
4243 default: return NULL
;
4248 get_mips_segment_type (unsigned long type
)
4252 case PT_MIPS_REGINFO
: return "REGINFO";
4253 case PT_MIPS_RTPROC
: return "RTPROC";
4254 case PT_MIPS_OPTIONS
: return "OPTIONS";
4255 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
4256 default: return NULL
;
4261 get_parisc_segment_type (unsigned long type
)
4265 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
4266 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
4267 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
4268 default: return NULL
;
4273 get_ia64_segment_type (unsigned long type
)
4277 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
4278 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
4279 default: return NULL
;
4284 get_tic6x_segment_type (unsigned long type
)
4288 case PT_C6000_PHATTR
: return "C6000_PHATTR";
4289 default: return NULL
;
4294 get_riscv_segment_type (unsigned long type
)
4298 case PT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4299 default: return NULL
;
4304 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
4306 if (e_machine
== EM_PARISC
)
4309 case PT_HP_TLS
: return "HP_TLS";
4310 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
4311 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
4312 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
4313 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
4314 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
4315 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
4316 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
4317 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
4318 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
4319 case PT_HP_PARALLEL
: return "HP_PARALLEL";
4320 case PT_HP_FASTBIND
: return "HP_FASTBIND";
4321 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
4322 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
4323 case PT_HP_STACK
: return "HP_STACK";
4324 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
4325 default: return NULL
;
4328 if (e_machine
== EM_IA_64
)
4331 case PT_HP_TLS
: return "HP_TLS";
4332 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
4333 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
4334 case PT_IA_64_HP_STACK
: return "HP_STACK";
4335 default: return NULL
;
4342 get_solaris_segment_type (unsigned long type
)
4346 case 0x6464e550: return "PT_SUNW_UNWIND";
4347 case 0x6474e550: return "PT_SUNW_EH_FRAME";
4348 case 0x6ffffff7: return "PT_LOSUNW";
4349 case 0x6ffffffa: return "PT_SUNWBSS";
4350 case 0x6ffffffb: return "PT_SUNWSTACK";
4351 case 0x6ffffffc: return "PT_SUNWDTRACE";
4352 case 0x6ffffffd: return "PT_SUNWCAP";
4353 case 0x6fffffff: return "PT_HISUNW";
4354 default: return NULL
;
4359 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
4361 static char buff
[32];
4365 case PT_NULL
: return "NULL";
4366 case PT_LOAD
: return "LOAD";
4367 case PT_DYNAMIC
: return "DYNAMIC";
4368 case PT_INTERP
: return "INTERP";
4369 case PT_NOTE
: return "NOTE";
4370 case PT_SHLIB
: return "SHLIB";
4371 case PT_PHDR
: return "PHDR";
4372 case PT_TLS
: return "TLS";
4373 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
4374 case PT_GNU_STACK
: return "GNU_STACK";
4375 case PT_GNU_RELRO
: return "GNU_RELRO";
4376 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
4378 case PT_OPENBSD_RANDOMIZE
: return "OPENBSD_RANDOMIZE";
4379 case PT_OPENBSD_WXNEEDED
: return "OPENBSD_WXNEEDED";
4380 case PT_OPENBSD_BOOTDATA
: return "OPENBSD_BOOTDATA";
4383 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
4385 const char * result
;
4387 switch (filedata
->file_header
.e_machine
)
4390 result
= get_aarch64_segment_type (p_type
);
4393 result
= get_arm_segment_type (p_type
);
4396 case EM_MIPS_RS3_LE
:
4397 result
= get_mips_segment_type (p_type
);
4400 result
= get_parisc_segment_type (p_type
);
4403 result
= get_ia64_segment_type (p_type
);
4406 result
= get_tic6x_segment_type (p_type
);
4410 result
= get_s390_segment_type (p_type
);
4413 result
= get_riscv_segment_type (p_type
);
4423 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
4425 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
4427 const char * result
= NULL
;
4429 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
4432 case ELFOSABI_FREEBSD
:
4433 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
4435 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
4440 result
= get_hpux_segment_type (p_type
,
4441 filedata
->file_header
.e_machine
);
4443 case ELFOSABI_SOLARIS
:
4444 result
= get_solaris_segment_type (p_type
);
4452 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4455 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4462 get_arc_section_type_name (unsigned int sh_type
)
4466 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4474 get_mips_section_type_name (unsigned int sh_type
)
4478 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4479 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4480 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4481 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4482 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4483 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4484 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4485 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4486 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4487 case SHT_MIPS_RELD
: return "MIPS_RELD";
4488 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4489 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4490 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4491 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4492 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4493 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4494 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4495 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4496 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4497 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4498 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4499 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4500 case SHT_MIPS_LINE
: return "MIPS_LINE";
4501 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4502 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4503 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4504 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4505 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4506 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4507 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4508 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4509 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4510 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4511 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4512 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4513 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4514 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4515 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4516 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4517 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4518 case SHT_MIPS_XHASH
: return "MIPS_XHASH";
4526 get_parisc_section_type_name (unsigned int sh_type
)
4530 case SHT_PARISC_EXT
: return "PARISC_EXT";
4531 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4532 case SHT_PARISC_DOC
: return "PARISC_DOC";
4533 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4534 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4535 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4536 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4537 default: return NULL
;
4542 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4544 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4545 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4546 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4550 case SHT_IA_64_EXT
: return "IA_64_EXT";
4551 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4552 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4553 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4554 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4555 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4556 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4557 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4558 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4559 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4567 get_x86_64_section_type_name (unsigned int sh_type
)
4571 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4572 default: return NULL
;
4577 get_aarch64_section_type_name (unsigned int sh_type
)
4581 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4582 default: return NULL
;
4587 get_arm_section_type_name (unsigned int sh_type
)
4591 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4592 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4593 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4594 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4595 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4596 default: return NULL
;
4601 get_tic6x_section_type_name (unsigned int sh_type
)
4605 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4606 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4607 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4608 case SHT_TI_ICODE
: return "TI_ICODE";
4609 case SHT_TI_XREF
: return "TI_XREF";
4610 case SHT_TI_HANDLER
: return "TI_HANDLER";
4611 case SHT_TI_INITINFO
: return "TI_INITINFO";
4612 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4613 default: return NULL
;
4618 get_msp430_section_type_name (unsigned int sh_type
)
4622 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4623 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4624 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4625 default: return NULL
;
4630 get_nfp_section_type_name (unsigned int sh_type
)
4634 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4635 case SHT_NFP_INITREG
: return "NFP_INITREG";
4636 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4637 default: return NULL
;
4642 get_v850_section_type_name (unsigned int sh_type
)
4646 case SHT_V850_SCOMMON
: return "V850 Small Common";
4647 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4648 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4649 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4650 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4651 default: return NULL
;
4656 get_riscv_section_type_name (unsigned int sh_type
)
4660 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4661 default: return NULL
;
4666 get_csky_section_type_name (unsigned int sh_type
)
4670 case SHT_CSKY_ATTRIBUTES
: return "CSKY_ATTRIBUTES";
4671 default: return NULL
;
4676 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4678 static char buff
[32];
4679 const char * result
;
4683 case SHT_NULL
: return "NULL";
4684 case SHT_PROGBITS
: return "PROGBITS";
4685 case SHT_SYMTAB
: return "SYMTAB";
4686 case SHT_STRTAB
: return "STRTAB";
4687 case SHT_RELA
: return "RELA";
4688 case SHT_RELR
: return "RELR";
4689 case SHT_HASH
: return "HASH";
4690 case SHT_DYNAMIC
: return "DYNAMIC";
4691 case SHT_NOTE
: return "NOTE";
4692 case SHT_NOBITS
: return "NOBITS";
4693 case SHT_REL
: return "REL";
4694 case SHT_SHLIB
: return "SHLIB";
4695 case SHT_DYNSYM
: return "DYNSYM";
4696 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4697 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4698 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4699 case SHT_GNU_HASH
: return "GNU_HASH";
4700 case SHT_GROUP
: return "GROUP";
4701 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4702 case SHT_GNU_verdef
: return "VERDEF";
4703 case SHT_GNU_verneed
: return "VERNEED";
4704 case SHT_GNU_versym
: return "VERSYM";
4705 case 0x6ffffff0: return "VERSYM";
4706 case 0x6ffffffc: return "VERDEF";
4707 case 0x7ffffffd: return "AUXILIARY";
4708 case 0x7fffffff: return "FILTER";
4709 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4712 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4714 switch (filedata
->file_header
.e_machine
)
4717 case EM_ARC_COMPACT
:
4718 case EM_ARC_COMPACT2
:
4719 result
= get_arc_section_type_name (sh_type
);
4722 case EM_MIPS_RS3_LE
:
4723 result
= get_mips_section_type_name (sh_type
);
4726 result
= get_parisc_section_type_name (sh_type
);
4729 result
= get_ia64_section_type_name (filedata
, sh_type
);
4734 result
= get_x86_64_section_type_name (sh_type
);
4737 result
= get_aarch64_section_type_name (sh_type
);
4740 result
= get_arm_section_type_name (sh_type
);
4743 result
= get_tic6x_section_type_name (sh_type
);
4746 result
= get_msp430_section_type_name (sh_type
);
4749 result
= get_nfp_section_type_name (sh_type
);
4753 case EM_CYGNUS_V850
:
4754 result
= get_v850_section_type_name (sh_type
);
4757 result
= get_riscv_section_type_name (sh_type
);
4760 result
= get_csky_section_type_name (sh_type
);
4770 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4772 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4774 switch (filedata
->file_header
.e_machine
)
4777 result
= get_ia64_section_type_name (filedata
, sh_type
);
4780 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4781 result
= get_solaris_section_type (sh_type
);
4786 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4787 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4788 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4789 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4801 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4803 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4805 switch (filedata
->file_header
.e_machine
)
4809 case EM_CYGNUS_V850
:
4810 result
= get_v850_section_type_name (sh_type
);
4820 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4823 /* This message is probably going to be displayed in a 15
4824 character wide field, so put the hex value first. */
4825 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4831 enum long_option_values
4833 OPTION_DEBUG_DUMP
= 512,
4843 OPTION_WITH_SYMBOL_VERSIONS
,
4844 OPTION_RECURSE_LIMIT
,
4845 OPTION_NO_RECURSE_LIMIT
,
4846 OPTION_NO_DEMANGLING
,
4850 static struct option options
[] =
4852 /* Note - This table is alpha-sorted on the 'val'
4853 field in order to make adding new options easier. */
4854 {"arch-specific", no_argument
, 0, 'A'},
4855 {"all", no_argument
, 0, 'a'},
4856 {"demangle", optional_argument
, 0, 'C'},
4857 {"archive-index", no_argument
, 0, 'c'},
4858 {"use-dynamic", no_argument
, 0, 'D'},
4859 {"dynamic", no_argument
, 0, 'd'},
4860 {"headers", no_argument
, 0, 'e'},
4861 {"section-groups", no_argument
, 0, 'g'},
4862 {"help", no_argument
, 0, 'H'},
4863 {"file-header", no_argument
, 0, 'h'},
4864 {"histogram", no_argument
, 0, 'I'},
4865 {"lint", no_argument
, 0, 'L'},
4866 {"enable-checks", no_argument
, 0, 'L'},
4867 {"program-headers", no_argument
, 0, 'l'},
4868 {"segments", no_argument
, 0, 'l'},
4869 {"full-section-name",no_argument
, 0, 'N'},
4870 {"notes", no_argument
, 0, 'n'},
4871 {"process-links", no_argument
, 0, 'P'},
4872 {"string-dump", required_argument
, 0, 'p'},
4873 {"relocated-dump", required_argument
, 0, 'R'},
4874 {"relocs", no_argument
, 0, 'r'},
4875 {"section-headers", no_argument
, 0, 'S'},
4876 {"sections", no_argument
, 0, 'S'},
4877 {"symbols", no_argument
, 0, 's'},
4878 {"syms", no_argument
, 0, 's'},
4879 {"silent-truncation",no_argument
, 0, 'T'},
4880 {"section-details", no_argument
, 0, 't'},
4881 {"unicode", required_argument
, NULL
, 'U'},
4882 {"unwind", no_argument
, 0, 'u'},
4883 {"version-info", no_argument
, 0, 'V'},
4884 {"version", no_argument
, 0, 'v'},
4885 {"wide", no_argument
, 0, 'W'},
4886 {"hex-dump", required_argument
, 0, 'x'},
4887 {"decompress", no_argument
, 0, 'z'},
4889 {"no-demangle", no_argument
, 0, OPTION_NO_DEMANGLING
},
4890 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
4891 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
4892 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
4893 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4894 {"lto-syms", no_argument
, 0, OPTION_LTO_SYMS
},
4895 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4896 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4897 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4898 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4899 #ifdef ENABLE_LIBCTF
4900 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
4901 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
4902 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
4903 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
4905 {"sym-base", optional_argument
, 0, OPTION_SYM_BASE
},
4907 {0, no_argument
, 0, 0}
4911 usage (FILE * stream
)
4913 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4914 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4915 fprintf (stream
, _(" Options are:\n"));
4916 fprintf (stream
, _("\
4917 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
4918 fprintf (stream
, _("\
4919 -h --file-header Display the ELF file header\n"));
4920 fprintf (stream
, _("\
4921 -l --program-headers Display the program headers\n"));
4922 fprintf (stream
, _("\
4923 --segments An alias for --program-headers\n"));
4924 fprintf (stream
, _("\
4925 -S --section-headers Display the sections' header\n"));
4926 fprintf (stream
, _("\
4927 --sections An alias for --section-headers\n"));
4928 fprintf (stream
, _("\
4929 -g --section-groups Display the section groups\n"));
4930 fprintf (stream
, _("\
4931 -t --section-details Display the section details\n"));
4932 fprintf (stream
, _("\
4933 -e --headers Equivalent to: -h -l -S\n"));
4934 fprintf (stream
, _("\
4935 -s --syms Display the symbol table\n"));
4936 fprintf (stream
, _("\
4937 --symbols An alias for --syms\n"));
4938 fprintf (stream
, _("\
4939 --dyn-syms Display the dynamic symbol table\n"));
4940 fprintf (stream
, _("\
4941 --lto-syms Display LTO symbol tables\n"));
4942 fprintf (stream
, _("\
4943 --sym-base=[0|8|10|16] \n\
4944 Force base for symbol sizes. The options are \n\
4945 mixed (the default), octal, decimal, hexadecimal.\n"));
4946 fprintf (stream
, _("\
4947 -C --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
4948 The STYLE, if specified, can be `auto' (the default),\n\
4949 `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
4951 fprintf (stream
, _("\
4952 --no-demangle Do not demangle low-level symbol names. (default)\n"));
4953 fprintf (stream
, _("\
4954 --recurse-limit Enable a demangling recursion limit. (default)\n"));
4955 fprintf (stream
, _("\
4956 --no-recurse-limit Disable a demangling recursion limit\n"));
4957 fprintf (stream
, _("\
4958 -U[dlexhi] --unicode=[default|locale|escape|hex|highlight|invalid]\n\
4959 Display unicode characters as determined by the current locale\n\
4960 (default), escape sequences, \"<hex sequences>\", highlighted\n\
4961 escape sequences, or treat them as invalid and display as\n\
4962 \"{hex sequences}\"\n"));
4963 fprintf (stream
, _("\
4964 -n --notes Display the core notes (if present)\n"));
4965 fprintf (stream
, _("\
4966 -r --relocs Display the relocations (if present)\n"));
4967 fprintf (stream
, _("\
4968 -u --unwind Display the unwind info (if present)\n"));
4969 fprintf (stream
, _("\
4970 -d --dynamic Display the dynamic section (if present)\n"));
4971 fprintf (stream
, _("\
4972 -V --version-info Display the version sections (if present)\n"));
4973 fprintf (stream
, _("\
4974 -A --arch-specific Display architecture specific information (if any)\n"));
4975 fprintf (stream
, _("\
4976 -c --archive-index Display the symbol/file index in an archive\n"));
4977 fprintf (stream
, _("\
4978 -D --use-dynamic Use the dynamic section info when displaying symbols\n"));
4979 fprintf (stream
, _("\
4980 -L --lint|--enable-checks\n\
4981 Display warning messages for possible problems\n"));
4982 fprintf (stream
, _("\
4983 -x --hex-dump=<number|name>\n\
4984 Dump the contents of section <number|name> as bytes\n"));
4985 fprintf (stream
, _("\
4986 -p --string-dump=<number|name>\n\
4987 Dump the contents of section <number|name> as strings\n"));
4988 fprintf (stream
, _("\
4989 -R --relocated-dump=<number|name>\n\
4990 Dump the relocated contents of section <number|name>\n"));
4991 fprintf (stream
, _("\
4992 -z --decompress Decompress section before dumping it\n"));
4993 fprintf (stream
, _("\
4994 -w --debug-dump[a/=abbrev, A/=addr, r/=aranges, c/=cu_index, L/=decodedline,\n\
4995 f/=frames, F/=frames-interp, g/=gdb_index, i/=info, o/=loc,\n\
4996 m/=macro, p/=pubnames, t/=pubtypes, R/=Ranges, l/=rawline,\n\
4997 s/=str, O/=str-offsets, u/=trace_abbrev, T/=trace_aranges,\n\
4999 Display the contents of DWARF debug sections\n"));
5000 fprintf (stream
, _("\
5001 -wk --debug-dump=links Display the contents of sections that link to separate\n\
5002 debuginfo files\n"));
5003 fprintf (stream
, _("\
5004 -P --process-links Display the contents of non-debug sections in separate\n\
5005 debuginfo files. (Implies -wK)\n"));
5006 #if DEFAULT_FOR_FOLLOW_LINKS
5007 fprintf (stream
, _("\
5008 -wK --debug-dump=follow-links\n\
5009 Follow links to separate debug info files (default)\n"));
5010 fprintf (stream
, _("\
5011 -wN --debug-dump=no-follow-links\n\
5012 Do not follow links to separate debug info files\n"));
5014 fprintf (stream
, _("\
5015 -wK --debug-dump=follow-links\n\
5016 Follow links to separate debug info files\n"));
5017 fprintf (stream
, _("\
5018 -wN --debug-dump=no-follow-links\n\
5019 Do not follow links to separate debug info files\n\
5022 fprintf (stream
, _("\
5023 --dwarf-depth=N Do not display DIEs at depth N or greater\n"));
5024 fprintf (stream
, _("\
5025 --dwarf-start=N Display DIEs starting at offset N\n"));
5026 #ifdef ENABLE_LIBCTF
5027 fprintf (stream
, _("\
5028 --ctf=<number|name> Display CTF info from section <number|name>\n"));
5029 fprintf (stream
, _("\
5030 --ctf-parent=<name> Use CTF archive member <name> as the CTF parent\n"));
5031 fprintf (stream
, _("\
5032 --ctf-symbols=<number|name>\n\
5033 Use section <number|name> as the CTF external symtab\n"));
5034 fprintf (stream
, _("\
5035 --ctf-strings=<number|name>\n\
5036 Use section <number|name> as the CTF external strtab\n"));
5039 #ifdef SUPPORT_DISASSEMBLY
5040 fprintf (stream
, _("\
5041 -i --instruction-dump=<number|name>\n\
5042 Disassemble the contents of section <number|name>\n"));
5044 fprintf (stream
, _("\
5045 -I --histogram Display histogram of bucket list lengths\n"));
5046 fprintf (stream
, _("\
5047 -W --wide Allow output width to exceed 80 characters\n"));
5048 fprintf (stream
, _("\
5049 -T --silent-truncation If a symbol name is truncated, do not add [...] suffix\n"));
5050 fprintf (stream
, _("\
5051 @<file> Read options from <file>\n"));
5052 fprintf (stream
, _("\
5053 -H --help Display this information\n"));
5054 fprintf (stream
, _("\
5055 -v --version Display the version number of readelf\n"));
5057 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
5058 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
5060 exit (stream
== stdout
? 0 : 1);
5063 /* Record the fact that the user wants the contents of section number
5064 SECTION to be displayed using the method(s) encoded as flags bits
5065 in TYPE. Note, TYPE can be zero if we are creating the array for
5069 request_dump_bynumber (struct dump_data
*dumpdata
,
5070 unsigned int section
, dump_type type
)
5072 if (section
>= dumpdata
->num_dump_sects
)
5074 dump_type
* new_dump_sects
;
5076 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
5077 sizeof (* new_dump_sects
));
5079 if (new_dump_sects
== NULL
)
5080 error (_("Out of memory allocating dump request table.\n"));
5083 if (dumpdata
->dump_sects
)
5085 /* Copy current flag settings. */
5086 memcpy (new_dump_sects
, dumpdata
->dump_sects
,
5087 dumpdata
->num_dump_sects
* sizeof (* new_dump_sects
));
5089 free (dumpdata
->dump_sects
);
5092 dumpdata
->dump_sects
= new_dump_sects
;
5093 dumpdata
->num_dump_sects
= section
+ 1;
5097 if (dumpdata
->dump_sects
)
5098 dumpdata
->dump_sects
[section
] |= type
;
5101 /* Request a dump by section name. */
5104 request_dump_byname (const char * section
, dump_type type
)
5106 struct dump_list_entry
* new_request
;
5108 new_request
= (struct dump_list_entry
*)
5109 malloc (sizeof (struct dump_list_entry
));
5111 error (_("Out of memory allocating dump request table.\n"));
5113 new_request
->name
= strdup (section
);
5114 if (!new_request
->name
)
5115 error (_("Out of memory allocating dump request table.\n"));
5117 new_request
->type
= type
;
5119 new_request
->next
= dump_sects_byname
;
5120 dump_sects_byname
= new_request
;
5124 request_dump (struct dump_data
*dumpdata
, dump_type type
)
5130 section
= strtoul (optarg
, & cp
, 0);
5132 if (! *cp
&& section
>= 0)
5133 request_dump_bynumber (dumpdata
, section
, type
);
5135 request_dump_byname (optarg
, type
);
5139 parse_args (struct dump_data
*dumpdata
, int argc
, char ** argv
)
5146 while ((c
= getopt_long
5147 (argc
, argv
, "ACDHILNPR:STU:VWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
5165 do_section_groups
= true;
5168 do_histogram
= true;
5174 do_section_groups
= true;
5179 do_section_details
= true;
5190 do_using_dynamic
= true;
5214 do_histogram
= true;
5220 do_archive_index
= true;
5226 process_links
= true;
5227 do_follow_links
= true;
5230 request_dump (dumpdata
, HEX_DUMP
);
5233 request_dump (dumpdata
, STRING_DUMP
);
5236 request_dump (dumpdata
, RELOC_DUMP
);
5239 decompress_dumps
= true;
5245 do_debugging
= true;
5246 dwarf_select_sections_all ();
5250 do_debugging
= false;
5251 dwarf_select_sections_by_letters (optarg
);
5254 case OPTION_DEBUG_DUMP
:
5258 do_debugging
= true;
5259 dwarf_select_sections_all ();
5263 do_debugging
= false;
5264 dwarf_select_sections_by_names (optarg
);
5267 case OPTION_DWARF_DEPTH
:
5271 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
5274 case OPTION_DWARF_START
:
5278 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
5281 case OPTION_DWARF_CHECK
:
5284 case OPTION_CTF_DUMP
:
5286 request_dump (dumpdata
, CTF_DUMP
);
5288 case OPTION_CTF_SYMBOLS
:
5289 free (dump_ctf_symtab_name
);
5290 dump_ctf_symtab_name
= strdup (optarg
);
5292 case OPTION_CTF_STRINGS
:
5293 free (dump_ctf_strtab_name
);
5294 dump_ctf_strtab_name
= strdup (optarg
);
5296 case OPTION_CTF_PARENT
:
5297 free (dump_ctf_parent_name
);
5298 dump_ctf_parent_name
= strdup (optarg
);
5300 case OPTION_DYN_SYMS
:
5303 case OPTION_LTO_SYMS
:
5306 #ifdef SUPPORT_DISASSEMBLY
5308 request_dump (dumpdata
, DISASS_DUMP
);
5312 print_version (program_name
);
5321 do_not_show_symbol_truncation
= true;
5327 enum demangling_styles style
;
5329 style
= cplus_demangle_name_to_style (optarg
);
5330 if (style
== unknown_demangling
)
5331 error (_("unknown demangling style `%s'"), optarg
);
5333 cplus_demangle_set_style (style
);
5336 case OPTION_NO_DEMANGLING
:
5337 do_demangle
= false;
5339 case OPTION_RECURSE_LIMIT
:
5340 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
5342 case OPTION_NO_RECURSE_LIMIT
:
5343 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
5345 case OPTION_WITH_SYMBOL_VERSIONS
:
5346 /* Ignored for backward compatibility. */
5351 error (_("Missing arg to -U/--unicode")); /* Can this happen ? */
5352 else if (streq (optarg
, "default") || streq (optarg
, "d"))
5353 unicode_display
= unicode_default
;
5354 else if (streq (optarg
, "locale") || streq (optarg
, "l"))
5355 unicode_display
= unicode_locale
;
5356 else if (streq (optarg
, "escape") || streq (optarg
, "e"))
5357 unicode_display
= unicode_escape
;
5358 else if (streq (optarg
, "invalid") || streq (optarg
, "i"))
5359 unicode_display
= unicode_invalid
;
5360 else if (streq (optarg
, "hex") || streq (optarg
, "x"))
5361 unicode_display
= unicode_hex
;
5362 else if (streq (optarg
, "highlight") || streq (optarg
, "h"))
5363 unicode_display
= unicode_highlight
;
5365 error (_("invalid argument to -U/--unicode: %s"), optarg
);
5368 case OPTION_SYM_BASE
:
5372 sym_base
= strtoul (optarg
, NULL
, 0);
5389 /* xgettext:c-format */
5390 error (_("Invalid option '-%c'\n"), c
);
5397 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
5398 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
5399 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
5400 && !do_section_groups
&& !do_archive_index
5401 && !do_dyn_syms
&& !do_lto_syms
)
5406 do_dynamic
= do_syms
= do_reloc
= do_unwind
= do_sections
= true;
5407 do_segments
= do_header
= do_dump
= do_version
= true;
5408 do_histogram
= do_debugging
= do_arch
= do_notes
= true;
5409 do_section_groups
= do_archive_index
= do_dyn_syms
= true;
5418 get_elf_class (unsigned int elf_class
)
5420 static char buff
[32];
5424 case ELFCLASSNONE
: return _("none");
5425 case ELFCLASS32
: return "ELF32";
5426 case ELFCLASS64
: return "ELF64";
5428 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
5434 get_data_encoding (unsigned int encoding
)
5436 static char buff
[32];
5440 case ELFDATANONE
: return _("none");
5441 case ELFDATA2LSB
: return _("2's complement, little endian");
5442 case ELFDATA2MSB
: return _("2's complement, big endian");
5444 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
5449 /* Decode the data held in 'filedata->file_header'. */
5452 process_file_header (Filedata
* filedata
)
5454 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
5456 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
5457 || header
->e_ident
[EI_MAG1
] != ELFMAG1
5458 || header
->e_ident
[EI_MAG2
] != ELFMAG2
5459 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
5462 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
5466 if (! filedata
->is_separate
)
5467 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
5473 if (filedata
->is_separate
)
5474 printf (_("ELF Header in linked file '%s':\n"), filedata
->file_name
);
5476 printf (_("ELF Header:\n"));
5477 printf (_(" Magic: "));
5478 for (i
= 0; i
< EI_NIDENT
; i
++)
5479 printf ("%2.2x ", header
->e_ident
[i
]);
5481 printf (_(" Class: %s\n"),
5482 get_elf_class (header
->e_ident
[EI_CLASS
]));
5483 printf (_(" Data: %s\n"),
5484 get_data_encoding (header
->e_ident
[EI_DATA
]));
5485 printf (_(" Version: %d%s\n"),
5486 header
->e_ident
[EI_VERSION
],
5487 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
5489 : (header
->e_ident
[EI_VERSION
] != EV_NONE
5492 printf (_(" OS/ABI: %s\n"),
5493 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
5494 printf (_(" ABI Version: %d\n"),
5495 header
->e_ident
[EI_ABIVERSION
]);
5496 printf (_(" Type: %s\n"),
5497 get_file_type (filedata
));
5498 printf (_(" Machine: %s\n"),
5499 get_machine_name (header
->e_machine
));
5500 printf (_(" Version: 0x%lx\n"),
5503 printf (_(" Entry point address: "));
5504 print_vma (header
->e_entry
, PREFIX_HEX
);
5505 printf (_("\n Start of program headers: "));
5506 print_vma (header
->e_phoff
, DEC
);
5507 printf (_(" (bytes into file)\n Start of section headers: "));
5508 print_vma (header
->e_shoff
, DEC
);
5509 printf (_(" (bytes into file)\n"));
5511 printf (_(" Flags: 0x%lx%s\n"),
5513 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
5514 printf (_(" Size of this header: %u (bytes)\n"),
5516 printf (_(" Size of program headers: %u (bytes)\n"),
5517 header
->e_phentsize
);
5518 printf (_(" Number of program headers: %u"),
5520 if (filedata
->section_headers
!= NULL
5521 && header
->e_phnum
== PN_XNUM
5522 && filedata
->section_headers
[0].sh_info
!= 0)
5524 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
5525 printf (" (%u)", header
->e_phnum
);
5527 putc ('\n', stdout
);
5528 printf (_(" Size of section headers: %u (bytes)\n"),
5529 header
->e_shentsize
);
5530 printf (_(" Number of section headers: %u"),
5532 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
5534 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5535 printf (" (%u)", header
->e_shnum
);
5537 putc ('\n', stdout
);
5538 printf (_(" Section header string table index: %u"),
5539 header
->e_shstrndx
);
5540 if (filedata
->section_headers
!= NULL
5541 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5543 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5544 printf (" (%u)", header
->e_shstrndx
);
5546 if (header
->e_shstrndx
!= SHN_UNDEF
5547 && header
->e_shstrndx
>= header
->e_shnum
)
5549 header
->e_shstrndx
= SHN_UNDEF
;
5550 printf (_(" <corrupt: out of range>"));
5552 putc ('\n', stdout
);
5555 if (filedata
->section_headers
!= NULL
)
5557 if (header
->e_phnum
== PN_XNUM
5558 && filedata
->section_headers
[0].sh_info
!= 0)
5559 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
5560 if (header
->e_shnum
== SHN_UNDEF
)
5561 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5562 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5563 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5564 if (header
->e_shstrndx
>= header
->e_shnum
)
5565 header
->e_shstrndx
= SHN_UNDEF
;
5571 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5572 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
5575 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5577 Elf32_External_Phdr
* phdrs
;
5578 Elf32_External_Phdr
* external
;
5579 Elf_Internal_Phdr
* internal
;
5581 unsigned int size
= filedata
->file_header
.e_phentsize
;
5582 unsigned int num
= filedata
->file_header
.e_phnum
;
5584 /* PR binutils/17531: Cope with unexpected section header sizes. */
5585 if (size
== 0 || num
== 0)
5587 if (size
< sizeof * phdrs
)
5589 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5592 if (size
> sizeof * phdrs
)
5593 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5595 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5596 size
, num
, _("program headers"));
5600 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5601 i
< filedata
->file_header
.e_phnum
;
5602 i
++, internal
++, external
++)
5604 internal
->p_type
= BYTE_GET (external
->p_type
);
5605 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5606 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5607 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5608 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5609 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5610 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5611 internal
->p_align
= BYTE_GET (external
->p_align
);
5618 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5619 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5622 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5624 Elf64_External_Phdr
* phdrs
;
5625 Elf64_External_Phdr
* external
;
5626 Elf_Internal_Phdr
* internal
;
5628 unsigned int size
= filedata
->file_header
.e_phentsize
;
5629 unsigned int num
= filedata
->file_header
.e_phnum
;
5631 /* PR binutils/17531: Cope with unexpected section header sizes. */
5632 if (size
== 0 || num
== 0)
5634 if (size
< sizeof * phdrs
)
5636 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5639 if (size
> sizeof * phdrs
)
5640 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5642 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5643 size
, num
, _("program headers"));
5647 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5648 i
< filedata
->file_header
.e_phnum
;
5649 i
++, internal
++, external
++)
5651 internal
->p_type
= BYTE_GET (external
->p_type
);
5652 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5653 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5654 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5655 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5656 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5657 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5658 internal
->p_align
= BYTE_GET (external
->p_align
);
5665 /* Returns TRUE if the program headers were read into `program_headers'. */
5668 get_program_headers (Filedata
* filedata
)
5670 Elf_Internal_Phdr
* phdrs
;
5672 /* Check cache of prior read. */
5673 if (filedata
->program_headers
!= NULL
)
5676 /* Be kind to memory checkers by looking for
5677 e_phnum values which we know must be invalid. */
5678 if (filedata
->file_header
.e_phnum
5679 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5680 >= filedata
->file_size
)
5682 error (_("Too many program headers - %#x - the file is not that big\n"),
5683 filedata
->file_header
.e_phnum
);
5687 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5688 sizeof (Elf_Internal_Phdr
));
5691 error (_("Out of memory reading %u program headers\n"),
5692 filedata
->file_header
.e_phnum
);
5697 ? get_32bit_program_headers (filedata
, phdrs
)
5698 : get_64bit_program_headers (filedata
, phdrs
))
5700 filedata
->program_headers
= phdrs
;
5708 /* Print program header info and locate dynamic section. */
5711 process_program_headers (Filedata
* filedata
)
5713 Elf_Internal_Phdr
* segment
;
5715 Elf_Internal_Phdr
* previous_load
= NULL
;
5717 if (filedata
->file_header
.e_phnum
== 0)
5719 /* PR binutils/12467. */
5720 if (filedata
->file_header
.e_phoff
!= 0)
5721 warn (_("possibly corrupt ELF header - it has a non-zero program"
5722 " header offset, but no program headers\n"));
5723 else if (do_segments
)
5725 if (filedata
->is_separate
)
5726 printf (_("\nThere are no program headers in linked file '%s'.\n"),
5727 filedata
->file_name
);
5729 printf (_("\nThere are no program headers in this file.\n"));
5734 if (do_segments
&& !do_header
)
5736 if (filedata
->is_separate
)
5737 printf ("\nIn linked file '%s' the ELF file type is %s\n",
5738 filedata
->file_name
, get_file_type (filedata
));
5740 printf (_("\nElf file type is %s\n"), get_file_type (filedata
));
5741 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5742 printf (ngettext ("There is %d program header, starting at offset %s\n",
5743 "There are %d program headers, starting at offset %s\n",
5744 filedata
->file_header
.e_phnum
),
5745 filedata
->file_header
.e_phnum
,
5746 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5749 if (! get_program_headers (filedata
))
5754 if (filedata
->file_header
.e_phnum
> 1)
5755 printf (_("\nProgram Headers:\n"));
5757 printf (_("\nProgram Headers:\n"));
5761 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5764 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5768 (_(" Type Offset VirtAddr PhysAddr\n"));
5770 (_(" FileSiz MemSiz Flags Align\n"));
5774 unsigned long dynamic_addr
= 0;
5775 bfd_size_type dynamic_size
= 0;
5776 for (i
= 0, segment
= filedata
->program_headers
;
5777 i
< filedata
->file_header
.e_phnum
;
5782 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5786 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5787 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5788 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5789 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5790 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5792 (segment
->p_flags
& PF_R
? 'R' : ' '),
5793 (segment
->p_flags
& PF_W
? 'W' : ' '),
5794 (segment
->p_flags
& PF_X
? 'E' : ' '));
5795 printf ("%#lx", (unsigned long) segment
->p_align
);
5799 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5800 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5803 print_vma (segment
->p_offset
, FULL_HEX
);
5807 print_vma (segment
->p_vaddr
, FULL_HEX
);
5809 print_vma (segment
->p_paddr
, FULL_HEX
);
5812 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5813 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5816 print_vma (segment
->p_filesz
, FULL_HEX
);
5820 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5821 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5824 print_vma (segment
->p_memsz
, FULL_HEX
);
5828 (segment
->p_flags
& PF_R
? 'R' : ' '),
5829 (segment
->p_flags
& PF_W
? 'W' : ' '),
5830 (segment
->p_flags
& PF_X
? 'E' : ' '));
5832 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5833 printf ("%#lx", (unsigned long) segment
->p_align
);
5836 print_vma (segment
->p_align
, PREFIX_HEX
);
5841 print_vma (segment
->p_offset
, FULL_HEX
);
5843 print_vma (segment
->p_vaddr
, FULL_HEX
);
5845 print_vma (segment
->p_paddr
, FULL_HEX
);
5847 print_vma (segment
->p_filesz
, FULL_HEX
);
5849 print_vma (segment
->p_memsz
, FULL_HEX
);
5851 (segment
->p_flags
& PF_R
? 'R' : ' '),
5852 (segment
->p_flags
& PF_W
? 'W' : ' '),
5853 (segment
->p_flags
& PF_X
? 'E' : ' '));
5854 print_vma (segment
->p_align
, PREFIX_HEX
);
5857 putc ('\n', stdout
);
5860 switch (segment
->p_type
)
5863 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5864 required by the ELF standard, several programs, including the Linux
5865 kernel, make use of non-ordered segments. */
5867 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5868 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5870 if (segment
->p_memsz
< segment
->p_filesz
)
5871 error (_("the segment's file size is larger than its memory size\n"));
5872 previous_load
= segment
;
5876 /* PR 20815 - Verify that the program header is loaded into memory. */
5877 if (i
> 0 && previous_load
!= NULL
)
5878 error (_("the PHDR segment must occur before any LOAD segment\n"));
5879 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5883 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5885 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
5886 if (load
->p_type
== PT_LOAD
5887 && load
->p_offset
<= segment
->p_offset
5888 && (load
->p_offset
+ load
->p_filesz
5889 >= segment
->p_offset
+ segment
->p_filesz
)
5890 && load
->p_vaddr
<= segment
->p_vaddr
5891 && (load
->p_vaddr
+ load
->p_filesz
5892 >= segment
->p_vaddr
+ segment
->p_filesz
))
5895 if (j
== filedata
->file_header
.e_phnum
)
5896 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5902 error (_("more than one dynamic segment\n"));
5904 /* By default, assume that the .dynamic section is the first
5905 section in the DYNAMIC segment. */
5906 dynamic_addr
= segment
->p_offset
;
5907 dynamic_size
= segment
->p_filesz
;
5909 /* Try to locate the .dynamic section. If there is
5910 a section header table, we can easily locate it. */
5911 if (filedata
->section_headers
!= NULL
)
5913 Elf_Internal_Shdr
* sec
;
5915 sec
= find_section (filedata
, ".dynamic");
5916 if (sec
== NULL
|| sec
->sh_size
== 0)
5918 /* A corresponding .dynamic section is expected, but on
5919 IA-64/OpenVMS it is OK for it to be missing. */
5920 if (!is_ia64_vms (filedata
))
5921 error (_("no .dynamic section in the dynamic segment\n"));
5925 if (sec
->sh_type
== SHT_NOBITS
)
5932 dynamic_addr
= sec
->sh_offset
;
5933 dynamic_size
= sec
->sh_size
;
5935 /* The PT_DYNAMIC segment, which is used by the run-time
5936 loader, should exactly match the .dynamic section. */
5938 && (dynamic_addr
!= segment
->p_offset
5939 || dynamic_size
!= segment
->p_filesz
))
5941 the .dynamic section is not the same as the dynamic segment\n"));
5944 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5945 segment. Check this after matching against the section headers
5946 so we don't warn on debuginfo file (which have NOBITS .dynamic
5948 if (dynamic_addr
> filedata
->file_size
5949 || (dynamic_size
> filedata
->file_size
- dynamic_addr
))
5951 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5958 if (segment
->p_offset
>= filedata
->file_size
5959 || segment
->p_filesz
> filedata
->file_size
- segment
->p_offset
5960 || segment
->p_filesz
- 1 >= (size_t) -2
5961 || fseek (filedata
->handle
,
5962 filedata
->archive_file_offset
+ (long) segment
->p_offset
,
5964 error (_("Unable to find program interpreter name\n"));
5967 size_t len
= segment
->p_filesz
;
5968 free (filedata
->program_interpreter
);
5969 filedata
->program_interpreter
= xmalloc (len
+ 1);
5970 len
= fread (filedata
->program_interpreter
, 1, len
,
5972 filedata
->program_interpreter
[len
] = 0;
5975 printf (_(" [Requesting program interpreter: %s]\n"),
5976 filedata
->program_interpreter
);
5983 && filedata
->section_headers
!= NULL
5984 && filedata
->string_table
!= NULL
)
5986 printf (_("\n Section to Segment mapping:\n"));
5987 printf (_(" Segment Sections...\n"));
5989 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5992 Elf_Internal_Shdr
* section
;
5994 segment
= filedata
->program_headers
+ i
;
5995 section
= filedata
->section_headers
+ 1;
5997 printf (" %2.2d ", i
);
5999 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
6001 if (!ELF_TBSS_SPECIAL (section
, segment
)
6002 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
6003 printf ("%s ", printable_section_name (filedata
, section
));
6010 filedata
->dynamic_addr
= dynamic_addr
;
6011 filedata
->dynamic_size
= dynamic_size
? dynamic_size
: 1;
6015 filedata
->dynamic_addr
= 0;
6016 filedata
->dynamic_size
= 1;
6020 /* Find the file offset corresponding to VMA by using the program headers. */
6023 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
6025 Elf_Internal_Phdr
* seg
;
6027 if (! get_program_headers (filedata
))
6029 warn (_("Cannot interpret virtual addresses without program headers.\n"));
6033 for (seg
= filedata
->program_headers
;
6034 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
6037 if (seg
->p_type
!= PT_LOAD
)
6040 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
6041 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
6042 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
6045 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
6046 (unsigned long) vma
);
6051 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
6052 If PROBE is true, this is just a probe and we do not generate any error
6053 messages if the load fails. */
6056 get_32bit_section_headers (Filedata
* filedata
, bool probe
)
6058 Elf32_External_Shdr
* shdrs
;
6059 Elf_Internal_Shdr
* internal
;
6061 unsigned int size
= filedata
->file_header
.e_shentsize
;
6062 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
6064 /* PR binutils/17531: Cope with unexpected section header sizes. */
6065 if (size
== 0 || num
== 0)
6067 if (size
< sizeof * shdrs
)
6070 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
6073 if (!probe
&& size
> sizeof * shdrs
)
6074 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
6076 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
6078 probe
? NULL
: _("section headers"));
6082 filedata
->section_headers
= (Elf_Internal_Shdr
*)
6083 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
6084 if (filedata
->section_headers
== NULL
)
6087 error (_("Out of memory reading %u section headers\n"), num
);
6092 for (i
= 0, internal
= filedata
->section_headers
;
6096 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
6097 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
6098 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
6099 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
6100 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
6101 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
6102 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
6103 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
6104 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
6105 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
6106 if (!probe
&& internal
->sh_link
> num
)
6107 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
6108 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
6109 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
6116 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
6119 get_64bit_section_headers (Filedata
* filedata
, bool probe
)
6121 Elf64_External_Shdr
* shdrs
;
6122 Elf_Internal_Shdr
* internal
;
6124 unsigned int size
= filedata
->file_header
.e_shentsize
;
6125 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
6127 /* PR binutils/17531: Cope with unexpected section header sizes. */
6128 if (size
== 0 || num
== 0)
6131 if (size
< sizeof * shdrs
)
6134 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
6138 if (! probe
&& size
> sizeof * shdrs
)
6139 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
6141 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
6142 filedata
->file_header
.e_shoff
,
6144 probe
? NULL
: _("section headers"));
6148 filedata
->section_headers
= (Elf_Internal_Shdr
*)
6149 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
6150 if (filedata
->section_headers
== NULL
)
6153 error (_("Out of memory reading %u section headers\n"), num
);
6158 for (i
= 0, internal
= filedata
->section_headers
;
6162 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
6163 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
6164 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
6165 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
6166 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
6167 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
6168 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
6169 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
6170 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
6171 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
6172 if (!probe
&& internal
->sh_link
> num
)
6173 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
6174 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
6175 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
6183 get_section_headers (Filedata
*filedata
, bool probe
)
6185 if (filedata
->section_headers
!= NULL
)
6189 return get_32bit_section_headers (filedata
, probe
);
6191 return get_64bit_section_headers (filedata
, probe
);
6194 static Elf_Internal_Sym
*
6195 get_32bit_elf_symbols (Filedata
* filedata
,
6196 Elf_Internal_Shdr
* section
,
6197 unsigned long * num_syms_return
)
6199 unsigned long number
= 0;
6200 Elf32_External_Sym
* esyms
= NULL
;
6201 Elf_External_Sym_Shndx
* shndx
= NULL
;
6202 Elf_Internal_Sym
* isyms
= NULL
;
6203 Elf_Internal_Sym
* psym
;
6205 elf_section_list
* entry
;
6207 if (section
->sh_size
== 0)
6209 if (num_syms_return
!= NULL
)
6210 * num_syms_return
= 0;
6214 /* Run some sanity checks first. */
6215 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
6217 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
6218 printable_section_name (filedata
, section
),
6219 (unsigned long) section
->sh_entsize
);
6223 if (section
->sh_size
> filedata
->file_size
)
6225 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
6226 printable_section_name (filedata
, section
),
6227 (unsigned long) section
->sh_size
);
6231 number
= section
->sh_size
/ section
->sh_entsize
;
6233 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
6235 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
6236 (unsigned long) section
->sh_size
,
6237 printable_section_name (filedata
, section
),
6238 (unsigned long) section
->sh_entsize
);
6242 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
6243 section
->sh_size
, _("symbols"));
6248 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
6250 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
6255 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
6259 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
6260 entry
->hdr
->sh_offset
,
6261 1, entry
->hdr
->sh_size
,
6262 _("symbol table section indices"));
6266 /* PR17531: file: heap-buffer-overflow */
6267 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
6269 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
6270 printable_section_name (filedata
, entry
->hdr
),
6271 (unsigned long) entry
->hdr
->sh_size
,
6272 (unsigned long) section
->sh_size
);
6277 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
6281 error (_("Out of memory reading %lu symbols\n"),
6282 (unsigned long) number
);
6286 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
6288 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
6289 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
6290 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
6291 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
6292 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
6294 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
6295 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
6296 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
6297 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
6298 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
6305 if (num_syms_return
!= NULL
)
6306 * num_syms_return
= isyms
== NULL
? 0 : number
;
6311 static Elf_Internal_Sym
*
6312 get_64bit_elf_symbols (Filedata
* filedata
,
6313 Elf_Internal_Shdr
* section
,
6314 unsigned long * num_syms_return
)
6316 unsigned long number
= 0;
6317 Elf64_External_Sym
* esyms
= NULL
;
6318 Elf_External_Sym_Shndx
* shndx
= NULL
;
6319 Elf_Internal_Sym
* isyms
= NULL
;
6320 Elf_Internal_Sym
* psym
;
6322 elf_section_list
* entry
;
6324 if (section
->sh_size
== 0)
6326 if (num_syms_return
!= NULL
)
6327 * num_syms_return
= 0;
6331 /* Run some sanity checks first. */
6332 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
6334 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
6335 printable_section_name (filedata
, section
),
6336 (unsigned long) section
->sh_entsize
);
6340 if (section
->sh_size
> filedata
->file_size
)
6342 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
6343 printable_section_name (filedata
, section
),
6344 (unsigned long) section
->sh_size
);
6348 number
= section
->sh_size
/ section
->sh_entsize
;
6350 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
6352 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
6353 (unsigned long) section
->sh_size
,
6354 printable_section_name (filedata
, section
),
6355 (unsigned long) section
->sh_entsize
);
6359 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
6360 section
->sh_size
, _("symbols"));
6365 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
6367 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
6372 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
6376 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
6377 entry
->hdr
->sh_offset
,
6378 1, entry
->hdr
->sh_size
,
6379 _("symbol table section indices"));
6383 /* PR17531: file: heap-buffer-overflow */
6384 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
6386 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
6387 printable_section_name (filedata
, entry
->hdr
),
6388 (unsigned long) entry
->hdr
->sh_size
,
6389 (unsigned long) section
->sh_size
);
6394 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
6398 error (_("Out of memory reading %lu symbols\n"),
6399 (unsigned long) number
);
6403 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
6405 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
6406 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
6407 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
6408 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
6410 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
6412 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
6413 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
6414 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
6416 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
6417 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
6424 if (num_syms_return
!= NULL
)
6425 * num_syms_return
= isyms
== NULL
? 0 : number
;
6430 static Elf_Internal_Sym
*
6431 get_elf_symbols (Filedata
*filedata
,
6432 Elf_Internal_Shdr
*section
,
6433 unsigned long *num_syms_return
)
6436 return get_32bit_elf_symbols (filedata
, section
, num_syms_return
);
6438 return get_64bit_elf_symbols (filedata
, section
, num_syms_return
);
6442 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
6444 static char buff
[1024];
6446 unsigned int field_size
= is_32bit_elf
? 8 : 16;
6448 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
6449 bfd_vma os_flags
= 0;
6450 bfd_vma proc_flags
= 0;
6451 bfd_vma unknown_flags
= 0;
6459 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
6460 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
6461 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
6462 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
6463 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
6464 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
6465 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
6466 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
6467 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
6468 /* 9 */ { STRING_COMMA_LEN ("TLS") },
6469 /* IA-64 specific. */
6470 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
6471 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
6472 /* IA-64 OpenVMS specific. */
6473 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
6474 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
6475 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
6476 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
6477 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
6478 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
6480 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
6481 /* SPARC specific. */
6482 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
6483 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
6485 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
6486 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
6487 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
6489 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
6491 /* 25 */ { STRING_COMMA_LEN ("VLE") },
6493 /* 26 */ { STRING_COMMA_LEN ("GNU_RETAIN") },
6496 if (do_section_details
)
6498 sprintf (buff
, "[%*.*lx]: ",
6499 field_size
, field_size
, (unsigned long) sh_flags
);
6500 p
+= field_size
+ 4;
6507 flag
= sh_flags
& - sh_flags
;
6510 if (do_section_details
)
6514 case SHF_WRITE
: sindex
= 0; break;
6515 case SHF_ALLOC
: sindex
= 1; break;
6516 case SHF_EXECINSTR
: sindex
= 2; break;
6517 case SHF_MERGE
: sindex
= 3; break;
6518 case SHF_STRINGS
: sindex
= 4; break;
6519 case SHF_INFO_LINK
: sindex
= 5; break;
6520 case SHF_LINK_ORDER
: sindex
= 6; break;
6521 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
6522 case SHF_GROUP
: sindex
= 8; break;
6523 case SHF_TLS
: sindex
= 9; break;
6524 case SHF_EXCLUDE
: sindex
= 18; break;
6525 case SHF_COMPRESSED
: sindex
= 20; break;
6529 switch (filedata
->file_header
.e_machine
)
6532 if (flag
== SHF_IA_64_SHORT
)
6534 else if (flag
== SHF_IA_64_NORECOV
)
6537 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
6540 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
6541 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
6542 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
6543 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
6544 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
6545 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
6556 case EM_OLD_SPARCV9
:
6557 case EM_SPARC32PLUS
:
6560 if (flag
== SHF_ORDERED
)
6567 case SHF_ENTRYSECT
: sindex
= 21; break;
6568 case SHF_ARM_PURECODE
: sindex
= 22; break;
6569 case SHF_COMDEF
: sindex
= 23; break;
6574 if (flag
== SHF_PPC_VLE
)
6581 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
6584 case ELFOSABI_FREEBSD
:
6585 if (flag
== SHF_GNU_RETAIN
)
6589 if (flag
== SHF_GNU_MBIND
)
6590 /* We should not recognize SHF_GNU_MBIND for
6591 ELFOSABI_NONE, but binutils as of 2019-07-23 did
6592 not set the EI_OSABI header byte. */
6603 if (p
!= buff
+ field_size
+ 4)
6605 if (size
< (10 + 2))
6607 warn (_("Internal error: not enough buffer room for section flag info"));
6608 return _("<unknown>");
6615 size
-= flags
[sindex
].len
;
6616 p
= stpcpy (p
, flags
[sindex
].str
);
6618 else if (flag
& SHF_MASKOS
)
6620 else if (flag
& SHF_MASKPROC
)
6623 unknown_flags
|= flag
;
6629 case SHF_WRITE
: *p
= 'W'; break;
6630 case SHF_ALLOC
: *p
= 'A'; break;
6631 case SHF_EXECINSTR
: *p
= 'X'; break;
6632 case SHF_MERGE
: *p
= 'M'; break;
6633 case SHF_STRINGS
: *p
= 'S'; break;
6634 case SHF_INFO_LINK
: *p
= 'I'; break;
6635 case SHF_LINK_ORDER
: *p
= 'L'; break;
6636 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
6637 case SHF_GROUP
: *p
= 'G'; break;
6638 case SHF_TLS
: *p
= 'T'; break;
6639 case SHF_EXCLUDE
: *p
= 'E'; break;
6640 case SHF_COMPRESSED
: *p
= 'C'; break;
6643 if ((filedata
->file_header
.e_machine
== EM_X86_64
6644 || filedata
->file_header
.e_machine
== EM_L1OM
6645 || filedata
->file_header
.e_machine
== EM_K1OM
)
6646 && flag
== SHF_X86_64_LARGE
)
6648 else if (filedata
->file_header
.e_machine
== EM_ARM
6649 && flag
== SHF_ARM_PURECODE
)
6651 else if (filedata
->file_header
.e_machine
== EM_PPC
6652 && flag
== SHF_PPC_VLE
)
6654 else if (flag
& SHF_MASKOS
)
6656 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
6659 case ELFOSABI_FREEBSD
:
6660 if (flag
== SHF_GNU_RETAIN
)
6667 if (flag
== SHF_GNU_MBIND
)
6669 /* We should not recognize SHF_GNU_MBIND for
6670 ELFOSABI_NONE, but binutils as of 2019-07-23 did
6671 not set the EI_OSABI header byte. */
6678 sh_flags
&= ~SHF_MASKOS
;
6682 else if (flag
& SHF_MASKPROC
)
6685 sh_flags
&= ~ SHF_MASKPROC
;
6695 if (do_section_details
)
6699 size
-= 5 + field_size
;
6700 if (p
!= buff
+ field_size
+ 4)
6704 warn (_("Internal error: not enough buffer room for section flag info"));
6705 return _("<unknown>");
6711 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6712 (unsigned long) os_flags
);
6713 p
+= 5 + field_size
;
6717 size
-= 7 + field_size
;
6718 if (p
!= buff
+ field_size
+ 4)
6722 warn (_("Internal error: not enough buffer room for section flag info"));
6723 return _("<unknown>");
6729 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6730 (unsigned long) proc_flags
);
6731 p
+= 7 + field_size
;
6735 size
-= 10 + field_size
;
6736 if (p
!= buff
+ field_size
+ 4)
6740 warn (_("Internal error: not enough buffer room for section flag info"));
6741 return _("<unknown>");
6747 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6748 (unsigned long) unknown_flags
);
6749 p
+= 10 + field_size
;
6757 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
6758 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6762 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6764 if (size
< sizeof (* echdr
))
6766 error (_("Compressed section is too small even for a compression header\n"));
6770 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6771 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6772 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6773 return sizeof (*echdr
);
6777 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6779 if (size
< sizeof (* echdr
))
6781 error (_("Compressed section is too small even for a compression header\n"));
6785 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6786 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6787 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6788 return sizeof (*echdr
);
6793 process_section_headers (Filedata
* filedata
)
6795 Elf_Internal_Shdr
* section
;
6798 if (filedata
->file_header
.e_shnum
== 0)
6800 /* PR binutils/12467. */
6801 if (filedata
->file_header
.e_shoff
!= 0)
6803 warn (_("possibly corrupt ELF file header - it has a non-zero"
6804 " section header offset, but no section headers\n"));
6807 else if (do_sections
)
6808 printf (_("\nThere are no sections in this file.\n"));
6813 if (do_sections
&& !do_header
)
6815 if (filedata
->is_separate
&& process_links
)
6816 printf (_("In linked file '%s': "), filedata
->file_name
);
6817 if (! filedata
->is_separate
|| process_links
)
6818 printf (ngettext ("There is %d section header, "
6819 "starting at offset 0x%lx:\n",
6820 "There are %d section headers, "
6821 "starting at offset 0x%lx:\n",
6822 filedata
->file_header
.e_shnum
),
6823 filedata
->file_header
.e_shnum
,
6824 (unsigned long) filedata
->file_header
.e_shoff
);
6827 if (!get_section_headers (filedata
, false))
6830 /* Read in the string table, so that we have names to display. */
6831 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6832 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6834 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6836 if (section
->sh_size
!= 0)
6838 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6839 1, section
->sh_size
,
6842 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6846 /* Scan the sections for the dynamic symbol table
6847 and dynamic string table and debug sections. */
6848 eh_addr_size
= is_32bit_elf
? 4 : 8;
6849 switch (filedata
->file_header
.e_machine
)
6852 case EM_MIPS_RS3_LE
:
6853 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6854 FDE addresses. However, the ABI also has a semi-official ILP32
6855 variant for which the normal FDE address size rules apply.
6857 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6858 section, where XX is the size of longs in bits. Unfortunately,
6859 earlier compilers provided no way of distinguishing ILP32 objects
6860 from LP64 objects, so if there's any doubt, we should assume that
6861 the official LP64 form is being used. */
6862 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6863 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6869 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6871 case E_H8_MACH_H8300
:
6872 case E_H8_MACH_H8300HN
:
6873 case E_H8_MACH_H8300SN
:
6874 case E_H8_MACH_H8300SXN
:
6877 case E_H8_MACH_H8300H
:
6878 case E_H8_MACH_H8300S
:
6879 case E_H8_MACH_H8300SX
:
6887 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6889 case EF_M32C_CPU_M16C
:
6896 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6899 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6900 if (section->sh_entsize != expected_entsize) \
6903 sprintf_vma (buf, section->sh_entsize); \
6904 /* Note: coded this way so that there is a single string for \
6906 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6907 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6908 (unsigned) expected_entsize); \
6909 section->sh_entsize = expected_entsize; \
6914 #define CHECK_ENTSIZE(section, i, type) \
6915 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6916 sizeof (Elf64_External_##type))
6918 for (i
= 0, section
= filedata
->section_headers
;
6919 i
< filedata
->file_header
.e_shnum
;
6922 const char *name
= section_name_print (filedata
, section
);
6924 /* Run some sanity checks on the headers and
6925 possibly fill in some file data as well. */
6926 switch (section
->sh_type
)
6929 if (filedata
->dynamic_symbols
!= NULL
)
6931 error (_("File contains multiple dynamic symbol tables\n"));
6935 CHECK_ENTSIZE (section
, i
, Sym
);
6936 filedata
->dynamic_symbols
6937 = get_elf_symbols (filedata
, section
, &filedata
->num_dynamic_syms
);
6938 filedata
->dynamic_symtab_section
= section
;
6942 if (streq (name
, ".dynstr"))
6944 if (filedata
->dynamic_strings
!= NULL
)
6946 error (_("File contains multiple dynamic string tables\n"));
6950 filedata
->dynamic_strings
6951 = (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6952 1, section
->sh_size
, _("dynamic strings"));
6953 filedata
->dynamic_strings_length
6954 = filedata
->dynamic_strings
== NULL
? 0 : section
->sh_size
;
6955 filedata
->dynamic_strtab_section
= section
;
6959 case SHT_SYMTAB_SHNDX
:
6961 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6963 entry
->hdr
= section
;
6964 entry
->next
= filedata
->symtab_shndx_list
;
6965 filedata
->symtab_shndx_list
= entry
;
6970 CHECK_ENTSIZE (section
, i
, Sym
);
6974 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6978 CHECK_ENTSIZE (section
, i
, Rel
);
6979 if (do_checks
&& section
->sh_size
== 0)
6980 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6984 CHECK_ENTSIZE (section
, i
, Rela
);
6985 if (do_checks
&& section
->sh_size
== 0)
6986 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6991 /* Having a zero sized section is not illegal according to the
6992 ELF standard, but it might be an indication that something
6993 is wrong. So issue a warning if we are running in lint mode. */
6994 if (do_checks
&& section
->sh_size
== 0)
6995 warn (_("Section '%s': has a size of zero - is this intended ?\n"), name
);
7002 if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
7003 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
7004 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
7005 || do_debug_str
|| do_debug_str_offsets
|| do_debug_loc
7007 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
7008 && (startswith (name
, ".debug_")
7009 || startswith (name
, ".zdebug_")))
7012 name
+= sizeof (".zdebug_") - 1;
7014 name
+= sizeof (".debug_") - 1;
7017 || (do_debug_info
&& startswith (name
, "info"))
7018 || (do_debug_info
&& startswith (name
, "types"))
7019 || (do_debug_abbrevs
&& startswith (name
, "abbrev"))
7020 || (do_debug_lines
&& strcmp (name
, "line") == 0)
7021 || (do_debug_lines
&& startswith (name
, "line."))
7022 || (do_debug_pubnames
&& startswith (name
, "pubnames"))
7023 || (do_debug_pubtypes
&& startswith (name
, "pubtypes"))
7024 || (do_debug_pubnames
&& startswith (name
, "gnu_pubnames"))
7025 || (do_debug_pubtypes
&& startswith (name
, "gnu_pubtypes"))
7026 || (do_debug_aranges
&& startswith (name
, "aranges"))
7027 || (do_debug_ranges
&& startswith (name
, "ranges"))
7028 || (do_debug_ranges
&& startswith (name
, "rnglists"))
7029 || (do_debug_frames
&& startswith (name
, "frame"))
7030 || (do_debug_macinfo
&& startswith (name
, "macinfo"))
7031 || (do_debug_macinfo
&& startswith (name
, "macro"))
7032 || (do_debug_str
&& startswith (name
, "str"))
7033 || (do_debug_links
&& startswith (name
, "sup"))
7034 || (do_debug_str_offsets
&& startswith (name
, "str_offsets"))
7035 || (do_debug_loc
&& startswith (name
, "loc"))
7036 || (do_debug_loc
&& startswith (name
, "loclists"))
7037 || (do_debug_addr
&& startswith (name
, "addr"))
7038 || (do_debug_cu_index
&& startswith (name
, "cu_index"))
7039 || (do_debug_cu_index
&& startswith (name
, "tu_index"))
7041 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7043 /* Linkonce section to be combined with .debug_info at link time. */
7044 else if ((do_debugging
|| do_debug_info
)
7045 && startswith (name
, ".gnu.linkonce.wi."))
7046 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7047 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
7048 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7049 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
7050 || streq (name
, ".debug_names")))
7051 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7052 /* Trace sections for Itanium VMS. */
7053 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
7054 || do_trace_aranges
)
7055 && startswith (name
, ".trace_"))
7057 name
+= sizeof (".trace_") - 1;
7060 || (do_trace_info
&& streq (name
, "info"))
7061 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
7062 || (do_trace_aranges
&& streq (name
, "aranges"))
7064 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7066 else if ((do_debugging
|| do_debug_links
)
7067 && (startswith (name
, ".gnu_debuglink")
7068 || startswith (name
, ".gnu_debugaltlink")))
7069 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
7075 if (filedata
->is_separate
&& ! process_links
)
7078 if (filedata
->is_separate
)
7079 printf (_("\nSection Headers in linked file '%s':\n"), filedata
->file_name
);
7080 else if (filedata
->file_header
.e_shnum
> 1)
7081 printf (_("\nSection Headers:\n"));
7083 printf (_("\nSection Header:\n"));
7087 if (do_section_details
)
7089 printf (_(" [Nr] Name\n"));
7090 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
7094 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
7098 if (do_section_details
)
7100 printf (_(" [Nr] Name\n"));
7101 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
7105 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
7109 if (do_section_details
)
7111 printf (_(" [Nr] Name\n"));
7112 printf (_(" Type Address Offset Link\n"));
7113 printf (_(" Size EntSize Info Align\n"));
7117 printf (_(" [Nr] Name Type Address Offset\n"));
7118 printf (_(" Size EntSize Flags Link Info Align\n"));
7122 if (do_section_details
)
7123 printf (_(" Flags\n"));
7125 for (i
= 0, section
= filedata
->section_headers
;
7126 i
< filedata
->file_header
.e_shnum
;
7129 /* Run some sanity checks on the section header. */
7131 /* Check the sh_link field. */
7132 switch (section
->sh_type
)
7136 if (section
->sh_link
== 0
7137 && (filedata
->file_header
.e_type
== ET_EXEC
7138 || filedata
->file_header
.e_type
== ET_DYN
))
7139 /* A dynamic relocation section where all entries use a
7140 zero symbol index need not specify a symtab section. */
7143 case SHT_SYMTAB_SHNDX
:
7147 case SHT_GNU_versym
:
7148 if (section
->sh_link
== 0
7149 || section
->sh_link
>= filedata
->file_header
.e_shnum
7150 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
7151 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
7152 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
7153 i
, section
->sh_link
);
7159 case SHT_GNU_verneed
:
7160 case SHT_GNU_verdef
:
7161 case SHT_GNU_LIBLIST
:
7162 if (section
->sh_link
== 0
7163 || section
->sh_link
>= filedata
->file_header
.e_shnum
7164 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
7165 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
7166 i
, section
->sh_link
);
7169 case SHT_INIT_ARRAY
:
7170 case SHT_FINI_ARRAY
:
7171 case SHT_PREINIT_ARRAY
:
7172 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
7173 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
7174 i
, section
->sh_link
);
7178 /* FIXME: Add support for target specific section types. */
7179 #if 0 /* Currently we do not check other section types as there are too
7180 many special cases. Stab sections for example have a type
7181 of SHT_PROGBITS but an sh_link field that links to the .stabstr
7183 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
7184 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
7185 i
, section
->sh_link
);
7190 /* Check the sh_info field. */
7191 switch (section
->sh_type
)
7195 if (section
->sh_info
== 0
7196 && (filedata
->file_header
.e_type
== ET_EXEC
7197 || filedata
->file_header
.e_type
== ET_DYN
))
7198 /* Dynamic relocations apply to segments, so they do not
7199 need to specify the section they relocate. */
7201 if (section
->sh_info
== 0
7202 || section
->sh_info
>= filedata
->file_header
.e_shnum
7203 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
7204 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
7205 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
7206 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
7207 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
7208 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
7209 /* FIXME: Are other section types valid ? */
7210 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
7211 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
7212 i
, section
->sh_info
);
7217 case SHT_SYMTAB_SHNDX
:
7218 case SHT_INIT_ARRAY
:
7219 case SHT_FINI_ARRAY
:
7220 case SHT_PREINIT_ARRAY
:
7221 if (section
->sh_info
!= 0)
7222 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
7223 i
, section
->sh_info
);
7229 /* A symbol index - we assume that it is valid. */
7233 /* FIXME: Add support for target specific section types. */
7234 if (section
->sh_type
== SHT_NOBITS
)
7235 /* NOBITS section headers with non-zero sh_info fields can be
7236 created when a binary is stripped of everything but its debug
7237 information. The stripped sections have their headers
7238 preserved but their types set to SHT_NOBITS. So do not check
7239 this type of section. */
7241 else if (section
->sh_flags
& SHF_INFO_LINK
)
7243 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
7244 warn (_("[%2u]: Expected link to another section in info field"), i
);
7246 else if (section
->sh_type
< SHT_LOOS
7247 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
7248 && section
->sh_info
!= 0)
7249 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
7250 i
, section
->sh_info
);
7254 /* Check the sh_size field. */
7255 if (section
->sh_size
> filedata
->file_size
7256 && section
->sh_type
!= SHT_NOBITS
7257 && section
->sh_type
!= SHT_NULL
7258 && section
->sh_type
< SHT_LOOS
)
7259 warn (_("Size of section %u is larger than the entire file!\n"), i
);
7261 printf (" [%2u] ", i
);
7262 if (do_section_details
)
7263 printf ("%s\n ", printable_section_name (filedata
, section
));
7265 print_symbol (-17, section_name_print (filedata
, section
));
7267 printf (do_wide
? " %-15s " : " %-15.15s ",
7268 get_section_type_name (filedata
, section
->sh_type
));
7272 const char * link_too_big
= NULL
;
7274 print_vma (section
->sh_addr
, LONG_HEX
);
7276 printf ( " %6.6lx %6.6lx %2.2lx",
7277 (unsigned long) section
->sh_offset
,
7278 (unsigned long) section
->sh_size
,
7279 (unsigned long) section
->sh_entsize
);
7281 if (do_section_details
)
7282 fputs (" ", stdout
);
7284 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
7286 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
7289 /* The sh_link value is out of range. Normally this indicates
7290 an error but it can have special values in Solaris binaries. */
7291 switch (filedata
->file_header
.e_machine
)
7298 case EM_OLD_SPARCV9
:
7299 case EM_SPARC32PLUS
:
7302 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
7303 link_too_big
= "BEFORE";
7304 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
7305 link_too_big
= "AFTER";
7312 if (do_section_details
)
7314 if (link_too_big
!= NULL
&& * link_too_big
)
7315 printf ("<%s> ", link_too_big
);
7317 printf ("%2u ", section
->sh_link
);
7318 printf ("%3u %2lu\n", section
->sh_info
,
7319 (unsigned long) section
->sh_addralign
);
7322 printf ("%2u %3u %2lu\n",
7325 (unsigned long) section
->sh_addralign
);
7327 if (link_too_big
&& ! * link_too_big
)
7328 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
7329 i
, section
->sh_link
);
7333 print_vma (section
->sh_addr
, LONG_HEX
);
7335 if ((long) section
->sh_offset
== section
->sh_offset
)
7336 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
7340 print_vma (section
->sh_offset
, LONG_HEX
);
7343 if ((unsigned long) section
->sh_size
== section
->sh_size
)
7344 printf (" %6.6lx", (unsigned long) section
->sh_size
);
7348 print_vma (section
->sh_size
, LONG_HEX
);
7351 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
7352 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
7356 print_vma (section
->sh_entsize
, LONG_HEX
);
7359 if (do_section_details
)
7360 fputs (" ", stdout
);
7362 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
7364 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
7366 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
7367 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
7370 print_vma (section
->sh_addralign
, DEC
);
7374 else if (do_section_details
)
7377 print_vma (section
->sh_addr
, LONG_HEX
);
7378 if ((long) section
->sh_offset
== section
->sh_offset
)
7379 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
7383 print_vma (section
->sh_offset
, LONG_HEX
);
7385 printf (" %u\n ", section
->sh_link
);
7386 print_vma (section
->sh_size
, LONG_HEX
);
7388 print_vma (section
->sh_entsize
, LONG_HEX
);
7390 printf (" %-16u %lu\n",
7392 (unsigned long) section
->sh_addralign
);
7397 print_vma (section
->sh_addr
, LONG_HEX
);
7398 if ((long) section
->sh_offset
== section
->sh_offset
)
7399 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
7403 print_vma (section
->sh_offset
, LONG_HEX
);
7406 print_vma (section
->sh_size
, LONG_HEX
);
7408 print_vma (section
->sh_entsize
, LONG_HEX
);
7410 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
7412 printf (" %2u %3u %lu\n",
7415 (unsigned long) section
->sh_addralign
);
7418 if (do_section_details
)
7420 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
7421 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
7423 /* Minimum section size is 12 bytes for 32-bit compression
7424 header + 12 bytes for compressed data header. */
7425 unsigned char buf
[24];
7427 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
7428 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
7429 sizeof (buf
), _("compression header")))
7431 Elf_Internal_Chdr chdr
;
7433 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
7434 printf (_(" [<corrupt>]\n"));
7437 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
7440 printf (_(" [<unknown>: 0x%x], "),
7442 print_vma (chdr
.ch_size
, LONG_HEX
);
7443 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
7450 if (!do_section_details
)
7452 /* The ordering of the letters shown here matches the ordering of the
7453 corresponding SHF_xxx values, and hence the order in which these
7454 letters will be displayed to the user. */
7455 printf (_("Key to Flags:\n\
7456 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
7457 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
7458 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
7459 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
7462 case ELFOSABI_FREEBSD
:
7463 printf (_("R (retain), "));
7466 printf (_("D (mbind), "));
7471 if (filedata
->file_header
.e_machine
== EM_X86_64
7472 || filedata
->file_header
.e_machine
== EM_L1OM
7473 || filedata
->file_header
.e_machine
== EM_K1OM
)
7474 printf (_("l (large), "));
7475 else if (filedata
->file_header
.e_machine
== EM_ARM
)
7476 printf (_("y (purecode), "));
7477 else if (filedata
->file_header
.e_machine
== EM_PPC
)
7478 printf (_("v (VLE), "));
7479 printf ("p (processor specific)\n");
7486 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
7487 Elf_Internal_Sym
**symtab
, unsigned long *nsyms
,
7488 char **strtab
, unsigned long *strtablen
)
7492 *symtab
= get_elf_symbols (filedata
, symsec
, nsyms
);
7494 if (*symtab
== NULL
)
7497 if (symsec
->sh_link
!= 0)
7499 Elf_Internal_Shdr
*strsec
;
7501 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
7503 error (_("Bad sh_link in symbol table section\n"));
7510 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7512 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7513 1, strsec
->sh_size
, _("string table"));
7514 if (*strtab
== NULL
)
7521 *strtablen
= strsec
->sh_size
;
7527 get_group_flags (unsigned int flags
)
7529 static char buff
[128];
7533 else if (flags
== GRP_COMDAT
)
7536 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
7538 flags
& GRP_MASKOS
? _("<OS specific>") : "",
7539 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
7540 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
7541 ? _("<unknown>") : ""));
7547 process_section_groups (Filedata
* filedata
)
7549 Elf_Internal_Shdr
* section
;
7551 struct group
* group
;
7552 Elf_Internal_Shdr
* symtab_sec
;
7553 Elf_Internal_Shdr
* strtab_sec
;
7554 Elf_Internal_Sym
* symtab
;
7555 unsigned long num_syms
;
7559 /* Don't process section groups unless needed. */
7560 if (!do_unwind
&& !do_section_groups
)
7563 if (filedata
->file_header
.e_shnum
== 0)
7565 if (do_section_groups
)
7567 if (filedata
->is_separate
)
7568 printf (_("\nThere are no sections group in linked file '%s'.\n"),
7569 filedata
->file_name
);
7571 printf (_("\nThere are no section groups in this file.\n"));
7576 if (filedata
->section_headers
== NULL
)
7578 error (_("Section headers are not available!\n"));
7579 /* PR 13622: This can happen with a corrupt ELF header. */
7583 filedata
->section_headers_groups
7584 = (struct group
**) calloc (filedata
->file_header
.e_shnum
,
7585 sizeof (struct group
*));
7587 if (filedata
->section_headers_groups
== NULL
)
7589 error (_("Out of memory reading %u section group headers\n"),
7590 filedata
->file_header
.e_shnum
);
7594 /* Scan the sections for the group section. */
7595 filedata
->group_count
= 0;
7596 for (i
= 0, section
= filedata
->section_headers
;
7597 i
< filedata
->file_header
.e_shnum
;
7599 if (section
->sh_type
== SHT_GROUP
)
7600 filedata
->group_count
++;
7602 if (filedata
->group_count
== 0)
7604 if (do_section_groups
)
7606 if (filedata
->is_separate
)
7607 printf (_("\nThere are no section groups in linked file '%s'.\n"),
7608 filedata
->file_name
);
7610 printf (_("\nThere are no section groups in this file.\n"));
7616 filedata
->section_groups
= (struct group
*) calloc (filedata
->group_count
,
7617 sizeof (struct group
));
7619 if (filedata
->section_groups
== NULL
)
7621 error (_("Out of memory reading %lu groups\n"),
7622 (unsigned long) filedata
->group_count
);
7633 if (filedata
->is_separate
)
7634 printf (_("Section groups in linked file '%s'\n"), filedata
->file_name
);
7636 for (i
= 0, section
= filedata
->section_headers
, group
= filedata
->section_groups
;
7637 i
< filedata
->file_header
.e_shnum
;
7640 if (section
->sh_type
== SHT_GROUP
)
7642 const char * name
= printable_section_name (filedata
, section
);
7643 const char * group_name
;
7644 unsigned char * start
;
7645 unsigned char * indices
;
7646 unsigned int entry
, j
, size
;
7647 Elf_Internal_Shdr
* sec
;
7648 Elf_Internal_Sym
* sym
;
7650 /* Get the symbol table. */
7651 if (section
->sh_link
>= filedata
->file_header
.e_shnum
7652 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
7655 error (_("Bad sh_link in group section `%s'\n"), name
);
7659 if (symtab_sec
!= sec
)
7663 symtab
= get_elf_symbols (filedata
, symtab_sec
, & num_syms
);
7668 error (_("Corrupt header in group section `%s'\n"), name
);
7672 if (section
->sh_info
>= num_syms
)
7674 error (_("Bad sh_info in group section `%s'\n"), name
);
7678 sym
= symtab
+ section
->sh_info
;
7680 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
7682 if (sym
->st_shndx
== 0
7683 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
7685 error (_("Bad sh_info in group section `%s'\n"), name
);
7689 group_name
= section_name_print (filedata
,
7690 filedata
->section_headers
7699 /* Get the string table. */
7700 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
7708 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
7713 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
7714 1, strtab_sec
->sh_size
,
7716 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
7718 group_name
= sym
->st_name
< strtab_size
7719 ? strtab
+ sym
->st_name
: _("<corrupt>");
7722 /* PR 17531: file: loop. */
7723 if (section
->sh_entsize
> section
->sh_size
)
7725 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7726 printable_section_name (filedata
, section
),
7727 (unsigned long) section
->sh_entsize
,
7728 (unsigned long) section
->sh_size
);
7732 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
7733 1, section
->sh_size
,
7739 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
7740 entry
= byte_get (indices
, 4);
7743 if (do_section_groups
)
7745 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7746 get_group_flags (entry
), i
, name
, group_name
, size
);
7748 printf (_(" [Index] Name\n"));
7751 group
->group_index
= i
;
7753 for (j
= 0; j
< size
; j
++)
7755 struct group_list
* g
;
7757 entry
= byte_get (indices
, 4);
7760 if (entry
>= filedata
->file_header
.e_shnum
)
7762 static unsigned num_group_errors
= 0;
7764 if (num_group_errors
++ < 10)
7766 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7767 entry
, i
, filedata
->file_header
.e_shnum
- 1);
7768 if (num_group_errors
== 10)
7769 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7774 if (filedata
->section_headers_groups
[entry
] != NULL
)
7778 static unsigned num_errs
= 0;
7780 if (num_errs
++ < 10)
7782 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7784 filedata
->section_headers_groups
[entry
]->group_index
);
7786 warn (_("Further error messages about already contained group sections suppressed\n"));
7792 /* Intel C/C++ compiler may put section 0 in a
7793 section group. We just warn it the first time
7794 and ignore it afterwards. */
7795 static bool warned
= false;
7798 error (_("section 0 in group section [%5u]\n"),
7799 filedata
->section_headers_groups
[entry
]->group_index
);
7805 filedata
->section_headers_groups
[entry
] = group
;
7807 if (do_section_groups
)
7809 sec
= filedata
->section_headers
+ entry
;
7810 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7813 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7814 g
->section_index
= entry
;
7815 g
->next
= group
->root
;
7830 /* Data used to display dynamic fixups. */
7832 struct ia64_vms_dynfixup
7834 bfd_vma needed_ident
; /* Library ident number. */
7835 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7836 bfd_vma fixup_needed
; /* Index of the library. */
7837 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7838 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7841 /* Data used to display dynamic relocations. */
7843 struct ia64_vms_dynimgrela
7845 bfd_vma img_rela_cnt
; /* Number of relocations. */
7846 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7849 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7853 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7854 struct ia64_vms_dynfixup
* fixup
,
7855 const char * strtab
,
7856 unsigned int strtab_sz
)
7858 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7860 const char * lib_name
;
7862 imfs
= get_data (NULL
, filedata
,
7863 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
7864 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
7865 _("dynamic section image fixups"));
7869 if (fixup
->needed
< strtab_sz
)
7870 lib_name
= strtab
+ fixup
->needed
;
7873 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7874 (unsigned long) fixup
->needed
);
7878 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7879 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7881 (_("Seg Offset Type SymVec DataType\n"));
7883 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7888 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7889 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7890 type
= BYTE_GET (imfs
[i
].type
);
7891 rtype
= elf_ia64_reloc_type (type
);
7893 printf (" 0x%08x ", type
);
7895 printf (" %-32s ", rtype
);
7896 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7897 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7904 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7907 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7909 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7912 imrs
= get_data (NULL
, filedata
,
7913 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
7914 sizeof (*imrs
), imgrela
->img_rela_cnt
,
7915 _("dynamic section image relocations"));
7919 printf (_("\nImage relocs\n"));
7921 (_("Seg Offset Type Addend Seg Sym Off\n"));
7923 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7928 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7929 printf ("%08" BFD_VMA_FMT
"x ",
7930 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7931 type
= BYTE_GET (imrs
[i
].type
);
7932 rtype
= elf_ia64_reloc_type (type
);
7934 printf ("0x%08x ", type
);
7936 printf ("%-31s ", rtype
);
7937 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7938 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7939 printf ("%08" BFD_VMA_FMT
"x\n",
7940 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7947 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7950 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7952 struct ia64_vms_dynfixup fixup
;
7953 struct ia64_vms_dynimgrela imgrela
;
7954 Elf_Internal_Dyn
*entry
;
7955 bfd_vma strtab_off
= 0;
7956 bfd_vma strtab_sz
= 0;
7957 char *strtab
= NULL
;
7960 memset (&fixup
, 0, sizeof (fixup
));
7961 memset (&imgrela
, 0, sizeof (imgrela
));
7963 /* Note: the order of the entries is specified by the OpenVMS specs. */
7964 for (entry
= filedata
->dynamic_section
;
7965 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
7968 switch (entry
->d_tag
)
7970 case DT_IA_64_VMS_STRTAB_OFFSET
:
7971 strtab_off
= entry
->d_un
.d_val
;
7974 strtab_sz
= entry
->d_un
.d_val
;
7976 strtab
= get_data (NULL
, filedata
,
7977 filedata
->dynamic_addr
+ strtab_off
,
7978 1, strtab_sz
, _("dynamic string section"));
7983 case DT_IA_64_VMS_NEEDED_IDENT
:
7984 fixup
.needed_ident
= entry
->d_un
.d_val
;
7987 fixup
.needed
= entry
->d_un
.d_val
;
7989 case DT_IA_64_VMS_FIXUP_NEEDED
:
7990 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7992 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7993 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7995 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7996 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7997 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
8000 case DT_IA_64_VMS_IMG_RELA_CNT
:
8001 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
8003 case DT_IA_64_VMS_IMG_RELA_OFF
:
8004 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
8005 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
8026 dynamic_relocations
[] =
8028 { "REL", DT_REL
, DT_RELSZ
, false },
8029 { "RELA", DT_RELA
, DT_RELASZ
, true },
8030 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
8033 /* Process the reloc section. */
8036 process_relocs (Filedata
* filedata
)
8038 unsigned long rel_size
;
8039 unsigned long rel_offset
;
8044 if (do_using_dynamic
)
8048 bool has_dynamic_reloc
;
8051 has_dynamic_reloc
= false;
8053 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
8055 is_rela
= dynamic_relocations
[i
].rela
;
8056 name
= dynamic_relocations
[i
].name
;
8057 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
8058 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
8061 has_dynamic_reloc
= true;
8063 if (is_rela
== UNKNOWN
)
8065 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
8066 switch (filedata
->dynamic_info
[DT_PLTREL
])
8079 if (filedata
->is_separate
)
8081 (_("\nIn linked file '%s' section '%s' at offset 0x%lx contains %ld bytes:\n"),
8082 filedata
->file_name
, name
, rel_offset
, rel_size
);
8085 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
8086 name
, rel_offset
, rel_size
);
8088 dump_relocations (filedata
,
8089 offset_from_vma (filedata
, rel_offset
, rel_size
),
8091 filedata
->dynamic_symbols
,
8092 filedata
->num_dynamic_syms
,
8093 filedata
->dynamic_strings
,
8094 filedata
->dynamic_strings_length
,
8095 is_rela
, true /* is_dynamic */);
8099 if (is_ia64_vms (filedata
))
8100 if (process_ia64_vms_dynamic_relocs (filedata
))
8101 has_dynamic_reloc
= true;
8103 if (! has_dynamic_reloc
)
8105 if (filedata
->is_separate
)
8106 printf (_("\nThere are no dynamic relocations in linked file '%s'.\n"),
8107 filedata
->file_name
);
8109 printf (_("\nThere are no dynamic relocations in this file.\n"));
8114 Elf_Internal_Shdr
* section
;
8118 for (i
= 0, section
= filedata
->section_headers
;
8119 i
< filedata
->file_header
.e_shnum
;
8122 if ( section
->sh_type
!= SHT_RELA
8123 && section
->sh_type
!= SHT_REL
)
8126 rel_offset
= section
->sh_offset
;
8127 rel_size
= section
->sh_size
;
8132 unsigned long num_rela
;
8134 if (filedata
->is_separate
)
8135 printf (_("\nIn linked file '%s' relocation section "),
8136 filedata
->file_name
);
8138 printf (_("\nRelocation section "));
8140 if (filedata
->string_table
== NULL
)
8141 printf ("%d", section
->sh_name
);
8143 printf ("'%s'", printable_section_name (filedata
, section
));
8145 num_rela
= rel_size
/ section
->sh_entsize
;
8146 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
8147 " at offset 0x%lx contains %lu entries:\n",
8149 rel_offset
, num_rela
);
8151 is_rela
= section
->sh_type
== SHT_RELA
;
8153 if (section
->sh_link
!= 0
8154 && section
->sh_link
< filedata
->file_header
.e_shnum
)
8156 Elf_Internal_Shdr
* symsec
;
8157 Elf_Internal_Sym
* symtab
;
8158 unsigned long nsyms
;
8159 unsigned long strtablen
= 0;
8160 char * strtab
= NULL
;
8162 symsec
= filedata
->section_headers
+ section
->sh_link
;
8163 if (symsec
->sh_type
!= SHT_SYMTAB
8164 && symsec
->sh_type
!= SHT_DYNSYM
)
8167 if (!get_symtab (filedata
, symsec
,
8168 &symtab
, &nsyms
, &strtab
, &strtablen
))
8171 dump_relocations (filedata
, rel_offset
, rel_size
,
8172 symtab
, nsyms
, strtab
, strtablen
,
8174 symsec
->sh_type
== SHT_DYNSYM
);
8179 dump_relocations (filedata
, rel_offset
, rel_size
,
8180 NULL
, 0, NULL
, 0, is_rela
,
8181 false /* is_dynamic */);
8189 /* Users sometimes forget the -D option, so try to be helpful. */
8190 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
8192 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
8194 if (filedata
->is_separate
)
8195 printf (_("\nThere are no static relocations in linked file '%s'."),
8196 filedata
->file_name
);
8198 printf (_("\nThere are no static relocations in this file."));
8199 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
8204 if (i
== ARRAY_SIZE (dynamic_relocations
))
8206 if (filedata
->is_separate
)
8207 printf (_("\nThere are no relocations in linked file '%s'.\n"),
8208 filedata
->file_name
);
8210 printf (_("\nThere are no relocations in this file.\n"));
8218 /* An absolute address consists of a section and an offset. If the
8219 section is NULL, the offset itself is the address, otherwise, the
8220 address equals to LOAD_ADDRESS(section) + offset. */
8224 unsigned short section
;
8228 /* Find the nearest symbol at or below ADDR. Returns the symbol
8229 name, if found, and the offset from the symbol to ADDR. */
8232 find_symbol_for_address (Filedata
* filedata
,
8233 Elf_Internal_Sym
* symtab
,
8234 unsigned long nsyms
,
8235 const char * strtab
,
8236 unsigned long strtab_size
,
8237 struct absaddr addr
,
8238 const char ** symname
,
8241 bfd_vma dist
= 0x100000;
8242 Elf_Internal_Sym
* sym
;
8243 Elf_Internal_Sym
* beg
;
8244 Elf_Internal_Sym
* end
;
8245 Elf_Internal_Sym
* best
= NULL
;
8247 REMOVE_ARCH_BITS (addr
.offset
);
8249 end
= symtab
+ nsyms
;
8255 sym
= beg
+ (end
- beg
) / 2;
8257 value
= sym
->st_value
;
8258 REMOVE_ARCH_BITS (value
);
8260 if (sym
->st_name
!= 0
8261 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
8262 && addr
.offset
>= value
8263 && addr
.offset
- value
< dist
)
8266 dist
= addr
.offset
- value
;
8271 if (addr
.offset
< value
)
8279 *symname
= (best
->st_name
>= strtab_size
8280 ? _("<corrupt>") : strtab
+ best
->st_name
);
8286 *offset
= addr
.offset
;
8289 static /* signed */ int
8290 symcmp (const void *p
, const void *q
)
8292 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
8293 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
8295 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
8298 /* Process the unwind section. */
8300 #include "unwind-ia64.h"
8302 struct ia64_unw_table_entry
8304 struct absaddr start
;
8306 struct absaddr info
;
8309 struct ia64_unw_aux_info
8311 struct ia64_unw_table_entry
* table
; /* Unwind table. */
8312 unsigned long table_len
; /* Length of unwind table. */
8313 unsigned char * info
; /* Unwind info. */
8314 unsigned long info_size
; /* Size of unwind info. */
8315 bfd_vma info_addr
; /* Starting address of unwind info. */
8316 bfd_vma seg_base
; /* Starting address of segment. */
8317 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8318 unsigned long nsyms
; /* Number of symbols. */
8319 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8320 unsigned long nfuns
; /* Number of entries in funtab. */
8321 char * strtab
; /* The string table. */
8322 unsigned long strtab_size
; /* Size of string table. */
8326 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
8328 struct ia64_unw_table_entry
* tp
;
8329 unsigned long j
, nfuns
;
8333 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8334 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8335 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8336 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8338 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8340 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8344 const unsigned char * dp
;
8345 const unsigned char * head
;
8346 const unsigned char * end
;
8347 const char * procname
;
8349 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8350 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
8352 fputs ("\n<", stdout
);
8356 fputs (procname
, stdout
);
8359 printf ("+%lx", (unsigned long) offset
);
8362 fputs (">: [", stdout
);
8363 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8364 fputc ('-', stdout
);
8365 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8366 printf ("], info at +0x%lx\n",
8367 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
8369 /* PR 17531: file: 86232b32. */
8370 if (aux
->info
== NULL
)
8373 offset
= tp
->info
.offset
;
8374 if (tp
->info
.section
)
8376 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
8378 warn (_("Invalid section %u in table entry %ld\n"),
8379 tp
->info
.section
, (long) (tp
- aux
->table
));
8383 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
8385 offset
-= aux
->info_addr
;
8386 /* PR 17531: file: 0997b4d1. */
8387 if (offset
>= aux
->info_size
8388 || aux
->info_size
- offset
< 8)
8390 warn (_("Invalid offset %lx in table entry %ld\n"),
8391 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
8396 head
= aux
->info
+ offset
;
8397 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
8399 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
8400 (unsigned) UNW_VER (stamp
),
8401 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
8402 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
8403 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
8404 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
8406 if (UNW_VER (stamp
) != 1)
8408 printf (_("\tUnknown version.\n"));
8413 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
8414 /* PR 17531: file: 16ceda89. */
8415 if (end
> aux
->info
+ aux
->info_size
)
8416 end
= aux
->info
+ aux
->info_size
;
8417 for (dp
= head
+ 8; dp
< end
;)
8418 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
8427 slurp_ia64_unwind_table (Filedata
* filedata
,
8428 struct ia64_unw_aux_info
* aux
,
8429 Elf_Internal_Shdr
* sec
)
8431 unsigned long size
, nrelas
, i
;
8432 Elf_Internal_Phdr
* seg
;
8433 struct ia64_unw_table_entry
* tep
;
8434 Elf_Internal_Shdr
* relsec
;
8435 Elf_Internal_Rela
* rela
;
8436 Elf_Internal_Rela
* rp
;
8437 unsigned char * table
;
8439 Elf_Internal_Sym
* sym
;
8440 const char * relname
;
8444 /* First, find the starting address of the segment that includes
8447 if (filedata
->file_header
.e_phnum
)
8449 if (! get_program_headers (filedata
))
8452 for (seg
= filedata
->program_headers
;
8453 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8456 if (seg
->p_type
!= PT_LOAD
)
8459 if (sec
->sh_addr
>= seg
->p_vaddr
8460 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8462 aux
->seg_base
= seg
->p_vaddr
;
8468 /* Second, build the unwind table from the contents of the unwind section: */
8469 size
= sec
->sh_size
;
8470 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8475 aux
->table_len
= size
/ (3 * eh_addr_size
);
8476 aux
->table
= (struct ia64_unw_table_entry
*)
8477 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
8480 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
8482 tep
->start
.section
= SHN_UNDEF
;
8483 tep
->end
.section
= SHN_UNDEF
;
8484 tep
->info
.section
= SHN_UNDEF
;
8485 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8486 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8487 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8488 tep
->start
.offset
+= aux
->seg_base
;
8489 tep
->end
.offset
+= aux
->seg_base
;
8490 tep
->info
.offset
+= aux
->seg_base
;
8494 /* Third, apply any relocations to the unwind table: */
8495 for (relsec
= filedata
->section_headers
;
8496 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8499 if (relsec
->sh_type
!= SHT_RELA
8500 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8501 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8504 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8513 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8515 unsigned int sym_ndx
;
8516 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8517 relname
= elf_ia64_reloc_type (r_type
);
8519 /* PR 17531: file: 9fa67536. */
8520 if (relname
== NULL
)
8522 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8526 if (! startswith (relname
, "R_IA64_SEGREL"))
8528 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8532 i
= rp
->r_offset
/ (3 * eh_addr_size
);
8534 /* PR 17531: file: 5bc8d9bf. */
8535 if (i
>= aux
->table_len
)
8537 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8541 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8542 if (sym_ndx
>= aux
->nsyms
)
8544 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8548 sym
= aux
->symtab
+ sym_ndx
;
8550 switch (rp
->r_offset
/ eh_addr_size
% 3)
8553 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8554 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
8557 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8558 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
8561 aux
->table
[i
].info
.section
= sym
->st_shndx
;
8562 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
8576 ia64_process_unwind (Filedata
* filedata
)
8578 Elf_Internal_Shdr
* sec
;
8579 Elf_Internal_Shdr
* unwsec
= NULL
;
8580 unsigned long i
, unwcount
= 0, unwstart
= 0;
8581 struct ia64_unw_aux_info aux
;
8584 memset (& aux
, 0, sizeof (aux
));
8586 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8588 if (sec
->sh_type
== SHT_SYMTAB
)
8592 error (_("Multiple symbol tables encountered\n"));
8598 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8599 &aux
.strtab
, &aux
.strtab_size
))
8602 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8607 printf (_("\nThere are no unwind sections in this file.\n"));
8609 while (unwcount
-- > 0)
8614 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
8615 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8616 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8621 /* We have already counted the number of SHT_IA64_UNWIND
8622 sections so the loop above should never fail. */
8623 assert (unwsec
!= NULL
);
8626 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
8628 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
8630 /* We need to find which section group it is in. */
8631 struct group_list
* g
;
8633 if (filedata
->section_headers_groups
== NULL
8634 || filedata
->section_headers_groups
[i
] == NULL
)
8635 i
= filedata
->file_header
.e_shnum
;
8638 g
= filedata
->section_headers_groups
[i
]->root
;
8640 for (; g
!= NULL
; g
= g
->next
)
8642 sec
= filedata
->section_headers
+ g
->section_index
;
8644 if (section_name_valid (filedata
, sec
)
8645 && streq (section_name (filedata
, sec
),
8646 ELF_STRING_ia64_unwind_info
))
8651 i
= filedata
->file_header
.e_shnum
;
8654 else if (section_name_valid (filedata
, unwsec
)
8655 && startswith (section_name (filedata
, unwsec
),
8656 ELF_STRING_ia64_unwind_once
))
8658 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
8659 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
8660 suffix
= section_name (filedata
, unwsec
) + len
;
8661 for (i
= 0, sec
= filedata
->section_headers
;
8662 i
< filedata
->file_header
.e_shnum
;
8664 if (section_name_valid (filedata
, sec
)
8665 && startswith (section_name (filedata
, sec
),
8666 ELF_STRING_ia64_unwind_info_once
)
8667 && streq (section_name (filedata
, sec
) + len2
, suffix
))
8672 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
8673 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
8674 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
8675 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
8677 if (section_name_valid (filedata
, unwsec
)
8678 && startswith (section_name (filedata
, unwsec
),
8679 ELF_STRING_ia64_unwind
))
8680 suffix
= section_name (filedata
, unwsec
) + len
;
8681 for (i
= 0, sec
= filedata
->section_headers
;
8682 i
< filedata
->file_header
.e_shnum
;
8684 if (section_name_valid (filedata
, sec
)
8685 && startswith (section_name (filedata
, sec
),
8686 ELF_STRING_ia64_unwind_info
)
8687 && streq (section_name (filedata
, sec
) + len2
, suffix
))
8691 if (i
== filedata
->file_header
.e_shnum
)
8693 printf (_("\nCould not find unwind info section for "));
8695 if (filedata
->string_table
== NULL
)
8696 printf ("%d", unwsec
->sh_name
);
8698 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8702 aux
.info_addr
= sec
->sh_addr
;
8703 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
8706 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
8708 printf (_("\nUnwind section "));
8710 if (filedata
->string_table
== NULL
)
8711 printf ("%d", unwsec
->sh_name
);
8713 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8715 printf (_(" at offset 0x%lx contains %lu entries:\n"),
8716 (unsigned long) unwsec
->sh_offset
,
8717 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
8719 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
8720 && aux
.table_len
> 0)
8721 dump_ia64_unwind (filedata
, & aux
);
8723 free ((char *) aux
.table
);
8724 free ((char *) aux
.info
);
8731 free ((char *) aux
.strtab
);
8736 struct hppa_unw_table_entry
8738 struct absaddr start
;
8740 unsigned int Cannot_unwind
:1; /* 0 */
8741 unsigned int Millicode
:1; /* 1 */
8742 unsigned int Millicode_save_sr0
:1; /* 2 */
8743 unsigned int Region_description
:2; /* 3..4 */
8744 unsigned int reserved1
:1; /* 5 */
8745 unsigned int Entry_SR
:1; /* 6 */
8746 unsigned int Entry_FR
:4; /* Number saved 7..10 */
8747 unsigned int Entry_GR
:5; /* Number saved 11..15 */
8748 unsigned int Args_stored
:1; /* 16 */
8749 unsigned int Variable_Frame
:1; /* 17 */
8750 unsigned int Separate_Package_Body
:1; /* 18 */
8751 unsigned int Frame_Extension_Millicode
:1; /* 19 */
8752 unsigned int Stack_Overflow_Check
:1; /* 20 */
8753 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
8754 unsigned int Ada_Region
:1; /* 22 */
8755 unsigned int cxx_info
:1; /* 23 */
8756 unsigned int cxx_try_catch
:1; /* 24 */
8757 unsigned int sched_entry_seq
:1; /* 25 */
8758 unsigned int reserved2
:1; /* 26 */
8759 unsigned int Save_SP
:1; /* 27 */
8760 unsigned int Save_RP
:1; /* 28 */
8761 unsigned int Save_MRP_in_frame
:1; /* 29 */
8762 unsigned int extn_ptr_defined
:1; /* 30 */
8763 unsigned int Cleanup_defined
:1; /* 31 */
8765 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
8766 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
8767 unsigned int Large_frame
:1; /* 2 */
8768 unsigned int Pseudo_SP_Set
:1; /* 3 */
8769 unsigned int reserved4
:1; /* 4 */
8770 unsigned int Total_frame_size
:27; /* 5..31 */
8773 struct hppa_unw_aux_info
8775 struct hppa_unw_table_entry
* table
; /* Unwind table. */
8776 unsigned long table_len
; /* Length of unwind table. */
8777 bfd_vma seg_base
; /* Starting address of segment. */
8778 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8779 unsigned long nsyms
; /* Number of symbols. */
8780 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8781 unsigned long nfuns
; /* Number of entries in funtab. */
8782 char * strtab
; /* The string table. */
8783 unsigned long strtab_size
; /* Size of string table. */
8787 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8789 struct hppa_unw_table_entry
* tp
;
8790 unsigned long j
, nfuns
;
8793 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8794 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8795 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8796 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8798 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8800 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8803 const char * procname
;
8805 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8806 aux
->strtab_size
, tp
->start
, &procname
,
8809 fputs ("\n<", stdout
);
8813 fputs (procname
, stdout
);
8816 printf ("+%lx", (unsigned long) offset
);
8819 fputs (">: [", stdout
);
8820 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8821 fputc ('-', stdout
);
8822 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8825 #define PF(_m) if (tp->_m) printf (#_m " ");
8826 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8829 PF(Millicode_save_sr0
);
8830 /* PV(Region_description); */
8836 PF(Separate_Package_Body
);
8837 PF(Frame_Extension_Millicode
);
8838 PF(Stack_Overflow_Check
);
8839 PF(Two_Instruction_SP_Increment
);
8843 PF(sched_entry_seq
);
8846 PF(Save_MRP_in_frame
);
8847 PF(extn_ptr_defined
);
8848 PF(Cleanup_defined
);
8849 PF(MPE_XL_interrupt_marker
);
8850 PF(HP_UX_interrupt_marker
);
8853 PV(Total_frame_size
);
8866 slurp_hppa_unwind_table (Filedata
* filedata
,
8867 struct hppa_unw_aux_info
* aux
,
8868 Elf_Internal_Shdr
* sec
)
8870 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8871 Elf_Internal_Phdr
* seg
;
8872 struct hppa_unw_table_entry
* tep
;
8873 Elf_Internal_Shdr
* relsec
;
8874 Elf_Internal_Rela
* rela
;
8875 Elf_Internal_Rela
* rp
;
8876 unsigned char * table
;
8878 Elf_Internal_Sym
* sym
;
8879 const char * relname
;
8881 /* First, find the starting address of the segment that includes
8883 if (filedata
->file_header
.e_phnum
)
8885 if (! get_program_headers (filedata
))
8888 for (seg
= filedata
->program_headers
;
8889 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8892 if (seg
->p_type
!= PT_LOAD
)
8895 if (sec
->sh_addr
>= seg
->p_vaddr
8896 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8898 aux
->seg_base
= seg
->p_vaddr
;
8904 /* Second, build the unwind table from the contents of the unwind
8906 size
= sec
->sh_size
;
8907 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8913 nentries
= size
/ unw_ent_size
;
8914 size
= unw_ent_size
* nentries
;
8916 aux
->table_len
= nentries
;
8917 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8918 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8920 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8922 unsigned int tmp1
, tmp2
;
8924 tep
->start
.section
= SHN_UNDEF
;
8925 tep
->end
.section
= SHN_UNDEF
;
8927 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8928 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8929 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8930 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8932 tep
->start
.offset
+= aux
->seg_base
;
8933 tep
->end
.offset
+= aux
->seg_base
;
8935 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8936 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8937 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8938 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8939 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8940 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8941 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8942 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8943 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8944 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8945 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8946 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8947 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8948 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8949 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8950 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8951 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8952 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8953 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8954 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8955 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8956 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8957 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8958 tep
->Cleanup_defined
= tmp1
& 0x1;
8960 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8961 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8962 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8963 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8964 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8965 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8969 /* Third, apply any relocations to the unwind table. */
8970 for (relsec
= filedata
->section_headers
;
8971 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8974 if (relsec
->sh_type
!= SHT_RELA
8975 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8976 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8979 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8983 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8985 unsigned int sym_ndx
;
8986 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8987 relname
= elf_hppa_reloc_type (r_type
);
8989 if (relname
== NULL
)
8991 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8995 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8996 if (! startswith (relname
, "R_PARISC_SEGREL"))
8998 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
9002 i
= rp
->r_offset
/ unw_ent_size
;
9003 if (i
>= aux
->table_len
)
9005 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
9009 sym_ndx
= get_reloc_symindex (rp
->r_info
);
9010 if (sym_ndx
>= aux
->nsyms
)
9012 warn (_("Skipping reloc with invalid symbol index: %u\n"),
9016 sym
= aux
->symtab
+ sym_ndx
;
9018 switch ((rp
->r_offset
% unw_ent_size
) / 4)
9021 aux
->table
[i
].start
.section
= sym
->st_shndx
;
9022 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
9025 aux
->table
[i
].end
.section
= sym
->st_shndx
;
9026 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
9040 hppa_process_unwind (Filedata
* filedata
)
9042 struct hppa_unw_aux_info aux
;
9043 Elf_Internal_Shdr
* unwsec
= NULL
;
9044 Elf_Internal_Shdr
* sec
;
9048 if (filedata
->string_table
== NULL
)
9051 memset (& aux
, 0, sizeof (aux
));
9053 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9055 if (sec
->sh_type
== SHT_SYMTAB
)
9059 error (_("Multiple symbol tables encountered\n"));
9065 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9066 &aux
.strtab
, &aux
.strtab_size
))
9069 else if (section_name_valid (filedata
, sec
)
9070 && streq (section_name (filedata
, sec
), ".PARISC.unwind"))
9075 printf (_("\nThere are no unwind sections in this file.\n"));
9077 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9079 if (section_name_valid (filedata
, sec
)
9080 && streq (section_name (filedata
, sec
), ".PARISC.unwind"))
9082 unsigned long num_unwind
= sec
->sh_size
/ 16;
9084 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9085 "contains %lu entry:\n",
9086 "\nUnwind section '%s' at offset 0x%lx "
9087 "contains %lu entries:\n",
9089 printable_section_name (filedata
, sec
),
9090 (unsigned long) sec
->sh_offset
,
9093 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
9096 if (res
&& aux
.table_len
> 0)
9098 if (! dump_hppa_unwind (filedata
, &aux
))
9102 free ((char *) aux
.table
);
9108 free ((char *) aux
.strtab
);
9115 unsigned char * data
; /* The unwind data. */
9116 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
9117 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
9118 unsigned long nrelas
; /* The number of relocations. */
9119 unsigned int rel_type
; /* REL or RELA ? */
9120 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
9123 struct arm_unw_aux_info
9125 Filedata
* filedata
; /* The file containing the unwind sections. */
9126 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
9127 unsigned long nsyms
; /* Number of symbols. */
9128 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
9129 unsigned long nfuns
; /* Number of these symbols. */
9130 char * strtab
; /* The file's string table. */
9131 unsigned long strtab_size
; /* Size of string table. */
9135 arm_print_vma_and_name (Filedata
* filedata
,
9136 struct arm_unw_aux_info
* aux
,
9138 struct absaddr addr
)
9140 const char *procname
;
9143 if (addr
.section
== SHN_UNDEF
)
9146 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
9147 aux
->strtab_size
, addr
, &procname
,
9150 print_vma (fn
, PREFIX_HEX
);
9154 fputs (" <", stdout
);
9155 fputs (procname
, stdout
);
9158 printf ("+0x%lx", (unsigned long) sym_offset
);
9159 fputc ('>', stdout
);
9166 arm_free_section (struct arm_section
*arm_sec
)
9168 free (arm_sec
->data
);
9169 free (arm_sec
->rela
);
9172 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
9173 cached section and install SEC instead.
9174 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
9175 and return its valued in * WORDP, relocating if necessary.
9176 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
9177 relocation's offset in ADDR.
9178 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
9179 into the string table of the symbol associated with the reloc. If no
9180 reloc was applied store -1 there.
9181 5) Return TRUE upon success, FALSE otherwise. */
9184 get_unwind_section_word (Filedata
* filedata
,
9185 struct arm_unw_aux_info
* aux
,
9186 struct arm_section
* arm_sec
,
9187 Elf_Internal_Shdr
* sec
,
9188 bfd_vma word_offset
,
9189 unsigned int * wordp
,
9190 struct absaddr
* addr
,
9193 Elf_Internal_Rela
*rp
;
9194 Elf_Internal_Sym
*sym
;
9195 const char * relname
;
9199 if (sec
== NULL
|| arm_sec
== NULL
)
9202 addr
->section
= SHN_UNDEF
;
9205 if (sym_name
!= NULL
)
9206 *sym_name
= (bfd_vma
) -1;
9208 /* If necessary, update the section cache. */
9209 if (sec
!= arm_sec
->sec
)
9211 Elf_Internal_Shdr
*relsec
;
9213 arm_free_section (arm_sec
);
9216 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
9217 sec
->sh_size
, _("unwind data"));
9218 arm_sec
->rela
= NULL
;
9219 arm_sec
->nrelas
= 0;
9221 for (relsec
= filedata
->section_headers
;
9222 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
9225 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
9226 || filedata
->section_headers
+ relsec
->sh_info
!= sec
9227 /* PR 15745: Check the section type as well. */
9228 || (relsec
->sh_type
!= SHT_REL
9229 && relsec
->sh_type
!= SHT_RELA
))
9232 arm_sec
->rel_type
= relsec
->sh_type
;
9233 if (relsec
->sh_type
== SHT_REL
)
9235 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
9237 & arm_sec
->rela
, & arm_sec
->nrelas
))
9240 else /* relsec->sh_type == SHT_RELA */
9242 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
9244 & arm_sec
->rela
, & arm_sec
->nrelas
))
9250 arm_sec
->next_rela
= arm_sec
->rela
;
9253 /* If there is no unwind data we can do nothing. */
9254 if (arm_sec
->data
== NULL
)
9257 /* If the offset is invalid then fail. */
9258 if (/* PR 21343 *//* PR 18879 */
9260 || word_offset
> (sec
->sh_size
- 4)
9261 || ((bfd_signed_vma
) word_offset
) < 0)
9264 /* Get the word at the required offset. */
9265 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
9267 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
9268 if (arm_sec
->rela
== NULL
)
9274 /* Look through the relocs to find the one that applies to the provided offset. */
9276 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
9278 bfd_vma prelval
, offset
;
9280 if (rp
->r_offset
> word_offset
&& !wrapped
)
9285 if (rp
->r_offset
> word_offset
)
9288 if (rp
->r_offset
& 3)
9290 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
9291 (unsigned long) rp
->r_offset
);
9295 if (rp
->r_offset
< word_offset
)
9298 /* PR 17531: file: 027-161405-0.004 */
9299 if (aux
->symtab
== NULL
)
9302 if (arm_sec
->rel_type
== SHT_REL
)
9304 offset
= word
& 0x7fffffff;
9305 if (offset
& 0x40000000)
9306 offset
|= ~ (bfd_vma
) 0x7fffffff;
9308 else if (arm_sec
->rel_type
== SHT_RELA
)
9309 offset
= rp
->r_addend
;
9312 error (_("Unknown section relocation type %d encountered\n"),
9317 /* PR 17531 file: 027-1241568-0.004. */
9318 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
9320 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
9321 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
9325 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
9326 offset
+= sym
->st_value
;
9327 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
9329 /* Check that we are processing the expected reloc type. */
9330 if (filedata
->file_header
.e_machine
== EM_ARM
)
9332 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
9333 if (relname
== NULL
)
9335 warn (_("Skipping unknown ARM relocation type: %d\n"),
9336 (int) ELF32_R_TYPE (rp
->r_info
));
9340 if (streq (relname
, "R_ARM_NONE"))
9343 if (! streq (relname
, "R_ARM_PREL31"))
9345 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
9349 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9351 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
9352 if (relname
== NULL
)
9354 warn (_("Skipping unknown C6000 relocation type: %d\n"),
9355 (int) ELF32_R_TYPE (rp
->r_info
));
9359 if (streq (relname
, "R_C6000_NONE"))
9362 if (! streq (relname
, "R_C6000_PREL31"))
9364 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
9372 /* This function currently only supports ARM and TI unwinders. */
9373 warn (_("Only TI and ARM unwinders are currently supported\n"));
9377 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
9378 addr
->section
= sym
->st_shndx
;
9379 addr
->offset
= offset
;
9382 * sym_name
= sym
->st_name
;
9387 arm_sec
->next_rela
= rp
;
9392 static const char *tic6x_unwind_regnames
[16] =
9394 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
9395 "A14", "A13", "A12", "A11", "A10",
9396 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
9400 decode_tic6x_unwind_regmask (unsigned int mask
)
9404 for (i
= 12; mask
; mask
>>= 1, i
--)
9408 fputs (tic6x_unwind_regnames
[i
], stdout
);
9410 fputs (", ", stdout
);
9416 if (remaining == 0 && more_words) \
9419 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
9420 data_offset, & word, & addr, NULL)) \
9426 #define GET_OP(OP) \
9431 (OP) = word >> 24; \
9436 printf (_("[Truncated opcode]\n")); \
9439 printf ("0x%02x ", OP)
9442 decode_arm_unwind_bytecode (Filedata
* filedata
,
9443 struct arm_unw_aux_info
* aux
,
9445 unsigned int remaining
,
9446 unsigned int more_words
,
9447 bfd_vma data_offset
,
9448 Elf_Internal_Shdr
* data_sec
,
9449 struct arm_section
* data_arm_sec
)
9451 struct absaddr addr
;
9454 /* Decode the unwinding instructions. */
9457 unsigned int op
, op2
;
9466 printf (" 0x%02x ", op
);
9468 if ((op
& 0xc0) == 0x00)
9470 int offset
= ((op
& 0x3f) << 2) + 4;
9472 printf (" vsp = vsp + %d", offset
);
9474 else if ((op
& 0xc0) == 0x40)
9476 int offset
= ((op
& 0x3f) << 2) + 4;
9478 printf (" vsp = vsp - %d", offset
);
9480 else if ((op
& 0xf0) == 0x80)
9483 if (op
== 0x80 && op2
== 0)
9484 printf (_("Refuse to unwind"));
9487 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
9492 for (i
= 0; i
< 12; i
++)
9493 if (mask
& (1 << i
))
9499 printf ("r%d", 4 + i
);
9504 else if ((op
& 0xf0) == 0x90)
9506 if (op
== 0x9d || op
== 0x9f)
9507 printf (_(" [Reserved]"));
9509 printf (" vsp = r%d", op
& 0x0f);
9511 else if ((op
& 0xf0) == 0xa0)
9513 int end
= 4 + (op
& 0x07);
9518 for (i
= 4; i
<= end
; i
++)
9534 else if (op
== 0xb0)
9535 printf (_(" finish"));
9536 else if (op
== 0xb1)
9539 if (op2
== 0 || (op2
& 0xf0) != 0)
9540 printf (_("[Spare]"));
9543 unsigned int mask
= op2
& 0x0f;
9548 for (i
= 0; i
< 12; i
++)
9549 if (mask
& (1 << i
))
9560 else if (op
== 0xb2)
9562 unsigned char buf
[9];
9563 unsigned int i
, len
;
9564 unsigned long offset
;
9566 for (i
= 0; i
< sizeof (buf
); i
++)
9569 if ((buf
[i
] & 0x80) == 0)
9572 if (i
== sizeof (buf
))
9574 error (_("corrupt change to vsp\n"));
9579 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
9580 assert (len
== i
+ 1);
9581 offset
= offset
* 4 + 0x204;
9582 printf ("vsp = vsp + %ld", offset
);
9585 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
9587 unsigned int first
, last
;
9594 printf ("pop {D%d", first
);
9596 printf ("-D%d", first
+ last
);
9599 else if (op
== 0xb4)
9600 printf (_(" pop {ra_auth_code}"));
9601 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
9603 unsigned int count
= op
& 0x07;
9607 printf ("-D%d", 8 + count
);
9610 else if (op
>= 0xc0 && op
<= 0xc5)
9612 unsigned int count
= op
& 0x07;
9614 printf (" pop {wR10");
9616 printf ("-wR%d", 10 + count
);
9619 else if (op
== 0xc6)
9621 unsigned int first
, last
;
9626 printf ("pop {wR%d", first
);
9628 printf ("-wR%d", first
+ last
);
9631 else if (op
== 0xc7)
9634 if (op2
== 0 || (op2
& 0xf0) != 0)
9635 printf (_("[Spare]"));
9638 unsigned int mask
= op2
& 0x0f;
9643 for (i
= 0; i
< 4; i
++)
9644 if (mask
& (1 << i
))
9650 printf ("wCGR%d", i
);
9657 printf (_(" [unsupported opcode]"));
9668 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
9669 struct arm_unw_aux_info
* aux
,
9671 unsigned int remaining
,
9672 unsigned int more_words
,
9673 bfd_vma data_offset
,
9674 Elf_Internal_Shdr
* data_sec
,
9675 struct arm_section
* data_arm_sec
)
9677 struct absaddr addr
;
9679 /* Decode the unwinding instructions. */
9682 unsigned int op
, op2
;
9691 printf (" 0x%02x ", op
);
9693 if ((op
& 0xc0) == 0x00)
9695 int offset
= ((op
& 0x3f) << 3) + 8;
9696 printf (" sp = sp + %d", offset
);
9698 else if ((op
& 0xc0) == 0x80)
9701 if (op
== 0x80 && op2
== 0)
9702 printf (_("Refuse to unwind"));
9705 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
9707 printf ("pop compact {");
9711 decode_tic6x_unwind_regmask (mask
);
9715 else if ((op
& 0xf0) == 0xc0)
9723 unsigned int offset
;
9727 /* Scan entire instruction first so that GET_OP output is not
9728 interleaved with disassembly. */
9730 for (i
= 0; nregs
< (op
& 0xf); i
++)
9736 regpos
[nregs
].offset
= i
* 2;
9737 regpos
[nregs
].reg
= reg
;
9744 regpos
[nregs
].offset
= i
* 2 + 1;
9745 regpos
[nregs
].reg
= reg
;
9750 printf (_("pop frame {"));
9753 printf (_("*corrupt* - no registers specified"));
9758 for (i
= i
* 2; i
> 0; i
--)
9760 if (regpos
[reg
].offset
== i
- 1)
9762 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
9769 fputs (name
, stdout
);
9777 else if (op
== 0xd0)
9778 printf (" MOV FP, SP");
9779 else if (op
== 0xd1)
9780 printf (" __c6xabi_pop_rts");
9781 else if (op
== 0xd2)
9783 unsigned char buf
[9];
9784 unsigned int i
, len
;
9785 unsigned long offset
;
9787 for (i
= 0; i
< sizeof (buf
); i
++)
9790 if ((buf
[i
] & 0x80) == 0)
9793 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9794 if (i
== sizeof (buf
))
9796 warn (_("Corrupt stack pointer adjustment detected\n"));
9800 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
9801 assert (len
== i
+ 1);
9802 offset
= offset
* 8 + 0x408;
9803 printf (_("sp = sp + %ld"), offset
);
9805 else if ((op
& 0xf0) == 0xe0)
9807 if ((op
& 0x0f) == 7)
9810 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9814 printf (_(" [unsupported opcode]"));
9823 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9827 offset
= word
& 0x7fffffff;
9828 if (offset
& 0x40000000)
9829 offset
|= ~ (bfd_vma
) 0x7fffffff;
9831 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9834 return offset
+ where
;
9838 decode_arm_unwind (Filedata
* filedata
,
9839 struct arm_unw_aux_info
* aux
,
9841 unsigned int remaining
,
9842 bfd_vma data_offset
,
9843 Elf_Internal_Shdr
* data_sec
,
9844 struct arm_section
* data_arm_sec
)
9847 unsigned int more_words
= 0;
9848 struct absaddr addr
;
9849 bfd_vma sym_name
= (bfd_vma
) -1;
9854 /* Fetch the first word.
9855 Note - when decoding an object file the address extracted
9856 here will always be 0. So we also pass in the sym_name
9857 parameter so that we can find the symbol associated with
9858 the personality routine. */
9859 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9860 & word
, & addr
, & sym_name
))
9867 addr
.section
= SHN_UNDEF
;
9871 if ((word
& 0x80000000) == 0)
9873 /* Expand prel31 for personality routine. */
9875 const char *procname
;
9877 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9878 printf (_(" Personality routine: "));
9880 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9881 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9883 procname
= aux
->strtab
+ sym_name
;
9884 print_vma (fn
, PREFIX_HEX
);
9887 fputs (" <", stdout
);
9888 fputs (procname
, stdout
);
9889 fputc ('>', stdout
);
9893 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9894 fputc ('\n', stdout
);
9896 /* The GCC personality routines use the standard compact
9897 encoding, starting with one byte giving the number of
9899 if (procname
!= NULL
9900 && (startswith (procname
, "__gcc_personality_v0")
9901 || startswith (procname
, "__gxx_personality_v0")
9902 || startswith (procname
, "__gcj_personality_v0")
9903 || startswith (procname
, "__gnu_objc_personality_v0")))
9910 printf (_(" [Truncated data]\n"));
9913 more_words
= word
>> 24;
9923 /* ARM EHABI Section 6.3:
9925 An exception-handling table entry for the compact model looks like:
9929 1 0 index Data for personalityRoutine[index] */
9931 if (filedata
->file_header
.e_machine
== EM_ARM
9932 && (word
& 0x70000000))
9934 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9938 per_index
= (word
>> 24) & 0x7f;
9939 printf (_(" Compact model index: %d\n"), per_index
);
9946 else if (per_index
< 3)
9948 more_words
= (word
>> 16) & 0xff;
9954 switch (filedata
->file_header
.e_machine
)
9959 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9960 data_offset
, data_sec
, data_arm_sec
))
9965 warn (_("Unknown ARM compact model index encountered\n"));
9966 printf (_(" [reserved]\n"));
9974 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9975 data_offset
, data_sec
, data_arm_sec
))
9978 else if (per_index
< 5)
9980 if (((word
>> 17) & 0x7f) == 0x7f)
9981 printf (_(" Restore stack from frame pointer\n"));
9983 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9984 printf (_(" Registers restored: "));
9986 printf (" (compact) ");
9987 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9989 printf (_(" Return register: %s\n"),
9990 tic6x_unwind_regnames
[word
& 0xf]);
9993 printf (_(" [reserved (%d)]\n"), per_index
);
9997 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9998 filedata
->file_header
.e_machine
);
10002 /* Decode the descriptors. Not implemented. */
10008 dump_arm_unwind (Filedata
* filedata
,
10009 struct arm_unw_aux_info
* aux
,
10010 Elf_Internal_Shdr
* exidx_sec
)
10012 struct arm_section exidx_arm_sec
, extab_arm_sec
;
10013 unsigned int i
, exidx_len
;
10014 unsigned long j
, nfuns
;
10017 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
10018 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
10019 exidx_len
= exidx_sec
->sh_size
/ 8;
10021 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
10022 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
10023 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
10024 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
10025 aux
->nfuns
= nfuns
;
10026 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
10028 for (i
= 0; i
< exidx_len
; i
++)
10030 unsigned int exidx_fn
, exidx_entry
;
10031 struct absaddr fn_addr
, entry_addr
;
10034 fputc ('\n', stdout
);
10036 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
10037 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
10038 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
10039 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
10041 free (aux
->funtab
);
10042 arm_free_section (& exidx_arm_sec
);
10043 arm_free_section (& extab_arm_sec
);
10047 /* ARM EHABI, Section 5:
10048 An index table entry consists of 2 words.
10049 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
10050 if (exidx_fn
& 0x80000000)
10052 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
10056 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
10058 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
10059 fputs (": ", stdout
);
10061 if (exidx_entry
== 1)
10063 print_vma (exidx_entry
, PREFIX_HEX
);
10064 fputs (" [cantunwind]\n", stdout
);
10066 else if (exidx_entry
& 0x80000000)
10068 print_vma (exidx_entry
, PREFIX_HEX
);
10069 fputc ('\n', stdout
);
10070 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
10074 bfd_vma table
, table_offset
= 0;
10075 Elf_Internal_Shdr
*table_sec
;
10077 fputs ("@", stdout
);
10078 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
10079 print_vma (table
, PREFIX_HEX
);
10082 /* Locate the matching .ARM.extab. */
10083 if (entry_addr
.section
!= SHN_UNDEF
10084 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
10086 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
10087 table_offset
= entry_addr
.offset
;
10089 if (table_offset
> table_sec
->sh_size
10090 || ((bfd_signed_vma
) table_offset
) < 0)
10092 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
10093 (unsigned long) table_offset
,
10094 printable_section_name (filedata
, table_sec
));
10101 table_sec
= find_section_by_address (filedata
, table
);
10102 if (table_sec
!= NULL
)
10103 table_offset
= table
- table_sec
->sh_addr
;
10106 if (table_sec
== NULL
)
10108 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
10109 (unsigned long) table
);
10114 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
10122 free (aux
->funtab
);
10123 arm_free_section (&exidx_arm_sec
);
10124 arm_free_section (&extab_arm_sec
);
10129 /* Used for both ARM and C6X unwinding tables. */
10132 arm_process_unwind (Filedata
* filedata
)
10134 struct arm_unw_aux_info aux
;
10135 Elf_Internal_Shdr
*unwsec
= NULL
;
10136 Elf_Internal_Shdr
*sec
;
10138 unsigned int sec_type
;
10141 switch (filedata
->file_header
.e_machine
)
10144 sec_type
= SHT_ARM_EXIDX
;
10148 sec_type
= SHT_C6000_UNWIND
;
10152 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
10153 filedata
->file_header
.e_machine
);
10157 if (filedata
->string_table
== NULL
)
10160 memset (& aux
, 0, sizeof (aux
));
10161 aux
.filedata
= filedata
;
10163 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
10165 if (sec
->sh_type
== SHT_SYMTAB
)
10169 error (_("Multiple symbol tables encountered\n"));
10175 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
10176 &aux
.strtab
, &aux
.strtab_size
))
10179 else if (sec
->sh_type
== sec_type
)
10183 if (unwsec
== NULL
)
10184 printf (_("\nThere are no unwind sections in this file.\n"));
10186 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
10188 if (sec
->sh_type
== sec_type
)
10190 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
10191 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
10192 "contains %lu entry:\n",
10193 "\nUnwind section '%s' at offset 0x%lx "
10194 "contains %lu entries:\n",
10196 printable_section_name (filedata
, sec
),
10197 (unsigned long) sec
->sh_offset
,
10200 if (! dump_arm_unwind (filedata
, &aux
, sec
))
10206 free ((char *) aux
.strtab
);
10212 no_processor_specific_unwind (Filedata
* filedata ATTRIBUTE_UNUSED
)
10214 printf (_("No processor specific unwind information to decode\n"));
10219 process_unwind (Filedata
* filedata
)
10221 struct unwind_handler
10223 unsigned int machtype
;
10224 bool (* handler
)(Filedata
*);
10227 { EM_ARM
, arm_process_unwind
},
10228 { EM_IA_64
, ia64_process_unwind
},
10229 { EM_PARISC
, hppa_process_unwind
},
10230 { EM_TI_C6000
, arm_process_unwind
},
10231 { EM_386
, no_processor_specific_unwind
},
10232 { EM_X86_64
, no_processor_specific_unwind
},
10240 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
10241 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
10242 return handlers
[i
].handler (filedata
);
10244 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
10245 get_machine_name (filedata
->file_header
.e_machine
));
10250 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
10252 switch (entry
->d_tag
)
10254 case DT_AARCH64_BTI_PLT
:
10255 case DT_AARCH64_PAC_PLT
:
10258 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10265 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
10267 switch (entry
->d_tag
)
10269 case DT_MIPS_FLAGS
:
10270 if (entry
->d_un
.d_val
== 0)
10271 printf (_("NONE"));
10274 static const char * opts
[] =
10276 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
10277 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
10278 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
10279 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
10285 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
10286 if (entry
->d_un
.d_val
& (1 << cnt
))
10288 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
10294 case DT_MIPS_IVERSION
:
10295 if (valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
10296 printf (_("Interface Version: %s"),
10297 get_dynamic_name (filedata
, entry
->d_un
.d_val
));
10301 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
10302 /* Note: coded this way so that there is a single string for translation. */
10303 printf (_("<corrupt: %s>"), buf
);
10307 case DT_MIPS_TIME_STAMP
:
10311 time_t atime
= entry
->d_un
.d_val
;
10313 tmp
= gmtime (&atime
);
10314 /* PR 17531: file: 6accc532. */
10316 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
10318 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
10319 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10320 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10321 printf (_("Time Stamp: %s"), timebuf
);
10325 case DT_MIPS_RLD_VERSION
:
10326 case DT_MIPS_LOCAL_GOTNO
:
10327 case DT_MIPS_CONFLICTNO
:
10328 case DT_MIPS_LIBLISTNO
:
10329 case DT_MIPS_SYMTABNO
:
10330 case DT_MIPS_UNREFEXTNO
:
10331 case DT_MIPS_HIPAGENO
:
10332 case DT_MIPS_DELTA_CLASS_NO
:
10333 case DT_MIPS_DELTA_INSTANCE_NO
:
10334 case DT_MIPS_DELTA_RELOC_NO
:
10335 case DT_MIPS_DELTA_SYM_NO
:
10336 case DT_MIPS_DELTA_CLASSSYM_NO
:
10337 case DT_MIPS_COMPACT_SIZE
:
10338 print_vma (entry
->d_un
.d_val
, DEC
);
10341 case DT_MIPS_XHASH
:
10342 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10343 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10344 /* Falls through. */
10347 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10353 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
10355 switch (entry
->d_tag
)
10357 case DT_HP_DLD_FLAGS
:
10366 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
10367 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
10368 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
10369 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
10370 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
10371 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
10372 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
10373 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
10374 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
10375 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
10376 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
10377 { DT_HP_GST
, "HP_GST" },
10378 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
10379 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
10380 { DT_HP_NODELETE
, "HP_NODELETE" },
10381 { DT_HP_GROUP
, "HP_GROUP" },
10382 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
10386 bfd_vma val
= entry
->d_un
.d_val
;
10388 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
10389 if (val
& flags
[cnt
].bit
)
10393 fputs (flags
[cnt
].str
, stdout
);
10395 val
^= flags
[cnt
].bit
;
10398 if (val
!= 0 || first
)
10402 print_vma (val
, HEX
);
10408 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10416 /* VMS vs Unix time offset and factor. */
10418 #define VMS_EPOCH_OFFSET 35067168000000000LL
10419 #define VMS_GRANULARITY_FACTOR 10000000
10421 #define INT64_MIN (-9223372036854775807LL - 1)
10424 /* Display a VMS time in a human readable format. */
10427 print_vms_time (bfd_int64_t vmstime
)
10429 struct tm
*tm
= NULL
;
10432 if (vmstime
>= INT64_MIN
+ VMS_EPOCH_OFFSET
)
10434 vmstime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
10436 if (unxtime
== vmstime
)
10437 tm
= gmtime (&unxtime
);
10440 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
10441 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
10442 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
10447 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
10449 switch (entry
->d_tag
)
10451 case DT_IA_64_PLT_RESERVE
:
10452 /* First 3 slots reserved. */
10453 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10455 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
10458 case DT_IA_64_VMS_LINKTIME
:
10460 print_vms_time (entry
->d_un
.d_val
);
10464 case DT_IA_64_VMS_LNKFLAGS
:
10465 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10466 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
10467 printf (" CALL_DEBUG");
10468 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
10469 printf (" NOP0BUFS");
10470 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
10471 printf (" P0IMAGE");
10472 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
10473 printf (" MKTHREADS");
10474 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
10475 printf (" UPCALLS");
10476 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
10477 printf (" IMGSTA");
10478 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
10479 printf (" INITIALIZE");
10480 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
10482 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
10483 printf (" EXE_INIT");
10484 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
10485 printf (" TBK_IN_IMG");
10486 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
10487 printf (" DBG_IN_IMG");
10488 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
10489 printf (" TBK_IN_DSF");
10490 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
10491 printf (" DBG_IN_DSF");
10492 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
10493 printf (" SIGNATURES");
10494 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
10495 printf (" REL_SEG_OFF");
10499 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10506 get_32bit_dynamic_section (Filedata
* filedata
)
10508 Elf32_External_Dyn
* edyn
;
10509 Elf32_External_Dyn
* ext
;
10510 Elf_Internal_Dyn
* entry
;
10512 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
10513 filedata
->dynamic_addr
, 1,
10514 filedata
->dynamic_size
,
10515 _("dynamic section"));
10519 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
10520 might not have the luxury of section headers. Look for the DT_NULL
10521 terminator to determine the number of entries. */
10522 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
10523 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
10526 filedata
->dynamic_nent
++;
10527 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
10531 filedata
->dynamic_section
10532 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
10533 if (filedata
->dynamic_section
== NULL
)
10535 error (_("Out of memory allocating space for %lu dynamic entries\n"),
10536 (unsigned long) filedata
->dynamic_nent
);
10541 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10542 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10545 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10546 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10555 get_64bit_dynamic_section (Filedata
* filedata
)
10557 Elf64_External_Dyn
* edyn
;
10558 Elf64_External_Dyn
* ext
;
10559 Elf_Internal_Dyn
* entry
;
10561 /* Read in the data. */
10562 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
10563 filedata
->dynamic_addr
, 1,
10564 filedata
->dynamic_size
,
10565 _("dynamic section"));
10569 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
10570 might not have the luxury of section headers. Look for the DT_NULL
10571 terminator to determine the number of entries. */
10572 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
10573 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
10574 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
10577 filedata
->dynamic_nent
++;
10578 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
10582 filedata
->dynamic_section
10583 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
10584 if (filedata
->dynamic_section
== NULL
)
10586 error (_("Out of memory allocating space for %lu dynamic entries\n"),
10587 (unsigned long) filedata
->dynamic_nent
);
10592 /* Convert from external to internal formats. */
10593 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10594 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10597 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10598 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10607 get_dynamic_section (Filedata
*filedata
)
10609 if (filedata
->dynamic_section
)
10613 return get_32bit_dynamic_section (filedata
);
10615 return get_64bit_dynamic_section (filedata
);
10619 print_dynamic_flags (bfd_vma flags
)
10627 flag
= flags
& - flags
;
10633 putc (' ', stdout
);
10637 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
10638 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
10639 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
10640 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
10641 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
10642 default: fputs (_("unknown"), stdout
); break;
10649 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
10651 unsigned char * e_data
;
10654 /* If the size_t type is smaller than the bfd_size_type, eg because
10655 you are building a 32-bit tool on a 64-bit host, then make sure
10656 that when (number) is cast to (size_t) no information is lost. */
10657 if (sizeof (size_t) < sizeof (bfd_size_type
)
10658 && (bfd_size_type
) ((size_t) number
) != number
)
10660 error (_("Size truncation prevents reading %s elements of size %u\n"),
10661 bfd_vmatoa ("u", number
), ent_size
);
10665 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
10666 attempting to allocate memory when the read is bound to fail. */
10667 if (ent_size
* number
> filedata
->file_size
)
10669 error (_("Invalid number of dynamic entries: %s\n"),
10670 bfd_vmatoa ("u", number
));
10674 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10675 if (e_data
== NULL
)
10677 error (_("Out of memory reading %s dynamic entries\n"),
10678 bfd_vmatoa ("u", number
));
10682 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
10684 error (_("Unable to read in %s bytes of dynamic data\n"),
10685 bfd_vmatoa ("u", number
* ent_size
));
10690 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10691 if (i_data
== NULL
)
10693 error (_("Out of memory allocating space for %s dynamic entries\n"),
10694 bfd_vmatoa ("u", number
));
10700 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10707 static unsigned long
10708 get_num_dynamic_syms (Filedata
* filedata
)
10710 unsigned long num_of_syms
= 0;
10712 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
10713 return num_of_syms
;
10715 if (filedata
->dynamic_info
[DT_HASH
])
10717 unsigned char nb
[8];
10718 unsigned char nc
[8];
10719 unsigned int hash_ent_size
= 4;
10721 if ((filedata
->file_header
.e_machine
== EM_ALPHA
10722 || filedata
->file_header
.e_machine
== EM_S390
10723 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
10724 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10727 if (fseek (filedata
->handle
,
10728 (filedata
->archive_file_offset
10729 + offset_from_vma (filedata
, filedata
->dynamic_info
[DT_HASH
],
10730 sizeof nb
+ sizeof nc
)),
10733 error (_("Unable to seek to start of dynamic information\n"));
10737 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
10739 error (_("Failed to read in number of buckets\n"));
10743 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
10745 error (_("Failed to read in number of chains\n"));
10749 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
10750 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
10752 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
10754 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
10756 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
10759 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
10760 num_of_syms
= filedata
->nchains
;
10763 if (num_of_syms
== 0)
10765 free (filedata
->buckets
);
10766 filedata
->buckets
= NULL
;
10767 free (filedata
->chains
);
10768 filedata
->chains
= NULL
;
10769 filedata
->nbuckets
= 0;
10773 if (filedata
->dynamic_info_DT_GNU_HASH
)
10775 unsigned char nb
[16];
10776 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10777 bfd_vma buckets_vma
;
10780 if (fseek (filedata
->handle
,
10781 (filedata
->archive_file_offset
10782 + offset_from_vma (filedata
,
10783 filedata
->dynamic_info_DT_GNU_HASH
,
10787 error (_("Unable to seek to start of dynamic information\n"));
10791 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
10793 error (_("Failed to read in number of buckets\n"));
10797 filedata
->ngnubuckets
= byte_get (nb
, 4);
10798 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
10799 bitmaskwords
= byte_get (nb
+ 8, 4);
10800 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
10802 buckets_vma
+= bitmaskwords
* 4;
10804 buckets_vma
+= bitmaskwords
* 8;
10806 if (fseek (filedata
->handle
,
10807 (filedata
->archive_file_offset
10808 + offset_from_vma (filedata
, buckets_vma
, 4)),
10811 error (_("Unable to seek to start of dynamic information\n"));
10815 filedata
->gnubuckets
10816 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
10818 if (filedata
->gnubuckets
== NULL
)
10821 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
10822 if (filedata
->gnubuckets
[i
] != 0)
10824 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
10827 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
10828 maxchain
= filedata
->gnubuckets
[i
];
10831 if (maxchain
== 0xffffffff)
10834 maxchain
-= filedata
->gnusymidx
;
10836 if (fseek (filedata
->handle
,
10837 (filedata
->archive_file_offset
10838 + offset_from_vma (filedata
,
10839 buckets_vma
+ 4 * (filedata
->ngnubuckets
10844 error (_("Unable to seek to start of dynamic information\n"));
10850 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
10852 error (_("Failed to determine last chain length\n"));
10856 if (maxchain
+ 1 == 0)
10861 while ((byte_get (nb
, 4) & 1) == 0);
10863 if (fseek (filedata
->handle
,
10864 (filedata
->archive_file_offset
10865 + offset_from_vma (filedata
, (buckets_vma
10866 + 4 * filedata
->ngnubuckets
),
10870 error (_("Unable to seek to start of dynamic information\n"));
10874 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
10875 filedata
->ngnuchains
= maxchain
;
10877 if (filedata
->gnuchains
== NULL
)
10880 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10882 if (fseek (filedata
->handle
,
10883 (filedata
->archive_file_offset
10884 + offset_from_vma (filedata
, (buckets_vma
10885 + 4 * (filedata
->ngnubuckets
10889 error (_("Unable to seek to start of dynamic information\n"));
10893 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
10894 if (filedata
->mipsxlat
== NULL
)
10898 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
10899 if (filedata
->gnubuckets
[hn
] != 0)
10901 bfd_vma si
= filedata
->gnubuckets
[hn
];
10902 bfd_vma off
= si
- filedata
->gnusymidx
;
10906 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10908 if (off
< filedata
->ngnuchains
10909 && filedata
->mipsxlat
[off
] >= num_of_syms
)
10910 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
10914 if (si
>= num_of_syms
)
10915 num_of_syms
= si
+ 1;
10919 while (off
< filedata
->ngnuchains
10920 && (filedata
->gnuchains
[off
++] & 1) == 0);
10923 if (num_of_syms
== 0)
10926 free (filedata
->mipsxlat
);
10927 filedata
->mipsxlat
= NULL
;
10928 free (filedata
->gnuchains
);
10929 filedata
->gnuchains
= NULL
;
10930 free (filedata
->gnubuckets
);
10931 filedata
->gnubuckets
= NULL
;
10932 filedata
->ngnubuckets
= 0;
10933 filedata
->ngnuchains
= 0;
10937 return num_of_syms
;
10940 /* Parse and display the contents of the dynamic section. */
10943 process_dynamic_section (Filedata
* filedata
)
10945 Elf_Internal_Dyn
* entry
;
10947 if (filedata
->dynamic_size
<= 1)
10951 if (filedata
->is_separate
)
10952 printf (_("\nThere is no dynamic section in linked file '%s'.\n"),
10953 filedata
->file_name
);
10955 printf (_("\nThere is no dynamic section in this file.\n"));
10961 if (!get_dynamic_section (filedata
))
10964 /* Find the appropriate symbol table. */
10965 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
10967 unsigned long num_of_syms
;
10969 for (entry
= filedata
->dynamic_section
;
10970 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10972 if (entry
->d_tag
== DT_SYMTAB
)
10973 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
10974 else if (entry
->d_tag
== DT_SYMENT
)
10975 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
10976 else if (entry
->d_tag
== DT_HASH
)
10977 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
10978 else if (entry
->d_tag
== DT_GNU_HASH
)
10979 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10980 else if ((filedata
->file_header
.e_machine
== EM_MIPS
10981 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
10982 && entry
->d_tag
== DT_MIPS_XHASH
)
10984 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10985 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10988 num_of_syms
= get_num_dynamic_syms (filedata
);
10990 if (num_of_syms
!= 0
10991 && filedata
->dynamic_symbols
== NULL
10992 && filedata
->dynamic_info
[DT_SYMTAB
]
10993 && filedata
->dynamic_info
[DT_SYMENT
])
10995 Elf_Internal_Phdr
*seg
;
10996 bfd_vma vma
= filedata
->dynamic_info
[DT_SYMTAB
];
10998 if (! get_program_headers (filedata
))
11000 error (_("Cannot interpret virtual addresses "
11001 "without program headers.\n"));
11005 for (seg
= filedata
->program_headers
;
11006 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
11009 if (seg
->p_type
!= PT_LOAD
)
11012 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
11014 /* See PR 21379 for a reproducer. */
11015 error (_("Invalid PT_LOAD entry\n"));
11019 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
11020 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
11022 /* Since we do not know how big the symbol table is,
11023 we default to reading in up to the end of PT_LOAD
11024 segment and processing that. This is overkill, I
11025 know, but it should work. */
11026 Elf_Internal_Shdr section
;
11027 section
.sh_offset
= (vma
- seg
->p_vaddr
11029 section
.sh_size
= (num_of_syms
11030 * filedata
->dynamic_info
[DT_SYMENT
]);
11031 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
11034 && filedata
->dynamic_symtab_section
!= NULL
11035 && ((filedata
->dynamic_symtab_section
->sh_offset
11036 != section
.sh_offset
)
11037 || (filedata
->dynamic_symtab_section
->sh_size
11038 != section
.sh_size
)
11039 || (filedata
->dynamic_symtab_section
->sh_entsize
11040 != section
.sh_entsize
)))
11042 the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
11044 section
.sh_name
= filedata
->string_table_length
;
11045 filedata
->dynamic_symbols
11046 = get_elf_symbols (filedata
, §ion
,
11047 &filedata
->num_dynamic_syms
);
11048 if (filedata
->dynamic_symbols
== NULL
11049 || filedata
->num_dynamic_syms
!= num_of_syms
)
11051 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
11060 /* Similarly find a string table. */
11061 if (filedata
->dynamic_strings
== NULL
)
11062 for (entry
= filedata
->dynamic_section
;
11063 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11066 if (entry
->d_tag
== DT_STRTAB
)
11067 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
11069 if (entry
->d_tag
== DT_STRSZ
)
11070 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
11072 if (filedata
->dynamic_info
[DT_STRTAB
]
11073 && filedata
->dynamic_info
[DT_STRSZ
])
11075 unsigned long offset
;
11076 bfd_size_type str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
11078 offset
= offset_from_vma (filedata
,
11079 filedata
->dynamic_info
[DT_STRTAB
],
11082 && filedata
->dynamic_strtab_section
11083 && ((filedata
->dynamic_strtab_section
->sh_offset
11084 != (file_ptr
) offset
)
11085 || (filedata
->dynamic_strtab_section
->sh_size
11088 the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
11090 filedata
->dynamic_strings
11091 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
11092 _("dynamic string table"));
11093 if (filedata
->dynamic_strings
== NULL
)
11095 error (_("Corrupt DT_STRTAB dynamic entry\n"));
11099 filedata
->dynamic_strings_length
= str_tab_len
;
11104 /* And find the syminfo section if available. */
11105 if (filedata
->dynamic_syminfo
== NULL
)
11107 unsigned long syminsz
= 0;
11109 for (entry
= filedata
->dynamic_section
;
11110 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11113 if (entry
->d_tag
== DT_SYMINENT
)
11115 /* Note: these braces are necessary to avoid a syntax
11116 error from the SunOS4 C compiler. */
11117 /* PR binutils/17531: A corrupt file can trigger this test.
11118 So do not use an assert, instead generate an error message. */
11119 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
11120 error (_("Bad value (%d) for SYMINENT entry\n"),
11121 (int) entry
->d_un
.d_val
);
11123 else if (entry
->d_tag
== DT_SYMINSZ
)
11124 syminsz
= entry
->d_un
.d_val
;
11125 else if (entry
->d_tag
== DT_SYMINFO
)
11126 filedata
->dynamic_syminfo_offset
11127 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
11130 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
11132 Elf_External_Syminfo
* extsyminfo
;
11133 Elf_External_Syminfo
* extsym
;
11134 Elf_Internal_Syminfo
* syminfo
;
11136 /* There is a syminfo section. Read the data. */
11137 extsyminfo
= (Elf_External_Syminfo
*)
11138 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
11139 1, syminsz
, _("symbol information"));
11143 if (filedata
->dynamic_syminfo
!= NULL
)
11145 error (_("Multiple dynamic symbol information sections found\n"));
11146 free (filedata
->dynamic_syminfo
);
11148 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
11149 if (filedata
->dynamic_syminfo
== NULL
)
11151 error (_("Out of memory allocating %lu bytes "
11152 "for dynamic symbol info\n"),
11153 (unsigned long) syminsz
);
11157 filedata
->dynamic_syminfo_nent
11158 = syminsz
/ sizeof (Elf_External_Syminfo
);
11159 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
11160 syminfo
< (filedata
->dynamic_syminfo
11161 + filedata
->dynamic_syminfo_nent
);
11162 ++syminfo
, ++extsym
)
11164 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
11165 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
11172 if (do_dynamic
&& filedata
->dynamic_addr
)
11174 if (filedata
->is_separate
)
11175 printf (ngettext ("\nIn linked file '%s' the dynamic section at offset 0x%lx contains %lu entry:\n",
11176 "\nIn linked file '%s' the dynamic section at offset 0x%lx contains %lu entries:\n",
11177 (unsigned long) filedata
->dynamic_nent
),
11178 filedata
->file_name
,
11179 filedata
->dynamic_addr
,
11180 (unsigned long) filedata
->dynamic_nent
);
11182 printf (ngettext ("\nDynamic section at offset 0x%lx contains %lu entry:\n",
11183 "\nDynamic section at offset 0x%lx contains %lu entries:\n",
11184 (unsigned long) filedata
->dynamic_nent
),
11185 filedata
->dynamic_addr
,
11186 (unsigned long) filedata
->dynamic_nent
);
11189 printf (_(" Tag Type Name/Value\n"));
11191 for (entry
= filedata
->dynamic_section
;
11192 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
11197 const char * dtype
;
11200 print_vma (entry
->d_tag
, FULL_HEX
);
11201 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
11202 printf (" (%s)%*s", dtype
,
11203 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
11206 switch (entry
->d_tag
)
11210 print_dynamic_flags (entry
->d_un
.d_val
);
11220 switch (entry
->d_tag
)
11223 printf (_("Auxiliary library"));
11227 printf (_("Filter library"));
11231 printf (_("Configuration file"));
11235 printf (_("Dependency audit library"));
11239 printf (_("Audit library"));
11243 if (valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
11244 printf (": [%s]\n",
11245 get_dynamic_name (filedata
, entry
->d_un
.d_val
));
11249 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11258 printf (_("Flags:"));
11260 if (entry
->d_un
.d_val
== 0)
11261 printf (_(" None\n"));
11264 unsigned long int val
= entry
->d_un
.d_val
;
11266 if (val
& DTF_1_PARINIT
)
11268 printf (" PARINIT");
11269 val
^= DTF_1_PARINIT
;
11271 if (val
& DTF_1_CONFEXP
)
11273 printf (" CONFEXP");
11274 val
^= DTF_1_CONFEXP
;
11277 printf (" %lx", val
);
11286 printf (_("Flags:"));
11288 if (entry
->d_un
.d_val
== 0)
11289 printf (_(" None\n"));
11292 unsigned long int val
= entry
->d_un
.d_val
;
11294 if (val
& DF_P1_LAZYLOAD
)
11296 printf (" LAZYLOAD");
11297 val
^= DF_P1_LAZYLOAD
;
11299 if (val
& DF_P1_GROUPPERM
)
11301 printf (" GROUPPERM");
11302 val
^= DF_P1_GROUPPERM
;
11305 printf (" %lx", val
);
11314 printf (_("Flags:"));
11315 if (entry
->d_un
.d_val
== 0)
11316 printf (_(" None\n"));
11319 unsigned long int val
= entry
->d_un
.d_val
;
11321 if (val
& DF_1_NOW
)
11326 if (val
& DF_1_GLOBAL
)
11328 printf (" GLOBAL");
11329 val
^= DF_1_GLOBAL
;
11331 if (val
& DF_1_GROUP
)
11336 if (val
& DF_1_NODELETE
)
11338 printf (" NODELETE");
11339 val
^= DF_1_NODELETE
;
11341 if (val
& DF_1_LOADFLTR
)
11343 printf (" LOADFLTR");
11344 val
^= DF_1_LOADFLTR
;
11346 if (val
& DF_1_INITFIRST
)
11348 printf (" INITFIRST");
11349 val
^= DF_1_INITFIRST
;
11351 if (val
& DF_1_NOOPEN
)
11353 printf (" NOOPEN");
11354 val
^= DF_1_NOOPEN
;
11356 if (val
& DF_1_ORIGIN
)
11358 printf (" ORIGIN");
11359 val
^= DF_1_ORIGIN
;
11361 if (val
& DF_1_DIRECT
)
11363 printf (" DIRECT");
11364 val
^= DF_1_DIRECT
;
11366 if (val
& DF_1_TRANS
)
11371 if (val
& DF_1_INTERPOSE
)
11373 printf (" INTERPOSE");
11374 val
^= DF_1_INTERPOSE
;
11376 if (val
& DF_1_NODEFLIB
)
11378 printf (" NODEFLIB");
11379 val
^= DF_1_NODEFLIB
;
11381 if (val
& DF_1_NODUMP
)
11383 printf (" NODUMP");
11384 val
^= DF_1_NODUMP
;
11386 if (val
& DF_1_CONFALT
)
11388 printf (" CONFALT");
11389 val
^= DF_1_CONFALT
;
11391 if (val
& DF_1_ENDFILTEE
)
11393 printf (" ENDFILTEE");
11394 val
^= DF_1_ENDFILTEE
;
11396 if (val
& DF_1_DISPRELDNE
)
11398 printf (" DISPRELDNE");
11399 val
^= DF_1_DISPRELDNE
;
11401 if (val
& DF_1_DISPRELPND
)
11403 printf (" DISPRELPND");
11404 val
^= DF_1_DISPRELPND
;
11406 if (val
& DF_1_NODIRECT
)
11408 printf (" NODIRECT");
11409 val
^= DF_1_NODIRECT
;
11411 if (val
& DF_1_IGNMULDEF
)
11413 printf (" IGNMULDEF");
11414 val
^= DF_1_IGNMULDEF
;
11416 if (val
& DF_1_NOKSYMS
)
11418 printf (" NOKSYMS");
11419 val
^= DF_1_NOKSYMS
;
11421 if (val
& DF_1_NOHDR
)
11426 if (val
& DF_1_EDITED
)
11428 printf (" EDITED");
11429 val
^= DF_1_EDITED
;
11431 if (val
& DF_1_NORELOC
)
11433 printf (" NORELOC");
11434 val
^= DF_1_NORELOC
;
11436 if (val
& DF_1_SYMINTPOSE
)
11438 printf (" SYMINTPOSE");
11439 val
^= DF_1_SYMINTPOSE
;
11441 if (val
& DF_1_GLOBAUDIT
)
11443 printf (" GLOBAUDIT");
11444 val
^= DF_1_GLOBAUDIT
;
11446 if (val
& DF_1_SINGLETON
)
11448 printf (" SINGLETON");
11449 val
^= DF_1_SINGLETON
;
11451 if (val
& DF_1_STUB
)
11456 if (val
& DF_1_PIE
)
11461 if (val
& DF_1_KMOD
)
11466 if (val
& DF_1_WEAKFILTER
)
11468 printf (" WEAKFILTER");
11469 val
^= DF_1_WEAKFILTER
;
11471 if (val
& DF_1_NOCOMMON
)
11473 printf (" NOCOMMON");
11474 val
^= DF_1_NOCOMMON
;
11477 printf (" %lx", val
);
11484 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11486 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
11506 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11512 if (valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
11513 name
= get_dynamic_name (filedata
, entry
->d_un
.d_val
);
11519 switch (entry
->d_tag
)
11522 printf (_("Shared library: [%s]"), name
);
11524 if (filedata
->program_interpreter
11525 && streq (name
, filedata
->program_interpreter
))
11526 printf (_(" program interpreter"));
11530 printf (_("Library soname: [%s]"), name
);
11534 printf (_("Library rpath: [%s]"), name
);
11538 printf (_("Library runpath: [%s]"), name
);
11542 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11547 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11560 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11561 /* Fall through. */
11567 case DT_PREINIT_ARRAYSZ
:
11568 case DT_INIT_ARRAYSZ
:
11569 case DT_FINI_ARRAYSZ
:
11570 case DT_GNU_CONFLICTSZ
:
11571 case DT_GNU_LIBLISTSZ
:
11574 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11575 printf (_(" (bytes)\n"));
11580 case DT_VERNEEDNUM
:
11585 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11594 case DT_INIT_ARRAY
:
11595 case DT_FINI_ARRAY
:
11598 if (entry
->d_tag
== DT_USED
11599 && valid_dynamic_name (filedata
, entry
->d_un
.d_val
))
11602 = get_dynamic_name (filedata
, entry
->d_un
.d_val
);
11606 printf (_("Not needed object: [%s]\n"), name
);
11611 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11617 /* The value of this entry is ignored. */
11622 case DT_GNU_PRELINKED
:
11626 time_t atime
= entry
->d_un
.d_val
;
11628 tmp
= gmtime (&atime
);
11629 /* PR 17533 file: 041-1244816-0.004. */
11631 printf (_("<corrupt time val: %lx"),
11632 (unsigned long) atime
);
11634 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
11635 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11636 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11642 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11645 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11650 case DT_GNU_FLAGS_1
:
11653 printf (_("Flags:"));
11654 if (entry
->d_un
.d_val
== 0)
11655 printf (_(" None\n"));
11658 unsigned long int val
= entry
->d_un
.d_val
;
11660 if (val
& DF_GNU_1_UNIQUE
)
11662 printf (" UNIQUE");
11663 val
^= DF_GNU_1_UNIQUE
;
11666 printf (" %lx", val
);
11673 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
11674 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
11675 = entry
->d_un
.d_val
;
11679 switch (filedata
->file_header
.e_machine
)
11682 dynamic_section_aarch64_val (entry
);
11685 case EM_MIPS_RS3_LE
:
11686 dynamic_section_mips_val (filedata
, entry
);
11689 dynamic_section_parisc_val (entry
);
11692 dynamic_section_ia64_val (entry
);
11695 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11707 get_ver_flags (unsigned int flags
)
11709 static char buff
[128];
11716 if (flags
& VER_FLG_BASE
)
11717 strcat (buff
, "BASE");
11719 if (flags
& VER_FLG_WEAK
)
11721 if (flags
& VER_FLG_BASE
)
11722 strcat (buff
, " | ");
11724 strcat (buff
, "WEAK");
11727 if (flags
& VER_FLG_INFO
)
11729 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
11730 strcat (buff
, " | ");
11732 strcat (buff
, "INFO");
11735 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11737 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11738 strcat (buff
, " | ");
11740 strcat (buff
, _("<unknown>"));
11746 /* Display the contents of the version sections. */
11749 process_version_sections (Filedata
* filedata
)
11751 Elf_Internal_Shdr
* section
;
11753 bool found
= false;
11758 for (i
= 0, section
= filedata
->section_headers
;
11759 i
< filedata
->file_header
.e_shnum
;
11762 switch (section
->sh_type
)
11764 case SHT_GNU_verdef
:
11766 Elf_External_Verdef
* edefs
;
11773 if (filedata
->is_separate
)
11774 printf (ngettext ("\nIn linked file '%s' the version definition section '%s' contains %u entry:\n",
11775 "\nIn linked file '%s' the version definition section '%s' contains %u entries:\n",
11777 filedata
->file_name
,
11778 printable_section_name (filedata
, section
),
11781 printf (ngettext ("\nVersion definition section '%s' "
11782 "contains %u entry:\n",
11783 "\nVersion definition section '%s' "
11784 "contains %u entries:\n",
11786 printable_section_name (filedata
, section
),
11789 printf (_(" Addr: 0x"));
11790 printf_vma (section
->sh_addr
);
11791 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11792 (unsigned long) section
->sh_offset
, section
->sh_link
,
11793 printable_section_name_from_index (filedata
, section
->sh_link
));
11795 edefs
= (Elf_External_Verdef
*)
11796 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
11797 _("version definition section"));
11800 endbuf
= (char *) edefs
+ section
->sh_size
;
11802 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11805 Elf_External_Verdef
* edef
;
11806 Elf_Internal_Verdef ent
;
11807 Elf_External_Verdaux
* eaux
;
11808 Elf_Internal_Verdaux aux
;
11809 unsigned long isum
;
11812 vstart
= ((char *) edefs
) + idx
;
11813 if (vstart
+ sizeof (*edef
) > endbuf
)
11816 edef
= (Elf_External_Verdef
*) vstart
;
11818 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
11819 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
11820 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
11821 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
11822 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
11823 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
11824 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
11826 printf (_(" %#06lx: Rev: %d Flags: %s"),
11827 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
11829 printf (_(" Index: %d Cnt: %d "),
11830 ent
.vd_ndx
, ent
.vd_cnt
);
11832 /* Check for overflow. */
11833 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
11836 vstart
+= ent
.vd_aux
;
11838 if (vstart
+ sizeof (*eaux
) > endbuf
)
11840 eaux
= (Elf_External_Verdaux
*) vstart
;
11842 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11843 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11845 if (valid_dynamic_name (filedata
, aux
.vda_name
))
11846 printf (_("Name: %s\n"),
11847 get_dynamic_name (filedata
, aux
.vda_name
));
11849 printf (_("Name index: %ld\n"), aux
.vda_name
);
11851 isum
= idx
+ ent
.vd_aux
;
11853 for (j
= 1; j
< ent
.vd_cnt
; j
++)
11855 if (aux
.vda_next
< sizeof (*eaux
)
11856 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
11858 warn (_("Invalid vda_next field of %lx\n"),
11863 /* Check for overflow. */
11864 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
11867 isum
+= aux
.vda_next
;
11868 vstart
+= aux
.vda_next
;
11870 if (vstart
+ sizeof (*eaux
) > endbuf
)
11872 eaux
= (Elf_External_Verdaux
*) vstart
;
11874 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11875 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11877 if (valid_dynamic_name (filedata
, aux
.vda_name
))
11878 printf (_(" %#06lx: Parent %d: %s\n"),
11880 get_dynamic_name (filedata
, aux
.vda_name
));
11882 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
11883 isum
, j
, aux
.vda_name
);
11886 if (j
< ent
.vd_cnt
)
11887 printf (_(" Version def aux past end of section\n"));
11890 file: id:000001,src:000172+005151,op:splice,rep:2. */
11891 if (ent
.vd_next
< sizeof (*edef
)
11892 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
11894 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
11895 cnt
= section
->sh_info
;
11898 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
11901 idx
+= ent
.vd_next
;
11904 if (cnt
< section
->sh_info
)
11905 printf (_(" Version definition past end of section\n"));
11911 case SHT_GNU_verneed
:
11913 Elf_External_Verneed
* eneed
;
11920 if (filedata
->is_separate
)
11921 printf (ngettext ("\nIn linked file '%s' the version needs section '%s' contains %u entry:\n",
11922 "\nIn linked file '%s' the version needs section '%s' contains %u entries:\n",
11924 filedata
->file_name
,
11925 printable_section_name (filedata
, section
),
11928 printf (ngettext ("\nVersion needs section '%s' "
11929 "contains %u entry:\n",
11930 "\nVersion needs section '%s' "
11931 "contains %u entries:\n",
11933 printable_section_name (filedata
, section
),
11936 printf (_(" Addr: 0x"));
11937 printf_vma (section
->sh_addr
);
11938 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11939 (unsigned long) section
->sh_offset
, section
->sh_link
,
11940 printable_section_name_from_index (filedata
, section
->sh_link
));
11942 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
11943 section
->sh_offset
, 1,
11945 _("Version Needs section"));
11948 endbuf
= (char *) eneed
+ section
->sh_size
;
11950 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11952 Elf_External_Verneed
* entry
;
11953 Elf_Internal_Verneed ent
;
11954 unsigned long isum
;
11958 vstart
= ((char *) eneed
) + idx
;
11959 if (vstart
+ sizeof (*entry
) > endbuf
)
11962 entry
= (Elf_External_Verneed
*) vstart
;
11964 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
11965 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
11966 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
11967 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
11968 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
11970 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
11972 if (valid_dynamic_name (filedata
, ent
.vn_file
))
11973 printf (_(" File: %s"),
11974 get_dynamic_name (filedata
, ent
.vn_file
));
11976 printf (_(" File: %lx"), ent
.vn_file
);
11978 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
11980 /* Check for overflow. */
11981 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
11983 vstart
+= ent
.vn_aux
;
11985 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
11987 Elf_External_Vernaux
* eaux
;
11988 Elf_Internal_Vernaux aux
;
11990 if (vstart
+ sizeof (*eaux
) > endbuf
)
11992 eaux
= (Elf_External_Vernaux
*) vstart
;
11994 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
11995 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
11996 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
11997 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
11998 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
12000 if (valid_dynamic_name (filedata
, aux
.vna_name
))
12001 printf (_(" %#06lx: Name: %s"),
12002 isum
, get_dynamic_name (filedata
, aux
.vna_name
));
12004 printf (_(" %#06lx: Name index: %lx"),
12005 isum
, aux
.vna_name
);
12007 printf (_(" Flags: %s Version: %d\n"),
12008 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
12010 if (aux
.vna_next
< sizeof (*eaux
)
12011 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
12013 warn (_("Invalid vna_next field of %lx\n"),
12018 /* Check for overflow. */
12019 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
12021 isum
+= aux
.vna_next
;
12022 vstart
+= aux
.vna_next
;
12025 if (j
< ent
.vn_cnt
)
12026 warn (_("Missing Version Needs auxiliary information\n"));
12028 if (ent
.vn_next
< sizeof (*entry
)
12029 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
12031 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
12032 cnt
= section
->sh_info
;
12035 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
12037 idx
+= ent
.vn_next
;
12040 if (cnt
< section
->sh_info
)
12041 warn (_("Missing Version Needs information\n"));
12047 case SHT_GNU_versym
:
12049 Elf_Internal_Shdr
* link_section
;
12052 unsigned char * edata
;
12053 unsigned short * data
;
12055 Elf_Internal_Sym
* symbols
;
12056 Elf_Internal_Shdr
* string_sec
;
12057 unsigned long num_syms
;
12060 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
12063 link_section
= filedata
->section_headers
+ section
->sh_link
;
12064 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
12066 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
12071 symbols
= get_elf_symbols (filedata
, link_section
, & num_syms
);
12072 if (symbols
== NULL
)
12075 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
12077 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
12078 string_sec
->sh_size
,
12079 _("version string table"));
12086 if (filedata
->is_separate
)
12087 printf (ngettext ("\nIn linked file '%s' the version symbols section '%s' contains %lu entry:\n",
12088 "\nIn linked file '%s' the version symbols section '%s' contains %lu entries:\n",
12090 filedata
->file_name
,
12091 printable_section_name (filedata
, section
),
12092 (unsigned long) total
);
12094 printf (ngettext ("\nVersion symbols section '%s' "
12095 "contains %lu entry:\n",
12096 "\nVersion symbols section '%s' "
12097 "contains %lu entries:\n",
12099 printable_section_name (filedata
, section
),
12100 (unsigned long) total
);
12102 printf (_(" Addr: 0x"));
12103 printf_vma (section
->sh_addr
);
12104 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
12105 (unsigned long) section
->sh_offset
, section
->sh_link
,
12106 printable_section_name (filedata
, link_section
));
12108 off
= offset_from_vma (filedata
,
12109 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
12110 total
* sizeof (short));
12111 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
12112 sizeof (short), total
,
12113 _("version symbol data"));
12121 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
12123 for (cnt
= total
; cnt
--;)
12124 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
12129 for (cnt
= 0; cnt
< total
; cnt
+= 4)
12133 char *invalid
= _("*invalid*");
12135 printf (" %03x:", cnt
);
12137 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
12138 switch (data
[cnt
+ j
])
12141 fputs (_(" 0 (*local*) "), stdout
);
12145 fputs (_(" 1 (*global*) "), stdout
);
12149 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
12150 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
12152 /* If this index value is greater than the size of the symbols
12153 array, break to avoid an out-of-bounds read. */
12154 if ((unsigned long)(cnt
+ j
) >= num_syms
)
12156 warn (_("invalid index into symbol array\n"));
12161 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
12163 Elf_Internal_Verneed ivn
;
12164 unsigned long offset
;
12166 offset
= offset_from_vma
12168 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
12169 sizeof (Elf_External_Verneed
));
12173 Elf_Internal_Vernaux ivna
;
12174 Elf_External_Verneed evn
;
12175 Elf_External_Vernaux evna
;
12176 unsigned long a_off
;
12178 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
12179 _("version need")) == NULL
)
12182 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
12183 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
12185 a_off
= offset
+ ivn
.vn_aux
;
12189 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
12190 1, _("version need aux (2)")) == NULL
)
12193 ivna
.vna_other
= 0;
12197 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
12198 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
12201 a_off
+= ivna
.vna_next
;
12203 while (ivna
.vna_other
!= data
[cnt
+ j
]
12204 && ivna
.vna_next
!= 0);
12206 if (ivna
.vna_other
== data
[cnt
+ j
])
12208 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
12210 if (ivna
.vna_name
>= string_sec
->sh_size
)
12213 name
= strtab
+ ivna
.vna_name
;
12217 offset
+= ivn
.vn_next
;
12219 while (ivn
.vn_next
);
12222 if (data
[cnt
+ j
] != 0x8001
12223 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
12225 Elf_Internal_Verdef ivd
;
12226 Elf_External_Verdef evd
;
12227 unsigned long offset
;
12229 offset
= offset_from_vma
12231 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
12236 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
12237 _("version def")) == NULL
)
12240 /* PR 17531: file: 046-1082287-0.004. */
12241 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
12246 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
12247 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
12250 offset
+= ivd
.vd_next
;
12252 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
12253 && ivd
.vd_next
!= 0);
12255 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
12257 Elf_External_Verdaux evda
;
12258 Elf_Internal_Verdaux ivda
;
12260 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
12262 if (get_data (&evda
, filedata
,
12263 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
12265 _("version def aux")) == NULL
)
12268 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
12270 if (ivda
.vda_name
>= string_sec
->sh_size
)
12272 else if (name
!= NULL
&& name
!= invalid
)
12273 name
= _("*both*");
12275 name
= strtab
+ ivda
.vda_name
;
12279 nn
+= printf ("(%s%-*s",
12281 12 - (int) strlen (name
),
12285 printf ("%*c", 18 - nn
, ' ');
12304 if (filedata
->is_separate
)
12305 printf (_("\nNo version information found in linked file '%s'.\n"),
12306 filedata
->file_name
);
12308 printf (_("\nNo version information found in this file.\n"));
12314 static const char *
12315 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
12317 static char buff
[64];
12321 case STB_LOCAL
: return "LOCAL";
12322 case STB_GLOBAL
: return "GLOBAL";
12323 case STB_WEAK
: return "WEAK";
12325 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
12326 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
12328 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
12330 if (binding
== STB_GNU_UNIQUE
12331 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
12333 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
12336 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
12341 static const char *
12342 get_symbol_type (Filedata
* filedata
, unsigned int type
)
12344 static char buff
[64];
12348 case STT_NOTYPE
: return "NOTYPE";
12349 case STT_OBJECT
: return "OBJECT";
12350 case STT_FUNC
: return "FUNC";
12351 case STT_SECTION
: return "SECTION";
12352 case STT_FILE
: return "FILE";
12353 case STT_COMMON
: return "COMMON";
12354 case STT_TLS
: return "TLS";
12355 case STT_RELC
: return "RELC";
12356 case STT_SRELC
: return "SRELC";
12358 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
12360 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
12361 return "THUMB_FUNC";
12363 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
12366 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
12367 return "PARISC_MILLI";
12369 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
12371 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
12373 if (filedata
->file_header
.e_machine
== EM_PARISC
)
12375 if (type
== STT_HP_OPAQUE
)
12376 return "HP_OPAQUE";
12377 if (type
== STT_HP_STUB
)
12381 if (type
== STT_GNU_IFUNC
12382 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
12383 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
12386 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
12389 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
12394 static const char *
12395 get_symbol_visibility (unsigned int visibility
)
12397 switch (visibility
)
12399 case STV_DEFAULT
: return "DEFAULT";
12400 case STV_INTERNAL
: return "INTERNAL";
12401 case STV_HIDDEN
: return "HIDDEN";
12402 case STV_PROTECTED
: return "PROTECTED";
12404 error (_("Unrecognized visibility value: %u\n"), visibility
);
12405 return _("<unknown>");
12409 static const char *
12410 get_alpha_symbol_other (unsigned int other
)
12414 case STO_ALPHA_NOPV
: return "NOPV";
12415 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
12417 error (_("Unrecognized alpha specific other value: %u\n"), other
);
12418 return _("<unknown>");
12422 static const char *
12423 get_solaris_symbol_visibility (unsigned int visibility
)
12425 switch (visibility
)
12427 case 4: return "EXPORTED";
12428 case 5: return "SINGLETON";
12429 case 6: return "ELIMINATE";
12430 default: return get_symbol_visibility (visibility
);
12434 static const char *
12435 get_aarch64_symbol_other (unsigned int other
)
12437 static char buf
[32];
12439 if (other
& STO_AARCH64_VARIANT_PCS
)
12441 other
&= ~STO_AARCH64_VARIANT_PCS
;
12443 return "VARIANT_PCS";
12444 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
12450 static const char *
12451 get_mips_symbol_other (unsigned int other
)
12455 case STO_OPTIONAL
: return "OPTIONAL";
12456 case STO_MIPS_PLT
: return "MIPS PLT";
12457 case STO_MIPS_PIC
: return "MIPS PIC";
12458 case STO_MICROMIPS
: return "MICROMIPS";
12459 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
12460 case STO_MIPS16
: return "MIPS16";
12461 default: return NULL
;
12465 static const char *
12466 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
12468 if (is_ia64_vms (filedata
))
12470 static char res
[32];
12474 /* Function types is for images and .STB files only. */
12475 switch (filedata
->file_header
.e_type
)
12479 switch (VMS_ST_FUNC_TYPE (other
))
12481 case VMS_SFT_CODE_ADDR
:
12482 strcat (res
, " CA");
12484 case VMS_SFT_SYMV_IDX
:
12485 strcat (res
, " VEC");
12488 strcat (res
, " FD");
12490 case VMS_SFT_RESERVE
:
12491 strcat (res
, " RSV");
12494 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
12495 VMS_ST_FUNC_TYPE (other
));
12496 strcat (res
, " <unknown>");
12503 switch (VMS_ST_LINKAGE (other
))
12505 case VMS_STL_IGNORE
:
12506 strcat (res
, " IGN");
12508 case VMS_STL_RESERVE
:
12509 strcat (res
, " RSV");
12512 strcat (res
, " STD");
12515 strcat (res
, " LNK");
12518 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
12519 VMS_ST_LINKAGE (other
));
12520 strcat (res
, " <unknown>");
12532 static const char *
12533 get_ppc64_symbol_other (unsigned int other
)
12535 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
12538 other
>>= STO_PPC64_LOCAL_BIT
;
12541 static char buf
[64];
12543 other
= ppc64_decode_local_entry (other
);
12544 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
12550 static const char *
12551 get_symbol_other (Filedata
* filedata
, unsigned int other
)
12553 const char * result
= NULL
;
12554 static char buff
[64];
12559 switch (filedata
->file_header
.e_machine
)
12562 result
= get_alpha_symbol_other (other
);
12565 result
= get_aarch64_symbol_other (other
);
12568 result
= get_mips_symbol_other (other
);
12571 result
= get_ia64_symbol_other (filedata
, other
);
12574 result
= get_ppc64_symbol_other (other
);
12584 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
12588 static const char *
12589 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
12591 static char buff
[32];
12595 case SHN_UNDEF
: return "UND";
12596 case SHN_ABS
: return "ABS";
12597 case SHN_COMMON
: return "COM";
12599 if (type
== SHN_IA_64_ANSI_COMMON
12600 && filedata
->file_header
.e_machine
== EM_IA_64
12601 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
12603 else if ((filedata
->file_header
.e_machine
== EM_X86_64
12604 || filedata
->file_header
.e_machine
== EM_L1OM
12605 || filedata
->file_header
.e_machine
== EM_K1OM
)
12606 && type
== SHN_X86_64_LCOMMON
)
12607 return "LARGE_COM";
12608 else if ((type
== SHN_MIPS_SCOMMON
12609 && filedata
->file_header
.e_machine
== EM_MIPS
)
12610 || (type
== SHN_TIC6X_SCOMMON
12611 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
12613 else if (type
== SHN_MIPS_SUNDEFINED
12614 && filedata
->file_header
.e_machine
== EM_MIPS
)
12616 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
12617 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
12618 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
12619 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
12620 else if (type
>= SHN_LORESERVE
)
12621 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
12622 else if (filedata
->file_header
.e_shnum
!= 0
12623 && type
>= filedata
->file_header
.e_shnum
)
12624 sprintf (buff
, _("bad section index[%3d]"), type
);
12626 sprintf (buff
, "%3d", type
);
12633 static const char *
12634 get_symbol_version_string (Filedata
* filedata
,
12636 const char * strtab
,
12637 unsigned long int strtab_size
,
12639 Elf_Internal_Sym
* psym
,
12640 enum versioned_symbol_info
* sym_info
,
12641 unsigned short * vna_other
)
12643 unsigned char data
[2];
12644 unsigned short vers_data
;
12645 unsigned long offset
;
12646 unsigned short max_vd_ndx
;
12649 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
12652 offset
= offset_from_vma (filedata
,
12653 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
12654 sizeof data
+ si
* sizeof (vers_data
));
12656 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
12657 sizeof (data
), 1, _("version data")) == NULL
)
12660 vers_data
= byte_get (data
, 2);
12662 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
12665 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
12668 /* Usually we'd only see verdef for defined symbols, and verneed for
12669 undefined symbols. However, symbols defined by the linker in
12670 .dynbss for variables copied from a shared library in order to
12671 avoid text relocations are defined yet have verneed. We could
12672 use a heuristic to detect the special case, for example, check
12673 for verneed first on symbols defined in SHT_NOBITS sections, but
12674 it is simpler and more reliable to just look for both verdef and
12675 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
12677 if (psym
->st_shndx
!= SHN_UNDEF
12678 && vers_data
!= 0x8001
12679 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
12681 Elf_Internal_Verdef ivd
;
12682 Elf_Internal_Verdaux ivda
;
12683 Elf_External_Verdaux evda
;
12686 off
= offset_from_vma (filedata
,
12687 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
12688 sizeof (Elf_External_Verdef
));
12692 Elf_External_Verdef evd
;
12694 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
12695 _("version def")) == NULL
)
12704 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
12705 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
12706 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
12707 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
12710 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
12711 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
12713 off
+= ivd
.vd_next
;
12715 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
12717 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
12719 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
12722 off
-= ivd
.vd_next
;
12725 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
12726 _("version def aux")) != NULL
)
12728 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
12730 if (psym
->st_name
!= ivda
.vda_name
)
12731 return (ivda
.vda_name
< strtab_size
12732 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
12737 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
12739 Elf_External_Verneed evn
;
12740 Elf_Internal_Verneed ivn
;
12741 Elf_Internal_Vernaux ivna
;
12743 offset
= offset_from_vma (filedata
,
12744 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
12748 unsigned long vna_off
;
12750 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
12751 _("version need")) == NULL
)
12754 ivna
.vna_other
= 0;
12759 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
12760 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
12762 vna_off
= offset
+ ivn
.vn_aux
;
12766 Elf_External_Vernaux evna
;
12768 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
12769 _("version need aux (3)")) == NULL
)
12772 ivna
.vna_other
= 0;
12777 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
12778 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
12779 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
12782 vna_off
+= ivna
.vna_next
;
12784 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
12786 if (ivna
.vna_other
== vers_data
)
12789 offset
+= ivn
.vn_next
;
12791 while (ivn
.vn_next
!= 0);
12793 if (ivna
.vna_other
== vers_data
)
12795 *sym_info
= symbol_undefined
;
12796 *vna_other
= ivna
.vna_other
;
12797 return (ivna
.vna_name
< strtab_size
12798 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
12800 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
12801 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
12802 return _("<corrupt>");
12807 /* Display a symbol size on stdout. Format is based on --sym-base setting. */
12809 static unsigned int
12810 print_dynamic_symbol_size (bfd_vma vma
, int base
)
12815 return print_vma (vma
, OCTAL_5
);
12818 return print_vma (vma
, UNSIGNED_5
);
12821 return print_vma (vma
, PREFIX_HEX_5
);
12825 return print_vma (vma
, DEC_5
);
12830 print_dynamic_symbol (Filedata
*filedata
, unsigned long si
,
12831 Elf_Internal_Sym
*symtab
,
12832 Elf_Internal_Shdr
*section
,
12833 char *strtab
, size_t strtab_size
)
12835 const char *version_string
;
12836 enum versioned_symbol_info sym_info
;
12837 unsigned short vna_other
;
12840 Elf_Internal_Sym
*psym
= symtab
+ si
;
12842 printf ("%6ld: ", si
);
12843 print_vma (psym
->st_value
, LONG_HEX
);
12845 print_dynamic_symbol_size (psym
->st_size
, sym_base
);
12846 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12847 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12848 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12849 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12852 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12854 printf (" %-7s", get_symbol_visibility (vis
));
12855 /* Check to see if any other bits in the st_other field are set.
12856 Note - displaying this information disrupts the layout of the
12857 table being generated, but for the moment this case is very rare. */
12858 if (psym
->st_other
^ vis
)
12859 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12861 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12863 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
12864 && psym
->st_shndx
< filedata
->file_header
.e_shnum
12865 && filedata
->section_headers
!= NULL
12866 && psym
->st_name
== 0)
12869 = section_name_valid (filedata
,
12870 filedata
->section_headers
+ psym
->st_shndx
);
12872 section_name_print (filedata
,
12873 filedata
->section_headers
+ psym
->st_shndx
)
12878 is_valid
= valid_symbol_name (strtab
, strtab_size
, psym
->st_name
);
12879 sstr
= is_valid
? strtab
+ psym
->st_name
: _("<corrupt>");
12883 = get_symbol_version_string (filedata
,
12885 || section
->sh_type
== SHT_DYNSYM
),
12886 strtab
, strtab_size
, si
,
12887 psym
, &sym_info
, &vna_other
);
12889 int len_avail
= 21;
12890 if (! do_wide
&& version_string
!= NULL
)
12894 len_avail
-= 1 + strlen (version_string
);
12896 if (sym_info
== symbol_undefined
)
12897 len_avail
-= sprintf (buffer
," (%d)", vna_other
);
12898 else if (sym_info
!= symbol_hidden
)
12902 print_symbol (len_avail
, sstr
);
12904 if (version_string
)
12906 if (sym_info
== symbol_undefined
)
12907 printf ("@%s (%d)", version_string
, vna_other
);
12909 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12915 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12917 && si
>= section
->sh_info
12918 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12919 && filedata
->file_header
.e_machine
!= EM_MIPS
12920 /* Solaris binaries have been found to violate this requirement as
12921 well. Not sure if this is a bug or an ABI requirement. */
12922 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12923 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12924 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12927 static const char *
12928 get_lto_kind (unsigned int kind
)
12932 case 0: return "DEF";
12933 case 1: return "WEAKDEF";
12934 case 2: return "UNDEF";
12935 case 3: return "WEAKUNDEF";
12936 case 4: return "COMMON";
12941 static char buffer
[30];
12942 error (_("Unknown LTO symbol definition encountered: %u\n"), kind
);
12943 sprintf (buffer
, "<unknown: %u>", kind
);
12947 static const char *
12948 get_lto_visibility (unsigned int visibility
)
12950 switch (visibility
)
12952 case 0: return "DEFAULT";
12953 case 1: return "PROTECTED";
12954 case 2: return "INTERNAL";
12955 case 3: return "HIDDEN";
12960 static char buffer
[30];
12961 error (_("Unknown LTO symbol visibility encountered: %u\n"), visibility
);
12962 sprintf (buffer
, "<unknown: %u>", visibility
);
12966 static const char *
12967 get_lto_sym_type (unsigned int sym_type
)
12971 case 0: return "UNKNOWN";
12972 case 1: return "FUNCTION";
12973 case 2: return "VARIABLE";
12978 static char buffer
[30];
12979 error (_("Unknown LTO symbol type encountered: %u\n"), sym_type
);
12980 sprintf (buffer
, "<unknown: %u>", sym_type
);
12984 /* Display an LTO format symbol table.
12985 FIXME: The format of LTO symbol tables is not formalized.
12986 So this code could need changing in the future. */
12989 display_lto_symtab (Filedata
* filedata
,
12990 Elf_Internal_Shdr
* section
)
12992 if (section
->sh_size
== 0)
12994 if (filedata
->is_separate
)
12995 printf (_("\nThe LTO Symbol table section '%s' in linked file '%s' is empty!\n"),
12996 printable_section_name (filedata
, section
),
12997 filedata
->file_name
);
12999 printf (_("\nLTO Symbol table '%s' is empty!\n"),
13000 printable_section_name (filedata
, section
));
13005 if (section
->sh_size
> filedata
->file_size
)
13007 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
13008 printable_section_name (filedata
, section
),
13009 (unsigned long) section
->sh_size
);
13013 void * alloced_data
= get_data (NULL
, filedata
, section
->sh_offset
,
13014 section
->sh_size
, 1, _("LTO symbols"));
13015 if (alloced_data
== NULL
)
13018 /* Look for extended data for the symbol table. */
13019 Elf_Internal_Shdr
* ext
;
13020 void * ext_data_orig
= NULL
;
13021 char * ext_data
= NULL
;
13022 char * ext_data_end
= NULL
;
13023 char * ext_name
= NULL
;
13025 if (asprintf (& ext_name
, ".gnu.lto_.ext_symtab.%s",
13026 (section_name (filedata
, section
)
13027 + sizeof (".gnu.lto_.symtab.") - 1)) > 0
13028 && ext_name
!= NULL
/* Paranoia. */
13029 && (ext
= find_section (filedata
, ext_name
)) != NULL
)
13031 if (ext
->sh_size
< 3)
13032 error (_("LTO Symbol extension table '%s' is empty!\n"),
13033 printable_section_name (filedata
, ext
));
13036 ext_data_orig
= ext_data
= get_data (NULL
, filedata
, ext
->sh_offset
,
13038 _("LTO ext symbol data"));
13039 if (ext_data
!= NULL
)
13041 ext_data_end
= ext_data
+ ext
->sh_size
;
13042 if (* ext_data
++ != 1)
13043 error (_("Unexpected version number in symbol extension table\n"));
13048 const unsigned char * data
= (const unsigned char *) alloced_data
;
13049 const unsigned char * end
= data
+ section
->sh_size
;
13051 if (filedata
->is_separate
)
13052 printf (_("\nIn linked file '%s': "), filedata
->file_name
);
13056 if (ext_data_orig
!= NULL
)
13059 printf (_("LTO Symbol table '%s' and extension table '%s' contain:\n"),
13060 printable_section_name (filedata
, section
),
13061 printable_section_name (filedata
, ext
));
13064 printf (_("LTO Symbol table '%s'\n"),
13065 printable_section_name (filedata
, section
));
13066 printf (_(" and extension table '%s' contain:\n"),
13067 printable_section_name (filedata
, ext
));
13071 printf (_("LTO Symbol table '%s' contains:\n"),
13072 printable_section_name (filedata
, section
));
13074 /* FIXME: Add a wide version. */
13075 if (ext_data_orig
!= NULL
)
13076 printf (_(" Comdat_Key Kind Visibility Size Slot Type Section Name\n"));
13078 printf (_(" Comdat_Key Kind Visibility Size Slot Name\n"));
13080 /* FIXME: We do not handle style prefixes. */
13084 const unsigned char * sym_name
= data
;
13085 data
+= strnlen ((const char *) sym_name
, end
- data
) + 1;
13089 const unsigned char * comdat_key
= data
;
13090 data
+= strnlen ((const char *) comdat_key
, end
- data
) + 1;
13094 if (data
+ 2 + 8 + 4 > end
)
13097 unsigned int kind
= *data
++;
13098 unsigned int visibility
= *data
++;
13100 elf_vma size
= byte_get (data
, 8);
13103 elf_vma slot
= byte_get (data
, 4);
13106 if (ext_data
!= NULL
)
13108 if (ext_data
< (ext_data_end
- 1))
13110 unsigned int sym_type
= * ext_data
++;
13111 unsigned int sec_kind
= * ext_data
++;
13113 printf (" %10s %10s %11s %08lx %08lx %9s %08lx _",
13114 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
13115 get_lto_kind (kind
),
13116 get_lto_visibility (visibility
),
13119 get_lto_sym_type (sym_type
),
13121 print_symbol (6, (const char *) sym_name
);
13125 error (_("Ran out of LTO symbol extension data\n"));
13127 /* FIXME: return FAIL result ? */
13132 printf (" %10s %10s %11s %08lx %08lx _",
13133 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
13134 get_lto_kind (kind
),
13135 get_lto_visibility (visibility
),
13138 print_symbol (21, (const char *) sym_name
);
13143 if (ext_data
!= NULL
&& ext_data
< ext_data_end
)
13145 error (_("Data remains in the LTO symbol extension table\n"));
13149 free (alloced_data
);
13150 free (ext_data_orig
);
13155 error (_("Buffer overrun encountered whilst decoding LTO symbol table\n"));
13156 free (alloced_data
);
13157 free (ext_data_orig
);
13162 /* Display LTO symbol tables. */
13165 process_lto_symbol_tables (Filedata
* filedata
)
13167 Elf_Internal_Shdr
* section
;
13174 if (filedata
->section_headers
== NULL
)
13177 for (i
= 0, section
= filedata
->section_headers
;
13178 i
< filedata
->file_header
.e_shnum
;
13180 if (section_name_valid (filedata
, section
)
13181 && startswith (section_name (filedata
, section
), ".gnu.lto_.symtab."))
13182 res
&= display_lto_symtab (filedata
, section
);
13187 /* Dump the symbol table. */
13190 process_symbol_table (Filedata
* filedata
)
13192 Elf_Internal_Shdr
* section
;
13194 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
13197 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
13199 && do_using_dynamic
13200 && filedata
->dynamic_strings
!= NULL
13201 && filedata
->dynamic_symbols
!= NULL
)
13205 if (filedata
->is_separate
)
13207 printf (ngettext ("\nIn linked file '%s' the dynamic symbol table contains %lu entry:\n",
13208 "\nIn linked file '%s' the dynamic symbol table contains %lu entries:\n",
13209 filedata
->num_dynamic_syms
),
13210 filedata
->file_name
,
13211 filedata
->num_dynamic_syms
);
13215 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
13216 "\nSymbol table for image contains %lu entries:\n",
13217 filedata
->num_dynamic_syms
),
13218 filedata
->num_dynamic_syms
);
13221 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
13223 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
13225 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
13226 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
13227 filedata
->dynamic_strings
,
13228 filedata
->dynamic_strings_length
);
13230 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
13231 && filedata
->section_headers
!= NULL
)
13235 for (i
= 0, section
= filedata
->section_headers
;
13236 i
< filedata
->file_header
.e_shnum
;
13239 char * strtab
= NULL
;
13240 unsigned long int strtab_size
= 0;
13241 Elf_Internal_Sym
* symtab
;
13242 unsigned long si
, num_syms
;
13244 if ((section
->sh_type
!= SHT_SYMTAB
13245 && section
->sh_type
!= SHT_DYNSYM
)
13247 && section
->sh_type
== SHT_SYMTAB
))
13250 if (section
->sh_entsize
== 0)
13252 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
13253 printable_section_name (filedata
, section
));
13257 num_syms
= section
->sh_size
/ section
->sh_entsize
;
13259 if (filedata
->is_separate
)
13260 printf (ngettext ("\nIn linked file '%s' symbol section '%s' contains %lu entry:\n",
13261 "\nIn linked file '%s' symbol section '%s' contains %lu entries:\n",
13263 filedata
->file_name
,
13264 printable_section_name (filedata
, section
),
13267 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
13268 "\nSymbol table '%s' contains %lu entries:\n",
13270 printable_section_name (filedata
, section
),
13274 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
13276 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
13278 symtab
= get_elf_symbols (filedata
, section
, & num_syms
);
13279 if (symtab
== NULL
)
13282 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
13284 strtab
= filedata
->string_table
;
13285 strtab_size
= filedata
->string_table_length
;
13287 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
13289 Elf_Internal_Shdr
* string_sec
;
13291 string_sec
= filedata
->section_headers
+ section
->sh_link
;
13293 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
13294 1, string_sec
->sh_size
,
13295 _("string table"));
13296 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
13299 for (si
= 0; si
< num_syms
; si
++)
13300 print_dynamic_symbol (filedata
, si
, symtab
, section
,
13301 strtab
, strtab_size
);
13304 if (strtab
!= filedata
->string_table
)
13310 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
13312 if (do_histogram
&& filedata
->buckets
!= NULL
)
13314 unsigned long * lengths
;
13315 unsigned long * counts
;
13318 unsigned long maxlength
= 0;
13319 unsigned long nzero_counts
= 0;
13320 unsigned long nsyms
= 0;
13323 printf (ngettext ("\nHistogram for bucket list length "
13324 "(total of %lu bucket):\n",
13325 "\nHistogram for bucket list length "
13326 "(total of %lu buckets):\n",
13327 (unsigned long) filedata
->nbuckets
),
13328 (unsigned long) filedata
->nbuckets
);
13330 lengths
= (unsigned long *) calloc (filedata
->nbuckets
,
13331 sizeof (*lengths
));
13332 if (lengths
== NULL
)
13334 error (_("Out of memory allocating space for histogram buckets\n"));
13337 visited
= xcmalloc (filedata
->nchains
, 1);
13338 memset (visited
, 0, filedata
->nchains
);
13340 printf (_(" Length Number %% of total Coverage\n"));
13341 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
13343 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
13346 if (maxlength
< ++lengths
[hn
])
13348 if (si
>= filedata
->nchains
|| visited
[si
])
13350 error (_("histogram chain is corrupt\n"));
13358 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
13359 if (counts
== NULL
)
13362 error (_("Out of memory allocating space for histogram counts\n"));
13366 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
13367 ++counts
[lengths
[hn
]];
13369 if (filedata
->nbuckets
> 0)
13372 printf (" 0 %-10lu (%5.1f%%)\n",
13373 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
13374 for (i
= 1; i
<= maxlength
; ++i
)
13376 nzero_counts
+= counts
[i
] * i
;
13377 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
13378 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
13379 (nzero_counts
* 100.0) / nsyms
);
13387 free (filedata
->buckets
);
13388 filedata
->buckets
= NULL
;
13389 filedata
->nbuckets
= 0;
13390 free (filedata
->chains
);
13391 filedata
->chains
= NULL
;
13393 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
13395 unsigned long * lengths
;
13396 unsigned long * counts
;
13398 unsigned long maxlength
= 0;
13399 unsigned long nzero_counts
= 0;
13400 unsigned long nsyms
= 0;
13402 printf (ngettext ("\nHistogram for `%s' bucket list length "
13403 "(total of %lu bucket):\n",
13404 "\nHistogram for `%s' bucket list length "
13405 "(total of %lu buckets):\n",
13406 (unsigned long) filedata
->ngnubuckets
),
13407 GNU_HASH_SECTION_NAME (filedata
),
13408 (unsigned long) filedata
->ngnubuckets
);
13410 lengths
= (unsigned long *) calloc (filedata
->ngnubuckets
,
13411 sizeof (*lengths
));
13412 if (lengths
== NULL
)
13414 error (_("Out of memory allocating space for gnu histogram buckets\n"));
13418 printf (_(" Length Number %% of total Coverage\n"));
13420 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
13421 if (filedata
->gnubuckets
[hn
] != 0)
13423 bfd_vma off
, length
= 1;
13425 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
13426 /* PR 17531 file: 010-77222-0.004. */
13427 off
< filedata
->ngnuchains
13428 && (filedata
->gnuchains
[off
] & 1) == 0;
13431 lengths
[hn
] = length
;
13432 if (length
> maxlength
)
13433 maxlength
= length
;
13437 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
13438 if (counts
== NULL
)
13441 error (_("Out of memory allocating space for gnu histogram counts\n"));
13445 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
13446 ++counts
[lengths
[hn
]];
13448 if (filedata
->ngnubuckets
> 0)
13451 printf (" 0 %-10lu (%5.1f%%)\n",
13452 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
13453 for (j
= 1; j
<= maxlength
; ++j
)
13455 nzero_counts
+= counts
[j
] * j
;
13456 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
13457 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
13458 (nzero_counts
* 100.0) / nsyms
);
13465 free (filedata
->gnubuckets
);
13466 filedata
->gnubuckets
= NULL
;
13467 filedata
->ngnubuckets
= 0;
13468 free (filedata
->gnuchains
);
13469 filedata
->gnuchains
= NULL
;
13470 filedata
->ngnuchains
= 0;
13471 free (filedata
->mipsxlat
);
13472 filedata
->mipsxlat
= NULL
;
13476 free (filedata
->gnubuckets
);
13477 filedata
->gnubuckets
= NULL
;
13478 filedata
->ngnubuckets
= 0;
13479 free (filedata
->gnuchains
);
13480 filedata
->gnuchains
= NULL
;
13481 filedata
->ngnuchains
= 0;
13482 free (filedata
->mipsxlat
);
13483 filedata
->mipsxlat
= NULL
;
13484 free (filedata
->buckets
);
13485 filedata
->buckets
= NULL
;
13486 filedata
->nbuckets
= 0;
13487 free (filedata
->chains
);
13488 filedata
->chains
= NULL
;
13493 process_syminfo (Filedata
* filedata
)
13497 if (filedata
->dynamic_syminfo
== NULL
13499 /* No syminfo, this is ok. */
13502 /* There better should be a dynamic symbol section. */
13503 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
13506 if (filedata
->is_separate
)
13507 printf (ngettext ("\nIn linked file '%s: the dynamic info segment at offset 0x%lx contains %d entry:\n",
13508 "\nIn linked file '%s: the dynamic info segment at offset 0x%lx contains %d entries:\n",
13509 filedata
->dynamic_syminfo_nent
),
13510 filedata
->file_name
,
13511 filedata
->dynamic_syminfo_offset
,
13512 filedata
->dynamic_syminfo_nent
);
13514 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
13515 "contains %d entry:\n",
13516 "\nDynamic info segment at offset 0x%lx "
13517 "contains %d entries:\n",
13518 filedata
->dynamic_syminfo_nent
),
13519 filedata
->dynamic_syminfo_offset
,
13520 filedata
->dynamic_syminfo_nent
);
13522 printf (_(" Num: Name BoundTo Flags\n"));
13523 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
13525 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
13527 printf ("%4d: ", i
);
13528 if (i
>= filedata
->num_dynamic_syms
)
13529 printf (_("<corrupt index>"));
13530 else if (valid_dynamic_name (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
13531 print_symbol (30, get_dynamic_name (filedata
,
13532 filedata
->dynamic_symbols
[i
].st_name
));
13534 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
13537 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
13539 case SYMINFO_BT_SELF
:
13540 fputs ("SELF ", stdout
);
13542 case SYMINFO_BT_PARENT
:
13543 fputs ("PARENT ", stdout
);
13546 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
13547 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
13548 && valid_dynamic_name (filedata
,
13549 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
13551 print_symbol (10, get_dynamic_name (filedata
,
13552 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
13556 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
13560 if (flags
& SYMINFO_FLG_DIRECT
)
13561 printf (" DIRECT");
13562 if (flags
& SYMINFO_FLG_PASSTHRU
)
13563 printf (" PASSTHRU");
13564 if (flags
& SYMINFO_FLG_COPY
)
13566 if (flags
& SYMINFO_FLG_LAZYLOAD
)
13567 printf (" LAZYLOAD");
13575 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
13576 is contained by the region START .. END. The types of ADDR, START
13577 and END should all be the same. Note both ADDR + NELEM and END
13578 point to just beyond the end of the regions that are being tested. */
13579 #define IN_RANGE(START,END,ADDR,NELEM) \
13580 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
13582 /* Check to see if the given reloc needs to be handled in a target specific
13583 manner. If so then process the reloc and return TRUE otherwise return
13586 If called with reloc == NULL, then this is a signal that reloc processing
13587 for the current section has finished, and any saved state should be
13591 target_specific_reloc_handling (Filedata
* filedata
,
13592 Elf_Internal_Rela
* reloc
,
13593 unsigned char * start
,
13594 unsigned char * end
,
13595 Elf_Internal_Sym
* symtab
,
13596 unsigned long num_syms
)
13598 unsigned int reloc_type
= 0;
13599 unsigned long sym_index
= 0;
13603 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
13604 sym_index
= get_reloc_symindex (reloc
->r_info
);
13607 switch (filedata
->file_header
.e_machine
)
13610 case EM_MSP430_OLD
:
13612 static Elf_Internal_Sym
* saved_sym
= NULL
;
13620 switch (reloc_type
)
13622 case 10: /* R_MSP430_SYM_DIFF */
13623 case 12: /* R_MSP430_GNU_SUB_ULEB128 */
13624 if (uses_msp430x_relocs (filedata
))
13626 /* Fall through. */
13627 case 21: /* R_MSP430X_SYM_DIFF */
13628 case 23: /* R_MSP430X_GNU_SUB_ULEB128 */
13630 if (sym_index
>= num_syms
)
13631 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
13634 saved_sym
= symtab
+ sym_index
;
13637 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
13638 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
13639 goto handle_sym_diff
;
13641 case 5: /* R_MSP430_16_BYTE */
13642 case 9: /* R_MSP430_8 */
13643 case 11: /* R_MSP430_GNU_SET_ULEB128 */
13644 if (uses_msp430x_relocs (filedata
))
13646 goto handle_sym_diff
;
13648 case 2: /* R_MSP430_ABS16 */
13649 case 15: /* R_MSP430X_ABS16 */
13650 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
13651 if (! uses_msp430x_relocs (filedata
))
13653 goto handle_sym_diff
;
13656 if (saved_sym
!= NULL
)
13659 unsigned int reloc_size
= 0;
13661 switch (reloc_type
)
13663 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
13666 case 11: /* R_MSP430_GNU_SET_ULEB128 */
13667 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
13668 if (reloc
->r_offset
< (size_t) (end
- start
))
13669 read_leb128 (start
+ reloc
->r_offset
, end
, false,
13670 &reloc_size
, &leb_ret
);
13677 if (leb_ret
!= 0 || reloc_size
== 0 || reloc_size
> 8)
13678 error (_("MSP430 ULEB128 field at 0x%lx contains invalid "
13679 "ULEB128 value\n"),
13680 (long) reloc
->r_offset
);
13681 else if (sym_index
>= num_syms
)
13682 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
13686 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
13687 - saved_sym
->st_value
);
13689 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
13690 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
13693 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
13694 (long) reloc
->r_offset
);
13703 if (saved_sym
!= NULL
)
13704 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13711 case EM_CYGNUS_MN10300
:
13713 static Elf_Internal_Sym
* saved_sym
= NULL
;
13721 switch (reloc_type
)
13723 case 34: /* R_MN10300_ALIGN */
13725 case 33: /* R_MN10300_SYM_DIFF */
13726 if (sym_index
>= num_syms
)
13727 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
13730 saved_sym
= symtab
+ sym_index
;
13733 case 1: /* R_MN10300_32 */
13734 case 2: /* R_MN10300_16 */
13735 if (saved_sym
!= NULL
)
13737 int reloc_size
= reloc_type
== 1 ? 4 : 2;
13740 if (sym_index
>= num_syms
)
13741 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
13745 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
13746 - saved_sym
->st_value
);
13748 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
13749 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
13751 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
13752 (long) reloc
->r_offset
);
13760 if (saved_sym
!= NULL
)
13761 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
13769 static bfd_vma saved_sym1
= 0;
13770 static bfd_vma saved_sym2
= 0;
13771 static bfd_vma value
;
13775 saved_sym1
= saved_sym2
= 0;
13779 switch (reloc_type
)
13781 case 0x80: /* R_RL78_SYM. */
13782 saved_sym1
= saved_sym2
;
13783 if (sym_index
>= num_syms
)
13784 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
13788 saved_sym2
= symtab
[sym_index
].st_value
;
13789 saved_sym2
+= reloc
->r_addend
;
13793 case 0x83: /* R_RL78_OPsub. */
13794 value
= saved_sym1
- saved_sym2
;
13795 saved_sym2
= saved_sym1
= 0;
13799 case 0x41: /* R_RL78_ABS32. */
13800 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
13801 byte_put (start
+ reloc
->r_offset
, value
, 4);
13803 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
13804 (long) reloc
->r_offset
);
13808 case 0x43: /* R_RL78_ABS16. */
13809 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
13810 byte_put (start
+ reloc
->r_offset
, value
, 2);
13812 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
13813 (long) reloc
->r_offset
);
13827 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
13828 DWARF debug sections. This is a target specific test. Note - we do not
13829 go through the whole including-target-headers-multiple-times route, (as
13830 we have already done with <elf/h8.h>) because this would become very
13831 messy and even then this function would have to contain target specific
13832 information (the names of the relocs instead of their numeric values).
13833 FIXME: This is not the correct way to solve this problem. The proper way
13834 is to have target specific reloc sizing and typing functions created by
13835 the reloc-macros.h header, in the same way that it already creates the
13836 reloc naming functions. */
13839 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13841 /* Please keep this table alpha-sorted for ease of visual lookup. */
13842 switch (filedata
->file_header
.e_machine
)
13846 return reloc_type
== 1; /* R_386_32. */
13848 return reloc_type
== 1; /* R_68K_32. */
13850 return reloc_type
== 1; /* R_860_32. */
13852 return reloc_type
== 2; /* R_960_32. */
13854 return (reloc_type
== 258
13855 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
13857 return reloc_type
== 11; /* R_BPF_DATA_32 */
13858 case EM_ADAPTEVA_EPIPHANY
:
13859 return reloc_type
== 3;
13861 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
13863 return reloc_type
== 1; /* R_ARC_32. */
13864 case EM_ARC_COMPACT
:
13865 case EM_ARC_COMPACT2
:
13866 return reloc_type
== 4; /* R_ARC_32. */
13868 return reloc_type
== 2; /* R_ARM_ABS32 */
13871 return reloc_type
== 1;
13873 return reloc_type
== 0x12; /* R_byte4_data. */
13875 return reloc_type
== 3; /* R_CRIS_32. */
13877 return reloc_type
== 3; /* R_CR16_NUM32. */
13879 return reloc_type
== 15; /* R_CRX_NUM32. */
13881 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
13882 case EM_CYGNUS_FRV
:
13883 return reloc_type
== 1;
13884 case EM_CYGNUS_D10V
:
13886 return reloc_type
== 6; /* R_D10V_32. */
13887 case EM_CYGNUS_D30V
:
13889 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
13891 return reloc_type
== 3; /* R_DLX_RELOC_32. */
13892 case EM_CYGNUS_FR30
:
13894 return reloc_type
== 3; /* R_FR30_32. */
13896 return reloc_type
== 1; /* R_FT32_32. */
13900 return reloc_type
== 1; /* R_H8_DIR32. */
13902 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
13903 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
13904 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
13905 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
13908 return reloc_type
== 2; /* R_IP2K_32. */
13910 return reloc_type
== 2; /* R_IQ2000_32. */
13911 case EM_LATTICEMICO32
:
13912 return reloc_type
== 3; /* R_LM32_32. */
13914 return reloc_type
== 1; /* R_LARCH_32. */
13917 return reloc_type
== 3; /* R_M32C_32. */
13919 return reloc_type
== 34; /* R_M32R_32_RELA. */
13922 return reloc_type
== 6; /* R_M68HC11_32. */
13924 return reloc_type
== 7 || /* R_S12Z_EXT32 */
13925 reloc_type
== 6; /* R_S12Z_CW32. */
13927 return reloc_type
== 1; /* R_MCORE_ADDR32. */
13928 case EM_CYGNUS_MEP
:
13929 return reloc_type
== 4; /* R_MEP_32. */
13931 return reloc_type
== 2; /* R_METAG_ADDR32. */
13932 case EM_MICROBLAZE
:
13933 return reloc_type
== 1; /* R_MICROBLAZE_32. */
13935 return reloc_type
== 2; /* R_MIPS_32. */
13937 return reloc_type
== 4; /* R_MMIX_32. */
13938 case EM_CYGNUS_MN10200
:
13940 return reloc_type
== 1; /* R_MN10200_32. */
13941 case EM_CYGNUS_MN10300
:
13943 return reloc_type
== 1; /* R_MN10300_32. */
13945 return reloc_type
== 1; /* R_MOXIE_32. */
13946 case EM_MSP430_OLD
:
13948 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
13950 return reloc_type
== 2; /* R_MT_32. */
13952 return reloc_type
== 20; /* R_NDS32_RELA. */
13953 case EM_ALTERA_NIOS2
:
13954 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
13956 return reloc_type
== 1; /* R_NIOS_32. */
13958 return reloc_type
== 1; /* R_OR1K_32. */
13960 return (reloc_type
== 1 /* R_PARISC_DIR32. */
13961 || reloc_type
== 2 /* R_PARISC_DIR21L. */
13962 || reloc_type
== 41); /* R_PARISC_SECREL32. */
13965 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
13967 return reloc_type
== 1; /* R_PPC64_ADDR32. */
13969 return reloc_type
== 1; /* R_PPC_ADDR32. */
13971 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
13973 return reloc_type
== 1; /* R_RISCV_32. */
13975 return reloc_type
== 1; /* R_RL78_DIR32. */
13977 return reloc_type
== 1; /* R_RX_DIR32. */
13979 return reloc_type
== 1; /* R_I370_ADDR31. */
13982 return reloc_type
== 4; /* R_S390_32. */
13984 return reloc_type
== 8; /* R_SCORE_ABS32. */
13986 return reloc_type
== 1; /* R_SH_DIR32. */
13987 case EM_SPARC32PLUS
:
13990 return reloc_type
== 3 /* R_SPARC_32. */
13991 || reloc_type
== 23; /* R_SPARC_UA32. */
13993 return reloc_type
== 6; /* R_SPU_ADDR32 */
13995 return reloc_type
== 1; /* R_C6000_ABS32. */
13997 return reloc_type
== 2; /* R_TILEGX_32. */
13999 return reloc_type
== 1; /* R_TILEPRO_32. */
14000 case EM_CYGNUS_V850
:
14002 return reloc_type
== 6; /* R_V850_ABS32. */
14004 return reloc_type
== 0x33; /* R_V810_WORD. */
14006 return reloc_type
== 1; /* R_VAX_32. */
14008 return reloc_type
== 3; /* R_VISIUM_32. */
14009 case EM_WEBASSEMBLY
:
14010 return reloc_type
== 1; /* R_WASM32_32. */
14014 return reloc_type
== 10; /* R_X86_64_32. */
14017 return reloc_type
== 3; /* R_XC16C_ABS_32. */
14019 return reloc_type
== 4; /* R_XGATE_32. */
14021 return reloc_type
== 1; /* R_XSTROMY16_32. */
14022 case EM_XTENSA_OLD
:
14024 return reloc_type
== 1; /* R_XTENSA_32. */
14026 return reloc_type
== 6; /* R_Z80_32. */
14029 static unsigned int prev_warn
= 0;
14031 /* Avoid repeating the same warning multiple times. */
14032 if (prev_warn
!= filedata
->file_header
.e_machine
)
14033 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
14034 filedata
->file_header
.e_machine
);
14035 prev_warn
= filedata
->file_header
.e_machine
;
14041 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14042 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
14045 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14047 switch (filedata
->file_header
.e_machine
)
14048 /* Please keep this table alpha-sorted for ease of visual lookup. */
14052 return reloc_type
== 2; /* R_386_PC32. */
14054 return reloc_type
== 4; /* R_68K_PC32. */
14056 return reloc_type
== 261; /* R_AARCH64_PREL32 */
14057 case EM_ADAPTEVA_EPIPHANY
:
14058 return reloc_type
== 6;
14060 return reloc_type
== 10; /* R_ALPHA_SREL32. */
14061 case EM_ARC_COMPACT
:
14062 case EM_ARC_COMPACT2
:
14063 return reloc_type
== 49; /* R_ARC_32_PCREL. */
14065 return reloc_type
== 3; /* R_ARM_REL32 */
14068 return reloc_type
== 36; /* R_AVR_32_PCREL. */
14069 case EM_MICROBLAZE
:
14070 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
14072 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
14074 return reloc_type
== 9; /* R_PARISC_PCREL32. */
14076 return reloc_type
== 26; /* R_PPC_REL32. */
14078 return reloc_type
== 26; /* R_PPC64_REL32. */
14080 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
14083 return reloc_type
== 5; /* R_390_PC32. */
14085 return reloc_type
== 2; /* R_SH_REL32. */
14086 case EM_SPARC32PLUS
:
14089 return reloc_type
== 6; /* R_SPARC_DISP32. */
14091 return reloc_type
== 13; /* R_SPU_REL32. */
14093 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
14095 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
14097 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
14101 return reloc_type
== 2; /* R_X86_64_PC32. */
14103 return reloc_type
== 4; /* R_VAX_PCREL32. */
14104 case EM_XTENSA_OLD
:
14106 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
14108 /* Do not abort or issue an error message here. Not all targets use
14109 pc-relative 32-bit relocs in their DWARF debug information and we
14110 have already tested for target coverage in is_32bit_abs_reloc. A
14111 more helpful warning message will be generated by apply_relocations
14112 anyway, so just return. */
14117 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14118 a 64-bit absolute RELA relocation used in DWARF debug sections. */
14121 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14123 switch (filedata
->file_header
.e_machine
)
14126 return reloc_type
== 257; /* R_AARCH64_ABS64. */
14128 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
14130 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
14131 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
14133 return reloc_type
== 2; /* R_LARCH_64 */
14135 return reloc_type
== 80; /* R_PARISC_DIR64. */
14137 return reloc_type
== 38; /* R_PPC64_ADDR64. */
14139 return reloc_type
== 2; /* R_RISCV_64. */
14140 case EM_SPARC32PLUS
:
14143 return reloc_type
== 32 /* R_SPARC_64. */
14144 || reloc_type
== 54; /* R_SPARC_UA64. */
14148 return reloc_type
== 1; /* R_X86_64_64. */
14151 return reloc_type
== 22; /* R_S390_64. */
14153 return reloc_type
== 1; /* R_TILEGX_64. */
14155 return reloc_type
== 18; /* R_MIPS_64. */
14161 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
14162 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
14165 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14167 switch (filedata
->file_header
.e_machine
)
14170 return reloc_type
== 260; /* R_AARCH64_PREL64. */
14172 return reloc_type
== 11; /* R_ALPHA_SREL64. */
14174 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
14175 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
14177 return reloc_type
== 72; /* R_PARISC_PCREL64. */
14179 return reloc_type
== 44; /* R_PPC64_REL64. */
14180 case EM_SPARC32PLUS
:
14183 return reloc_type
== 46; /* R_SPARC_DISP64. */
14187 return reloc_type
== 24; /* R_X86_64_PC64. */
14190 return reloc_type
== 23; /* R_S390_PC64. */
14192 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
14198 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14199 a 24-bit absolute RELA relocation used in DWARF debug sections. */
14202 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14204 switch (filedata
->file_header
.e_machine
)
14206 case EM_CYGNUS_MN10200
:
14208 return reloc_type
== 4; /* R_MN10200_24. */
14210 return reloc_type
== 5; /* R_FT32_20. */
14212 return reloc_type
== 5; /* R_Z80_24. */
14218 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14219 a 16-bit absolute RELA relocation used in DWARF debug sections. */
14222 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14224 /* Please keep this table alpha-sorted for ease of visual lookup. */
14225 switch (filedata
->file_header
.e_machine
)
14228 case EM_ARC_COMPACT
:
14229 case EM_ARC_COMPACT2
:
14230 return reloc_type
== 2; /* R_ARC_16. */
14231 case EM_ADAPTEVA_EPIPHANY
:
14232 return reloc_type
== 5;
14235 return reloc_type
== 4; /* R_AVR_16. */
14236 case EM_CYGNUS_D10V
:
14238 return reloc_type
== 3; /* R_D10V_16. */
14240 return reloc_type
== 2; /* R_FT32_16. */
14244 return reloc_type
== R_H8_DIR16
;
14247 return reloc_type
== 1; /* R_IP2K_16. */
14250 return reloc_type
== 1; /* R_M32C_16 */
14251 case EM_CYGNUS_MN10200
:
14253 return reloc_type
== 2; /* R_MN10200_16. */
14254 case EM_CYGNUS_MN10300
:
14256 return reloc_type
== 2; /* R_MN10300_16. */
14258 if (uses_msp430x_relocs (filedata
))
14259 return reloc_type
== 2; /* R_MSP430_ABS16. */
14260 /* Fall through. */
14261 case EM_MSP430_OLD
:
14262 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
14264 return reloc_type
== 19; /* R_NDS32_RELA. */
14265 case EM_ALTERA_NIOS2
:
14266 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
14268 return reloc_type
== 9; /* R_NIOS_16. */
14270 return reloc_type
== 2; /* R_OR1K_16. */
14272 return reloc_type
== 55; /* R_RISCV_SET16. */
14274 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
14276 return reloc_type
== 2; /* R_C6000_ABS16. */
14278 return reloc_type
== 2; /* R_VISIUM_16. */
14281 return reloc_type
== 2; /* R_XC16C_ABS_16. */
14283 return reloc_type
== 3; /* R_XGATE_16. */
14285 return reloc_type
== 4; /* R_Z80_16. */
14291 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14292 a 8-bit absolute RELA relocation used in DWARF debug sections. */
14295 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14297 switch (filedata
->file_header
.e_machine
)
14300 return reloc_type
== 54; /* R_RISCV_SET8. */
14302 return reloc_type
== 1; /* R_Z80_8. */
14308 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14309 a 6-bit absolute RELA relocation used in DWARF debug sections. */
14312 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14314 switch (filedata
->file_header
.e_machine
)
14317 return reloc_type
== 53; /* R_RISCV_SET6. */
14323 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14324 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
14327 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14329 /* Please keep this table alpha-sorted for ease of visual lookup. */
14330 switch (filedata
->file_header
.e_machine
)
14333 return reloc_type
== 35; /* R_RISCV_ADD32. */
14339 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14340 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
14343 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14345 /* Please keep this table alpha-sorted for ease of visual lookup. */
14346 switch (filedata
->file_header
.e_machine
)
14349 return reloc_type
== 39; /* R_RISCV_SUB32. */
14355 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14356 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
14359 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14361 /* Please keep this table alpha-sorted for ease of visual lookup. */
14362 switch (filedata
->file_header
.e_machine
)
14365 return reloc_type
== 36; /* R_RISCV_ADD64. */
14371 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14372 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
14375 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14377 /* Please keep this table alpha-sorted for ease of visual lookup. */
14378 switch (filedata
->file_header
.e_machine
)
14381 return reloc_type
== 40; /* R_RISCV_SUB64. */
14387 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14388 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
14391 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14393 /* Please keep this table alpha-sorted for ease of visual lookup. */
14394 switch (filedata
->file_header
.e_machine
)
14397 return reloc_type
== 34; /* R_RISCV_ADD16. */
14403 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14404 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
14407 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14409 /* Please keep this table alpha-sorted for ease of visual lookup. */
14410 switch (filedata
->file_header
.e_machine
)
14413 return reloc_type
== 38; /* R_RISCV_SUB16. */
14419 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14420 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
14423 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14425 /* Please keep this table alpha-sorted for ease of visual lookup. */
14426 switch (filedata
->file_header
.e_machine
)
14429 return reloc_type
== 33; /* R_RISCV_ADD8. */
14435 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14436 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
14439 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14441 /* Please keep this table alpha-sorted for ease of visual lookup. */
14442 switch (filedata
->file_header
.e_machine
)
14445 return reloc_type
== 37; /* R_RISCV_SUB8. */
14451 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14452 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
14455 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14457 switch (filedata
->file_header
.e_machine
)
14460 return reloc_type
== 52; /* R_RISCV_SUB6. */
14466 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
14467 relocation entries (possibly formerly used for SHT_GROUP sections). */
14470 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14472 switch (filedata
->file_header
.e_machine
)
14474 case EM_386
: /* R_386_NONE. */
14475 case EM_68K
: /* R_68K_NONE. */
14476 case EM_ADAPTEVA_EPIPHANY
:
14477 case EM_ALPHA
: /* R_ALPHA_NONE. */
14478 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
14479 case EM_ARC
: /* R_ARC_NONE. */
14480 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
14481 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
14482 case EM_ARM
: /* R_ARM_NONE. */
14483 case EM_C166
: /* R_XC16X_NONE. */
14484 case EM_CRIS
: /* R_CRIS_NONE. */
14485 case EM_FT32
: /* R_FT32_NONE. */
14486 case EM_IA_64
: /* R_IA64_NONE. */
14487 case EM_K1OM
: /* R_X86_64_NONE. */
14488 case EM_L1OM
: /* R_X86_64_NONE. */
14489 case EM_M32R
: /* R_M32R_NONE. */
14490 case EM_MIPS
: /* R_MIPS_NONE. */
14491 case EM_MN10300
: /* R_MN10300_NONE. */
14492 case EM_MOXIE
: /* R_MOXIE_NONE. */
14493 case EM_NIOS32
: /* R_NIOS_NONE. */
14494 case EM_OR1K
: /* R_OR1K_NONE. */
14495 case EM_PARISC
: /* R_PARISC_NONE. */
14496 case EM_PPC64
: /* R_PPC64_NONE. */
14497 case EM_PPC
: /* R_PPC_NONE. */
14498 case EM_RISCV
: /* R_RISCV_NONE. */
14499 case EM_S390
: /* R_390_NONE. */
14501 case EM_SH
: /* R_SH_NONE. */
14502 case EM_SPARC32PLUS
:
14503 case EM_SPARC
: /* R_SPARC_NONE. */
14505 case EM_TILEGX
: /* R_TILEGX_NONE. */
14506 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
14507 case EM_TI_C6000
:/* R_C6000_NONE. */
14508 case EM_X86_64
: /* R_X86_64_NONE. */
14510 case EM_Z80
: /* R_Z80_NONE. */
14511 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
14512 return reloc_type
== 0;
14515 return reloc_type
== 0 || reloc_type
== 256;
14518 return (reloc_type
== 0 /* R_AVR_NONE. */
14519 || reloc_type
== 30 /* R_AVR_DIFF8. */
14520 || reloc_type
== 31 /* R_AVR_DIFF16. */
14521 || reloc_type
== 32 /* R_AVR_DIFF32. */);
14523 return reloc_type
== 3; /* R_METAG_NONE. */
14525 return (reloc_type
== 0 /* R_XTENSA_NONE. */
14526 || reloc_type
== 204 /* R_NDS32_DIFF8. */
14527 || reloc_type
== 205 /* R_NDS32_DIFF16. */
14528 || reloc_type
== 206 /* R_NDS32_DIFF32. */
14529 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
14531 return (reloc_type
== 0 /* R_PRU_NONE. */
14532 || reloc_type
== 65 /* R_PRU_DIFF8. */
14533 || reloc_type
== 66 /* R_PRU_DIFF16. */
14534 || reloc_type
== 67 /* R_PRU_DIFF32. */);
14535 case EM_XTENSA_OLD
:
14537 return (reloc_type
== 0 /* R_XTENSA_NONE. */
14538 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
14539 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
14540 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
14541 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
14542 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
14543 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
14544 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
14545 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
14546 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
14551 /* Returns TRUE if there is a relocation against
14552 section NAME at OFFSET bytes. */
14555 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
14557 Elf_Internal_Rela
* relocs
;
14558 Elf_Internal_Rela
* rp
;
14560 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
14563 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
14565 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
14566 if (rp
->r_offset
== offset
)
14572 /* Apply relocations to a section.
14573 Returns TRUE upon success, FALSE otherwise.
14574 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
14575 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
14576 will be set to the number of relocs loaded.
14578 Note: So far support has been added only for those relocations
14579 which can be found in debug sections. FIXME: Add support for
14580 more relocations ? */
14583 apply_relocations (Filedata
* filedata
,
14584 const Elf_Internal_Shdr
* section
,
14585 unsigned char * start
,
14586 bfd_size_type size
,
14587 void ** relocs_return
,
14588 unsigned long * num_relocs_return
)
14590 Elf_Internal_Shdr
* relsec
;
14591 unsigned char * end
= start
+ size
;
14593 if (relocs_return
!= NULL
)
14595 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
14596 * num_relocs_return
= 0;
14599 if (filedata
->file_header
.e_type
!= ET_REL
)
14600 /* No relocs to apply. */
14603 /* Find the reloc section associated with the section. */
14604 for (relsec
= filedata
->section_headers
;
14605 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14609 unsigned long num_relocs
;
14610 Elf_Internal_Rela
* relocs
;
14611 Elf_Internal_Rela
* rp
;
14612 Elf_Internal_Shdr
* symsec
;
14613 Elf_Internal_Sym
* symtab
;
14614 unsigned long num_syms
;
14615 Elf_Internal_Sym
* sym
;
14617 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14618 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14619 || filedata
->section_headers
+ relsec
->sh_info
!= section
14620 || relsec
->sh_size
== 0
14621 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14624 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
14625 if (symsec
->sh_type
!= SHT_SYMTAB
14626 && symsec
->sh_type
!= SHT_DYNSYM
)
14629 is_rela
= relsec
->sh_type
== SHT_RELA
;
14633 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
14634 relsec
->sh_size
, & relocs
, & num_relocs
))
14639 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
14640 relsec
->sh_size
, & relocs
, & num_relocs
))
14644 /* SH uses RELA but uses in place value instead of the addend field. */
14645 if (filedata
->file_header
.e_machine
== EM_SH
)
14648 symtab
= get_elf_symbols (filedata
, symsec
, & num_syms
);
14650 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
14653 unsigned int reloc_type
;
14654 unsigned int reloc_size
;
14655 bool reloc_inplace
= false;
14656 bool reloc_subtract
= false;
14657 unsigned char *rloc
;
14658 unsigned long sym_index
;
14660 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
14662 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
14664 else if (is_none_reloc (filedata
, reloc_type
))
14666 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
14667 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
14669 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
14670 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
14672 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
14674 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
14676 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
14677 || is_6bit_abs_reloc (filedata
, reloc_type
))
14679 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
14681 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
14684 reloc_inplace
= true;
14686 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
14688 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
14691 reloc_inplace
= true;
14693 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
14695 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
14698 reloc_inplace
= true;
14700 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
14702 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
14705 reloc_inplace
= true;
14707 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
14711 reloc_inplace
= true;
14715 static unsigned int prev_reloc
= 0;
14717 if (reloc_type
!= prev_reloc
)
14718 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
14719 reloc_type
, printable_section_name (filedata
, section
));
14720 prev_reloc
= reloc_type
;
14724 rloc
= start
+ rp
->r_offset
;
14725 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
14727 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
14728 (unsigned long) rp
->r_offset
,
14729 printable_section_name (filedata
, section
));
14733 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
14734 if (sym_index
>= num_syms
)
14736 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
14737 sym_index
, printable_section_name (filedata
, section
));
14740 sym
= symtab
+ sym_index
;
14742 /* If the reloc has a symbol associated with it,
14743 make sure that it is of an appropriate type.
14745 Relocations against symbols without type can happen.
14746 Gcc -feliminate-dwarf2-dups may generate symbols
14747 without type for debug info.
14749 Icc generates relocations against function symbols
14750 instead of local labels.
14752 Relocations against object symbols can happen, eg when
14753 referencing a global array. For an example of this see
14754 the _clz.o binary in libgcc.a. */
14756 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
14757 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
14759 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
14760 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
14761 printable_section_name (filedata
, relsec
),
14762 (long int)(rp
- relocs
));
14768 addend
+= rp
->r_addend
;
14769 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
14770 partial_inplace. */
14772 || (filedata
->file_header
.e_machine
== EM_XTENSA
14773 && reloc_type
== 1)
14774 || ((filedata
->file_header
.e_machine
== EM_PJ
14775 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
14776 && reloc_type
== 1)
14777 || ((filedata
->file_header
.e_machine
== EM_D30V
14778 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
14779 && reloc_type
== 12)
14782 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
14783 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
14785 addend
+= byte_get (rloc
, reloc_size
);
14788 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
14789 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
14791 /* On HPPA, all pc-relative relocations are biased by 8. */
14792 if (filedata
->file_header
.e_machine
== EM_PARISC
)
14794 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
14797 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
14798 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
14800 if (reloc_subtract
)
14801 addend
-= sym
->st_value
;
14803 addend
+= sym
->st_value
;
14804 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
14805 byte_put (rloc
, addend
, reloc_size
);
14807 else if (reloc_subtract
)
14808 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
14810 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
14814 /* Let the target specific reloc processing code know that
14815 we have finished with these relocs. */
14816 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
14820 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
14821 * num_relocs_return
= num_relocs
;
14832 #ifdef SUPPORT_DISASSEMBLY
14834 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14836 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
14838 /* FIXME: XXX -- to be done --- XXX */
14844 /* Reads in the contents of SECTION from FILE, returning a pointer
14845 to a malloc'ed buffer or NULL if something went wrong. */
14848 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14850 bfd_size_type num_bytes
= section
->sh_size
;
14852 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
14854 printf (_("Section '%s' has no data to dump.\n"),
14855 printable_section_name (filedata
, section
));
14859 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
14860 _("section contents"));
14863 /* Uncompresses a section that was compressed using zlib, in place. */
14866 uncompress_section_contents (unsigned char ** buffer
,
14867 dwarf_size_type uncompressed_size
,
14868 dwarf_size_type
* size
)
14870 dwarf_size_type compressed_size
= *size
;
14871 unsigned char * compressed_buffer
= *buffer
;
14872 unsigned char * uncompressed_buffer
;
14876 /* It is possible the section consists of several compressed
14877 buffers concatenated together, so we uncompress in a loop. */
14878 /* PR 18313: The state field in the z_stream structure is supposed
14879 to be invisible to the user (ie us), but some compilers will
14880 still complain about it being used without initialisation. So
14881 we first zero the entire z_stream structure and then set the fields
14883 memset (& strm
, 0, sizeof strm
);
14884 strm
.avail_in
= compressed_size
;
14885 strm
.next_in
= (Bytef
*) compressed_buffer
;
14886 strm
.avail_out
= uncompressed_size
;
14887 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
14889 rc
= inflateInit (& strm
);
14890 while (strm
.avail_in
> 0)
14894 strm
.next_out
= ((Bytef
*) uncompressed_buffer
14895 + (uncompressed_size
- strm
.avail_out
));
14896 rc
= inflate (&strm
, Z_FINISH
);
14897 if (rc
!= Z_STREAM_END
)
14899 rc
= inflateReset (& strm
);
14901 if (inflateEnd (& strm
) != Z_OK
14903 || strm
.avail_out
!= 0)
14906 *buffer
= uncompressed_buffer
;
14907 *size
= uncompressed_size
;
14911 free (uncompressed_buffer
);
14912 /* Indicate decompression failure. */
14918 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14920 Elf_Internal_Shdr
*relsec
;
14921 bfd_size_type num_bytes
;
14922 unsigned char *data
;
14923 unsigned char *end
;
14924 unsigned char *real_start
;
14925 unsigned char *start
;
14926 bool some_strings_shown
;
14928 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
14930 /* PR 21820: Do not fail if the section was empty. */
14931 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
14933 num_bytes
= section
->sh_size
;
14935 if (filedata
->is_separate
)
14936 printf (_("\nString dump of section '%s' in linked file %s:\n"),
14937 printable_section_name (filedata
, section
),
14938 filedata
->file_name
);
14940 printf (_("\nString dump of section '%s':\n"),
14941 printable_section_name (filedata
, section
));
14943 if (decompress_dumps
)
14945 dwarf_size_type new_size
= num_bytes
;
14946 dwarf_size_type uncompressed_size
= 0;
14948 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14950 Elf_Internal_Chdr chdr
;
14951 unsigned int compression_header_size
14952 = get_compression_header (& chdr
, (unsigned char *) start
,
14954 if (compression_header_size
== 0)
14955 /* An error message will have already been generated
14956 by get_compression_header. */
14959 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14961 warn (_("section '%s' has unsupported compress type: %d\n"),
14962 printable_section_name (filedata
, section
), chdr
.ch_type
);
14965 uncompressed_size
= chdr
.ch_size
;
14966 start
+= compression_header_size
;
14967 new_size
-= compression_header_size
;
14969 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14971 /* Read the zlib header. In this case, it should be "ZLIB"
14972 followed by the uncompressed section size, 8 bytes in
14973 big-endian order. */
14974 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14975 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14976 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14977 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14978 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14979 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14980 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14981 uncompressed_size
+= start
[11];
14986 if (uncompressed_size
)
14988 if (uncompress_section_contents (& start
,
14989 uncompressed_size
, & new_size
))
14990 num_bytes
= new_size
;
14993 error (_("Unable to decompress section %s\n"),
14994 printable_section_name (filedata
, section
));
14999 start
= real_start
;
15002 /* If the section being dumped has relocations against it the user might
15003 be expecting these relocations to have been applied. Check for this
15004 case and issue a warning message in order to avoid confusion.
15005 FIXME: Maybe we ought to have an option that dumps a section with
15006 relocs applied ? */
15007 for (relsec
= filedata
->section_headers
;
15008 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
15011 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
15012 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
15013 || filedata
->section_headers
+ relsec
->sh_info
!= section
15014 || relsec
->sh_size
== 0
15015 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
15018 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
15023 end
= start
+ num_bytes
;
15024 some_strings_shown
= false;
15026 #ifdef HAVE_MBSTATE_T
15028 /* Initialise the multibyte conversion state. */
15029 memset (& state
, 0, sizeof (state
));
15032 bool continuing
= false;
15036 while (!ISPRINT (* data
))
15037 if (++ data
>= end
)
15042 size_t maxlen
= end
- data
;
15047 continuing
= false;
15051 printf (" [%6lx] ", (unsigned long) (data
- start
));
15065 /* PR 25543: Treat new-lines as string-ending characters. */
15074 /* Do not print control characters directly as they can affect terminal
15075 settings. Such characters usually appear in the names generated
15076 by the assembler for local labels. */
15079 printf ("^%c", c
+ 0x40);
15081 else if (ISPRINT (c
))
15088 #ifdef HAVE_MBSTATE_T
15091 /* Let printf do the hard work of displaying multibyte characters. */
15092 printf ("%.1s", data
- 1);
15093 #ifdef HAVE_MBSTATE_T
15094 /* Try to find out how many bytes made up the character that was
15095 just printed. Advance the symbol pointer past the bytes that
15097 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
15101 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
15111 printf (_("<corrupt>\n"));
15114 some_strings_shown
= true;
15118 if (! some_strings_shown
)
15119 printf (_(" No strings found in this section."));
15132 dump_section_as_bytes (Elf_Internal_Shdr
*section
,
15133 Filedata
*filedata
,
15136 Elf_Internal_Shdr
* relsec
;
15137 bfd_size_type bytes
;
15138 bfd_size_type section_size
;
15140 unsigned char * data
;
15141 unsigned char * real_start
;
15142 unsigned char * start
;
15144 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
15146 /* PR 21820: Do not fail if the section was empty. */
15147 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
15149 section_size
= section
->sh_size
;
15151 if (filedata
->is_separate
)
15152 printf (_("\nHex dump of section '%s' in linked file %s:\n"),
15153 printable_section_name (filedata
, section
),
15154 filedata
->file_name
);
15156 printf (_("\nHex dump of section '%s':\n"),
15157 printable_section_name (filedata
, section
));
15159 if (decompress_dumps
)
15161 dwarf_size_type new_size
= section_size
;
15162 dwarf_size_type uncompressed_size
= 0;
15164 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
15166 Elf_Internal_Chdr chdr
;
15167 unsigned int compression_header_size
15168 = get_compression_header (& chdr
, start
, section_size
);
15170 if (compression_header_size
== 0)
15171 /* An error message will have already been generated
15172 by get_compression_header. */
15175 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
15177 warn (_("section '%s' has unsupported compress type: %d\n"),
15178 printable_section_name (filedata
, section
), chdr
.ch_type
);
15181 uncompressed_size
= chdr
.ch_size
;
15182 start
+= compression_header_size
;
15183 new_size
-= compression_header_size
;
15185 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
15187 /* Read the zlib header. In this case, it should be "ZLIB"
15188 followed by the uncompressed section size, 8 bytes in
15189 big-endian order. */
15190 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
15191 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
15192 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
15193 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
15194 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
15195 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
15196 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
15197 uncompressed_size
+= start
[11];
15202 if (uncompressed_size
)
15204 if (uncompress_section_contents (& start
, uncompressed_size
,
15207 section_size
= new_size
;
15211 error (_("Unable to decompress section %s\n"),
15212 printable_section_name (filedata
, section
));
15213 /* FIXME: Print the section anyway ? */
15218 start
= real_start
;
15223 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
15228 /* If the section being dumped has relocations against it the user might
15229 be expecting these relocations to have been applied. Check for this
15230 case and issue a warning message in order to avoid confusion.
15231 FIXME: Maybe we ought to have an option that dumps a section with
15232 relocs applied ? */
15233 for (relsec
= filedata
->section_headers
;
15234 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
15237 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
15238 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
15239 || filedata
->section_headers
+ relsec
->sh_info
!= section
15240 || relsec
->sh_size
== 0
15241 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
15244 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
15249 addr
= section
->sh_addr
;
15250 bytes
= section_size
;
15259 lbytes
= (bytes
> 16 ? 16 : bytes
);
15261 printf (" 0x%8.8lx ", (unsigned long) addr
);
15263 for (j
= 0; j
< 16; j
++)
15266 printf ("%2.2x", data
[j
]);
15274 for (j
= 0; j
< lbytes
; j
++)
15277 if (k
>= ' ' && k
< 0x7f)
15300 #ifdef ENABLE_LIBCTF
15301 static ctf_sect_t
*
15302 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
15304 buf
->cts_name
= section_name_print (filedata
, shdr
);
15305 buf
->cts_size
= shdr
->sh_size
;
15306 buf
->cts_entsize
= shdr
->sh_entsize
;
15311 /* Formatting callback function passed to ctf_dump. Returns either the pointer
15312 it is passed, or a pointer to newly-allocated storage, in which case
15313 dump_ctf() will free it when it no longer needs it. */
15316 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
15317 char *s
, void *arg
)
15319 const char *blanks
= arg
;
15322 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
15327 /* Dump CTF errors/warnings. */
15329 dump_ctf_errs (ctf_dict_t
*fp
)
15331 ctf_next_t
*it
= NULL
;
15336 /* Dump accumulated errors and warnings. */
15337 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
15339 error (_("%s: %s"), is_warning
? _("warning"): _("error"),
15343 if (err
!= ECTF_NEXT_END
)
15344 error (_("CTF error: cannot get CTF errors: `%s'"), ctf_errmsg (err
));
15347 /* Dump one CTF archive member. */
15350 dump_ctf_archive_member (ctf_dict_t
*ctf
, const char *name
, ctf_dict_t
*parent
,
15353 const char *things
[] = {"Header", "Labels", "Data objects",
15354 "Function objects", "Variables", "Types", "Strings",
15356 const char **thing
;
15359 /* Don't print out the name of the default-named archive member if it appears
15360 first in the list. The name .ctf appears everywhere, even for things that
15361 aren't really archives, so printing it out is liable to be confusing; also,
15362 the common case by far is for only one archive member to exist, and hiding
15363 it in that case seems worthwhile. */
15365 if (strcmp (name
, ".ctf") != 0 || member
!= 0)
15366 printf (_("\nCTF archive member: %s:\n"), name
);
15368 if (ctf_parent_name (ctf
) != NULL
)
15369 ctf_import (ctf
, parent
);
15371 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
15373 ctf_dump_state_t
*s
= NULL
;
15376 printf ("\n %s:\n", *thing
);
15377 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
15378 (void *) " ")) != NULL
)
15380 printf ("%s\n", item
);
15384 if (ctf_errno (ctf
))
15386 error (_("Iteration failed: %s, %s\n"), *thing
,
15387 ctf_errmsg (ctf_errno (ctf
)));
15392 dump_ctf_errs (ctf
);
15396 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15398 Elf_Internal_Shdr
* symtab_sec
= NULL
;
15399 Elf_Internal_Shdr
* strtab_sec
= NULL
;
15400 void * data
= NULL
;
15401 void * symdata
= NULL
;
15402 void * strdata
= NULL
;
15403 ctf_sect_t ctfsect
, symsect
, strsect
;
15404 ctf_sect_t
* symsectp
= NULL
;
15405 ctf_sect_t
* strsectp
= NULL
;
15406 ctf_archive_t
* ctfa
= NULL
;
15407 ctf_dict_t
* parent
= NULL
;
15410 ctf_next_t
*i
= NULL
;
15416 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
15417 data
= get_section_contents (section
, filedata
);
15418 ctfsect
.cts_data
= data
;
15420 if (!dump_ctf_symtab_name
)
15421 dump_ctf_symtab_name
= strdup (".dynsym");
15423 if (!dump_ctf_strtab_name
)
15424 dump_ctf_strtab_name
= strdup (".dynstr");
15426 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
15428 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
15430 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
15433 if ((symdata
= (void *) get_data (NULL
, filedata
,
15434 symtab_sec
->sh_offset
, 1,
15435 symtab_sec
->sh_size
,
15436 _("symbols"))) == NULL
)
15438 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
15439 symsect
.cts_data
= symdata
;
15442 if (dump_ctf_strtab_name
&& dump_ctf_strtab_name
[0] != 0)
15444 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
15446 error (_("No string table section named %s\n"),
15447 dump_ctf_strtab_name
);
15450 if ((strdata
= (void *) get_data (NULL
, filedata
,
15451 strtab_sec
->sh_offset
, 1,
15452 strtab_sec
->sh_size
,
15453 _("strings"))) == NULL
)
15455 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
15456 strsect
.cts_data
= strdata
;
15459 /* Load the CTF file and dump it. It may be a raw CTF section, or an archive:
15460 libctf papers over the difference, so we can pretend it is always an
15463 if ((ctfa
= ctf_arc_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
15465 dump_ctf_errs (NULL
);
15466 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15470 ctf_arc_symsect_endianness (ctfa
, filedata
->file_header
.e_ident
[EI_DATA
]
15473 /* Preload the parent dict, since it will need to be imported into every
15475 if ((parent
= ctf_dict_open (ctfa
, dump_ctf_parent_name
, &err
)) == NULL
)
15477 dump_ctf_errs (NULL
);
15478 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15484 if (filedata
->is_separate
)
15485 printf (_("\nDump of CTF section '%s' in linked file %s:\n"),
15486 printable_section_name (filedata
, section
),
15487 filedata
->file_name
);
15489 printf (_("\nDump of CTF section '%s':\n"),
15490 printable_section_name (filedata
, section
));
15492 while ((fp
= ctf_archive_next (ctfa
, &i
, &name
, 0, &err
)) != NULL
)
15493 dump_ctf_archive_member (fp
, name
, parent
, member
++);
15494 if (err
!= ECTF_NEXT_END
)
15496 dump_ctf_errs (NULL
);
15497 error (_("CTF member open failure: %s\n"), ctf_errmsg (err
));
15502 ctf_dict_close (parent
);
15512 load_specific_debug_section (enum dwarf_section_display_enum debug
,
15513 const Elf_Internal_Shdr
* sec
,
15516 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15518 Filedata
* filedata
= (Filedata
*) data
;
15520 if (section
->start
!= NULL
)
15522 /* If it is already loaded, do nothing. */
15523 if (streq (section
->filename
, filedata
->file_name
))
15525 free (section
->start
);
15528 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
15529 section
->address
= sec
->sh_addr
;
15530 section
->filename
= filedata
->file_name
;
15531 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
15533 sec
->sh_size
, buf
);
15534 if (section
->start
== NULL
)
15538 unsigned char *start
= section
->start
;
15539 dwarf_size_type size
= sec
->sh_size
;
15540 dwarf_size_type uncompressed_size
= 0;
15542 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
15544 Elf_Internal_Chdr chdr
;
15545 unsigned int compression_header_size
;
15547 if (size
< (is_32bit_elf
15548 ? sizeof (Elf32_External_Chdr
)
15549 : sizeof (Elf64_External_Chdr
)))
15551 warn (_("compressed section %s is too small to contain a compression header\n"),
15556 compression_header_size
= get_compression_header (&chdr
, start
, size
);
15557 if (compression_header_size
== 0)
15558 /* An error message will have already been generated
15559 by get_compression_header. */
15562 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
15564 warn (_("section '%s' has unsupported compress type: %d\n"),
15565 section
->name
, chdr
.ch_type
);
15568 uncompressed_size
= chdr
.ch_size
;
15569 start
+= compression_header_size
;
15570 size
-= compression_header_size
;
15572 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
15574 /* Read the zlib header. In this case, it should be "ZLIB"
15575 followed by the uncompressed section size, 8 bytes in
15576 big-endian order. */
15577 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
15578 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
15579 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
15580 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
15581 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
15582 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
15583 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
15584 uncompressed_size
+= start
[11];
15589 if (uncompressed_size
)
15591 if (uncompress_section_contents (&start
, uncompressed_size
,
15594 /* Free the compressed buffer, update the section buffer
15595 and the section size if uncompress is successful. */
15596 free (section
->start
);
15597 section
->start
= start
;
15601 error (_("Unable to decompress section %s\n"),
15602 printable_section_name (filedata
, sec
));
15607 section
->size
= size
;
15610 if (section
->start
== NULL
)
15613 if (debug_displays
[debug
].relocate
)
15615 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
15616 & section
->reloc_info
, & section
->num_relocs
))
15621 section
->reloc_info
= NULL
;
15622 section
->num_relocs
= 0;
15628 #if HAVE_LIBDEBUGINFOD
15629 /* Return a hex string representation of the build-id. */
15631 get_build_id (void * data
)
15633 Filedata
* filedata
= (Filedata
*) data
;
15634 Elf_Internal_Shdr
* shdr
;
15637 /* Iterate through notes to find note.gnu.build-id.
15638 FIXME: Only the first note in any note section is examined. */
15639 for (i
= 0, shdr
= filedata
->section_headers
;
15640 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
15643 if (shdr
->sh_type
!= SHT_NOTE
)
15648 size_t data_remaining
;
15650 Elf_External_Note
* enote
;
15651 Elf_Internal_Note inote
;
15653 bfd_vma offset
= shdr
->sh_offset
;
15654 bfd_vma align
= shdr
->sh_addralign
;
15655 bfd_vma length
= shdr
->sh_size
;
15657 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
15663 else if (align
!= 4 && align
!= 8)
15669 end
= (char *) enote
+ length
;
15670 data_remaining
= end
- (char *) enote
;
15672 if (!is_ia64_vms (filedata
))
15674 min_notesz
= offsetof (Elf_External_Note
, name
);
15675 if (data_remaining
< min_notesz
)
15678 malformed note encountered in section %s whilst scanning for build-id note\n"),
15679 printable_section_name (filedata
, shdr
));
15683 data_remaining
-= min_notesz
;
15685 inote
.type
= BYTE_GET (enote
->type
);
15686 inote
.namesz
= BYTE_GET (enote
->namesz
);
15687 inote
.namedata
= enote
->name
;
15688 inote
.descsz
= BYTE_GET (enote
->descsz
);
15689 inote
.descdata
= ((char *) enote
15690 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
15691 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
15692 next
= ((char *) enote
15693 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
15697 Elf64_External_VMS_Note
*vms_enote
;
15699 /* PR binutils/15191
15700 Make sure that there is enough data to read. */
15701 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
15702 if (data_remaining
< min_notesz
)
15705 malformed note encountered in section %s whilst scanning for build-id note\n"),
15706 printable_section_name (filedata
, shdr
));
15710 data_remaining
-= min_notesz
;
15712 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
15713 inote
.type
= BYTE_GET (vms_enote
->type
);
15714 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
15715 inote
.namedata
= vms_enote
->name
;
15716 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
15717 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
15718 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
15719 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
15722 /* Skip malformed notes. */
15723 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
15724 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
15725 || (size_t) (next
- inote
.descdata
) < inote
.descsz
15726 || ((size_t) (next
- inote
.descdata
)
15727 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
15730 malformed note encountered in section %s whilst scanning for build-id note\n"),
15731 printable_section_name (filedata
, shdr
));
15736 /* Check if this is the build-id note. If so then convert the build-id
15737 bytes to a hex string. */
15738 if (inote
.namesz
> 0
15739 && startswith (inote
.namedata
, "GNU")
15740 && inote
.type
== NT_GNU_BUILD_ID
)
15745 build_id
= malloc (inote
.descsz
* 2 + 1);
15746 if (build_id
== NULL
)
15752 for (j
= 0; j
< inote
.descsz
; ++j
)
15753 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
15754 build_id
[inote
.descsz
* 2] = '\0';
15757 return (unsigned char *) build_id
;
15764 #endif /* HAVE_LIBDEBUGINFOD */
15766 /* If this is not NULL, load_debug_section will only look for sections
15767 within the list of sections given here. */
15768 static unsigned int * section_subset
= NULL
;
15771 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
15773 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15774 Elf_Internal_Shdr
* sec
;
15775 Filedata
* filedata
= (Filedata
*) data
;
15777 /* Without section headers we cannot find any sections. */
15778 if (filedata
->section_headers
== NULL
)
15781 if (filedata
->string_table
== NULL
15782 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
15783 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
15785 Elf_Internal_Shdr
* strs
;
15787 /* Read in the string table, so that we have section names to scan. */
15788 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
15790 if (strs
!= NULL
&& strs
->sh_size
!= 0)
15792 filedata
->string_table
15793 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
15794 1, strs
->sh_size
, _("string table"));
15796 filedata
->string_table_length
15797 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
15801 /* Locate the debug section. */
15802 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
15804 section
->name
= section
->uncompressed_name
;
15807 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
15809 section
->name
= section
->compressed_name
;
15814 /* If we're loading from a subset of sections, and we've loaded
15815 a section matching this name before, it's likely that it's a
15817 if (section_subset
!= NULL
)
15818 free_debug_section (debug
);
15820 return load_specific_debug_section (debug
, sec
, data
);
15824 free_debug_section (enum dwarf_section_display_enum debug
)
15826 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15828 if (section
->start
== NULL
)
15831 free ((char *) section
->start
);
15832 section
->start
= NULL
;
15833 section
->address
= 0;
15836 free (section
->reloc_info
);
15837 section
->reloc_info
= NULL
;
15838 section
->num_relocs
= 0;
15842 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15844 const char *name
= (section_name_valid (filedata
, section
)
15845 ? section_name (filedata
, section
) : "");
15846 const char *print_name
= printable_section_name (filedata
, section
);
15847 bfd_size_type length
;
15848 bool result
= true;
15851 length
= section
->sh_size
;
15854 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
15857 if (section
->sh_type
== SHT_NOBITS
)
15859 /* There is no point in dumping the contents of a debugging section
15860 which has the NOBITS type - the bits in the file will be random.
15861 This can happen when a file containing a .eh_frame section is
15862 stripped with the --only-keep-debug command line option. */
15863 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
15868 if (startswith (name
, ".gnu.linkonce.wi."))
15869 name
= ".debug_info";
15871 /* See if we know how to display the contents of this section. */
15872 for (i
= 0; i
< max
; i
++)
15874 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
15875 struct dwarf_section_display
* display
= debug_displays
+ i
;
15876 struct dwarf_section
* sec
= & display
->section
;
15878 if (streq (sec
->uncompressed_name
, name
)
15879 || (id
== line
&& startswith (name
, ".debug_line."))
15880 || streq (sec
->compressed_name
, name
))
15882 bool secondary
= (section
!= find_section (filedata
, name
));
15885 free_debug_section (id
);
15887 if (i
== line
&& startswith (name
, ".debug_line."))
15889 else if (streq (sec
->uncompressed_name
, name
))
15890 sec
->name
= sec
->uncompressed_name
;
15892 sec
->name
= sec
->compressed_name
;
15894 if (load_specific_debug_section (id
, section
, filedata
))
15896 /* If this debug section is part of a CU/TU set in a .dwp file,
15897 restrict load_debug_section to the sections in that set. */
15898 section_subset
= find_cu_tu_set (filedata
, shndx
);
15900 result
&= display
->display (sec
, filedata
);
15902 section_subset
= NULL
;
15904 if (secondary
|| (id
!= info
&& id
!= abbrev
&& id
!= debug_addr
))
15905 free_debug_section (id
);
15913 printf (_("Unrecognized debug section: %s\n"), print_name
);
15920 /* Set DUMP_SECTS for all sections where dumps were requested
15921 based on section name. */
15924 initialise_dumps_byname (Filedata
* filedata
)
15926 struct dump_list_entry
* cur
;
15928 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
15933 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
15934 if (section_name_valid (filedata
, filedata
->section_headers
+ i
)
15935 && streq (section_name (filedata
, filedata
->section_headers
+ i
),
15938 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
15942 if (!any
&& !filedata
->is_separate
)
15943 warn (_("Section '%s' was not dumped because it does not exist\n"),
15949 process_section_contents (Filedata
* filedata
)
15951 Elf_Internal_Shdr
* section
;
15958 initialise_dumps_byname (filedata
);
15960 for (i
= 0, section
= filedata
->section_headers
;
15961 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
15964 dump_type dump
= filedata
->dump
.dump_sects
[i
];
15966 if (filedata
->is_separate
&& ! process_links
)
15967 dump
&= DEBUG_DUMP
;
15969 #ifdef SUPPORT_DISASSEMBLY
15970 if (dump
& DISASS_DUMP
)
15972 if (! disassemble_section (section
, filedata
))
15976 if (dump
& HEX_DUMP
)
15978 if (! dump_section_as_bytes (section
, filedata
, false))
15982 if (dump
& RELOC_DUMP
)
15984 if (! dump_section_as_bytes (section
, filedata
, true))
15988 if (dump
& STRING_DUMP
)
15990 if (! dump_section_as_strings (section
, filedata
))
15994 if (dump
& DEBUG_DUMP
)
15996 if (! display_debug_section (i
, section
, filedata
))
16000 #ifdef ENABLE_LIBCTF
16001 if (dump
& CTF_DUMP
)
16003 if (! dump_section_as_ctf (section
, filedata
))
16009 if (! filedata
->is_separate
)
16011 /* Check to see if the user requested a
16012 dump of a section that does not exist. */
16013 for (; i
< filedata
->dump
.num_dump_sects
; i
++)
16014 if (filedata
->dump
.dump_sects
[i
])
16016 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
16025 process_mips_fpe_exception (int mask
)
16031 if (mask
& OEX_FPU_INEX
)
16032 fputs ("INEX", stdout
), first
= false;
16033 if (mask
& OEX_FPU_UFLO
)
16034 printf ("%sUFLO", first
? "" : "|"), first
= false;
16035 if (mask
& OEX_FPU_OFLO
)
16036 printf ("%sOFLO", first
? "" : "|"), first
= false;
16037 if (mask
& OEX_FPU_DIV0
)
16038 printf ("%sDIV0", first
? "" : "|"), first
= false;
16039 if (mask
& OEX_FPU_INVAL
)
16040 printf ("%sINVAL", first
? "" : "|");
16043 fputs ("0", stdout
);
16046 /* Display's the value of TAG at location P. If TAG is
16047 greater than 0 it is assumed to be an unknown tag, and
16048 a message is printed to this effect. Otherwise it is
16049 assumed that a message has already been printed.
16051 If the bottom bit of TAG is set it assumed to have a
16052 string value, otherwise it is assumed to have an integer
16055 Returns an updated P pointing to the first unread byte
16056 beyond the end of TAG's value.
16058 Reads at or beyond END will not be made. */
16060 static unsigned char *
16061 display_tag_value (signed int tag
,
16063 const unsigned char * const end
)
16068 printf (" Tag_unknown_%d: ", tag
);
16072 warn (_("<corrupt tag>\n"));
16076 /* PR 17531 file: 027-19978-0.004. */
16077 size_t maxlen
= (end
- p
) - 1;
16082 print_symbol ((int) maxlen
, (const char *) p
);
16083 p
+= strnlen ((char *) p
, maxlen
) + 1;
16087 printf (_("<corrupt string tag>"));
16088 p
= (unsigned char *) end
;
16094 READ_ULEB (val
, p
, end
);
16095 printf ("%ld (0x%lx)\n", val
, val
);
16102 /* ARC ABI attributes section. */
16104 static unsigned char *
16105 display_arc_attribute (unsigned char * p
,
16106 const unsigned char * const end
)
16111 READ_ULEB (tag
, p
, end
);
16115 case Tag_ARC_PCS_config
:
16116 READ_ULEB (val
, p
, end
);
16117 printf (" Tag_ARC_PCS_config: ");
16121 printf (_("Absent/Non standard\n"));
16124 printf (_("Bare metal/mwdt\n"));
16127 printf (_("Bare metal/newlib\n"));
16130 printf (_("Linux/uclibc\n"));
16133 printf (_("Linux/glibc\n"));
16136 printf (_("Unknown\n"));
16141 case Tag_ARC_CPU_base
:
16142 READ_ULEB (val
, p
, end
);
16143 printf (" Tag_ARC_CPU_base: ");
16148 printf (_("Absent\n"));
16150 case TAG_CPU_ARC6xx
:
16151 printf ("ARC6xx\n");
16153 case TAG_CPU_ARC7xx
:
16154 printf ("ARC7xx\n");
16156 case TAG_CPU_ARCEM
:
16157 printf ("ARCEM\n");
16159 case TAG_CPU_ARCHS
:
16160 printf ("ARCHS\n");
16165 case Tag_ARC_CPU_variation
:
16166 READ_ULEB (val
, p
, end
);
16167 printf (" Tag_ARC_CPU_variation: ");
16171 if (val
> 0 && val
< 16)
16172 printf ("Core%d\n", val
);
16174 printf ("Unknown\n");
16178 printf (_("Absent\n"));
16183 case Tag_ARC_CPU_name
:
16184 printf (" Tag_ARC_CPU_name: ");
16185 p
= display_tag_value (-1, p
, end
);
16188 case Tag_ARC_ABI_rf16
:
16189 READ_ULEB (val
, p
, end
);
16190 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
16193 case Tag_ARC_ABI_osver
:
16194 READ_ULEB (val
, p
, end
);
16195 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
16198 case Tag_ARC_ABI_pic
:
16199 case Tag_ARC_ABI_sda
:
16200 READ_ULEB (val
, p
, end
);
16201 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
16202 : " Tag_ARC_ABI_pic: ");
16206 printf (_("Absent\n"));
16215 printf (_("Unknown\n"));
16220 case Tag_ARC_ABI_tls
:
16221 READ_ULEB (val
, p
, end
);
16222 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
16225 case Tag_ARC_ABI_enumsize
:
16226 READ_ULEB (val
, p
, end
);
16227 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
16231 case Tag_ARC_ABI_exceptions
:
16232 READ_ULEB (val
, p
, end
);
16233 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
16237 case Tag_ARC_ABI_double_size
:
16238 READ_ULEB (val
, p
, end
);
16239 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
16242 case Tag_ARC_ISA_config
:
16243 printf (" Tag_ARC_ISA_config: ");
16244 p
= display_tag_value (-1, p
, end
);
16247 case Tag_ARC_ISA_apex
:
16248 printf (" Tag_ARC_ISA_apex: ");
16249 p
= display_tag_value (-1, p
, end
);
16252 case Tag_ARC_ISA_mpy_option
:
16253 READ_ULEB (val
, p
, end
);
16254 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
16257 case Tag_ARC_ATR_version
:
16258 READ_ULEB (val
, p
, end
);
16259 printf (" Tag_ARC_ATR_version: %d\n", val
);
16263 return display_tag_value (tag
& 1, p
, end
);
16269 /* ARM EABI attributes section. */
16274 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
16276 const char *const *table
;
16277 } arm_attr_public_tag
;
16279 static const char *const arm_attr_tag_CPU_arch
[] =
16280 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
16281 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
16282 "v8-M.mainline", "v8.1-A", "v8.2-A", "v8.3-A",
16283 "v8.1-M.mainline", "v9"};
16284 static const char *const arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
16285 static const char *const arm_attr_tag_THUMB_ISA_use
[] =
16286 {"No", "Thumb-1", "Thumb-2", "Yes"};
16287 static const char *const arm_attr_tag_FP_arch
[] =
16288 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
16289 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
16290 static const char *const arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
16291 static const char *const arm_attr_tag_Advanced_SIMD_arch
[] =
16292 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
16293 "NEON for ARMv8.1"};
16294 static const char *const arm_attr_tag_PCS_config
[] =
16295 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
16296 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
16297 static const char *const arm_attr_tag_ABI_PCS_R9_use
[] =
16298 {"V6", "SB", "TLS", "Unused"};
16299 static const char *const arm_attr_tag_ABI_PCS_RW_data
[] =
16300 {"Absolute", "PC-relative", "SB-relative", "None"};
16301 static const char *const arm_attr_tag_ABI_PCS_RO_data
[] =
16302 {"Absolute", "PC-relative", "None"};
16303 static const char *const arm_attr_tag_ABI_PCS_GOT_use
[] =
16304 {"None", "direct", "GOT-indirect"};
16305 static const char *const arm_attr_tag_ABI_PCS_wchar_t
[] =
16306 {"None", "??? 1", "2", "??? 3", "4"};
16307 static const char *const arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
16308 static const char *const arm_attr_tag_ABI_FP_denormal
[] =
16309 {"Unused", "Needed", "Sign only"};
16310 static const char *const arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
16311 static const char *const arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
16312 static const char *const arm_attr_tag_ABI_FP_number_model
[] =
16313 {"Unused", "Finite", "RTABI", "IEEE 754"};
16314 static const char *const arm_attr_tag_ABI_enum_size
[] =
16315 {"Unused", "small", "int", "forced to int"};
16316 static const char *const arm_attr_tag_ABI_HardFP_use
[] =
16317 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
16318 static const char *const arm_attr_tag_ABI_VFP_args
[] =
16319 {"AAPCS", "VFP registers", "custom", "compatible"};
16320 static const char *const arm_attr_tag_ABI_WMMX_args
[] =
16321 {"AAPCS", "WMMX registers", "custom"};
16322 static const char *const arm_attr_tag_ABI_optimization_goals
[] =
16323 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
16324 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
16325 static const char *const arm_attr_tag_ABI_FP_optimization_goals
[] =
16326 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
16327 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
16328 static const char *const arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
16329 static const char *const arm_attr_tag_FP_HP_extension
[] =
16330 {"Not Allowed", "Allowed"};
16331 static const char *const arm_attr_tag_ABI_FP_16bit_format
[] =
16332 {"None", "IEEE 754", "Alternative Format"};
16333 static const char *const arm_attr_tag_DSP_extension
[] =
16334 {"Follow architecture", "Allowed"};
16335 static const char *const arm_attr_tag_MPextension_use
[] =
16336 {"Not Allowed", "Allowed"};
16337 static const char *const arm_attr_tag_DIV_use
[] =
16338 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
16339 "Allowed in v7-A with integer division extension"};
16340 static const char *const arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
16341 static const char *const arm_attr_tag_Virtualization_use
[] =
16342 {"Not Allowed", "TrustZone", "Virtualization Extensions",
16343 "TrustZone and Virtualization Extensions"};
16344 static const char *const arm_attr_tag_MPextension_use_legacy
[] =
16345 {"Not Allowed", "Allowed"};
16347 static const char *const arm_attr_tag_MVE_arch
[] =
16348 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
16350 static const char * arm_attr_tag_PAC_extension
[] =
16351 {"No PAC/AUT instructions",
16352 "PAC/AUT instructions permitted in the NOP space",
16353 "PAC/AUT instructions permitted in the NOP and in the non-NOP space"};
16355 static const char * arm_attr_tag_BTI_extension
[] =
16356 {"BTI instructions not permitted",
16357 "BTI instructions permitted in the NOP space",
16358 "BTI instructions permitted in the NOP and in the non-NOP space"};
16360 static const char * arm_attr_tag_BTI_use
[] =
16361 {"Compiled without branch target enforcement",
16362 "Compiled with branch target enforcement"};
16364 static const char * arm_attr_tag_PACRET_use
[] =
16365 {"Compiled without return address signing and authentication",
16366 "Compiled with return address signing and authentication"};
16368 #define LOOKUP(id, name) \
16369 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
16370 static arm_attr_public_tag arm_attr_public_tags
[] =
16372 {4, "CPU_raw_name", 1, NULL
},
16373 {5, "CPU_name", 1, NULL
},
16374 LOOKUP(6, CPU_arch
),
16375 {7, "CPU_arch_profile", 0, NULL
},
16376 LOOKUP(8, ARM_ISA_use
),
16377 LOOKUP(9, THUMB_ISA_use
),
16378 LOOKUP(10, FP_arch
),
16379 LOOKUP(11, WMMX_arch
),
16380 LOOKUP(12, Advanced_SIMD_arch
),
16381 LOOKUP(13, PCS_config
),
16382 LOOKUP(14, ABI_PCS_R9_use
),
16383 LOOKUP(15, ABI_PCS_RW_data
),
16384 LOOKUP(16, ABI_PCS_RO_data
),
16385 LOOKUP(17, ABI_PCS_GOT_use
),
16386 LOOKUP(18, ABI_PCS_wchar_t
),
16387 LOOKUP(19, ABI_FP_rounding
),
16388 LOOKUP(20, ABI_FP_denormal
),
16389 LOOKUP(21, ABI_FP_exceptions
),
16390 LOOKUP(22, ABI_FP_user_exceptions
),
16391 LOOKUP(23, ABI_FP_number_model
),
16392 {24, "ABI_align_needed", 0, NULL
},
16393 {25, "ABI_align_preserved", 0, NULL
},
16394 LOOKUP(26, ABI_enum_size
),
16395 LOOKUP(27, ABI_HardFP_use
),
16396 LOOKUP(28, ABI_VFP_args
),
16397 LOOKUP(29, ABI_WMMX_args
),
16398 LOOKUP(30, ABI_optimization_goals
),
16399 LOOKUP(31, ABI_FP_optimization_goals
),
16400 {32, "compatibility", 0, NULL
},
16401 LOOKUP(34, CPU_unaligned_access
),
16402 LOOKUP(36, FP_HP_extension
),
16403 LOOKUP(38, ABI_FP_16bit_format
),
16404 LOOKUP(42, MPextension_use
),
16405 LOOKUP(44, DIV_use
),
16406 LOOKUP(46, DSP_extension
),
16407 LOOKUP(48, MVE_arch
),
16408 LOOKUP(50, PAC_extension
),
16409 LOOKUP(52, BTI_extension
),
16410 LOOKUP(74, BTI_use
),
16411 LOOKUP(76, PACRET_use
),
16412 {64, "nodefaults", 0, NULL
},
16413 {65, "also_compatible_with", 0, NULL
},
16414 LOOKUP(66, T2EE_use
),
16415 {67, "conformance", 1, NULL
},
16416 LOOKUP(68, Virtualization_use
),
16417 LOOKUP(70, MPextension_use_legacy
)
16421 static unsigned char *
16422 display_arm_attribute (unsigned char * p
,
16423 const unsigned char * const end
)
16427 arm_attr_public_tag
* attr
;
16431 READ_ULEB (tag
, p
, end
);
16433 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
16435 if (arm_attr_public_tags
[i
].tag
== tag
)
16437 attr
= &arm_attr_public_tags
[i
];
16444 printf (" Tag_%s: ", attr
->name
);
16445 switch (attr
->type
)
16450 case 7: /* Tag_CPU_arch_profile. */
16451 READ_ULEB (val
, p
, end
);
16454 case 0: printf (_("None\n")); break;
16455 case 'A': printf (_("Application\n")); break;
16456 case 'R': printf (_("Realtime\n")); break;
16457 case 'M': printf (_("Microcontroller\n")); break;
16458 case 'S': printf (_("Application or Realtime\n")); break;
16459 default: printf ("??? (%d)\n", val
); break;
16463 case 24: /* Tag_align_needed. */
16464 READ_ULEB (val
, p
, end
);
16467 case 0: printf (_("None\n")); break;
16468 case 1: printf (_("8-byte\n")); break;
16469 case 2: printf (_("4-byte\n")); break;
16470 case 3: printf ("??? 3\n"); break;
16473 printf (_("8-byte and up to %d-byte extended\n"),
16476 printf ("??? (%d)\n", val
);
16481 case 25: /* Tag_align_preserved. */
16482 READ_ULEB (val
, p
, end
);
16485 case 0: printf (_("None\n")); break;
16486 case 1: printf (_("8-byte, except leaf SP\n")); break;
16487 case 2: printf (_("8-byte\n")); break;
16488 case 3: printf ("??? 3\n"); break;
16491 printf (_("8-byte and up to %d-byte extended\n"),
16494 printf ("??? (%d)\n", val
);
16499 case 32: /* Tag_compatibility. */
16501 READ_ULEB (val
, p
, end
);
16502 printf (_("flag = %d, vendor = "), val
);
16505 size_t maxlen
= (end
- p
) - 1;
16507 print_symbol ((int) maxlen
, (const char *) p
);
16508 p
+= strnlen ((char *) p
, maxlen
) + 1;
16512 printf (_("<corrupt>"));
16513 p
= (unsigned char *) end
;
16519 case 64: /* Tag_nodefaults. */
16520 /* PR 17531: file: 001-505008-0.01. */
16523 printf (_("True\n"));
16526 case 65: /* Tag_also_compatible_with. */
16527 READ_ULEB (val
, p
, end
);
16528 if (val
== 6 /* Tag_CPU_arch. */)
16530 READ_ULEB (val
, p
, end
);
16531 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
16532 printf ("??? (%d)\n", val
);
16534 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
16538 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
16543 printf (_("<unknown: %d>\n"), tag
);
16549 return display_tag_value (-1, p
, end
);
16551 return display_tag_value (0, p
, end
);
16554 assert (attr
->type
& 0x80);
16555 READ_ULEB (val
, p
, end
);
16556 type
= attr
->type
& 0x7f;
16558 printf ("??? (%d)\n", val
);
16560 printf ("%s\n", attr
->table
[val
]);
16565 return display_tag_value (tag
, p
, end
);
16568 static unsigned char *
16569 display_gnu_attribute (unsigned char * p
,
16570 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
16571 const unsigned char * const end
)
16576 READ_ULEB (tag
, p
, end
);
16578 /* Tag_compatibility is the only generic GNU attribute defined at
16582 READ_ULEB (val
, p
, end
);
16584 printf (_("flag = %d, vendor = "), val
);
16587 printf (_("<corrupt>\n"));
16588 warn (_("corrupt vendor attribute\n"));
16594 size_t maxlen
= (end
- p
) - 1;
16596 print_symbol ((int) maxlen
, (const char *) p
);
16597 p
+= strnlen ((char *) p
, maxlen
) + 1;
16601 printf (_("<corrupt>"));
16602 p
= (unsigned char *) end
;
16609 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
16610 return display_proc_gnu_attribute (p
, tag
, end
);
16612 return display_tag_value (tag
, p
, end
);
16615 static unsigned char *
16616 display_m68k_gnu_attribute (unsigned char * p
,
16618 const unsigned char * const end
)
16622 if (tag
== Tag_GNU_M68K_ABI_FP
)
16624 printf (" Tag_GNU_M68K_ABI_FP: ");
16627 printf (_("<corrupt>\n"));
16630 READ_ULEB (val
, p
, end
);
16633 printf ("(%#x), ", val
);
16638 printf (_("unspecified hard/soft float\n"));
16641 printf (_("hard float\n"));
16644 printf (_("soft float\n"));
16650 return display_tag_value (tag
& 1, p
, end
);
16653 static unsigned char *
16654 display_power_gnu_attribute (unsigned char * p
,
16656 const unsigned char * const end
)
16660 if (tag
== Tag_GNU_Power_ABI_FP
)
16662 printf (" Tag_GNU_Power_ABI_FP: ");
16665 printf (_("<corrupt>\n"));
16668 READ_ULEB (val
, p
, end
);
16671 printf ("(%#x), ", val
);
16676 printf (_("unspecified hard/soft float, "));
16679 printf (_("hard float, "));
16682 printf (_("soft float, "));
16685 printf (_("single-precision hard float, "));
16692 printf (_("unspecified long double\n"));
16695 printf (_("128-bit IBM long double\n"));
16698 printf (_("64-bit long double\n"));
16701 printf (_("128-bit IEEE long double\n"));
16707 if (tag
== Tag_GNU_Power_ABI_Vector
)
16709 printf (" Tag_GNU_Power_ABI_Vector: ");
16712 printf (_("<corrupt>\n"));
16715 READ_ULEB (val
, p
, end
);
16718 printf ("(%#x), ", val
);
16723 printf (_("unspecified\n"));
16726 printf (_("generic\n"));
16729 printf ("AltiVec\n");
16738 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
16740 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
16743 printf (_("<corrupt>\n"));
16746 READ_ULEB (val
, p
, end
);
16749 printf ("(%#x), ", val
);
16754 printf (_("unspecified\n"));
16757 printf ("r3/r4\n");
16760 printf (_("memory\n"));
16769 return display_tag_value (tag
& 1, p
, end
);
16772 static unsigned char *
16773 display_s390_gnu_attribute (unsigned char * p
,
16775 const unsigned char * const end
)
16779 if (tag
== Tag_GNU_S390_ABI_Vector
)
16781 printf (" Tag_GNU_S390_ABI_Vector: ");
16782 READ_ULEB (val
, p
, end
);
16787 printf (_("any\n"));
16790 printf (_("software\n"));
16793 printf (_("hardware\n"));
16796 printf ("??? (%d)\n", val
);
16802 return display_tag_value (tag
& 1, p
, end
);
16806 display_sparc_hwcaps (unsigned int mask
)
16812 if (mask
& ELF_SPARC_HWCAP_MUL32
)
16813 fputs ("mul32", stdout
), first
= false;
16814 if (mask
& ELF_SPARC_HWCAP_DIV32
)
16815 printf ("%sdiv32", first
? "" : "|"), first
= false;
16816 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
16817 printf ("%sfsmuld", first
? "" : "|"), first
= false;
16818 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
16819 printf ("%sv8plus", first
? "" : "|"), first
= false;
16820 if (mask
& ELF_SPARC_HWCAP_POPC
)
16821 printf ("%spopc", first
? "" : "|"), first
= false;
16822 if (mask
& ELF_SPARC_HWCAP_VIS
)
16823 printf ("%svis", first
? "" : "|"), first
= false;
16824 if (mask
& ELF_SPARC_HWCAP_VIS2
)
16825 printf ("%svis2", first
? "" : "|"), first
= false;
16826 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
16827 printf ("%sASIBlkInit", first
? "" : "|"), first
= false;
16828 if (mask
& ELF_SPARC_HWCAP_FMAF
)
16829 printf ("%sfmaf", first
? "" : "|"), first
= false;
16830 if (mask
& ELF_SPARC_HWCAP_VIS3
)
16831 printf ("%svis3", first
? "" : "|"), first
= false;
16832 if (mask
& ELF_SPARC_HWCAP_HPC
)
16833 printf ("%shpc", first
? "" : "|"), first
= false;
16834 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
16835 printf ("%srandom", first
? "" : "|"), first
= false;
16836 if (mask
& ELF_SPARC_HWCAP_TRANS
)
16837 printf ("%strans", first
? "" : "|"), first
= false;
16838 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
16839 printf ("%sfjfmau", first
? "" : "|"), first
= false;
16840 if (mask
& ELF_SPARC_HWCAP_IMA
)
16841 printf ("%sima", first
? "" : "|"), first
= false;
16842 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
16843 printf ("%scspare", first
? "" : "|"), first
= false;
16846 fputc ('0', stdout
);
16847 fputc ('\n', stdout
);
16851 display_sparc_hwcaps2 (unsigned int mask
)
16857 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
16858 fputs ("fjathplus", stdout
), first
= false;
16859 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
16860 printf ("%svis3b", first
? "" : "|"), first
= false;
16861 if (mask
& ELF_SPARC_HWCAP2_ADP
)
16862 printf ("%sadp", first
? "" : "|"), first
= false;
16863 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
16864 printf ("%ssparc5", first
? "" : "|"), first
= false;
16865 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
16866 printf ("%smwait", first
? "" : "|"), first
= false;
16867 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
16868 printf ("%sxmpmul", first
? "" : "|"), first
= false;
16869 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
16870 printf ("%sxmont2", first
? "" : "|"), first
= false;
16871 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
16872 printf ("%snsec", first
? "" : "|"), first
= false;
16873 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
16874 printf ("%sfjathhpc", first
? "" : "|"), first
= false;
16875 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
16876 printf ("%sfjdes", first
? "" : "|"), first
= false;
16877 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
16878 printf ("%sfjaes", first
? "" : "|"), first
= false;
16881 fputc ('0', stdout
);
16882 fputc ('\n', stdout
);
16885 static unsigned char *
16886 display_sparc_gnu_attribute (unsigned char * p
,
16888 const unsigned char * const end
)
16892 if (tag
== Tag_GNU_Sparc_HWCAPS
)
16894 READ_ULEB (val
, p
, end
);
16895 printf (" Tag_GNU_Sparc_HWCAPS: ");
16896 display_sparc_hwcaps (val
);
16899 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
16901 READ_ULEB (val
, p
, end
);
16902 printf (" Tag_GNU_Sparc_HWCAPS2: ");
16903 display_sparc_hwcaps2 (val
);
16907 return display_tag_value (tag
, p
, end
);
16911 print_mips_fp_abi_value (unsigned int val
)
16915 case Val_GNU_MIPS_ABI_FP_ANY
:
16916 printf (_("Hard or soft float\n"));
16918 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
16919 printf (_("Hard float (double precision)\n"));
16921 case Val_GNU_MIPS_ABI_FP_SINGLE
:
16922 printf (_("Hard float (single precision)\n"));
16924 case Val_GNU_MIPS_ABI_FP_SOFT
:
16925 printf (_("Soft float\n"));
16927 case Val_GNU_MIPS_ABI_FP_OLD_64
:
16928 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
16930 case Val_GNU_MIPS_ABI_FP_XX
:
16931 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
16933 case Val_GNU_MIPS_ABI_FP_64
:
16934 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
16936 case Val_GNU_MIPS_ABI_FP_64A
:
16937 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
16939 case Val_GNU_MIPS_ABI_FP_NAN2008
:
16940 printf (_("NaN 2008 compatibility\n"));
16943 printf ("??? (%d)\n", val
);
16948 static unsigned char *
16949 display_mips_gnu_attribute (unsigned char * p
,
16951 const unsigned char * const end
)
16953 if (tag
== Tag_GNU_MIPS_ABI_FP
)
16957 printf (" Tag_GNU_MIPS_ABI_FP: ");
16958 READ_ULEB (val
, p
, end
);
16959 print_mips_fp_abi_value (val
);
16963 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
16967 printf (" Tag_GNU_MIPS_ABI_MSA: ");
16968 READ_ULEB (val
, p
, end
);
16972 case Val_GNU_MIPS_ABI_MSA_ANY
:
16973 printf (_("Any MSA or not\n"));
16975 case Val_GNU_MIPS_ABI_MSA_128
:
16976 printf (_("128-bit MSA\n"));
16979 printf ("??? (%d)\n", val
);
16985 return display_tag_value (tag
& 1, p
, end
);
16988 static unsigned char *
16989 display_tic6x_attribute (unsigned char * p
,
16990 const unsigned char * const end
)
16995 READ_ULEB (tag
, p
, end
);
17000 printf (" Tag_ISA: ");
17001 READ_ULEB (val
, p
, end
);
17005 case C6XABI_Tag_ISA_none
:
17006 printf (_("None\n"));
17008 case C6XABI_Tag_ISA_C62X
:
17011 case C6XABI_Tag_ISA_C67X
:
17014 case C6XABI_Tag_ISA_C67XP
:
17015 printf ("C67x+\n");
17017 case C6XABI_Tag_ISA_C64X
:
17020 case C6XABI_Tag_ISA_C64XP
:
17021 printf ("C64x+\n");
17023 case C6XABI_Tag_ISA_C674X
:
17024 printf ("C674x\n");
17027 printf ("??? (%d)\n", val
);
17032 case Tag_ABI_wchar_t
:
17033 printf (" Tag_ABI_wchar_t: ");
17034 READ_ULEB (val
, p
, end
);
17038 printf (_("Not used\n"));
17041 printf (_("2 bytes\n"));
17044 printf (_("4 bytes\n"));
17047 printf ("??? (%d)\n", val
);
17052 case Tag_ABI_stack_align_needed
:
17053 printf (" Tag_ABI_stack_align_needed: ");
17054 READ_ULEB (val
, p
, end
);
17058 printf (_("8-byte\n"));
17061 printf (_("16-byte\n"));
17064 printf ("??? (%d)\n", val
);
17069 case Tag_ABI_stack_align_preserved
:
17070 READ_ULEB (val
, p
, end
);
17071 printf (" Tag_ABI_stack_align_preserved: ");
17075 printf (_("8-byte\n"));
17078 printf (_("16-byte\n"));
17081 printf ("??? (%d)\n", val
);
17087 READ_ULEB (val
, p
, end
);
17088 printf (" Tag_ABI_DSBT: ");
17092 printf (_("DSBT addressing not used\n"));
17095 printf (_("DSBT addressing used\n"));
17098 printf ("??? (%d)\n", val
);
17104 READ_ULEB (val
, p
, end
);
17105 printf (" Tag_ABI_PID: ");
17109 printf (_("Data addressing position-dependent\n"));
17112 printf (_("Data addressing position-independent, GOT near DP\n"));
17115 printf (_("Data addressing position-independent, GOT far from DP\n"));
17118 printf ("??? (%d)\n", val
);
17124 READ_ULEB (val
, p
, end
);
17125 printf (" Tag_ABI_PIC: ");
17129 printf (_("Code addressing position-dependent\n"));
17132 printf (_("Code addressing position-independent\n"));
17135 printf ("??? (%d)\n", val
);
17140 case Tag_ABI_array_object_alignment
:
17141 READ_ULEB (val
, p
, end
);
17142 printf (" Tag_ABI_array_object_alignment: ");
17146 printf (_("8-byte\n"));
17149 printf (_("4-byte\n"));
17152 printf (_("16-byte\n"));
17155 printf ("??? (%d)\n", val
);
17160 case Tag_ABI_array_object_align_expected
:
17161 READ_ULEB (val
, p
, end
);
17162 printf (" Tag_ABI_array_object_align_expected: ");
17166 printf (_("8-byte\n"));
17169 printf (_("4-byte\n"));
17172 printf (_("16-byte\n"));
17175 printf ("??? (%d)\n", val
);
17180 case Tag_ABI_compatibility
:
17182 READ_ULEB (val
, p
, end
);
17183 printf (" Tag_ABI_compatibility: ");
17184 printf (_("flag = %d, vendor = "), val
);
17187 size_t maxlen
= (end
- p
) - 1;
17189 print_symbol ((int) maxlen
, (const char *) p
);
17190 p
+= strnlen ((char *) p
, maxlen
) + 1;
17194 printf (_("<corrupt>"));
17195 p
= (unsigned char *) end
;
17201 case Tag_ABI_conformance
:
17203 printf (" Tag_ABI_conformance: \"");
17206 size_t maxlen
= (end
- p
) - 1;
17208 print_symbol ((int) maxlen
, (const char *) p
);
17209 p
+= strnlen ((char *) p
, maxlen
) + 1;
17213 printf (_("<corrupt>"));
17214 p
= (unsigned char *) end
;
17221 return display_tag_value (tag
, p
, end
);
17225 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
17227 unsigned long addr
= 0;
17228 size_t bytes
= end
- p
;
17235 int lbytes
= (bytes
> 16 ? 16 : bytes
);
17237 printf (" 0x%8.8lx ", addr
);
17239 for (j
= 0; j
< 16; j
++)
17242 printf ("%2.2x", p
[j
]);
17250 for (j
= 0; j
< lbytes
; j
++)
17253 if (k
>= ' ' && k
< 0x7f)
17269 static unsigned char *
17270 display_msp430_attribute (unsigned char * p
,
17271 const unsigned char * const end
)
17276 READ_ULEB (tag
, p
, end
);
17280 case OFBA_MSPABI_Tag_ISA
:
17281 printf (" Tag_ISA: ");
17282 READ_ULEB (val
, p
, end
);
17285 case 0: printf (_("None\n")); break;
17286 case 1: printf (_("MSP430\n")); break;
17287 case 2: printf (_("MSP430X\n")); break;
17288 default: printf ("??? (%d)\n", val
); break;
17292 case OFBA_MSPABI_Tag_Code_Model
:
17293 printf (" Tag_Code_Model: ");
17294 READ_ULEB (val
, p
, end
);
17297 case 0: printf (_("None\n")); break;
17298 case 1: printf (_("Small\n")); break;
17299 case 2: printf (_("Large\n")); break;
17300 default: printf ("??? (%d)\n", val
); break;
17304 case OFBA_MSPABI_Tag_Data_Model
:
17305 printf (" Tag_Data_Model: ");
17306 READ_ULEB (val
, p
, end
);
17309 case 0: printf (_("None\n")); break;
17310 case 1: printf (_("Small\n")); break;
17311 case 2: printf (_("Large\n")); break;
17312 case 3: printf (_("Restricted Large\n")); break;
17313 default: printf ("??? (%d)\n", val
); break;
17318 printf (_(" <unknown tag %d>: "), tag
);
17325 size_t maxlen
= (end
- p
) - 1;
17327 print_symbol ((int) maxlen
, (const char *) p
);
17328 p
+= strnlen ((char *) p
, maxlen
) + 1;
17332 printf (_("<corrupt>"));
17333 p
= (unsigned char *) end
;
17339 READ_ULEB (val
, p
, end
);
17340 printf ("%d (0x%x)\n", val
, val
);
17349 static unsigned char *
17350 display_msp430_gnu_attribute (unsigned char * p
,
17352 const unsigned char * const end
)
17354 if (tag
== Tag_GNU_MSP430_Data_Region
)
17358 printf (" Tag_GNU_MSP430_Data_Region: ");
17359 READ_ULEB (val
, p
, end
);
17363 case Val_GNU_MSP430_Data_Region_Any
:
17364 printf (_("Any Region\n"));
17366 case Val_GNU_MSP430_Data_Region_Lower
:
17367 printf (_("Lower Region Only\n"));
17370 printf ("??? (%u)\n", val
);
17374 return display_tag_value (tag
& 1, p
, end
);
17377 struct riscv_attr_tag_t
{
17382 static struct riscv_attr_tag_t riscv_attr_tag
[] =
17384 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
17387 T(priv_spec_minor
),
17388 T(priv_spec_revision
),
17389 T(unaligned_access
),
17394 static unsigned char *
17395 display_riscv_attribute (unsigned char *p
,
17396 const unsigned char * const end
)
17400 struct riscv_attr_tag_t
*attr
= NULL
;
17403 READ_ULEB (tag
, p
, end
);
17405 /* Find the name of attribute. */
17406 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
17408 if (riscv_attr_tag
[i
].tag
== tag
)
17410 attr
= &riscv_attr_tag
[i
];
17416 printf (" %s: ", attr
->name
);
17418 return display_tag_value (tag
, p
, end
);
17422 case Tag_RISCV_priv_spec
:
17423 case Tag_RISCV_priv_spec_minor
:
17424 case Tag_RISCV_priv_spec_revision
:
17425 READ_ULEB (val
, p
, end
);
17426 printf (_("%u\n"), val
);
17428 case Tag_RISCV_unaligned_access
:
17429 READ_ULEB (val
, p
, end
);
17433 printf (_("No unaligned access\n"));
17436 printf (_("Unaligned access\n"));
17440 case Tag_RISCV_stack_align
:
17441 READ_ULEB (val
, p
, end
);
17442 printf (_("%u-bytes\n"), val
);
17444 case Tag_RISCV_arch
:
17445 p
= display_tag_value (-1, p
, end
);
17448 return display_tag_value (tag
, p
, end
);
17454 static unsigned char *
17455 display_csky_attribute (unsigned char * p
,
17456 const unsigned char * const end
)
17460 READ_ULEB (tag
, p
, end
);
17462 if (tag
>= Tag_CSKY_MAX
)
17464 return display_tag_value (-1, p
, end
);
17469 case Tag_CSKY_ARCH_NAME
:
17470 printf (" Tag_CSKY_ARCH_NAME:\t\t");
17471 return display_tag_value (-1, p
, end
);
17472 case Tag_CSKY_CPU_NAME
:
17473 printf (" Tag_CSKY_CPU_NAME:\t\t");
17474 return display_tag_value (-1, p
, end
);
17476 case Tag_CSKY_ISA_FLAGS
:
17477 printf (" Tag_CSKY_ISA_FLAGS:\t\t");
17478 return display_tag_value (0, p
, end
);
17479 case Tag_CSKY_ISA_EXT_FLAGS
:
17480 printf (" Tag_CSKY_ISA_EXT_FLAGS:\t");
17481 return display_tag_value (0, p
, end
);
17483 case Tag_CSKY_DSP_VERSION
:
17484 printf (" Tag_CSKY_DSP_VERSION:\t\t");
17485 READ_ULEB (val
, p
, end
);
17486 if (val
== VAL_CSKY_DSP_VERSION_EXTENSION
)
17487 printf ("DSP Extension\n");
17488 else if (val
== VAL_CSKY_DSP_VERSION_2
)
17489 printf ("DSP 2.0\n");
17492 case Tag_CSKY_VDSP_VERSION
:
17493 printf (" Tag_CSKY_VDSP_VERSION:\t");
17494 READ_ULEB (val
, p
, end
);
17495 printf ("VDSP Version %d\n", val
);
17498 case Tag_CSKY_FPU_VERSION
:
17499 printf (" Tag_CSKY_FPU_VERSION:\t\t");
17500 READ_ULEB (val
, p
, end
);
17501 if (val
== VAL_CSKY_FPU_VERSION_1
)
17502 printf ("ABIV1 FPU Version 1\n");
17503 else if (val
== VAL_CSKY_FPU_VERSION_2
)
17504 printf ("FPU Version 2\n");
17507 case Tag_CSKY_FPU_ABI
:
17508 printf (" Tag_CSKY_FPU_ABI:\t\t");
17509 READ_ULEB (val
, p
, end
);
17510 if (val
== VAL_CSKY_FPU_ABI_HARD
)
17512 else if (val
== VAL_CSKY_FPU_ABI_SOFTFP
)
17513 printf ("SoftFP\n");
17514 else if (val
== VAL_CSKY_FPU_ABI_SOFT
)
17517 case Tag_CSKY_FPU_ROUNDING
:
17518 READ_ULEB (val
, p
, end
);
17521 printf (" Tag_CSKY_FPU_ROUNDING:\t");
17522 printf ("Needed\n");
17525 case Tag_CSKY_FPU_DENORMAL
:
17526 READ_ULEB (val
, p
, end
);
17529 printf (" Tag_CSKY_FPU_DENORMAL:\t");
17530 printf ("Needed\n");
17533 case Tag_CSKY_FPU_Exception
:
17534 READ_ULEB (val
, p
, end
);
17537 printf (" Tag_CSKY_FPU_Exception:\t");
17538 printf ("Needed\n");
17541 case Tag_CSKY_FPU_NUMBER_MODULE
:
17542 printf (" Tag_CSKY_FPU_NUMBER_MODULE:\t");
17543 return display_tag_value (-1, p
, end
);
17544 case Tag_CSKY_FPU_HARDFP
:
17545 printf (" Tag_CSKY_FPU_HARDFP:\t\t");
17546 READ_ULEB (val
, p
, end
);
17547 if (val
& VAL_CSKY_FPU_HARDFP_HALF
)
17549 if (val
& VAL_CSKY_FPU_HARDFP_SINGLE
)
17550 printf (" Single");
17551 if (val
& VAL_CSKY_FPU_HARDFP_DOUBLE
)
17552 printf (" Double");
17556 return display_tag_value (tag
, p
, end
);
17562 process_attributes (Filedata
* filedata
,
17563 const char * public_name
,
17564 unsigned int proc_type
,
17565 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
17566 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
17568 Elf_Internal_Shdr
* sect
;
17572 /* Find the section header so that we get the size. */
17573 for (i
= 0, sect
= filedata
->section_headers
;
17574 i
< filedata
->file_header
.e_shnum
;
17577 unsigned char * contents
;
17580 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
17583 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17584 sect
->sh_size
, _("attributes"));
17585 if (contents
== NULL
)
17592 /* The first character is the version of the attributes.
17593 Currently only version 1, (aka 'A') is recognised here. */
17596 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
17601 bfd_vma section_len
;
17603 section_len
= sect
->sh_size
- 1;
17606 while (section_len
> 0)
17609 unsigned int namelen
;
17610 bool public_section
;
17613 if (section_len
<= 4)
17615 error (_("Tag section ends prematurely\n"));
17619 attr_len
= byte_get (p
, 4);
17622 if (attr_len
> section_len
)
17624 error (_("Bad attribute length (%u > %u)\n"),
17625 (unsigned) attr_len
, (unsigned) section_len
);
17626 attr_len
= section_len
;
17629 /* PR 17531: file: 001-101425-0.004 */
17630 else if (attr_len
< 5)
17632 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
17637 section_len
-= attr_len
;
17640 namelen
= strnlen ((char *) p
, attr_len
) + 1;
17641 if (namelen
== 0 || namelen
>= attr_len
)
17643 error (_("Corrupt attribute section name\n"));
17648 printf (_("Attribute Section: "));
17649 print_symbol (INT_MAX
, (const char *) p
);
17652 if (public_name
&& streq ((char *) p
, public_name
))
17653 public_section
= true;
17655 public_section
= false;
17657 if (streq ((char *) p
, "gnu"))
17658 gnu_section
= true;
17660 gnu_section
= false;
17663 attr_len
-= namelen
;
17665 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
17670 unsigned char * end
;
17672 /* PR binutils/17531: Safe handling of corrupt files. */
17675 error (_("Unused bytes at end of section\n"));
17682 size
= byte_get (p
, 4);
17683 if (size
> attr_len
)
17685 error (_("Bad subsection length (%u > %u)\n"),
17686 (unsigned) size
, (unsigned) attr_len
);
17690 /* PR binutils/17531: Safe handling of corrupt files. */
17693 error (_("Bad subsection length (%u < 6)\n"),
17701 end
= p
+ size
- 1;
17702 assert (end
<= contents
+ sect
->sh_size
);
17708 printf (_("File Attributes\n"));
17711 printf (_("Section Attributes:"));
17714 printf (_("Symbol Attributes:"));
17715 /* Fall through. */
17719 READ_ULEB (val
, p
, end
);
17722 printf (" %d", val
);
17727 printf (_("Unknown tag: %d\n"), tag
);
17728 public_section
= false;
17732 if (public_section
&& display_pub_attribute
!= NULL
)
17735 p
= display_pub_attribute (p
, end
);
17738 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
17741 p
= display_gnu_attribute (p
,
17742 display_proc_gnu_attribute
,
17748 printf (_(" Unknown attribute:\n"));
17749 display_raw_attribute (p
, end
);
17764 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
17765 Print the Address, Access and Initial fields of an entry at VMA ADDR
17766 and return the VMA of the next entry, or -1 if there was a problem.
17767 Does not read from DATA_END or beyond. */
17770 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
17771 unsigned char * data_end
)
17774 print_vma (addr
, LONG_HEX
);
17776 if (addr
< pltgot
+ 0xfff0)
17777 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
17779 printf ("%10s", "");
17782 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
17786 unsigned char * from
= data
+ addr
- pltgot
;
17788 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
17790 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
17791 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
17792 return (bfd_vma
) -1;
17796 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
17797 print_vma (entry
, LONG_HEX
);
17800 return addr
+ (is_32bit_elf
? 4 : 8);
17803 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
17804 PLTGOT. Print the Address and Initial fields of an entry at VMA
17805 ADDR and return the VMA of the next entry. */
17808 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
17811 print_vma (addr
, LONG_HEX
);
17814 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
17819 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
17820 print_vma (entry
, LONG_HEX
);
17822 return addr
+ (is_32bit_elf
? 4 : 8);
17826 print_mips_ases (unsigned int mask
)
17828 if (mask
& AFL_ASE_DSP
)
17829 fputs ("\n\tDSP ASE", stdout
);
17830 if (mask
& AFL_ASE_DSPR2
)
17831 fputs ("\n\tDSP R2 ASE", stdout
);
17832 if (mask
& AFL_ASE_DSPR3
)
17833 fputs ("\n\tDSP R3 ASE", stdout
);
17834 if (mask
& AFL_ASE_EVA
)
17835 fputs ("\n\tEnhanced VA Scheme", stdout
);
17836 if (mask
& AFL_ASE_MCU
)
17837 fputs ("\n\tMCU (MicroController) ASE", stdout
);
17838 if (mask
& AFL_ASE_MDMX
)
17839 fputs ("\n\tMDMX ASE", stdout
);
17840 if (mask
& AFL_ASE_MIPS3D
)
17841 fputs ("\n\tMIPS-3D ASE", stdout
);
17842 if (mask
& AFL_ASE_MT
)
17843 fputs ("\n\tMT ASE", stdout
);
17844 if (mask
& AFL_ASE_SMARTMIPS
)
17845 fputs ("\n\tSmartMIPS ASE", stdout
);
17846 if (mask
& AFL_ASE_VIRT
)
17847 fputs ("\n\tVZ ASE", stdout
);
17848 if (mask
& AFL_ASE_MSA
)
17849 fputs ("\n\tMSA ASE", stdout
);
17850 if (mask
& AFL_ASE_MIPS16
)
17851 fputs ("\n\tMIPS16 ASE", stdout
);
17852 if (mask
& AFL_ASE_MICROMIPS
)
17853 fputs ("\n\tMICROMIPS ASE", stdout
);
17854 if (mask
& AFL_ASE_XPA
)
17855 fputs ("\n\tXPA ASE", stdout
);
17856 if (mask
& AFL_ASE_MIPS16E2
)
17857 fputs ("\n\tMIPS16e2 ASE", stdout
);
17858 if (mask
& AFL_ASE_CRC
)
17859 fputs ("\n\tCRC ASE", stdout
);
17860 if (mask
& AFL_ASE_GINV
)
17861 fputs ("\n\tGINV ASE", stdout
);
17862 if (mask
& AFL_ASE_LOONGSON_MMI
)
17863 fputs ("\n\tLoongson MMI ASE", stdout
);
17864 if (mask
& AFL_ASE_LOONGSON_CAM
)
17865 fputs ("\n\tLoongson CAM ASE", stdout
);
17866 if (mask
& AFL_ASE_LOONGSON_EXT
)
17867 fputs ("\n\tLoongson EXT ASE", stdout
);
17868 if (mask
& AFL_ASE_LOONGSON_EXT2
)
17869 fputs ("\n\tLoongson EXT2 ASE", stdout
);
17871 fprintf (stdout
, "\n\t%s", _("None"));
17872 else if ((mask
& ~AFL_ASE_MASK
) != 0)
17873 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
17877 print_mips_isa_ext (unsigned int isa_ext
)
17882 fputs (_("None"), stdout
);
17885 fputs ("RMI XLR", stdout
);
17887 case AFL_EXT_OCTEON3
:
17888 fputs ("Cavium Networks Octeon3", stdout
);
17890 case AFL_EXT_OCTEON2
:
17891 fputs ("Cavium Networks Octeon2", stdout
);
17893 case AFL_EXT_OCTEONP
:
17894 fputs ("Cavium Networks OcteonP", stdout
);
17896 case AFL_EXT_OCTEON
:
17897 fputs ("Cavium Networks Octeon", stdout
);
17900 fputs ("Toshiba R5900", stdout
);
17903 fputs ("MIPS R4650", stdout
);
17906 fputs ("LSI R4010", stdout
);
17909 fputs ("NEC VR4100", stdout
);
17912 fputs ("Toshiba R3900", stdout
);
17914 case AFL_EXT_10000
:
17915 fputs ("MIPS R10000", stdout
);
17918 fputs ("Broadcom SB-1", stdout
);
17921 fputs ("NEC VR4111/VR4181", stdout
);
17924 fputs ("NEC VR4120", stdout
);
17927 fputs ("NEC VR5400", stdout
);
17930 fputs ("NEC VR5500", stdout
);
17932 case AFL_EXT_LOONGSON_2E
:
17933 fputs ("ST Microelectronics Loongson 2E", stdout
);
17935 case AFL_EXT_LOONGSON_2F
:
17936 fputs ("ST Microelectronics Loongson 2F", stdout
);
17938 case AFL_EXT_INTERAPTIV_MR2
:
17939 fputs ("Imagination interAptiv MR2", stdout
);
17942 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
17947 get_mips_reg_size (int reg_size
)
17949 return (reg_size
== AFL_REG_NONE
) ? 0
17950 : (reg_size
== AFL_REG_32
) ? 32
17951 : (reg_size
== AFL_REG_64
) ? 64
17952 : (reg_size
== AFL_REG_128
) ? 128
17957 process_mips_specific (Filedata
* filedata
)
17959 Elf_Internal_Dyn
* entry
;
17960 Elf_Internal_Shdr
*sect
= NULL
;
17961 size_t liblist_offset
= 0;
17962 size_t liblistno
= 0;
17963 size_t conflictsno
= 0;
17964 size_t options_offset
= 0;
17965 size_t conflicts_offset
= 0;
17966 size_t pltrelsz
= 0;
17968 bfd_vma pltgot
= 0;
17969 bfd_vma mips_pltgot
= 0;
17970 bfd_vma jmprel
= 0;
17971 bfd_vma local_gotno
= 0;
17972 bfd_vma gotsym
= 0;
17973 bfd_vma symtabno
= 0;
17976 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17977 display_mips_gnu_attribute
))
17980 sect
= find_section (filedata
, ".MIPS.abiflags");
17984 Elf_External_ABIFlags_v0
*abiflags_ext
;
17985 Elf_Internal_ABIFlags_v0 abiflags_in
;
17987 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
17989 error (_("Corrupt MIPS ABI Flags section.\n"));
17994 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17995 sect
->sh_size
, _("MIPS ABI Flags section"));
17998 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
17999 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
18000 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
18001 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
18002 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
18003 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
18004 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
18005 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
18006 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
18007 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
18008 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
18010 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
18011 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
18012 if (abiflags_in
.isa_rev
> 1)
18013 printf ("r%d", abiflags_in
.isa_rev
);
18014 printf ("\nGPR size: %d",
18015 get_mips_reg_size (abiflags_in
.gpr_size
));
18016 printf ("\nCPR1 size: %d",
18017 get_mips_reg_size (abiflags_in
.cpr1_size
));
18018 printf ("\nCPR2 size: %d",
18019 get_mips_reg_size (abiflags_in
.cpr2_size
));
18020 fputs ("\nFP ABI: ", stdout
);
18021 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
18022 fputs ("ISA Extension: ", stdout
);
18023 print_mips_isa_ext (abiflags_in
.isa_ext
);
18024 fputs ("\nASEs:", stdout
);
18025 print_mips_ases (abiflags_in
.ases
);
18026 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
18027 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
18028 fputc ('\n', stdout
);
18029 free (abiflags_ext
);
18034 /* We have a lot of special sections. Thanks SGI! */
18035 if (filedata
->dynamic_section
== NULL
)
18037 /* No dynamic information available. See if there is static GOT. */
18038 sect
= find_section (filedata
, ".got");
18041 unsigned char *data_end
;
18042 unsigned char *data
;
18046 pltgot
= sect
->sh_addr
;
18049 addr_size
= (is_32bit_elf
? 4 : 8);
18050 end
= pltgot
+ sect
->sh_size
;
18052 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
18054 _("Global Offset Table data"));
18055 /* PR 12855: Null data is handled gracefully throughout. */
18056 data_end
= data
+ (end
- pltgot
);
18058 printf (_("\nStatic GOT:\n"));
18059 printf (_(" Canonical gp value: "));
18060 print_vma (ent
+ 0x7ff0, LONG_HEX
);
18063 /* In a dynamic binary GOT[0] is reserved for the dynamic
18064 loader to store the lazy resolver pointer, however in
18065 a static binary it may well have been omitted and GOT
18066 reduced to a table of addresses.
18067 PR 21344: Check for the entry being fully available
18068 before fetching it. */
18070 && data
+ ent
- pltgot
+ addr_size
<= data_end
18071 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
18073 printf (_(" Reserved entries:\n"));
18074 printf (_(" %*s %10s %*s\n"),
18075 addr_size
* 2, _("Address"), _("Access"),
18076 addr_size
* 2, _("Value"));
18077 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18079 if (ent
== (bfd_vma
) -1)
18080 goto sgot_print_fail
;
18082 /* Check for the MSB of GOT[1] being set, identifying a
18083 GNU object. This entry will be used by some runtime
18084 loaders, to store the module pointer. Otherwise this
18085 is an ordinary local entry.
18086 PR 21344: Check for the entry being fully available
18087 before fetching it. */
18089 && data
+ ent
- pltgot
+ addr_size
<= data_end
18090 && (byte_get (data
+ ent
- pltgot
, addr_size
)
18091 >> (addr_size
* 8 - 1)) != 0)
18093 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18095 if (ent
== (bfd_vma
) -1)
18096 goto sgot_print_fail
;
18101 if (data
!= NULL
&& ent
< end
)
18103 printf (_(" Local entries:\n"));
18104 printf (" %*s %10s %*s\n",
18105 addr_size
* 2, _("Address"), _("Access"),
18106 addr_size
* 2, _("Value"));
18109 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18111 if (ent
== (bfd_vma
) -1)
18112 goto sgot_print_fail
;
18123 for (entry
= filedata
->dynamic_section
;
18124 /* PR 17531 file: 012-50589-0.004. */
18125 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
18126 && entry
->d_tag
!= DT_NULL
);
18128 switch (entry
->d_tag
)
18130 case DT_MIPS_LIBLIST
:
18132 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
18133 liblistno
* sizeof (Elf32_External_Lib
));
18135 case DT_MIPS_LIBLISTNO
:
18136 liblistno
= entry
->d_un
.d_val
;
18138 case DT_MIPS_OPTIONS
:
18139 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
18141 case DT_MIPS_CONFLICT
:
18143 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
18144 conflictsno
* sizeof (Elf32_External_Conflict
));
18146 case DT_MIPS_CONFLICTNO
:
18147 conflictsno
= entry
->d_un
.d_val
;
18150 pltgot
= entry
->d_un
.d_ptr
;
18152 case DT_MIPS_LOCAL_GOTNO
:
18153 local_gotno
= entry
->d_un
.d_val
;
18155 case DT_MIPS_GOTSYM
:
18156 gotsym
= entry
->d_un
.d_val
;
18158 case DT_MIPS_SYMTABNO
:
18159 symtabno
= entry
->d_un
.d_val
;
18161 case DT_MIPS_PLTGOT
:
18162 mips_pltgot
= entry
->d_un
.d_ptr
;
18165 pltrel
= entry
->d_un
.d_val
;
18168 pltrelsz
= entry
->d_un
.d_val
;
18171 jmprel
= entry
->d_un
.d_ptr
;
18177 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
18179 Elf32_External_Lib
* elib
;
18182 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
18183 sizeof (Elf32_External_Lib
),
18185 _("liblist section data"));
18188 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
18189 "\nSection '.liblist' contains %lu entries:\n",
18190 (unsigned long) liblistno
),
18191 (unsigned long) liblistno
);
18192 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
18195 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
18202 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
18203 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
18204 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
18205 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
18206 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
18208 tmp
= gmtime (&atime
);
18209 snprintf (timebuf
, sizeof (timebuf
),
18210 "%04u-%02u-%02uT%02u:%02u:%02u",
18211 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
18212 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
18214 printf ("%3lu: ", (unsigned long) cnt
);
18215 if (valid_dynamic_name (filedata
, liblist
.l_name
))
18216 print_symbol (20, get_dynamic_name (filedata
, liblist
.l_name
));
18218 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
18219 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
18220 liblist
.l_version
);
18222 if (liblist
.l_flags
== 0)
18226 static const struct
18233 { " EXACT_MATCH", LL_EXACT_MATCH
},
18234 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
18235 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
18236 { " EXPORTS", LL_EXPORTS
},
18237 { " DELAY_LOAD", LL_DELAY_LOAD
},
18238 { " DELTA", LL_DELTA
}
18240 int flags
= liblist
.l_flags
;
18243 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
18244 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
18246 fputs (l_flags_vals
[fcnt
].name
, stdout
);
18247 flags
^= l_flags_vals
[fcnt
].bit
;
18250 printf (" %#x", (unsigned int) flags
);
18262 if (options_offset
!= 0)
18264 Elf_External_Options
* eopt
;
18268 /* Find the section header so that we get the size. */
18269 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
18270 /* PR 17533 file: 012-277276-0.004. */
18273 error (_("No MIPS_OPTIONS header found\n"));
18277 if (sect
->sh_size
< sizeof (* eopt
))
18279 error (_("The MIPS options section is too small.\n"));
18283 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
18284 sect
->sh_size
, _("options"));
18287 Elf_Internal_Options option
;
18290 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
18292 Elf_External_Options
* eoption
;
18293 unsigned int optsize
;
18295 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
18297 optsize
= BYTE_GET (eoption
->size
);
18299 /* PR 17531: file: ffa0fa3b. */
18300 if (optsize
< sizeof (* eopt
)
18301 || optsize
> sect
->sh_size
- offset
)
18303 error (_("Invalid size (%u) for MIPS option\n"),
18312 printf (ngettext ("\nSection '%s' contains %d entry:\n",
18313 "\nSection '%s' contains %d entries:\n",
18315 printable_section_name (filedata
, sect
), cnt
);
18321 Elf_External_Options
* eoption
;
18323 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
18325 option
.kind
= BYTE_GET (eoption
->kind
);
18326 option
.size
= BYTE_GET (eoption
->size
);
18327 option
.section
= BYTE_GET (eoption
->section
);
18328 option
.info
= BYTE_GET (eoption
->info
);
18330 switch (option
.kind
)
18333 /* This shouldn't happen. */
18334 printf (" NULL %" PRId16
" %" PRIx32
,
18335 option
.section
, option
.info
);
18339 printf (" REGINFO ");
18340 if (filedata
->file_header
.e_machine
== EM_MIPS
)
18342 Elf32_External_RegInfo
* ereg
;
18343 Elf32_RegInfo reginfo
;
18346 if (option
.size
< (sizeof (Elf_External_Options
)
18347 + sizeof (Elf32_External_RegInfo
)))
18349 printf (_("<corrupt>\n"));
18350 error (_("Truncated MIPS REGINFO option\n"));
18355 ereg
= (Elf32_External_RegInfo
*) (eoption
+ 1);
18357 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
18358 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
18359 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
18360 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
18361 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
18362 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
18364 printf ("GPR %08" PRIx32
" GP 0x%" PRIx32
"\n",
18365 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
18367 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
18368 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
18369 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
18370 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
18375 Elf64_External_RegInfo
* ereg
;
18376 Elf64_Internal_RegInfo reginfo
;
18378 if (option
.size
< (sizeof (Elf_External_Options
)
18379 + sizeof (Elf64_External_RegInfo
)))
18381 printf (_("<corrupt>\n"));
18382 error (_("Truncated MIPS REGINFO option\n"));
18387 ereg
= (Elf64_External_RegInfo
*) (eoption
+ 1);
18388 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
18389 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
18390 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
18391 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
18392 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
18393 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
18395 printf ("GPR %08" PRIx32
" GP 0x%" PRIx64
"\n",
18396 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
18398 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
18399 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
18400 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
18401 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
18403 offset
+= option
.size
;
18406 case ODK_EXCEPTIONS
:
18407 fputs (" EXCEPTIONS fpe_min(", stdout
);
18408 process_mips_fpe_exception (option
.info
& OEX_FPU_MIN
);
18409 fputs (") fpe_max(", stdout
);
18410 process_mips_fpe_exception ((option
.info
& OEX_FPU_MAX
) >> 8);
18411 fputs (")", stdout
);
18413 if (option
.info
& OEX_PAGE0
)
18414 fputs (" PAGE0", stdout
);
18415 if (option
.info
& OEX_SMM
)
18416 fputs (" SMM", stdout
);
18417 if (option
.info
& OEX_FPDBUG
)
18418 fputs (" FPDBUG", stdout
);
18419 if (option
.info
& OEX_DISMISS
)
18420 fputs (" DISMISS", stdout
);
18424 fputs (" PAD ", stdout
);
18425 if (option
.info
& OPAD_PREFIX
)
18426 fputs (" PREFIX", stdout
);
18427 if (option
.info
& OPAD_POSTFIX
)
18428 fputs (" POSTFIX", stdout
);
18429 if (option
.info
& OPAD_SYMBOL
)
18430 fputs (" SYMBOL", stdout
);
18434 fputs (" HWPATCH ", stdout
);
18435 if (option
.info
& OHW_R4KEOP
)
18436 fputs (" R4KEOP", stdout
);
18437 if (option
.info
& OHW_R8KPFETCH
)
18438 fputs (" R8KPFETCH", stdout
);
18439 if (option
.info
& OHW_R5KEOP
)
18440 fputs (" R5KEOP", stdout
);
18441 if (option
.info
& OHW_R5KCVTL
)
18442 fputs (" R5KCVTL", stdout
);
18446 fputs (" FILL ", stdout
);
18447 /* XXX Print content of info word? */
18451 fputs (" TAGS ", stdout
);
18452 /* XXX Print content of info word? */
18456 fputs (" HWAND ", stdout
);
18457 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
18458 fputs (" R4KEOP_CHECKED", stdout
);
18459 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
18460 fputs (" R4KEOP_CLEAN", stdout
);
18464 fputs (" HWOR ", stdout
);
18465 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
18466 fputs (" R4KEOP_CHECKED", stdout
);
18467 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
18468 fputs (" R4KEOP_CLEAN", stdout
);
18472 printf (" GP_GROUP %#06x self-contained %#06x",
18473 option
.info
& OGP_GROUP
,
18474 (option
.info
& OGP_SELF
) >> 16);
18478 printf (" IDENT %#06x self-contained %#06x",
18479 option
.info
& OGP_GROUP
,
18480 (option
.info
& OGP_SELF
) >> 16);
18484 /* This shouldn't happen. */
18485 printf (" %3d ??? %" PRId16
" %" PRIx32
,
18486 option
.kind
, option
.section
, option
.info
);
18490 len
= sizeof (* eopt
);
18491 while (len
< option
.size
)
18493 unsigned char datum
= *((unsigned char *) eoption
+ len
);
18495 if (ISPRINT (datum
))
18496 printf ("%c", datum
);
18498 printf ("\\%03o", datum
);
18501 fputs ("\n", stdout
);
18503 offset
+= option
.size
;
18511 if (conflicts_offset
!= 0 && conflictsno
!= 0)
18513 Elf32_Conflict
* iconf
;
18516 if (filedata
->dynamic_symbols
== NULL
)
18518 error (_("conflict list found without a dynamic symbol table\n"));
18522 /* PR 21345 - print a slightly more helpful error message
18523 if we are sure that the cmalloc will fail. */
18524 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
18526 error (_("Overlarge number of conflicts detected: %lx\n"),
18527 (long) conflictsno
);
18531 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
18534 error (_("Out of memory allocating space for dynamic conflicts\n"));
18540 Elf32_External_Conflict
* econf32
;
18542 econf32
= (Elf32_External_Conflict
*)
18543 get_data (NULL
, filedata
, conflicts_offset
,
18544 sizeof (*econf32
), conflictsno
, _("conflict"));
18551 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18552 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
18558 Elf64_External_Conflict
* econf64
;
18560 econf64
= (Elf64_External_Conflict
*)
18561 get_data (NULL
, filedata
, conflicts_offset
,
18562 sizeof (*econf64
), conflictsno
, _("conflict"));
18569 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18570 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
18575 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
18576 "\nSection '.conflict' contains %lu entries:\n",
18577 (unsigned long) conflictsno
),
18578 (unsigned long) conflictsno
);
18579 puts (_(" Num: Index Value Name"));
18581 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18583 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
18585 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
18586 printf (_("<corrupt symbol index>"));
18589 Elf_Internal_Sym
* psym
;
18591 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
18592 print_vma (psym
->st_value
, FULL_HEX
);
18594 if (valid_dynamic_name (filedata
, psym
->st_name
))
18595 print_symbol (25, get_dynamic_name (filedata
, psym
->st_name
));
18597 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18605 if (pltgot
!= 0 && local_gotno
!= 0)
18607 bfd_vma ent
, local_end
, global_end
;
18609 unsigned char * data
;
18610 unsigned char * data_end
;
18614 addr_size
= (is_32bit_elf
? 4 : 8);
18615 local_end
= pltgot
+ local_gotno
* addr_size
;
18617 /* PR binutils/17533 file: 012-111227-0.004 */
18618 if (symtabno
< gotsym
)
18620 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
18621 (unsigned long) gotsym
, (unsigned long) symtabno
);
18625 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
18626 /* PR 17531: file: 54c91a34. */
18627 if (global_end
< local_end
)
18629 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
18633 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
18634 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
18635 global_end
- pltgot
, 1,
18636 _("Global Offset Table data"));
18637 /* PR 12855: Null data is handled gracefully throughout. */
18638 data_end
= data
+ (global_end
- pltgot
);
18640 printf (_("\nPrimary GOT:\n"));
18641 printf (_(" Canonical gp value: "));
18642 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
18645 printf (_(" Reserved entries:\n"));
18646 printf (_(" %*s %10s %*s Purpose\n"),
18647 addr_size
* 2, _("Address"), _("Access"),
18648 addr_size
* 2, _("Initial"));
18649 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18650 printf (_(" Lazy resolver\n"));
18651 if (ent
== (bfd_vma
) -1)
18652 goto got_print_fail
;
18654 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
18655 This entry will be used by some runtime loaders, to store the
18656 module pointer. Otherwise this is an ordinary local entry.
18657 PR 21344: Check for the entry being fully available before
18660 && data
+ ent
- pltgot
+ addr_size
<= data_end
18661 && (byte_get (data
+ ent
- pltgot
, addr_size
)
18662 >> (addr_size
* 8 - 1)) != 0)
18664 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18665 printf (_(" Module pointer (GNU extension)\n"));
18666 if (ent
== (bfd_vma
) -1)
18667 goto got_print_fail
;
18671 if (data
!= NULL
&& ent
< local_end
)
18673 printf (_(" Local entries:\n"));
18674 printf (" %*s %10s %*s\n",
18675 addr_size
* 2, _("Address"), _("Access"),
18676 addr_size
* 2, _("Initial"));
18677 while (ent
< local_end
)
18679 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18681 if (ent
== (bfd_vma
) -1)
18682 goto got_print_fail
;
18687 if (data
!= NULL
&& gotsym
< symtabno
)
18691 printf (_(" Global entries:\n"));
18692 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
18693 addr_size
* 2, _("Address"),
18695 addr_size
* 2, _("Initial"),
18696 addr_size
* 2, _("Sym.Val."),
18698 /* Note for translators: "Ndx" = abbreviated form of "Index". */
18699 _("Ndx"), _("Name"));
18701 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
18703 for (i
= gotsym
; i
< symtabno
; i
++)
18705 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18708 if (filedata
->dynamic_symbols
== NULL
)
18709 printf (_("<no dynamic symbols>"));
18710 else if (i
< filedata
->num_dynamic_syms
)
18712 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
18714 print_vma (psym
->st_value
, LONG_HEX
);
18715 printf (" %-7s %3s ",
18716 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
18717 get_symbol_index_type (filedata
, psym
->st_shndx
));
18719 if (valid_dynamic_name (filedata
, psym
->st_name
))
18720 print_symbol (sym_width
,
18721 get_dynamic_name (filedata
, psym
->st_name
));
18723 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18726 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
18727 (unsigned long) i
);
18730 if (ent
== (bfd_vma
) -1)
18740 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
18743 size_t offset
, rel_offset
;
18744 unsigned long count
, i
;
18745 unsigned char * data
;
18746 int addr_size
, sym_width
;
18747 Elf_Internal_Rela
* rels
;
18749 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
18750 if (pltrel
== DT_RELA
)
18752 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
18757 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
18762 addr_size
= (is_32bit_elf
? 4 : 8);
18763 end
= mips_pltgot
+ (2 + count
) * addr_size
;
18765 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
18766 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
18767 1, _("Procedure Linkage Table data"));
18774 printf ("\nPLT GOT:\n\n");
18775 printf (_(" Reserved entries:\n"));
18776 printf (_(" %*s %*s Purpose\n"),
18777 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
18778 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18779 printf (_(" PLT lazy resolver\n"));
18780 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18781 printf (_(" Module pointer\n"));
18784 printf (_(" Entries:\n"));
18785 printf (" %*s %*s %*s %-7s %3s %s\n",
18786 addr_size
* 2, _("Address"),
18787 addr_size
* 2, _("Initial"),
18788 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
18789 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
18790 for (i
= 0; i
< count
; i
++)
18792 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
18794 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18797 if (idx
>= filedata
->num_dynamic_syms
)
18798 printf (_("<corrupt symbol index: %lu>"), idx
);
18801 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
18803 print_vma (psym
->st_value
, LONG_HEX
);
18804 printf (" %-7s %3s ",
18805 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
18806 get_symbol_index_type (filedata
, psym
->st_shndx
));
18807 if (valid_dynamic_name (filedata
, psym
->st_name
))
18808 print_symbol (sym_width
,
18809 get_dynamic_name (filedata
, psym
->st_name
));
18811 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18825 process_nds32_specific (Filedata
* filedata
)
18827 Elf_Internal_Shdr
*sect
= NULL
;
18829 sect
= find_section (filedata
, ".nds32_e_flags");
18830 if (sect
!= NULL
&& sect
->sh_size
>= 4)
18832 unsigned char *buf
;
18835 printf ("\nNDS32 elf flags section:\n");
18836 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
18837 _("NDS32 elf flags section"));
18842 flag
= byte_get (buf
, 4);
18844 switch (flag
& 0x3)
18847 printf ("(VEC_SIZE):\tNo entry.\n");
18850 printf ("(VEC_SIZE):\t4 bytes\n");
18853 printf ("(VEC_SIZE):\t16 bytes\n");
18856 printf ("(VEC_SIZE):\treserved\n");
18865 process_gnu_liblist (Filedata
* filedata
)
18867 Elf_Internal_Shdr
* section
;
18868 Elf_Internal_Shdr
* string_sec
;
18869 Elf32_External_Lib
* elib
;
18871 size_t strtab_size
;
18873 unsigned long num_liblist
;
18880 for (i
= 0, section
= filedata
->section_headers
;
18881 i
< filedata
->file_header
.e_shnum
;
18884 switch (section
->sh_type
)
18886 case SHT_GNU_LIBLIST
:
18887 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
18890 elib
= (Elf32_External_Lib
*)
18891 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
18892 _("liblist section data"));
18900 string_sec
= filedata
->section_headers
+ section
->sh_link
;
18901 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
18902 string_sec
->sh_size
,
18903 _("liblist string table"));
18905 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
18912 strtab_size
= string_sec
->sh_size
;
18914 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
18915 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
18916 "\nLibrary list section '%s' contains %lu entries:\n",
18918 printable_section_name (filedata
, section
),
18921 puts (_(" Library Time Stamp Checksum Version Flags"));
18923 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
18931 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
18932 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
18933 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
18934 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
18935 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
18937 tmp
= gmtime (&atime
);
18938 snprintf (timebuf
, sizeof (timebuf
),
18939 "%04u-%02u-%02uT%02u:%02u:%02u",
18940 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
18941 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
18943 printf ("%3lu: ", (unsigned long) cnt
);
18945 printf ("%-20s", liblist
.l_name
< strtab_size
18946 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
18948 printf ("%-20.20s", liblist
.l_name
< strtab_size
18949 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
18950 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
18951 liblist
.l_version
, liblist
.l_flags
);
18962 static const char *
18963 get_note_type (Filedata
* filedata
, unsigned e_type
)
18965 static char buff
[64];
18967 if (filedata
->file_header
.e_type
== ET_CORE
)
18971 return _("NT_AUXV (auxiliary vector)");
18973 return _("NT_PRSTATUS (prstatus structure)");
18975 return _("NT_FPREGSET (floating point registers)");
18977 return _("NT_PRPSINFO (prpsinfo structure)");
18978 case NT_TASKSTRUCT
:
18979 return _("NT_TASKSTRUCT (task structure)");
18981 return _("NT_GDB_TDESC (GDB XML target description)");
18983 return _("NT_PRXFPREG (user_xfpregs structure)");
18985 return _("NT_PPC_VMX (ppc Altivec registers)");
18987 return _("NT_PPC_VSX (ppc VSX registers)");
18989 return _("NT_PPC_TAR (ppc TAR register)");
18991 return _("NT_PPC_PPR (ppc PPR register)");
18993 return _("NT_PPC_DSCR (ppc DSCR register)");
18995 return _("NT_PPC_EBB (ppc EBB registers)");
18997 return _("NT_PPC_PMU (ppc PMU registers)");
18998 case NT_PPC_TM_CGPR
:
18999 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
19000 case NT_PPC_TM_CFPR
:
19001 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
19002 case NT_PPC_TM_CVMX
:
19003 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
19004 case NT_PPC_TM_CVSX
:
19005 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
19006 case NT_PPC_TM_SPR
:
19007 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
19008 case NT_PPC_TM_CTAR
:
19009 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
19010 case NT_PPC_TM_CPPR
:
19011 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
19012 case NT_PPC_TM_CDSCR
:
19013 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
19015 return _("NT_386_TLS (x86 TLS information)");
19016 case NT_386_IOPERM
:
19017 return _("NT_386_IOPERM (x86 I/O permissions)");
19018 case NT_X86_XSTATE
:
19019 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
19021 return _("NT_X86_CET (x86 CET state)");
19022 case NT_S390_HIGH_GPRS
:
19023 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
19024 case NT_S390_TIMER
:
19025 return _("NT_S390_TIMER (s390 timer register)");
19026 case NT_S390_TODCMP
:
19027 return _("NT_S390_TODCMP (s390 TOD comparator register)");
19028 case NT_S390_TODPREG
:
19029 return _("NT_S390_TODPREG (s390 TOD programmable register)");
19031 return _("NT_S390_CTRS (s390 control registers)");
19032 case NT_S390_PREFIX
:
19033 return _("NT_S390_PREFIX (s390 prefix register)");
19034 case NT_S390_LAST_BREAK
:
19035 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
19036 case NT_S390_SYSTEM_CALL
:
19037 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
19039 return _("NT_S390_TDB (s390 transaction diagnostic block)");
19040 case NT_S390_VXRS_LOW
:
19041 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
19042 case NT_S390_VXRS_HIGH
:
19043 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
19044 case NT_S390_GS_CB
:
19045 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
19046 case NT_S390_GS_BC
:
19047 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
19049 return _("NT_ARM_VFP (arm VFP registers)");
19051 return _("NT_ARM_TLS (AArch TLS registers)");
19052 case NT_ARM_HW_BREAK
:
19053 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
19054 case NT_ARM_HW_WATCH
:
19055 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
19057 return _("NT_ARM_SVE (AArch SVE registers)");
19058 case NT_ARM_PAC_MASK
:
19059 return _("NT_ARM_PAC_MASK (AArch pointer authentication code masks)");
19060 case NT_ARM_PACA_KEYS
:
19061 return _("NT_ARM_PACA_KEYS (ARM pointer authentication address keys)");
19062 case NT_ARM_PACG_KEYS
:
19063 return _("NT_ARM_PACG_KEYS (ARM pointer authentication generic keys)");
19064 case NT_ARM_TAGGED_ADDR_CTRL
:
19065 return _("NT_ARM_TAGGED_ADDR_CTRL (AArch tagged address control)");
19066 case NT_ARM_PAC_ENABLED_KEYS
:
19067 return _("NT_ARM_PAC_ENABLED_KEYS (AArch64 pointer authentication enabled keys)");
19069 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
19071 return _("NT_RISCV_CSR (RISC-V control and status registers)");
19073 return _("NT_PSTATUS (pstatus structure)");
19075 return _("NT_FPREGS (floating point registers)");
19077 return _("NT_PSINFO (psinfo structure)");
19079 return _("NT_LWPSTATUS (lwpstatus_t structure)");
19081 return _("NT_LWPSINFO (lwpsinfo_t structure)");
19082 case NT_WIN32PSTATUS
:
19083 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
19085 return _("NT_SIGINFO (siginfo_t data)");
19087 return _("NT_FILE (mapped files)");
19095 return _("NT_VERSION (version)");
19097 return _("NT_ARCH (architecture)");
19098 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
19100 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
19102 case NT_GO_BUILDID
:
19103 return _("GO BUILDID");
19108 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19113 print_core_note (Elf_Internal_Note
*pnote
)
19115 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
19116 bfd_vma count
, page_size
;
19117 unsigned char *descdata
, *filenames
, *descend
;
19119 if (pnote
->type
!= NT_FILE
)
19129 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
19130 /* Still "successful". */
19135 if (pnote
->descsz
< 2 * addr_size
)
19137 error (_(" Malformed note - too short for header\n"));
19141 descdata
= (unsigned char *) pnote
->descdata
;
19142 descend
= descdata
+ pnote
->descsz
;
19144 if (descdata
[pnote
->descsz
- 1] != '\0')
19146 error (_(" Malformed note - does not end with \\0\n"));
19150 count
= byte_get (descdata
, addr_size
);
19151 descdata
+= addr_size
;
19153 page_size
= byte_get (descdata
, addr_size
);
19154 descdata
+= addr_size
;
19156 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
19157 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
19159 error (_(" Malformed note - too short for supplied file count\n"));
19163 printf (_(" Page size: "));
19164 print_vma (page_size
, DEC
);
19167 printf (_(" %*s%*s%*s\n"),
19168 (int) (2 + 2 * addr_size
), _("Start"),
19169 (int) (4 + 2 * addr_size
), _("End"),
19170 (int) (4 + 2 * addr_size
), _("Page Offset"));
19171 filenames
= descdata
+ count
* 3 * addr_size
;
19172 while (count
-- > 0)
19174 bfd_vma start
, end
, file_ofs
;
19176 if (filenames
== descend
)
19178 error (_(" Malformed note - filenames end too early\n"));
19182 start
= byte_get (descdata
, addr_size
);
19183 descdata
+= addr_size
;
19184 end
= byte_get (descdata
, addr_size
);
19185 descdata
+= addr_size
;
19186 file_ofs
= byte_get (descdata
, addr_size
);
19187 descdata
+= addr_size
;
19190 print_vma (start
, FULL_HEX
);
19192 print_vma (end
, FULL_HEX
);
19194 print_vma (file_ofs
, FULL_HEX
);
19195 printf ("\n %s\n", filenames
);
19197 filenames
+= 1 + strlen ((char *) filenames
);
19203 static const char *
19204 get_gnu_elf_note_type (unsigned e_type
)
19206 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
19209 case NT_GNU_ABI_TAG
:
19210 return _("NT_GNU_ABI_TAG (ABI version tag)");
19212 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
19213 case NT_GNU_BUILD_ID
:
19214 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
19215 case NT_GNU_GOLD_VERSION
:
19216 return _("NT_GNU_GOLD_VERSION (gold version)");
19217 case NT_GNU_PROPERTY_TYPE_0
:
19218 return _("NT_GNU_PROPERTY_TYPE_0");
19219 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
19220 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
19221 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
19222 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
19225 static char buff
[64];
19227 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19234 decode_x86_compat_isa (unsigned int bitmask
)
19238 unsigned int bit
= bitmask
& (- bitmask
);
19243 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
19246 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
19249 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
19252 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
19255 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
19258 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
19261 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
19264 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
19267 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
19270 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
19273 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
19276 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
19277 printf ("AVX512F");
19279 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
19280 printf ("AVX512CD");
19282 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
19283 printf ("AVX512ER");
19285 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
19286 printf ("AVX512PF");
19288 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
19289 printf ("AVX512VL");
19291 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
19292 printf ("AVX512DQ");
19294 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
19295 printf ("AVX512BW");
19298 printf (_("<unknown: %x>"), bit
);
19307 decode_x86_compat_2_isa (unsigned int bitmask
)
19311 printf (_("<None>"));
19317 unsigned int bit
= bitmask
& (- bitmask
);
19322 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_CMOV
:
19325 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE
:
19328 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE2
:
19331 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE3
:
19334 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSSE3
:
19337 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_1
:
19340 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_2
:
19343 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX
:
19346 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX2
:
19349 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_FMA
:
19352 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512F
:
19353 printf ("AVX512F");
19355 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512CD
:
19356 printf ("AVX512CD");
19358 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512ER
:
19359 printf ("AVX512ER");
19361 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512PF
:
19362 printf ("AVX512PF");
19364 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512VL
:
19365 printf ("AVX512VL");
19367 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512DQ
:
19368 printf ("AVX512DQ");
19370 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512BW
:
19371 printf ("AVX512BW");
19373 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4FMAPS
:
19374 printf ("AVX512_4FMAPS");
19376 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4VNNIW
:
19377 printf ("AVX512_4VNNIW");
19379 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BITALG
:
19380 printf ("AVX512_BITALG");
19382 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_IFMA
:
19383 printf ("AVX512_IFMA");
19385 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI
:
19386 printf ("AVX512_VBMI");
19388 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI2
:
19389 printf ("AVX512_VBMI2");
19391 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VNNI
:
19392 printf ("AVX512_VNNI");
19394 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BF16
:
19395 printf ("AVX512_BF16");
19398 printf (_("<unknown: %x>"), bit
);
19407 decode_x86_isa (unsigned int bitmask
)
19411 unsigned int bit
= bitmask
& (- bitmask
);
19416 case GNU_PROPERTY_X86_ISA_1_BASELINE
:
19417 printf ("x86-64-baseline");
19419 case GNU_PROPERTY_X86_ISA_1_V2
:
19420 printf ("x86-64-v2");
19422 case GNU_PROPERTY_X86_ISA_1_V3
:
19423 printf ("x86-64-v3");
19425 case GNU_PROPERTY_X86_ISA_1_V4
:
19426 printf ("x86-64-v4");
19429 printf (_("<unknown: %x>"), bit
);
19438 decode_x86_feature_1 (unsigned int bitmask
)
19442 printf (_("<None>"));
19448 unsigned int bit
= bitmask
& (- bitmask
);
19453 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
19456 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
19459 case GNU_PROPERTY_X86_FEATURE_1_LAM_U48
:
19460 printf ("LAM_U48");
19462 case GNU_PROPERTY_X86_FEATURE_1_LAM_U57
:
19463 printf ("LAM_U57");
19466 printf (_("<unknown: %x>"), bit
);
19475 decode_x86_feature_2 (unsigned int bitmask
)
19479 printf (_("<None>"));
19485 unsigned int bit
= bitmask
& (- bitmask
);
19490 case GNU_PROPERTY_X86_FEATURE_2_X86
:
19493 case GNU_PROPERTY_X86_FEATURE_2_X87
:
19496 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
19499 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
19502 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
19505 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
19508 case GNU_PROPERTY_X86_FEATURE_2_TMM
:
19511 case GNU_PROPERTY_X86_FEATURE_2_MASK
:
19514 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
19517 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
19520 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
19521 printf ("XSAVEOPT");
19523 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
19527 printf (_("<unknown: %x>"), bit
);
19536 decode_aarch64_feature_1_and (unsigned int bitmask
)
19540 unsigned int bit
= bitmask
& (- bitmask
);
19545 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
19549 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
19554 printf (_("<unknown: %x>"), bit
);
19563 decode_1_needed (unsigned int bitmask
)
19567 unsigned int bit
= bitmask
& (- bitmask
);
19572 case GNU_PROPERTY_1_NEEDED_INDIRECT_EXTERN_ACCESS
:
19573 printf ("indirect external access");
19576 printf (_("<unknown: %x>"), bit
);
19585 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
19587 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
19588 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
19589 unsigned int size
= is_32bit_elf
? 4 : 8;
19591 printf (_(" Properties: "));
19593 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
19595 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
19599 while (ptr
< ptr_end
)
19603 unsigned int datasz
;
19605 if ((size_t) (ptr_end
- ptr
) < 8)
19607 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
19611 type
= byte_get (ptr
, 4);
19612 datasz
= byte_get (ptr
+ 4, 4);
19616 if (datasz
> (size_t) (ptr_end
- ptr
))
19618 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
19623 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
19625 if (filedata
->file_header
.e_machine
== EM_X86_64
19626 || filedata
->file_header
.e_machine
== EM_IAMCU
19627 || filedata
->file_header
.e_machine
== EM_386
)
19629 unsigned int bitmask
;
19632 bitmask
= byte_get (ptr
, 4);
19638 case GNU_PROPERTY_X86_ISA_1_USED
:
19640 printf (_("x86 ISA used: <corrupt length: %#x> "),
19644 printf ("x86 ISA used: ");
19645 decode_x86_isa (bitmask
);
19649 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
19651 printf (_("x86 ISA needed: <corrupt length: %#x> "),
19655 printf ("x86 ISA needed: ");
19656 decode_x86_isa (bitmask
);
19660 case GNU_PROPERTY_X86_FEATURE_1_AND
:
19662 printf (_("x86 feature: <corrupt length: %#x> "),
19666 printf ("x86 feature: ");
19667 decode_x86_feature_1 (bitmask
);
19671 case GNU_PROPERTY_X86_FEATURE_2_USED
:
19673 printf (_("x86 feature used: <corrupt length: %#x> "),
19677 printf ("x86 feature used: ");
19678 decode_x86_feature_2 (bitmask
);
19682 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
19684 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
19687 printf ("x86 feature needed: ");
19688 decode_x86_feature_2 (bitmask
);
19692 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
19694 printf (_("x86 ISA used: <corrupt length: %#x> "),
19698 printf ("x86 ISA used: ");
19699 decode_x86_compat_isa (bitmask
);
19703 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
19705 printf (_("x86 ISA needed: <corrupt length: %#x> "),
19709 printf ("x86 ISA needed: ");
19710 decode_x86_compat_isa (bitmask
);
19714 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_USED
:
19716 printf (_("x86 ISA used: <corrupt length: %#x> "),
19720 printf ("x86 ISA used: ");
19721 decode_x86_compat_2_isa (bitmask
);
19725 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_NEEDED
:
19727 printf (_("x86 ISA needed: <corrupt length: %#x> "),
19731 printf ("x86 ISA needed: ");
19732 decode_x86_compat_2_isa (bitmask
);
19740 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
19742 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
19744 printf ("AArch64 feature: ");
19746 printf (_("<corrupt length: %#x> "), datasz
);
19748 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
19757 case GNU_PROPERTY_STACK_SIZE
:
19758 printf (_("stack size: "));
19759 if (datasz
!= size
)
19760 printf (_("<corrupt length: %#x> "), datasz
);
19762 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
19765 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
19766 printf ("no copy on protected ");
19768 printf (_("<corrupt length: %#x> "), datasz
);
19772 if ((type
>= GNU_PROPERTY_UINT32_AND_LO
19773 && type
<= GNU_PROPERTY_UINT32_AND_HI
)
19774 || (type
>= GNU_PROPERTY_UINT32_OR_LO
19775 && type
<= GNU_PROPERTY_UINT32_OR_HI
))
19779 case GNU_PROPERTY_1_NEEDED
:
19781 printf (_("1_needed: <corrupt length: %#x> "),
19785 unsigned int bitmask
= byte_get (ptr
, 4);
19786 printf ("1_needed: ");
19787 decode_1_needed (bitmask
);
19794 if (type
<= GNU_PROPERTY_UINT32_AND_HI
)
19795 printf (_("UINT32_AND (%#x): "), type
);
19797 printf (_("UINT32_OR (%#x): "), type
);
19799 printf (_("<corrupt length: %#x> "), datasz
);
19801 printf ("%#x", (unsigned int) byte_get (ptr
, 4));
19808 if (type
< GNU_PROPERTY_LOPROC
)
19809 printf (_("<unknown type %#x data: "), type
);
19810 else if (type
< GNU_PROPERTY_LOUSER
)
19811 printf (_("<processor-specific type %#x data: "), type
);
19813 printf (_("<application-specific type %#x data: "), type
);
19814 for (j
= 0; j
< datasz
; ++j
)
19815 printf ("%02x ", ptr
[j
] & 0xff);
19819 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
19820 if (ptr
== ptr_end
)
19833 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
19835 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
19836 switch (pnote
->type
)
19838 case NT_GNU_BUILD_ID
:
19842 printf (_(" Build ID: "));
19843 for (i
= 0; i
< pnote
->descsz
; ++i
)
19844 printf ("%02x", pnote
->descdata
[i
] & 0xff);
19849 case NT_GNU_ABI_TAG
:
19851 unsigned long os
, major
, minor
, subminor
;
19852 const char *osname
;
19854 /* PR 17531: file: 030-599401-0.004. */
19855 if (pnote
->descsz
< 16)
19857 printf (_(" <corrupt GNU_ABI_TAG>\n"));
19861 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19862 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19863 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
19864 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
19868 case GNU_ABI_TAG_LINUX
:
19871 case GNU_ABI_TAG_HURD
:
19874 case GNU_ABI_TAG_SOLARIS
:
19875 osname
= "Solaris";
19877 case GNU_ABI_TAG_FREEBSD
:
19878 osname
= "FreeBSD";
19880 case GNU_ABI_TAG_NETBSD
:
19883 case GNU_ABI_TAG_SYLLABLE
:
19884 osname
= "Syllable";
19886 case GNU_ABI_TAG_NACL
:
19890 osname
= "Unknown";
19894 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
19895 major
, minor
, subminor
);
19899 case NT_GNU_GOLD_VERSION
:
19903 printf (_(" Version: "));
19904 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
19905 printf ("%c", pnote
->descdata
[i
]);
19912 unsigned long num_entries
, mask
;
19914 /* Hardware capabilities information. Word 0 is the number of entries.
19915 Word 1 is a bitmask of enabled entries. The rest of the descriptor
19916 is a series of entries, where each entry is a single byte followed
19917 by a nul terminated string. The byte gives the bit number to test
19918 if enabled in the bitmask. */
19919 printf (_(" Hardware Capabilities: "));
19920 if (pnote
->descsz
< 8)
19922 error (_("<corrupt GNU_HWCAP>\n"));
19925 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19926 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19927 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
19928 /* FIXME: Add code to display the entries... */
19932 case NT_GNU_PROPERTY_TYPE_0
:
19933 print_gnu_property_note (filedata
, pnote
);
19937 /* Handle unrecognised types. An error message should have already been
19938 created by get_gnu_elf_note_type(), so all that we need to do is to
19939 display the data. */
19943 printf (_(" Description data: "));
19944 for (i
= 0; i
< pnote
->descsz
; ++i
)
19945 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19954 static const char *
19955 get_v850_elf_note_type (enum v850_notes n_type
)
19957 static char buff
[64];
19961 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
19962 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
19963 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
19964 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
19965 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
19966 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
19968 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
19974 print_v850_note (Elf_Internal_Note
* pnote
)
19978 if (pnote
->descsz
!= 4)
19981 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
19985 printf (_("not set\n"));
19989 switch (pnote
->type
)
19991 case V850_NOTE_ALIGNMENT
:
19994 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return true;
19995 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return true;
19999 case V850_NOTE_DATA_SIZE
:
20002 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return true;
20003 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return true;
20007 case V850_NOTE_FPU_INFO
:
20010 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return true;
20011 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return true;
20015 case V850_NOTE_MMU_INFO
:
20016 case V850_NOTE_CACHE_INFO
:
20017 case V850_NOTE_SIMD_INFO
:
20018 if (val
== EF_RH850_SIMD
)
20020 printf (_("yes\n"));
20026 /* An 'unknown note type' message will already have been displayed. */
20030 printf (_("unknown value: %x\n"), val
);
20035 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
20037 unsigned int version
;
20039 switch (pnote
->type
)
20041 case NT_NETBSD_IDENT
:
20042 if (pnote
->descsz
< 1)
20044 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
20045 if ((version
/ 10000) % 100)
20046 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
20047 version
, version
/ 100000000, (version
/ 1000000) % 100,
20048 (version
/ 10000) % 100 > 26 ? "Z" : "",
20049 'A' + (version
/ 10000) % 26);
20051 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
20052 version
, version
/ 100000000, (version
/ 1000000) % 100,
20053 (version
/ 100) % 100);
20056 case NT_NETBSD_MARCH
:
20057 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
20061 case NT_NETBSD_PAX
:
20062 if (pnote
->descsz
< 1)
20064 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
20065 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
20066 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
20067 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
20068 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
20069 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
20070 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
20071 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
20075 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
20076 pnote
->descsz
, pnote
->type
);
20080 static const char *
20081 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
20085 case NT_FREEBSD_THRMISC
:
20086 return _("NT_THRMISC (thrmisc structure)");
20087 case NT_FREEBSD_PROCSTAT_PROC
:
20088 return _("NT_PROCSTAT_PROC (proc data)");
20089 case NT_FREEBSD_PROCSTAT_FILES
:
20090 return _("NT_PROCSTAT_FILES (files data)");
20091 case NT_FREEBSD_PROCSTAT_VMMAP
:
20092 return _("NT_PROCSTAT_VMMAP (vmmap data)");
20093 case NT_FREEBSD_PROCSTAT_GROUPS
:
20094 return _("NT_PROCSTAT_GROUPS (groups data)");
20095 case NT_FREEBSD_PROCSTAT_UMASK
:
20096 return _("NT_PROCSTAT_UMASK (umask data)");
20097 case NT_FREEBSD_PROCSTAT_RLIMIT
:
20098 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
20099 case NT_FREEBSD_PROCSTAT_OSREL
:
20100 return _("NT_PROCSTAT_OSREL (osreldate data)");
20101 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
20102 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
20103 case NT_FREEBSD_PROCSTAT_AUXV
:
20104 return _("NT_PROCSTAT_AUXV (auxv data)");
20105 case NT_FREEBSD_PTLWPINFO
:
20106 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
20108 return get_note_type (filedata
, e_type
);
20111 static const char *
20112 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
20114 static char buff
[64];
20118 case NT_NETBSDCORE_PROCINFO
:
20119 /* NetBSD core "procinfo" structure. */
20120 return _("NetBSD procinfo structure");
20122 case NT_NETBSDCORE_AUXV
:
20123 return _("NetBSD ELF auxiliary vector data");
20125 case NT_NETBSDCORE_LWPSTATUS
:
20126 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
20129 /* As of Jan 2020 there are no other machine-independent notes
20130 defined for NetBSD core files. If the note type is less
20131 than the start of the machine-dependent note types, we don't
20134 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
20136 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
20142 switch (filedata
->file_header
.e_machine
)
20144 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
20145 and PT_GETFPREGS == mach+2. */
20150 case EM_SPARC32PLUS
:
20154 case NT_NETBSDCORE_FIRSTMACH
+ 0:
20155 return _("PT_GETREGS (reg structure)");
20156 case NT_NETBSDCORE_FIRSTMACH
+ 2:
20157 return _("PT_GETFPREGS (fpreg structure)");
20163 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
20164 There's also old PT___GETREGS40 == mach + 1 for old reg
20165 structure which lacks GBR. */
20169 case NT_NETBSDCORE_FIRSTMACH
+ 1:
20170 return _("PT___GETREGS40 (old reg structure)");
20171 case NT_NETBSDCORE_FIRSTMACH
+ 3:
20172 return _("PT_GETREGS (reg structure)");
20173 case NT_NETBSDCORE_FIRSTMACH
+ 5:
20174 return _("PT_GETFPREGS (fpreg structure)");
20180 /* On all other arch's, PT_GETREGS == mach+1 and
20181 PT_GETFPREGS == mach+3. */
20185 case NT_NETBSDCORE_FIRSTMACH
+ 1:
20186 return _("PT_GETREGS (reg structure)");
20187 case NT_NETBSDCORE_FIRSTMACH
+ 3:
20188 return _("PT_GETFPREGS (fpreg structure)");
20194 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
20195 e_type
- NT_NETBSDCORE_FIRSTMACH
);
20199 static const char *
20200 get_openbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
20204 case NT_OPENBSD_PROCINFO
:
20205 return _("OpenBSD procinfo structure");
20206 case NT_OPENBSD_AUXV
:
20207 return _("OpenBSD ELF auxiliary vector data");
20208 case NT_OPENBSD_REGS
:
20209 return _("OpenBSD regular registers");
20210 case NT_OPENBSD_FPREGS
:
20211 return _("OpenBSD floating point registers");
20212 case NT_OPENBSD_WCOOKIE
:
20213 return _("OpenBSD window cookie");
20216 return get_note_type (filedata
, e_type
);
20219 static const char *
20220 get_stapsdt_note_type (unsigned e_type
)
20222 static char buff
[64];
20227 return _("NT_STAPSDT (SystemTap probe descriptors)");
20233 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
20238 print_stapsdt_note (Elf_Internal_Note
*pnote
)
20240 size_t len
, maxlen
;
20241 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
20242 char *data
= pnote
->descdata
;
20243 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
20244 bfd_vma pc
, base_addr
, semaphore
;
20245 char *provider
, *probe
, *arg_fmt
;
20247 if (pnote
->descsz
< (addr_size
* 3))
20248 goto stapdt_note_too_small
;
20250 pc
= byte_get ((unsigned char *) data
, addr_size
);
20253 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
20256 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
20259 if (data
>= data_end
)
20260 goto stapdt_note_too_small
;
20261 maxlen
= data_end
- data
;
20262 len
= strnlen (data
, maxlen
);
20269 goto stapdt_note_too_small
;
20271 if (data
>= data_end
)
20272 goto stapdt_note_too_small
;
20273 maxlen
= data_end
- data
;
20274 len
= strnlen (data
, maxlen
);
20281 goto stapdt_note_too_small
;
20283 if (data
>= data_end
)
20284 goto stapdt_note_too_small
;
20285 maxlen
= data_end
- data
;
20286 len
= strnlen (data
, maxlen
);
20293 goto stapdt_note_too_small
;
20295 printf (_(" Provider: %s\n"), provider
);
20296 printf (_(" Name: %s\n"), probe
);
20297 printf (_(" Location: "));
20298 print_vma (pc
, FULL_HEX
);
20299 printf (_(", Base: "));
20300 print_vma (base_addr
, FULL_HEX
);
20301 printf (_(", Semaphore: "));
20302 print_vma (semaphore
, FULL_HEX
);
20304 printf (_(" Arguments: %s\n"), arg_fmt
);
20306 return data
== data_end
;
20308 stapdt_note_too_small
:
20309 printf (_(" <corrupt - note is too small>\n"));
20310 error (_("corrupt stapdt note - the data size is too small\n"));
20314 static const char *
20315 get_ia64_vms_note_type (unsigned e_type
)
20317 static char buff
[64];
20322 return _("NT_VMS_MHD (module header)");
20324 return _("NT_VMS_LNM (language name)");
20326 return _("NT_VMS_SRC (source files)");
20328 return "NT_VMS_TITLE";
20330 return _("NT_VMS_EIDC (consistency check)");
20331 case NT_VMS_FPMODE
:
20332 return _("NT_VMS_FPMODE (FP mode)");
20333 case NT_VMS_LINKTIME
:
20334 return "NT_VMS_LINKTIME";
20335 case NT_VMS_IMGNAM
:
20336 return _("NT_VMS_IMGNAM (image name)");
20338 return _("NT_VMS_IMGID (image id)");
20339 case NT_VMS_LINKID
:
20340 return _("NT_VMS_LINKID (link id)");
20341 case NT_VMS_IMGBID
:
20342 return _("NT_VMS_IMGBID (build id)");
20343 case NT_VMS_GSTNAM
:
20344 return _("NT_VMS_GSTNAM (sym table name)");
20345 case NT_VMS_ORIG_DYN
:
20346 return "NT_VMS_ORIG_DYN";
20347 case NT_VMS_PATCHTIME
:
20348 return "NT_VMS_PATCHTIME";
20350 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
20356 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
20358 int maxlen
= pnote
->descsz
;
20360 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
20361 goto desc_size_fail
;
20363 switch (pnote
->type
)
20367 goto desc_size_fail
;
20369 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
20371 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
20372 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
20373 if (l
+ 34 < maxlen
)
20375 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
20376 if (l
+ 35 < maxlen
)
20377 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
20379 printf (_(" Module version : <missing>\n"));
20383 printf (_(" Module name : <missing>\n"));
20384 printf (_(" Module version : <missing>\n"));
20389 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
20393 case NT_VMS_FPMODE
:
20394 printf (_(" Floating Point mode: "));
20396 goto desc_size_fail
;
20397 /* FIXME: Generate an error if descsz > 8 ? */
20399 printf ("0x%016" BFD_VMA_FMT
"x\n",
20400 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
20403 case NT_VMS_LINKTIME
:
20404 printf (_(" Link time: "));
20406 goto desc_size_fail
;
20407 /* FIXME: Generate an error if descsz > 8 ? */
20410 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
20414 case NT_VMS_PATCHTIME
:
20415 printf (_(" Patch time: "));
20417 goto desc_size_fail
;
20418 /* FIXME: Generate an error if descsz > 8 ? */
20421 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
20425 case NT_VMS_ORIG_DYN
:
20427 goto desc_size_fail
;
20429 printf (_(" Major id: %u, minor id: %u\n"),
20430 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
20431 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
20432 printf (_(" Last modified : "));
20434 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
20435 printf (_("\n Link flags : "));
20436 printf ("0x%016" BFD_VMA_FMT
"x\n",
20437 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
20438 printf (_(" Header flags: 0x%08x\n"),
20439 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
20440 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
20444 case NT_VMS_IMGNAM
:
20445 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
20448 case NT_VMS_GSTNAM
:
20449 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
20453 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
20456 case NT_VMS_LINKID
:
20457 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
20467 printf (_(" <corrupt - data size is too small>\n"));
20468 error (_("corrupt IA64 note: data size is too small\n"));
20472 struct build_attr_cache
{
20473 Filedata
*filedata
;
20475 unsigned long strtablen
;
20476 Elf_Internal_Sym
*symtab
;
20477 unsigned long nsyms
;
20480 /* Find the symbol associated with a build attribute that is attached
20481 to address OFFSET. If PNAME is non-NULL then store the name of
20482 the symbol (if found) in the provided pointer, Returns NULL if a
20483 symbol could not be found. */
20485 static Elf_Internal_Sym
*
20486 get_symbol_for_build_attribute (Filedata
*filedata
,
20487 unsigned long offset
,
20489 const char **pname
)
20491 Elf_Internal_Sym
*saved_sym
= NULL
;
20492 Elf_Internal_Sym
*sym
;
20494 if (filedata
->section_headers
!= NULL
20495 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
20497 Elf_Internal_Shdr
* symsec
;
20499 free (ba_cache
.strtab
);
20500 ba_cache
.strtab
= NULL
;
20501 free (ba_cache
.symtab
);
20502 ba_cache
.symtab
= NULL
;
20504 /* Load the symbol and string sections. */
20505 for (symsec
= filedata
->section_headers
;
20506 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
20509 if (symsec
->sh_type
== SHT_SYMTAB
20510 && get_symtab (filedata
, symsec
,
20511 &ba_cache
.symtab
, &ba_cache
.nsyms
,
20512 &ba_cache
.strtab
, &ba_cache
.strtablen
))
20515 ba_cache
.filedata
= filedata
;
20518 if (ba_cache
.symtab
== NULL
)
20521 /* Find a symbol whose value matches offset. */
20522 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
20523 if (sym
->st_value
== offset
)
20525 if (sym
->st_name
>= ba_cache
.strtablen
)
20526 /* Huh ? This should not happen. */
20529 if (ba_cache
.strtab
[sym
->st_name
] == 0)
20532 /* The AArch64, ARM and RISC-V architectures define mapping symbols
20533 (eg $d, $x, $t) which we want to ignore. */
20534 if (ba_cache
.strtab
[sym
->st_name
] == '$'
20535 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
20536 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
20541 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
20542 and FILE or OBJECT symbols over NOTYPE symbols. We skip
20543 FUNC symbols entirely. */
20544 switch (ELF_ST_TYPE (sym
->st_info
))
20551 /* If the symbol has a size associated
20552 with it then we can stop searching. */
20553 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
20558 /* Ignore function symbols. */
20565 switch (ELF_ST_BIND (sym
->st_info
))
20568 if (saved_sym
== NULL
20569 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
20574 if (saved_sym
== NULL
)
20584 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
20592 if (saved_sym
&& pname
)
20593 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
20598 /* Returns true iff addr1 and addr2 are in the same section. */
20601 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
20603 Elf_Internal_Shdr
* a1
;
20604 Elf_Internal_Shdr
* a2
;
20606 a1
= find_section_by_address (filedata
, addr1
);
20607 a2
= find_section_by_address (filedata
, addr2
);
20609 return a1
== a2
&& a1
!= NULL
;
20613 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
20614 Filedata
* filedata
)
20616 static unsigned long global_offset
= 0;
20617 static unsigned long global_end
= 0;
20618 static unsigned long func_offset
= 0;
20619 static unsigned long func_end
= 0;
20621 Elf_Internal_Sym
*sym
;
20623 unsigned long start
;
20625 bool is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
20627 switch (pnote
->descsz
)
20630 /* A zero-length description means that the range of
20631 the previous note of the same type should be used. */
20634 if (global_end
> global_offset
)
20635 printf (_(" Applies to region from %#lx to %#lx\n"),
20636 global_offset
, global_end
);
20638 printf (_(" Applies to region from %#lx\n"), global_offset
);
20642 if (func_end
> func_offset
)
20643 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
20645 printf (_(" Applies to region from %#lx\n"), func_offset
);
20650 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20655 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20656 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
20660 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
20661 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
20665 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
20666 printf (_(" <invalid descsz>"));
20671 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
20672 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
20673 in order to avoid them being confused with the start address of the
20674 first function in the file... */
20675 if (sym
== NULL
&& is_open_attr
)
20676 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
20679 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
20680 end
= start
+ sym
->st_size
;
20684 /* FIXME: Need to properly allow for section alignment.
20685 16 is just the alignment used on x86_64. */
20687 && start
> BFD_ALIGN (global_end
, 16)
20688 /* Build notes are not guaranteed to be organised in order of
20689 increasing address, but we should find the all of the notes
20690 for one section in the same place. */
20691 && same_section (filedata
, start
, global_end
))
20692 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
20693 global_end
+ 1, start
- 1);
20695 printf (_(" Applies to region from %#lx"), start
);
20696 global_offset
= start
;
20700 printf (_(" to %#lx"), end
);
20706 printf (_(" Applies to region from %#lx"), start
);
20707 func_offset
= start
;
20711 printf (_(" to %#lx"), end
);
20717 printf (_(" (%s)"), name
);
20724 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
20726 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
20727 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
20728 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
20730 char name_attribute
;
20731 const char * expected_types
;
20732 const char * name
= pnote
->namedata
;
20736 if (name
== NULL
|| pnote
->namesz
< 2)
20738 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
20739 print_symbol (-20, _(" <corrupt name>"));
20748 /* Version 2 of the spec adds a "GA" prefix to the name field. */
20749 if (name
[0] == 'G' && name
[1] == 'A')
20751 if (pnote
->namesz
< 4)
20753 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
20754 print_symbol (-20, _(" <corrupt name>"));
20763 switch ((name_type
= * name
))
20765 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
20766 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
20767 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
20768 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
20769 printf ("%c", * name
);
20773 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
20774 print_symbol (-20, _("<unknown name type>"));
20781 switch ((name_attribute
= * name
))
20783 case GNU_BUILD_ATTRIBUTE_VERSION
:
20784 text
= _("<version>");
20785 expected_types
= string_expected
;
20788 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
20789 text
= _("<stack prot>");
20790 expected_types
= "!+*";
20793 case GNU_BUILD_ATTRIBUTE_RELRO
:
20794 text
= _("<relro>");
20795 expected_types
= bool_expected
;
20798 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
20799 text
= _("<stack size>");
20800 expected_types
= number_expected
;
20803 case GNU_BUILD_ATTRIBUTE_TOOL
:
20804 text
= _("<tool>");
20805 expected_types
= string_expected
;
20808 case GNU_BUILD_ATTRIBUTE_ABI
:
20810 expected_types
= "$*";
20813 case GNU_BUILD_ATTRIBUTE_PIC
:
20815 expected_types
= number_expected
;
20818 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
20819 text
= _("<short enum>");
20820 expected_types
= bool_expected
;
20824 if (ISPRINT (* name
))
20826 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
20828 if (len
> left
&& ! do_wide
)
20830 printf ("%.*s:", len
, name
);
20836 static char tmpbuf
[128];
20838 error (_("unrecognised byte in name field: %d\n"), * name
);
20839 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
20843 expected_types
= "*$!+";
20848 left
-= printf ("%s", text
);
20850 if (strchr (expected_types
, name_type
) == NULL
)
20851 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
20853 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
20855 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
20856 (unsigned long) pnote
->namesz
,
20857 (long) (name
- pnote
->namedata
));
20861 if (left
< 1 && ! do_wide
)
20866 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
20868 unsigned int bytes
;
20869 unsigned long long val
= 0;
20870 unsigned int shift
= 0;
20871 char * decoded
= NULL
;
20873 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
20875 /* The -1 is because the name field is always 0 terminated, and we
20876 want to be able to ensure that the shift in the while loop below
20877 will not overflow. */
20880 if (bytes
> sizeof (val
))
20882 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
20884 bytes
= sizeof (val
);
20886 /* We do not bother to warn if bytes == 0 as this can
20887 happen with some early versions of the gcc plugin. */
20891 unsigned long long byte
= *name
++ & 0xff;
20893 val
|= byte
<< shift
;
20897 switch (name_attribute
)
20899 case GNU_BUILD_ATTRIBUTE_PIC
:
20902 case 0: decoded
= "static"; break;
20903 case 1: decoded
= "pic"; break;
20904 case 2: decoded
= "PIC"; break;
20905 case 3: decoded
= "pie"; break;
20906 case 4: decoded
= "PIE"; break;
20910 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
20913 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
20914 case 0: decoded
= "off"; break;
20915 case 1: decoded
= "on"; break;
20916 case 2: decoded
= "all"; break;
20917 case 3: decoded
= "strong"; break;
20918 case 4: decoded
= "explicit"; break;
20926 if (decoded
!= NULL
)
20928 print_symbol (-left
, decoded
);
20939 left
-= printf ("0x%llx", val
);
20941 left
-= printf ("0x%-.*llx", left
, val
);
20945 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
20946 left
-= print_symbol (- left
, name
);
20948 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
20949 left
-= print_symbol (- left
, "true");
20951 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
20952 left
-= print_symbol (- left
, "false");
20956 if (do_wide
&& left
> 0)
20957 printf ("%-*s", left
, " ");
20962 /* Note that by the ELF standard, the name field is already null byte
20963 terminated, and namesz includes the terminating null byte.
20964 I.E. the value of namesz for the name "FSF" is 4.
20966 If the value of namesz is zero, there is no name present. */
20969 process_note (Elf_Internal_Note
* pnote
,
20970 Filedata
* filedata
)
20972 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
20975 if (pnote
->namesz
== 0)
20976 /* If there is no note name, then use the default set of
20977 note type strings. */
20978 nt
= get_note_type (filedata
, pnote
->type
);
20980 else if (startswith (pnote
->namedata
, "GNU"))
20981 /* GNU-specific object file notes. */
20982 nt
= get_gnu_elf_note_type (pnote
->type
);
20984 else if (startswith (pnote
->namedata
, "FreeBSD"))
20985 /* FreeBSD-specific core file notes. */
20986 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
20988 else if (startswith (pnote
->namedata
, "NetBSD-CORE"))
20989 /* NetBSD-specific core file notes. */
20990 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
20992 else if (startswith (pnote
->namedata
, "NetBSD"))
20993 /* NetBSD-specific core file notes. */
20994 return process_netbsd_elf_note (pnote
);
20996 else if (startswith (pnote
->namedata
, "PaX"))
20997 /* NetBSD-specific core file notes. */
20998 return process_netbsd_elf_note (pnote
);
21000 else if (startswith (pnote
->namedata
, "OpenBSD"))
21001 /* OpenBSD-specific core file notes. */
21002 nt
= get_openbsd_elfcore_note_type (filedata
, pnote
->type
);
21004 else if (startswith (pnote
->namedata
, "SPU/"))
21006 /* SPU-specific core file notes. */
21007 nt
= pnote
->namedata
+ 4;
21011 else if (startswith (pnote
->namedata
, "IPF/VMS"))
21012 /* VMS/ia64-specific file notes. */
21013 nt
= get_ia64_vms_note_type (pnote
->type
);
21015 else if (startswith (pnote
->namedata
, "stapsdt"))
21016 nt
= get_stapsdt_note_type (pnote
->type
);
21019 /* Don't recognize this note name; just use the default set of
21020 note type strings. */
21021 nt
= get_note_type (filedata
, pnote
->type
);
21025 if (((startswith (pnote
->namedata
, "GA")
21026 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
21027 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
21028 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
21029 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
21030 print_gnu_build_attribute_name (pnote
);
21032 print_symbol (-20, name
);
21035 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
21037 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
21039 if (startswith (pnote
->namedata
, "IPF/VMS"))
21040 return print_ia64_vms_note (pnote
);
21041 else if (startswith (pnote
->namedata
, "GNU"))
21042 return print_gnu_note (filedata
, pnote
);
21043 else if (startswith (pnote
->namedata
, "stapsdt"))
21044 return print_stapsdt_note (pnote
);
21045 else if (startswith (pnote
->namedata
, "CORE"))
21046 return print_core_note (pnote
);
21047 else if (((startswith (pnote
->namedata
, "GA")
21048 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
21049 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
21050 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
21051 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
21052 return print_gnu_build_attribute_description (pnote
, filedata
);
21058 printf (_(" description data: "));
21059 for (i
= 0; i
< pnote
->descsz
; i
++)
21060 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
21072 process_notes_at (Filedata
* filedata
,
21073 Elf_Internal_Shdr
* section
,
21078 Elf_External_Note
*pnotes
;
21079 Elf_External_Note
*external
;
21088 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
21091 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
21099 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
21102 if (pnotes
== NULL
)
21107 if (filedata
->is_separate
)
21108 printf (_("In linked file '%s': "), filedata
->file_name
);
21112 printf (_("Displaying notes found in: %s\n"), printable_section_name (filedata
, section
));
21114 printf (_("Displaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
21115 (unsigned long) offset
, (unsigned long) length
);
21117 /* NB: Some note sections may have alignment value of 0 or 1. gABI
21118 specifies that notes should be aligned to 4 bytes in 32-bit
21119 objects and to 8 bytes in 64-bit objects. As a Linux extension,
21120 we also support 4 byte alignment in 64-bit objects. If section
21121 alignment is less than 4, we treate alignment as 4 bytes. */
21124 else if (align
!= 4 && align
!= 8)
21126 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
21132 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
21134 end
= (char *) pnotes
+ length
;
21135 while ((char *) external
< end
)
21137 Elf_Internal_Note inote
;
21140 char * temp
= NULL
;
21141 size_t data_remaining
= end
- (char *) external
;
21143 if (!is_ia64_vms (filedata
))
21145 /* PR binutils/15191
21146 Make sure that there is enough data to read. */
21147 min_notesz
= offsetof (Elf_External_Note
, name
);
21148 if (data_remaining
< min_notesz
)
21150 warn (ngettext ("Corrupt note: only %ld byte remains, "
21151 "not enough for a full note\n",
21152 "Corrupt note: only %ld bytes remain, "
21153 "not enough for a full note\n",
21155 (long) data_remaining
);
21158 data_remaining
-= min_notesz
;
21160 inote
.type
= BYTE_GET (external
->type
);
21161 inote
.namesz
= BYTE_GET (external
->namesz
);
21162 inote
.namedata
= external
->name
;
21163 inote
.descsz
= BYTE_GET (external
->descsz
);
21164 inote
.descdata
= ((char *) external
21165 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
21166 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
21167 next
= ((char *) external
21168 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
21172 Elf64_External_VMS_Note
*vms_external
;
21174 /* PR binutils/15191
21175 Make sure that there is enough data to read. */
21176 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
21177 if (data_remaining
< min_notesz
)
21179 warn (ngettext ("Corrupt note: only %ld byte remains, "
21180 "not enough for a full note\n",
21181 "Corrupt note: only %ld bytes remain, "
21182 "not enough for a full note\n",
21184 (long) data_remaining
);
21187 data_remaining
-= min_notesz
;
21189 vms_external
= (Elf64_External_VMS_Note
*) external
;
21190 inote
.type
= BYTE_GET (vms_external
->type
);
21191 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
21192 inote
.namedata
= vms_external
->name
;
21193 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
21194 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
21195 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
21196 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
21199 /* PR 17531: file: 3443835e. */
21200 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
21201 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
21202 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
21203 || (size_t) (next
- inote
.descdata
) < inote
.descsz
21204 || ((size_t) (next
- inote
.descdata
)
21205 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
21207 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
21208 (unsigned long) ((char *) external
- (char *) pnotes
));
21209 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
21210 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
21214 external
= (Elf_External_Note
*) next
;
21216 /* Verify that name is null terminated. It appears that at least
21217 one version of Linux (RedHat 6.0) generates corefiles that don't
21218 comply with the ELF spec by failing to include the null byte in
21220 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
21222 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
21224 temp
= (char *) malloc (inote
.namesz
+ 1);
21227 error (_("Out of memory allocating space for inote name\n"));
21232 memcpy (temp
, inote
.namedata
, inote
.namesz
);
21233 inote
.namedata
= temp
;
21235 inote
.namedata
[inote
.namesz
] = 0;
21238 if (! process_note (& inote
, filedata
))
21251 process_corefile_note_segments (Filedata
* filedata
)
21253 Elf_Internal_Phdr
*segment
;
21257 if (! get_program_headers (filedata
))
21260 for (i
= 0, segment
= filedata
->program_headers
;
21261 i
< filedata
->file_header
.e_phnum
;
21264 if (segment
->p_type
== PT_NOTE
)
21265 if (! process_notes_at (filedata
, NULL
,
21266 (bfd_vma
) segment
->p_offset
,
21267 (bfd_vma
) segment
->p_filesz
,
21268 (bfd_vma
) segment
->p_align
))
21276 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
21278 Elf_External_Note
* pnotes
;
21279 Elf_External_Note
* external
;
21286 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
21288 if (pnotes
== NULL
)
21292 end
= (char*) pnotes
+ length
;
21294 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
21295 (unsigned long) offset
, (unsigned long) length
);
21297 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
21299 Elf_External_Note
* next
;
21300 Elf_Internal_Note inote
;
21302 inote
.type
= BYTE_GET (external
->type
);
21303 inote
.namesz
= BYTE_GET (external
->namesz
);
21304 inote
.namedata
= external
->name
;
21305 inote
.descsz
= BYTE_GET (external
->descsz
);
21306 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
21307 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
21309 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
21311 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
21312 inote
.descdata
= inote
.namedata
;
21316 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
21318 if ( ((char *) next
> end
)
21319 || ((char *) next
< (char *) pnotes
))
21321 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
21322 (unsigned long) ((char *) external
- (char *) pnotes
));
21323 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
21324 inote
.type
, inote
.namesz
, inote
.descsz
);
21330 /* Prevent out-of-bounds indexing. */
21331 if ( inote
.namedata
+ inote
.namesz
> end
21332 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
21334 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
21335 (unsigned long) ((char *) external
- (char *) pnotes
));
21336 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
21337 inote
.type
, inote
.namesz
, inote
.descsz
);
21341 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
21343 if (! print_v850_note (& inote
))
21346 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
21347 inote
.namesz
, inote
.descsz
);
21357 process_note_sections (Filedata
* filedata
)
21359 Elf_Internal_Shdr
*section
;
21361 unsigned int n
= 0;
21364 for (i
= 0, section
= filedata
->section_headers
;
21365 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
21368 if (section
->sh_type
== SHT_NOTE
)
21370 if (! process_notes_at (filedata
, section
,
21371 (bfd_vma
) section
->sh_offset
,
21372 (bfd_vma
) section
->sh_size
,
21373 (bfd_vma
) section
->sh_addralign
))
21378 if (( filedata
->file_header
.e_machine
== EM_V800
21379 || filedata
->file_header
.e_machine
== EM_V850
21380 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
21381 && section
->sh_type
== SHT_RENESAS_INFO
)
21383 if (! process_v850_notes (filedata
,
21384 (bfd_vma
) section
->sh_offset
,
21385 (bfd_vma
) section
->sh_size
))
21392 /* Try processing NOTE segments instead. */
21393 return process_corefile_note_segments (filedata
);
21399 process_notes (Filedata
* filedata
)
21401 /* If we have not been asked to display the notes then do nothing. */
21405 if (filedata
->file_header
.e_type
!= ET_CORE
)
21406 return process_note_sections (filedata
);
21408 /* No program headers means no NOTE segment. */
21409 if (filedata
->file_header
.e_phnum
> 0)
21410 return process_corefile_note_segments (filedata
);
21412 if (filedata
->is_separate
)
21413 printf (_("No notes found in linked file '%s'.\n"),
21414 filedata
->file_name
);
21416 printf (_("No notes found file.\n"));
21421 static unsigned char *
21422 display_public_gnu_attributes (unsigned char * start
,
21423 const unsigned char * const end
)
21425 printf (_(" Unknown GNU attribute: %s\n"), start
);
21427 start
+= strnlen ((char *) start
, end
- start
);
21428 display_raw_attribute (start
, end
);
21430 return (unsigned char *) end
;
21433 static unsigned char *
21434 display_generic_attribute (unsigned char * start
,
21436 const unsigned char * const end
)
21439 return (unsigned char *) end
;
21441 return display_tag_value (tag
, start
, end
);
21445 process_arch_specific (Filedata
* filedata
)
21450 switch (filedata
->file_header
.e_machine
)
21453 case EM_ARC_COMPACT
:
21454 case EM_ARC_COMPACT2
:
21455 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
21456 display_arc_attribute
,
21457 display_generic_attribute
);
21459 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
21460 display_arm_attribute
,
21461 display_generic_attribute
);
21464 case EM_MIPS_RS3_LE
:
21465 return process_mips_specific (filedata
);
21468 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
21469 display_msp430_attribute
,
21470 display_msp430_gnu_attribute
);
21473 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
21474 display_riscv_attribute
,
21475 display_generic_attribute
);
21478 return process_nds32_specific (filedata
);
21481 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21482 display_m68k_gnu_attribute
);
21486 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21487 display_power_gnu_attribute
);
21491 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21492 display_s390_gnu_attribute
);
21495 case EM_SPARC32PLUS
:
21497 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21498 display_sparc_gnu_attribute
);
21501 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
21502 display_tic6x_attribute
,
21503 display_generic_attribute
);
21506 return process_attributes (filedata
, "csky", SHT_CSKY_ATTRIBUTES
,
21507 display_csky_attribute
, NULL
);
21510 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
21511 display_public_gnu_attributes
,
21512 display_generic_attribute
);
21517 get_file_header (Filedata
* filedata
)
21519 /* Read in the identity array. */
21520 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
21523 /* Determine how to read the rest of the header. */
21524 switch (filedata
->file_header
.e_ident
[EI_DATA
])
21529 byte_get
= byte_get_little_endian
;
21530 byte_put
= byte_put_little_endian
;
21533 byte_get
= byte_get_big_endian
;
21534 byte_put
= byte_put_big_endian
;
21538 /* For now we only support 32 bit and 64 bit ELF files. */
21539 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
21541 /* Read in the rest of the header. */
21544 Elf32_External_Ehdr ehdr32
;
21546 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
21549 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
21550 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
21551 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
21552 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
21553 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
21554 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
21555 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
21556 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
21557 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
21558 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
21559 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
21560 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
21561 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
21565 Elf64_External_Ehdr ehdr64
;
21567 /* If we have been compiled with sizeof (bfd_vma) == 4, then
21568 we will not be able to cope with the 64bit data found in
21569 64 ELF files. Detect this now and abort before we start
21570 overwriting things. */
21571 if (sizeof (bfd_vma
) < 8)
21573 error (_("This instance of readelf has been built without support for a\n\
21574 64 bit data type and so it cannot read 64 bit ELF files.\n"));
21578 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
21581 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
21582 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
21583 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
21584 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
21585 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
21586 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
21587 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
21588 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
21589 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
21590 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
21591 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
21592 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
21593 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
21600 free_filedata (Filedata
*filedata
)
21602 free (filedata
->program_interpreter
);
21603 free (filedata
->program_headers
);
21604 free (filedata
->section_headers
);
21605 free (filedata
->string_table
);
21606 free (filedata
->dump
.dump_sects
);
21607 free (filedata
->dynamic_strings
);
21608 free (filedata
->dynamic_symbols
);
21609 free (filedata
->dynamic_syminfo
);
21610 free (filedata
->dynamic_section
);
21612 while (filedata
->symtab_shndx_list
!= NULL
)
21614 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
21615 free (filedata
->symtab_shndx_list
);
21616 filedata
->symtab_shndx_list
= next
;
21619 free (filedata
->section_headers_groups
);
21621 if (filedata
->section_groups
)
21624 struct group_list
* g
;
21625 struct group_list
* next
;
21627 for (i
= 0; i
< filedata
->group_count
; i
++)
21629 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
21636 free (filedata
->section_groups
);
21638 memset (&filedata
->section_headers
, 0,
21639 sizeof (Filedata
) - offsetof (Filedata
, section_headers
));
21643 close_file (Filedata
* filedata
)
21647 if (filedata
->handle
)
21648 fclose (filedata
->handle
);
21654 close_debug_file (void * data
)
21656 free_filedata ((Filedata
*) data
);
21657 close_file ((Filedata
*) data
);
21661 open_file (const char * pathname
, bool is_separate
)
21663 struct stat statbuf
;
21664 Filedata
* filedata
= NULL
;
21666 if (stat (pathname
, & statbuf
) < 0
21667 || ! S_ISREG (statbuf
.st_mode
))
21670 filedata
= calloc (1, sizeof * filedata
);
21671 if (filedata
== NULL
)
21674 filedata
->handle
= fopen (pathname
, "rb");
21675 if (filedata
->handle
== NULL
)
21678 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
21679 filedata
->file_name
= pathname
;
21680 filedata
->is_separate
= is_separate
;
21682 if (! get_file_header (filedata
))
21685 if (!get_section_headers (filedata
, false))
21693 if (filedata
->handle
)
21694 fclose (filedata
->handle
);
21701 open_debug_file (const char * pathname
)
21703 return open_file (pathname
, true);
21707 initialise_dump_sects (Filedata
* filedata
)
21709 /* Initialise the dump_sects array from the cmdline_dump_sects array.
21710 Note we do this even if cmdline_dump_sects is empty because we
21711 must make sure that the dump_sets array is zeroed out before each
21712 object file is processed. */
21713 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
21714 memset (filedata
->dump
.dump_sects
, 0,
21715 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
21717 if (cmdline
.num_dump_sects
> 0)
21719 if (filedata
->dump
.num_dump_sects
== 0)
21720 /* A sneaky way of allocating the dump_sects array. */
21721 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
21723 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
21724 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
21725 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
21729 /* Process one ELF object file according to the command line options.
21730 This file may actually be stored in an archive. The file is
21731 positioned at the start of the ELF object. Returns TRUE if no
21732 problems were encountered, FALSE otherwise. */
21735 process_object (Filedata
* filedata
)
21737 bool have_separate_files
;
21741 if (! get_file_header (filedata
))
21743 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
21747 /* Initialise per file variables. */
21748 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
21749 filedata
->version_info
[i
] = 0;
21751 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
21752 filedata
->dynamic_info
[i
] = 0;
21753 filedata
->dynamic_info_DT_GNU_HASH
= 0;
21754 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
21756 /* Process the file. */
21758 printf (_("\nFile: %s\n"), filedata
->file_name
);
21760 initialise_dump_sects (filedata
);
21762 /* There may be some extensions in the first section header. Don't
21763 bomb if we can't read it. */
21764 get_section_headers (filedata
, true);
21766 if (! process_file_header (filedata
))
21772 /* Throw away the single section header read above, so that we
21773 re-read the entire set. */
21774 free (filedata
->section_headers
);
21775 filedata
->section_headers
= NULL
;
21777 if (! process_section_headers (filedata
))
21779 /* Without loaded section headers we cannot process lots of things. */
21780 do_unwind
= do_version
= do_dump
= do_arch
= false;
21782 if (! do_using_dynamic
)
21783 do_syms
= do_dyn_syms
= do_reloc
= false;
21786 if (! process_section_groups (filedata
))
21787 /* Without loaded section groups we cannot process unwind. */
21790 process_program_headers (filedata
);
21792 res
= process_dynamic_section (filedata
);
21794 if (! process_relocs (filedata
))
21797 if (! process_unwind (filedata
))
21800 if (! process_symbol_table (filedata
))
21803 if (! process_lto_symbol_tables (filedata
))
21806 if (! process_syminfo (filedata
))
21809 if (! process_version_sections (filedata
))
21812 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
21813 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
21815 have_separate_files
= false;
21817 if (! process_section_contents (filedata
))
21820 if (have_separate_files
)
21824 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
21826 initialise_dump_sects (d
->handle
);
21828 if (process_links
&& ! process_file_header (d
->handle
))
21830 else if (! process_section_headers (d
->handle
))
21832 else if (! process_section_contents (d
->handle
))
21834 else if (process_links
)
21836 if (! process_section_groups (d
->handle
))
21838 process_program_headers (d
->handle
);
21839 if (! process_dynamic_section (d
->handle
))
21841 if (! process_relocs (d
->handle
))
21843 if (! process_unwind (d
->handle
))
21845 if (! process_symbol_table (d
->handle
))
21847 if (! process_lto_symbol_tables (d
->handle
))
21849 if (! process_syminfo (d
->handle
))
21851 if (! process_version_sections (d
->handle
))
21853 if (! process_notes (d
->handle
))
21858 /* The file handles are closed by the call to free_debug_memory() below. */
21861 if (! process_notes (filedata
))
21864 if (! process_gnu_liblist (filedata
))
21867 if (! process_arch_specific (filedata
))
21871 free_filedata (filedata
);
21873 free_debug_memory ();
21878 /* Process an ELF archive.
21879 On entry the file is positioned just after the ARMAG string.
21880 Returns TRUE upon success, FALSE otherwise. */
21883 process_archive (Filedata
* filedata
, bool is_thin_archive
)
21885 struct archive_info arch
;
21886 struct archive_info nested_arch
;
21892 /* The ARCH structure is used to hold information about this archive. */
21893 arch
.file_name
= NULL
;
21895 arch
.index_array
= NULL
;
21896 arch
.sym_table
= NULL
;
21897 arch
.longnames
= NULL
;
21899 /* The NESTED_ARCH structure is used as a single-item cache of information
21900 about a nested archive (when members of a thin archive reside within
21901 another regular archive file). */
21902 nested_arch
.file_name
= NULL
;
21903 nested_arch
.file
= NULL
;
21904 nested_arch
.index_array
= NULL
;
21905 nested_arch
.sym_table
= NULL
;
21906 nested_arch
.longnames
= NULL
;
21908 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
21909 filedata
->file_size
, is_thin_archive
,
21910 do_archive_index
) != 0)
21916 if (do_archive_index
)
21918 if (arch
.sym_table
== NULL
)
21919 error (_("%s: unable to dump the index as none was found\n"),
21920 filedata
->file_name
);
21923 unsigned long i
, l
;
21924 unsigned long current_pos
;
21926 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
21927 "in the symbol table)\n"),
21928 filedata
->file_name
, (unsigned long) arch
.index_num
,
21931 current_pos
= ftell (filedata
->handle
);
21933 for (i
= l
= 0; i
< arch
.index_num
; i
++)
21936 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
21939 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
21942 if (member_name
!= NULL
)
21944 char * qualified_name
21945 = make_qualified_name (&arch
, &nested_arch
,
21948 if (qualified_name
!= NULL
)
21950 printf (_("Contents of binary %s at offset "),
21952 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
21954 free (qualified_name
);
21956 free (member_name
);
21960 if (l
>= arch
.sym_size
)
21962 error (_("%s: end of the symbol table reached "
21963 "before the end of the index\n"),
21964 filedata
->file_name
);
21968 /* PR 17531: file: 0b6630b2. */
21969 printf ("\t%.*s\n",
21970 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
21971 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
21974 if (arch
.uses_64bit_indices
)
21979 if (l
< arch
.sym_size
)
21981 error (ngettext ("%s: %ld byte remains in the symbol table, "
21982 "but without corresponding entries in "
21983 "the index table\n",
21984 "%s: %ld bytes remain in the symbol table, "
21985 "but without corresponding entries in "
21986 "the index table\n",
21987 arch
.sym_size
- l
),
21988 filedata
->file_name
, arch
.sym_size
- l
);
21992 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
21994 error (_("%s: failed to seek back to start of object files "
21995 "in the archive\n"),
21996 filedata
->file_name
);
22002 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
22003 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
22004 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
22005 && !do_section_groups
&& !do_dyn_syms
)
22007 ret
= true; /* Archive index only. */
22016 char * qualified_name
;
22018 /* Read the next archive header. */
22019 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
22021 error (_("%s: failed to seek to next archive header\n"),
22026 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
22027 if (got
!= sizeof arch
.arhdr
)
22031 /* PR 24049 - we cannot use filedata->file_name as this will
22032 have already been freed. */
22033 error (_("%s: failed to read archive header\n"), arch
.file_name
);
22038 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
22040 error (_("%s: did not find a valid archive header\n"),
22046 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
22048 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
22050 name
= get_archive_member_name (&arch
, &nested_arch
);
22053 error (_("%s: bad archive file name\n"), arch
.file_name
);
22057 namelen
= strlen (name
);
22059 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
22060 if (qualified_name
== NULL
)
22062 error (_("%s: bad archive file name\n"), arch
.file_name
);
22068 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
22070 /* This is a proxy for an external member of a thin archive. */
22071 Filedata
* member_filedata
;
22072 char * member_file_name
= adjust_relative_path
22073 (filedata
->file_name
, name
, namelen
);
22076 if (member_file_name
== NULL
)
22078 free (qualified_name
);
22083 member_filedata
= open_file (member_file_name
, false);
22084 if (member_filedata
== NULL
)
22086 error (_("Input file '%s' is not readable.\n"), member_file_name
);
22087 free (member_file_name
);
22088 free (qualified_name
);
22093 filedata
->archive_file_offset
= arch
.nested_member_origin
;
22094 member_filedata
->file_name
= qualified_name
;
22096 /* The call to process_object() expects the file to be at the beginning. */
22097 rewind (member_filedata
->handle
);
22099 if (! process_object (member_filedata
))
22102 close_file (member_filedata
);
22103 free (member_file_name
);
22105 else if (is_thin_archive
)
22107 Filedata thin_filedata
;
22109 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
22111 /* PR 15140: Allow for corrupt thin archives. */
22112 if (nested_arch
.file
== NULL
)
22114 error (_("%s: contains corrupt thin archive: %s\n"),
22115 qualified_name
, name
);
22116 free (qualified_name
);
22123 /* This is a proxy for a member of a nested archive. */
22124 filedata
->archive_file_offset
22125 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
22127 /* The nested archive file will have been opened and setup by
22128 get_archive_member_name. */
22129 if (fseek (nested_arch
.file
, filedata
->archive_file_offset
,
22132 error (_("%s: failed to seek to archive member.\n"),
22133 nested_arch
.file_name
);
22134 free (qualified_name
);
22139 thin_filedata
.handle
= nested_arch
.file
;
22140 thin_filedata
.file_name
= qualified_name
;
22142 if (! process_object (& thin_filedata
))
22148 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
22149 filedata
->file_name
= qualified_name
;
22150 if (! process_object (filedata
))
22152 arch
.next_arhdr_offset
+= (filedata
->archive_file_size
+ 1) & -2;
22153 /* Stop looping with "negative" archive_file_size. */
22154 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
22155 arch
.next_arhdr_offset
= -1ul;
22158 free (qualified_name
);
22162 if (nested_arch
.file
!= NULL
)
22163 fclose (nested_arch
.file
);
22164 release_archive (&nested_arch
);
22165 release_archive (&arch
);
22171 process_file (char * file_name
)
22173 Filedata
* filedata
= NULL
;
22174 struct stat statbuf
;
22175 char armag
[SARMAG
];
22178 if (stat (file_name
, &statbuf
) < 0)
22180 if (errno
== ENOENT
)
22181 error (_("'%s': No such file\n"), file_name
);
22183 error (_("Could not locate '%s'. System error message: %s\n"),
22184 file_name
, strerror (errno
));
22188 if (! S_ISREG (statbuf
.st_mode
))
22190 error (_("'%s' is not an ordinary file\n"), file_name
);
22194 filedata
= calloc (1, sizeof * filedata
);
22195 if (filedata
== NULL
)
22197 error (_("Out of memory allocating file data structure\n"));
22201 filedata
->file_name
= file_name
;
22202 filedata
->handle
= fopen (file_name
, "rb");
22203 if (filedata
->handle
== NULL
)
22205 error (_("Input file '%s' is not readable.\n"), file_name
);
22210 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
22212 error (_("%s: Failed to read file's magic number\n"), file_name
);
22213 fclose (filedata
->handle
);
22218 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
22219 filedata
->is_separate
= false;
22221 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
22223 if (! process_archive (filedata
, false))
22226 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
22228 if ( ! process_archive (filedata
, true))
22233 if (do_archive_index
&& !check_all
)
22234 error (_("File %s is not an archive so its index cannot be displayed.\n"),
22237 rewind (filedata
->handle
);
22238 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
22240 if (! process_object (filedata
))
22244 fclose (filedata
->handle
);
22245 free (filedata
->section_headers
);
22246 free (filedata
->program_headers
);
22247 free (filedata
->string_table
);
22248 free (filedata
->dump
.dump_sects
);
22251 free (ba_cache
.strtab
);
22252 ba_cache
.strtab
= NULL
;
22253 free (ba_cache
.symtab
);
22254 ba_cache
.symtab
= NULL
;
22255 ba_cache
.filedata
= NULL
;
22260 #ifdef SUPPORT_DISASSEMBLY
22261 /* Needed by the i386 disassembler. For extra credit, someone could
22262 fix this so that we insert symbolic addresses here, esp for GOT/PLT
22266 print_address (unsigned int addr
, FILE * outfile
)
22268 fprintf (outfile
,"0x%8.8x", addr
);
22271 /* Needed by the i386 disassembler. */
22274 db_task_printsym (unsigned int addr
)
22276 print_address (addr
, stderr
);
22281 main (int argc
, char ** argv
)
22285 #ifdef HAVE_LC_MESSAGES
22286 setlocale (LC_MESSAGES
, "");
22288 setlocale (LC_CTYPE
, "");
22289 bindtextdomain (PACKAGE
, LOCALEDIR
);
22290 textdomain (PACKAGE
);
22292 expandargv (&argc
, &argv
);
22294 parse_args (& cmdline
, argc
, argv
);
22296 if (optind
< (argc
- 1))
22297 /* When displaying information for more than one file,
22298 prefix the information with the file name. */
22300 else if (optind
>= argc
)
22302 /* Ensure that the warning is always displayed. */
22305 warn (_("Nothing to do.\n"));
22310 while (optind
< argc
)
22311 if (! process_file (argv
[optind
++]))
22314 free (cmdline
.dump_sects
);
22316 free (dump_ctf_symtab_name
);
22317 free (dump_ctf_strtab_name
);
22318 free (dump_ctf_parent_name
);
22320 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;