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"
167 #include "libiberty.h"
168 #include "safe-ctype.h"
169 #include "filenames.h"
172 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
175 typedef struct elf_section_list
177 Elf_Internal_Shdr
* hdr
;
178 struct elf_section_list
* next
;
181 /* Flag bits indicating particular types of dump. */
182 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
183 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
184 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
185 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
186 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
187 #define CTF_DUMP (1 << 5) /* The --ctf command line switch. */
189 typedef unsigned char dump_type
;
191 /* A linked list of the section names for which dumps were requested. */
192 struct dump_list_entry
196 struct dump_list_entry
* next
;
199 /* A dynamic array of flags indicating for which sections a dump
200 has been requested via command line switches. */
203 dump_type
* dump_sects
;
204 unsigned int num_dump_sects
;
207 static struct dump_data cmdline
;
209 static struct dump_list_entry
* dump_sects_byname
;
211 char * program_name
= "readelf";
213 static bool show_name
= false;
214 static bool do_dynamic
= false;
215 static bool do_syms
= false;
216 static bool do_dyn_syms
= false;
217 static bool do_lto_syms
= false;
218 static bool do_reloc
= false;
219 static bool do_sections
= false;
220 static bool do_section_groups
= false;
221 static bool do_section_details
= false;
222 static bool do_segments
= false;
223 static bool do_unwind
= false;
224 static bool do_using_dynamic
= false;
225 static bool do_header
= false;
226 static bool do_dump
= false;
227 static bool do_version
= false;
228 static bool do_histogram
= false;
229 static bool do_debugging
= false;
230 static bool do_ctf
= false;
231 static bool do_arch
= false;
232 static bool do_notes
= false;
233 static bool do_archive_index
= false;
234 static bool check_all
= false;
235 static bool is_32bit_elf
= false;
236 static bool decompress_dumps
= false;
237 static bool do_not_show_symbol_truncation
= false;
238 static bool do_demangle
= false; /* Pretty print C++ symbol names. */
239 static bool process_links
= false;
240 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
241 static int sym_base
= 0;
243 static char *dump_ctf_parent_name
;
244 static char *dump_ctf_symtab_name
;
245 static char *dump_ctf_strtab_name
;
249 struct group_list
* next
;
250 unsigned int section_index
;
255 struct group_list
* root
;
256 unsigned int group_index
;
259 typedef struct filedata
261 const char * file_name
;
264 bfd_size_type file_size
;
265 Elf_Internal_Ehdr file_header
;
266 unsigned long archive_file_offset
;
267 unsigned long archive_file_size
;
268 /* Everything below this point is cleared out by free_filedata. */
269 Elf_Internal_Shdr
* section_headers
;
270 Elf_Internal_Phdr
* program_headers
;
272 unsigned long string_table_length
;
273 unsigned long dynamic_addr
;
274 bfd_size_type dynamic_size
;
276 Elf_Internal_Dyn
* dynamic_section
;
277 Elf_Internal_Shdr
* dynamic_strtab_section
;
278 char * dynamic_strings
;
279 unsigned long dynamic_strings_length
;
280 Elf_Internal_Shdr
* dynamic_symtab_section
;
281 unsigned long num_dynamic_syms
;
282 Elf_Internal_Sym
* dynamic_symbols
;
283 bfd_vma version_info
[16];
284 unsigned int dynamic_syminfo_nent
;
285 Elf_Internal_Syminfo
* dynamic_syminfo
;
286 unsigned long dynamic_syminfo_offset
;
287 bfd_size_type nbuckets
;
288 bfd_size_type nchains
;
291 bfd_size_type ngnubuckets
;
292 bfd_size_type ngnuchains
;
293 bfd_vma
* gnubuckets
;
297 char * program_interpreter
;
298 bfd_vma dynamic_info
[DT_ENCODING
];
299 bfd_vma dynamic_info_DT_GNU_HASH
;
300 bfd_vma dynamic_info_DT_MIPS_XHASH
;
301 elf_section_list
* symtab_shndx_list
;
303 struct group
* section_groups
;
304 struct group
** section_headers_groups
;
305 /* A dynamic array of flags indicating for which sections a dump of
306 some kind has been requested. It is reset on a per-object file
307 basis and then initialised from the cmdline_dump_sects array,
308 the results of interpreting the -w switch, and the
309 dump_sects_byname list. */
310 struct dump_data dump
;
313 /* How to print a vma value. */
314 typedef enum print_mode
331 /* Versioned symbol info. */
332 enum versioned_symbol_info
339 static const char * get_symbol_version_string
340 (Filedata
*, bool, const char *, unsigned long, unsigned,
341 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
345 #define SECTION_NAME(X) \
346 (filedata->string_table + (X)->sh_name)
348 #define SECTION_NAME_VALID(X) \
350 && filedata->string_table != NULL \
351 && (X)->sh_name < filedata->string_table_length)
353 #define SECTION_NAME_PRINT(X) \
354 ((X) == NULL ? _("<none>") \
355 : filedata->string_table == NULL ? _("<no-strings>") \
356 : (X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
357 : filedata->string_table + (X)->sh_name)
359 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
361 #define VALID_SYMBOL_NAME(strtab, strtab_size, offset) \
362 (strtab != NULL && offset < strtab_size)
363 #define VALID_DYNAMIC_NAME(filedata, offset) \
364 VALID_SYMBOL_NAME (filedata->dynamic_strings, \
365 filedata->dynamic_strings_length, offset)
366 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
367 already been called and verified that the string exists. */
368 #define GET_DYNAMIC_NAME(filedata, offset) \
369 (filedata->dynamic_strings + offset)
371 #define REMOVE_ARCH_BITS(ADDR) \
374 if (filedata->file_header.e_machine == EM_ARM) \
379 /* Get the correct GNU hash section name. */
380 #define GNU_HASH_SECTION_NAME(filedata) \
381 filedata->dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
383 /* Print a BFD_VMA to an internal buffer, for use in error messages.
384 BFD_FMA_FMT can't be used in translated strings. */
387 bfd_vmatoa (char *fmtch
, bfd_vma value
)
389 /* bfd_vmatoa is used more then once in a printf call for output.
390 Cycle through an array of buffers. */
391 static int buf_pos
= 0;
392 static struct bfd_vmatoa_buf
399 ret
= buf
[buf_pos
++].place
;
400 buf_pos
%= ARRAY_SIZE (buf
);
402 sprintf (fmt
, "%%%s%s", BFD_VMA_FMT
, fmtch
);
403 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
407 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
408 OFFSET + the offset of the current archive member, if we are examining an
409 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
410 allocate a buffer using malloc and fill that. In either case return the
411 pointer to the start of the retrieved data or NULL if something went wrong.
412 If something does go wrong and REASON is not NULL then emit an error
413 message using REASON as part of the context. */
416 get_data (void * var
,
418 unsigned long offset
,
424 bfd_size_type amt
= size
* nmemb
;
426 if (size
== 0 || nmemb
== 0)
429 /* If the size_t type is smaller than the bfd_size_type, eg because
430 you are building a 32-bit tool on a 64-bit host, then make sure
431 that when the sizes are cast to (size_t) no information is lost. */
432 if ((size_t) size
!= size
433 || (size_t) nmemb
!= nmemb
434 || (size_t) amt
!= amt
)
437 error (_("Size truncation prevents reading %s"
438 " elements of size %s for %s\n"),
439 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
443 /* Check for size overflow. */
444 if (amt
/ size
!= nmemb
|| (size_t) amt
+ 1 == 0)
447 error (_("Size overflow prevents reading %s"
448 " elements of size %s for %s\n"),
449 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
453 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
454 attempting to allocate memory when the read is bound to fail. */
455 if (filedata
->archive_file_offset
> filedata
->file_size
456 || offset
> filedata
->file_size
- filedata
->archive_file_offset
457 || amt
> filedata
->file_size
- filedata
->archive_file_offset
- offset
)
460 error (_("Reading %s bytes extends past end of file for %s\n"),
461 bfd_vmatoa ("u", amt
), reason
);
465 if (fseek (filedata
->handle
, filedata
->archive_file_offset
+ offset
,
469 error (_("Unable to seek to 0x%lx for %s\n"),
470 filedata
->archive_file_offset
+ offset
, reason
);
477 /* + 1 so that we can '\0' terminate invalid string table sections. */
478 mvar
= malloc ((size_t) amt
+ 1);
483 error (_("Out of memory allocating %s bytes for %s\n"),
484 bfd_vmatoa ("u", amt
), reason
);
488 ((char *) mvar
)[amt
] = '\0';
491 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
494 error (_("Unable to read in %s bytes of %s\n"),
495 bfd_vmatoa ("u", amt
), reason
);
504 /* Print a VMA value in the MODE specified.
505 Returns the number of characters displayed. */
508 print_vma (bfd_vma vma
, print_mode mode
)
520 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
527 return printf ("%5" BFD_VMA_FMT
"d", vma
);
533 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
539 return nc
+ printf ("%05" BFD_VMA_FMT
"x", vma
);
542 return printf ("%" BFD_VMA_FMT
"d", vma
);
545 return printf ("%" BFD_VMA_FMT
"u", vma
);
548 return printf ("%5" BFD_VMA_FMT
"u", vma
);
551 return printf ("%" BFD_VMA_FMT
"o", vma
);
554 return printf ("%5" BFD_VMA_FMT
"o", vma
);
557 /* FIXME: Report unrecognised mode ? */
563 /* Display a symbol on stdout. Handles the display of control characters and
564 multibye characters (assuming the host environment supports them).
566 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
568 If truncation will happen and do_not_show_symbol_truncation is FALSE then display
569 abs(WIDTH) - 5 characters followed by "[...]".
571 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
572 padding as necessary.
574 Returns the number of emitted characters. */
577 print_symbol (signed int width
, const char * symbol
)
579 bool extra_padding
= false;
580 bool do_dots
= false;
581 signed int num_printed
= 0;
582 #ifdef HAVE_MBSTATE_T
585 unsigned int width_remaining
;
586 const void * alloced_symbol
= NULL
;
590 /* Keep the width positive. This helps the code below. */
592 extra_padding
= true;
598 /* Set the remaining width to a very large value.
599 This simplifies the code below. */
600 width_remaining
= INT_MAX
;
603 width_remaining
= width
;
604 if (! do_not_show_symbol_truncation
605 && (int) strlen (symbol
) > width
)
607 width_remaining
-= 5;
608 if ((int) width_remaining
< 0)
614 #ifdef HAVE_MBSTATE_T
615 /* Initialise the multibyte conversion state. */
616 memset (& state
, 0, sizeof (state
));
619 if (do_demangle
&& *symbol
)
621 const char * res
= cplus_demangle (symbol
, demangle_flags
);
624 alloced_symbol
= symbol
= res
;
627 while (width_remaining
)
630 const char c
= *symbol
++;
635 /* Do not print control characters directly as they can affect terminal
636 settings. Such characters usually appear in the names generated
637 by the assembler for local labels. */
640 if (width_remaining
< 2)
643 printf ("^%c", c
+ 0x40);
644 width_remaining
-= 2;
647 else if (ISPRINT (c
))
655 #ifdef HAVE_MBSTATE_T
658 /* Let printf do the hard work of displaying multibyte characters. */
659 printf ("%.1s", symbol
- 1);
663 #ifdef HAVE_MBSTATE_T
664 /* Try to find out how many bytes made up the character that was
665 just printed. Advance the symbol pointer past the bytes that
667 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
671 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
677 num_printed
+= printf ("[...]");
679 if (extra_padding
&& num_printed
< width
)
681 /* Fill in the remaining spaces. */
682 printf ("%-*s", width
- num_printed
, " ");
686 free ((void *) alloced_symbol
);
690 /* Returns a pointer to a static buffer containing a printable version of
691 the given section's name. Like print_symbol, except that it does not try
692 to print multibyte characters, it just interprets them as hex values. */
695 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
697 #define MAX_PRINT_SEC_NAME_LEN 256
698 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
699 const char * name
= SECTION_NAME_PRINT (sec
);
700 char * buf
= sec_name_buf
;
702 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
704 while ((c
= * name
++) != 0)
715 else if (ISPRINT (c
))
722 static char hex
[17] = "0123456789ABCDEF";
727 * buf
++ = hex
[(c
& 0xf0) >> 4];
728 * buf
++ = hex
[c
& 0x0f];
742 printable_section_name_from_index (Filedata
* filedata
, unsigned long ndx
)
744 if (ndx
>= filedata
->file_header
.e_shnum
)
745 return _("<corrupt>");
747 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
750 /* Return a pointer to section NAME, or NULL if no such section exists. */
752 static Elf_Internal_Shdr
*
753 find_section (Filedata
* filedata
, const char * name
)
757 if (filedata
->section_headers
== NULL
)
760 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
761 if (SECTION_NAME_VALID (filedata
->section_headers
+ i
)
762 && streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
763 return filedata
->section_headers
+ i
;
768 /* Return a pointer to a section containing ADDR, or NULL if no such
771 static Elf_Internal_Shdr
*
772 find_section_by_address (Filedata
* filedata
, bfd_vma addr
)
776 if (filedata
->section_headers
== NULL
)
779 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
781 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
783 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
790 static Elf_Internal_Shdr
*
791 find_section_by_type (Filedata
* filedata
, unsigned int type
)
795 if (filedata
->section_headers
== NULL
)
798 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
800 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
802 if (sec
->sh_type
== type
)
809 /* Return a pointer to section NAME, or NULL if no such section exists,
810 restricted to the list of sections given in SET. */
812 static Elf_Internal_Shdr
*
813 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
817 if (filedata
->section_headers
== NULL
)
822 while ((i
= *set
++) > 0)
824 /* See PR 21156 for a reproducer. */
825 if (i
>= filedata
->file_header
.e_shnum
)
826 continue; /* FIXME: Should we issue an error message ? */
828 if (SECTION_NAME_VALID (filedata
->section_headers
+ i
)
829 && streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
830 return filedata
->section_headers
+ i
;
834 return find_section (filedata
, name
);
837 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
838 This OS has so many departures from the ELF standard that we test it at
842 is_ia64_vms (Filedata
* filedata
)
844 return filedata
->file_header
.e_machine
== EM_IA_64
845 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
848 /* Guess the relocation size commonly used by the specific machines. */
851 guess_is_rela (unsigned int e_machine
)
855 /* Targets that use REL relocations. */
872 /* Targets that use RELA relocations. */
876 case EM_ADAPTEVA_EPIPHANY
:
878 case EM_ALTERA_NIOS2
:
881 case EM_ARC_COMPACT2
:
902 case EM_LATTICEMICO32
:
911 case EM_CYGNUS_MN10200
:
913 case EM_CYGNUS_MN10300
:
949 case EM_MICROBLAZE_OLD
:
971 warn (_("Don't know about relocations on this machine architecture\n"));
976 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
977 Returns TRUE upon success, FALSE otherwise. If successful then a
978 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
979 and the number of relocs loaded is placed in *NRELASP. It is the caller's
980 responsibility to free the allocated buffer. */
983 slurp_rela_relocs (Filedata
* filedata
,
984 unsigned long rel_offset
,
985 unsigned long rel_size
,
986 Elf_Internal_Rela
** relasp
,
987 unsigned long * nrelasp
)
989 Elf_Internal_Rela
* relas
;
995 Elf32_External_Rela
* erelas
;
997 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
998 rel_size
, _("32-bit relocation data"));
1002 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
1004 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
1005 sizeof (Elf_Internal_Rela
));
1010 error (_("out of memory parsing relocs\n"));
1014 for (i
= 0; i
< nrelas
; i
++)
1016 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
1017 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
1018 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
1025 Elf64_External_Rela
* erelas
;
1027 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
1028 rel_size
, _("64-bit relocation data"));
1032 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
1034 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
1035 sizeof (Elf_Internal_Rela
));
1040 error (_("out of memory parsing relocs\n"));
1044 for (i
= 0; i
< nrelas
; i
++)
1046 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
1047 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
1048 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
1050 /* The #ifdef BFD64 below is to prevent a compile time
1051 warning. We know that if we do not have a 64 bit data
1052 type that we will never execute this code anyway. */
1054 if (filedata
->file_header
.e_machine
== EM_MIPS
1055 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1057 /* In little-endian objects, r_info isn't really a
1058 64-bit little-endian value: it has a 32-bit
1059 little-endian symbol index followed by four
1060 individual byte fields. Reorder INFO
1062 bfd_vma inf
= relas
[i
].r_info
;
1063 inf
= (((inf
& 0xffffffff) << 32)
1064 | ((inf
>> 56) & 0xff)
1065 | ((inf
>> 40) & 0xff00)
1066 | ((inf
>> 24) & 0xff0000)
1067 | ((inf
>> 8) & 0xff000000));
1068 relas
[i
].r_info
= inf
;
1081 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1082 Returns TRUE upon success, FALSE otherwise. If successful then a
1083 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1084 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1085 responsibility to free the allocated buffer. */
1088 slurp_rel_relocs (Filedata
* filedata
,
1089 unsigned long rel_offset
,
1090 unsigned long rel_size
,
1091 Elf_Internal_Rela
** relsp
,
1092 unsigned long * nrelsp
)
1094 Elf_Internal_Rela
* rels
;
1100 Elf32_External_Rel
* erels
;
1102 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1103 rel_size
, _("32-bit relocation data"));
1107 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1109 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1114 error (_("out of memory parsing relocs\n"));
1118 for (i
= 0; i
< nrels
; i
++)
1120 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1121 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1122 rels
[i
].r_addend
= 0;
1129 Elf64_External_Rel
* erels
;
1131 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1132 rel_size
, _("64-bit relocation data"));
1136 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1138 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1143 error (_("out of memory parsing relocs\n"));
1147 for (i
= 0; i
< nrels
; i
++)
1149 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1150 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1151 rels
[i
].r_addend
= 0;
1153 /* The #ifdef BFD64 below is to prevent a compile time
1154 warning. We know that if we do not have a 64 bit data
1155 type that we will never execute this code anyway. */
1157 if (filedata
->file_header
.e_machine
== EM_MIPS
1158 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1160 /* In little-endian objects, r_info isn't really a
1161 64-bit little-endian value: it has a 32-bit
1162 little-endian symbol index followed by four
1163 individual byte fields. Reorder INFO
1165 bfd_vma inf
= rels
[i
].r_info
;
1166 inf
= (((inf
& 0xffffffff) << 32)
1167 | ((inf
>> 56) & 0xff)
1168 | ((inf
>> 40) & 0xff00)
1169 | ((inf
>> 24) & 0xff0000)
1170 | ((inf
>> 8) & 0xff000000));
1171 rels
[i
].r_info
= inf
;
1184 /* Returns the reloc type extracted from the reloc info field. */
1187 get_reloc_type (Filedata
* filedata
, bfd_vma reloc_info
)
1190 return ELF32_R_TYPE (reloc_info
);
1192 switch (filedata
->file_header
.e_machine
)
1195 /* Note: We assume that reloc_info has already been adjusted for us. */
1196 return ELF64_MIPS_R_TYPE (reloc_info
);
1199 return ELF64_R_TYPE_ID (reloc_info
);
1202 return ELF64_R_TYPE (reloc_info
);
1206 /* Return the symbol index extracted from the reloc info field. */
1209 get_reloc_symindex (bfd_vma reloc_info
)
1211 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1215 uses_msp430x_relocs (Filedata
* filedata
)
1218 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1219 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1220 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1221 /* TI compiler uses ELFOSABI_NONE. */
1222 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1225 /* Display the contents of the relocation data found at the specified
1229 dump_relocations (Filedata
* filedata
,
1230 unsigned long rel_offset
,
1231 unsigned long rel_size
,
1232 Elf_Internal_Sym
* symtab
,
1233 unsigned long nsyms
,
1235 unsigned long strtablen
,
1240 Elf_Internal_Rela
* rels
;
1243 if (is_rela
== UNKNOWN
)
1244 is_rela
= guess_is_rela (filedata
->file_header
.e_machine
);
1248 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1253 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1262 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1264 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1269 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1271 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1279 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1281 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1286 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1288 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1292 for (i
= 0; i
< rel_size
; i
++)
1297 bfd_vma symtab_index
;
1300 offset
= rels
[i
].r_offset
;
1301 inf
= rels
[i
].r_info
;
1303 type
= get_reloc_type (filedata
, inf
);
1304 symtab_index
= get_reloc_symindex (inf
);
1308 printf ("%8.8lx %8.8lx ",
1309 (unsigned long) offset
& 0xffffffff,
1310 (unsigned long) inf
& 0xffffffff);
1315 ? "%16.16" BFD_VMA_FMT
"x %16.16" BFD_VMA_FMT
"x "
1316 : "%12.12" BFD_VMA_FMT
"x %12.12" BFD_VMA_FMT
"x ",
1320 switch (filedata
->file_header
.e_machine
)
1327 rtype
= elf_aarch64_reloc_type (type
);
1331 case EM_CYGNUS_M32R
:
1332 rtype
= elf_m32r_reloc_type (type
);
1337 rtype
= elf_i386_reloc_type (type
);
1342 rtype
= elf_m68hc11_reloc_type (type
);
1346 rtype
= elf_s12z_reloc_type (type
);
1350 rtype
= elf_m68k_reloc_type (type
);
1354 rtype
= elf_i960_reloc_type (type
);
1359 rtype
= elf_avr_reloc_type (type
);
1362 case EM_OLD_SPARCV9
:
1363 case EM_SPARC32PLUS
:
1366 rtype
= elf_sparc_reloc_type (type
);
1370 rtype
= elf_spu_reloc_type (type
);
1374 rtype
= v800_reloc_type (type
);
1377 case EM_CYGNUS_V850
:
1378 rtype
= v850_reloc_type (type
);
1382 case EM_CYGNUS_D10V
:
1383 rtype
= elf_d10v_reloc_type (type
);
1387 case EM_CYGNUS_D30V
:
1388 rtype
= elf_d30v_reloc_type (type
);
1392 rtype
= elf_dlx_reloc_type (type
);
1396 rtype
= elf_sh_reloc_type (type
);
1400 case EM_CYGNUS_MN10300
:
1401 rtype
= elf_mn10300_reloc_type (type
);
1405 case EM_CYGNUS_MN10200
:
1406 rtype
= elf_mn10200_reloc_type (type
);
1410 case EM_CYGNUS_FR30
:
1411 rtype
= elf_fr30_reloc_type (type
);
1415 rtype
= elf_frv_reloc_type (type
);
1419 rtype
= elf_csky_reloc_type (type
);
1423 rtype
= elf_ft32_reloc_type (type
);
1427 rtype
= elf_mcore_reloc_type (type
);
1431 rtype
= elf_mmix_reloc_type (type
);
1435 rtype
= elf_moxie_reloc_type (type
);
1439 if (uses_msp430x_relocs (filedata
))
1441 rtype
= elf_msp430x_reloc_type (type
);
1446 rtype
= elf_msp430_reloc_type (type
);
1450 rtype
= elf_nds32_reloc_type (type
);
1454 rtype
= elf_ppc_reloc_type (type
);
1458 rtype
= elf_ppc64_reloc_type (type
);
1462 case EM_MIPS_RS3_LE
:
1463 rtype
= elf_mips_reloc_type (type
);
1467 rtype
= elf_riscv_reloc_type (type
);
1471 rtype
= elf_alpha_reloc_type (type
);
1475 rtype
= elf_arm_reloc_type (type
);
1479 case EM_ARC_COMPACT
:
1480 case EM_ARC_COMPACT2
:
1481 rtype
= elf_arc_reloc_type (type
);
1485 rtype
= elf_hppa_reloc_type (type
);
1491 rtype
= elf_h8_reloc_type (type
);
1495 rtype
= elf_or1k_reloc_type (type
);
1500 rtype
= elf_pj_reloc_type (type
);
1503 rtype
= elf_ia64_reloc_type (type
);
1507 rtype
= elf_cris_reloc_type (type
);
1511 rtype
= elf_i860_reloc_type (type
);
1517 rtype
= elf_x86_64_reloc_type (type
);
1521 rtype
= i370_reloc_type (type
);
1526 rtype
= elf_s390_reloc_type (type
);
1530 rtype
= elf_score_reloc_type (type
);
1534 rtype
= elf_xstormy16_reloc_type (type
);
1538 rtype
= elf_crx_reloc_type (type
);
1542 rtype
= elf_vax_reloc_type (type
);
1546 rtype
= elf_visium_reloc_type (type
);
1550 rtype
= elf_bpf_reloc_type (type
);
1553 case EM_ADAPTEVA_EPIPHANY
:
1554 rtype
= elf_epiphany_reloc_type (type
);
1559 rtype
= elf_ip2k_reloc_type (type
);
1563 rtype
= elf_iq2000_reloc_type (type
);
1568 rtype
= elf_xtensa_reloc_type (type
);
1571 case EM_LATTICEMICO32
:
1572 rtype
= elf_lm32_reloc_type (type
);
1577 rtype
= elf_m32c_reloc_type (type
);
1581 rtype
= elf_mt_reloc_type (type
);
1585 rtype
= elf_bfin_reloc_type (type
);
1589 rtype
= elf_mep_reloc_type (type
);
1593 rtype
= elf_cr16_reloc_type (type
);
1597 case EM_MICROBLAZE_OLD
:
1598 rtype
= elf_microblaze_reloc_type (type
);
1602 rtype
= elf_rl78_reloc_type (type
);
1606 rtype
= elf_rx_reloc_type (type
);
1610 rtype
= elf_metag_reloc_type (type
);
1615 rtype
= elf_xc16x_reloc_type (type
);
1619 rtype
= elf_tic6x_reloc_type (type
);
1623 rtype
= elf_tilegx_reloc_type (type
);
1627 rtype
= elf_tilepro_reloc_type (type
);
1630 case EM_WEBASSEMBLY
:
1631 rtype
= elf_wasm32_reloc_type (type
);
1635 rtype
= elf_xgate_reloc_type (type
);
1638 case EM_ALTERA_NIOS2
:
1639 rtype
= elf_nios2_reloc_type (type
);
1643 rtype
= elf_pru_reloc_type (type
);
1647 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
1648 rtype
= elf_nfp3200_reloc_type (type
);
1650 rtype
= elf_nfp_reloc_type (type
);
1654 rtype
= elf_z80_reloc_type (type
);
1659 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1661 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1663 if (filedata
->file_header
.e_machine
== EM_ALPHA
1665 && streq (rtype
, "R_ALPHA_LITUSE")
1668 switch (rels
[i
].r_addend
)
1670 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1671 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1672 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1673 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1674 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1675 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1676 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1677 default: rtype
= NULL
;
1681 printf (" (%s)", rtype
);
1685 printf (_("<unknown addend: %lx>"),
1686 (unsigned long) rels
[i
].r_addend
);
1690 else if (symtab_index
)
1692 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1694 error (_(" bad symbol index: %08lx in reloc\n"),
1695 (unsigned long) symtab_index
);
1700 Elf_Internal_Sym
* psym
;
1701 const char * version_string
;
1702 enum versioned_symbol_info sym_info
;
1703 unsigned short vna_other
;
1705 psym
= symtab
+ symtab_index
;
1708 = get_symbol_version_string (filedata
, is_dynsym
,
1717 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1721 unsigned int width
= is_32bit_elf
? 8 : 14;
1723 /* Relocations against GNU_IFUNC symbols do not use the value
1724 of the symbol as the address to relocate against. Instead
1725 they invoke the function named by the symbol and use its
1726 result as the address for relocation.
1728 To indicate this to the user, do not display the value of
1729 the symbol in the "Symbols's Value" field. Instead show
1730 its name followed by () as a hint that the symbol is
1734 || psym
->st_name
== 0
1735 || psym
->st_name
>= strtablen
)
1738 name
= strtab
+ psym
->st_name
;
1740 len
= print_symbol (width
, name
);
1742 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1744 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1748 print_vma (psym
->st_value
, LONG_HEX
);
1750 printf (is_32bit_elf
? " " : " ");
1753 if (psym
->st_name
== 0)
1755 const char * sec_name
= "<null>";
1758 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1760 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
)
1761 sec_name
= SECTION_NAME_PRINT (filedata
->section_headers
1763 else if (psym
->st_shndx
== SHN_ABS
)
1765 else if (psym
->st_shndx
== SHN_COMMON
)
1766 sec_name
= "COMMON";
1767 else if ((filedata
->file_header
.e_machine
== EM_MIPS
1768 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1769 || (filedata
->file_header
.e_machine
== EM_TI_C6000
1770 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1771 sec_name
= "SCOMMON";
1772 else if (filedata
->file_header
.e_machine
== EM_MIPS
1773 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1774 sec_name
= "SUNDEF";
1775 else if ((filedata
->file_header
.e_machine
== EM_X86_64
1776 || filedata
->file_header
.e_machine
== EM_L1OM
1777 || filedata
->file_header
.e_machine
== EM_K1OM
)
1778 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1779 sec_name
= "LARGE_COMMON";
1780 else if (filedata
->file_header
.e_machine
== EM_IA_64
1781 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1782 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1783 sec_name
= "ANSI_COM";
1784 else if (is_ia64_vms (filedata
)
1785 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1786 sec_name
= "VMS_SYMVEC";
1789 sprintf (name_buf
, "<section 0x%x>",
1790 (unsigned int) psym
->st_shndx
);
1791 sec_name
= name_buf
;
1794 print_symbol (22, sec_name
);
1796 else if (strtab
== NULL
)
1797 printf (_("<string table index: %3ld>"), psym
->st_name
);
1798 else if (psym
->st_name
>= strtablen
)
1800 error (_("<corrupt string table index: %3ld>\n"),
1806 print_symbol (22, strtab
+ psym
->st_name
);
1808 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1814 bfd_vma off
= rels
[i
].r_addend
;
1816 if ((bfd_signed_vma
) off
< 0)
1817 printf (" - %" BFD_VMA_FMT
"x", - off
);
1819 printf (" + %" BFD_VMA_FMT
"x", off
);
1825 bfd_vma off
= rels
[i
].r_addend
;
1827 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1828 if ((bfd_signed_vma
) off
< 0)
1829 printf ("-%" BFD_VMA_FMT
"x", - off
);
1831 printf ("%" BFD_VMA_FMT
"x", off
);
1834 if (filedata
->file_header
.e_machine
== EM_SPARCV9
1836 && streq (rtype
, "R_SPARC_OLO10"))
1837 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1842 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
1844 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1845 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1846 const char * rtype2
= elf_mips_reloc_type (type2
);
1847 const char * rtype3
= elf_mips_reloc_type (type3
);
1849 printf (" Type2: ");
1852 printf (_("unrecognized: %-7lx"),
1853 (unsigned long) type2
& 0xffffffff);
1855 printf ("%-17.17s", rtype2
);
1857 printf ("\n Type3: ");
1860 printf (_("unrecognized: %-7lx"),
1861 (unsigned long) type3
& 0xffffffff);
1863 printf ("%-17.17s", rtype3
);
1876 get_aarch64_dynamic_type (unsigned long type
)
1880 case DT_AARCH64_BTI_PLT
: return "AARCH64_BTI_PLT";
1881 case DT_AARCH64_PAC_PLT
: return "AARCH64_PAC_PLT";
1882 case DT_AARCH64_VARIANT_PCS
: return "AARCH64_VARIANT_PCS";
1889 get_mips_dynamic_type (unsigned long type
)
1893 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1894 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1895 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1896 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1897 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1898 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1899 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1900 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1901 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1902 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1903 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1904 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1905 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1906 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1907 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1908 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1909 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1910 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1911 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1912 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1913 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1914 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1915 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1916 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1917 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1918 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1919 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1920 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1921 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1922 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1923 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1924 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1925 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1926 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1927 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1928 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1929 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1930 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1931 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1932 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1933 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1934 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1935 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1936 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1937 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1938 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1939 case DT_MIPS_XHASH
: return "MIPS_XHASH";
1946 get_sparc64_dynamic_type (unsigned long type
)
1950 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1957 get_ppc_dynamic_type (unsigned long type
)
1961 case DT_PPC_GOT
: return "PPC_GOT";
1962 case DT_PPC_OPT
: return "PPC_OPT";
1969 get_ppc64_dynamic_type (unsigned long type
)
1973 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1974 case DT_PPC64_OPD
: return "PPC64_OPD";
1975 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1976 case DT_PPC64_OPT
: return "PPC64_OPT";
1983 get_parisc_dynamic_type (unsigned long type
)
1987 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1988 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1989 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1990 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1991 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1992 case DT_HP_PREINIT
: return "HP_PREINIT";
1993 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1994 case DT_HP_NEEDED
: return "HP_NEEDED";
1995 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1996 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1997 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1998 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1999 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
2000 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
2001 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
2002 case DT_HP_FILTERED
: return "HP_FILTERED";
2003 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
2004 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
2005 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
2006 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
2007 case DT_PLT
: return "PLT";
2008 case DT_PLT_SIZE
: return "PLT_SIZE";
2009 case DT_DLT
: return "DLT";
2010 case DT_DLT_SIZE
: return "DLT_SIZE";
2017 get_ia64_dynamic_type (unsigned long type
)
2021 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
2022 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
2023 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
2024 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
2025 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
2026 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
2027 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
2028 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
2029 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
2030 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
2031 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
2032 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
2033 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
2034 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
2035 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
2036 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
2037 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
2038 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
2039 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
2040 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
2041 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
2042 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
2043 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
2044 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
2045 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
2046 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
2047 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
2048 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
2049 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
2050 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
2051 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
2058 get_solaris_section_type (unsigned long type
)
2062 case 0x6fffffee: return "SUNW_ancillary";
2063 case 0x6fffffef: return "SUNW_capchain";
2064 case 0x6ffffff0: return "SUNW_capinfo";
2065 case 0x6ffffff1: return "SUNW_symsort";
2066 case 0x6ffffff2: return "SUNW_tlssort";
2067 case 0x6ffffff3: return "SUNW_LDYNSYM";
2068 case 0x6ffffff4: return "SUNW_dof";
2069 case 0x6ffffff5: return "SUNW_cap";
2070 case 0x6ffffff6: return "SUNW_SIGNATURE";
2071 case 0x6ffffff7: return "SUNW_ANNOTATE";
2072 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2073 case 0x6ffffff9: return "SUNW_DEBUG";
2074 case 0x6ffffffa: return "SUNW_move";
2075 case 0x6ffffffb: return "SUNW_COMDAT";
2076 case 0x6ffffffc: return "SUNW_syminfo";
2077 case 0x6ffffffd: return "SUNW_verdef";
2078 case 0x6ffffffe: return "SUNW_verneed";
2079 case 0x6fffffff: return "SUNW_versym";
2080 case 0x70000000: return "SPARC_GOTDATA";
2081 default: return NULL
;
2086 get_alpha_dynamic_type (unsigned long type
)
2090 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2091 default: return NULL
;
2096 get_score_dynamic_type (unsigned long type
)
2100 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2101 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2102 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2103 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2104 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2105 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2106 default: return NULL
;
2111 get_tic6x_dynamic_type (unsigned long type
)
2115 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2116 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2117 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2118 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2119 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2120 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2121 default: return NULL
;
2126 get_nios2_dynamic_type (unsigned long type
)
2130 case DT_NIOS2_GP
: return "NIOS2_GP";
2131 default: return NULL
;
2136 get_solaris_dynamic_type (unsigned long type
)
2140 case 0x6000000d: return "SUNW_AUXILIARY";
2141 case 0x6000000e: return "SUNW_RTLDINF";
2142 case 0x6000000f: return "SUNW_FILTER";
2143 case 0x60000010: return "SUNW_CAP";
2144 case 0x60000011: return "SUNW_SYMTAB";
2145 case 0x60000012: return "SUNW_SYMSZ";
2146 case 0x60000013: return "SUNW_SORTENT";
2147 case 0x60000014: return "SUNW_SYMSORT";
2148 case 0x60000015: return "SUNW_SYMSORTSZ";
2149 case 0x60000016: return "SUNW_TLSSORT";
2150 case 0x60000017: return "SUNW_TLSSORTSZ";
2151 case 0x60000018: return "SUNW_CAPINFO";
2152 case 0x60000019: return "SUNW_STRPAD";
2153 case 0x6000001a: return "SUNW_CAPCHAIN";
2154 case 0x6000001b: return "SUNW_LDMACH";
2155 case 0x6000001d: return "SUNW_CAPCHAINENT";
2156 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2157 case 0x60000021: return "SUNW_PARENT";
2158 case 0x60000023: return "SUNW_ASLR";
2159 case 0x60000025: return "SUNW_RELAX";
2160 case 0x60000029: return "SUNW_NXHEAP";
2161 case 0x6000002b: return "SUNW_NXSTACK";
2163 case 0x70000001: return "SPARC_REGISTER";
2164 case 0x7ffffffd: return "AUXILIARY";
2165 case 0x7ffffffe: return "USED";
2166 case 0x7fffffff: return "FILTER";
2168 default: return NULL
;
2173 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2175 static char buff
[64];
2179 case DT_NULL
: return "NULL";
2180 case DT_NEEDED
: return "NEEDED";
2181 case DT_PLTRELSZ
: return "PLTRELSZ";
2182 case DT_PLTGOT
: return "PLTGOT";
2183 case DT_HASH
: return "HASH";
2184 case DT_STRTAB
: return "STRTAB";
2185 case DT_SYMTAB
: return "SYMTAB";
2186 case DT_RELA
: return "RELA";
2187 case DT_RELASZ
: return "RELASZ";
2188 case DT_RELAENT
: return "RELAENT";
2189 case DT_STRSZ
: return "STRSZ";
2190 case DT_SYMENT
: return "SYMENT";
2191 case DT_INIT
: return "INIT";
2192 case DT_FINI
: return "FINI";
2193 case DT_SONAME
: return "SONAME";
2194 case DT_RPATH
: return "RPATH";
2195 case DT_SYMBOLIC
: return "SYMBOLIC";
2196 case DT_REL
: return "REL";
2197 case DT_RELSZ
: return "RELSZ";
2198 case DT_RELENT
: return "RELENT";
2199 case DT_PLTREL
: return "PLTREL";
2200 case DT_DEBUG
: return "DEBUG";
2201 case DT_TEXTREL
: return "TEXTREL";
2202 case DT_JMPREL
: return "JMPREL";
2203 case DT_BIND_NOW
: return "BIND_NOW";
2204 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2205 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2206 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2207 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2208 case DT_RUNPATH
: return "RUNPATH";
2209 case DT_FLAGS
: return "FLAGS";
2211 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2212 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2213 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2215 case DT_CHECKSUM
: return "CHECKSUM";
2216 case DT_PLTPADSZ
: return "PLTPADSZ";
2217 case DT_MOVEENT
: return "MOVEENT";
2218 case DT_MOVESZ
: return "MOVESZ";
2219 case DT_FEATURE
: return "FEATURE";
2220 case DT_POSFLAG_1
: return "POSFLAG_1";
2221 case DT_SYMINSZ
: return "SYMINSZ";
2222 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2224 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2225 case DT_CONFIG
: return "CONFIG";
2226 case DT_DEPAUDIT
: return "DEPAUDIT";
2227 case DT_AUDIT
: return "AUDIT";
2228 case DT_PLTPAD
: return "PLTPAD";
2229 case DT_MOVETAB
: return "MOVETAB";
2230 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2232 case DT_VERSYM
: return "VERSYM";
2234 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2235 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2236 case DT_RELACOUNT
: return "RELACOUNT";
2237 case DT_RELCOUNT
: return "RELCOUNT";
2238 case DT_FLAGS_1
: return "FLAGS_1";
2239 case DT_VERDEF
: return "VERDEF";
2240 case DT_VERDEFNUM
: return "VERDEFNUM";
2241 case DT_VERNEED
: return "VERNEED";
2242 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2244 case DT_AUXILIARY
: return "AUXILIARY";
2245 case DT_USED
: return "USED";
2246 case DT_FILTER
: return "FILTER";
2248 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2249 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2250 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2251 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2252 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2253 case DT_GNU_HASH
: return "GNU_HASH";
2254 case DT_GNU_FLAGS_1
: return "GNU_FLAGS_1";
2257 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2259 const char * result
;
2261 switch (filedata
->file_header
.e_machine
)
2264 result
= get_aarch64_dynamic_type (type
);
2267 case EM_MIPS_RS3_LE
:
2268 result
= get_mips_dynamic_type (type
);
2271 result
= get_sparc64_dynamic_type (type
);
2274 result
= get_ppc_dynamic_type (type
);
2277 result
= get_ppc64_dynamic_type (type
);
2280 result
= get_ia64_dynamic_type (type
);
2283 result
= get_alpha_dynamic_type (type
);
2286 result
= get_score_dynamic_type (type
);
2289 result
= get_tic6x_dynamic_type (type
);
2291 case EM_ALTERA_NIOS2
:
2292 result
= get_nios2_dynamic_type (type
);
2295 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2296 result
= get_solaris_dynamic_type (type
);
2305 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2307 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2308 || (filedata
->file_header
.e_machine
== EM_PARISC
2309 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2311 const char * result
;
2313 switch (filedata
->file_header
.e_machine
)
2316 result
= get_parisc_dynamic_type (type
);
2319 result
= get_ia64_dynamic_type (type
);
2322 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2323 result
= get_solaris_dynamic_type (type
);
2332 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2336 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2343 get_file_type (unsigned e_type
)
2345 static char buff
[64];
2349 case ET_NONE
: return _("NONE (None)");
2350 case ET_REL
: return _("REL (Relocatable file)");
2351 case ET_EXEC
: return _("EXEC (Executable file)");
2352 case ET_DYN
: return _("DYN (Shared object file)");
2353 case ET_CORE
: return _("CORE (Core file)");
2356 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2357 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2358 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2359 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2361 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2367 get_machine_name (unsigned e_machine
)
2369 static char buff
[64]; /* XXX */
2373 /* Please keep this switch table sorted by increasing EM_ value. */
2375 case EM_NONE
: return _("None");
2376 case EM_M32
: return "WE32100";
2377 case EM_SPARC
: return "Sparc";
2378 case EM_386
: return "Intel 80386";
2379 case EM_68K
: return "MC68000";
2380 case EM_88K
: return "MC88000";
2381 case EM_IAMCU
: return "Intel MCU";
2382 case EM_860
: return "Intel 80860";
2383 case EM_MIPS
: return "MIPS R3000";
2384 case EM_S370
: return "IBM System/370";
2386 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2387 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2388 case EM_PARISC
: return "HPPA";
2389 case EM_VPP550
: return "Fujitsu VPP500";
2390 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2391 case EM_960
: return "Intel 80960";
2392 case EM_PPC
: return "PowerPC";
2394 case EM_PPC64
: return "PowerPC64";
2396 case EM_S390
: return "IBM S/390";
2397 case EM_SPU
: return "SPU";
2399 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2400 case EM_FR20
: return "Fujitsu FR20";
2401 case EM_RH32
: return "TRW RH32";
2402 case EM_MCORE
: return "MCORE";
2404 case EM_ARM
: return "ARM";
2405 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2406 case EM_SH
: return "Renesas / SuperH SH";
2407 case EM_SPARCV9
: return "Sparc v9";
2408 case EM_TRICORE
: return "Siemens Tricore";
2409 case EM_ARC
: return "ARC";
2410 case EM_H8_300
: return "Renesas H8/300";
2411 case EM_H8_300H
: return "Renesas H8/300H";
2412 case EM_H8S
: return "Renesas H8S";
2413 case EM_H8_500
: return "Renesas H8/500";
2415 case EM_IA_64
: return "Intel IA-64";
2416 case EM_MIPS_X
: return "Stanford MIPS-X";
2417 case EM_COLDFIRE
: return "Motorola Coldfire";
2418 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2419 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2420 case EM_PCP
: return "Siemens PCP";
2421 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2422 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2423 case EM_STARCORE
: return "Motorola Star*Core processor";
2424 case EM_ME16
: return "Toyota ME16 processor";
2426 case EM_ST100
: return "STMicroelectronics ST100 processor";
2427 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2428 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2429 case EM_PDSP
: return "Sony DSP processor";
2430 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2431 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2432 case EM_FX66
: return "Siemens FX66 microcontroller";
2433 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2434 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2435 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2437 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2438 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2439 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2440 case EM_SVX
: return "Silicon Graphics SVx";
2441 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2442 case EM_VAX
: return "Digital VAX";
2443 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2444 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2445 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2446 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2448 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2449 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2450 case EM_PRISM
: return "Vitesse Prism";
2452 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2453 case EM_CYGNUS_FR30
:
2454 case EM_FR30
: return "Fujitsu FR30";
2455 case EM_CYGNUS_D10V
:
2456 case EM_D10V
: return "d10v";
2457 case EM_CYGNUS_D30V
:
2458 case EM_D30V
: return "d30v";
2459 case EM_CYGNUS_V850
:
2460 case EM_V850
: return "Renesas V850";
2461 case EM_CYGNUS_M32R
:
2462 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2463 case EM_CYGNUS_MN10300
:
2464 case EM_MN10300
: return "mn10300";
2466 case EM_CYGNUS_MN10200
:
2467 case EM_MN10200
: return "mn10200";
2468 case EM_PJ
: return "picoJava";
2469 case EM_OR1K
: return "OpenRISC 1000";
2470 case EM_ARC_COMPACT
: return "ARCompact";
2472 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2473 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2474 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2475 case EM_NS32K
: return "National Semiconductor 32000 series";
2476 case EM_TPC
: return "Tenor Network TPC processor";
2477 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2479 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2481 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2482 case EM_MAX
: return "MAX Processor";
2483 case EM_CR
: return "National Semiconductor CompactRISC";
2484 case EM_F2MC16
: return "Fujitsu F2MC16";
2485 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2486 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2487 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2488 case EM_SEP
: return "Sharp embedded microprocessor";
2489 case EM_ARCA
: return "Arca RISC microprocessor";
2491 case EM_UNICORE
: return "Unicore";
2492 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2493 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2494 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2495 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2496 case EM_XGATE
: return "Motorola XGATE embedded processor";
2498 case EM_XC16X
: return "Infineon Technologies xc16x";
2499 case EM_M16C
: return "Renesas M16C series microprocessors";
2500 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2501 case EM_CE
: return "Freescale Communication Engine RISC core";
2503 case EM_M32C
: return "Renesas M32c";
2505 case EM_TSK3000
: return "Altium TSK3000 core";
2506 case EM_RS08
: return "Freescale RS08 embedded processor";
2507 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2508 case EM_SCORE
: return "SUNPLUS S+Core";
2509 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2510 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2511 case EM_LATTICEMICO32
: return "Lattice Mico32";
2512 case EM_SE_C17
: return "Seiko Epson C17 family";
2514 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2515 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2516 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2517 case EM_TI_PRU
: return "TI PRU I/O processor";
2519 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2520 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2521 case EM_R32C
: return "Renesas R32C series microprocessors";
2522 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2523 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2524 case EM_8051
: return "Intel 8051 and variants";
2525 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2526 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2527 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2528 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2530 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2531 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2532 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2533 case EM_RX
: return "Renesas RX";
2534 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2535 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2536 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2539 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2540 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2541 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2543 case EM_L1OM
: return "Intel L1OM";
2544 case EM_K1OM
: return "Intel K1OM";
2545 case EM_INTEL182
: return "Intel (reserved)";
2546 case EM_AARCH64
: return "AArch64";
2547 case EM_ARM184
: return "ARM (reserved)";
2548 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2549 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2550 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2551 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2553 case EM_CUDA
: return "NVIDIA CUDA architecture";
2554 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2555 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2556 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2557 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2558 case EM_ARC_COMPACT2
: return "ARCv2";
2559 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2560 case EM_RL78
: return "Renesas RL78";
2561 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2562 case EM_78K0R
: return "Renesas 78K0R";
2564 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2565 case EM_BA1
: return "Beyond BA1 CPU architecture";
2566 case EM_BA2
: return "Beyond BA2 CPU architecture";
2567 case EM_XCORE
: return "XMOS xCORE processor family";
2568 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2569 case EM_INTELGT
: return "Intel Graphics Technology";
2571 case EM_KM32
: return "KM211 KM32 32-bit processor";
2572 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2573 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2574 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2575 case EM_KVARC
: return "KM211 KVARC processor";
2576 case EM_CDP
: return "Paneve CDP architecture family";
2577 case EM_COGE
: return "Cognitive Smart Memory Processor";
2578 case EM_COOL
: return "Bluechip Systems CoolEngine";
2579 case EM_NORC
: return "Nanoradio Optimized RISC";
2580 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2582 case EM_Z80
: return "Zilog Z80";
2583 case EM_VISIUM
: return "CDS VISIUMcore processor";
2584 case EM_FT32
: return "FTDI Chip FT32";
2585 case EM_MOXIE
: return "Moxie";
2586 case EM_AMDGPU
: return "AMD GPU";
2587 /* 230 (all reserved) */
2589 case EM_RISCV
: return "RISC-V";
2590 case EM_LANAI
: return "Lanai 32-bit processor";
2591 case EM_CEVA
: return "CEVA Processor Architecture Family";
2592 case EM_CEVA_X2
: return "CEVA X2 Processor Family";
2593 case EM_BPF
: return "Linux BPF";
2594 case EM_GRAPHCORE_IPU
: return "Graphcore Intelligent Processing Unit";
2595 case EM_IMG1
: return "Imagination Technologies";
2597 case EM_NFP
: return "Netronome Flow Processor";
2598 case EM_VE
: return "NEC Vector Engine";
2599 case EM_CSKY
: return "C-SKY";
2600 case EM_ARC_COMPACT3_64
: return "Synopsys ARCv2.3 64-bit";
2601 case EM_MCS6502
: return "MOS Technology MCS 6502 processor";
2602 case EM_ARC_COMPACT3
: return "Synopsys ARCv2.3 32-bit";
2603 case EM_KVX
: return "Kalray VLIW core of the MPPA processor family";
2604 case EM_65816
: return "WDC 65816/65C816";
2605 case EM_LOONGARCH
: return "LoongArch";
2606 case EM_KF32
: return "ChipON KungFu32";
2608 /* Large numbers... */
2609 case EM_MT
: return "Morpho Techologies MT processor";
2610 case EM_ALPHA
: return "Alpha";
2611 case EM_WEBASSEMBLY
: return "Web Assembly";
2612 case EM_DLX
: return "OpenDLX";
2613 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2614 case EM_IQ2000
: return "Vitesse IQ2000";
2616 case EM_NIOS32
: return "Altera Nios";
2617 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2618 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2619 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2620 case EM_S12Z
: return "Freescale S12Z";
2623 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2629 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2631 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2632 other compilers don't specify an architecture type in the e_flags, and
2633 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2634 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2637 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2638 but also sets a specific architecture type in the e_flags field.
2640 However, when decoding the flags we don't worry if we see an
2641 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2642 ARCEM architecture type. */
2644 switch (e_flags
& EF_ARC_MACH_MSK
)
2646 /* We only expect these to occur for EM_ARC_COMPACT2. */
2647 case EF_ARC_CPU_ARCV2EM
:
2648 strcat (buf
, ", ARC EM");
2650 case EF_ARC_CPU_ARCV2HS
:
2651 strcat (buf
, ", ARC HS");
2654 /* We only expect these to occur for EM_ARC_COMPACT. */
2655 case E_ARC_MACH_ARC600
:
2656 strcat (buf
, ", ARC600");
2658 case E_ARC_MACH_ARC601
:
2659 strcat (buf
, ", ARC601");
2661 case E_ARC_MACH_ARC700
:
2662 strcat (buf
, ", ARC700");
2665 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2666 new ELF with new architecture being read by an old version of
2667 readelf, or (c) An ELF built with non-GNU compiler that does not
2668 set the architecture in the e_flags. */
2670 if (e_machine
== EM_ARC_COMPACT
)
2671 strcat (buf
, ", Unknown ARCompact");
2673 strcat (buf
, ", Unknown ARC");
2677 switch (e_flags
& EF_ARC_OSABI_MSK
)
2679 case E_ARC_OSABI_ORIG
:
2680 strcat (buf
, ", (ABI:legacy)");
2682 case E_ARC_OSABI_V2
:
2683 strcat (buf
, ", (ABI:v2)");
2685 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2686 case E_ARC_OSABI_V3
:
2687 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2689 case E_ARC_OSABI_V4
:
2690 strcat (buf
, ", v4 ABI");
2693 strcat (buf
, ", unrecognised ARC OSABI flag");
2699 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2702 bool unknown
= false;
2704 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2705 e_flags
&= ~ EF_ARM_EABIMASK
;
2707 /* Handle "generic" ARM flags. */
2708 if (e_flags
& EF_ARM_RELEXEC
)
2710 strcat (buf
, ", relocatable executable");
2711 e_flags
&= ~ EF_ARM_RELEXEC
;
2714 if (e_flags
& EF_ARM_PIC
)
2716 strcat (buf
, ", position independent");
2717 e_flags
&= ~ EF_ARM_PIC
;
2720 /* Now handle EABI specific flags. */
2724 strcat (buf
, ", <unrecognized EABI>");
2729 case EF_ARM_EABI_VER1
:
2730 strcat (buf
, ", Version1 EABI");
2735 /* Process flags one bit at a time. */
2736 flag
= e_flags
& - e_flags
;
2741 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2742 strcat (buf
, ", sorted symbol tables");
2752 case EF_ARM_EABI_VER2
:
2753 strcat (buf
, ", Version2 EABI");
2758 /* Process flags one bit at a time. */
2759 flag
= e_flags
& - e_flags
;
2764 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2765 strcat (buf
, ", sorted symbol tables");
2768 case EF_ARM_DYNSYMSUSESEGIDX
:
2769 strcat (buf
, ", dynamic symbols use segment index");
2772 case EF_ARM_MAPSYMSFIRST
:
2773 strcat (buf
, ", mapping symbols precede others");
2783 case EF_ARM_EABI_VER3
:
2784 strcat (buf
, ", Version3 EABI");
2787 case EF_ARM_EABI_VER4
:
2788 strcat (buf
, ", Version4 EABI");
2793 /* Process flags one bit at a time. */
2794 flag
= e_flags
& - e_flags
;
2800 strcat (buf
, ", BE8");
2804 strcat (buf
, ", LE8");
2814 case EF_ARM_EABI_VER5
:
2815 strcat (buf
, ", Version5 EABI");
2820 /* Process flags one bit at a time. */
2821 flag
= e_flags
& - e_flags
;
2827 strcat (buf
, ", BE8");
2831 strcat (buf
, ", LE8");
2834 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2835 strcat (buf
, ", soft-float ABI");
2838 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2839 strcat (buf
, ", hard-float ABI");
2849 case EF_ARM_EABI_UNKNOWN
:
2850 strcat (buf
, ", GNU EABI");
2855 /* Process flags one bit at a time. */
2856 flag
= e_flags
& - e_flags
;
2861 case EF_ARM_INTERWORK
:
2862 strcat (buf
, ", interworking enabled");
2865 case EF_ARM_APCS_26
:
2866 strcat (buf
, ", uses APCS/26");
2869 case EF_ARM_APCS_FLOAT
:
2870 strcat (buf
, ", uses APCS/float");
2874 strcat (buf
, ", position independent");
2878 strcat (buf
, ", 8 bit structure alignment");
2881 case EF_ARM_NEW_ABI
:
2882 strcat (buf
, ", uses new ABI");
2885 case EF_ARM_OLD_ABI
:
2886 strcat (buf
, ", uses old ABI");
2889 case EF_ARM_SOFT_FLOAT
:
2890 strcat (buf
, ", software FP");
2893 case EF_ARM_VFP_FLOAT
:
2894 strcat (buf
, ", VFP");
2897 case EF_ARM_MAVERICK_FLOAT
:
2898 strcat (buf
, ", Maverick FP");
2909 strcat (buf
,_(", <unknown>"));
2913 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2915 --size
; /* Leave space for null terminator. */
2917 switch (e_flags
& EF_AVR_MACH
)
2919 case E_AVR_MACH_AVR1
:
2920 strncat (buf
, ", avr:1", size
);
2922 case E_AVR_MACH_AVR2
:
2923 strncat (buf
, ", avr:2", size
);
2925 case E_AVR_MACH_AVR25
:
2926 strncat (buf
, ", avr:25", size
);
2928 case E_AVR_MACH_AVR3
:
2929 strncat (buf
, ", avr:3", size
);
2931 case E_AVR_MACH_AVR31
:
2932 strncat (buf
, ", avr:31", size
);
2934 case E_AVR_MACH_AVR35
:
2935 strncat (buf
, ", avr:35", size
);
2937 case E_AVR_MACH_AVR4
:
2938 strncat (buf
, ", avr:4", size
);
2940 case E_AVR_MACH_AVR5
:
2941 strncat (buf
, ", avr:5", size
);
2943 case E_AVR_MACH_AVR51
:
2944 strncat (buf
, ", avr:51", size
);
2946 case E_AVR_MACH_AVR6
:
2947 strncat (buf
, ", avr:6", size
);
2949 case E_AVR_MACH_AVRTINY
:
2950 strncat (buf
, ", avr:100", size
);
2952 case E_AVR_MACH_XMEGA1
:
2953 strncat (buf
, ", avr:101", size
);
2955 case E_AVR_MACH_XMEGA2
:
2956 strncat (buf
, ", avr:102", size
);
2958 case E_AVR_MACH_XMEGA3
:
2959 strncat (buf
, ", avr:103", size
);
2961 case E_AVR_MACH_XMEGA4
:
2962 strncat (buf
, ", avr:104", size
);
2964 case E_AVR_MACH_XMEGA5
:
2965 strncat (buf
, ", avr:105", size
);
2967 case E_AVR_MACH_XMEGA6
:
2968 strncat (buf
, ", avr:106", size
);
2970 case E_AVR_MACH_XMEGA7
:
2971 strncat (buf
, ", avr:107", size
);
2974 strncat (buf
, ", avr:<unknown>", size
);
2978 size
-= strlen (buf
);
2979 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2980 strncat (buf
, ", link-relax", size
);
2984 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2990 bool has_fpu
= false;
2993 static const char *ABI_STRINGS
[] =
2995 "ABI v0", /* use r5 as return register; only used in N1213HC */
2996 "ABI v1", /* use r0 as return register */
2997 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2998 "ABI v2fp", /* for FPU */
3002 static const char *VER_STRINGS
[] =
3004 "Andes ELF V1.3 or older",
3008 static const char *ARCH_STRINGS
[] =
3017 abi
= EF_NDS_ABI
& e_flags
;
3018 arch
= EF_NDS_ARCH
& e_flags
;
3019 config
= EF_NDS_INST
& e_flags
;
3020 version
= EF_NDS32_ELF_VERSION
& e_flags
;
3022 memset (buf
, 0, size
);
3029 case E_NDS_ABI_V2FP
:
3030 case E_NDS_ABI_AABI
:
3031 case E_NDS_ABI_V2FP_PLUS
:
3032 /* In case there are holes in the array. */
3033 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
3037 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
3043 case E_NDS32_ELF_VER_1_2
:
3044 case E_NDS32_ELF_VER_1_3
:
3045 case E_NDS32_ELF_VER_1_4
:
3046 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
3050 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
3054 if (E_NDS_ABI_V0
== abi
)
3056 /* OLD ABI; only used in N1213HC, has performance extension 1. */
3057 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
3058 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3059 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
3065 case E_NDS_ARCH_STAR_V1_0
:
3066 case E_NDS_ARCH_STAR_V2_0
:
3067 case E_NDS_ARCH_STAR_V3_0
:
3068 case E_NDS_ARCH_STAR_V3_M
:
3069 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
3073 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
3074 /* ARCH version determines how the e_flags are interpreted.
3075 If it is unknown, we cannot proceed. */
3079 /* Newer ABI; Now handle architecture specific flags. */
3080 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3082 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3083 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
3085 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
3086 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
3088 if (config
& E_NDS32_HAS_DIV_INST
)
3089 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
3091 if (config
& E_NDS32_HAS_16BIT_INST
)
3092 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3096 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3098 if (version
<= E_NDS32_ELF_VER_1_3
)
3099 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
3101 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
3104 if (config
& E_NDS32_HAS_MAC_DX_INST
)
3105 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
3107 if (config
& E_NDS32_HAS_DIV_DX_INST
)
3108 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
3110 if (config
& E_NDS32_HAS_16BIT_INST
)
3112 if (version
<= E_NDS32_ELF_VER_1_3
)
3113 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3115 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3119 if (config
& E_NDS32_HAS_EXT_INST
)
3120 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3122 if (config
& E_NDS32_HAS_EXT2_INST
)
3123 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3125 if (config
& E_NDS32_HAS_FPU_INST
)
3128 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3131 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3134 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3137 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3140 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3145 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3147 case E_NDS32_FPU_REG_8SP_4DP
:
3148 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3150 case E_NDS32_FPU_REG_16SP_8DP
:
3151 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3153 case E_NDS32_FPU_REG_32SP_16DP
:
3154 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3156 case E_NDS32_FPU_REG_32SP_32DP
:
3157 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3162 if (config
& E_NDS32_HAS_AUDIO_INST
)
3163 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3165 if (config
& E_NDS32_HAS_STRING_INST
)
3166 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3168 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3169 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3171 if (config
& E_NDS32_HAS_VIDEO_INST
)
3173 if (version
<= E_NDS32_ELF_VER_1_3
)
3174 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3176 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3179 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3180 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3182 if (config
& E_NDS32_HAS_L2C_INST
)
3183 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3187 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3189 static char buf
[1024];
3200 case EM_ARC_COMPACT2
:
3201 case EM_ARC_COMPACT
:
3202 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3206 decode_ARM_machine_flags (e_flags
, buf
);
3210 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3214 if (e_flags
& EF_BFIN_PIC
)
3215 strcat (buf
, ", PIC");
3217 if (e_flags
& EF_BFIN_FDPIC
)
3218 strcat (buf
, ", FDPIC");
3220 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3221 strcat (buf
, ", code in L1");
3223 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3224 strcat (buf
, ", data in L1");
3229 switch (e_flags
& EF_FRV_CPU_MASK
)
3231 case EF_FRV_CPU_GENERIC
:
3235 strcat (buf
, ", fr???");
3238 case EF_FRV_CPU_FR300
:
3239 strcat (buf
, ", fr300");
3242 case EF_FRV_CPU_FR400
:
3243 strcat (buf
, ", fr400");
3245 case EF_FRV_CPU_FR405
:
3246 strcat (buf
, ", fr405");
3249 case EF_FRV_CPU_FR450
:
3250 strcat (buf
, ", fr450");
3253 case EF_FRV_CPU_FR500
:
3254 strcat (buf
, ", fr500");
3256 case EF_FRV_CPU_FR550
:
3257 strcat (buf
, ", fr550");
3260 case EF_FRV_CPU_SIMPLE
:
3261 strcat (buf
, ", simple");
3263 case EF_FRV_CPU_TOMCAT
:
3264 strcat (buf
, ", tomcat");
3270 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3271 strcat (buf
, ", m68000");
3272 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3273 strcat (buf
, ", cpu32");
3274 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3275 strcat (buf
, ", fido_a");
3278 char const * isa
= _("unknown");
3279 char const * mac
= _("unknown mac");
3280 char const * additional
= NULL
;
3282 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3284 case EF_M68K_CF_ISA_A_NODIV
:
3286 additional
= ", nodiv";
3288 case EF_M68K_CF_ISA_A
:
3291 case EF_M68K_CF_ISA_A_PLUS
:
3294 case EF_M68K_CF_ISA_B_NOUSP
:
3296 additional
= ", nousp";
3298 case EF_M68K_CF_ISA_B
:
3301 case EF_M68K_CF_ISA_C
:
3304 case EF_M68K_CF_ISA_C_NODIV
:
3306 additional
= ", nodiv";
3309 strcat (buf
, ", cf, isa ");
3312 strcat (buf
, additional
);
3313 if (e_flags
& EF_M68K_CF_FLOAT
)
3314 strcat (buf
, ", float");
3315 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3320 case EF_M68K_CF_MAC
:
3323 case EF_M68K_CF_EMAC
:
3326 case EF_M68K_CF_EMAC_B
:
3339 switch (e_flags
& EF_MEP_CPU_MASK
)
3341 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3342 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3343 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3344 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3345 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3346 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3347 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3350 switch (e_flags
& EF_MEP_COP_MASK
)
3352 case EF_MEP_COP_NONE
: break;
3353 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3354 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3355 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3356 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3357 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3360 if (e_flags
& EF_MEP_LIBRARY
)
3361 strcat (buf
, ", Built for Library");
3363 if (e_flags
& EF_MEP_INDEX_MASK
)
3364 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3365 e_flags
& EF_MEP_INDEX_MASK
);
3367 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3368 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3369 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3373 if (e_flags
& EF_PPC_EMB
)
3374 strcat (buf
, ", emb");
3376 if (e_flags
& EF_PPC_RELOCATABLE
)
3377 strcat (buf
, _(", relocatable"));
3379 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3380 strcat (buf
, _(", relocatable-lib"));
3384 if (e_flags
& EF_PPC64_ABI
)
3386 char abi
[] = ", abiv0";
3388 abi
[6] += e_flags
& EF_PPC64_ABI
;
3394 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3395 strcat (buf
, ", RH850 ABI");
3397 if (e_flags
& EF_V800_850E3
)
3398 strcat (buf
, ", V3 architecture");
3400 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3401 strcat (buf
, ", FPU not used");
3403 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3404 strcat (buf
, ", regmode: COMMON");
3406 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3407 strcat (buf
, ", r4 not used");
3409 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3410 strcat (buf
, ", r30 not used");
3412 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3413 strcat (buf
, ", r5 not used");
3415 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3416 strcat (buf
, ", r2 not used");
3418 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3420 switch (e_flags
& - e_flags
)
3422 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3423 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3424 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3425 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3426 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3427 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3428 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3429 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3430 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3431 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3432 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3433 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3440 case EM_CYGNUS_V850
:
3441 switch (e_flags
& EF_V850_ARCH
)
3443 case E_V850E3V5_ARCH
:
3444 strcat (buf
, ", v850e3v5");
3446 case E_V850E2V3_ARCH
:
3447 strcat (buf
, ", v850e2v3");
3450 strcat (buf
, ", v850e2");
3453 strcat (buf
, ", v850e1");
3456 strcat (buf
, ", v850e");
3459 strcat (buf
, ", v850");
3462 strcat (buf
, _(", unknown v850 architecture variant"));
3468 case EM_CYGNUS_M32R
:
3469 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3470 strcat (buf
, ", m32r");
3474 case EM_MIPS_RS3_LE
:
3475 if (e_flags
& EF_MIPS_NOREORDER
)
3476 strcat (buf
, ", noreorder");
3478 if (e_flags
& EF_MIPS_PIC
)
3479 strcat (buf
, ", pic");
3481 if (e_flags
& EF_MIPS_CPIC
)
3482 strcat (buf
, ", cpic");
3484 if (e_flags
& EF_MIPS_UCODE
)
3485 strcat (buf
, ", ugen_reserved");
3487 if (e_flags
& EF_MIPS_ABI2
)
3488 strcat (buf
, ", abi2");
3490 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3491 strcat (buf
, ", odk first");
3493 if (e_flags
& EF_MIPS_32BITMODE
)
3494 strcat (buf
, ", 32bitmode");
3496 if (e_flags
& EF_MIPS_NAN2008
)
3497 strcat (buf
, ", nan2008");
3499 if (e_flags
& EF_MIPS_FP64
)
3500 strcat (buf
, ", fp64");
3502 switch ((e_flags
& EF_MIPS_MACH
))
3504 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3505 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3506 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3507 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3508 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3509 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3510 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3511 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3512 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3513 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3514 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3515 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3516 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3517 case E_MIPS_MACH_GS464
: strcat (buf
, ", gs464"); break;
3518 case E_MIPS_MACH_GS464E
: strcat (buf
, ", gs464e"); break;
3519 case E_MIPS_MACH_GS264E
: strcat (buf
, ", gs264e"); break;
3520 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3521 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3522 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3523 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3524 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3526 /* We simply ignore the field in this case to avoid confusion:
3527 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3530 default: strcat (buf
, _(", unknown CPU")); break;
3533 switch ((e_flags
& EF_MIPS_ABI
))
3535 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3536 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3537 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3538 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3540 /* We simply ignore the field in this case to avoid confusion:
3541 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3542 This means it is likely to be an o32 file, but not for
3545 default: strcat (buf
, _(", unknown ABI")); break;
3548 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3549 strcat (buf
, ", mdmx");
3551 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3552 strcat (buf
, ", mips16");
3554 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3555 strcat (buf
, ", micromips");
3557 switch ((e_flags
& EF_MIPS_ARCH
))
3559 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3560 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3561 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3562 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3563 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3564 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3565 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3566 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3567 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3568 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3569 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3570 default: strcat (buf
, _(", unknown ISA")); break;
3575 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3579 switch (EF_NFP_MACH (e_flags
))
3581 case E_NFP_MACH_3200
:
3582 strcat (buf
, ", NFP-32xx");
3584 case E_NFP_MACH_6000
:
3585 strcat (buf
, ", NFP-6xxx");
3591 if (e_flags
& EF_RISCV_RVC
)
3592 strcat (buf
, ", RVC");
3594 if (e_flags
& EF_RISCV_RVE
)
3595 strcat (buf
, ", RVE");
3597 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3599 case EF_RISCV_FLOAT_ABI_SOFT
:
3600 strcat (buf
, ", soft-float ABI");
3603 case EF_RISCV_FLOAT_ABI_SINGLE
:
3604 strcat (buf
, ", single-float ABI");
3607 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3608 strcat (buf
, ", double-float ABI");
3611 case EF_RISCV_FLOAT_ABI_QUAD
:
3612 strcat (buf
, ", quad-float ABI");
3618 switch ((e_flags
& EF_SH_MACH_MASK
))
3620 case EF_SH1
: strcat (buf
, ", sh1"); break;
3621 case EF_SH2
: strcat (buf
, ", sh2"); break;
3622 case EF_SH3
: strcat (buf
, ", sh3"); break;
3623 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3624 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3625 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3626 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3627 case EF_SH4
: strcat (buf
, ", sh4"); break;
3628 case EF_SH5
: strcat (buf
, ", sh5"); break;
3629 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3630 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3631 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3632 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3633 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3634 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3635 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3636 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3637 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3638 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3639 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3640 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3641 default: strcat (buf
, _(", unknown ISA")); break;
3644 if (e_flags
& EF_SH_PIC
)
3645 strcat (buf
, ", pic");
3647 if (e_flags
& EF_SH_FDPIC
)
3648 strcat (buf
, ", fdpic");
3652 if (e_flags
& EF_OR1K_NODELAY
)
3653 strcat (buf
, ", no delay");
3657 if (e_flags
& EF_SPARC_32PLUS
)
3658 strcat (buf
, ", v8+");
3660 if (e_flags
& EF_SPARC_SUN_US1
)
3661 strcat (buf
, ", ultrasparcI");
3663 if (e_flags
& EF_SPARC_SUN_US3
)
3664 strcat (buf
, ", ultrasparcIII");
3666 if (e_flags
& EF_SPARC_HAL_R1
)
3667 strcat (buf
, ", halr1");
3669 if (e_flags
& EF_SPARC_LEDATA
)
3670 strcat (buf
, ", ledata");
3672 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3673 strcat (buf
, ", tso");
3675 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3676 strcat (buf
, ", pso");
3678 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3679 strcat (buf
, ", rmo");
3683 switch (e_flags
& EF_PARISC_ARCH
)
3685 case EFA_PARISC_1_0
:
3686 strcpy (buf
, ", PA-RISC 1.0");
3688 case EFA_PARISC_1_1
:
3689 strcpy (buf
, ", PA-RISC 1.1");
3691 case EFA_PARISC_2_0
:
3692 strcpy (buf
, ", PA-RISC 2.0");
3697 if (e_flags
& EF_PARISC_TRAPNIL
)
3698 strcat (buf
, ", trapnil");
3699 if (e_flags
& EF_PARISC_EXT
)
3700 strcat (buf
, ", ext");
3701 if (e_flags
& EF_PARISC_LSB
)
3702 strcat (buf
, ", lsb");
3703 if (e_flags
& EF_PARISC_WIDE
)
3704 strcat (buf
, ", wide");
3705 if (e_flags
& EF_PARISC_NO_KABP
)
3706 strcat (buf
, ", no kabp");
3707 if (e_flags
& EF_PARISC_LAZYSWAP
)
3708 strcat (buf
, ", lazyswap");
3713 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3714 strcat (buf
, ", new calling convention");
3716 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3717 strcat (buf
, ", gnu calling convention");
3721 if ((e_flags
& EF_IA_64_ABI64
))
3722 strcat (buf
, ", 64-bit");
3724 strcat (buf
, ", 32-bit");
3725 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3726 strcat (buf
, ", reduced fp model");
3727 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3728 strcat (buf
, ", no function descriptors, constant gp");
3729 else if ((e_flags
& EF_IA_64_CONS_GP
))
3730 strcat (buf
, ", constant gp");
3731 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3732 strcat (buf
, ", absolute");
3733 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3735 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3736 strcat (buf
, ", vms_linkages");
3737 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3739 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3741 case EF_IA_64_VMS_COMCOD_WARNING
:
3742 strcat (buf
, ", warning");
3744 case EF_IA_64_VMS_COMCOD_ERROR
:
3745 strcat (buf
, ", error");
3747 case EF_IA_64_VMS_COMCOD_ABORT
:
3748 strcat (buf
, ", abort");
3751 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3752 e_flags
& EF_IA_64_VMS_COMCOD
);
3753 strcat (buf
, ", <unknown>");
3759 if ((e_flags
& EF_VAX_NONPIC
))
3760 strcat (buf
, ", non-PIC");
3761 if ((e_flags
& EF_VAX_DFLOAT
))
3762 strcat (buf
, ", D-Float");
3763 if ((e_flags
& EF_VAX_GFLOAT
))
3764 strcat (buf
, ", G-Float");
3768 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3769 strcat (buf
, ", mcm");
3770 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3771 strcat (buf
, ", mcm24");
3772 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3773 strcat (buf
, ", gr6");
3777 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3779 case E_FLAG_RL78_ANY_CPU
: break;
3780 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3781 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3782 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3784 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3785 strcat (buf
, ", 64-bit doubles");
3789 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3790 strcat (buf
, ", 64-bit doubles");
3791 if (e_flags
& E_FLAG_RX_DSP
)
3792 strcat (buf
, ", dsp");
3793 if (e_flags
& E_FLAG_RX_PID
)
3794 strcat (buf
, ", pid");
3795 if (e_flags
& E_FLAG_RX_ABI
)
3796 strcat (buf
, ", RX ABI");
3797 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3798 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3799 ? ", uses String instructions" : ", bans String instructions");
3800 if (e_flags
& E_FLAG_RX_V2
)
3801 strcat (buf
, ", V2");
3802 if (e_flags
& E_FLAG_RX_V3
)
3803 strcat (buf
, ", V3");
3807 if (e_flags
& EF_S390_HIGH_GPRS
)
3808 strcat (buf
, ", highgprs");
3812 if ((e_flags
& EF_C6000_REL
))
3813 strcat (buf
, ", relocatable module");
3817 strcat (buf
, _(": architecture variant: "));
3818 switch (e_flags
& EF_MSP430_MACH
)
3820 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3821 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3822 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3823 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3824 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3825 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3826 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3827 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3828 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3829 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3830 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3831 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3832 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3833 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3834 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3836 strcat (buf
, _(": unknown")); break;
3839 if (e_flags
& ~ EF_MSP430_MACH
)
3840 strcat (buf
, _(": unknown extra flag bits also present"));
3844 switch (e_flags
& EF_Z80_MACH_MSK
)
3846 case EF_Z80_MACH_Z80
: strcat (buf
, ", Z80"); break;
3847 case EF_Z80_MACH_Z180
: strcat (buf
, ", Z180"); break;
3848 case EF_Z80_MACH_R800
: strcat (buf
, ", R800"); break;
3849 case EF_Z80_MACH_EZ80_Z80
: strcat (buf
, ", EZ80"); break;
3850 case EF_Z80_MACH_EZ80_ADL
: strcat (buf
, ", EZ80, ADL"); break;
3851 case EF_Z80_MACH_GBZ80
: strcat (buf
, ", GBZ80"); break;
3852 case EF_Z80_MACH_Z80N
: strcat (buf
, ", Z80N"); break;
3854 strcat (buf
, _(", unknown")); break;
3864 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3866 static char buff
[32];
3870 case ELFOSABI_NONE
: return "UNIX - System V";
3871 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3872 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3873 case ELFOSABI_GNU
: return "UNIX - GNU";
3874 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3875 case ELFOSABI_AIX
: return "UNIX - AIX";
3876 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3877 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3878 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3879 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3880 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3881 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3882 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3883 case ELFOSABI_AROS
: return "AROS";
3884 case ELFOSABI_FENIXOS
: return "FenixOS";
3885 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3886 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3889 switch (filedata
->file_header
.e_machine
)
3894 case ELFOSABI_ARM
: return "ARM";
3895 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3906 case ELFOSABI_STANDALONE
: return _("Standalone App");
3915 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3916 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3925 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3931 get_aarch64_segment_type (unsigned long type
)
3935 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3936 default: return NULL
;
3941 get_arm_segment_type (unsigned long type
)
3945 case PT_ARM_EXIDX
: return "EXIDX";
3946 default: return NULL
;
3951 get_s390_segment_type (unsigned long type
)
3955 case PT_S390_PGSTE
: return "S390_PGSTE";
3956 default: return NULL
;
3961 get_mips_segment_type (unsigned long type
)
3965 case PT_MIPS_REGINFO
: return "REGINFO";
3966 case PT_MIPS_RTPROC
: return "RTPROC";
3967 case PT_MIPS_OPTIONS
: return "OPTIONS";
3968 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3969 default: return NULL
;
3974 get_parisc_segment_type (unsigned long type
)
3978 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3979 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3980 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3981 default: return NULL
;
3986 get_ia64_segment_type (unsigned long type
)
3990 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3991 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3992 default: return NULL
;
3997 get_tic6x_segment_type (unsigned long type
)
4001 case PT_C6000_PHATTR
: return "C6000_PHATTR";
4002 default: return NULL
;
4007 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
4009 if (e_machine
== EM_PARISC
)
4012 case PT_HP_TLS
: return "HP_TLS";
4013 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
4014 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
4015 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
4016 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
4017 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
4018 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
4019 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
4020 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
4021 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
4022 case PT_HP_PARALLEL
: return "HP_PARALLEL";
4023 case PT_HP_FASTBIND
: return "HP_FASTBIND";
4024 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
4025 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
4026 case PT_HP_STACK
: return "HP_STACK";
4027 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
4028 default: return NULL
;
4031 if (e_machine
== EM_IA_64
)
4034 case PT_HP_TLS
: return "HP_TLS";
4035 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
4036 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
4037 case PT_IA_64_HP_STACK
: return "HP_STACK";
4038 default: return NULL
;
4045 get_solaris_segment_type (unsigned long type
)
4049 case 0x6464e550: return "PT_SUNW_UNWIND";
4050 case 0x6474e550: return "PT_SUNW_EH_FRAME";
4051 case 0x6ffffff7: return "PT_LOSUNW";
4052 case 0x6ffffffa: return "PT_SUNWBSS";
4053 case 0x6ffffffb: return "PT_SUNWSTACK";
4054 case 0x6ffffffc: return "PT_SUNWDTRACE";
4055 case 0x6ffffffd: return "PT_SUNWCAP";
4056 case 0x6fffffff: return "PT_HISUNW";
4057 default: return NULL
;
4062 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
4064 static char buff
[32];
4068 case PT_NULL
: return "NULL";
4069 case PT_LOAD
: return "LOAD";
4070 case PT_DYNAMIC
: return "DYNAMIC";
4071 case PT_INTERP
: return "INTERP";
4072 case PT_NOTE
: return "NOTE";
4073 case PT_SHLIB
: return "SHLIB";
4074 case PT_PHDR
: return "PHDR";
4075 case PT_TLS
: return "TLS";
4076 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
4077 case PT_GNU_STACK
: return "GNU_STACK";
4078 case PT_GNU_RELRO
: return "GNU_RELRO";
4079 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
4081 case PT_OPENBSD_RANDOMIZE
: return "OPENBSD_RANDOMIZE";
4082 case PT_OPENBSD_WXNEEDED
: return "OPENBSD_WXNEEDED";
4083 case PT_OPENBSD_BOOTDATA
: return "OPENBSD_BOOTDATA";
4086 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
4088 const char * result
;
4090 switch (filedata
->file_header
.e_machine
)
4093 result
= get_aarch64_segment_type (p_type
);
4096 result
= get_arm_segment_type (p_type
);
4099 case EM_MIPS_RS3_LE
:
4100 result
= get_mips_segment_type (p_type
);
4103 result
= get_parisc_segment_type (p_type
);
4106 result
= get_ia64_segment_type (p_type
);
4109 result
= get_tic6x_segment_type (p_type
);
4113 result
= get_s390_segment_type (p_type
);
4123 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
4125 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
4127 const char * result
= NULL
;
4129 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
4132 case ELFOSABI_FREEBSD
:
4133 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
4135 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
4140 result
= get_hpux_segment_type (p_type
,
4141 filedata
->file_header
.e_machine
);
4143 case ELFOSABI_SOLARIS
:
4144 result
= get_solaris_segment_type (p_type
);
4152 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4155 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4162 get_arc_section_type_name (unsigned int sh_type
)
4166 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4174 get_mips_section_type_name (unsigned int sh_type
)
4178 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4179 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4180 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4181 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4182 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4183 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4184 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4185 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4186 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4187 case SHT_MIPS_RELD
: return "MIPS_RELD";
4188 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4189 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4190 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4191 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4192 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4193 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4194 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4195 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4196 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4197 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4198 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4199 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4200 case SHT_MIPS_LINE
: return "MIPS_LINE";
4201 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4202 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4203 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4204 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4205 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4206 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4207 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4208 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4209 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4210 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4211 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4212 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4213 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4214 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4215 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4216 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4217 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4218 case SHT_MIPS_XHASH
: return "MIPS_XHASH";
4226 get_parisc_section_type_name (unsigned int sh_type
)
4230 case SHT_PARISC_EXT
: return "PARISC_EXT";
4231 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4232 case SHT_PARISC_DOC
: return "PARISC_DOC";
4233 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4234 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4235 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4236 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4237 default: return NULL
;
4242 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4244 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4245 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4246 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4250 case SHT_IA_64_EXT
: return "IA_64_EXT";
4251 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4252 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4253 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4254 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4255 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4256 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4257 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4258 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4259 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4267 get_x86_64_section_type_name (unsigned int sh_type
)
4271 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4272 default: return NULL
;
4277 get_aarch64_section_type_name (unsigned int sh_type
)
4281 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4282 default: return NULL
;
4287 get_arm_section_type_name (unsigned int sh_type
)
4291 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4292 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4293 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4294 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4295 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4296 default: return NULL
;
4301 get_tic6x_section_type_name (unsigned int sh_type
)
4305 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4306 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4307 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4308 case SHT_TI_ICODE
: return "TI_ICODE";
4309 case SHT_TI_XREF
: return "TI_XREF";
4310 case SHT_TI_HANDLER
: return "TI_HANDLER";
4311 case SHT_TI_INITINFO
: return "TI_INITINFO";
4312 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4313 default: return NULL
;
4318 get_msp430_section_type_name (unsigned int sh_type
)
4322 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4323 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4324 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4325 default: return NULL
;
4330 get_nfp_section_type_name (unsigned int sh_type
)
4334 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4335 case SHT_NFP_INITREG
: return "NFP_INITREG";
4336 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4337 default: return NULL
;
4342 get_v850_section_type_name (unsigned int sh_type
)
4346 case SHT_V850_SCOMMON
: return "V850 Small Common";
4347 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4348 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4349 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4350 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4351 default: return NULL
;
4356 get_riscv_section_type_name (unsigned int sh_type
)
4360 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4361 default: return NULL
;
4366 get_csky_section_type_name (unsigned int sh_type
)
4370 case SHT_CSKY_ATTRIBUTES
: return "CSKY_ATTRIBUTES";
4371 default: return NULL
;
4376 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4378 static char buff
[32];
4379 const char * result
;
4383 case SHT_NULL
: return "NULL";
4384 case SHT_PROGBITS
: return "PROGBITS";
4385 case SHT_SYMTAB
: return "SYMTAB";
4386 case SHT_STRTAB
: return "STRTAB";
4387 case SHT_RELA
: return "RELA";
4388 case SHT_HASH
: return "HASH";
4389 case SHT_DYNAMIC
: return "DYNAMIC";
4390 case SHT_NOTE
: return "NOTE";
4391 case SHT_NOBITS
: return "NOBITS";
4392 case SHT_REL
: return "REL";
4393 case SHT_SHLIB
: return "SHLIB";
4394 case SHT_DYNSYM
: return "DYNSYM";
4395 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4396 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4397 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4398 case SHT_GNU_HASH
: return "GNU_HASH";
4399 case SHT_GROUP
: return "GROUP";
4400 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4401 case SHT_GNU_verdef
: return "VERDEF";
4402 case SHT_GNU_verneed
: return "VERNEED";
4403 case SHT_GNU_versym
: return "VERSYM";
4404 case 0x6ffffff0: return "VERSYM";
4405 case 0x6ffffffc: return "VERDEF";
4406 case 0x7ffffffd: return "AUXILIARY";
4407 case 0x7fffffff: return "FILTER";
4408 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4411 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4413 switch (filedata
->file_header
.e_machine
)
4416 case EM_ARC_COMPACT
:
4417 case EM_ARC_COMPACT2
:
4418 result
= get_arc_section_type_name (sh_type
);
4421 case EM_MIPS_RS3_LE
:
4422 result
= get_mips_section_type_name (sh_type
);
4425 result
= get_parisc_section_type_name (sh_type
);
4428 result
= get_ia64_section_type_name (filedata
, sh_type
);
4433 result
= get_x86_64_section_type_name (sh_type
);
4436 result
= get_aarch64_section_type_name (sh_type
);
4439 result
= get_arm_section_type_name (sh_type
);
4442 result
= get_tic6x_section_type_name (sh_type
);
4445 result
= get_msp430_section_type_name (sh_type
);
4448 result
= get_nfp_section_type_name (sh_type
);
4452 case EM_CYGNUS_V850
:
4453 result
= get_v850_section_type_name (sh_type
);
4456 result
= get_riscv_section_type_name (sh_type
);
4459 result
= get_csky_section_type_name (sh_type
);
4469 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4471 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4473 switch (filedata
->file_header
.e_machine
)
4476 result
= get_ia64_section_type_name (filedata
, sh_type
);
4479 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4480 result
= get_solaris_section_type (sh_type
);
4485 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4486 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4487 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4488 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4500 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4502 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4504 switch (filedata
->file_header
.e_machine
)
4508 case EM_CYGNUS_V850
:
4509 result
= get_v850_section_type_name (sh_type
);
4519 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4522 /* This message is probably going to be displayed in a 15
4523 character wide field, so put the hex value first. */
4524 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4530 enum long_option_values
4532 OPTION_DEBUG_DUMP
= 512,
4542 OPTION_WITH_SYMBOL_VERSIONS
,
4543 OPTION_RECURSE_LIMIT
,
4544 OPTION_NO_RECURSE_LIMIT
,
4545 OPTION_NO_DEMANGLING
,
4549 static struct option options
[] =
4551 /* Note - This table is alpha-sorted on the 'val'
4552 field in order to make adding new options easier. */
4553 {"arch-specific", no_argument
, 0, 'A'},
4554 {"all", no_argument
, 0, 'a'},
4555 {"demangle", optional_argument
, 0, 'C'},
4556 {"archive-index", no_argument
, 0, 'c'},
4557 {"use-dynamic", no_argument
, 0, 'D'},
4558 {"dynamic", no_argument
, 0, 'd'},
4559 {"headers", no_argument
, 0, 'e'},
4560 {"section-groups", no_argument
, 0, 'g'},
4561 {"help", no_argument
, 0, 'H'},
4562 {"file-header", no_argument
, 0, 'h'},
4563 {"histogram", no_argument
, 0, 'I'},
4564 {"lint", no_argument
, 0, 'L'},
4565 {"enable-checks", no_argument
, 0, 'L'},
4566 {"program-headers", no_argument
, 0, 'l'},
4567 {"segments", no_argument
, 0, 'l'},
4568 {"full-section-name",no_argument
, 0, 'N'},
4569 {"notes", no_argument
, 0, 'n'},
4570 {"process-links", no_argument
, 0, 'P'},
4571 {"string-dump", required_argument
, 0, 'p'},
4572 {"relocated-dump", required_argument
, 0, 'R'},
4573 {"relocs", no_argument
, 0, 'r'},
4574 {"section-headers", no_argument
, 0, 'S'},
4575 {"sections", no_argument
, 0, 'S'},
4576 {"symbols", no_argument
, 0, 's'},
4577 {"syms", no_argument
, 0, 's'},
4578 {"silent-truncation",no_argument
, 0, 'T'},
4579 {"section-details", no_argument
, 0, 't'},
4580 {"unwind", no_argument
, 0, 'u'},
4581 {"version-info", no_argument
, 0, 'V'},
4582 {"version", no_argument
, 0, 'v'},
4583 {"wide", no_argument
, 0, 'W'},
4584 {"hex-dump", required_argument
, 0, 'x'},
4585 {"decompress", no_argument
, 0, 'z'},
4587 {"no-demangle", no_argument
, 0, OPTION_NO_DEMANGLING
},
4588 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
4589 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
4590 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
4591 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4592 {"lto-syms", no_argument
, 0, OPTION_LTO_SYMS
},
4593 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4594 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4595 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4596 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4597 #ifdef ENABLE_LIBCTF
4598 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
4599 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
4600 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
4601 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
4603 {"sym-base", optional_argument
, 0, OPTION_SYM_BASE
},
4605 {0, no_argument
, 0, 0}
4609 usage (FILE * stream
)
4611 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4612 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4613 fprintf (stream
, _(" Options are:\n"));
4614 fprintf (stream
, _("\
4615 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
4616 fprintf (stream
, _("\
4617 -h --file-header Display the ELF file header\n"));
4618 fprintf (stream
, _("\
4619 -l --program-headers Display the program headers\n"));
4620 fprintf (stream
, _("\
4621 --segments An alias for --program-headers\n"));
4622 fprintf (stream
, _("\
4623 -S --section-headers Display the sections' header\n"));
4624 fprintf (stream
, _("\
4625 --sections An alias for --section-headers\n"));
4626 fprintf (stream
, _("\
4627 -g --section-groups Display the section groups\n"));
4628 fprintf (stream
, _("\
4629 -t --section-details Display the section details\n"));
4630 fprintf (stream
, _("\
4631 -e --headers Equivalent to: -h -l -S\n"));
4632 fprintf (stream
, _("\
4633 -s --syms Display the symbol table\n"));
4634 fprintf (stream
, _("\
4635 --symbols An alias for --syms\n"));
4636 fprintf (stream
, _("\
4637 --dyn-syms Display the dynamic symbol table\n"));
4638 fprintf (stream
, _("\
4639 --lto-syms Display LTO symbol tables\n"));
4640 fprintf (stream
, _("\
4641 --sym-base=[0|8|10|16] \n\
4642 Force base for symbol sizes. The options are \n\
4643 mixed (the default), octal, decimal, hexadecimal.\n"));
4644 fprintf (stream
, _("\
4645 -C --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
4646 The STYLE, if specified, can be `auto' (the default),\n\
4647 `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
4649 fprintf (stream
, _("\
4650 --no-demangle Do not demangle low-level symbol names. (default)\n"));
4651 fprintf (stream
, _("\
4652 --recurse-limit Enable a demangling recursion limit. (default)\n"));
4653 fprintf (stream
, _("\
4654 --no-recurse-limit Disable a demangling recursion limit\n"));
4655 fprintf (stream
, _("\
4656 -n --notes Display the core notes (if present)\n"));
4657 fprintf (stream
, _("\
4658 -r --relocs Display the relocations (if present)\n"));
4659 fprintf (stream
, _("\
4660 -u --unwind Display the unwind info (if present)\n"));
4661 fprintf (stream
, _("\
4662 -d --dynamic Display the dynamic section (if present)\n"));
4663 fprintf (stream
, _("\
4664 -V --version-info Display the version sections (if present)\n"));
4665 fprintf (stream
, _("\
4666 -A --arch-specific Display architecture specific information (if any)\n"));
4667 fprintf (stream
, _("\
4668 -c --archive-index Display the symbol/file index in an archive\n"));
4669 fprintf (stream
, _("\
4670 -D --use-dynamic Use the dynamic section info when displaying symbols\n"));
4671 fprintf (stream
, _("\
4672 -L --lint|--enable-checks\n\
4673 Display warning messages for possible problems\n"));
4674 fprintf (stream
, _("\
4675 -x --hex-dump=<number|name>\n\
4676 Dump the contents of section <number|name> as bytes\n"));
4677 fprintf (stream
, _("\
4678 -p --string-dump=<number|name>\n\
4679 Dump the contents of section <number|name> as strings\n"));
4680 fprintf (stream
, _("\
4681 -R --relocated-dump=<number|name>\n\
4682 Dump the relocated contents of section <number|name>\n"));
4683 fprintf (stream
, _("\
4684 -z --decompress Decompress section before dumping it\n"));
4685 fprintf (stream
, _("\
4686 -w --debug-dump[a/=abbrev, A/=addr, r/=aranges, c/=cu_index, L/=decodedline,\n\
4687 f/=frames, F/=frames-interp, g/=gdb_index, i/=info, o/=loc,\n\
4688 m/=macro, p/=pubnames, t/=pubtypes, R/=Ranges, l/=rawline,\n\
4689 s/=str, O/=str-offsets, u/=trace_abbrev, T/=trace_aranges,\n\
4691 Display the contents of DWARF debug sections\n"));
4692 fprintf (stream
, _("\
4693 -wk --debug-dump=links Display the contents of sections that link to separate\n\
4694 debuginfo files\n"));
4695 fprintf (stream
, _("\
4696 -P --process-links Display the contents of non-debug sections in separate\n\
4697 debuginfo files. (Implies -wK)\n"));
4698 #if DEFAULT_FOR_FOLLOW_LINKS
4699 fprintf (stream
, _("\
4700 -wK --debug-dump=follow-links\n\
4701 Follow links to separate debug info files (default)\n"));
4702 fprintf (stream
, _("\
4703 -wN --debug-dump=no-follow-links\n\
4704 Do not follow links to separate debug info files\n"));
4706 fprintf (stream
, _("\
4707 -wK --debug-dump=follow-links\n\
4708 Follow links to separate debug info files\n"));
4709 fprintf (stream
, _("\
4710 -wN --debug-dump=no-follow-links\n\
4711 Do not follow links to separate debug info files\n\
4714 fprintf (stream
, _("\
4715 --dwarf-depth=N Do not display DIEs at depth N or greater\n"));
4716 fprintf (stream
, _("\
4717 --dwarf-start=N Display DIEs starting at offset N\n"));
4718 #ifdef ENABLE_LIBCTF
4719 fprintf (stream
, _("\
4720 --ctf=<number|name> Display CTF info from section <number|name>\n"));
4721 fprintf (stream
, _("\
4722 --ctf-parent=<number|name>\n\
4723 Use section <number|name> as the CTF parent\n"));
4724 fprintf (stream
, _("\
4725 --ctf-symbols=<number|name>\n\
4726 Use section <number|name> as the CTF external symtab\n"));
4727 fprintf (stream
, _("\
4728 --ctf-strings=<number|name>\n\
4729 Use section <number|name> as the CTF external strtab\n"));
4732 #ifdef SUPPORT_DISASSEMBLY
4733 fprintf (stream
, _("\
4734 -i --instruction-dump=<number|name>\n\
4735 Disassemble the contents of section <number|name>\n"));
4737 fprintf (stream
, _("\
4738 -I --histogram Display histogram of bucket list lengths\n"));
4739 fprintf (stream
, _("\
4740 -W --wide Allow output width to exceed 80 characters\n"));
4741 fprintf (stream
, _("\
4742 -T --silent-truncation If a symbol name is truncated, do not add [...] suffix\n"));
4743 fprintf (stream
, _("\
4744 @<file> Read options from <file>\n"));
4745 fprintf (stream
, _("\
4746 -H --help Display this information\n"));
4747 fprintf (stream
, _("\
4748 -v --version Display the version number of readelf\n"));
4750 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4751 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4753 exit (stream
== stdout
? 0 : 1);
4756 /* Record the fact that the user wants the contents of section number
4757 SECTION to be displayed using the method(s) encoded as flags bits
4758 in TYPE. Note, TYPE can be zero if we are creating the array for
4762 request_dump_bynumber (struct dump_data
*dumpdata
,
4763 unsigned int section
, dump_type type
)
4765 if (section
>= dumpdata
->num_dump_sects
)
4767 dump_type
* new_dump_sects
;
4769 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4770 sizeof (* new_dump_sects
));
4772 if (new_dump_sects
== NULL
)
4773 error (_("Out of memory allocating dump request table.\n"));
4776 if (dumpdata
->dump_sects
)
4778 /* Copy current flag settings. */
4779 memcpy (new_dump_sects
, dumpdata
->dump_sects
,
4780 dumpdata
->num_dump_sects
* sizeof (* new_dump_sects
));
4782 free (dumpdata
->dump_sects
);
4785 dumpdata
->dump_sects
= new_dump_sects
;
4786 dumpdata
->num_dump_sects
= section
+ 1;
4790 if (dumpdata
->dump_sects
)
4791 dumpdata
->dump_sects
[section
] |= type
;
4794 /* Request a dump by section name. */
4797 request_dump_byname (const char * section
, dump_type type
)
4799 struct dump_list_entry
* new_request
;
4801 new_request
= (struct dump_list_entry
*)
4802 malloc (sizeof (struct dump_list_entry
));
4804 error (_("Out of memory allocating dump request table.\n"));
4806 new_request
->name
= strdup (section
);
4807 if (!new_request
->name
)
4808 error (_("Out of memory allocating dump request table.\n"));
4810 new_request
->type
= type
;
4812 new_request
->next
= dump_sects_byname
;
4813 dump_sects_byname
= new_request
;
4817 request_dump (struct dump_data
*dumpdata
, dump_type type
)
4823 section
= strtoul (optarg
, & cp
, 0);
4825 if (! *cp
&& section
>= 0)
4826 request_dump_bynumber (dumpdata
, section
, type
);
4828 request_dump_byname (optarg
, type
);
4832 parse_args (struct dump_data
*dumpdata
, int argc
, char ** argv
)
4839 while ((c
= getopt_long
4840 (argc
, argv
, "ACDHILNPR:STVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4858 do_section_groups
= true;
4861 do_histogram
= true;
4867 do_section_groups
= true;
4872 do_section_details
= true;
4883 do_using_dynamic
= true;
4907 do_histogram
= true;
4913 do_archive_index
= true;
4919 process_links
= true;
4920 do_follow_links
= true;
4923 request_dump (dumpdata
, HEX_DUMP
);
4926 request_dump (dumpdata
, STRING_DUMP
);
4929 request_dump (dumpdata
, RELOC_DUMP
);
4932 decompress_dumps
= true;
4938 do_debugging
= true;
4939 dwarf_select_sections_all ();
4943 do_debugging
= false;
4944 dwarf_select_sections_by_letters (optarg
);
4947 case OPTION_DEBUG_DUMP
:
4951 do_debugging
= true;
4952 dwarf_select_sections_all ();
4956 do_debugging
= false;
4957 dwarf_select_sections_by_names (optarg
);
4960 case OPTION_DWARF_DEPTH
:
4964 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4967 case OPTION_DWARF_START
:
4971 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4974 case OPTION_DWARF_CHECK
:
4977 case OPTION_CTF_DUMP
:
4979 request_dump (dumpdata
, CTF_DUMP
);
4981 case OPTION_CTF_SYMBOLS
:
4982 free (dump_ctf_symtab_name
);
4983 dump_ctf_symtab_name
= strdup (optarg
);
4985 case OPTION_CTF_STRINGS
:
4986 free (dump_ctf_strtab_name
);
4987 dump_ctf_strtab_name
= strdup (optarg
);
4989 case OPTION_CTF_PARENT
:
4990 free (dump_ctf_parent_name
);
4991 dump_ctf_parent_name
= strdup (optarg
);
4993 case OPTION_DYN_SYMS
:
4996 case OPTION_LTO_SYMS
:
4999 #ifdef SUPPORT_DISASSEMBLY
5001 request_dump (dumpdata
, DISASS_DUMP
);
5005 print_version (program_name
);
5014 do_not_show_symbol_truncation
= true;
5020 enum demangling_styles style
;
5022 style
= cplus_demangle_name_to_style (optarg
);
5023 if (style
== unknown_demangling
)
5024 error (_("unknown demangling style `%s'"), optarg
);
5026 cplus_demangle_set_style (style
);
5029 case OPTION_NO_DEMANGLING
:
5030 do_demangle
= false;
5032 case OPTION_RECURSE_LIMIT
:
5033 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
5035 case OPTION_NO_RECURSE_LIMIT
:
5036 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
5038 case OPTION_WITH_SYMBOL_VERSIONS
:
5039 /* Ignored for backward compatibility. */
5042 case OPTION_SYM_BASE
:
5046 sym_base
= strtoul (optarg
, NULL
, 0);
5063 /* xgettext:c-format */
5064 error (_("Invalid option '-%c'\n"), c
);
5071 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
5072 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
5073 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
5074 && !do_section_groups
&& !do_archive_index
5075 && !do_dyn_syms
&& !do_lto_syms
)
5080 do_dynamic
= do_syms
= do_reloc
= do_unwind
= do_sections
= true;
5081 do_segments
= do_header
= do_dump
= do_version
= true;
5082 do_histogram
= do_debugging
= do_arch
= do_notes
= true;
5083 do_section_groups
= do_archive_index
= do_dyn_syms
= true;
5092 get_elf_class (unsigned int elf_class
)
5094 static char buff
[32];
5098 case ELFCLASSNONE
: return _("none");
5099 case ELFCLASS32
: return "ELF32";
5100 case ELFCLASS64
: return "ELF64";
5102 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
5108 get_data_encoding (unsigned int encoding
)
5110 static char buff
[32];
5114 case ELFDATANONE
: return _("none");
5115 case ELFDATA2LSB
: return _("2's complement, little endian");
5116 case ELFDATA2MSB
: return _("2's complement, big endian");
5118 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
5123 /* Decode the data held in 'filedata->file_header'. */
5126 process_file_header (Filedata
* filedata
)
5128 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
5130 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
5131 || header
->e_ident
[EI_MAG1
] != ELFMAG1
5132 || header
->e_ident
[EI_MAG2
] != ELFMAG2
5133 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
5136 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
5140 if (! filedata
->is_separate
)
5141 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
5147 if (filedata
->is_separate
)
5148 printf (_("ELF Header in linked file '%s':\n"), filedata
->file_name
);
5150 printf (_("ELF Header:\n"));
5151 printf (_(" Magic: "));
5152 for (i
= 0; i
< EI_NIDENT
; i
++)
5153 printf ("%2.2x ", header
->e_ident
[i
]);
5155 printf (_(" Class: %s\n"),
5156 get_elf_class (header
->e_ident
[EI_CLASS
]));
5157 printf (_(" Data: %s\n"),
5158 get_data_encoding (header
->e_ident
[EI_DATA
]));
5159 printf (_(" Version: %d%s\n"),
5160 header
->e_ident
[EI_VERSION
],
5161 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
5163 : (header
->e_ident
[EI_VERSION
] != EV_NONE
5166 printf (_(" OS/ABI: %s\n"),
5167 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
5168 printf (_(" ABI Version: %d\n"),
5169 header
->e_ident
[EI_ABIVERSION
]);
5170 printf (_(" Type: %s\n"),
5171 get_file_type (header
->e_type
));
5172 printf (_(" Machine: %s\n"),
5173 get_machine_name (header
->e_machine
));
5174 printf (_(" Version: 0x%lx\n"),
5177 printf (_(" Entry point address: "));
5178 print_vma (header
->e_entry
, PREFIX_HEX
);
5179 printf (_("\n Start of program headers: "));
5180 print_vma (header
->e_phoff
, DEC
);
5181 printf (_(" (bytes into file)\n Start of section headers: "));
5182 print_vma (header
->e_shoff
, DEC
);
5183 printf (_(" (bytes into file)\n"));
5185 printf (_(" Flags: 0x%lx%s\n"),
5187 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
5188 printf (_(" Size of this header: %u (bytes)\n"),
5190 printf (_(" Size of program headers: %u (bytes)\n"),
5191 header
->e_phentsize
);
5192 printf (_(" Number of program headers: %u"),
5194 if (filedata
->section_headers
!= NULL
5195 && header
->e_phnum
== PN_XNUM
5196 && filedata
->section_headers
[0].sh_info
!= 0)
5198 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
5199 printf (" (%u)", header
->e_phnum
);
5201 putc ('\n', stdout
);
5202 printf (_(" Size of section headers: %u (bytes)\n"),
5203 header
->e_shentsize
);
5204 printf (_(" Number of section headers: %u"),
5206 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
5208 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5209 printf (" (%u)", header
->e_shnum
);
5211 putc ('\n', stdout
);
5212 printf (_(" Section header string table index: %u"),
5213 header
->e_shstrndx
);
5214 if (filedata
->section_headers
!= NULL
5215 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5217 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5218 printf (" (%u)", header
->e_shstrndx
);
5220 if (header
->e_shstrndx
!= SHN_UNDEF
5221 && header
->e_shstrndx
>= header
->e_shnum
)
5223 header
->e_shstrndx
= SHN_UNDEF
;
5224 printf (_(" <corrupt: out of range>"));
5226 putc ('\n', stdout
);
5229 if (filedata
->section_headers
!= NULL
)
5231 if (header
->e_phnum
== PN_XNUM
5232 && filedata
->section_headers
[0].sh_info
!= 0)
5233 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
5234 if (header
->e_shnum
== SHN_UNDEF
)
5235 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5236 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5237 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5238 if (header
->e_shstrndx
>= header
->e_shnum
)
5239 header
->e_shstrndx
= SHN_UNDEF
;
5240 free (filedata
->section_headers
);
5241 filedata
->section_headers
= NULL
;
5247 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5248 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
5251 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5253 Elf32_External_Phdr
* phdrs
;
5254 Elf32_External_Phdr
* external
;
5255 Elf_Internal_Phdr
* internal
;
5257 unsigned int size
= filedata
->file_header
.e_phentsize
;
5258 unsigned int num
= filedata
->file_header
.e_phnum
;
5260 /* PR binutils/17531: Cope with unexpected section header sizes. */
5261 if (size
== 0 || num
== 0)
5263 if (size
< sizeof * phdrs
)
5265 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5268 if (size
> sizeof * phdrs
)
5269 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5271 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5272 size
, num
, _("program headers"));
5276 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5277 i
< filedata
->file_header
.e_phnum
;
5278 i
++, internal
++, external
++)
5280 internal
->p_type
= BYTE_GET (external
->p_type
);
5281 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5282 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5283 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5284 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5285 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5286 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5287 internal
->p_align
= BYTE_GET (external
->p_align
);
5294 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5295 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5298 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5300 Elf64_External_Phdr
* phdrs
;
5301 Elf64_External_Phdr
* external
;
5302 Elf_Internal_Phdr
* internal
;
5304 unsigned int size
= filedata
->file_header
.e_phentsize
;
5305 unsigned int num
= filedata
->file_header
.e_phnum
;
5307 /* PR binutils/17531: Cope with unexpected section header sizes. */
5308 if (size
== 0 || num
== 0)
5310 if (size
< sizeof * phdrs
)
5312 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5315 if (size
> sizeof * phdrs
)
5316 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5318 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5319 size
, num
, _("program headers"));
5323 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5324 i
< filedata
->file_header
.e_phnum
;
5325 i
++, internal
++, external
++)
5327 internal
->p_type
= BYTE_GET (external
->p_type
);
5328 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5329 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5330 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5331 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5332 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5333 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5334 internal
->p_align
= BYTE_GET (external
->p_align
);
5341 /* Returns TRUE if the program headers were read into `program_headers'. */
5344 get_program_headers (Filedata
* filedata
)
5346 Elf_Internal_Phdr
* phdrs
;
5348 /* Check cache of prior read. */
5349 if (filedata
->program_headers
!= NULL
)
5352 /* Be kind to memory checkers by looking for
5353 e_phnum values which we know must be invalid. */
5354 if (filedata
->file_header
.e_phnum
5355 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5356 >= filedata
->file_size
)
5358 error (_("Too many program headers - %#x - the file is not that big\n"),
5359 filedata
->file_header
.e_phnum
);
5363 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5364 sizeof (Elf_Internal_Phdr
));
5367 error (_("Out of memory reading %u program headers\n"),
5368 filedata
->file_header
.e_phnum
);
5373 ? get_32bit_program_headers (filedata
, phdrs
)
5374 : get_64bit_program_headers (filedata
, phdrs
))
5376 filedata
->program_headers
= phdrs
;
5384 /* Returns TRUE if the program headers were loaded. */
5387 process_program_headers (Filedata
* filedata
)
5389 Elf_Internal_Phdr
* segment
;
5391 Elf_Internal_Phdr
* previous_load
= NULL
;
5393 filedata
->dynamic_addr
= 0;
5394 filedata
->dynamic_size
= 0;
5396 if (filedata
->file_header
.e_phnum
== 0)
5398 /* PR binutils/12467. */
5399 if (filedata
->file_header
.e_phoff
!= 0)
5401 warn (_("possibly corrupt ELF header - it has a non-zero program"
5402 " header offset, but no program headers\n"));
5405 else if (do_segments
)
5407 if (filedata
->is_separate
)
5408 printf (_("\nThere are no program headers in linked file '%s'.\n"),
5409 filedata
->file_name
);
5411 printf (_("\nThere are no program headers in this file.\n"));
5416 if (do_segments
&& !do_header
)
5418 if (filedata
->is_separate
)
5419 printf ("\nIn linked file '%s' the ELF file type is %s\n",
5420 filedata
->file_name
,
5421 get_file_type (filedata
->file_header
.e_type
));
5423 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5424 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5425 printf (ngettext ("There is %d program header, starting at offset %s\n",
5426 "There are %d program headers, starting at offset %s\n",
5427 filedata
->file_header
.e_phnum
),
5428 filedata
->file_header
.e_phnum
,
5429 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5432 if (! get_program_headers (filedata
))
5437 if (filedata
->file_header
.e_phnum
> 1)
5438 printf (_("\nProgram Headers:\n"));
5440 printf (_("\nProgram Headers:\n"));
5444 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5447 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5451 (_(" Type Offset VirtAddr PhysAddr\n"));
5453 (_(" FileSiz MemSiz Flags Align\n"));
5457 for (i
= 0, segment
= filedata
->program_headers
;
5458 i
< filedata
->file_header
.e_phnum
;
5463 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5467 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5468 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5469 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5470 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5471 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5473 (segment
->p_flags
& PF_R
? 'R' : ' '),
5474 (segment
->p_flags
& PF_W
? 'W' : ' '),
5475 (segment
->p_flags
& PF_X
? 'E' : ' '));
5476 printf ("%#lx", (unsigned long) segment
->p_align
);
5480 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5481 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5484 print_vma (segment
->p_offset
, FULL_HEX
);
5488 print_vma (segment
->p_vaddr
, FULL_HEX
);
5490 print_vma (segment
->p_paddr
, FULL_HEX
);
5493 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5494 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5497 print_vma (segment
->p_filesz
, FULL_HEX
);
5501 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5502 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5505 print_vma (segment
->p_memsz
, FULL_HEX
);
5509 (segment
->p_flags
& PF_R
? 'R' : ' '),
5510 (segment
->p_flags
& PF_W
? 'W' : ' '),
5511 (segment
->p_flags
& PF_X
? 'E' : ' '));
5513 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5514 printf ("%#lx", (unsigned long) segment
->p_align
);
5517 print_vma (segment
->p_align
, PREFIX_HEX
);
5522 print_vma (segment
->p_offset
, FULL_HEX
);
5524 print_vma (segment
->p_vaddr
, FULL_HEX
);
5526 print_vma (segment
->p_paddr
, FULL_HEX
);
5528 print_vma (segment
->p_filesz
, FULL_HEX
);
5530 print_vma (segment
->p_memsz
, FULL_HEX
);
5532 (segment
->p_flags
& PF_R
? 'R' : ' '),
5533 (segment
->p_flags
& PF_W
? 'W' : ' '),
5534 (segment
->p_flags
& PF_X
? 'E' : ' '));
5535 print_vma (segment
->p_align
, PREFIX_HEX
);
5538 putc ('\n', stdout
);
5541 switch (segment
->p_type
)
5544 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5545 required by the ELF standard, several programs, including the Linux
5546 kernel, make use of non-ordered segments. */
5548 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5549 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5551 if (segment
->p_memsz
< segment
->p_filesz
)
5552 error (_("the segment's file size is larger than its memory size\n"));
5553 previous_load
= segment
;
5557 /* PR 20815 - Verify that the program header is loaded into memory. */
5558 if (i
> 0 && previous_load
!= NULL
)
5559 error (_("the PHDR segment must occur before any LOAD segment\n"));
5560 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5564 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5566 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
5567 if (load
->p_type
== PT_LOAD
5568 && load
->p_offset
<= segment
->p_offset
5569 && (load
->p_offset
+ load
->p_filesz
5570 >= segment
->p_offset
+ segment
->p_filesz
)
5571 && load
->p_vaddr
<= segment
->p_vaddr
5572 && (load
->p_vaddr
+ load
->p_filesz
5573 >= segment
->p_vaddr
+ segment
->p_filesz
))
5576 if (j
== filedata
->file_header
.e_phnum
)
5577 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5582 if (filedata
->dynamic_addr
)
5583 error (_("more than one dynamic segment\n"));
5585 /* By default, assume that the .dynamic section is the first
5586 section in the DYNAMIC segment. */
5587 filedata
->dynamic_addr
= segment
->p_offset
;
5588 filedata
->dynamic_size
= segment
->p_filesz
;
5590 /* Try to locate the .dynamic section. If there is
5591 a section header table, we can easily locate it. */
5592 if (filedata
->section_headers
!= NULL
)
5594 Elf_Internal_Shdr
* sec
;
5596 sec
= find_section (filedata
, ".dynamic");
5597 if (sec
== NULL
|| sec
->sh_size
== 0)
5599 /* A corresponding .dynamic section is expected, but on
5600 IA-64/OpenVMS it is OK for it to be missing. */
5601 if (!is_ia64_vms (filedata
))
5602 error (_("no .dynamic section in the dynamic segment\n"));
5606 if (sec
->sh_type
== SHT_NOBITS
)
5608 filedata
->dynamic_size
= 0;
5612 filedata
->dynamic_addr
= sec
->sh_offset
;
5613 filedata
->dynamic_size
= sec
->sh_size
;
5615 /* The PT_DYNAMIC segment, which is used by the run-time
5616 loader, should exactly match the .dynamic section. */
5618 && (filedata
->dynamic_addr
!= segment
->p_offset
5619 || filedata
->dynamic_size
!= segment
->p_filesz
))
5621 the .dynamic section is not the same as the dynamic segment\n"));
5624 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5625 segment. Check this after matching against the section headers
5626 so we don't warn on debuginfo file (which have NOBITS .dynamic
5628 if (filedata
->dynamic_addr
> filedata
->file_size
5629 || (filedata
->dynamic_size
5630 > filedata
->file_size
- filedata
->dynamic_addr
))
5632 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5633 filedata
->dynamic_addr
= filedata
->dynamic_size
= 0;
5638 if (segment
->p_offset
>= filedata
->file_size
5639 || segment
->p_filesz
> filedata
->file_size
- segment
->p_offset
5640 || segment
->p_filesz
- 1 >= (size_t) -2
5641 || fseek (filedata
->handle
,
5642 filedata
->archive_file_offset
+ (long) segment
->p_offset
,
5644 error (_("Unable to find program interpreter name\n"));
5647 size_t len
= segment
->p_filesz
;
5648 free (filedata
->program_interpreter
);
5649 filedata
->program_interpreter
= xmalloc (len
+ 1);
5650 len
= fread (filedata
->program_interpreter
, 1, len
,
5652 filedata
->program_interpreter
[len
] = 0;
5655 printf (_(" [Requesting program interpreter: %s]\n"),
5656 filedata
->program_interpreter
);
5663 && filedata
->section_headers
!= NULL
5664 && filedata
->string_table
!= NULL
)
5666 printf (_("\n Section to Segment mapping:\n"));
5667 printf (_(" Segment Sections...\n"));
5669 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5672 Elf_Internal_Shdr
* section
;
5674 segment
= filedata
->program_headers
+ i
;
5675 section
= filedata
->section_headers
+ 1;
5677 printf (" %2.2d ", i
);
5679 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5681 if (!ELF_TBSS_SPECIAL (section
, segment
)
5682 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5683 printf ("%s ", printable_section_name (filedata
, section
));
5694 /* Find the file offset corresponding to VMA by using the program headers. */
5697 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5699 Elf_Internal_Phdr
* seg
;
5701 if (! get_program_headers (filedata
))
5703 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5707 for (seg
= filedata
->program_headers
;
5708 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5711 if (seg
->p_type
!= PT_LOAD
)
5714 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5715 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5716 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5719 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5720 (unsigned long) vma
);
5725 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5726 If PROBE is true, this is just a probe and we do not generate any error
5727 messages if the load fails. */
5730 get_32bit_section_headers (Filedata
* filedata
, bool probe
)
5732 Elf32_External_Shdr
* shdrs
;
5733 Elf_Internal_Shdr
* internal
;
5735 unsigned int size
= filedata
->file_header
.e_shentsize
;
5736 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5738 /* PR binutils/17531: Cope with unexpected section header sizes. */
5739 if (size
== 0 || num
== 0)
5741 if (size
< sizeof * shdrs
)
5744 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5747 if (!probe
&& size
> sizeof * shdrs
)
5748 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5750 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5752 probe
? NULL
: _("section headers"));
5756 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5757 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5758 if (filedata
->section_headers
== NULL
)
5761 error (_("Out of memory reading %u section headers\n"), num
);
5766 for (i
= 0, internal
= filedata
->section_headers
;
5770 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5771 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5772 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5773 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5774 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5775 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5776 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5777 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5778 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5779 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5780 if (!probe
&& internal
->sh_link
> num
)
5781 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5782 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5783 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5790 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5793 get_64bit_section_headers (Filedata
* filedata
, bool probe
)
5795 Elf64_External_Shdr
* shdrs
;
5796 Elf_Internal_Shdr
* internal
;
5798 unsigned int size
= filedata
->file_header
.e_shentsize
;
5799 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5801 /* PR binutils/17531: Cope with unexpected section header sizes. */
5802 if (size
== 0 || num
== 0)
5805 if (size
< sizeof * shdrs
)
5808 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5812 if (! probe
&& size
> sizeof * shdrs
)
5813 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5815 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5816 filedata
->file_header
.e_shoff
,
5818 probe
? NULL
: _("section headers"));
5822 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5823 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5824 if (filedata
->section_headers
== NULL
)
5827 error (_("Out of memory reading %u section headers\n"), num
);
5832 for (i
= 0, internal
= filedata
->section_headers
;
5836 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5837 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5838 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5839 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5840 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5841 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5842 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5843 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5844 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5845 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5846 if (!probe
&& internal
->sh_link
> num
)
5847 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5848 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5849 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5857 get_section_headers (Filedata
*filedata
, bool probe
)
5859 if (filedata
->section_headers
!= NULL
)
5863 return get_32bit_section_headers (filedata
, probe
);
5865 return get_64bit_section_headers (filedata
, probe
);
5868 static Elf_Internal_Sym
*
5869 get_32bit_elf_symbols (Filedata
* filedata
,
5870 Elf_Internal_Shdr
* section
,
5871 unsigned long * num_syms_return
)
5873 unsigned long number
= 0;
5874 Elf32_External_Sym
* esyms
= NULL
;
5875 Elf_External_Sym_Shndx
* shndx
= NULL
;
5876 Elf_Internal_Sym
* isyms
= NULL
;
5877 Elf_Internal_Sym
* psym
;
5879 elf_section_list
* entry
;
5881 if (section
->sh_size
== 0)
5883 if (num_syms_return
!= NULL
)
5884 * num_syms_return
= 0;
5888 /* Run some sanity checks first. */
5889 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5891 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5892 printable_section_name (filedata
, section
),
5893 (unsigned long) section
->sh_entsize
);
5897 if (section
->sh_size
> filedata
->file_size
)
5899 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5900 printable_section_name (filedata
, section
),
5901 (unsigned long) section
->sh_size
);
5905 number
= section
->sh_size
/ section
->sh_entsize
;
5907 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5909 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5910 (unsigned long) section
->sh_size
,
5911 printable_section_name (filedata
, section
),
5912 (unsigned long) section
->sh_entsize
);
5916 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5917 section
->sh_size
, _("symbols"));
5922 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5924 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5929 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5933 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5934 entry
->hdr
->sh_offset
,
5935 1, entry
->hdr
->sh_size
,
5936 _("symbol table section indices"));
5940 /* PR17531: file: heap-buffer-overflow */
5941 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5943 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5944 printable_section_name (filedata
, entry
->hdr
),
5945 (unsigned long) entry
->hdr
->sh_size
,
5946 (unsigned long) section
->sh_size
);
5951 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5955 error (_("Out of memory reading %lu symbols\n"),
5956 (unsigned long) number
);
5960 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5962 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5963 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5964 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5965 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5966 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5968 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5969 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5970 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5971 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5972 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5979 if (num_syms_return
!= NULL
)
5980 * num_syms_return
= isyms
== NULL
? 0 : number
;
5985 static Elf_Internal_Sym
*
5986 get_64bit_elf_symbols (Filedata
* filedata
,
5987 Elf_Internal_Shdr
* section
,
5988 unsigned long * num_syms_return
)
5990 unsigned long number
= 0;
5991 Elf64_External_Sym
* esyms
= NULL
;
5992 Elf_External_Sym_Shndx
* shndx
= NULL
;
5993 Elf_Internal_Sym
* isyms
= NULL
;
5994 Elf_Internal_Sym
* psym
;
5996 elf_section_list
* entry
;
5998 if (section
->sh_size
== 0)
6000 if (num_syms_return
!= NULL
)
6001 * num_syms_return
= 0;
6005 /* Run some sanity checks first. */
6006 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
6008 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
6009 printable_section_name (filedata
, section
),
6010 (unsigned long) section
->sh_entsize
);
6014 if (section
->sh_size
> filedata
->file_size
)
6016 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
6017 printable_section_name (filedata
, section
),
6018 (unsigned long) section
->sh_size
);
6022 number
= section
->sh_size
/ section
->sh_entsize
;
6024 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
6026 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
6027 (unsigned long) section
->sh_size
,
6028 printable_section_name (filedata
, section
),
6029 (unsigned long) section
->sh_entsize
);
6033 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
6034 section
->sh_size
, _("symbols"));
6039 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
6041 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
6046 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
6050 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
6051 entry
->hdr
->sh_offset
,
6052 1, entry
->hdr
->sh_size
,
6053 _("symbol table section indices"));
6057 /* PR17531: file: heap-buffer-overflow */
6058 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
6060 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
6061 printable_section_name (filedata
, entry
->hdr
),
6062 (unsigned long) entry
->hdr
->sh_size
,
6063 (unsigned long) section
->sh_size
);
6068 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
6072 error (_("Out of memory reading %lu symbols\n"),
6073 (unsigned long) number
);
6077 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
6079 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
6080 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
6081 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
6082 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
6084 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
6086 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
6087 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
6088 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
6090 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
6091 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
6098 if (num_syms_return
!= NULL
)
6099 * num_syms_return
= isyms
== NULL
? 0 : number
;
6104 static Elf_Internal_Sym
*
6105 get_elf_symbols (Filedata
*filedata
,
6106 Elf_Internal_Shdr
*section
,
6107 unsigned long *num_syms_return
)
6110 return get_32bit_elf_symbols (filedata
, section
, num_syms_return
);
6112 return get_64bit_elf_symbols (filedata
, section
, num_syms_return
);
6116 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
6118 static char buff
[1024];
6120 unsigned int field_size
= is_32bit_elf
? 8 : 16;
6122 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
6123 bfd_vma os_flags
= 0;
6124 bfd_vma proc_flags
= 0;
6125 bfd_vma unknown_flags
= 0;
6133 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
6134 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
6135 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
6136 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
6137 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
6138 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
6139 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
6140 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
6141 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
6142 /* 9 */ { STRING_COMMA_LEN ("TLS") },
6143 /* IA-64 specific. */
6144 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
6145 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
6146 /* IA-64 OpenVMS specific. */
6147 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
6148 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
6149 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
6150 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
6151 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
6152 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
6154 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
6155 /* SPARC specific. */
6156 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
6157 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
6159 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
6160 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
6161 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
6163 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
6165 /* 25 */ { STRING_COMMA_LEN ("VLE") },
6167 /* 26 */ { STRING_COMMA_LEN ("GNU_RETAIN") },
6170 if (do_section_details
)
6172 sprintf (buff
, "[%*.*lx]: ",
6173 field_size
, field_size
, (unsigned long) sh_flags
);
6174 p
+= field_size
+ 4;
6181 flag
= sh_flags
& - sh_flags
;
6184 if (do_section_details
)
6188 case SHF_WRITE
: sindex
= 0; break;
6189 case SHF_ALLOC
: sindex
= 1; break;
6190 case SHF_EXECINSTR
: sindex
= 2; break;
6191 case SHF_MERGE
: sindex
= 3; break;
6192 case SHF_STRINGS
: sindex
= 4; break;
6193 case SHF_INFO_LINK
: sindex
= 5; break;
6194 case SHF_LINK_ORDER
: sindex
= 6; break;
6195 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
6196 case SHF_GROUP
: sindex
= 8; break;
6197 case SHF_TLS
: sindex
= 9; break;
6198 case SHF_EXCLUDE
: sindex
= 18; break;
6199 case SHF_COMPRESSED
: sindex
= 20; break;
6203 switch (filedata
->file_header
.e_machine
)
6206 if (flag
== SHF_IA_64_SHORT
)
6208 else if (flag
== SHF_IA_64_NORECOV
)
6211 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
6214 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
6215 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
6216 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
6217 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
6218 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
6219 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
6230 case EM_OLD_SPARCV9
:
6231 case EM_SPARC32PLUS
:
6234 if (flag
== SHF_ORDERED
)
6241 case SHF_ENTRYSECT
: sindex
= 21; break;
6242 case SHF_ARM_PURECODE
: sindex
= 22; break;
6243 case SHF_COMDEF
: sindex
= 23; break;
6248 if (flag
== SHF_PPC_VLE
)
6255 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
6258 case ELFOSABI_FREEBSD
:
6259 if (flag
== SHF_GNU_RETAIN
)
6263 if (flag
== SHF_GNU_MBIND
)
6264 /* We should not recognize SHF_GNU_MBIND for
6265 ELFOSABI_NONE, but binutils as of 2019-07-23 did
6266 not set the EI_OSABI header byte. */
6277 if (p
!= buff
+ field_size
+ 4)
6279 if (size
< (10 + 2))
6281 warn (_("Internal error: not enough buffer room for section flag info"));
6282 return _("<unknown>");
6289 size
-= flags
[sindex
].len
;
6290 p
= stpcpy (p
, flags
[sindex
].str
);
6292 else if (flag
& SHF_MASKOS
)
6294 else if (flag
& SHF_MASKPROC
)
6297 unknown_flags
|= flag
;
6303 case SHF_WRITE
: *p
= 'W'; break;
6304 case SHF_ALLOC
: *p
= 'A'; break;
6305 case SHF_EXECINSTR
: *p
= 'X'; break;
6306 case SHF_MERGE
: *p
= 'M'; break;
6307 case SHF_STRINGS
: *p
= 'S'; break;
6308 case SHF_INFO_LINK
: *p
= 'I'; break;
6309 case SHF_LINK_ORDER
: *p
= 'L'; break;
6310 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
6311 case SHF_GROUP
: *p
= 'G'; break;
6312 case SHF_TLS
: *p
= 'T'; break;
6313 case SHF_EXCLUDE
: *p
= 'E'; break;
6314 case SHF_COMPRESSED
: *p
= 'C'; break;
6317 if ((filedata
->file_header
.e_machine
== EM_X86_64
6318 || filedata
->file_header
.e_machine
== EM_L1OM
6319 || filedata
->file_header
.e_machine
== EM_K1OM
)
6320 && flag
== SHF_X86_64_LARGE
)
6322 else if (filedata
->file_header
.e_machine
== EM_ARM
6323 && flag
== SHF_ARM_PURECODE
)
6325 else if (filedata
->file_header
.e_machine
== EM_PPC
6326 && flag
== SHF_PPC_VLE
)
6328 else if (flag
& SHF_MASKOS
)
6330 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
6333 case ELFOSABI_FREEBSD
:
6334 if (flag
== SHF_GNU_RETAIN
)
6341 if (flag
== SHF_GNU_MBIND
)
6343 /* We should not recognize SHF_GNU_MBIND for
6344 ELFOSABI_NONE, but binutils as of 2019-07-23 did
6345 not set the EI_OSABI header byte. */
6352 sh_flags
&= ~SHF_MASKOS
;
6356 else if (flag
& SHF_MASKPROC
)
6359 sh_flags
&= ~ SHF_MASKPROC
;
6369 if (do_section_details
)
6373 size
-= 5 + field_size
;
6374 if (p
!= buff
+ field_size
+ 4)
6378 warn (_("Internal error: not enough buffer room for section flag info"));
6379 return _("<unknown>");
6385 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6386 (unsigned long) os_flags
);
6387 p
+= 5 + field_size
;
6391 size
-= 7 + field_size
;
6392 if (p
!= buff
+ field_size
+ 4)
6396 warn (_("Internal error: not enough buffer room for section flag info"));
6397 return _("<unknown>");
6403 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6404 (unsigned long) proc_flags
);
6405 p
+= 7 + field_size
;
6409 size
-= 10 + field_size
;
6410 if (p
!= buff
+ field_size
+ 4)
6414 warn (_("Internal error: not enough buffer room for section flag info"));
6415 return _("<unknown>");
6421 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6422 (unsigned long) unknown_flags
);
6423 p
+= 10 + field_size
;
6431 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
6432 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6436 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6438 if (size
< sizeof (* echdr
))
6440 error (_("Compressed section is too small even for a compression header\n"));
6444 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6445 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6446 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6447 return sizeof (*echdr
);
6451 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6453 if (size
< sizeof (* echdr
))
6455 error (_("Compressed section is too small even for a compression header\n"));
6459 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6460 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6461 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6462 return sizeof (*echdr
);
6467 process_section_headers (Filedata
* filedata
)
6469 Elf_Internal_Shdr
* section
;
6472 if (filedata
->file_header
.e_shnum
== 0)
6474 /* PR binutils/12467. */
6475 if (filedata
->file_header
.e_shoff
!= 0)
6477 warn (_("possibly corrupt ELF file header - it has a non-zero"
6478 " section header offset, but no section headers\n"));
6481 else if (do_sections
)
6482 printf (_("\nThere are no sections in this file.\n"));
6487 if (do_sections
&& !do_header
)
6489 if (filedata
->is_separate
&& process_links
)
6490 printf (_("In linked file '%s': "), filedata
->file_name
);
6491 if (! filedata
->is_separate
|| process_links
)
6492 printf (ngettext ("There is %d section header, "
6493 "starting at offset 0x%lx:\n",
6494 "There are %d section headers, "
6495 "starting at offset 0x%lx:\n",
6496 filedata
->file_header
.e_shnum
),
6497 filedata
->file_header
.e_shnum
,
6498 (unsigned long) filedata
->file_header
.e_shoff
);
6501 if (!get_section_headers (filedata
, false))
6504 /* Read in the string table, so that we have names to display. */
6505 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6506 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6508 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6510 if (section
->sh_size
!= 0)
6512 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6513 1, section
->sh_size
,
6516 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6520 /* Scan the sections for the dynamic symbol table
6521 and dynamic string table and debug sections. */
6522 eh_addr_size
= is_32bit_elf
? 4 : 8;
6523 switch (filedata
->file_header
.e_machine
)
6526 case EM_MIPS_RS3_LE
:
6527 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6528 FDE addresses. However, the ABI also has a semi-official ILP32
6529 variant for which the normal FDE address size rules apply.
6531 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6532 section, where XX is the size of longs in bits. Unfortunately,
6533 earlier compilers provided no way of distinguishing ILP32 objects
6534 from LP64 objects, so if there's any doubt, we should assume that
6535 the official LP64 form is being used. */
6536 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6537 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6543 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6545 case E_H8_MACH_H8300
:
6546 case E_H8_MACH_H8300HN
:
6547 case E_H8_MACH_H8300SN
:
6548 case E_H8_MACH_H8300SXN
:
6551 case E_H8_MACH_H8300H
:
6552 case E_H8_MACH_H8300S
:
6553 case E_H8_MACH_H8300SX
:
6561 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6563 case EF_M32C_CPU_M16C
:
6570 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6573 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6574 if (section->sh_entsize != expected_entsize) \
6577 sprintf_vma (buf, section->sh_entsize); \
6578 /* Note: coded this way so that there is a single string for \
6580 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6581 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6582 (unsigned) expected_entsize); \
6583 section->sh_entsize = expected_entsize; \
6588 #define CHECK_ENTSIZE(section, i, type) \
6589 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6590 sizeof (Elf64_External_##type))
6592 for (i
= 0, section
= filedata
->section_headers
;
6593 i
< filedata
->file_header
.e_shnum
;
6596 char * name
= SECTION_NAME_PRINT (section
);
6598 /* Run some sanity checks on the headers and
6599 possibly fill in some file data as well. */
6600 switch (section
->sh_type
)
6603 if (filedata
->dynamic_symbols
!= NULL
)
6605 error (_("File contains multiple dynamic symbol tables\n"));
6609 CHECK_ENTSIZE (section
, i
, Sym
);
6610 filedata
->dynamic_symbols
6611 = get_elf_symbols (filedata
, section
, &filedata
->num_dynamic_syms
);
6612 filedata
->dynamic_symtab_section
= section
;
6616 if (streq (name
, ".dynstr"))
6618 if (filedata
->dynamic_strings
!= NULL
)
6620 error (_("File contains multiple dynamic string tables\n"));
6624 filedata
->dynamic_strings
6625 = (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6626 1, section
->sh_size
, _("dynamic strings"));
6627 filedata
->dynamic_strings_length
6628 = filedata
->dynamic_strings
== NULL
? 0 : section
->sh_size
;
6629 filedata
->dynamic_strtab_section
= section
;
6633 case SHT_SYMTAB_SHNDX
:
6635 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6637 entry
->hdr
= section
;
6638 entry
->next
= filedata
->symtab_shndx_list
;
6639 filedata
->symtab_shndx_list
= entry
;
6644 CHECK_ENTSIZE (section
, i
, Sym
);
6648 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6652 CHECK_ENTSIZE (section
, i
, Rel
);
6653 if (do_checks
&& section
->sh_size
== 0)
6654 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6658 CHECK_ENTSIZE (section
, i
, Rela
);
6659 if (do_checks
&& section
->sh_size
== 0)
6660 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6665 /* Having a zero sized section is not illegal according to the
6666 ELF standard, but it might be an indication that something
6667 is wrong. So issue a warning if we are running in lint mode. */
6668 if (do_checks
&& section
->sh_size
== 0)
6669 warn (_("Section '%s': has a size of zero - is this intended ?\n"), name
);
6676 if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6677 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6678 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6679 || do_debug_str
|| do_debug_str_offsets
|| do_debug_loc
6681 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6682 && (startswith (name
, ".debug_")
6683 || startswith (name
, ".zdebug_")))
6686 name
+= sizeof (".zdebug_") - 1;
6688 name
+= sizeof (".debug_") - 1;
6691 || (do_debug_info
&& startswith (name
, "info"))
6692 || (do_debug_info
&& startswith (name
, "types"))
6693 || (do_debug_abbrevs
&& startswith (name
, "abbrev"))
6694 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6695 || (do_debug_lines
&& startswith (name
, "line."))
6696 || (do_debug_pubnames
&& startswith (name
, "pubnames"))
6697 || (do_debug_pubtypes
&& startswith (name
, "pubtypes"))
6698 || (do_debug_pubnames
&& startswith (name
, "gnu_pubnames"))
6699 || (do_debug_pubtypes
&& startswith (name
, "gnu_pubtypes"))
6700 || (do_debug_aranges
&& startswith (name
, "aranges"))
6701 || (do_debug_ranges
&& startswith (name
, "ranges"))
6702 || (do_debug_ranges
&& startswith (name
, "rnglists"))
6703 || (do_debug_frames
&& startswith (name
, "frame"))
6704 || (do_debug_macinfo
&& startswith (name
, "macinfo"))
6705 || (do_debug_macinfo
&& startswith (name
, "macro"))
6706 || (do_debug_str
&& startswith (name
, "str"))
6707 || (do_debug_links
&& startswith (name
, "sup"))
6708 || (do_debug_str_offsets
&& startswith (name
, "str_offsets"))
6709 || (do_debug_loc
&& startswith (name
, "loc"))
6710 || (do_debug_loc
&& startswith (name
, "loclists"))
6711 || (do_debug_addr
&& startswith (name
, "addr"))
6712 || (do_debug_cu_index
&& startswith (name
, "cu_index"))
6713 || (do_debug_cu_index
&& startswith (name
, "tu_index"))
6715 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6717 /* Linkonce section to be combined with .debug_info at link time. */
6718 else if ((do_debugging
|| do_debug_info
)
6719 && startswith (name
, ".gnu.linkonce.wi."))
6720 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6721 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6722 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6723 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6724 || streq (name
, ".debug_names")))
6725 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6726 /* Trace sections for Itanium VMS. */
6727 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6728 || do_trace_aranges
)
6729 && startswith (name
, ".trace_"))
6731 name
+= sizeof (".trace_") - 1;
6734 || (do_trace_info
&& streq (name
, "info"))
6735 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6736 || (do_trace_aranges
&& streq (name
, "aranges"))
6738 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6740 else if ((do_debugging
|| do_debug_links
)
6741 && (startswith (name
, ".gnu_debuglink")
6742 || startswith (name
, ".gnu_debugaltlink")))
6743 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6749 if (filedata
->is_separate
&& ! process_links
)
6752 if (filedata
->is_separate
)
6753 printf (_("\nSection Headers in linked file '%s':\n"), filedata
->file_name
);
6754 else if (filedata
->file_header
.e_shnum
> 1)
6755 printf (_("\nSection Headers:\n"));
6757 printf (_("\nSection Header:\n"));
6761 if (do_section_details
)
6763 printf (_(" [Nr] Name\n"));
6764 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6768 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6772 if (do_section_details
)
6774 printf (_(" [Nr] Name\n"));
6775 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6779 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6783 if (do_section_details
)
6785 printf (_(" [Nr] Name\n"));
6786 printf (_(" Type Address Offset Link\n"));
6787 printf (_(" Size EntSize Info Align\n"));
6791 printf (_(" [Nr] Name Type Address Offset\n"));
6792 printf (_(" Size EntSize Flags Link Info Align\n"));
6796 if (do_section_details
)
6797 printf (_(" Flags\n"));
6799 for (i
= 0, section
= filedata
->section_headers
;
6800 i
< filedata
->file_header
.e_shnum
;
6803 /* Run some sanity checks on the section header. */
6805 /* Check the sh_link field. */
6806 switch (section
->sh_type
)
6810 if (section
->sh_link
== 0
6811 && (filedata
->file_header
.e_type
== ET_EXEC
6812 || filedata
->file_header
.e_type
== ET_DYN
))
6813 /* A dynamic relocation section where all entries use a
6814 zero symbol index need not specify a symtab section. */
6817 case SHT_SYMTAB_SHNDX
:
6821 case SHT_GNU_versym
:
6822 if (section
->sh_link
== 0
6823 || section
->sh_link
>= filedata
->file_header
.e_shnum
6824 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6825 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6826 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6827 i
, section
->sh_link
);
6833 case SHT_GNU_verneed
:
6834 case SHT_GNU_verdef
:
6835 case SHT_GNU_LIBLIST
:
6836 if (section
->sh_link
== 0
6837 || section
->sh_link
>= filedata
->file_header
.e_shnum
6838 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6839 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6840 i
, section
->sh_link
);
6843 case SHT_INIT_ARRAY
:
6844 case SHT_FINI_ARRAY
:
6845 case SHT_PREINIT_ARRAY
:
6846 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6847 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6848 i
, section
->sh_link
);
6852 /* FIXME: Add support for target specific section types. */
6853 #if 0 /* Currently we do not check other section types as there are too
6854 many special cases. Stab sections for example have a type
6855 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6857 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6858 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6859 i
, section
->sh_link
);
6864 /* Check the sh_info field. */
6865 switch (section
->sh_type
)
6869 if (section
->sh_info
== 0
6870 && (filedata
->file_header
.e_type
== ET_EXEC
6871 || filedata
->file_header
.e_type
== ET_DYN
))
6872 /* Dynamic relocations apply to segments, so they do not
6873 need to specify the section they relocate. */
6875 if (section
->sh_info
== 0
6876 || section
->sh_info
>= filedata
->file_header
.e_shnum
6877 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6878 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6879 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6880 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6881 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6882 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6883 /* FIXME: Are other section types valid ? */
6884 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6885 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6886 i
, section
->sh_info
);
6891 case SHT_SYMTAB_SHNDX
:
6892 case SHT_INIT_ARRAY
:
6893 case SHT_FINI_ARRAY
:
6894 case SHT_PREINIT_ARRAY
:
6895 if (section
->sh_info
!= 0)
6896 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6897 i
, section
->sh_info
);
6903 /* A symbol index - we assume that it is valid. */
6907 /* FIXME: Add support for target specific section types. */
6908 if (section
->sh_type
== SHT_NOBITS
)
6909 /* NOBITS section headers with non-zero sh_info fields can be
6910 created when a binary is stripped of everything but its debug
6911 information. The stripped sections have their headers
6912 preserved but their types set to SHT_NOBITS. So do not check
6913 this type of section. */
6915 else if (section
->sh_flags
& SHF_INFO_LINK
)
6917 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6918 warn (_("[%2u]: Expected link to another section in info field"), i
);
6920 else if (section
->sh_type
< SHT_LOOS
6921 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6922 && section
->sh_info
!= 0)
6923 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6924 i
, section
->sh_info
);
6928 /* Check the sh_size field. */
6929 if (section
->sh_size
> filedata
->file_size
6930 && section
->sh_type
!= SHT_NOBITS
6931 && section
->sh_type
!= SHT_NULL
6932 && section
->sh_type
< SHT_LOOS
)
6933 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6935 printf (" [%2u] ", i
);
6936 if (do_section_details
)
6937 printf ("%s\n ", printable_section_name (filedata
, section
));
6939 print_symbol (-17, SECTION_NAME_PRINT (section
));
6941 printf (do_wide
? " %-15s " : " %-15.15s ",
6942 get_section_type_name (filedata
, section
->sh_type
));
6946 const char * link_too_big
= NULL
;
6948 print_vma (section
->sh_addr
, LONG_HEX
);
6950 printf ( " %6.6lx %6.6lx %2.2lx",
6951 (unsigned long) section
->sh_offset
,
6952 (unsigned long) section
->sh_size
,
6953 (unsigned long) section
->sh_entsize
);
6955 if (do_section_details
)
6956 fputs (" ", stdout
);
6958 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6960 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6963 /* The sh_link value is out of range. Normally this indicates
6964 an error but it can have special values in Solaris binaries. */
6965 switch (filedata
->file_header
.e_machine
)
6972 case EM_OLD_SPARCV9
:
6973 case EM_SPARC32PLUS
:
6976 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6977 link_too_big
= "BEFORE";
6978 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6979 link_too_big
= "AFTER";
6986 if (do_section_details
)
6988 if (link_too_big
!= NULL
&& * link_too_big
)
6989 printf ("<%s> ", link_too_big
);
6991 printf ("%2u ", section
->sh_link
);
6992 printf ("%3u %2lu\n", section
->sh_info
,
6993 (unsigned long) section
->sh_addralign
);
6996 printf ("%2u %3u %2lu\n",
6999 (unsigned long) section
->sh_addralign
);
7001 if (link_too_big
&& ! * link_too_big
)
7002 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
7003 i
, section
->sh_link
);
7007 print_vma (section
->sh_addr
, LONG_HEX
);
7009 if ((long) section
->sh_offset
== section
->sh_offset
)
7010 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
7014 print_vma (section
->sh_offset
, LONG_HEX
);
7017 if ((unsigned long) section
->sh_size
== section
->sh_size
)
7018 printf (" %6.6lx", (unsigned long) section
->sh_size
);
7022 print_vma (section
->sh_size
, LONG_HEX
);
7025 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
7026 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
7030 print_vma (section
->sh_entsize
, LONG_HEX
);
7033 if (do_section_details
)
7034 fputs (" ", stdout
);
7036 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
7038 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
7040 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
7041 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
7044 print_vma (section
->sh_addralign
, DEC
);
7048 else if (do_section_details
)
7051 print_vma (section
->sh_addr
, LONG_HEX
);
7052 if ((long) section
->sh_offset
== section
->sh_offset
)
7053 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
7057 print_vma (section
->sh_offset
, LONG_HEX
);
7059 printf (" %u\n ", section
->sh_link
);
7060 print_vma (section
->sh_size
, LONG_HEX
);
7062 print_vma (section
->sh_entsize
, LONG_HEX
);
7064 printf (" %-16u %lu\n",
7066 (unsigned long) section
->sh_addralign
);
7071 print_vma (section
->sh_addr
, LONG_HEX
);
7072 if ((long) section
->sh_offset
== section
->sh_offset
)
7073 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
7077 print_vma (section
->sh_offset
, LONG_HEX
);
7080 print_vma (section
->sh_size
, LONG_HEX
);
7082 print_vma (section
->sh_entsize
, LONG_HEX
);
7084 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
7086 printf (" %2u %3u %lu\n",
7089 (unsigned long) section
->sh_addralign
);
7092 if (do_section_details
)
7094 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
7095 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
7097 /* Minimum section size is 12 bytes for 32-bit compression
7098 header + 12 bytes for compressed data header. */
7099 unsigned char buf
[24];
7101 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
7102 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
7103 sizeof (buf
), _("compression header")))
7105 Elf_Internal_Chdr chdr
;
7107 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
7108 printf (_(" [<corrupt>]\n"));
7111 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
7114 printf (_(" [<unknown>: 0x%x], "),
7116 print_vma (chdr
.ch_size
, LONG_HEX
);
7117 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
7124 if (!do_section_details
)
7126 /* The ordering of the letters shown here matches the ordering of the
7127 corresponding SHF_xxx values, and hence the order in which these
7128 letters will be displayed to the user. */
7129 printf (_("Key to Flags:\n\
7130 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
7131 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
7132 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
7133 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
7136 case ELFOSABI_FREEBSD
:
7137 printf (_("R (retain), "));
7140 printf (_("D (mbind), "));
7145 if (filedata
->file_header
.e_machine
== EM_X86_64
7146 || filedata
->file_header
.e_machine
== EM_L1OM
7147 || filedata
->file_header
.e_machine
== EM_K1OM
)
7148 printf (_("l (large), "));
7149 else if (filedata
->file_header
.e_machine
== EM_ARM
)
7150 printf (_("y (purecode), "));
7151 else if (filedata
->file_header
.e_machine
== EM_PPC
)
7152 printf (_("v (VLE), "));
7153 printf ("p (processor specific)\n");
7160 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
7161 Elf_Internal_Sym
**symtab
, unsigned long *nsyms
,
7162 char **strtab
, unsigned long *strtablen
)
7166 *symtab
= get_elf_symbols (filedata
, symsec
, nsyms
);
7168 if (*symtab
== NULL
)
7171 if (symsec
->sh_link
!= 0)
7173 Elf_Internal_Shdr
*strsec
;
7175 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
7177 error (_("Bad sh_link in symbol table section\n"));
7184 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7186 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7187 1, strsec
->sh_size
, _("string table"));
7188 if (*strtab
== NULL
)
7195 *strtablen
= strsec
->sh_size
;
7201 get_group_flags (unsigned int flags
)
7203 static char buff
[128];
7207 else if (flags
== GRP_COMDAT
)
7210 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
7212 flags
& GRP_MASKOS
? _("<OS specific>") : "",
7213 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
7214 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
7215 ? _("<unknown>") : ""));
7221 process_section_groups (Filedata
* filedata
)
7223 Elf_Internal_Shdr
* section
;
7225 struct group
* group
;
7226 Elf_Internal_Shdr
* symtab_sec
;
7227 Elf_Internal_Shdr
* strtab_sec
;
7228 Elf_Internal_Sym
* symtab
;
7229 unsigned long num_syms
;
7233 /* Don't process section groups unless needed. */
7234 if (!do_unwind
&& !do_section_groups
)
7237 if (filedata
->file_header
.e_shnum
== 0)
7239 if (do_section_groups
)
7241 if (filedata
->is_separate
)
7242 printf (_("\nThere are no sections group in linked file '%s'.\n"),
7243 filedata
->file_name
);
7245 printf (_("\nThere are no section groups in this file.\n"));
7250 if (filedata
->section_headers
== NULL
)
7252 error (_("Section headers are not available!\n"));
7253 /* PR 13622: This can happen with a corrupt ELF header. */
7257 filedata
->section_headers_groups
7258 = (struct group
**) calloc (filedata
->file_header
.e_shnum
,
7259 sizeof (struct group
*));
7261 if (filedata
->section_headers_groups
== NULL
)
7263 error (_("Out of memory reading %u section group headers\n"),
7264 filedata
->file_header
.e_shnum
);
7268 /* Scan the sections for the group section. */
7269 filedata
->group_count
= 0;
7270 for (i
= 0, section
= filedata
->section_headers
;
7271 i
< filedata
->file_header
.e_shnum
;
7273 if (section
->sh_type
== SHT_GROUP
)
7274 filedata
->group_count
++;
7276 if (filedata
->group_count
== 0)
7278 if (do_section_groups
)
7280 if (filedata
->is_separate
)
7281 printf (_("\nThere are no section groups in linked file '%s'.\n"),
7282 filedata
->file_name
);
7284 printf (_("\nThere are no section groups in this file.\n"));
7290 filedata
->section_groups
= (struct group
*) calloc (filedata
->group_count
,
7291 sizeof (struct group
));
7293 if (filedata
->section_groups
== NULL
)
7295 error (_("Out of memory reading %lu groups\n"),
7296 (unsigned long) filedata
->group_count
);
7307 if (filedata
->is_separate
)
7308 printf (_("Section groups in linked file '%s'\n"), filedata
->file_name
);
7310 for (i
= 0, section
= filedata
->section_headers
, group
= filedata
->section_groups
;
7311 i
< filedata
->file_header
.e_shnum
;
7314 if (section
->sh_type
== SHT_GROUP
)
7316 const char * name
= printable_section_name (filedata
, section
);
7317 const char * group_name
;
7318 unsigned char * start
;
7319 unsigned char * indices
;
7320 unsigned int entry
, j
, size
;
7321 Elf_Internal_Shdr
* sec
;
7322 Elf_Internal_Sym
* sym
;
7324 /* Get the symbol table. */
7325 if (section
->sh_link
>= filedata
->file_header
.e_shnum
7326 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
7329 error (_("Bad sh_link in group section `%s'\n"), name
);
7333 if (symtab_sec
!= sec
)
7337 symtab
= get_elf_symbols (filedata
, symtab_sec
, & num_syms
);
7342 error (_("Corrupt header in group section `%s'\n"), name
);
7346 if (section
->sh_info
>= num_syms
)
7348 error (_("Bad sh_info in group section `%s'\n"), name
);
7352 sym
= symtab
+ section
->sh_info
;
7354 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
7356 if (sym
->st_shndx
== 0
7357 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
7359 error (_("Bad sh_info in group section `%s'\n"), name
);
7363 group_name
= SECTION_NAME_PRINT (filedata
->section_headers
7372 /* Get the string table. */
7373 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
7381 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
7386 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
7387 1, strtab_sec
->sh_size
,
7389 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
7391 group_name
= sym
->st_name
< strtab_size
7392 ? strtab
+ sym
->st_name
: _("<corrupt>");
7395 /* PR 17531: file: loop. */
7396 if (section
->sh_entsize
> section
->sh_size
)
7398 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7399 printable_section_name (filedata
, section
),
7400 (unsigned long) section
->sh_entsize
,
7401 (unsigned long) section
->sh_size
);
7405 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
7406 1, section
->sh_size
,
7412 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
7413 entry
= byte_get (indices
, 4);
7416 if (do_section_groups
)
7418 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7419 get_group_flags (entry
), i
, name
, group_name
, size
);
7421 printf (_(" [Index] Name\n"));
7424 group
->group_index
= i
;
7426 for (j
= 0; j
< size
; j
++)
7428 struct group_list
* g
;
7430 entry
= byte_get (indices
, 4);
7433 if (entry
>= filedata
->file_header
.e_shnum
)
7435 static unsigned num_group_errors
= 0;
7437 if (num_group_errors
++ < 10)
7439 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7440 entry
, i
, filedata
->file_header
.e_shnum
- 1);
7441 if (num_group_errors
== 10)
7442 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7447 if (filedata
->section_headers_groups
[entry
] != NULL
)
7451 static unsigned num_errs
= 0;
7453 if (num_errs
++ < 10)
7455 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7457 filedata
->section_headers_groups
[entry
]->group_index
);
7459 warn (_("Further error messages about already contained group sections suppressed\n"));
7465 /* Intel C/C++ compiler may put section 0 in a
7466 section group. We just warn it the first time
7467 and ignore it afterwards. */
7468 static bool warned
= false;
7471 error (_("section 0 in group section [%5u]\n"),
7472 filedata
->section_headers_groups
[entry
]->group_index
);
7478 filedata
->section_headers_groups
[entry
] = group
;
7480 if (do_section_groups
)
7482 sec
= filedata
->section_headers
+ entry
;
7483 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7486 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7487 g
->section_index
= entry
;
7488 g
->next
= group
->root
;
7503 /* Data used to display dynamic fixups. */
7505 struct ia64_vms_dynfixup
7507 bfd_vma needed_ident
; /* Library ident number. */
7508 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7509 bfd_vma fixup_needed
; /* Index of the library. */
7510 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7511 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7514 /* Data used to display dynamic relocations. */
7516 struct ia64_vms_dynimgrela
7518 bfd_vma img_rela_cnt
; /* Number of relocations. */
7519 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7522 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7526 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7527 struct ia64_vms_dynfixup
* fixup
,
7528 const char * strtab
,
7529 unsigned int strtab_sz
)
7531 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7533 const char * lib_name
;
7535 imfs
= get_data (NULL
, filedata
,
7536 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
7537 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
7538 _("dynamic section image fixups"));
7542 if (fixup
->needed
< strtab_sz
)
7543 lib_name
= strtab
+ fixup
->needed
;
7546 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7547 (unsigned long) fixup
->needed
);
7551 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7552 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7554 (_("Seg Offset Type SymVec DataType\n"));
7556 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7561 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7562 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7563 type
= BYTE_GET (imfs
[i
].type
);
7564 rtype
= elf_ia64_reloc_type (type
);
7566 printf (" 0x%08x ", type
);
7568 printf (" %-32s ", rtype
);
7569 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7570 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7577 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7580 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7582 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7585 imrs
= get_data (NULL
, filedata
,
7586 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
7587 sizeof (*imrs
), imgrela
->img_rela_cnt
,
7588 _("dynamic section image relocations"));
7592 printf (_("\nImage relocs\n"));
7594 (_("Seg Offset Type Addend Seg Sym Off\n"));
7596 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7601 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7602 printf ("%08" BFD_VMA_FMT
"x ",
7603 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7604 type
= BYTE_GET (imrs
[i
].type
);
7605 rtype
= elf_ia64_reloc_type (type
);
7607 printf ("0x%08x ", type
);
7609 printf ("%-31s ", rtype
);
7610 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7611 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7612 printf ("%08" BFD_VMA_FMT
"x\n",
7613 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7620 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7623 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7625 struct ia64_vms_dynfixup fixup
;
7626 struct ia64_vms_dynimgrela imgrela
;
7627 Elf_Internal_Dyn
*entry
;
7628 bfd_vma strtab_off
= 0;
7629 bfd_vma strtab_sz
= 0;
7630 char *strtab
= NULL
;
7633 memset (&fixup
, 0, sizeof (fixup
));
7634 memset (&imgrela
, 0, sizeof (imgrela
));
7636 /* Note: the order of the entries is specified by the OpenVMS specs. */
7637 for (entry
= filedata
->dynamic_section
;
7638 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
7641 switch (entry
->d_tag
)
7643 case DT_IA_64_VMS_STRTAB_OFFSET
:
7644 strtab_off
= entry
->d_un
.d_val
;
7647 strtab_sz
= entry
->d_un
.d_val
;
7649 strtab
= get_data (NULL
, filedata
,
7650 filedata
->dynamic_addr
+ strtab_off
,
7651 1, strtab_sz
, _("dynamic string section"));
7656 case DT_IA_64_VMS_NEEDED_IDENT
:
7657 fixup
.needed_ident
= entry
->d_un
.d_val
;
7660 fixup
.needed
= entry
->d_un
.d_val
;
7662 case DT_IA_64_VMS_FIXUP_NEEDED
:
7663 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7665 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7666 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7668 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7669 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7670 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7673 case DT_IA_64_VMS_IMG_RELA_CNT
:
7674 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7676 case DT_IA_64_VMS_IMG_RELA_OFF
:
7677 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7678 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7699 dynamic_relocations
[] =
7701 { "REL", DT_REL
, DT_RELSZ
, false },
7702 { "RELA", DT_RELA
, DT_RELASZ
, true },
7703 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7706 /* Process the reloc section. */
7709 process_relocs (Filedata
* filedata
)
7711 unsigned long rel_size
;
7712 unsigned long rel_offset
;
7717 if (do_using_dynamic
)
7721 bool has_dynamic_reloc
;
7724 has_dynamic_reloc
= false;
7726 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7728 is_rela
= dynamic_relocations
[i
].rela
;
7729 name
= dynamic_relocations
[i
].name
;
7730 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
7731 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
7734 has_dynamic_reloc
= true;
7736 if (is_rela
== UNKNOWN
)
7738 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7739 switch (filedata
->dynamic_info
[DT_PLTREL
])
7752 if (filedata
->is_separate
)
7754 (_("\nIn linked file '%s' section '%s' at offset 0x%lx contains %ld bytes:\n"),
7755 filedata
->file_name
, name
, rel_offset
, rel_size
);
7758 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7759 name
, rel_offset
, rel_size
);
7761 dump_relocations (filedata
,
7762 offset_from_vma (filedata
, rel_offset
, rel_size
),
7764 filedata
->dynamic_symbols
,
7765 filedata
->num_dynamic_syms
,
7766 filedata
->dynamic_strings
,
7767 filedata
->dynamic_strings_length
,
7768 is_rela
, true /* is_dynamic */);
7772 if (is_ia64_vms (filedata
))
7773 if (process_ia64_vms_dynamic_relocs (filedata
))
7774 has_dynamic_reloc
= true;
7776 if (! has_dynamic_reloc
)
7778 if (filedata
->is_separate
)
7779 printf (_("\nThere are no dynamic relocations in linked file '%s'.\n"),
7780 filedata
->file_name
);
7782 printf (_("\nThere are no dynamic relocations in this file.\n"));
7787 Elf_Internal_Shdr
* section
;
7791 for (i
= 0, section
= filedata
->section_headers
;
7792 i
< filedata
->file_header
.e_shnum
;
7795 if ( section
->sh_type
!= SHT_RELA
7796 && section
->sh_type
!= SHT_REL
)
7799 rel_offset
= section
->sh_offset
;
7800 rel_size
= section
->sh_size
;
7805 unsigned long num_rela
;
7807 if (filedata
->is_separate
)
7808 printf (_("\nIn linked file '%s' relocation section "),
7809 filedata
->file_name
);
7811 printf (_("\nRelocation section "));
7813 if (filedata
->string_table
== NULL
)
7814 printf ("%d", section
->sh_name
);
7816 printf ("'%s'", printable_section_name (filedata
, section
));
7818 num_rela
= rel_size
/ section
->sh_entsize
;
7819 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7820 " at offset 0x%lx contains %lu entries:\n",
7822 rel_offset
, num_rela
);
7824 is_rela
= section
->sh_type
== SHT_RELA
;
7826 if (section
->sh_link
!= 0
7827 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7829 Elf_Internal_Shdr
* symsec
;
7830 Elf_Internal_Sym
* symtab
;
7831 unsigned long nsyms
;
7832 unsigned long strtablen
= 0;
7833 char * strtab
= NULL
;
7835 symsec
= filedata
->section_headers
+ section
->sh_link
;
7836 if (symsec
->sh_type
!= SHT_SYMTAB
7837 && symsec
->sh_type
!= SHT_DYNSYM
)
7840 if (!get_symtab (filedata
, symsec
,
7841 &symtab
, &nsyms
, &strtab
, &strtablen
))
7844 dump_relocations (filedata
, rel_offset
, rel_size
,
7845 symtab
, nsyms
, strtab
, strtablen
,
7847 symsec
->sh_type
== SHT_DYNSYM
);
7852 dump_relocations (filedata
, rel_offset
, rel_size
,
7853 NULL
, 0, NULL
, 0, is_rela
,
7854 false /* is_dynamic */);
7862 /* Users sometimes forget the -D option, so try to be helpful. */
7863 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7865 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
7867 if (filedata
->is_separate
)
7868 printf (_("\nThere are no static relocations in linked file '%s'."),
7869 filedata
->file_name
);
7871 printf (_("\nThere are no static relocations in this file."));
7872 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7877 if (i
== ARRAY_SIZE (dynamic_relocations
))
7879 if (filedata
->is_separate
)
7880 printf (_("\nThere are no relocations in linked file '%s'.\n"),
7881 filedata
->file_name
);
7883 printf (_("\nThere are no relocations in this file.\n"));
7891 /* An absolute address consists of a section and an offset. If the
7892 section is NULL, the offset itself is the address, otherwise, the
7893 address equals to LOAD_ADDRESS(section) + offset. */
7897 unsigned short section
;
7901 /* Find the nearest symbol at or below ADDR. Returns the symbol
7902 name, if found, and the offset from the symbol to ADDR. */
7905 find_symbol_for_address (Filedata
* filedata
,
7906 Elf_Internal_Sym
* symtab
,
7907 unsigned long nsyms
,
7908 const char * strtab
,
7909 unsigned long strtab_size
,
7910 struct absaddr addr
,
7911 const char ** symname
,
7914 bfd_vma dist
= 0x100000;
7915 Elf_Internal_Sym
* sym
;
7916 Elf_Internal_Sym
* beg
;
7917 Elf_Internal_Sym
* end
;
7918 Elf_Internal_Sym
* best
= NULL
;
7920 REMOVE_ARCH_BITS (addr
.offset
);
7922 end
= symtab
+ nsyms
;
7928 sym
= beg
+ (end
- beg
) / 2;
7930 value
= sym
->st_value
;
7931 REMOVE_ARCH_BITS (value
);
7933 if (sym
->st_name
!= 0
7934 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7935 && addr
.offset
>= value
7936 && addr
.offset
- value
< dist
)
7939 dist
= addr
.offset
- value
;
7944 if (addr
.offset
< value
)
7952 *symname
= (best
->st_name
>= strtab_size
7953 ? _("<corrupt>") : strtab
+ best
->st_name
);
7959 *offset
= addr
.offset
;
7962 static /* signed */ int
7963 symcmp (const void *p
, const void *q
)
7965 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7966 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7968 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7971 /* Process the unwind section. */
7973 #include "unwind-ia64.h"
7975 struct ia64_unw_table_entry
7977 struct absaddr start
;
7979 struct absaddr info
;
7982 struct ia64_unw_aux_info
7984 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7985 unsigned long table_len
; /* Length of unwind table. */
7986 unsigned char * info
; /* Unwind info. */
7987 unsigned long info_size
; /* Size of unwind info. */
7988 bfd_vma info_addr
; /* Starting address of unwind info. */
7989 bfd_vma seg_base
; /* Starting address of segment. */
7990 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7991 unsigned long nsyms
; /* Number of symbols. */
7992 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7993 unsigned long nfuns
; /* Number of entries in funtab. */
7994 char * strtab
; /* The string table. */
7995 unsigned long strtab_size
; /* Size of string table. */
7999 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
8001 struct ia64_unw_table_entry
* tp
;
8002 unsigned long j
, nfuns
;
8006 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8007 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8008 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8009 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8011 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8013 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8017 const unsigned char * dp
;
8018 const unsigned char * head
;
8019 const unsigned char * end
;
8020 const char * procname
;
8022 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8023 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
8025 fputs ("\n<", stdout
);
8029 fputs (procname
, stdout
);
8032 printf ("+%lx", (unsigned long) offset
);
8035 fputs (">: [", stdout
);
8036 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8037 fputc ('-', stdout
);
8038 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8039 printf ("], info at +0x%lx\n",
8040 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
8042 /* PR 17531: file: 86232b32. */
8043 if (aux
->info
== NULL
)
8046 offset
= tp
->info
.offset
;
8047 if (tp
->info
.section
)
8049 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
8051 warn (_("Invalid section %u in table entry %ld\n"),
8052 tp
->info
.section
, (long) (tp
- aux
->table
));
8056 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
8058 offset
-= aux
->info_addr
;
8059 /* PR 17531: file: 0997b4d1. */
8060 if (offset
>= aux
->info_size
8061 || aux
->info_size
- offset
< 8)
8063 warn (_("Invalid offset %lx in table entry %ld\n"),
8064 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
8069 head
= aux
->info
+ offset
;
8070 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
8072 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
8073 (unsigned) UNW_VER (stamp
),
8074 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
8075 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
8076 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
8077 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
8079 if (UNW_VER (stamp
) != 1)
8081 printf (_("\tUnknown version.\n"));
8086 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
8087 /* PR 17531: file: 16ceda89. */
8088 if (end
> aux
->info
+ aux
->info_size
)
8089 end
= aux
->info
+ aux
->info_size
;
8090 for (dp
= head
+ 8; dp
< end
;)
8091 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
8100 slurp_ia64_unwind_table (Filedata
* filedata
,
8101 struct ia64_unw_aux_info
* aux
,
8102 Elf_Internal_Shdr
* sec
)
8104 unsigned long size
, nrelas
, i
;
8105 Elf_Internal_Phdr
* seg
;
8106 struct ia64_unw_table_entry
* tep
;
8107 Elf_Internal_Shdr
* relsec
;
8108 Elf_Internal_Rela
* rela
;
8109 Elf_Internal_Rela
* rp
;
8110 unsigned char * table
;
8112 Elf_Internal_Sym
* sym
;
8113 const char * relname
;
8117 /* First, find the starting address of the segment that includes
8120 if (filedata
->file_header
.e_phnum
)
8122 if (! get_program_headers (filedata
))
8125 for (seg
= filedata
->program_headers
;
8126 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8129 if (seg
->p_type
!= PT_LOAD
)
8132 if (sec
->sh_addr
>= seg
->p_vaddr
8133 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8135 aux
->seg_base
= seg
->p_vaddr
;
8141 /* Second, build the unwind table from the contents of the unwind section: */
8142 size
= sec
->sh_size
;
8143 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8148 aux
->table_len
= size
/ (3 * eh_addr_size
);
8149 aux
->table
= (struct ia64_unw_table_entry
*)
8150 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
8153 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
8155 tep
->start
.section
= SHN_UNDEF
;
8156 tep
->end
.section
= SHN_UNDEF
;
8157 tep
->info
.section
= SHN_UNDEF
;
8158 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8159 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8160 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8161 tep
->start
.offset
+= aux
->seg_base
;
8162 tep
->end
.offset
+= aux
->seg_base
;
8163 tep
->info
.offset
+= aux
->seg_base
;
8167 /* Third, apply any relocations to the unwind table: */
8168 for (relsec
= filedata
->section_headers
;
8169 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8172 if (relsec
->sh_type
!= SHT_RELA
8173 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8174 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8177 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8186 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8188 unsigned int sym_ndx
;
8189 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8190 relname
= elf_ia64_reloc_type (r_type
);
8192 /* PR 17531: file: 9fa67536. */
8193 if (relname
== NULL
)
8195 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8199 if (! startswith (relname
, "R_IA64_SEGREL"))
8201 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8205 i
= rp
->r_offset
/ (3 * eh_addr_size
);
8207 /* PR 17531: file: 5bc8d9bf. */
8208 if (i
>= aux
->table_len
)
8210 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8214 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8215 if (sym_ndx
>= aux
->nsyms
)
8217 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8221 sym
= aux
->symtab
+ sym_ndx
;
8223 switch (rp
->r_offset
/ eh_addr_size
% 3)
8226 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8227 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
8230 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8231 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
8234 aux
->table
[i
].info
.section
= sym
->st_shndx
;
8235 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
8249 ia64_process_unwind (Filedata
* filedata
)
8251 Elf_Internal_Shdr
* sec
;
8252 Elf_Internal_Shdr
* unwsec
= NULL
;
8253 unsigned long i
, unwcount
= 0, unwstart
= 0;
8254 struct ia64_unw_aux_info aux
;
8257 memset (& aux
, 0, sizeof (aux
));
8259 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8261 if (sec
->sh_type
== SHT_SYMTAB
)
8265 error (_("Multiple symbol tables encountered\n"));
8271 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8272 &aux
.strtab
, &aux
.strtab_size
))
8275 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8280 printf (_("\nThere are no unwind sections in this file.\n"));
8282 while (unwcount
-- > 0)
8287 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
8288 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8289 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8294 /* We have already counted the number of SHT_IA64_UNWIND
8295 sections so the loop above should never fail. */
8296 assert (unwsec
!= NULL
);
8299 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
8301 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
8303 /* We need to find which section group it is in. */
8304 struct group_list
* g
;
8306 if (filedata
->section_headers_groups
== NULL
8307 || filedata
->section_headers_groups
[i
] == NULL
)
8308 i
= filedata
->file_header
.e_shnum
;
8311 g
= filedata
->section_headers_groups
[i
]->root
;
8313 for (; g
!= NULL
; g
= g
->next
)
8315 sec
= filedata
->section_headers
+ g
->section_index
;
8317 if (SECTION_NAME_VALID (sec
)
8318 && streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
8323 i
= filedata
->file_header
.e_shnum
;
8326 else if (SECTION_NAME_VALID (unwsec
)
8327 && startswith (SECTION_NAME (unwsec
),
8328 ELF_STRING_ia64_unwind_once
))
8330 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
8331 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
8332 suffix
= SECTION_NAME (unwsec
) + len
;
8333 for (i
= 0, sec
= filedata
->section_headers
;
8334 i
< filedata
->file_header
.e_shnum
;
8336 if (SECTION_NAME_VALID (sec
)
8337 && startswith (SECTION_NAME (sec
),
8338 ELF_STRING_ia64_unwind_info_once
)
8339 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8344 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
8345 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
8346 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
8347 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
8349 if (SECTION_NAME_VALID (unwsec
)
8350 && startswith (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
))
8351 suffix
= SECTION_NAME (unwsec
) + len
;
8352 for (i
= 0, sec
= filedata
->section_headers
;
8353 i
< filedata
->file_header
.e_shnum
;
8355 if (SECTION_NAME_VALID (sec
)
8356 && startswith (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
)
8357 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8361 if (i
== filedata
->file_header
.e_shnum
)
8363 printf (_("\nCould not find unwind info section for "));
8365 if (filedata
->string_table
== NULL
)
8366 printf ("%d", unwsec
->sh_name
);
8368 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8372 aux
.info_addr
= sec
->sh_addr
;
8373 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
8376 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
8378 printf (_("\nUnwind section "));
8380 if (filedata
->string_table
== NULL
)
8381 printf ("%d", unwsec
->sh_name
);
8383 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8385 printf (_(" at offset 0x%lx contains %lu entries:\n"),
8386 (unsigned long) unwsec
->sh_offset
,
8387 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
8389 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
8390 && aux
.table_len
> 0)
8391 dump_ia64_unwind (filedata
, & aux
);
8393 free ((char *) aux
.table
);
8394 free ((char *) aux
.info
);
8401 free ((char *) aux
.strtab
);
8406 struct hppa_unw_table_entry
8408 struct absaddr start
;
8410 unsigned int Cannot_unwind
:1; /* 0 */
8411 unsigned int Millicode
:1; /* 1 */
8412 unsigned int Millicode_save_sr0
:1; /* 2 */
8413 unsigned int Region_description
:2; /* 3..4 */
8414 unsigned int reserved1
:1; /* 5 */
8415 unsigned int Entry_SR
:1; /* 6 */
8416 unsigned int Entry_FR
:4; /* Number saved 7..10 */
8417 unsigned int Entry_GR
:5; /* Number saved 11..15 */
8418 unsigned int Args_stored
:1; /* 16 */
8419 unsigned int Variable_Frame
:1; /* 17 */
8420 unsigned int Separate_Package_Body
:1; /* 18 */
8421 unsigned int Frame_Extension_Millicode
:1; /* 19 */
8422 unsigned int Stack_Overflow_Check
:1; /* 20 */
8423 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
8424 unsigned int Ada_Region
:1; /* 22 */
8425 unsigned int cxx_info
:1; /* 23 */
8426 unsigned int cxx_try_catch
:1; /* 24 */
8427 unsigned int sched_entry_seq
:1; /* 25 */
8428 unsigned int reserved2
:1; /* 26 */
8429 unsigned int Save_SP
:1; /* 27 */
8430 unsigned int Save_RP
:1; /* 28 */
8431 unsigned int Save_MRP_in_frame
:1; /* 29 */
8432 unsigned int extn_ptr_defined
:1; /* 30 */
8433 unsigned int Cleanup_defined
:1; /* 31 */
8435 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
8436 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
8437 unsigned int Large_frame
:1; /* 2 */
8438 unsigned int Pseudo_SP_Set
:1; /* 3 */
8439 unsigned int reserved4
:1; /* 4 */
8440 unsigned int Total_frame_size
:27; /* 5..31 */
8443 struct hppa_unw_aux_info
8445 struct hppa_unw_table_entry
* table
; /* Unwind table. */
8446 unsigned long table_len
; /* Length of unwind table. */
8447 bfd_vma seg_base
; /* Starting address of segment. */
8448 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8449 unsigned long nsyms
; /* Number of symbols. */
8450 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8451 unsigned long nfuns
; /* Number of entries in funtab. */
8452 char * strtab
; /* The string table. */
8453 unsigned long strtab_size
; /* Size of string table. */
8457 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8459 struct hppa_unw_table_entry
* tp
;
8460 unsigned long j
, nfuns
;
8463 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8464 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8465 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8466 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8468 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8470 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8473 const char * procname
;
8475 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8476 aux
->strtab_size
, tp
->start
, &procname
,
8479 fputs ("\n<", stdout
);
8483 fputs (procname
, stdout
);
8486 printf ("+%lx", (unsigned long) offset
);
8489 fputs (">: [", stdout
);
8490 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8491 fputc ('-', stdout
);
8492 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8495 #define PF(_m) if (tp->_m) printf (#_m " ");
8496 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8499 PF(Millicode_save_sr0
);
8500 /* PV(Region_description); */
8506 PF(Separate_Package_Body
);
8507 PF(Frame_Extension_Millicode
);
8508 PF(Stack_Overflow_Check
);
8509 PF(Two_Instruction_SP_Increment
);
8513 PF(sched_entry_seq
);
8516 PF(Save_MRP_in_frame
);
8517 PF(extn_ptr_defined
);
8518 PF(Cleanup_defined
);
8519 PF(MPE_XL_interrupt_marker
);
8520 PF(HP_UX_interrupt_marker
);
8523 PV(Total_frame_size
);
8536 slurp_hppa_unwind_table (Filedata
* filedata
,
8537 struct hppa_unw_aux_info
* aux
,
8538 Elf_Internal_Shdr
* sec
)
8540 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8541 Elf_Internal_Phdr
* seg
;
8542 struct hppa_unw_table_entry
* tep
;
8543 Elf_Internal_Shdr
* relsec
;
8544 Elf_Internal_Rela
* rela
;
8545 Elf_Internal_Rela
* rp
;
8546 unsigned char * table
;
8548 Elf_Internal_Sym
* sym
;
8549 const char * relname
;
8551 /* First, find the starting address of the segment that includes
8553 if (filedata
->file_header
.e_phnum
)
8555 if (! get_program_headers (filedata
))
8558 for (seg
= filedata
->program_headers
;
8559 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8562 if (seg
->p_type
!= PT_LOAD
)
8565 if (sec
->sh_addr
>= seg
->p_vaddr
8566 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8568 aux
->seg_base
= seg
->p_vaddr
;
8574 /* Second, build the unwind table from the contents of the unwind
8576 size
= sec
->sh_size
;
8577 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8583 nentries
= size
/ unw_ent_size
;
8584 size
= unw_ent_size
* nentries
;
8586 aux
->table_len
= nentries
;
8587 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8588 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8590 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8592 unsigned int tmp1
, tmp2
;
8594 tep
->start
.section
= SHN_UNDEF
;
8595 tep
->end
.section
= SHN_UNDEF
;
8597 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8598 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8599 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8600 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8602 tep
->start
.offset
+= aux
->seg_base
;
8603 tep
->end
.offset
+= aux
->seg_base
;
8605 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8606 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8607 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8608 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8609 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8610 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8611 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8612 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8613 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8614 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8615 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8616 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8617 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8618 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8619 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8620 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8621 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8622 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8623 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8624 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8625 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8626 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8627 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8628 tep
->Cleanup_defined
= tmp1
& 0x1;
8630 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8631 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8632 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8633 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8634 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8635 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8639 /* Third, apply any relocations to the unwind table. */
8640 for (relsec
= filedata
->section_headers
;
8641 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8644 if (relsec
->sh_type
!= SHT_RELA
8645 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8646 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8649 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8653 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8655 unsigned int sym_ndx
;
8656 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8657 relname
= elf_hppa_reloc_type (r_type
);
8659 if (relname
== NULL
)
8661 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8665 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8666 if (! startswith (relname
, "R_PARISC_SEGREL"))
8668 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8672 i
= rp
->r_offset
/ unw_ent_size
;
8673 if (i
>= aux
->table_len
)
8675 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8679 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8680 if (sym_ndx
>= aux
->nsyms
)
8682 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8686 sym
= aux
->symtab
+ sym_ndx
;
8688 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8691 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8692 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8695 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8696 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8710 hppa_process_unwind (Filedata
* filedata
)
8712 struct hppa_unw_aux_info aux
;
8713 Elf_Internal_Shdr
* unwsec
= NULL
;
8714 Elf_Internal_Shdr
* sec
;
8718 if (filedata
->string_table
== NULL
)
8721 memset (& aux
, 0, sizeof (aux
));
8723 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8725 if (sec
->sh_type
== SHT_SYMTAB
)
8729 error (_("Multiple symbol tables encountered\n"));
8735 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8736 &aux
.strtab
, &aux
.strtab_size
))
8739 else if (SECTION_NAME_VALID (sec
)
8740 && streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8745 printf (_("\nThere are no unwind sections in this file.\n"));
8747 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8749 if (SECTION_NAME_VALID (sec
)
8750 && streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8752 unsigned long num_unwind
= sec
->sh_size
/ 16;
8754 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8755 "contains %lu entry:\n",
8756 "\nUnwind section '%s' at offset 0x%lx "
8757 "contains %lu entries:\n",
8759 printable_section_name (filedata
, sec
),
8760 (unsigned long) sec
->sh_offset
,
8763 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8766 if (res
&& aux
.table_len
> 0)
8768 if (! dump_hppa_unwind (filedata
, &aux
))
8772 free ((char *) aux
.table
);
8778 free ((char *) aux
.strtab
);
8785 unsigned char * data
; /* The unwind data. */
8786 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8787 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8788 unsigned long nrelas
; /* The number of relocations. */
8789 unsigned int rel_type
; /* REL or RELA ? */
8790 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8793 struct arm_unw_aux_info
8795 Filedata
* filedata
; /* The file containing the unwind sections. */
8796 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8797 unsigned long nsyms
; /* Number of symbols. */
8798 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8799 unsigned long nfuns
; /* Number of these symbols. */
8800 char * strtab
; /* The file's string table. */
8801 unsigned long strtab_size
; /* Size of string table. */
8805 arm_print_vma_and_name (Filedata
* filedata
,
8806 struct arm_unw_aux_info
* aux
,
8808 struct absaddr addr
)
8810 const char *procname
;
8813 if (addr
.section
== SHN_UNDEF
)
8816 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8817 aux
->strtab_size
, addr
, &procname
,
8820 print_vma (fn
, PREFIX_HEX
);
8824 fputs (" <", stdout
);
8825 fputs (procname
, stdout
);
8828 printf ("+0x%lx", (unsigned long) sym_offset
);
8829 fputc ('>', stdout
);
8836 arm_free_section (struct arm_section
*arm_sec
)
8838 free (arm_sec
->data
);
8839 free (arm_sec
->rela
);
8842 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8843 cached section and install SEC instead.
8844 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8845 and return its valued in * WORDP, relocating if necessary.
8846 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8847 relocation's offset in ADDR.
8848 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8849 into the string table of the symbol associated with the reloc. If no
8850 reloc was applied store -1 there.
8851 5) Return TRUE upon success, FALSE otherwise. */
8854 get_unwind_section_word (Filedata
* filedata
,
8855 struct arm_unw_aux_info
* aux
,
8856 struct arm_section
* arm_sec
,
8857 Elf_Internal_Shdr
* sec
,
8858 bfd_vma word_offset
,
8859 unsigned int * wordp
,
8860 struct absaddr
* addr
,
8863 Elf_Internal_Rela
*rp
;
8864 Elf_Internal_Sym
*sym
;
8865 const char * relname
;
8869 if (sec
== NULL
|| arm_sec
== NULL
)
8872 addr
->section
= SHN_UNDEF
;
8875 if (sym_name
!= NULL
)
8876 *sym_name
= (bfd_vma
) -1;
8878 /* If necessary, update the section cache. */
8879 if (sec
!= arm_sec
->sec
)
8881 Elf_Internal_Shdr
*relsec
;
8883 arm_free_section (arm_sec
);
8886 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8887 sec
->sh_size
, _("unwind data"));
8888 arm_sec
->rela
= NULL
;
8889 arm_sec
->nrelas
= 0;
8891 for (relsec
= filedata
->section_headers
;
8892 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8895 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8896 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8897 /* PR 15745: Check the section type as well. */
8898 || (relsec
->sh_type
!= SHT_REL
8899 && relsec
->sh_type
!= SHT_RELA
))
8902 arm_sec
->rel_type
= relsec
->sh_type
;
8903 if (relsec
->sh_type
== SHT_REL
)
8905 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8907 & arm_sec
->rela
, & arm_sec
->nrelas
))
8910 else /* relsec->sh_type == SHT_RELA */
8912 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8914 & arm_sec
->rela
, & arm_sec
->nrelas
))
8920 arm_sec
->next_rela
= arm_sec
->rela
;
8923 /* If there is no unwind data we can do nothing. */
8924 if (arm_sec
->data
== NULL
)
8927 /* If the offset is invalid then fail. */
8928 if (/* PR 21343 *//* PR 18879 */
8930 || word_offset
> (sec
->sh_size
- 4)
8931 || ((bfd_signed_vma
) word_offset
) < 0)
8934 /* Get the word at the required offset. */
8935 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8937 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8938 if (arm_sec
->rela
== NULL
)
8944 /* Look through the relocs to find the one that applies to the provided offset. */
8946 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8948 bfd_vma prelval
, offset
;
8950 if (rp
->r_offset
> word_offset
&& !wrapped
)
8955 if (rp
->r_offset
> word_offset
)
8958 if (rp
->r_offset
& 3)
8960 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8961 (unsigned long) rp
->r_offset
);
8965 if (rp
->r_offset
< word_offset
)
8968 /* PR 17531: file: 027-161405-0.004 */
8969 if (aux
->symtab
== NULL
)
8972 if (arm_sec
->rel_type
== SHT_REL
)
8974 offset
= word
& 0x7fffffff;
8975 if (offset
& 0x40000000)
8976 offset
|= ~ (bfd_vma
) 0x7fffffff;
8978 else if (arm_sec
->rel_type
== SHT_RELA
)
8979 offset
= rp
->r_addend
;
8982 error (_("Unknown section relocation type %d encountered\n"),
8987 /* PR 17531 file: 027-1241568-0.004. */
8988 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8990 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8991 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8995 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8996 offset
+= sym
->st_value
;
8997 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8999 /* Check that we are processing the expected reloc type. */
9000 if (filedata
->file_header
.e_machine
== EM_ARM
)
9002 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
9003 if (relname
== NULL
)
9005 warn (_("Skipping unknown ARM relocation type: %d\n"),
9006 (int) ELF32_R_TYPE (rp
->r_info
));
9010 if (streq (relname
, "R_ARM_NONE"))
9013 if (! streq (relname
, "R_ARM_PREL31"))
9015 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
9019 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9021 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
9022 if (relname
== NULL
)
9024 warn (_("Skipping unknown C6000 relocation type: %d\n"),
9025 (int) ELF32_R_TYPE (rp
->r_info
));
9029 if (streq (relname
, "R_C6000_NONE"))
9032 if (! streq (relname
, "R_C6000_PREL31"))
9034 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
9042 /* This function currently only supports ARM and TI unwinders. */
9043 warn (_("Only TI and ARM unwinders are currently supported\n"));
9047 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
9048 addr
->section
= sym
->st_shndx
;
9049 addr
->offset
= offset
;
9052 * sym_name
= sym
->st_name
;
9057 arm_sec
->next_rela
= rp
;
9062 static const char *tic6x_unwind_regnames
[16] =
9064 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
9065 "A14", "A13", "A12", "A11", "A10",
9066 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
9070 decode_tic6x_unwind_regmask (unsigned int mask
)
9074 for (i
= 12; mask
; mask
>>= 1, i
--)
9078 fputs (tic6x_unwind_regnames
[i
], stdout
);
9080 fputs (", ", stdout
);
9086 if (remaining == 0 && more_words) \
9089 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
9090 data_offset, & word, & addr, NULL)) \
9096 #define GET_OP(OP) \
9101 (OP) = word >> 24; \
9106 printf (_("[Truncated opcode]\n")); \
9109 printf ("0x%02x ", OP)
9112 decode_arm_unwind_bytecode (Filedata
* filedata
,
9113 struct arm_unw_aux_info
* aux
,
9115 unsigned int remaining
,
9116 unsigned int more_words
,
9117 bfd_vma data_offset
,
9118 Elf_Internal_Shdr
* data_sec
,
9119 struct arm_section
* data_arm_sec
)
9121 struct absaddr addr
;
9124 /* Decode the unwinding instructions. */
9127 unsigned int op
, op2
;
9136 printf (" 0x%02x ", op
);
9138 if ((op
& 0xc0) == 0x00)
9140 int offset
= ((op
& 0x3f) << 2) + 4;
9142 printf (" vsp = vsp + %d", offset
);
9144 else if ((op
& 0xc0) == 0x40)
9146 int offset
= ((op
& 0x3f) << 2) + 4;
9148 printf (" vsp = vsp - %d", offset
);
9150 else if ((op
& 0xf0) == 0x80)
9153 if (op
== 0x80 && op2
== 0)
9154 printf (_("Refuse to unwind"));
9157 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
9162 for (i
= 0; i
< 12; i
++)
9163 if (mask
& (1 << i
))
9169 printf ("r%d", 4 + i
);
9174 else if ((op
& 0xf0) == 0x90)
9176 if (op
== 0x9d || op
== 0x9f)
9177 printf (_(" [Reserved]"));
9179 printf (" vsp = r%d", op
& 0x0f);
9181 else if ((op
& 0xf0) == 0xa0)
9183 int end
= 4 + (op
& 0x07);
9188 for (i
= 4; i
<= end
; i
++)
9204 else if (op
== 0xb0)
9205 printf (_(" finish"));
9206 else if (op
== 0xb1)
9209 if (op2
== 0 || (op2
& 0xf0) != 0)
9210 printf (_("[Spare]"));
9213 unsigned int mask
= op2
& 0x0f;
9218 for (i
= 0; i
< 12; i
++)
9219 if (mask
& (1 << i
))
9230 else if (op
== 0xb2)
9232 unsigned char buf
[9];
9233 unsigned int i
, len
;
9234 unsigned long offset
;
9236 for (i
= 0; i
< sizeof (buf
); i
++)
9239 if ((buf
[i
] & 0x80) == 0)
9242 if (i
== sizeof (buf
))
9244 error (_("corrupt change to vsp\n"));
9249 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
9250 assert (len
== i
+ 1);
9251 offset
= offset
* 4 + 0x204;
9252 printf ("vsp = vsp + %ld", offset
);
9255 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
9257 unsigned int first
, last
;
9264 printf ("pop {D%d", first
);
9266 printf ("-D%d", first
+ last
);
9269 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
9271 unsigned int count
= op
& 0x07;
9275 printf ("-D%d", 8 + count
);
9278 else if (op
>= 0xc0 && op
<= 0xc5)
9280 unsigned int count
= op
& 0x07;
9282 printf (" pop {wR10");
9284 printf ("-wR%d", 10 + count
);
9287 else if (op
== 0xc6)
9289 unsigned int first
, last
;
9294 printf ("pop {wR%d", first
);
9296 printf ("-wR%d", first
+ last
);
9299 else if (op
== 0xc7)
9302 if (op2
== 0 || (op2
& 0xf0) != 0)
9303 printf (_("[Spare]"));
9306 unsigned int mask
= op2
& 0x0f;
9311 for (i
= 0; i
< 4; i
++)
9312 if (mask
& (1 << i
))
9318 printf ("wCGR%d", i
);
9325 printf (_(" [unsupported opcode]"));
9336 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
9337 struct arm_unw_aux_info
* aux
,
9339 unsigned int remaining
,
9340 unsigned int more_words
,
9341 bfd_vma data_offset
,
9342 Elf_Internal_Shdr
* data_sec
,
9343 struct arm_section
* data_arm_sec
)
9345 struct absaddr addr
;
9347 /* Decode the unwinding instructions. */
9350 unsigned int op
, op2
;
9359 printf (" 0x%02x ", op
);
9361 if ((op
& 0xc0) == 0x00)
9363 int offset
= ((op
& 0x3f) << 3) + 8;
9364 printf (" sp = sp + %d", offset
);
9366 else if ((op
& 0xc0) == 0x80)
9369 if (op
== 0x80 && op2
== 0)
9370 printf (_("Refuse to unwind"));
9373 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
9375 printf ("pop compact {");
9379 decode_tic6x_unwind_regmask (mask
);
9383 else if ((op
& 0xf0) == 0xc0)
9391 unsigned int offset
;
9395 /* Scan entire instruction first so that GET_OP output is not
9396 interleaved with disassembly. */
9398 for (i
= 0; nregs
< (op
& 0xf); i
++)
9404 regpos
[nregs
].offset
= i
* 2;
9405 regpos
[nregs
].reg
= reg
;
9412 regpos
[nregs
].offset
= i
* 2 + 1;
9413 regpos
[nregs
].reg
= reg
;
9418 printf (_("pop frame {"));
9421 printf (_("*corrupt* - no registers specified"));
9426 for (i
= i
* 2; i
> 0; i
--)
9428 if (regpos
[reg
].offset
== i
- 1)
9430 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
9437 fputs (name
, stdout
);
9445 else if (op
== 0xd0)
9446 printf (" MOV FP, SP");
9447 else if (op
== 0xd1)
9448 printf (" __c6xabi_pop_rts");
9449 else if (op
== 0xd2)
9451 unsigned char buf
[9];
9452 unsigned int i
, len
;
9453 unsigned long offset
;
9455 for (i
= 0; i
< sizeof (buf
); i
++)
9458 if ((buf
[i
] & 0x80) == 0)
9461 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9462 if (i
== sizeof (buf
))
9464 warn (_("Corrupt stack pointer adjustment detected\n"));
9468 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
9469 assert (len
== i
+ 1);
9470 offset
= offset
* 8 + 0x408;
9471 printf (_("sp = sp + %ld"), offset
);
9473 else if ((op
& 0xf0) == 0xe0)
9475 if ((op
& 0x0f) == 7)
9478 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9482 printf (_(" [unsupported opcode]"));
9491 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9495 offset
= word
& 0x7fffffff;
9496 if (offset
& 0x40000000)
9497 offset
|= ~ (bfd_vma
) 0x7fffffff;
9499 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9502 return offset
+ where
;
9506 decode_arm_unwind (Filedata
* filedata
,
9507 struct arm_unw_aux_info
* aux
,
9509 unsigned int remaining
,
9510 bfd_vma data_offset
,
9511 Elf_Internal_Shdr
* data_sec
,
9512 struct arm_section
* data_arm_sec
)
9515 unsigned int more_words
= 0;
9516 struct absaddr addr
;
9517 bfd_vma sym_name
= (bfd_vma
) -1;
9522 /* Fetch the first word.
9523 Note - when decoding an object file the address extracted
9524 here will always be 0. So we also pass in the sym_name
9525 parameter so that we can find the symbol associated with
9526 the personality routine. */
9527 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9528 & word
, & addr
, & sym_name
))
9535 addr
.section
= SHN_UNDEF
;
9539 if ((word
& 0x80000000) == 0)
9541 /* Expand prel31 for personality routine. */
9543 const char *procname
;
9545 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9546 printf (_(" Personality routine: "));
9548 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9549 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9551 procname
= aux
->strtab
+ sym_name
;
9552 print_vma (fn
, PREFIX_HEX
);
9555 fputs (" <", stdout
);
9556 fputs (procname
, stdout
);
9557 fputc ('>', stdout
);
9561 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9562 fputc ('\n', stdout
);
9564 /* The GCC personality routines use the standard compact
9565 encoding, starting with one byte giving the number of
9567 if (procname
!= NULL
9568 && (startswith (procname
, "__gcc_personality_v0")
9569 || startswith (procname
, "__gxx_personality_v0")
9570 || startswith (procname
, "__gcj_personality_v0")
9571 || startswith (procname
, "__gnu_objc_personality_v0")))
9578 printf (_(" [Truncated data]\n"));
9581 more_words
= word
>> 24;
9591 /* ARM EHABI Section 6.3:
9593 An exception-handling table entry for the compact model looks like:
9597 1 0 index Data for personalityRoutine[index] */
9599 if (filedata
->file_header
.e_machine
== EM_ARM
9600 && (word
& 0x70000000))
9602 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9606 per_index
= (word
>> 24) & 0x7f;
9607 printf (_(" Compact model index: %d\n"), per_index
);
9614 else if (per_index
< 3)
9616 more_words
= (word
>> 16) & 0xff;
9622 switch (filedata
->file_header
.e_machine
)
9627 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9628 data_offset
, data_sec
, data_arm_sec
))
9633 warn (_("Unknown ARM compact model index encountered\n"));
9634 printf (_(" [reserved]\n"));
9642 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9643 data_offset
, data_sec
, data_arm_sec
))
9646 else if (per_index
< 5)
9648 if (((word
>> 17) & 0x7f) == 0x7f)
9649 printf (_(" Restore stack from frame pointer\n"));
9651 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9652 printf (_(" Registers restored: "));
9654 printf (" (compact) ");
9655 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9657 printf (_(" Return register: %s\n"),
9658 tic6x_unwind_regnames
[word
& 0xf]);
9661 printf (_(" [reserved (%d)]\n"), per_index
);
9665 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9666 filedata
->file_header
.e_machine
);
9670 /* Decode the descriptors. Not implemented. */
9676 dump_arm_unwind (Filedata
* filedata
,
9677 struct arm_unw_aux_info
* aux
,
9678 Elf_Internal_Shdr
* exidx_sec
)
9680 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9681 unsigned int i
, exidx_len
;
9682 unsigned long j
, nfuns
;
9685 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9686 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9687 exidx_len
= exidx_sec
->sh_size
/ 8;
9689 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9690 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9691 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9692 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9694 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9696 for (i
= 0; i
< exidx_len
; i
++)
9698 unsigned int exidx_fn
, exidx_entry
;
9699 struct absaddr fn_addr
, entry_addr
;
9702 fputc ('\n', stdout
);
9704 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9705 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9706 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9707 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9710 arm_free_section (& exidx_arm_sec
);
9711 arm_free_section (& extab_arm_sec
);
9715 /* ARM EHABI, Section 5:
9716 An index table entry consists of 2 words.
9717 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9718 if (exidx_fn
& 0x80000000)
9720 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9724 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9726 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9727 fputs (": ", stdout
);
9729 if (exidx_entry
== 1)
9731 print_vma (exidx_entry
, PREFIX_HEX
);
9732 fputs (" [cantunwind]\n", stdout
);
9734 else if (exidx_entry
& 0x80000000)
9736 print_vma (exidx_entry
, PREFIX_HEX
);
9737 fputc ('\n', stdout
);
9738 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9742 bfd_vma table
, table_offset
= 0;
9743 Elf_Internal_Shdr
*table_sec
;
9745 fputs ("@", stdout
);
9746 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9747 print_vma (table
, PREFIX_HEX
);
9750 /* Locate the matching .ARM.extab. */
9751 if (entry_addr
.section
!= SHN_UNDEF
9752 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9754 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9755 table_offset
= entry_addr
.offset
;
9757 if (table_offset
> table_sec
->sh_size
9758 || ((bfd_signed_vma
) table_offset
) < 0)
9760 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9761 (unsigned long) table_offset
,
9762 printable_section_name (filedata
, table_sec
));
9769 table_sec
= find_section_by_address (filedata
, table
);
9770 if (table_sec
!= NULL
)
9771 table_offset
= table
- table_sec
->sh_addr
;
9774 if (table_sec
== NULL
)
9776 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9777 (unsigned long) table
);
9782 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9791 arm_free_section (&exidx_arm_sec
);
9792 arm_free_section (&extab_arm_sec
);
9797 /* Used for both ARM and C6X unwinding tables. */
9800 arm_process_unwind (Filedata
* filedata
)
9802 struct arm_unw_aux_info aux
;
9803 Elf_Internal_Shdr
*unwsec
= NULL
;
9804 Elf_Internal_Shdr
*sec
;
9806 unsigned int sec_type
;
9809 switch (filedata
->file_header
.e_machine
)
9812 sec_type
= SHT_ARM_EXIDX
;
9816 sec_type
= SHT_C6000_UNWIND
;
9820 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9821 filedata
->file_header
.e_machine
);
9825 if (filedata
->string_table
== NULL
)
9828 memset (& aux
, 0, sizeof (aux
));
9829 aux
.filedata
= filedata
;
9831 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9833 if (sec
->sh_type
== SHT_SYMTAB
)
9837 error (_("Multiple symbol tables encountered\n"));
9843 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9844 &aux
.strtab
, &aux
.strtab_size
))
9847 else if (sec
->sh_type
== sec_type
)
9852 printf (_("\nThere are no unwind sections in this file.\n"));
9854 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9856 if (sec
->sh_type
== sec_type
)
9858 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9859 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9860 "contains %lu entry:\n",
9861 "\nUnwind section '%s' at offset 0x%lx "
9862 "contains %lu entries:\n",
9864 printable_section_name (filedata
, sec
),
9865 (unsigned long) sec
->sh_offset
,
9868 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9874 free ((char *) aux
.strtab
);
9880 no_processor_specific_unwind (Filedata
* filedata ATTRIBUTE_UNUSED
)
9882 printf (_("No processor specific unwind information to decode\n"));
9887 process_unwind (Filedata
* filedata
)
9889 struct unwind_handler
9891 unsigned int machtype
;
9892 bool (* handler
)(Filedata
*);
9895 { EM_ARM
, arm_process_unwind
},
9896 { EM_IA_64
, ia64_process_unwind
},
9897 { EM_PARISC
, hppa_process_unwind
},
9898 { EM_TI_C6000
, arm_process_unwind
},
9899 { EM_386
, no_processor_specific_unwind
},
9900 { EM_X86_64
, no_processor_specific_unwind
},
9908 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9909 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9910 return handlers
[i
].handler (filedata
);
9912 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9913 get_machine_name (filedata
->file_header
.e_machine
));
9918 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9920 switch (entry
->d_tag
)
9922 case DT_AARCH64_BTI_PLT
:
9923 case DT_AARCH64_PAC_PLT
:
9926 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9933 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
9935 switch (entry
->d_tag
)
9938 if (entry
->d_un
.d_val
== 0)
9942 static const char * opts
[] =
9944 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9945 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9946 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9947 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9953 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9954 if (entry
->d_un
.d_val
& (1 << cnt
))
9956 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9962 case DT_MIPS_IVERSION
:
9963 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
9964 printf (_("Interface Version: %s"),
9965 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
9969 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9970 /* Note: coded this way so that there is a single string for translation. */
9971 printf (_("<corrupt: %s>"), buf
);
9975 case DT_MIPS_TIME_STAMP
:
9979 time_t atime
= entry
->d_un
.d_val
;
9981 tmp
= gmtime (&atime
);
9982 /* PR 17531: file: 6accc532. */
9984 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9986 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9987 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9988 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9989 printf (_("Time Stamp: %s"), timebuf
);
9993 case DT_MIPS_RLD_VERSION
:
9994 case DT_MIPS_LOCAL_GOTNO
:
9995 case DT_MIPS_CONFLICTNO
:
9996 case DT_MIPS_LIBLISTNO
:
9997 case DT_MIPS_SYMTABNO
:
9998 case DT_MIPS_UNREFEXTNO
:
9999 case DT_MIPS_HIPAGENO
:
10000 case DT_MIPS_DELTA_CLASS_NO
:
10001 case DT_MIPS_DELTA_INSTANCE_NO
:
10002 case DT_MIPS_DELTA_RELOC_NO
:
10003 case DT_MIPS_DELTA_SYM_NO
:
10004 case DT_MIPS_DELTA_CLASSSYM_NO
:
10005 case DT_MIPS_COMPACT_SIZE
:
10006 print_vma (entry
->d_un
.d_val
, DEC
);
10009 case DT_MIPS_XHASH
:
10010 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10011 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10012 /* Falls through. */
10015 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10021 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
10023 switch (entry
->d_tag
)
10025 case DT_HP_DLD_FLAGS
:
10034 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
10035 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
10036 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
10037 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
10038 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
10039 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
10040 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
10041 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
10042 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
10043 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
10044 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
10045 { DT_HP_GST
, "HP_GST" },
10046 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
10047 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
10048 { DT_HP_NODELETE
, "HP_NODELETE" },
10049 { DT_HP_GROUP
, "HP_GROUP" },
10050 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
10054 bfd_vma val
= entry
->d_un
.d_val
;
10056 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
10057 if (val
& flags
[cnt
].bit
)
10061 fputs (flags
[cnt
].str
, stdout
);
10063 val
^= flags
[cnt
].bit
;
10066 if (val
!= 0 || first
)
10070 print_vma (val
, HEX
);
10076 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10084 /* VMS vs Unix time offset and factor. */
10086 #define VMS_EPOCH_OFFSET 35067168000000000LL
10087 #define VMS_GRANULARITY_FACTOR 10000000
10089 #define INT64_MIN (-9223372036854775807LL - 1)
10092 /* Display a VMS time in a human readable format. */
10095 print_vms_time (bfd_int64_t vmstime
)
10097 struct tm
*tm
= NULL
;
10100 if (vmstime
>= INT64_MIN
+ VMS_EPOCH_OFFSET
)
10102 vmstime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
10104 if (unxtime
== vmstime
)
10105 tm
= gmtime (&unxtime
);
10108 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
10109 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
10110 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
10115 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
10117 switch (entry
->d_tag
)
10119 case DT_IA_64_PLT_RESERVE
:
10120 /* First 3 slots reserved. */
10121 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10123 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
10126 case DT_IA_64_VMS_LINKTIME
:
10128 print_vms_time (entry
->d_un
.d_val
);
10132 case DT_IA_64_VMS_LNKFLAGS
:
10133 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10134 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
10135 printf (" CALL_DEBUG");
10136 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
10137 printf (" NOP0BUFS");
10138 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
10139 printf (" P0IMAGE");
10140 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
10141 printf (" MKTHREADS");
10142 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
10143 printf (" UPCALLS");
10144 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
10145 printf (" IMGSTA");
10146 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
10147 printf (" INITIALIZE");
10148 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
10150 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
10151 printf (" EXE_INIT");
10152 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
10153 printf (" TBK_IN_IMG");
10154 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
10155 printf (" DBG_IN_IMG");
10156 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
10157 printf (" TBK_IN_DSF");
10158 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
10159 printf (" DBG_IN_DSF");
10160 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
10161 printf (" SIGNATURES");
10162 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
10163 printf (" REL_SEG_OFF");
10167 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10174 get_32bit_dynamic_section (Filedata
* filedata
)
10176 Elf32_External_Dyn
* edyn
;
10177 Elf32_External_Dyn
* ext
;
10178 Elf_Internal_Dyn
* entry
;
10180 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
10181 filedata
->dynamic_addr
, 1,
10182 filedata
->dynamic_size
,
10183 _("dynamic section"));
10187 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
10188 might not have the luxury of section headers. Look for the DT_NULL
10189 terminator to determine the number of entries. */
10190 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
10191 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
10194 filedata
->dynamic_nent
++;
10195 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
10199 filedata
->dynamic_section
10200 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
10201 if (filedata
->dynamic_section
== NULL
)
10203 error (_("Out of memory allocating space for %lu dynamic entries\n"),
10204 (unsigned long) filedata
->dynamic_nent
);
10209 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10210 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10213 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10214 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10223 get_64bit_dynamic_section (Filedata
* filedata
)
10225 Elf64_External_Dyn
* edyn
;
10226 Elf64_External_Dyn
* ext
;
10227 Elf_Internal_Dyn
* entry
;
10229 /* Read in the data. */
10230 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
10231 filedata
->dynamic_addr
, 1,
10232 filedata
->dynamic_size
,
10233 _("dynamic section"));
10237 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
10238 might not have the luxury of section headers. Look for the DT_NULL
10239 terminator to determine the number of entries. */
10240 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
10241 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
10242 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
10245 filedata
->dynamic_nent
++;
10246 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
10250 filedata
->dynamic_section
10251 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
10252 if (filedata
->dynamic_section
== NULL
)
10254 error (_("Out of memory allocating space for %lu dynamic entries\n"),
10255 (unsigned long) filedata
->dynamic_nent
);
10260 /* Convert from external to internal formats. */
10261 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10262 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10265 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10266 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10275 get_dynamic_section (Filedata
*filedata
)
10277 if (filedata
->dynamic_section
)
10281 return get_32bit_dynamic_section (filedata
);
10283 return get_64bit_dynamic_section (filedata
);
10287 print_dynamic_flags (bfd_vma flags
)
10295 flag
= flags
& - flags
;
10301 putc (' ', stdout
);
10305 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
10306 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
10307 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
10308 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
10309 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
10310 default: fputs (_("unknown"), stdout
); break;
10317 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
10319 unsigned char * e_data
;
10322 /* If the size_t type is smaller than the bfd_size_type, eg because
10323 you are building a 32-bit tool on a 64-bit host, then make sure
10324 that when (number) is cast to (size_t) no information is lost. */
10325 if (sizeof (size_t) < sizeof (bfd_size_type
)
10326 && (bfd_size_type
) ((size_t) number
) != number
)
10328 error (_("Size truncation prevents reading %s elements of size %u\n"),
10329 bfd_vmatoa ("u", number
), ent_size
);
10333 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
10334 attempting to allocate memory when the read is bound to fail. */
10335 if (ent_size
* number
> filedata
->file_size
)
10337 error (_("Invalid number of dynamic entries: %s\n"),
10338 bfd_vmatoa ("u", number
));
10342 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10343 if (e_data
== NULL
)
10345 error (_("Out of memory reading %s dynamic entries\n"),
10346 bfd_vmatoa ("u", number
));
10350 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
10352 error (_("Unable to read in %s bytes of dynamic data\n"),
10353 bfd_vmatoa ("u", number
* ent_size
));
10358 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10359 if (i_data
== NULL
)
10361 error (_("Out of memory allocating space for %s dynamic entries\n"),
10362 bfd_vmatoa ("u", number
));
10368 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10375 static unsigned long
10376 get_num_dynamic_syms (Filedata
* filedata
)
10378 unsigned long num_of_syms
= 0;
10380 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
10381 return num_of_syms
;
10383 if (filedata
->dynamic_info
[DT_HASH
])
10385 unsigned char nb
[8];
10386 unsigned char nc
[8];
10387 unsigned int hash_ent_size
= 4;
10389 if ((filedata
->file_header
.e_machine
== EM_ALPHA
10390 || filedata
->file_header
.e_machine
== EM_S390
10391 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
10392 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10395 if (fseek (filedata
->handle
,
10396 (filedata
->archive_file_offset
10397 + offset_from_vma (filedata
, filedata
->dynamic_info
[DT_HASH
],
10398 sizeof nb
+ sizeof nc
)),
10401 error (_("Unable to seek to start of dynamic information\n"));
10405 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
10407 error (_("Failed to read in number of buckets\n"));
10411 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
10413 error (_("Failed to read in number of chains\n"));
10417 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
10418 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
10420 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
10422 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
10424 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
10427 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
10428 num_of_syms
= filedata
->nchains
;
10431 if (num_of_syms
== 0)
10433 free (filedata
->buckets
);
10434 filedata
->buckets
= NULL
;
10435 free (filedata
->chains
);
10436 filedata
->chains
= NULL
;
10437 filedata
->nbuckets
= 0;
10441 if (filedata
->dynamic_info_DT_GNU_HASH
)
10443 unsigned char nb
[16];
10444 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10445 bfd_vma buckets_vma
;
10448 if (fseek (filedata
->handle
,
10449 (filedata
->archive_file_offset
10450 + offset_from_vma (filedata
,
10451 filedata
->dynamic_info_DT_GNU_HASH
,
10455 error (_("Unable to seek to start of dynamic information\n"));
10459 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
10461 error (_("Failed to read in number of buckets\n"));
10465 filedata
->ngnubuckets
= byte_get (nb
, 4);
10466 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
10467 bitmaskwords
= byte_get (nb
+ 8, 4);
10468 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
10470 buckets_vma
+= bitmaskwords
* 4;
10472 buckets_vma
+= bitmaskwords
* 8;
10474 if (fseek (filedata
->handle
,
10475 (filedata
->archive_file_offset
10476 + offset_from_vma (filedata
, buckets_vma
, 4)),
10479 error (_("Unable to seek to start of dynamic information\n"));
10483 filedata
->gnubuckets
10484 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
10486 if (filedata
->gnubuckets
== NULL
)
10489 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
10490 if (filedata
->gnubuckets
[i
] != 0)
10492 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
10495 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
10496 maxchain
= filedata
->gnubuckets
[i
];
10499 if (maxchain
== 0xffffffff)
10502 maxchain
-= filedata
->gnusymidx
;
10504 if (fseek (filedata
->handle
,
10505 (filedata
->archive_file_offset
10506 + offset_from_vma (filedata
,
10507 buckets_vma
+ 4 * (filedata
->ngnubuckets
10512 error (_("Unable to seek to start of dynamic information\n"));
10518 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
10520 error (_("Failed to determine last chain length\n"));
10524 if (maxchain
+ 1 == 0)
10529 while ((byte_get (nb
, 4) & 1) == 0);
10531 if (fseek (filedata
->handle
,
10532 (filedata
->archive_file_offset
10533 + offset_from_vma (filedata
, (buckets_vma
10534 + 4 * filedata
->ngnubuckets
),
10538 error (_("Unable to seek to start of dynamic information\n"));
10542 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
10543 filedata
->ngnuchains
= maxchain
;
10545 if (filedata
->gnuchains
== NULL
)
10548 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10550 if (fseek (filedata
->handle
,
10551 (filedata
->archive_file_offset
10552 + offset_from_vma (filedata
, (buckets_vma
10553 + 4 * (filedata
->ngnubuckets
10557 error (_("Unable to seek to start of dynamic information\n"));
10561 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
10562 if (filedata
->mipsxlat
== NULL
)
10566 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
10567 if (filedata
->gnubuckets
[hn
] != 0)
10569 bfd_vma si
= filedata
->gnubuckets
[hn
];
10570 bfd_vma off
= si
- filedata
->gnusymidx
;
10574 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10576 if (off
< filedata
->ngnuchains
10577 && filedata
->mipsxlat
[off
] >= num_of_syms
)
10578 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
10582 if (si
>= num_of_syms
)
10583 num_of_syms
= si
+ 1;
10587 while (off
< filedata
->ngnuchains
10588 && (filedata
->gnuchains
[off
++] & 1) == 0);
10591 if (num_of_syms
== 0)
10594 free (filedata
->mipsxlat
);
10595 filedata
->mipsxlat
= NULL
;
10596 free (filedata
->gnuchains
);
10597 filedata
->gnuchains
= NULL
;
10598 free (filedata
->gnubuckets
);
10599 filedata
->gnubuckets
= NULL
;
10600 filedata
->ngnubuckets
= 0;
10601 filedata
->ngnuchains
= 0;
10605 return num_of_syms
;
10608 /* Parse and display the contents of the dynamic section. */
10611 process_dynamic_section (Filedata
* filedata
)
10613 Elf_Internal_Dyn
* entry
;
10615 if (filedata
->dynamic_size
== 0)
10619 if (filedata
->is_separate
)
10620 printf (_("\nThere is no dynamic section in linked file '%s'.\n"),
10621 filedata
->file_name
);
10623 printf (_("\nThere is no dynamic section in this file.\n"));
10629 if (!get_dynamic_section (filedata
))
10632 /* Find the appropriate symbol table. */
10633 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
10635 unsigned long num_of_syms
;
10637 for (entry
= filedata
->dynamic_section
;
10638 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10640 if (entry
->d_tag
== DT_SYMTAB
)
10641 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
10642 else if (entry
->d_tag
== DT_SYMENT
)
10643 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
10644 else if (entry
->d_tag
== DT_HASH
)
10645 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
10646 else if (entry
->d_tag
== DT_GNU_HASH
)
10647 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10648 else if ((filedata
->file_header
.e_machine
== EM_MIPS
10649 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
10650 && entry
->d_tag
== DT_MIPS_XHASH
)
10652 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10653 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10656 num_of_syms
= get_num_dynamic_syms (filedata
);
10658 if (num_of_syms
!= 0
10659 && filedata
->dynamic_symbols
== NULL
10660 && filedata
->dynamic_info
[DT_SYMTAB
]
10661 && filedata
->dynamic_info
[DT_SYMENT
])
10663 Elf_Internal_Phdr
*seg
;
10664 bfd_vma vma
= filedata
->dynamic_info
[DT_SYMTAB
];
10666 if (! get_program_headers (filedata
))
10668 error (_("Cannot interpret virtual addresses "
10669 "without program headers.\n"));
10673 for (seg
= filedata
->program_headers
;
10674 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
10677 if (seg
->p_type
!= PT_LOAD
)
10680 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
10682 /* See PR 21379 for a reproducer. */
10683 error (_("Invalid PT_LOAD entry\n"));
10687 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
10688 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
10690 /* Since we do not know how big the symbol table is,
10691 we default to reading in up to the end of PT_LOAD
10692 segment and processing that. This is overkill, I
10693 know, but it should work. */
10694 Elf_Internal_Shdr section
;
10695 section
.sh_offset
= (vma
- seg
->p_vaddr
10697 section
.sh_size
= (num_of_syms
10698 * filedata
->dynamic_info
[DT_SYMENT
]);
10699 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
10702 && filedata
->dynamic_symtab_section
!= NULL
10703 && ((filedata
->dynamic_symtab_section
->sh_offset
10704 != section
.sh_offset
)
10705 || (filedata
->dynamic_symtab_section
->sh_size
10706 != section
.sh_size
)
10707 || (filedata
->dynamic_symtab_section
->sh_entsize
10708 != section
.sh_entsize
)))
10710 the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
10712 section
.sh_name
= filedata
->string_table_length
;
10713 filedata
->dynamic_symbols
10714 = get_elf_symbols (filedata
, §ion
,
10715 &filedata
->num_dynamic_syms
);
10716 if (filedata
->dynamic_symbols
== NULL
10717 || filedata
->num_dynamic_syms
!= num_of_syms
)
10719 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
10728 /* Similarly find a string table. */
10729 if (filedata
->dynamic_strings
== NULL
)
10730 for (entry
= filedata
->dynamic_section
;
10731 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10734 if (entry
->d_tag
== DT_STRTAB
)
10735 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
10737 if (entry
->d_tag
== DT_STRSZ
)
10738 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
10740 if (filedata
->dynamic_info
[DT_STRTAB
]
10741 && filedata
->dynamic_info
[DT_STRSZ
])
10743 unsigned long offset
;
10744 bfd_size_type str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
10746 offset
= offset_from_vma (filedata
,
10747 filedata
->dynamic_info
[DT_STRTAB
],
10750 && filedata
->dynamic_strtab_section
10751 && ((filedata
->dynamic_strtab_section
->sh_offset
10752 != (file_ptr
) offset
)
10753 || (filedata
->dynamic_strtab_section
->sh_size
10756 the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
10758 filedata
->dynamic_strings
10759 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
10760 _("dynamic string table"));
10761 if (filedata
->dynamic_strings
== NULL
)
10763 error (_("Corrupt DT_STRTAB dynamic entry\n"));
10767 filedata
->dynamic_strings_length
= str_tab_len
;
10772 /* And find the syminfo section if available. */
10773 if (filedata
->dynamic_syminfo
== NULL
)
10775 unsigned long syminsz
= 0;
10777 for (entry
= filedata
->dynamic_section
;
10778 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10781 if (entry
->d_tag
== DT_SYMINENT
)
10783 /* Note: these braces are necessary to avoid a syntax
10784 error from the SunOS4 C compiler. */
10785 /* PR binutils/17531: A corrupt file can trigger this test.
10786 So do not use an assert, instead generate an error message. */
10787 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
10788 error (_("Bad value (%d) for SYMINENT entry\n"),
10789 (int) entry
->d_un
.d_val
);
10791 else if (entry
->d_tag
== DT_SYMINSZ
)
10792 syminsz
= entry
->d_un
.d_val
;
10793 else if (entry
->d_tag
== DT_SYMINFO
)
10794 filedata
->dynamic_syminfo_offset
10795 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
10798 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
10800 Elf_External_Syminfo
* extsyminfo
;
10801 Elf_External_Syminfo
* extsym
;
10802 Elf_Internal_Syminfo
* syminfo
;
10804 /* There is a syminfo section. Read the data. */
10805 extsyminfo
= (Elf_External_Syminfo
*)
10806 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
10807 1, syminsz
, _("symbol information"));
10811 if (filedata
->dynamic_syminfo
!= NULL
)
10813 error (_("Multiple dynamic symbol information sections found\n"));
10814 free (filedata
->dynamic_syminfo
);
10816 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10817 if (filedata
->dynamic_syminfo
== NULL
)
10819 error (_("Out of memory allocating %lu bytes "
10820 "for dynamic symbol info\n"),
10821 (unsigned long) syminsz
);
10825 filedata
->dynamic_syminfo_nent
10826 = syminsz
/ sizeof (Elf_External_Syminfo
);
10827 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
10828 syminfo
< (filedata
->dynamic_syminfo
10829 + filedata
->dynamic_syminfo_nent
);
10830 ++syminfo
, ++extsym
)
10832 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10833 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10840 if (do_dynamic
&& filedata
->dynamic_addr
)
10842 if (filedata
->dynamic_nent
== 1)
10844 if (filedata
->is_separate
)
10845 printf (_("\nIn linked file '%s' the dynamic section at offset 0x%lx contains 1 entry:\n"),
10846 filedata
->file_name
,
10847 filedata
->dynamic_addr
);
10849 printf (_("\nDynamic section at offset 0x%lx contains 1 entry:\n"),
10850 filedata
->dynamic_addr
);
10854 if (filedata
->is_separate
)
10855 printf (_("\nIn linked file '%s' the dynamic section at offset 0x%lx contains %lu entries:\n"),
10856 filedata
->file_name
,
10857 filedata
->dynamic_addr
,
10858 (unsigned long) filedata
->dynamic_nent
);
10860 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
10861 filedata
->dynamic_addr
,
10862 (unsigned long) filedata
->dynamic_nent
);
10866 printf (_(" Tag Type Name/Value\n"));
10868 for (entry
= filedata
->dynamic_section
;
10869 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10874 const char * dtype
;
10877 print_vma (entry
->d_tag
, FULL_HEX
);
10878 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10879 printf (" (%s)%*s", dtype
,
10880 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10883 switch (entry
->d_tag
)
10887 print_dynamic_flags (entry
->d_un
.d_val
);
10897 switch (entry
->d_tag
)
10900 printf (_("Auxiliary library"));
10904 printf (_("Filter library"));
10908 printf (_("Configuration file"));
10912 printf (_("Dependency audit library"));
10916 printf (_("Audit library"));
10920 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10921 printf (": [%s]\n",
10922 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
10926 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10935 printf (_("Flags:"));
10937 if (entry
->d_un
.d_val
== 0)
10938 printf (_(" None\n"));
10941 unsigned long int val
= entry
->d_un
.d_val
;
10943 if (val
& DTF_1_PARINIT
)
10945 printf (" PARINIT");
10946 val
^= DTF_1_PARINIT
;
10948 if (val
& DTF_1_CONFEXP
)
10950 printf (" CONFEXP");
10951 val
^= DTF_1_CONFEXP
;
10954 printf (" %lx", val
);
10963 printf (_("Flags:"));
10965 if (entry
->d_un
.d_val
== 0)
10966 printf (_(" None\n"));
10969 unsigned long int val
= entry
->d_un
.d_val
;
10971 if (val
& DF_P1_LAZYLOAD
)
10973 printf (" LAZYLOAD");
10974 val
^= DF_P1_LAZYLOAD
;
10976 if (val
& DF_P1_GROUPPERM
)
10978 printf (" GROUPPERM");
10979 val
^= DF_P1_GROUPPERM
;
10982 printf (" %lx", val
);
10991 printf (_("Flags:"));
10992 if (entry
->d_un
.d_val
== 0)
10993 printf (_(" None\n"));
10996 unsigned long int val
= entry
->d_un
.d_val
;
10998 if (val
& DF_1_NOW
)
11003 if (val
& DF_1_GLOBAL
)
11005 printf (" GLOBAL");
11006 val
^= DF_1_GLOBAL
;
11008 if (val
& DF_1_GROUP
)
11013 if (val
& DF_1_NODELETE
)
11015 printf (" NODELETE");
11016 val
^= DF_1_NODELETE
;
11018 if (val
& DF_1_LOADFLTR
)
11020 printf (" LOADFLTR");
11021 val
^= DF_1_LOADFLTR
;
11023 if (val
& DF_1_INITFIRST
)
11025 printf (" INITFIRST");
11026 val
^= DF_1_INITFIRST
;
11028 if (val
& DF_1_NOOPEN
)
11030 printf (" NOOPEN");
11031 val
^= DF_1_NOOPEN
;
11033 if (val
& DF_1_ORIGIN
)
11035 printf (" ORIGIN");
11036 val
^= DF_1_ORIGIN
;
11038 if (val
& DF_1_DIRECT
)
11040 printf (" DIRECT");
11041 val
^= DF_1_DIRECT
;
11043 if (val
& DF_1_TRANS
)
11048 if (val
& DF_1_INTERPOSE
)
11050 printf (" INTERPOSE");
11051 val
^= DF_1_INTERPOSE
;
11053 if (val
& DF_1_NODEFLIB
)
11055 printf (" NODEFLIB");
11056 val
^= DF_1_NODEFLIB
;
11058 if (val
& DF_1_NODUMP
)
11060 printf (" NODUMP");
11061 val
^= DF_1_NODUMP
;
11063 if (val
& DF_1_CONFALT
)
11065 printf (" CONFALT");
11066 val
^= DF_1_CONFALT
;
11068 if (val
& DF_1_ENDFILTEE
)
11070 printf (" ENDFILTEE");
11071 val
^= DF_1_ENDFILTEE
;
11073 if (val
& DF_1_DISPRELDNE
)
11075 printf (" DISPRELDNE");
11076 val
^= DF_1_DISPRELDNE
;
11078 if (val
& DF_1_DISPRELPND
)
11080 printf (" DISPRELPND");
11081 val
^= DF_1_DISPRELPND
;
11083 if (val
& DF_1_NODIRECT
)
11085 printf (" NODIRECT");
11086 val
^= DF_1_NODIRECT
;
11088 if (val
& DF_1_IGNMULDEF
)
11090 printf (" IGNMULDEF");
11091 val
^= DF_1_IGNMULDEF
;
11093 if (val
& DF_1_NOKSYMS
)
11095 printf (" NOKSYMS");
11096 val
^= DF_1_NOKSYMS
;
11098 if (val
& DF_1_NOHDR
)
11103 if (val
& DF_1_EDITED
)
11105 printf (" EDITED");
11106 val
^= DF_1_EDITED
;
11108 if (val
& DF_1_NORELOC
)
11110 printf (" NORELOC");
11111 val
^= DF_1_NORELOC
;
11113 if (val
& DF_1_SYMINTPOSE
)
11115 printf (" SYMINTPOSE");
11116 val
^= DF_1_SYMINTPOSE
;
11118 if (val
& DF_1_GLOBAUDIT
)
11120 printf (" GLOBAUDIT");
11121 val
^= DF_1_GLOBAUDIT
;
11123 if (val
& DF_1_SINGLETON
)
11125 printf (" SINGLETON");
11126 val
^= DF_1_SINGLETON
;
11128 if (val
& DF_1_STUB
)
11133 if (val
& DF_1_PIE
)
11138 if (val
& DF_1_KMOD
)
11143 if (val
& DF_1_WEAKFILTER
)
11145 printf (" WEAKFILTER");
11146 val
^= DF_1_WEAKFILTER
;
11148 if (val
& DF_1_NOCOMMON
)
11150 printf (" NOCOMMON");
11151 val
^= DF_1_NOCOMMON
;
11154 printf (" %lx", val
);
11161 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11163 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
11183 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11189 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
11190 name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
11196 switch (entry
->d_tag
)
11199 printf (_("Shared library: [%s]"), name
);
11201 if (filedata
->program_interpreter
11202 && streq (name
, filedata
->program_interpreter
))
11203 printf (_(" program interpreter"));
11207 printf (_("Library soname: [%s]"), name
);
11211 printf (_("Library rpath: [%s]"), name
);
11215 printf (_("Library runpath: [%s]"), name
);
11219 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11224 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11237 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11238 /* Fall through. */
11242 case DT_INIT_ARRAYSZ
:
11243 case DT_FINI_ARRAYSZ
:
11244 case DT_GNU_CONFLICTSZ
:
11245 case DT_GNU_LIBLISTSZ
:
11248 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11249 printf (_(" (bytes)\n"));
11254 case DT_VERNEEDNUM
:
11259 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11268 case DT_INIT_ARRAY
:
11269 case DT_FINI_ARRAY
:
11272 if (entry
->d_tag
== DT_USED
11273 && VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
11275 char * name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
11279 printf (_("Not needed object: [%s]\n"), name
);
11284 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11290 /* The value of this entry is ignored. */
11295 case DT_GNU_PRELINKED
:
11299 time_t atime
= entry
->d_un
.d_val
;
11301 tmp
= gmtime (&atime
);
11302 /* PR 17533 file: 041-1244816-0.004. */
11304 printf (_("<corrupt time val: %lx"),
11305 (unsigned long) atime
);
11307 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
11308 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11309 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11315 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11318 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11323 case DT_GNU_FLAGS_1
:
11326 printf (_("Flags:"));
11327 if (entry
->d_un
.d_val
== 0)
11328 printf (_(" None\n"));
11331 unsigned long int val
= entry
->d_un
.d_val
;
11333 if (val
& DF_GNU_1_UNIQUE
)
11335 printf (" UNIQUE");
11336 val
^= DF_GNU_1_UNIQUE
;
11339 printf (" %lx", val
);
11346 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
11347 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
11348 = entry
->d_un
.d_val
;
11352 switch (filedata
->file_header
.e_machine
)
11355 dynamic_section_aarch64_val (entry
);
11358 case EM_MIPS_RS3_LE
:
11359 dynamic_section_mips_val (filedata
, entry
);
11362 dynamic_section_parisc_val (entry
);
11365 dynamic_section_ia64_val (entry
);
11368 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11380 get_ver_flags (unsigned int flags
)
11382 static char buff
[128];
11389 if (flags
& VER_FLG_BASE
)
11390 strcat (buff
, "BASE");
11392 if (flags
& VER_FLG_WEAK
)
11394 if (flags
& VER_FLG_BASE
)
11395 strcat (buff
, " | ");
11397 strcat (buff
, "WEAK");
11400 if (flags
& VER_FLG_INFO
)
11402 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
11403 strcat (buff
, " | ");
11405 strcat (buff
, "INFO");
11408 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11410 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11411 strcat (buff
, " | ");
11413 strcat (buff
, _("<unknown>"));
11419 /* Display the contents of the version sections. */
11422 process_version_sections (Filedata
* filedata
)
11424 Elf_Internal_Shdr
* section
;
11426 bool found
= false;
11431 for (i
= 0, section
= filedata
->section_headers
;
11432 i
< filedata
->file_header
.e_shnum
;
11435 switch (section
->sh_type
)
11437 case SHT_GNU_verdef
:
11439 Elf_External_Verdef
* edefs
;
11446 if (filedata
->is_separate
)
11447 printf (ngettext ("\nIn linked file '%s' the version definition section '%s' contains %u entry:\n",
11448 "\nIn linked file '%s' the version definition section '%s' contains %u entries:\n",
11450 filedata
->file_name
,
11451 printable_section_name (filedata
, section
),
11454 printf (ngettext ("\nVersion definition section '%s' "
11455 "contains %u entry:\n",
11456 "\nVersion definition section '%s' "
11457 "contains %u entries:\n",
11459 printable_section_name (filedata
, section
),
11462 printf (_(" Addr: 0x"));
11463 printf_vma (section
->sh_addr
);
11464 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11465 (unsigned long) section
->sh_offset
, section
->sh_link
,
11466 printable_section_name_from_index (filedata
, section
->sh_link
));
11468 edefs
= (Elf_External_Verdef
*)
11469 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
11470 _("version definition section"));
11473 endbuf
= (char *) edefs
+ section
->sh_size
;
11475 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11478 Elf_External_Verdef
* edef
;
11479 Elf_Internal_Verdef ent
;
11480 Elf_External_Verdaux
* eaux
;
11481 Elf_Internal_Verdaux aux
;
11482 unsigned long isum
;
11485 vstart
= ((char *) edefs
) + idx
;
11486 if (vstart
+ sizeof (*edef
) > endbuf
)
11489 edef
= (Elf_External_Verdef
*) vstart
;
11491 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
11492 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
11493 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
11494 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
11495 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
11496 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
11497 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
11499 printf (_(" %#06lx: Rev: %d Flags: %s"),
11500 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
11502 printf (_(" Index: %d Cnt: %d "),
11503 ent
.vd_ndx
, ent
.vd_cnt
);
11505 /* Check for overflow. */
11506 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
11509 vstart
+= ent
.vd_aux
;
11511 if (vstart
+ sizeof (*eaux
) > endbuf
)
11513 eaux
= (Elf_External_Verdaux
*) vstart
;
11515 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11516 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11518 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11519 printf (_("Name: %s\n"),
11520 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11522 printf (_("Name index: %ld\n"), aux
.vda_name
);
11524 isum
= idx
+ ent
.vd_aux
;
11526 for (j
= 1; j
< ent
.vd_cnt
; j
++)
11528 if (aux
.vda_next
< sizeof (*eaux
)
11529 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
11531 warn (_("Invalid vda_next field of %lx\n"),
11536 /* Check for overflow. */
11537 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
11540 isum
+= aux
.vda_next
;
11541 vstart
+= aux
.vda_next
;
11543 if (vstart
+ sizeof (*eaux
) > endbuf
)
11545 eaux
= (Elf_External_Verdaux
*) vstart
;
11547 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11548 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11550 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11551 printf (_(" %#06lx: Parent %d: %s\n"),
11553 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11555 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
11556 isum
, j
, aux
.vda_name
);
11559 if (j
< ent
.vd_cnt
)
11560 printf (_(" Version def aux past end of section\n"));
11563 file: id:000001,src:000172+005151,op:splice,rep:2. */
11564 if (ent
.vd_next
< sizeof (*edef
)
11565 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
11567 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
11568 cnt
= section
->sh_info
;
11571 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
11574 idx
+= ent
.vd_next
;
11577 if (cnt
< section
->sh_info
)
11578 printf (_(" Version definition past end of section\n"));
11584 case SHT_GNU_verneed
:
11586 Elf_External_Verneed
* eneed
;
11593 if (filedata
->is_separate
)
11594 printf (ngettext ("\nIn linked file '%s' the version needs section '%s' contains %u entry:\n",
11595 "\nIn linked file '%s' the version needs section '%s' contains %u entries:\n",
11597 filedata
->file_name
,
11598 printable_section_name (filedata
, section
),
11601 printf (ngettext ("\nVersion needs section '%s' "
11602 "contains %u entry:\n",
11603 "\nVersion needs section '%s' "
11604 "contains %u entries:\n",
11606 printable_section_name (filedata
, section
),
11609 printf (_(" Addr: 0x"));
11610 printf_vma (section
->sh_addr
);
11611 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11612 (unsigned long) section
->sh_offset
, section
->sh_link
,
11613 printable_section_name_from_index (filedata
, section
->sh_link
));
11615 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
11616 section
->sh_offset
, 1,
11618 _("Version Needs section"));
11621 endbuf
= (char *) eneed
+ section
->sh_size
;
11623 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11625 Elf_External_Verneed
* entry
;
11626 Elf_Internal_Verneed ent
;
11627 unsigned long isum
;
11631 vstart
= ((char *) eneed
) + idx
;
11632 if (vstart
+ sizeof (*entry
) > endbuf
)
11635 entry
= (Elf_External_Verneed
*) vstart
;
11637 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
11638 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
11639 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
11640 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
11641 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
11643 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
11645 if (VALID_DYNAMIC_NAME (filedata
, ent
.vn_file
))
11646 printf (_(" File: %s"),
11647 GET_DYNAMIC_NAME (filedata
, ent
.vn_file
));
11649 printf (_(" File: %lx"), ent
.vn_file
);
11651 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
11653 /* Check for overflow. */
11654 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
11656 vstart
+= ent
.vn_aux
;
11658 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
11660 Elf_External_Vernaux
* eaux
;
11661 Elf_Internal_Vernaux aux
;
11663 if (vstart
+ sizeof (*eaux
) > endbuf
)
11665 eaux
= (Elf_External_Vernaux
*) vstart
;
11667 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
11668 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
11669 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
11670 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
11671 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
11673 if (VALID_DYNAMIC_NAME (filedata
, aux
.vna_name
))
11674 printf (_(" %#06lx: Name: %s"),
11675 isum
, GET_DYNAMIC_NAME (filedata
, aux
.vna_name
));
11677 printf (_(" %#06lx: Name index: %lx"),
11678 isum
, aux
.vna_name
);
11680 printf (_(" Flags: %s Version: %d\n"),
11681 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
11683 if (aux
.vna_next
< sizeof (*eaux
)
11684 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
11686 warn (_("Invalid vna_next field of %lx\n"),
11691 /* Check for overflow. */
11692 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
11694 isum
+= aux
.vna_next
;
11695 vstart
+= aux
.vna_next
;
11698 if (j
< ent
.vn_cnt
)
11699 warn (_("Missing Version Needs auxiliary information\n"));
11701 if (ent
.vn_next
< sizeof (*entry
)
11702 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
11704 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
11705 cnt
= section
->sh_info
;
11708 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
11710 idx
+= ent
.vn_next
;
11713 if (cnt
< section
->sh_info
)
11714 warn (_("Missing Version Needs information\n"));
11720 case SHT_GNU_versym
:
11722 Elf_Internal_Shdr
* link_section
;
11725 unsigned char * edata
;
11726 unsigned short * data
;
11728 Elf_Internal_Sym
* symbols
;
11729 Elf_Internal_Shdr
* string_sec
;
11730 unsigned long num_syms
;
11733 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
11736 link_section
= filedata
->section_headers
+ section
->sh_link
;
11737 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
11739 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
11744 symbols
= get_elf_symbols (filedata
, link_section
, & num_syms
);
11745 if (symbols
== NULL
)
11748 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
11750 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
11751 string_sec
->sh_size
,
11752 _("version string table"));
11759 if (filedata
->is_separate
)
11760 printf (ngettext ("\nIn linked file '%s' the version symbols section '%s' contains %lu entry:\n",
11761 "\nIn linked file '%s' the version symbols section '%s' contains %lu entries:\n",
11763 filedata
->file_name
,
11764 printable_section_name (filedata
, section
),
11765 (unsigned long) total
);
11767 printf (ngettext ("\nVersion symbols section '%s' "
11768 "contains %lu entry:\n",
11769 "\nVersion symbols section '%s' "
11770 "contains %lu entries:\n",
11772 printable_section_name (filedata
, section
),
11773 (unsigned long) total
);
11775 printf (_(" Addr: 0x"));
11776 printf_vma (section
->sh_addr
);
11777 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11778 (unsigned long) section
->sh_offset
, section
->sh_link
,
11779 printable_section_name (filedata
, link_section
));
11781 off
= offset_from_vma (filedata
,
11782 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11783 total
* sizeof (short));
11784 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
11785 sizeof (short), total
,
11786 _("version symbol data"));
11794 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
11796 for (cnt
= total
; cnt
--;)
11797 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
11802 for (cnt
= 0; cnt
< total
; cnt
+= 4)
11806 char *invalid
= _("*invalid*");
11808 printf (" %03x:", cnt
);
11810 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
11811 switch (data
[cnt
+ j
])
11814 fputs (_(" 0 (*local*) "), stdout
);
11818 fputs (_(" 1 (*global*) "), stdout
);
11822 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
11823 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
11825 /* If this index value is greater than the size of the symbols
11826 array, break to avoid an out-of-bounds read. */
11827 if ((unsigned long)(cnt
+ j
) >= num_syms
)
11829 warn (_("invalid index into symbol array\n"));
11834 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11836 Elf_Internal_Verneed ivn
;
11837 unsigned long offset
;
11839 offset
= offset_from_vma
11841 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11842 sizeof (Elf_External_Verneed
));
11846 Elf_Internal_Vernaux ivna
;
11847 Elf_External_Verneed evn
;
11848 Elf_External_Vernaux evna
;
11849 unsigned long a_off
;
11851 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11852 _("version need")) == NULL
)
11855 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11856 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11858 a_off
= offset
+ ivn
.vn_aux
;
11862 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
11863 1, _("version need aux (2)")) == NULL
)
11866 ivna
.vna_other
= 0;
11870 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11871 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11874 a_off
+= ivna
.vna_next
;
11876 while (ivna
.vna_other
!= data
[cnt
+ j
]
11877 && ivna
.vna_next
!= 0);
11879 if (ivna
.vna_other
== data
[cnt
+ j
])
11881 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11883 if (ivna
.vna_name
>= string_sec
->sh_size
)
11886 name
= strtab
+ ivna
.vna_name
;
11890 offset
+= ivn
.vn_next
;
11892 while (ivn
.vn_next
);
11895 if (data
[cnt
+ j
] != 0x8001
11896 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11898 Elf_Internal_Verdef ivd
;
11899 Elf_External_Verdef evd
;
11900 unsigned long offset
;
11902 offset
= offset_from_vma
11904 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11909 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11910 _("version def")) == NULL
)
11913 /* PR 17531: file: 046-1082287-0.004. */
11914 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11919 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11920 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11923 offset
+= ivd
.vd_next
;
11925 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11926 && ivd
.vd_next
!= 0);
11928 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11930 Elf_External_Verdaux evda
;
11931 Elf_Internal_Verdaux ivda
;
11933 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11935 if (get_data (&evda
, filedata
,
11936 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11938 _("version def aux")) == NULL
)
11941 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11943 if (ivda
.vda_name
>= string_sec
->sh_size
)
11945 else if (name
!= NULL
&& name
!= invalid
)
11946 name
= _("*both*");
11948 name
= strtab
+ ivda
.vda_name
;
11952 nn
+= printf ("(%s%-*s",
11954 12 - (int) strlen (name
),
11958 printf ("%*c", 18 - nn
, ' ');
11977 if (filedata
->is_separate
)
11978 printf (_("\nNo version information found in linked file '%s'.\n"),
11979 filedata
->file_name
);
11981 printf (_("\nNo version information found in this file.\n"));
11987 static const char *
11988 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11990 static char buff
[64];
11994 case STB_LOCAL
: return "LOCAL";
11995 case STB_GLOBAL
: return "GLOBAL";
11996 case STB_WEAK
: return "WEAK";
11998 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11999 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
12001 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
12003 if (binding
== STB_GNU_UNIQUE
12004 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
12006 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
12009 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
12014 static const char *
12015 get_symbol_type (Filedata
* filedata
, unsigned int type
)
12017 static char buff
[64];
12021 case STT_NOTYPE
: return "NOTYPE";
12022 case STT_OBJECT
: return "OBJECT";
12023 case STT_FUNC
: return "FUNC";
12024 case STT_SECTION
: return "SECTION";
12025 case STT_FILE
: return "FILE";
12026 case STT_COMMON
: return "COMMON";
12027 case STT_TLS
: return "TLS";
12028 case STT_RELC
: return "RELC";
12029 case STT_SRELC
: return "SRELC";
12031 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
12033 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
12034 return "THUMB_FUNC";
12036 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
12039 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
12040 return "PARISC_MILLI";
12042 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
12044 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
12046 if (filedata
->file_header
.e_machine
== EM_PARISC
)
12048 if (type
== STT_HP_OPAQUE
)
12049 return "HP_OPAQUE";
12050 if (type
== STT_HP_STUB
)
12054 if (type
== STT_GNU_IFUNC
12055 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
12056 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
12059 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
12062 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
12067 static const char *
12068 get_symbol_visibility (unsigned int visibility
)
12070 switch (visibility
)
12072 case STV_DEFAULT
: return "DEFAULT";
12073 case STV_INTERNAL
: return "INTERNAL";
12074 case STV_HIDDEN
: return "HIDDEN";
12075 case STV_PROTECTED
: return "PROTECTED";
12077 error (_("Unrecognized visibility value: %u\n"), visibility
);
12078 return _("<unknown>");
12082 static const char *
12083 get_alpha_symbol_other (unsigned int other
)
12087 case STO_ALPHA_NOPV
: return "NOPV";
12088 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
12090 error (_("Unrecognized alpha specific other value: %u\n"), other
);
12091 return _("<unknown>");
12095 static const char *
12096 get_solaris_symbol_visibility (unsigned int visibility
)
12098 switch (visibility
)
12100 case 4: return "EXPORTED";
12101 case 5: return "SINGLETON";
12102 case 6: return "ELIMINATE";
12103 default: return get_symbol_visibility (visibility
);
12107 static const char *
12108 get_aarch64_symbol_other (unsigned int other
)
12110 static char buf
[32];
12112 if (other
& STO_AARCH64_VARIANT_PCS
)
12114 other
&= ~STO_AARCH64_VARIANT_PCS
;
12116 return "VARIANT_PCS";
12117 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
12123 static const char *
12124 get_mips_symbol_other (unsigned int other
)
12128 case STO_OPTIONAL
: return "OPTIONAL";
12129 case STO_MIPS_PLT
: return "MIPS PLT";
12130 case STO_MIPS_PIC
: return "MIPS PIC";
12131 case STO_MICROMIPS
: return "MICROMIPS";
12132 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
12133 case STO_MIPS16
: return "MIPS16";
12134 default: return NULL
;
12138 static const char *
12139 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
12141 if (is_ia64_vms (filedata
))
12143 static char res
[32];
12147 /* Function types is for images and .STB files only. */
12148 switch (filedata
->file_header
.e_type
)
12152 switch (VMS_ST_FUNC_TYPE (other
))
12154 case VMS_SFT_CODE_ADDR
:
12155 strcat (res
, " CA");
12157 case VMS_SFT_SYMV_IDX
:
12158 strcat (res
, " VEC");
12161 strcat (res
, " FD");
12163 case VMS_SFT_RESERVE
:
12164 strcat (res
, " RSV");
12167 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
12168 VMS_ST_FUNC_TYPE (other
));
12169 strcat (res
, " <unknown>");
12176 switch (VMS_ST_LINKAGE (other
))
12178 case VMS_STL_IGNORE
:
12179 strcat (res
, " IGN");
12181 case VMS_STL_RESERVE
:
12182 strcat (res
, " RSV");
12185 strcat (res
, " STD");
12188 strcat (res
, " LNK");
12191 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
12192 VMS_ST_LINKAGE (other
));
12193 strcat (res
, " <unknown>");
12205 static const char *
12206 get_ppc64_symbol_other (unsigned int other
)
12208 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
12211 other
>>= STO_PPC64_LOCAL_BIT
;
12214 static char buf
[64];
12216 other
= ppc64_decode_local_entry (other
);
12217 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
12223 static const char *
12224 get_symbol_other (Filedata
* filedata
, unsigned int other
)
12226 const char * result
= NULL
;
12227 static char buff
[64];
12232 switch (filedata
->file_header
.e_machine
)
12235 result
= get_alpha_symbol_other (other
);
12238 result
= get_aarch64_symbol_other (other
);
12241 result
= get_mips_symbol_other (other
);
12244 result
= get_ia64_symbol_other (filedata
, other
);
12247 result
= get_ppc64_symbol_other (other
);
12257 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
12261 static const char *
12262 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
12264 static char buff
[32];
12268 case SHN_UNDEF
: return "UND";
12269 case SHN_ABS
: return "ABS";
12270 case SHN_COMMON
: return "COM";
12272 if (type
== SHN_IA_64_ANSI_COMMON
12273 && filedata
->file_header
.e_machine
== EM_IA_64
12274 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
12276 else if ((filedata
->file_header
.e_machine
== EM_X86_64
12277 || filedata
->file_header
.e_machine
== EM_L1OM
12278 || filedata
->file_header
.e_machine
== EM_K1OM
)
12279 && type
== SHN_X86_64_LCOMMON
)
12280 return "LARGE_COM";
12281 else if ((type
== SHN_MIPS_SCOMMON
12282 && filedata
->file_header
.e_machine
== EM_MIPS
)
12283 || (type
== SHN_TIC6X_SCOMMON
12284 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
12286 else if (type
== SHN_MIPS_SUNDEFINED
12287 && filedata
->file_header
.e_machine
== EM_MIPS
)
12289 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
12290 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
12291 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
12292 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
12293 else if (type
>= SHN_LORESERVE
)
12294 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
12295 else if (filedata
->file_header
.e_shnum
!= 0
12296 && type
>= filedata
->file_header
.e_shnum
)
12297 sprintf (buff
, _("bad section index[%3d]"), type
);
12299 sprintf (buff
, "%3d", type
);
12306 static const char *
12307 get_symbol_version_string (Filedata
* filedata
,
12309 const char * strtab
,
12310 unsigned long int strtab_size
,
12312 Elf_Internal_Sym
* psym
,
12313 enum versioned_symbol_info
* sym_info
,
12314 unsigned short * vna_other
)
12316 unsigned char data
[2];
12317 unsigned short vers_data
;
12318 unsigned long offset
;
12319 unsigned short max_vd_ndx
;
12322 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
12325 offset
= offset_from_vma (filedata
,
12326 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
12327 sizeof data
+ si
* sizeof (vers_data
));
12329 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
12330 sizeof (data
), 1, _("version data")) == NULL
)
12333 vers_data
= byte_get (data
, 2);
12335 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
12338 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
12341 /* Usually we'd only see verdef for defined symbols, and verneed for
12342 undefined symbols. However, symbols defined by the linker in
12343 .dynbss for variables copied from a shared library in order to
12344 avoid text relocations are defined yet have verneed. We could
12345 use a heuristic to detect the special case, for example, check
12346 for verneed first on symbols defined in SHT_NOBITS sections, but
12347 it is simpler and more reliable to just look for both verdef and
12348 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
12350 if (psym
->st_shndx
!= SHN_UNDEF
12351 && vers_data
!= 0x8001
12352 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
12354 Elf_Internal_Verdef ivd
;
12355 Elf_Internal_Verdaux ivda
;
12356 Elf_External_Verdaux evda
;
12359 off
= offset_from_vma (filedata
,
12360 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
12361 sizeof (Elf_External_Verdef
));
12365 Elf_External_Verdef evd
;
12367 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
12368 _("version def")) == NULL
)
12377 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
12378 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
12379 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
12380 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
12383 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
12384 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
12386 off
+= ivd
.vd_next
;
12388 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
12390 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
12392 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
12395 off
-= ivd
.vd_next
;
12398 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
12399 _("version def aux")) != NULL
)
12401 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
12403 if (psym
->st_name
!= ivda
.vda_name
)
12404 return (ivda
.vda_name
< strtab_size
12405 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
12410 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
12412 Elf_External_Verneed evn
;
12413 Elf_Internal_Verneed ivn
;
12414 Elf_Internal_Vernaux ivna
;
12416 offset
= offset_from_vma (filedata
,
12417 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
12421 unsigned long vna_off
;
12423 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
12424 _("version need")) == NULL
)
12427 ivna
.vna_other
= 0;
12432 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
12433 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
12435 vna_off
= offset
+ ivn
.vn_aux
;
12439 Elf_External_Vernaux evna
;
12441 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
12442 _("version need aux (3)")) == NULL
)
12445 ivna
.vna_other
= 0;
12450 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
12451 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
12452 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
12455 vna_off
+= ivna
.vna_next
;
12457 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
12459 if (ivna
.vna_other
== vers_data
)
12462 offset
+= ivn
.vn_next
;
12464 while (ivn
.vn_next
!= 0);
12466 if (ivna
.vna_other
== vers_data
)
12468 *sym_info
= symbol_undefined
;
12469 *vna_other
= ivna
.vna_other
;
12470 return (ivna
.vna_name
< strtab_size
12471 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
12473 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
12474 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
12475 return _("<corrupt>");
12480 /* Display a symbol size on stdout. Format is based on --sym-base setting. */
12482 static unsigned int
12483 print_dynamic_symbol_size (bfd_vma vma
, int base
)
12488 return print_vma (vma
, OCTAL_5
);
12491 return print_vma (vma
, UNSIGNED_5
);
12494 return print_vma (vma
, PREFIX_HEX_5
);
12498 return print_vma (vma
, DEC_5
);
12503 print_dynamic_symbol (Filedata
*filedata
, unsigned long si
,
12504 Elf_Internal_Sym
*symtab
,
12505 Elf_Internal_Shdr
*section
,
12506 char *strtab
, size_t strtab_size
)
12508 const char *version_string
;
12509 enum versioned_symbol_info sym_info
;
12510 unsigned short vna_other
;
12513 Elf_Internal_Sym
*psym
= symtab
+ si
;
12515 printf ("%6ld: ", si
);
12516 print_vma (psym
->st_value
, LONG_HEX
);
12518 print_dynamic_symbol_size (psym
->st_size
, sym_base
);
12519 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12520 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12521 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12522 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12525 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12527 printf (" %-7s", get_symbol_visibility (vis
));
12528 /* Check to see if any other bits in the st_other field are set.
12529 Note - displaying this information disrupts the layout of the
12530 table being generated, but for the moment this case is very rare. */
12531 if (psym
->st_other
^ vis
)
12532 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12534 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12536 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
12537 && psym
->st_shndx
< filedata
->file_header
.e_shnum
12538 && psym
->st_name
== 0)
12540 is_valid
= SECTION_NAME_VALID (filedata
->section_headers
+ psym
->st_shndx
);
12542 SECTION_NAME_PRINT (filedata
->section_headers
+ psym
->st_shndx
)
12547 is_valid
= VALID_SYMBOL_NAME (strtab
, strtab_size
, psym
->st_name
);
12548 sstr
= is_valid
? strtab
+ psym
->st_name
: _("<corrupt>");
12552 = get_symbol_version_string (filedata
,
12554 || section
->sh_type
== SHT_DYNSYM
),
12555 strtab
, strtab_size
, si
,
12556 psym
, &sym_info
, &vna_other
);
12558 int len_avail
= 21;
12559 if (! do_wide
&& version_string
!= NULL
)
12563 len_avail
-= 1 + strlen (version_string
);
12565 if (sym_info
== symbol_undefined
)
12566 len_avail
-= sprintf (buffer
," (%d)", vna_other
);
12567 else if (sym_info
!= symbol_hidden
)
12571 print_symbol (len_avail
, sstr
);
12573 if (version_string
)
12575 if (sym_info
== symbol_undefined
)
12576 printf ("@%s (%d)", version_string
, vna_other
);
12578 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12584 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12586 && si
>= section
->sh_info
12587 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12588 && filedata
->file_header
.e_machine
!= EM_MIPS
12589 /* Solaris binaries have been found to violate this requirement as
12590 well. Not sure if this is a bug or an ABI requirement. */
12591 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12592 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12593 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12596 static const char *
12597 get_lto_kind (unsigned int kind
)
12601 case 0: return "DEF";
12602 case 1: return "WEAKDEF";
12603 case 2: return "UNDEF";
12604 case 3: return "WEAKUNDEF";
12605 case 4: return "COMMON";
12610 static char buffer
[30];
12611 error (_("Unknown LTO symbol definition encountered: %u\n"), kind
);
12612 sprintf (buffer
, "<unknown: %u>", kind
);
12616 static const char *
12617 get_lto_visibility (unsigned int visibility
)
12619 switch (visibility
)
12621 case 0: return "DEFAULT";
12622 case 1: return "PROTECTED";
12623 case 2: return "INTERNAL";
12624 case 3: return "HIDDEN";
12629 static char buffer
[30];
12630 error (_("Unknown LTO symbol visibility encountered: %u\n"), visibility
);
12631 sprintf (buffer
, "<unknown: %u>", visibility
);
12635 static const char *
12636 get_lto_sym_type (unsigned int sym_type
)
12640 case 0: return "UNKNOWN";
12641 case 1: return "FUNCTION";
12642 case 2: return "VARIABLE";
12647 static char buffer
[30];
12648 error (_("Unknown LTO symbol type encountered: %u\n"), sym_type
);
12649 sprintf (buffer
, "<unknown: %u>", sym_type
);
12653 /* Display an LTO format symbol table.
12654 FIXME: The format of LTO symbol tables is not formalized.
12655 So this code could need changing in the future. */
12658 display_lto_symtab (Filedata
* filedata
,
12659 Elf_Internal_Shdr
* section
)
12661 if (section
->sh_size
== 0)
12663 if (filedata
->is_separate
)
12664 printf (_("\nThe LTO Symbol table section '%s' in linked file '%s' is empty!\n"),
12665 printable_section_name (filedata
, section
),
12666 filedata
->file_name
);
12668 printf (_("\nLTO Symbol table '%s' is empty!\n"),
12669 printable_section_name (filedata
, section
));
12674 if (section
->sh_size
> filedata
->file_size
)
12676 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
12677 printable_section_name (filedata
, section
),
12678 (unsigned long) section
->sh_size
);
12682 void * alloced_data
= get_data (NULL
, filedata
, section
->sh_offset
,
12683 section
->sh_size
, 1, _("LTO symbols"));
12684 if (alloced_data
== NULL
)
12687 /* Look for extended data for the symbol table. */
12688 Elf_Internal_Shdr
* ext
;
12689 void * ext_data_orig
= NULL
;
12690 char * ext_data
= NULL
;
12691 char * ext_data_end
= NULL
;
12692 char * ext_name
= NULL
;
12694 if (asprintf (& ext_name
, ".gnu.lto_.ext_symtab.%s",
12695 SECTION_NAME (section
) + sizeof (".gnu.lto_.symtab.") - 1) > 0
12696 && ext_name
!= NULL
/* Paranoia. */
12697 && (ext
= find_section (filedata
, ext_name
)) != NULL
)
12699 if (ext
->sh_size
< 3)
12700 error (_("LTO Symbol extension table '%s' is empty!\n"),
12701 printable_section_name (filedata
, ext
));
12704 ext_data_orig
= ext_data
= get_data (NULL
, filedata
, ext
->sh_offset
,
12706 _("LTO ext symbol data"));
12707 if (ext_data
!= NULL
)
12709 ext_data_end
= ext_data
+ ext
->sh_size
;
12710 if (* ext_data
++ != 1)
12711 error (_("Unexpected version number in symbol extension table\n"));
12716 const unsigned char * data
= (const unsigned char *) alloced_data
;
12717 const unsigned char * end
= data
+ section
->sh_size
;
12719 if (filedata
->is_separate
)
12720 printf (_("\nIn linked file '%s': "), filedata
->file_name
);
12724 if (ext_data_orig
!= NULL
)
12727 printf (_("LTO Symbol table '%s' and extension table '%s' contain:\n"),
12728 printable_section_name (filedata
, section
),
12729 printable_section_name (filedata
, ext
));
12732 printf (_("LTO Symbol table '%s'\n"),
12733 printable_section_name (filedata
, section
));
12734 printf (_(" and extension table '%s' contain:\n"),
12735 printable_section_name (filedata
, ext
));
12739 printf (_("LTO Symbol table '%s' contains:\n"),
12740 printable_section_name (filedata
, section
));
12742 /* FIXME: Add a wide version. */
12743 if (ext_data_orig
!= NULL
)
12744 printf (_(" Comdat_Key Kind Visibility Size Slot Type Section Name\n"));
12746 printf (_(" Comdat_Key Kind Visibility Size Slot Name\n"));
12748 /* FIXME: We do not handle style prefixes. */
12752 const unsigned char * sym_name
= data
;
12753 data
+= strnlen ((const char *) sym_name
, end
- data
) + 1;
12757 const unsigned char * comdat_key
= data
;
12758 data
+= strnlen ((const char *) comdat_key
, end
- data
) + 1;
12762 if (data
+ 2 + 8 + 4 > end
)
12765 unsigned int kind
= *data
++;
12766 unsigned int visibility
= *data
++;
12768 elf_vma size
= byte_get (data
, 8);
12771 elf_vma slot
= byte_get (data
, 4);
12774 if (ext_data
!= NULL
)
12776 if (ext_data
< (ext_data_end
- 1))
12778 unsigned int sym_type
= * ext_data
++;
12779 unsigned int sec_kind
= * ext_data
++;
12781 printf (" %10s %10s %11s %08lx %08lx %9s %08lx _",
12782 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
12783 get_lto_kind (kind
),
12784 get_lto_visibility (visibility
),
12787 get_lto_sym_type (sym_type
),
12789 print_symbol (6, (const char *) sym_name
);
12793 error (_("Ran out of LTO symbol extension data\n"));
12795 /* FIXME: return FAIL result ? */
12800 printf (" %10s %10s %11s %08lx %08lx _",
12801 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
12802 get_lto_kind (kind
),
12803 get_lto_visibility (visibility
),
12806 print_symbol (21, (const char *) sym_name
);
12811 if (ext_data
!= NULL
&& ext_data
< ext_data_end
)
12813 error (_("Data remains in the LTO symbol extension table\n"));
12817 free (alloced_data
);
12818 free (ext_data_orig
);
12823 error (_("Buffer overrun encountered whilst decoding LTO symbol table\n"));
12824 free (alloced_data
);
12825 free (ext_data_orig
);
12830 /* Display LTO symbol tables. */
12833 process_lto_symbol_tables (Filedata
* filedata
)
12835 Elf_Internal_Shdr
* section
;
12842 if (filedata
->section_headers
== NULL
)
12845 for (i
= 0, section
= filedata
->section_headers
;
12846 i
< filedata
->file_header
.e_shnum
;
12848 if (SECTION_NAME_VALID (section
)
12849 && startswith (SECTION_NAME (section
), ".gnu.lto_.symtab."))
12850 res
&= display_lto_symtab (filedata
, section
);
12855 /* Dump the symbol table. */
12858 process_symbol_table (Filedata
* filedata
)
12860 Elf_Internal_Shdr
* section
;
12862 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
12865 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
12867 && do_using_dynamic
12868 && filedata
->dynamic_strings
!= NULL
12869 && filedata
->dynamic_symbols
!= NULL
)
12873 if (filedata
->is_separate
)
12875 printf (ngettext ("\nIn linked file '%s' the dynamic symbol table contains %lu entry:\n",
12876 "\nIn linked file '%s' the dynamic symbol table contains %lu entries:\n",
12877 filedata
->num_dynamic_syms
),
12878 filedata
->file_name
,
12879 filedata
->num_dynamic_syms
);
12883 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
12884 "\nSymbol table for image contains %lu entries:\n",
12885 filedata
->num_dynamic_syms
),
12886 filedata
->num_dynamic_syms
);
12889 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12891 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12893 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
12894 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
12895 filedata
->dynamic_strings
,
12896 filedata
->dynamic_strings_length
);
12898 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
12899 && filedata
->section_headers
!= NULL
)
12903 for (i
= 0, section
= filedata
->section_headers
;
12904 i
< filedata
->file_header
.e_shnum
;
12907 char * strtab
= NULL
;
12908 unsigned long int strtab_size
= 0;
12909 Elf_Internal_Sym
* symtab
;
12910 unsigned long si
, num_syms
;
12912 if ((section
->sh_type
!= SHT_SYMTAB
12913 && section
->sh_type
!= SHT_DYNSYM
)
12915 && section
->sh_type
== SHT_SYMTAB
))
12918 if (section
->sh_entsize
== 0)
12920 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12921 printable_section_name (filedata
, section
));
12925 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12927 if (filedata
->is_separate
)
12928 printf (ngettext ("\nIn linked file '%s' symbol section '%s' contains %lu entry:\n",
12929 "\nIn linked file '%s' symbol section '%s' contains %lu entries:\n",
12931 filedata
->file_name
,
12932 printable_section_name (filedata
, section
),
12935 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12936 "\nSymbol table '%s' contains %lu entries:\n",
12938 printable_section_name (filedata
, section
),
12942 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12944 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12946 symtab
= get_elf_symbols (filedata
, section
, & num_syms
);
12947 if (symtab
== NULL
)
12950 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12952 strtab
= filedata
->string_table
;
12953 strtab_size
= filedata
->string_table_length
;
12955 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12957 Elf_Internal_Shdr
* string_sec
;
12959 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12961 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12962 1, string_sec
->sh_size
,
12963 _("string table"));
12964 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12967 for (si
= 0; si
< num_syms
; si
++)
12968 print_dynamic_symbol (filedata
, si
, symtab
, section
,
12969 strtab
, strtab_size
);
12972 if (strtab
!= filedata
->string_table
)
12978 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12980 if (do_histogram
&& filedata
->buckets
!= NULL
)
12982 unsigned long * lengths
;
12983 unsigned long * counts
;
12986 unsigned long maxlength
= 0;
12987 unsigned long nzero_counts
= 0;
12988 unsigned long nsyms
= 0;
12991 printf (ngettext ("\nHistogram for bucket list length "
12992 "(total of %lu bucket):\n",
12993 "\nHistogram for bucket list length "
12994 "(total of %lu buckets):\n",
12995 (unsigned long) filedata
->nbuckets
),
12996 (unsigned long) filedata
->nbuckets
);
12998 lengths
= (unsigned long *) calloc (filedata
->nbuckets
,
12999 sizeof (*lengths
));
13000 if (lengths
== NULL
)
13002 error (_("Out of memory allocating space for histogram buckets\n"));
13005 visited
= xcmalloc (filedata
->nchains
, 1);
13006 memset (visited
, 0, filedata
->nchains
);
13008 printf (_(" Length Number %% of total Coverage\n"));
13009 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
13011 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
13014 if (maxlength
< ++lengths
[hn
])
13016 if (si
>= filedata
->nchains
|| visited
[si
])
13018 error (_("histogram chain is corrupt\n"));
13026 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
13027 if (counts
== NULL
)
13030 error (_("Out of memory allocating space for histogram counts\n"));
13034 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
13035 ++counts
[lengths
[hn
]];
13037 if (filedata
->nbuckets
> 0)
13040 printf (" 0 %-10lu (%5.1f%%)\n",
13041 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
13042 for (i
= 1; i
<= maxlength
; ++i
)
13044 nzero_counts
+= counts
[i
] * i
;
13045 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
13046 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
13047 (nzero_counts
* 100.0) / nsyms
);
13055 free (filedata
->buckets
);
13056 filedata
->buckets
= NULL
;
13057 filedata
->nbuckets
= 0;
13058 free (filedata
->chains
);
13059 filedata
->chains
= NULL
;
13061 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
13063 unsigned long * lengths
;
13064 unsigned long * counts
;
13066 unsigned long maxlength
= 0;
13067 unsigned long nzero_counts
= 0;
13068 unsigned long nsyms
= 0;
13070 printf (ngettext ("\nHistogram for `%s' bucket list length "
13071 "(total of %lu bucket):\n",
13072 "\nHistogram for `%s' bucket list length "
13073 "(total of %lu buckets):\n",
13074 (unsigned long) filedata
->ngnubuckets
),
13075 GNU_HASH_SECTION_NAME (filedata
),
13076 (unsigned long) filedata
->ngnubuckets
);
13078 lengths
= (unsigned long *) calloc (filedata
->ngnubuckets
,
13079 sizeof (*lengths
));
13080 if (lengths
== NULL
)
13082 error (_("Out of memory allocating space for gnu histogram buckets\n"));
13086 printf (_(" Length Number %% of total Coverage\n"));
13088 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
13089 if (filedata
->gnubuckets
[hn
] != 0)
13091 bfd_vma off
, length
= 1;
13093 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
13094 /* PR 17531 file: 010-77222-0.004. */
13095 off
< filedata
->ngnuchains
13096 && (filedata
->gnuchains
[off
] & 1) == 0;
13099 lengths
[hn
] = length
;
13100 if (length
> maxlength
)
13101 maxlength
= length
;
13105 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
13106 if (counts
== NULL
)
13109 error (_("Out of memory allocating space for gnu histogram counts\n"));
13113 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
13114 ++counts
[lengths
[hn
]];
13116 if (filedata
->ngnubuckets
> 0)
13119 printf (" 0 %-10lu (%5.1f%%)\n",
13120 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
13121 for (j
= 1; j
<= maxlength
; ++j
)
13123 nzero_counts
+= counts
[j
] * j
;
13124 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
13125 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
13126 (nzero_counts
* 100.0) / nsyms
);
13133 free (filedata
->gnubuckets
);
13134 filedata
->gnubuckets
= NULL
;
13135 filedata
->ngnubuckets
= 0;
13136 free (filedata
->gnuchains
);
13137 filedata
->gnuchains
= NULL
;
13138 filedata
->ngnuchains
= 0;
13139 free (filedata
->mipsxlat
);
13140 filedata
->mipsxlat
= NULL
;
13144 free (filedata
->gnubuckets
);
13145 filedata
->gnubuckets
= NULL
;
13146 filedata
->ngnubuckets
= 0;
13147 free (filedata
->gnuchains
);
13148 filedata
->gnuchains
= NULL
;
13149 filedata
->ngnuchains
= 0;
13150 free (filedata
->mipsxlat
);
13151 filedata
->mipsxlat
= NULL
;
13152 free (filedata
->buckets
);
13153 filedata
->buckets
= NULL
;
13154 filedata
->nbuckets
= 0;
13155 free (filedata
->chains
);
13156 filedata
->chains
= NULL
;
13161 process_syminfo (Filedata
* filedata
)
13165 if (filedata
->dynamic_syminfo
== NULL
13167 /* No syminfo, this is ok. */
13170 /* There better should be a dynamic symbol section. */
13171 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
13174 if (filedata
->is_separate
)
13175 printf (ngettext ("\nIn linked file '%s: the dynamic info segment at offset 0x%lx contains %d entry:\n",
13176 "\nIn linked file '%s: the dynamic info segment at offset 0x%lx contains %d entries:\n",
13177 filedata
->dynamic_syminfo_nent
),
13178 filedata
->file_name
,
13179 filedata
->dynamic_syminfo_offset
,
13180 filedata
->dynamic_syminfo_nent
);
13182 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
13183 "contains %d entry:\n",
13184 "\nDynamic info segment at offset 0x%lx "
13185 "contains %d entries:\n",
13186 filedata
->dynamic_syminfo_nent
),
13187 filedata
->dynamic_syminfo_offset
,
13188 filedata
->dynamic_syminfo_nent
);
13190 printf (_(" Num: Name BoundTo Flags\n"));
13191 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
13193 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
13195 printf ("%4d: ", i
);
13196 if (i
>= filedata
->num_dynamic_syms
)
13197 printf (_("<corrupt index>"));
13198 else if (VALID_DYNAMIC_NAME (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
13199 print_symbol (30, GET_DYNAMIC_NAME (filedata
,
13200 filedata
->dynamic_symbols
[i
].st_name
));
13202 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
13205 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
13207 case SYMINFO_BT_SELF
:
13208 fputs ("SELF ", stdout
);
13210 case SYMINFO_BT_PARENT
:
13211 fputs ("PARENT ", stdout
);
13214 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
13215 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
13216 && VALID_DYNAMIC_NAME (filedata
,
13217 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
13219 print_symbol (10, GET_DYNAMIC_NAME (filedata
,
13220 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
13224 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
13228 if (flags
& SYMINFO_FLG_DIRECT
)
13229 printf (" DIRECT");
13230 if (flags
& SYMINFO_FLG_PASSTHRU
)
13231 printf (" PASSTHRU");
13232 if (flags
& SYMINFO_FLG_COPY
)
13234 if (flags
& SYMINFO_FLG_LAZYLOAD
)
13235 printf (" LAZYLOAD");
13243 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
13244 is contained by the region START .. END. The types of ADDR, START
13245 and END should all be the same. Note both ADDR + NELEM and END
13246 point to just beyond the end of the regions that are being tested. */
13247 #define IN_RANGE(START,END,ADDR,NELEM) \
13248 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
13250 /* Check to see if the given reloc needs to be handled in a target specific
13251 manner. If so then process the reloc and return TRUE otherwise return
13254 If called with reloc == NULL, then this is a signal that reloc processing
13255 for the current section has finished, and any saved state should be
13259 target_specific_reloc_handling (Filedata
* filedata
,
13260 Elf_Internal_Rela
* reloc
,
13261 unsigned char * start
,
13262 unsigned char * end
,
13263 Elf_Internal_Sym
* symtab
,
13264 unsigned long num_syms
)
13266 unsigned int reloc_type
= 0;
13267 unsigned long sym_index
= 0;
13271 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
13272 sym_index
= get_reloc_symindex (reloc
->r_info
);
13275 switch (filedata
->file_header
.e_machine
)
13278 case EM_MSP430_OLD
:
13280 static Elf_Internal_Sym
* saved_sym
= NULL
;
13288 switch (reloc_type
)
13290 case 10: /* R_MSP430_SYM_DIFF */
13291 case 12: /* R_MSP430_GNU_SUB_ULEB128 */
13292 if (uses_msp430x_relocs (filedata
))
13294 /* Fall through. */
13295 case 21: /* R_MSP430X_SYM_DIFF */
13296 case 23: /* R_MSP430X_GNU_SUB_ULEB128 */
13298 if (sym_index
>= num_syms
)
13299 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
13302 saved_sym
= symtab
+ sym_index
;
13305 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
13306 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
13307 goto handle_sym_diff
;
13309 case 5: /* R_MSP430_16_BYTE */
13310 case 9: /* R_MSP430_8 */
13311 case 11: /* R_MSP430_GNU_SET_ULEB128 */
13312 if (uses_msp430x_relocs (filedata
))
13314 goto handle_sym_diff
;
13316 case 2: /* R_MSP430_ABS16 */
13317 case 15: /* R_MSP430X_ABS16 */
13318 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
13319 if (! uses_msp430x_relocs (filedata
))
13321 goto handle_sym_diff
;
13324 if (saved_sym
!= NULL
)
13327 unsigned int reloc_size
= 0;
13329 switch (reloc_type
)
13331 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
13334 case 11: /* R_MSP430_GNU_SET_ULEB128 */
13335 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
13336 if (reloc
->r_offset
< (size_t) (end
- start
))
13337 read_leb128 (start
+ reloc
->r_offset
, end
, false,
13338 &reloc_size
, &leb_ret
);
13345 if (leb_ret
!= 0 || reloc_size
== 0 || reloc_size
> 8)
13346 error (_("MSP430 ULEB128 field at 0x%lx contains invalid "
13347 "ULEB128 value\n"),
13348 (long) reloc
->r_offset
);
13349 else if (sym_index
>= num_syms
)
13350 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
13354 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
13355 - saved_sym
->st_value
);
13357 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
13358 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
13361 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
13362 (long) reloc
->r_offset
);
13371 if (saved_sym
!= NULL
)
13372 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13379 case EM_CYGNUS_MN10300
:
13381 static Elf_Internal_Sym
* saved_sym
= NULL
;
13389 switch (reloc_type
)
13391 case 34: /* R_MN10300_ALIGN */
13393 case 33: /* R_MN10300_SYM_DIFF */
13394 if (sym_index
>= num_syms
)
13395 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
13398 saved_sym
= symtab
+ sym_index
;
13401 case 1: /* R_MN10300_32 */
13402 case 2: /* R_MN10300_16 */
13403 if (saved_sym
!= NULL
)
13405 int reloc_size
= reloc_type
== 1 ? 4 : 2;
13408 if (sym_index
>= num_syms
)
13409 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
13413 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
13414 - saved_sym
->st_value
);
13416 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
13417 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
13419 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
13420 (long) reloc
->r_offset
);
13428 if (saved_sym
!= NULL
)
13429 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
13437 static bfd_vma saved_sym1
= 0;
13438 static bfd_vma saved_sym2
= 0;
13439 static bfd_vma value
;
13443 saved_sym1
= saved_sym2
= 0;
13447 switch (reloc_type
)
13449 case 0x80: /* R_RL78_SYM. */
13450 saved_sym1
= saved_sym2
;
13451 if (sym_index
>= num_syms
)
13452 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
13456 saved_sym2
= symtab
[sym_index
].st_value
;
13457 saved_sym2
+= reloc
->r_addend
;
13461 case 0x83: /* R_RL78_OPsub. */
13462 value
= saved_sym1
- saved_sym2
;
13463 saved_sym2
= saved_sym1
= 0;
13467 case 0x41: /* R_RL78_ABS32. */
13468 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
13469 byte_put (start
+ reloc
->r_offset
, value
, 4);
13471 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
13472 (long) reloc
->r_offset
);
13476 case 0x43: /* R_RL78_ABS16. */
13477 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
13478 byte_put (start
+ reloc
->r_offset
, value
, 2);
13480 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
13481 (long) reloc
->r_offset
);
13495 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
13496 DWARF debug sections. This is a target specific test. Note - we do not
13497 go through the whole including-target-headers-multiple-times route, (as
13498 we have already done with <elf/h8.h>) because this would become very
13499 messy and even then this function would have to contain target specific
13500 information (the names of the relocs instead of their numeric values).
13501 FIXME: This is not the correct way to solve this problem. The proper way
13502 is to have target specific reloc sizing and typing functions created by
13503 the reloc-macros.h header, in the same way that it already creates the
13504 reloc naming functions. */
13507 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13509 /* Please keep this table alpha-sorted for ease of visual lookup. */
13510 switch (filedata
->file_header
.e_machine
)
13514 return reloc_type
== 1; /* R_386_32. */
13516 return reloc_type
== 1; /* R_68K_32. */
13518 return reloc_type
== 1; /* R_860_32. */
13520 return reloc_type
== 2; /* R_960_32. */
13522 return (reloc_type
== 258
13523 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
13525 return reloc_type
== 11; /* R_BPF_DATA_32 */
13526 case EM_ADAPTEVA_EPIPHANY
:
13527 return reloc_type
== 3;
13529 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
13531 return reloc_type
== 1; /* R_ARC_32. */
13532 case EM_ARC_COMPACT
:
13533 case EM_ARC_COMPACT2
:
13534 return reloc_type
== 4; /* R_ARC_32. */
13536 return reloc_type
== 2; /* R_ARM_ABS32 */
13539 return reloc_type
== 1;
13541 return reloc_type
== 0x12; /* R_byte4_data. */
13543 return reloc_type
== 3; /* R_CRIS_32. */
13545 return reloc_type
== 3; /* R_CR16_NUM32. */
13547 return reloc_type
== 15; /* R_CRX_NUM32. */
13549 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
13550 case EM_CYGNUS_FRV
:
13551 return reloc_type
== 1;
13552 case EM_CYGNUS_D10V
:
13554 return reloc_type
== 6; /* R_D10V_32. */
13555 case EM_CYGNUS_D30V
:
13557 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
13559 return reloc_type
== 3; /* R_DLX_RELOC_32. */
13560 case EM_CYGNUS_FR30
:
13562 return reloc_type
== 3; /* R_FR30_32. */
13564 return reloc_type
== 1; /* R_FT32_32. */
13568 return reloc_type
== 1; /* R_H8_DIR32. */
13570 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
13571 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
13572 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
13573 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
13576 return reloc_type
== 2; /* R_IP2K_32. */
13578 return reloc_type
== 2; /* R_IQ2000_32. */
13579 case EM_LATTICEMICO32
:
13580 return reloc_type
== 3; /* R_LM32_32. */
13583 return reloc_type
== 3; /* R_M32C_32. */
13585 return reloc_type
== 34; /* R_M32R_32_RELA. */
13588 return reloc_type
== 6; /* R_M68HC11_32. */
13590 return reloc_type
== 7 || /* R_S12Z_EXT32 */
13591 reloc_type
== 6; /* R_S12Z_CW32. */
13593 return reloc_type
== 1; /* R_MCORE_ADDR32. */
13594 case EM_CYGNUS_MEP
:
13595 return reloc_type
== 4; /* R_MEP_32. */
13597 return reloc_type
== 2; /* R_METAG_ADDR32. */
13598 case EM_MICROBLAZE
:
13599 return reloc_type
== 1; /* R_MICROBLAZE_32. */
13601 return reloc_type
== 2; /* R_MIPS_32. */
13603 return reloc_type
== 4; /* R_MMIX_32. */
13604 case EM_CYGNUS_MN10200
:
13606 return reloc_type
== 1; /* R_MN10200_32. */
13607 case EM_CYGNUS_MN10300
:
13609 return reloc_type
== 1; /* R_MN10300_32. */
13611 return reloc_type
== 1; /* R_MOXIE_32. */
13612 case EM_MSP430_OLD
:
13614 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
13616 return reloc_type
== 2; /* R_MT_32. */
13618 return reloc_type
== 20; /* R_NDS32_RELA. */
13619 case EM_ALTERA_NIOS2
:
13620 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
13622 return reloc_type
== 1; /* R_NIOS_32. */
13624 return reloc_type
== 1; /* R_OR1K_32. */
13626 return (reloc_type
== 1 /* R_PARISC_DIR32. */
13627 || reloc_type
== 2 /* R_PARISC_DIR21L. */
13628 || reloc_type
== 41); /* R_PARISC_SECREL32. */
13631 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
13633 return reloc_type
== 1; /* R_PPC64_ADDR32. */
13635 return reloc_type
== 1; /* R_PPC_ADDR32. */
13637 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
13639 return reloc_type
== 1; /* R_RISCV_32. */
13641 return reloc_type
== 1; /* R_RL78_DIR32. */
13643 return reloc_type
== 1; /* R_RX_DIR32. */
13645 return reloc_type
== 1; /* R_I370_ADDR31. */
13648 return reloc_type
== 4; /* R_S390_32. */
13650 return reloc_type
== 8; /* R_SCORE_ABS32. */
13652 return reloc_type
== 1; /* R_SH_DIR32. */
13653 case EM_SPARC32PLUS
:
13656 return reloc_type
== 3 /* R_SPARC_32. */
13657 || reloc_type
== 23; /* R_SPARC_UA32. */
13659 return reloc_type
== 6; /* R_SPU_ADDR32 */
13661 return reloc_type
== 1; /* R_C6000_ABS32. */
13663 return reloc_type
== 2; /* R_TILEGX_32. */
13665 return reloc_type
== 1; /* R_TILEPRO_32. */
13666 case EM_CYGNUS_V850
:
13668 return reloc_type
== 6; /* R_V850_ABS32. */
13670 return reloc_type
== 0x33; /* R_V810_WORD. */
13672 return reloc_type
== 1; /* R_VAX_32. */
13674 return reloc_type
== 3; /* R_VISIUM_32. */
13675 case EM_WEBASSEMBLY
:
13676 return reloc_type
== 1; /* R_WASM32_32. */
13680 return reloc_type
== 10; /* R_X86_64_32. */
13683 return reloc_type
== 3; /* R_XC16C_ABS_32. */
13685 return reloc_type
== 4; /* R_XGATE_32. */
13687 return reloc_type
== 1; /* R_XSTROMY16_32. */
13688 case EM_XTENSA_OLD
:
13690 return reloc_type
== 1; /* R_XTENSA_32. */
13692 return reloc_type
== 6; /* R_Z80_32. */
13695 static unsigned int prev_warn
= 0;
13697 /* Avoid repeating the same warning multiple times. */
13698 if (prev_warn
!= filedata
->file_header
.e_machine
)
13699 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
13700 filedata
->file_header
.e_machine
);
13701 prev_warn
= filedata
->file_header
.e_machine
;
13707 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13708 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
13711 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13713 switch (filedata
->file_header
.e_machine
)
13714 /* Please keep this table alpha-sorted for ease of visual lookup. */
13718 return reloc_type
== 2; /* R_386_PC32. */
13720 return reloc_type
== 4; /* R_68K_PC32. */
13722 return reloc_type
== 261; /* R_AARCH64_PREL32 */
13723 case EM_ADAPTEVA_EPIPHANY
:
13724 return reloc_type
== 6;
13726 return reloc_type
== 10; /* R_ALPHA_SREL32. */
13727 case EM_ARC_COMPACT
:
13728 case EM_ARC_COMPACT2
:
13729 return reloc_type
== 49; /* R_ARC_32_PCREL. */
13731 return reloc_type
== 3; /* R_ARM_REL32 */
13734 return reloc_type
== 36; /* R_AVR_32_PCREL. */
13735 case EM_MICROBLAZE
:
13736 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
13738 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
13740 return reloc_type
== 9; /* R_PARISC_PCREL32. */
13742 return reloc_type
== 26; /* R_PPC_REL32. */
13744 return reloc_type
== 26; /* R_PPC64_REL32. */
13746 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
13749 return reloc_type
== 5; /* R_390_PC32. */
13751 return reloc_type
== 2; /* R_SH_REL32. */
13752 case EM_SPARC32PLUS
:
13755 return reloc_type
== 6; /* R_SPARC_DISP32. */
13757 return reloc_type
== 13; /* R_SPU_REL32. */
13759 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
13761 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
13763 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
13767 return reloc_type
== 2; /* R_X86_64_PC32. */
13769 return reloc_type
== 4; /* R_VAX_PCREL32. */
13770 case EM_XTENSA_OLD
:
13772 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
13774 /* Do not abort or issue an error message here. Not all targets use
13775 pc-relative 32-bit relocs in their DWARF debug information and we
13776 have already tested for target coverage in is_32bit_abs_reloc. A
13777 more helpful warning message will be generated by apply_relocations
13778 anyway, so just return. */
13783 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13784 a 64-bit absolute RELA relocation used in DWARF debug sections. */
13787 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13789 switch (filedata
->file_header
.e_machine
)
13792 return reloc_type
== 257; /* R_AARCH64_ABS64. */
13794 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
13796 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
13797 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
13799 return reloc_type
== 80; /* R_PARISC_DIR64. */
13801 return reloc_type
== 38; /* R_PPC64_ADDR64. */
13803 return reloc_type
== 2; /* R_RISCV_64. */
13804 case EM_SPARC32PLUS
:
13807 return reloc_type
== 32 /* R_SPARC_64. */
13808 || reloc_type
== 54; /* R_SPARC_UA64. */
13812 return reloc_type
== 1; /* R_X86_64_64. */
13815 return reloc_type
== 22; /* R_S390_64. */
13817 return reloc_type
== 1; /* R_TILEGX_64. */
13819 return reloc_type
== 18; /* R_MIPS_64. */
13825 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
13826 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
13829 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13831 switch (filedata
->file_header
.e_machine
)
13834 return reloc_type
== 260; /* R_AARCH64_PREL64. */
13836 return reloc_type
== 11; /* R_ALPHA_SREL64. */
13838 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
13839 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
13841 return reloc_type
== 72; /* R_PARISC_PCREL64. */
13843 return reloc_type
== 44; /* R_PPC64_REL64. */
13844 case EM_SPARC32PLUS
:
13847 return reloc_type
== 46; /* R_SPARC_DISP64. */
13851 return reloc_type
== 24; /* R_X86_64_PC64. */
13854 return reloc_type
== 23; /* R_S390_PC64. */
13856 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
13862 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13863 a 24-bit absolute RELA relocation used in DWARF debug sections. */
13866 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13868 switch (filedata
->file_header
.e_machine
)
13870 case EM_CYGNUS_MN10200
:
13872 return reloc_type
== 4; /* R_MN10200_24. */
13874 return reloc_type
== 5; /* R_FT32_20. */
13876 return reloc_type
== 5; /* R_Z80_24. */
13882 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13883 a 16-bit absolute RELA relocation used in DWARF debug sections. */
13886 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13888 /* Please keep this table alpha-sorted for ease of visual lookup. */
13889 switch (filedata
->file_header
.e_machine
)
13892 case EM_ARC_COMPACT
:
13893 case EM_ARC_COMPACT2
:
13894 return reloc_type
== 2; /* R_ARC_16. */
13895 case EM_ADAPTEVA_EPIPHANY
:
13896 return reloc_type
== 5;
13899 return reloc_type
== 4; /* R_AVR_16. */
13900 case EM_CYGNUS_D10V
:
13902 return reloc_type
== 3; /* R_D10V_16. */
13904 return reloc_type
== 2; /* R_FT32_16. */
13908 return reloc_type
== R_H8_DIR16
;
13911 return reloc_type
== 1; /* R_IP2K_16. */
13914 return reloc_type
== 1; /* R_M32C_16 */
13915 case EM_CYGNUS_MN10200
:
13917 return reloc_type
== 2; /* R_MN10200_16. */
13918 case EM_CYGNUS_MN10300
:
13920 return reloc_type
== 2; /* R_MN10300_16. */
13922 if (uses_msp430x_relocs (filedata
))
13923 return reloc_type
== 2; /* R_MSP430_ABS16. */
13924 /* Fall through. */
13925 case EM_MSP430_OLD
:
13926 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13928 return reloc_type
== 19; /* R_NDS32_RELA. */
13929 case EM_ALTERA_NIOS2
:
13930 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13932 return reloc_type
== 9; /* R_NIOS_16. */
13934 return reloc_type
== 2; /* R_OR1K_16. */
13936 return reloc_type
== 55; /* R_RISCV_SET16. */
13938 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13940 return reloc_type
== 2; /* R_C6000_ABS16. */
13942 return reloc_type
== 2; /* R_VISIUM_16. */
13945 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13947 return reloc_type
== 3; /* R_XGATE_16. */
13949 return reloc_type
== 4; /* R_Z80_16. */
13955 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13956 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13959 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13961 switch (filedata
->file_header
.e_machine
)
13964 return reloc_type
== 54; /* R_RISCV_SET8. */
13966 return reloc_type
== 1; /* R_Z80_8. */
13972 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13973 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13976 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13978 switch (filedata
->file_header
.e_machine
)
13981 return reloc_type
== 53; /* R_RISCV_SET6. */
13987 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13988 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13991 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13993 /* Please keep this table alpha-sorted for ease of visual lookup. */
13994 switch (filedata
->file_header
.e_machine
)
13997 return reloc_type
== 35; /* R_RISCV_ADD32. */
14003 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14004 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
14007 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14009 /* Please keep this table alpha-sorted for ease of visual lookup. */
14010 switch (filedata
->file_header
.e_machine
)
14013 return reloc_type
== 39; /* R_RISCV_SUB32. */
14019 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14020 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
14023 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14025 /* Please keep this table alpha-sorted for ease of visual lookup. */
14026 switch (filedata
->file_header
.e_machine
)
14029 return reloc_type
== 36; /* R_RISCV_ADD64. */
14035 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14036 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
14039 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14041 /* Please keep this table alpha-sorted for ease of visual lookup. */
14042 switch (filedata
->file_header
.e_machine
)
14045 return reloc_type
== 40; /* R_RISCV_SUB64. */
14051 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14052 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
14055 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14057 /* Please keep this table alpha-sorted for ease of visual lookup. */
14058 switch (filedata
->file_header
.e_machine
)
14061 return reloc_type
== 34; /* R_RISCV_ADD16. */
14067 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14068 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
14071 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14073 /* Please keep this table alpha-sorted for ease of visual lookup. */
14074 switch (filedata
->file_header
.e_machine
)
14077 return reloc_type
== 38; /* R_RISCV_SUB16. */
14083 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14084 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
14087 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14089 /* Please keep this table alpha-sorted for ease of visual lookup. */
14090 switch (filedata
->file_header
.e_machine
)
14093 return reloc_type
== 33; /* R_RISCV_ADD8. */
14099 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14100 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
14103 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14105 /* Please keep this table alpha-sorted for ease of visual lookup. */
14106 switch (filedata
->file_header
.e_machine
)
14109 return reloc_type
== 37; /* R_RISCV_SUB8. */
14115 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14116 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
14119 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14121 switch (filedata
->file_header
.e_machine
)
14124 return reloc_type
== 52; /* R_RISCV_SUB6. */
14130 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
14131 relocation entries (possibly formerly used for SHT_GROUP sections). */
14134 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14136 switch (filedata
->file_header
.e_machine
)
14138 case EM_386
: /* R_386_NONE. */
14139 case EM_68K
: /* R_68K_NONE. */
14140 case EM_ADAPTEVA_EPIPHANY
:
14141 case EM_ALPHA
: /* R_ALPHA_NONE. */
14142 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
14143 case EM_ARC
: /* R_ARC_NONE. */
14144 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
14145 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
14146 case EM_ARM
: /* R_ARM_NONE. */
14147 case EM_C166
: /* R_XC16X_NONE. */
14148 case EM_CRIS
: /* R_CRIS_NONE. */
14149 case EM_FT32
: /* R_FT32_NONE. */
14150 case EM_IA_64
: /* R_IA64_NONE. */
14151 case EM_K1OM
: /* R_X86_64_NONE. */
14152 case EM_L1OM
: /* R_X86_64_NONE. */
14153 case EM_M32R
: /* R_M32R_NONE. */
14154 case EM_MIPS
: /* R_MIPS_NONE. */
14155 case EM_MN10300
: /* R_MN10300_NONE. */
14156 case EM_MOXIE
: /* R_MOXIE_NONE. */
14157 case EM_NIOS32
: /* R_NIOS_NONE. */
14158 case EM_OR1K
: /* R_OR1K_NONE. */
14159 case EM_PARISC
: /* R_PARISC_NONE. */
14160 case EM_PPC64
: /* R_PPC64_NONE. */
14161 case EM_PPC
: /* R_PPC_NONE. */
14162 case EM_RISCV
: /* R_RISCV_NONE. */
14163 case EM_S390
: /* R_390_NONE. */
14165 case EM_SH
: /* R_SH_NONE. */
14166 case EM_SPARC32PLUS
:
14167 case EM_SPARC
: /* R_SPARC_NONE. */
14169 case EM_TILEGX
: /* R_TILEGX_NONE. */
14170 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
14171 case EM_TI_C6000
:/* R_C6000_NONE. */
14172 case EM_X86_64
: /* R_X86_64_NONE. */
14174 case EM_Z80
: /* R_Z80_NONE. */
14175 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
14176 return reloc_type
== 0;
14179 return reloc_type
== 0 || reloc_type
== 256;
14182 return (reloc_type
== 0 /* R_AVR_NONE. */
14183 || reloc_type
== 30 /* R_AVR_DIFF8. */
14184 || reloc_type
== 31 /* R_AVR_DIFF16. */
14185 || reloc_type
== 32 /* R_AVR_DIFF32. */);
14187 return reloc_type
== 3; /* R_METAG_NONE. */
14189 return (reloc_type
== 0 /* R_XTENSA_NONE. */
14190 || reloc_type
== 204 /* R_NDS32_DIFF8. */
14191 || reloc_type
== 205 /* R_NDS32_DIFF16. */
14192 || reloc_type
== 206 /* R_NDS32_DIFF32. */
14193 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
14195 return (reloc_type
== 0 /* R_PRU_NONE. */
14196 || reloc_type
== 65 /* R_PRU_DIFF8. */
14197 || reloc_type
== 66 /* R_PRU_DIFF16. */
14198 || reloc_type
== 67 /* R_PRU_DIFF32. */);
14199 case EM_XTENSA_OLD
:
14201 return (reloc_type
== 0 /* R_XTENSA_NONE. */
14202 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
14203 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
14204 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
14205 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
14206 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
14207 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
14208 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
14209 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
14210 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
14215 /* Returns TRUE if there is a relocation against
14216 section NAME at OFFSET bytes. */
14219 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
14221 Elf_Internal_Rela
* relocs
;
14222 Elf_Internal_Rela
* rp
;
14224 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
14227 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
14229 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
14230 if (rp
->r_offset
== offset
)
14236 /* Apply relocations to a section.
14237 Returns TRUE upon success, FALSE otherwise.
14238 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
14239 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
14240 will be set to the number of relocs loaded.
14242 Note: So far support has been added only for those relocations
14243 which can be found in debug sections. FIXME: Add support for
14244 more relocations ? */
14247 apply_relocations (Filedata
* filedata
,
14248 const Elf_Internal_Shdr
* section
,
14249 unsigned char * start
,
14250 bfd_size_type size
,
14251 void ** relocs_return
,
14252 unsigned long * num_relocs_return
)
14254 Elf_Internal_Shdr
* relsec
;
14255 unsigned char * end
= start
+ size
;
14257 if (relocs_return
!= NULL
)
14259 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
14260 * num_relocs_return
= 0;
14263 if (filedata
->file_header
.e_type
!= ET_REL
)
14264 /* No relocs to apply. */
14267 /* Find the reloc section associated with the section. */
14268 for (relsec
= filedata
->section_headers
;
14269 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14273 unsigned long num_relocs
;
14274 Elf_Internal_Rela
* relocs
;
14275 Elf_Internal_Rela
* rp
;
14276 Elf_Internal_Shdr
* symsec
;
14277 Elf_Internal_Sym
* symtab
;
14278 unsigned long num_syms
;
14279 Elf_Internal_Sym
* sym
;
14281 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14282 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14283 || filedata
->section_headers
+ relsec
->sh_info
!= section
14284 || relsec
->sh_size
== 0
14285 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14288 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
14289 if (symsec
->sh_type
!= SHT_SYMTAB
14290 && symsec
->sh_type
!= SHT_DYNSYM
)
14293 is_rela
= relsec
->sh_type
== SHT_RELA
;
14297 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
14298 relsec
->sh_size
, & relocs
, & num_relocs
))
14303 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
14304 relsec
->sh_size
, & relocs
, & num_relocs
))
14308 /* SH uses RELA but uses in place value instead of the addend field. */
14309 if (filedata
->file_header
.e_machine
== EM_SH
)
14312 symtab
= get_elf_symbols (filedata
, symsec
, & num_syms
);
14314 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
14317 unsigned int reloc_type
;
14318 unsigned int reloc_size
;
14319 bool reloc_inplace
= false;
14320 bool reloc_subtract
= false;
14321 unsigned char *rloc
;
14322 unsigned long sym_index
;
14324 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
14326 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
14328 else if (is_none_reloc (filedata
, reloc_type
))
14330 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
14331 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
14333 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
14334 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
14336 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
14338 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
14340 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
14341 || is_6bit_abs_reloc (filedata
, reloc_type
))
14343 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
14345 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
14348 reloc_inplace
= true;
14350 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
14352 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
14355 reloc_inplace
= true;
14357 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
14359 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
14362 reloc_inplace
= true;
14364 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
14366 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
14369 reloc_inplace
= true;
14371 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
14375 reloc_inplace
= true;
14379 static unsigned int prev_reloc
= 0;
14381 if (reloc_type
!= prev_reloc
)
14382 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
14383 reloc_type
, printable_section_name (filedata
, section
));
14384 prev_reloc
= reloc_type
;
14388 rloc
= start
+ rp
->r_offset
;
14389 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
14391 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
14392 (unsigned long) rp
->r_offset
,
14393 printable_section_name (filedata
, section
));
14397 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
14398 if (sym_index
>= num_syms
)
14400 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
14401 sym_index
, printable_section_name (filedata
, section
));
14404 sym
= symtab
+ sym_index
;
14406 /* If the reloc has a symbol associated with it,
14407 make sure that it is of an appropriate type.
14409 Relocations against symbols without type can happen.
14410 Gcc -feliminate-dwarf2-dups may generate symbols
14411 without type for debug info.
14413 Icc generates relocations against function symbols
14414 instead of local labels.
14416 Relocations against object symbols can happen, eg when
14417 referencing a global array. For an example of this see
14418 the _clz.o binary in libgcc.a. */
14420 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
14421 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
14423 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
14424 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
14425 printable_section_name (filedata
, relsec
),
14426 (long int)(rp
- relocs
));
14432 addend
+= rp
->r_addend
;
14433 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
14434 partial_inplace. */
14436 || (filedata
->file_header
.e_machine
== EM_XTENSA
14437 && reloc_type
== 1)
14438 || ((filedata
->file_header
.e_machine
== EM_PJ
14439 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
14440 && reloc_type
== 1)
14441 || ((filedata
->file_header
.e_machine
== EM_D30V
14442 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
14443 && reloc_type
== 12)
14446 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
14447 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
14449 addend
+= byte_get (rloc
, reloc_size
);
14452 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
14453 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
14455 /* On HPPA, all pc-relative relocations are biased by 8. */
14456 if (filedata
->file_header
.e_machine
== EM_PARISC
)
14458 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
14461 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
14462 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
14464 if (reloc_subtract
)
14465 addend
-= sym
->st_value
;
14467 addend
+= sym
->st_value
;
14468 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
14469 byte_put (rloc
, addend
, reloc_size
);
14471 else if (reloc_subtract
)
14472 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
14474 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
14478 /* Let the target specific reloc processing code know that
14479 we have finished with these relocs. */
14480 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
14484 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
14485 * num_relocs_return
= num_relocs
;
14496 #ifdef SUPPORT_DISASSEMBLY
14498 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14500 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
14502 /* FIXME: XXX -- to be done --- XXX */
14508 /* Reads in the contents of SECTION from FILE, returning a pointer
14509 to a malloc'ed buffer or NULL if something went wrong. */
14512 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14514 bfd_size_type num_bytes
= section
->sh_size
;
14516 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
14518 printf (_("Section '%s' has no data to dump.\n"),
14519 printable_section_name (filedata
, section
));
14523 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
14524 _("section contents"));
14527 /* Uncompresses a section that was compressed using zlib, in place. */
14530 uncompress_section_contents (unsigned char ** buffer
,
14531 dwarf_size_type uncompressed_size
,
14532 dwarf_size_type
* size
)
14534 dwarf_size_type compressed_size
= *size
;
14535 unsigned char * compressed_buffer
= *buffer
;
14536 unsigned char * uncompressed_buffer
;
14540 /* It is possible the section consists of several compressed
14541 buffers concatenated together, so we uncompress in a loop. */
14542 /* PR 18313: The state field in the z_stream structure is supposed
14543 to be invisible to the user (ie us), but some compilers will
14544 still complain about it being used without initialisation. So
14545 we first zero the entire z_stream structure and then set the fields
14547 memset (& strm
, 0, sizeof strm
);
14548 strm
.avail_in
= compressed_size
;
14549 strm
.next_in
= (Bytef
*) compressed_buffer
;
14550 strm
.avail_out
= uncompressed_size
;
14551 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
14553 rc
= inflateInit (& strm
);
14554 while (strm
.avail_in
> 0)
14558 strm
.next_out
= ((Bytef
*) uncompressed_buffer
14559 + (uncompressed_size
- strm
.avail_out
));
14560 rc
= inflate (&strm
, Z_FINISH
);
14561 if (rc
!= Z_STREAM_END
)
14563 rc
= inflateReset (& strm
);
14565 if (inflateEnd (& strm
) != Z_OK
14567 || strm
.avail_out
!= 0)
14570 *buffer
= uncompressed_buffer
;
14571 *size
= uncompressed_size
;
14575 free (uncompressed_buffer
);
14576 /* Indicate decompression failure. */
14582 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14584 Elf_Internal_Shdr
*relsec
;
14585 bfd_size_type num_bytes
;
14586 unsigned char *data
;
14587 unsigned char *end
;
14588 unsigned char *real_start
;
14589 unsigned char *start
;
14590 bool some_strings_shown
;
14592 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
14594 /* PR 21820: Do not fail if the section was empty. */
14595 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
14597 num_bytes
= section
->sh_size
;
14599 if (filedata
->is_separate
)
14600 printf (_("\nString dump of section '%s' in linked file %s:\n"),
14601 printable_section_name (filedata
, section
),
14602 filedata
->file_name
);
14604 printf (_("\nString dump of section '%s':\n"),
14605 printable_section_name (filedata
, section
));
14607 if (decompress_dumps
)
14609 dwarf_size_type new_size
= num_bytes
;
14610 dwarf_size_type uncompressed_size
= 0;
14612 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14614 Elf_Internal_Chdr chdr
;
14615 unsigned int compression_header_size
14616 = get_compression_header (& chdr
, (unsigned char *) start
,
14618 if (compression_header_size
== 0)
14619 /* An error message will have already been generated
14620 by get_compression_header. */
14623 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14625 warn (_("section '%s' has unsupported compress type: %d\n"),
14626 printable_section_name (filedata
, section
), chdr
.ch_type
);
14629 uncompressed_size
= chdr
.ch_size
;
14630 start
+= compression_header_size
;
14631 new_size
-= compression_header_size
;
14633 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14635 /* Read the zlib header. In this case, it should be "ZLIB"
14636 followed by the uncompressed section size, 8 bytes in
14637 big-endian order. */
14638 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14639 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14640 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14641 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14642 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14643 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14644 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14645 uncompressed_size
+= start
[11];
14650 if (uncompressed_size
)
14652 if (uncompress_section_contents (& start
,
14653 uncompressed_size
, & new_size
))
14654 num_bytes
= new_size
;
14657 error (_("Unable to decompress section %s\n"),
14658 printable_section_name (filedata
, section
));
14663 start
= real_start
;
14666 /* If the section being dumped has relocations against it the user might
14667 be expecting these relocations to have been applied. Check for this
14668 case and issue a warning message in order to avoid confusion.
14669 FIXME: Maybe we ought to have an option that dumps a section with
14670 relocs applied ? */
14671 for (relsec
= filedata
->section_headers
;
14672 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14675 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14676 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14677 || filedata
->section_headers
+ relsec
->sh_info
!= section
14678 || relsec
->sh_size
== 0
14679 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14682 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14687 end
= start
+ num_bytes
;
14688 some_strings_shown
= false;
14690 #ifdef HAVE_MBSTATE_T
14692 /* Initialise the multibyte conversion state. */
14693 memset (& state
, 0, sizeof (state
));
14696 bool continuing
= false;
14700 while (!ISPRINT (* data
))
14701 if (++ data
>= end
)
14706 size_t maxlen
= end
- data
;
14711 continuing
= false;
14715 printf (" [%6lx] ", (unsigned long) (data
- start
));
14729 /* PR 25543: Treat new-lines as string-ending characters. */
14738 /* Do not print control characters directly as they can affect terminal
14739 settings. Such characters usually appear in the names generated
14740 by the assembler for local labels. */
14743 printf ("^%c", c
+ 0x40);
14745 else if (ISPRINT (c
))
14752 #ifdef HAVE_MBSTATE_T
14755 /* Let printf do the hard work of displaying multibyte characters. */
14756 printf ("%.1s", data
- 1);
14757 #ifdef HAVE_MBSTATE_T
14758 /* Try to find out how many bytes made up the character that was
14759 just printed. Advance the symbol pointer past the bytes that
14761 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
14765 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
14775 printf (_("<corrupt>\n"));
14778 some_strings_shown
= true;
14782 if (! some_strings_shown
)
14783 printf (_(" No strings found in this section."));
14796 dump_section_as_bytes (Elf_Internal_Shdr
*section
,
14797 Filedata
*filedata
,
14800 Elf_Internal_Shdr
* relsec
;
14801 bfd_size_type bytes
;
14802 bfd_size_type section_size
;
14804 unsigned char * data
;
14805 unsigned char * real_start
;
14806 unsigned char * start
;
14808 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
14810 /* PR 21820: Do not fail if the section was empty. */
14811 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
14813 section_size
= section
->sh_size
;
14815 if (filedata
->is_separate
)
14816 printf (_("\nHex dump of section '%s' in linked file %s:\n"),
14817 printable_section_name (filedata
, section
),
14818 filedata
->file_name
);
14820 printf (_("\nHex dump of section '%s':\n"),
14821 printable_section_name (filedata
, section
));
14823 if (decompress_dumps
)
14825 dwarf_size_type new_size
= section_size
;
14826 dwarf_size_type uncompressed_size
= 0;
14828 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14830 Elf_Internal_Chdr chdr
;
14831 unsigned int compression_header_size
14832 = get_compression_header (& chdr
, start
, section_size
);
14834 if (compression_header_size
== 0)
14835 /* An error message will have already been generated
14836 by get_compression_header. */
14839 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14841 warn (_("section '%s' has unsupported compress type: %d\n"),
14842 printable_section_name (filedata
, section
), chdr
.ch_type
);
14845 uncompressed_size
= chdr
.ch_size
;
14846 start
+= compression_header_size
;
14847 new_size
-= compression_header_size
;
14849 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14851 /* Read the zlib header. In this case, it should be "ZLIB"
14852 followed by the uncompressed section size, 8 bytes in
14853 big-endian order. */
14854 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14855 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14856 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14857 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14858 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14859 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14860 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14861 uncompressed_size
+= start
[11];
14866 if (uncompressed_size
)
14868 if (uncompress_section_contents (& start
, uncompressed_size
,
14871 section_size
= new_size
;
14875 error (_("Unable to decompress section %s\n"),
14876 printable_section_name (filedata
, section
));
14877 /* FIXME: Print the section anyway ? */
14882 start
= real_start
;
14887 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
14892 /* If the section being dumped has relocations against it the user might
14893 be expecting these relocations to have been applied. Check for this
14894 case and issue a warning message in order to avoid confusion.
14895 FIXME: Maybe we ought to have an option that dumps a section with
14896 relocs applied ? */
14897 for (relsec
= filedata
->section_headers
;
14898 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14901 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14902 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14903 || filedata
->section_headers
+ relsec
->sh_info
!= section
14904 || relsec
->sh_size
== 0
14905 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14908 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14913 addr
= section
->sh_addr
;
14914 bytes
= section_size
;
14923 lbytes
= (bytes
> 16 ? 16 : bytes
);
14925 printf (" 0x%8.8lx ", (unsigned long) addr
);
14927 for (j
= 0; j
< 16; j
++)
14930 printf ("%2.2x", data
[j
]);
14938 for (j
= 0; j
< lbytes
; j
++)
14941 if (k
>= ' ' && k
< 0x7f)
14964 #ifdef ENABLE_LIBCTF
14965 static ctf_sect_t
*
14966 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14968 buf
->cts_name
= SECTION_NAME_PRINT (shdr
);
14969 buf
->cts_size
= shdr
->sh_size
;
14970 buf
->cts_entsize
= shdr
->sh_entsize
;
14975 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14976 it is passed, or a pointer to newly-allocated storage, in which case
14977 dump_ctf() will free it when it no longer needs it. */
14980 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14981 char *s
, void *arg
)
14983 const char *blanks
= arg
;
14986 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14991 /* Dump CTF errors/warnings. */
14993 dump_ctf_errs (ctf_dict_t
*fp
)
14995 ctf_next_t
*it
= NULL
;
15000 /* Dump accumulated errors and warnings. */
15001 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
15003 error (_("%s: %s"), is_warning
? _("warning"): _("error"),
15007 if (err
!= ECTF_NEXT_END
)
15008 error (_("CTF error: cannot get CTF errors: `%s'"), ctf_errmsg (err
));
15011 /* Dump one CTF archive member. */
15014 dump_ctf_archive_member (ctf_dict_t
*ctf
, const char *name
, void *arg
)
15016 ctf_dict_t
*parent
= (ctf_dict_t
*) arg
;
15017 const char *things
[] = {"Header", "Labels", "Data objects",
15018 "Function objects", "Variables", "Types", "Strings",
15020 const char **thing
;
15024 /* Only print out the name of non-default-named archive members.
15025 The name .ctf appears everywhere, even for things that aren't
15026 really archives, so printing it out is liable to be confusing.
15028 The parent, if there is one, is the default-owned archive member:
15029 avoid importing it into itself. (This does no harm, but looks
15032 if (strcmp (name
, ".ctf") != 0)
15034 printf (_("\nCTF archive member: %s:\n"), name
);
15035 ctf_import (ctf
, parent
);
15038 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
15040 ctf_dump_state_t
*s
= NULL
;
15043 printf ("\n %s:\n", *thing
);
15044 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
15045 (void *) " ")) != NULL
)
15047 printf ("%s\n", item
);
15051 if (ctf_errno (ctf
))
15053 error (_("Iteration failed: %s, %s\n"), *thing
,
15054 ctf_errmsg (ctf_errno (ctf
)));
15061 dump_ctf_errs (ctf
);
15066 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15068 Elf_Internal_Shdr
* parent_sec
= NULL
;
15069 Elf_Internal_Shdr
* symtab_sec
= NULL
;
15070 Elf_Internal_Shdr
* strtab_sec
= NULL
;
15071 void * data
= NULL
;
15072 void * symdata
= NULL
;
15073 void * strdata
= NULL
;
15074 void * parentdata
= NULL
;
15075 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
15076 ctf_sect_t
* symsectp
= NULL
;
15077 ctf_sect_t
* strsectp
= NULL
;
15078 ctf_archive_t
* ctfa
= NULL
;
15079 ctf_archive_t
* parenta
= NULL
, *lookparent
;
15080 ctf_dict_t
* parent
= NULL
;
15085 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
15086 data
= get_section_contents (section
, filedata
);
15087 ctfsect
.cts_data
= data
;
15089 if (!dump_ctf_symtab_name
)
15090 dump_ctf_symtab_name
= strdup (".dynsym");
15092 if (!dump_ctf_strtab_name
)
15093 dump_ctf_strtab_name
= strdup (".dynstr");
15095 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
15097 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
15099 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
15102 if ((symdata
= (void *) get_data (NULL
, filedata
,
15103 symtab_sec
->sh_offset
, 1,
15104 symtab_sec
->sh_size
,
15105 _("symbols"))) == NULL
)
15107 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
15108 symsect
.cts_data
= symdata
;
15111 if (dump_ctf_strtab_name
&& dump_ctf_strtab_name
[0] != 0)
15113 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
15115 error (_("No string table section named %s\n"),
15116 dump_ctf_strtab_name
);
15119 if ((strdata
= (void *) get_data (NULL
, filedata
,
15120 strtab_sec
->sh_offset
, 1,
15121 strtab_sec
->sh_size
,
15122 _("strings"))) == NULL
)
15124 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
15125 strsect
.cts_data
= strdata
;
15128 if (dump_ctf_parent_name
)
15130 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
15132 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
15135 if ((parentdata
= (void *) get_data (NULL
, filedata
,
15136 parent_sec
->sh_offset
, 1,
15137 parent_sec
->sh_size
,
15138 _("CTF parent"))) == NULL
)
15140 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
15141 parentsect
.cts_data
= parentdata
;
15144 /* Load the CTF file and dump it. It may be a raw CTF section, or an archive:
15145 libctf papers over the difference, so we can pretend it is always an
15146 archive. Possibly open the parent as well, if one was specified. */
15148 if ((ctfa
= ctf_arc_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
15150 dump_ctf_errs (NULL
);
15151 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15155 ctf_arc_symsect_endianness (ctfa
, filedata
->file_header
.e_ident
[EI_DATA
]
15160 if ((parenta
= ctf_arc_bufopen (&parentsect
, symsectp
, strsectp
,
15163 dump_ctf_errs (NULL
);
15164 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15167 lookparent
= parenta
;
15172 /* Assume that the applicable parent archive member is the default one.
15173 (This is what all known implementations are expected to do, if they
15174 put CTFs and their parents in archives together.) */
15175 if ((parent
= ctf_dict_open (lookparent
, NULL
, &err
)) == NULL
)
15177 dump_ctf_errs (NULL
);
15178 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15184 if (filedata
->is_separate
)
15185 printf (_("\nDump of CTF section '%s' in linked file %s:\n"),
15186 printable_section_name (filedata
, section
),
15187 filedata
->file_name
);
15189 printf (_("\nDump of CTF section '%s':\n"),
15190 printable_section_name (filedata
, section
));
15192 if ((err
= ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
)) != 0)
15194 dump_ctf_errs (NULL
);
15195 error (_("CTF member open failure: %s\n"), ctf_errmsg (err
));
15200 ctf_dict_close (parent
);
15202 ctf_close (parenta
);
15212 load_specific_debug_section (enum dwarf_section_display_enum debug
,
15213 const Elf_Internal_Shdr
* sec
,
15216 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15218 Filedata
* filedata
= (Filedata
*) data
;
15220 if (section
->start
!= NULL
)
15222 /* If it is already loaded, do nothing. */
15223 if (streq (section
->filename
, filedata
->file_name
))
15225 free (section
->start
);
15228 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
15229 section
->address
= sec
->sh_addr
;
15230 section
->filename
= filedata
->file_name
;
15231 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
15233 sec
->sh_size
, buf
);
15234 if (section
->start
== NULL
)
15238 unsigned char *start
= section
->start
;
15239 dwarf_size_type size
= sec
->sh_size
;
15240 dwarf_size_type uncompressed_size
= 0;
15242 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
15244 Elf_Internal_Chdr chdr
;
15245 unsigned int compression_header_size
;
15247 if (size
< (is_32bit_elf
15248 ? sizeof (Elf32_External_Chdr
)
15249 : sizeof (Elf64_External_Chdr
)))
15251 warn (_("compressed section %s is too small to contain a compression header\n"),
15256 compression_header_size
= get_compression_header (&chdr
, start
, size
);
15257 if (compression_header_size
== 0)
15258 /* An error message will have already been generated
15259 by get_compression_header. */
15262 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
15264 warn (_("section '%s' has unsupported compress type: %d\n"),
15265 section
->name
, chdr
.ch_type
);
15268 uncompressed_size
= chdr
.ch_size
;
15269 start
+= compression_header_size
;
15270 size
-= compression_header_size
;
15272 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
15274 /* Read the zlib header. In this case, it should be "ZLIB"
15275 followed by the uncompressed section size, 8 bytes in
15276 big-endian order. */
15277 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
15278 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
15279 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
15280 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
15281 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
15282 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
15283 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
15284 uncompressed_size
+= start
[11];
15289 if (uncompressed_size
)
15291 if (uncompress_section_contents (&start
, uncompressed_size
,
15294 /* Free the compressed buffer, update the section buffer
15295 and the section size if uncompress is successful. */
15296 free (section
->start
);
15297 section
->start
= start
;
15301 error (_("Unable to decompress section %s\n"),
15302 printable_section_name (filedata
, sec
));
15307 section
->size
= size
;
15310 if (section
->start
== NULL
)
15313 if (debug_displays
[debug
].relocate
)
15315 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
15316 & section
->reloc_info
, & section
->num_relocs
))
15321 section
->reloc_info
= NULL
;
15322 section
->num_relocs
= 0;
15328 #if HAVE_LIBDEBUGINFOD
15329 /* Return a hex string representation of the build-id. */
15331 get_build_id (void * data
)
15333 Filedata
* filedata
= (Filedata
*) data
;
15334 Elf_Internal_Shdr
* shdr
;
15337 /* Iterate through notes to find note.gnu.build-id.
15338 FIXME: Only the first note in any note section is examined. */
15339 for (i
= 0, shdr
= filedata
->section_headers
;
15340 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
15343 if (shdr
->sh_type
!= SHT_NOTE
)
15348 size_t data_remaining
;
15350 Elf_External_Note
* enote
;
15351 Elf_Internal_Note inote
;
15353 bfd_vma offset
= shdr
->sh_offset
;
15354 bfd_vma align
= shdr
->sh_addralign
;
15355 bfd_vma length
= shdr
->sh_size
;
15357 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
15363 else if (align
!= 4 && align
!= 8)
15369 end
= (char *) enote
+ length
;
15370 data_remaining
= end
- (char *) enote
;
15372 if (!is_ia64_vms (filedata
))
15374 min_notesz
= offsetof (Elf_External_Note
, name
);
15375 if (data_remaining
< min_notesz
)
15378 malformed note encountered in section %s whilst scanning for build-id note\n"),
15379 printable_section_name (filedata
, shdr
));
15383 data_remaining
-= min_notesz
;
15385 inote
.type
= BYTE_GET (enote
->type
);
15386 inote
.namesz
= BYTE_GET (enote
->namesz
);
15387 inote
.namedata
= enote
->name
;
15388 inote
.descsz
= BYTE_GET (enote
->descsz
);
15389 inote
.descdata
= ((char *) enote
15390 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
15391 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
15392 next
= ((char *) enote
15393 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
15397 Elf64_External_VMS_Note
*vms_enote
;
15399 /* PR binutils/15191
15400 Make sure that there is enough data to read. */
15401 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
15402 if (data_remaining
< min_notesz
)
15405 malformed note encountered in section %s whilst scanning for build-id note\n"),
15406 printable_section_name (filedata
, shdr
));
15410 data_remaining
-= min_notesz
;
15412 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
15413 inote
.type
= BYTE_GET (vms_enote
->type
);
15414 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
15415 inote
.namedata
= vms_enote
->name
;
15416 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
15417 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
15418 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
15419 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
15422 /* Skip malformed notes. */
15423 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
15424 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
15425 || (size_t) (next
- inote
.descdata
) < inote
.descsz
15426 || ((size_t) (next
- inote
.descdata
)
15427 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
15430 malformed note encountered in section %s whilst scanning for build-id note\n"),
15431 printable_section_name (filedata
, shdr
));
15436 /* Check if this is the build-id note. If so then convert the build-id
15437 bytes to a hex string. */
15438 if (inote
.namesz
> 0
15439 && startswith (inote
.namedata
, "GNU")
15440 && inote
.type
== NT_GNU_BUILD_ID
)
15445 build_id
= malloc (inote
.descsz
* 2 + 1);
15446 if (build_id
== NULL
)
15452 for (j
= 0; j
< inote
.descsz
; ++j
)
15453 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
15454 build_id
[inote
.descsz
* 2] = '\0';
15457 return (unsigned char *) build_id
;
15464 #endif /* HAVE_LIBDEBUGINFOD */
15466 /* If this is not NULL, load_debug_section will only look for sections
15467 within the list of sections given here. */
15468 static unsigned int * section_subset
= NULL
;
15471 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
15473 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15474 Elf_Internal_Shdr
* sec
;
15475 Filedata
* filedata
= (Filedata
*) data
;
15477 /* Without section headers we cannot find any sections. */
15478 if (filedata
->section_headers
== NULL
)
15481 if (filedata
->string_table
== NULL
15482 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
15483 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
15485 Elf_Internal_Shdr
* strs
;
15487 /* Read in the string table, so that we have section names to scan. */
15488 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
15490 if (strs
!= NULL
&& strs
->sh_size
!= 0)
15492 filedata
->string_table
15493 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
15494 1, strs
->sh_size
, _("string table"));
15496 filedata
->string_table_length
15497 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
15501 /* Locate the debug section. */
15502 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
15504 section
->name
= section
->uncompressed_name
;
15507 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
15509 section
->name
= section
->compressed_name
;
15514 /* If we're loading from a subset of sections, and we've loaded
15515 a section matching this name before, it's likely that it's a
15517 if (section_subset
!= NULL
)
15518 free_debug_section (debug
);
15520 return load_specific_debug_section (debug
, sec
, data
);
15524 free_debug_section (enum dwarf_section_display_enum debug
)
15526 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15528 if (section
->start
== NULL
)
15531 free ((char *) section
->start
);
15532 section
->start
= NULL
;
15533 section
->address
= 0;
15536 free (section
->reloc_info
);
15537 section
->reloc_info
= NULL
;
15538 section
->num_relocs
= 0;
15542 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15544 char * name
= SECTION_NAME_VALID (section
) ? SECTION_NAME (section
) : "";
15545 const char * print_name
= printable_section_name (filedata
, section
);
15546 bfd_size_type length
;
15547 bool result
= true;
15550 length
= section
->sh_size
;
15553 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
15556 if (section
->sh_type
== SHT_NOBITS
)
15558 /* There is no point in dumping the contents of a debugging section
15559 which has the NOBITS type - the bits in the file will be random.
15560 This can happen when a file containing a .eh_frame section is
15561 stripped with the --only-keep-debug command line option. */
15562 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
15567 if (startswith (name
, ".gnu.linkonce.wi."))
15568 name
= ".debug_info";
15570 /* See if we know how to display the contents of this section. */
15571 for (i
= 0; i
< max
; i
++)
15573 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
15574 struct dwarf_section_display
* display
= debug_displays
+ i
;
15575 struct dwarf_section
* sec
= & display
->section
;
15577 if (streq (sec
->uncompressed_name
, name
)
15578 || (id
== line
&& startswith (name
, ".debug_line."))
15579 || streq (sec
->compressed_name
, name
))
15581 bool secondary
= (section
!= find_section (filedata
, name
));
15584 free_debug_section (id
);
15586 if (i
== line
&& startswith (name
, ".debug_line."))
15588 else if (streq (sec
->uncompressed_name
, name
))
15589 sec
->name
= sec
->uncompressed_name
;
15591 sec
->name
= sec
->compressed_name
;
15593 if (load_specific_debug_section (id
, section
, filedata
))
15595 /* If this debug section is part of a CU/TU set in a .dwp file,
15596 restrict load_debug_section to the sections in that set. */
15597 section_subset
= find_cu_tu_set (filedata
, shndx
);
15599 result
&= display
->display (sec
, filedata
);
15601 section_subset
= NULL
;
15603 if (secondary
|| (id
!= info
&& id
!= abbrev
&& id
!= debug_addr
))
15604 free_debug_section (id
);
15612 printf (_("Unrecognized debug section: %s\n"), print_name
);
15619 /* Set DUMP_SECTS for all sections where dumps were requested
15620 based on section name. */
15623 initialise_dumps_byname (Filedata
* filedata
)
15625 struct dump_list_entry
* cur
;
15627 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
15632 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
15633 if (SECTION_NAME_VALID (filedata
->section_headers
+ i
)
15634 && streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
15636 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
15640 if (!any
&& !filedata
->is_separate
)
15641 warn (_("Section '%s' was not dumped because it does not exist\n"),
15647 process_section_contents (Filedata
* filedata
)
15649 Elf_Internal_Shdr
* section
;
15656 initialise_dumps_byname (filedata
);
15658 for (i
= 0, section
= filedata
->section_headers
;
15659 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
15662 dump_type dump
= filedata
->dump
.dump_sects
[i
];
15664 if (filedata
->is_separate
&& ! process_links
)
15665 dump
&= DEBUG_DUMP
;
15667 #ifdef SUPPORT_DISASSEMBLY
15668 if (dump
& DISASS_DUMP
)
15670 if (! disassemble_section (section
, filedata
))
15674 if (dump
& HEX_DUMP
)
15676 if (! dump_section_as_bytes (section
, filedata
, false))
15680 if (dump
& RELOC_DUMP
)
15682 if (! dump_section_as_bytes (section
, filedata
, true))
15686 if (dump
& STRING_DUMP
)
15688 if (! dump_section_as_strings (section
, filedata
))
15692 if (dump
& DEBUG_DUMP
)
15694 if (! display_debug_section (i
, section
, filedata
))
15698 #ifdef ENABLE_LIBCTF
15699 if (dump
& CTF_DUMP
)
15701 if (! dump_section_as_ctf (section
, filedata
))
15707 if (! filedata
->is_separate
)
15709 /* Check to see if the user requested a
15710 dump of a section that does not exist. */
15711 for (; i
< filedata
->dump
.num_dump_sects
; i
++)
15712 if (filedata
->dump
.dump_sects
[i
])
15714 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
15723 process_mips_fpe_exception (int mask
)
15729 if (mask
& OEX_FPU_INEX
)
15730 fputs ("INEX", stdout
), first
= false;
15731 if (mask
& OEX_FPU_UFLO
)
15732 printf ("%sUFLO", first
? "" : "|"), first
= false;
15733 if (mask
& OEX_FPU_OFLO
)
15734 printf ("%sOFLO", first
? "" : "|"), first
= false;
15735 if (mask
& OEX_FPU_DIV0
)
15736 printf ("%sDIV0", first
? "" : "|"), first
= false;
15737 if (mask
& OEX_FPU_INVAL
)
15738 printf ("%sINVAL", first
? "" : "|");
15741 fputs ("0", stdout
);
15744 /* Display's the value of TAG at location P. If TAG is
15745 greater than 0 it is assumed to be an unknown tag, and
15746 a message is printed to this effect. Otherwise it is
15747 assumed that a message has already been printed.
15749 If the bottom bit of TAG is set it assumed to have a
15750 string value, otherwise it is assumed to have an integer
15753 Returns an updated P pointing to the first unread byte
15754 beyond the end of TAG's value.
15756 Reads at or beyond END will not be made. */
15758 static unsigned char *
15759 display_tag_value (signed int tag
,
15761 const unsigned char * const end
)
15766 printf (" Tag_unknown_%d: ", tag
);
15770 warn (_("<corrupt tag>\n"));
15774 /* PR 17531 file: 027-19978-0.004. */
15775 size_t maxlen
= (end
- p
) - 1;
15780 print_symbol ((int) maxlen
, (const char *) p
);
15781 p
+= strnlen ((char *) p
, maxlen
) + 1;
15785 printf (_("<corrupt string tag>"));
15786 p
= (unsigned char *) end
;
15792 READ_ULEB (val
, p
, end
);
15793 printf ("%ld (0x%lx)\n", val
, val
);
15800 /* ARC ABI attributes section. */
15802 static unsigned char *
15803 display_arc_attribute (unsigned char * p
,
15804 const unsigned char * const end
)
15809 READ_ULEB (tag
, p
, end
);
15813 case Tag_ARC_PCS_config
:
15814 READ_ULEB (val
, p
, end
);
15815 printf (" Tag_ARC_PCS_config: ");
15819 printf (_("Absent/Non standard\n"));
15822 printf (_("Bare metal/mwdt\n"));
15825 printf (_("Bare metal/newlib\n"));
15828 printf (_("Linux/uclibc\n"));
15831 printf (_("Linux/glibc\n"));
15834 printf (_("Unknown\n"));
15839 case Tag_ARC_CPU_base
:
15840 READ_ULEB (val
, p
, end
);
15841 printf (" Tag_ARC_CPU_base: ");
15846 printf (_("Absent\n"));
15848 case TAG_CPU_ARC6xx
:
15849 printf ("ARC6xx\n");
15851 case TAG_CPU_ARC7xx
:
15852 printf ("ARC7xx\n");
15854 case TAG_CPU_ARCEM
:
15855 printf ("ARCEM\n");
15857 case TAG_CPU_ARCHS
:
15858 printf ("ARCHS\n");
15863 case Tag_ARC_CPU_variation
:
15864 READ_ULEB (val
, p
, end
);
15865 printf (" Tag_ARC_CPU_variation: ");
15869 if (val
> 0 && val
< 16)
15870 printf ("Core%d\n", val
);
15872 printf ("Unknown\n");
15876 printf (_("Absent\n"));
15881 case Tag_ARC_CPU_name
:
15882 printf (" Tag_ARC_CPU_name: ");
15883 p
= display_tag_value (-1, p
, end
);
15886 case Tag_ARC_ABI_rf16
:
15887 READ_ULEB (val
, p
, end
);
15888 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
15891 case Tag_ARC_ABI_osver
:
15892 READ_ULEB (val
, p
, end
);
15893 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
15896 case Tag_ARC_ABI_pic
:
15897 case Tag_ARC_ABI_sda
:
15898 READ_ULEB (val
, p
, end
);
15899 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
15900 : " Tag_ARC_ABI_pic: ");
15904 printf (_("Absent\n"));
15913 printf (_("Unknown\n"));
15918 case Tag_ARC_ABI_tls
:
15919 READ_ULEB (val
, p
, end
);
15920 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
15923 case Tag_ARC_ABI_enumsize
:
15924 READ_ULEB (val
, p
, end
);
15925 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
15929 case Tag_ARC_ABI_exceptions
:
15930 READ_ULEB (val
, p
, end
);
15931 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
15935 case Tag_ARC_ABI_double_size
:
15936 READ_ULEB (val
, p
, end
);
15937 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
15940 case Tag_ARC_ISA_config
:
15941 printf (" Tag_ARC_ISA_config: ");
15942 p
= display_tag_value (-1, p
, end
);
15945 case Tag_ARC_ISA_apex
:
15946 printf (" Tag_ARC_ISA_apex: ");
15947 p
= display_tag_value (-1, p
, end
);
15950 case Tag_ARC_ISA_mpy_option
:
15951 READ_ULEB (val
, p
, end
);
15952 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
15955 case Tag_ARC_ATR_version
:
15956 READ_ULEB (val
, p
, end
);
15957 printf (" Tag_ARC_ATR_version: %d\n", val
);
15961 return display_tag_value (tag
& 1, p
, end
);
15967 /* ARM EABI attributes section. */
15972 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
15974 const char *const *table
;
15975 } arm_attr_public_tag
;
15977 static const char *const arm_attr_tag_CPU_arch
[] =
15978 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
15979 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
15980 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
15981 static const char *const arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
15982 static const char *const arm_attr_tag_THUMB_ISA_use
[] =
15983 {"No", "Thumb-1", "Thumb-2", "Yes"};
15984 static const char *const arm_attr_tag_FP_arch
[] =
15985 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
15986 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
15987 static const char *const arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
15988 static const char *const arm_attr_tag_Advanced_SIMD_arch
[] =
15989 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
15990 "NEON for ARMv8.1"};
15991 static const char *const arm_attr_tag_PCS_config
[] =
15992 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
15993 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
15994 static const char *const arm_attr_tag_ABI_PCS_R9_use
[] =
15995 {"V6", "SB", "TLS", "Unused"};
15996 static const char *const arm_attr_tag_ABI_PCS_RW_data
[] =
15997 {"Absolute", "PC-relative", "SB-relative", "None"};
15998 static const char *const arm_attr_tag_ABI_PCS_RO_data
[] =
15999 {"Absolute", "PC-relative", "None"};
16000 static const char *const arm_attr_tag_ABI_PCS_GOT_use
[] =
16001 {"None", "direct", "GOT-indirect"};
16002 static const char *const arm_attr_tag_ABI_PCS_wchar_t
[] =
16003 {"None", "??? 1", "2", "??? 3", "4"};
16004 static const char *const arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
16005 static const char *const arm_attr_tag_ABI_FP_denormal
[] =
16006 {"Unused", "Needed", "Sign only"};
16007 static const char *const arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
16008 static const char *const arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
16009 static const char *const arm_attr_tag_ABI_FP_number_model
[] =
16010 {"Unused", "Finite", "RTABI", "IEEE 754"};
16011 static const char *const arm_attr_tag_ABI_enum_size
[] =
16012 {"Unused", "small", "int", "forced to int"};
16013 static const char *const arm_attr_tag_ABI_HardFP_use
[] =
16014 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
16015 static const char *const arm_attr_tag_ABI_VFP_args
[] =
16016 {"AAPCS", "VFP registers", "custom", "compatible"};
16017 static const char *const arm_attr_tag_ABI_WMMX_args
[] =
16018 {"AAPCS", "WMMX registers", "custom"};
16019 static const char *const arm_attr_tag_ABI_optimization_goals
[] =
16020 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
16021 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
16022 static const char *const arm_attr_tag_ABI_FP_optimization_goals
[] =
16023 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
16024 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
16025 static const char *const arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
16026 static const char *const arm_attr_tag_FP_HP_extension
[] =
16027 {"Not Allowed", "Allowed"};
16028 static const char *const arm_attr_tag_ABI_FP_16bit_format
[] =
16029 {"None", "IEEE 754", "Alternative Format"};
16030 static const char *const arm_attr_tag_DSP_extension
[] =
16031 {"Follow architecture", "Allowed"};
16032 static const char *const arm_attr_tag_MPextension_use
[] =
16033 {"Not Allowed", "Allowed"};
16034 static const char *const arm_attr_tag_DIV_use
[] =
16035 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
16036 "Allowed in v7-A with integer division extension"};
16037 static const char *const arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
16038 static const char *const arm_attr_tag_Virtualization_use
[] =
16039 {"Not Allowed", "TrustZone", "Virtualization Extensions",
16040 "TrustZone and Virtualization Extensions"};
16041 static const char *const arm_attr_tag_MPextension_use_legacy
[] =
16042 {"Not Allowed", "Allowed"};
16044 static const char *const arm_attr_tag_MVE_arch
[] =
16045 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
16047 #define LOOKUP(id, name) \
16048 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
16049 static arm_attr_public_tag arm_attr_public_tags
[] =
16051 {4, "CPU_raw_name", 1, NULL
},
16052 {5, "CPU_name", 1, NULL
},
16053 LOOKUP(6, CPU_arch
),
16054 {7, "CPU_arch_profile", 0, NULL
},
16055 LOOKUP(8, ARM_ISA_use
),
16056 LOOKUP(9, THUMB_ISA_use
),
16057 LOOKUP(10, FP_arch
),
16058 LOOKUP(11, WMMX_arch
),
16059 LOOKUP(12, Advanced_SIMD_arch
),
16060 LOOKUP(13, PCS_config
),
16061 LOOKUP(14, ABI_PCS_R9_use
),
16062 LOOKUP(15, ABI_PCS_RW_data
),
16063 LOOKUP(16, ABI_PCS_RO_data
),
16064 LOOKUP(17, ABI_PCS_GOT_use
),
16065 LOOKUP(18, ABI_PCS_wchar_t
),
16066 LOOKUP(19, ABI_FP_rounding
),
16067 LOOKUP(20, ABI_FP_denormal
),
16068 LOOKUP(21, ABI_FP_exceptions
),
16069 LOOKUP(22, ABI_FP_user_exceptions
),
16070 LOOKUP(23, ABI_FP_number_model
),
16071 {24, "ABI_align_needed", 0, NULL
},
16072 {25, "ABI_align_preserved", 0, NULL
},
16073 LOOKUP(26, ABI_enum_size
),
16074 LOOKUP(27, ABI_HardFP_use
),
16075 LOOKUP(28, ABI_VFP_args
),
16076 LOOKUP(29, ABI_WMMX_args
),
16077 LOOKUP(30, ABI_optimization_goals
),
16078 LOOKUP(31, ABI_FP_optimization_goals
),
16079 {32, "compatibility", 0, NULL
},
16080 LOOKUP(34, CPU_unaligned_access
),
16081 LOOKUP(36, FP_HP_extension
),
16082 LOOKUP(38, ABI_FP_16bit_format
),
16083 LOOKUP(42, MPextension_use
),
16084 LOOKUP(44, DIV_use
),
16085 LOOKUP(46, DSP_extension
),
16086 LOOKUP(48, MVE_arch
),
16087 {64, "nodefaults", 0, NULL
},
16088 {65, "also_compatible_with", 0, NULL
},
16089 LOOKUP(66, T2EE_use
),
16090 {67, "conformance", 1, NULL
},
16091 LOOKUP(68, Virtualization_use
),
16092 LOOKUP(70, MPextension_use_legacy
)
16096 static unsigned char *
16097 display_arm_attribute (unsigned char * p
,
16098 const unsigned char * const end
)
16102 arm_attr_public_tag
* attr
;
16106 READ_ULEB (tag
, p
, end
);
16108 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
16110 if (arm_attr_public_tags
[i
].tag
== tag
)
16112 attr
= &arm_attr_public_tags
[i
];
16119 printf (" Tag_%s: ", attr
->name
);
16120 switch (attr
->type
)
16125 case 7: /* Tag_CPU_arch_profile. */
16126 READ_ULEB (val
, p
, end
);
16129 case 0: printf (_("None\n")); break;
16130 case 'A': printf (_("Application\n")); break;
16131 case 'R': printf (_("Realtime\n")); break;
16132 case 'M': printf (_("Microcontroller\n")); break;
16133 case 'S': printf (_("Application or Realtime\n")); break;
16134 default: printf ("??? (%d)\n", val
); break;
16138 case 24: /* Tag_align_needed. */
16139 READ_ULEB (val
, p
, end
);
16142 case 0: printf (_("None\n")); break;
16143 case 1: printf (_("8-byte\n")); break;
16144 case 2: printf (_("4-byte\n")); break;
16145 case 3: printf ("??? 3\n"); break;
16148 printf (_("8-byte and up to %d-byte extended\n"),
16151 printf ("??? (%d)\n", val
);
16156 case 25: /* Tag_align_preserved. */
16157 READ_ULEB (val
, p
, end
);
16160 case 0: printf (_("None\n")); break;
16161 case 1: printf (_("8-byte, except leaf SP\n")); break;
16162 case 2: printf (_("8-byte\n")); break;
16163 case 3: printf ("??? 3\n"); break;
16166 printf (_("8-byte and up to %d-byte extended\n"),
16169 printf ("??? (%d)\n", val
);
16174 case 32: /* Tag_compatibility. */
16176 READ_ULEB (val
, p
, end
);
16177 printf (_("flag = %d, vendor = "), val
);
16180 size_t maxlen
= (end
- p
) - 1;
16182 print_symbol ((int) maxlen
, (const char *) p
);
16183 p
+= strnlen ((char *) p
, maxlen
) + 1;
16187 printf (_("<corrupt>"));
16188 p
= (unsigned char *) end
;
16194 case 64: /* Tag_nodefaults. */
16195 /* PR 17531: file: 001-505008-0.01. */
16198 printf (_("True\n"));
16201 case 65: /* Tag_also_compatible_with. */
16202 READ_ULEB (val
, p
, end
);
16203 if (val
== 6 /* Tag_CPU_arch. */)
16205 READ_ULEB (val
, p
, end
);
16206 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
16207 printf ("??? (%d)\n", val
);
16209 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
16213 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
16218 printf (_("<unknown: %d>\n"), tag
);
16224 return display_tag_value (-1, p
, end
);
16226 return display_tag_value (0, p
, end
);
16229 assert (attr
->type
& 0x80);
16230 READ_ULEB (val
, p
, end
);
16231 type
= attr
->type
& 0x7f;
16233 printf ("??? (%d)\n", val
);
16235 printf ("%s\n", attr
->table
[val
]);
16240 return display_tag_value (tag
, p
, end
);
16243 static unsigned char *
16244 display_gnu_attribute (unsigned char * p
,
16245 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
16246 const unsigned char * const end
)
16251 READ_ULEB (tag
, p
, end
);
16253 /* Tag_compatibility is the only generic GNU attribute defined at
16257 READ_ULEB (val
, p
, end
);
16259 printf (_("flag = %d, vendor = "), val
);
16262 printf (_("<corrupt>\n"));
16263 warn (_("corrupt vendor attribute\n"));
16269 size_t maxlen
= (end
- p
) - 1;
16271 print_symbol ((int) maxlen
, (const char *) p
);
16272 p
+= strnlen ((char *) p
, maxlen
) + 1;
16276 printf (_("<corrupt>"));
16277 p
= (unsigned char *) end
;
16284 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
16285 return display_proc_gnu_attribute (p
, tag
, end
);
16287 return display_tag_value (tag
, p
, end
);
16290 static unsigned char *
16291 display_m68k_gnu_attribute (unsigned char * p
,
16293 const unsigned char * const end
)
16297 if (tag
== Tag_GNU_M68K_ABI_FP
)
16299 printf (" Tag_GNU_M68K_ABI_FP: ");
16302 printf (_("<corrupt>\n"));
16305 READ_ULEB (val
, p
, end
);
16308 printf ("(%#x), ", val
);
16313 printf (_("unspecified hard/soft float\n"));
16316 printf (_("hard float\n"));
16319 printf (_("soft float\n"));
16325 return display_tag_value (tag
& 1, p
, end
);
16328 static unsigned char *
16329 display_power_gnu_attribute (unsigned char * p
,
16331 const unsigned char * const end
)
16335 if (tag
== Tag_GNU_Power_ABI_FP
)
16337 printf (" Tag_GNU_Power_ABI_FP: ");
16340 printf (_("<corrupt>\n"));
16343 READ_ULEB (val
, p
, end
);
16346 printf ("(%#x), ", val
);
16351 printf (_("unspecified hard/soft float, "));
16354 printf (_("hard float, "));
16357 printf (_("soft float, "));
16360 printf (_("single-precision hard float, "));
16367 printf (_("unspecified long double\n"));
16370 printf (_("128-bit IBM long double\n"));
16373 printf (_("64-bit long double\n"));
16376 printf (_("128-bit IEEE long double\n"));
16382 if (tag
== Tag_GNU_Power_ABI_Vector
)
16384 printf (" Tag_GNU_Power_ABI_Vector: ");
16387 printf (_("<corrupt>\n"));
16390 READ_ULEB (val
, p
, end
);
16393 printf ("(%#x), ", val
);
16398 printf (_("unspecified\n"));
16401 printf (_("generic\n"));
16404 printf ("AltiVec\n");
16413 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
16415 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
16418 printf (_("<corrupt>\n"));
16421 READ_ULEB (val
, p
, end
);
16424 printf ("(%#x), ", val
);
16429 printf (_("unspecified\n"));
16432 printf ("r3/r4\n");
16435 printf (_("memory\n"));
16444 return display_tag_value (tag
& 1, p
, end
);
16447 static unsigned char *
16448 display_s390_gnu_attribute (unsigned char * p
,
16450 const unsigned char * const end
)
16454 if (tag
== Tag_GNU_S390_ABI_Vector
)
16456 printf (" Tag_GNU_S390_ABI_Vector: ");
16457 READ_ULEB (val
, p
, end
);
16462 printf (_("any\n"));
16465 printf (_("software\n"));
16468 printf (_("hardware\n"));
16471 printf ("??? (%d)\n", val
);
16477 return display_tag_value (tag
& 1, p
, end
);
16481 display_sparc_hwcaps (unsigned int mask
)
16487 if (mask
& ELF_SPARC_HWCAP_MUL32
)
16488 fputs ("mul32", stdout
), first
= false;
16489 if (mask
& ELF_SPARC_HWCAP_DIV32
)
16490 printf ("%sdiv32", first
? "" : "|"), first
= false;
16491 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
16492 printf ("%sfsmuld", first
? "" : "|"), first
= false;
16493 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
16494 printf ("%sv8plus", first
? "" : "|"), first
= false;
16495 if (mask
& ELF_SPARC_HWCAP_POPC
)
16496 printf ("%spopc", first
? "" : "|"), first
= false;
16497 if (mask
& ELF_SPARC_HWCAP_VIS
)
16498 printf ("%svis", first
? "" : "|"), first
= false;
16499 if (mask
& ELF_SPARC_HWCAP_VIS2
)
16500 printf ("%svis2", first
? "" : "|"), first
= false;
16501 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
16502 printf ("%sASIBlkInit", first
? "" : "|"), first
= false;
16503 if (mask
& ELF_SPARC_HWCAP_FMAF
)
16504 printf ("%sfmaf", first
? "" : "|"), first
= false;
16505 if (mask
& ELF_SPARC_HWCAP_VIS3
)
16506 printf ("%svis3", first
? "" : "|"), first
= false;
16507 if (mask
& ELF_SPARC_HWCAP_HPC
)
16508 printf ("%shpc", first
? "" : "|"), first
= false;
16509 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
16510 printf ("%srandom", first
? "" : "|"), first
= false;
16511 if (mask
& ELF_SPARC_HWCAP_TRANS
)
16512 printf ("%strans", first
? "" : "|"), first
= false;
16513 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
16514 printf ("%sfjfmau", first
? "" : "|"), first
= false;
16515 if (mask
& ELF_SPARC_HWCAP_IMA
)
16516 printf ("%sima", first
? "" : "|"), first
= false;
16517 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
16518 printf ("%scspare", first
? "" : "|"), first
= false;
16521 fputc ('0', stdout
);
16522 fputc ('\n', stdout
);
16526 display_sparc_hwcaps2 (unsigned int mask
)
16532 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
16533 fputs ("fjathplus", stdout
), first
= false;
16534 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
16535 printf ("%svis3b", first
? "" : "|"), first
= false;
16536 if (mask
& ELF_SPARC_HWCAP2_ADP
)
16537 printf ("%sadp", first
? "" : "|"), first
= false;
16538 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
16539 printf ("%ssparc5", first
? "" : "|"), first
= false;
16540 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
16541 printf ("%smwait", first
? "" : "|"), first
= false;
16542 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
16543 printf ("%sxmpmul", first
? "" : "|"), first
= false;
16544 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
16545 printf ("%sxmont2", first
? "" : "|"), first
= false;
16546 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
16547 printf ("%snsec", first
? "" : "|"), first
= false;
16548 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
16549 printf ("%sfjathhpc", first
? "" : "|"), first
= false;
16550 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
16551 printf ("%sfjdes", first
? "" : "|"), first
= false;
16552 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
16553 printf ("%sfjaes", first
? "" : "|"), first
= false;
16556 fputc ('0', stdout
);
16557 fputc ('\n', stdout
);
16560 static unsigned char *
16561 display_sparc_gnu_attribute (unsigned char * p
,
16563 const unsigned char * const end
)
16567 if (tag
== Tag_GNU_Sparc_HWCAPS
)
16569 READ_ULEB (val
, p
, end
);
16570 printf (" Tag_GNU_Sparc_HWCAPS: ");
16571 display_sparc_hwcaps (val
);
16574 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
16576 READ_ULEB (val
, p
, end
);
16577 printf (" Tag_GNU_Sparc_HWCAPS2: ");
16578 display_sparc_hwcaps2 (val
);
16582 return display_tag_value (tag
, p
, end
);
16586 print_mips_fp_abi_value (unsigned int val
)
16590 case Val_GNU_MIPS_ABI_FP_ANY
:
16591 printf (_("Hard or soft float\n"));
16593 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
16594 printf (_("Hard float (double precision)\n"));
16596 case Val_GNU_MIPS_ABI_FP_SINGLE
:
16597 printf (_("Hard float (single precision)\n"));
16599 case Val_GNU_MIPS_ABI_FP_SOFT
:
16600 printf (_("Soft float\n"));
16602 case Val_GNU_MIPS_ABI_FP_OLD_64
:
16603 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
16605 case Val_GNU_MIPS_ABI_FP_XX
:
16606 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
16608 case Val_GNU_MIPS_ABI_FP_64
:
16609 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
16611 case Val_GNU_MIPS_ABI_FP_64A
:
16612 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
16614 case Val_GNU_MIPS_ABI_FP_NAN2008
:
16615 printf (_("NaN 2008 compatibility\n"));
16618 printf ("??? (%d)\n", val
);
16623 static unsigned char *
16624 display_mips_gnu_attribute (unsigned char * p
,
16626 const unsigned char * const end
)
16628 if (tag
== Tag_GNU_MIPS_ABI_FP
)
16632 printf (" Tag_GNU_MIPS_ABI_FP: ");
16633 READ_ULEB (val
, p
, end
);
16634 print_mips_fp_abi_value (val
);
16638 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
16642 printf (" Tag_GNU_MIPS_ABI_MSA: ");
16643 READ_ULEB (val
, p
, end
);
16647 case Val_GNU_MIPS_ABI_MSA_ANY
:
16648 printf (_("Any MSA or not\n"));
16650 case Val_GNU_MIPS_ABI_MSA_128
:
16651 printf (_("128-bit MSA\n"));
16654 printf ("??? (%d)\n", val
);
16660 return display_tag_value (tag
& 1, p
, end
);
16663 static unsigned char *
16664 display_tic6x_attribute (unsigned char * p
,
16665 const unsigned char * const end
)
16670 READ_ULEB (tag
, p
, end
);
16675 printf (" Tag_ISA: ");
16676 READ_ULEB (val
, p
, end
);
16680 case C6XABI_Tag_ISA_none
:
16681 printf (_("None\n"));
16683 case C6XABI_Tag_ISA_C62X
:
16686 case C6XABI_Tag_ISA_C67X
:
16689 case C6XABI_Tag_ISA_C67XP
:
16690 printf ("C67x+\n");
16692 case C6XABI_Tag_ISA_C64X
:
16695 case C6XABI_Tag_ISA_C64XP
:
16696 printf ("C64x+\n");
16698 case C6XABI_Tag_ISA_C674X
:
16699 printf ("C674x\n");
16702 printf ("??? (%d)\n", val
);
16707 case Tag_ABI_wchar_t
:
16708 printf (" Tag_ABI_wchar_t: ");
16709 READ_ULEB (val
, p
, end
);
16713 printf (_("Not used\n"));
16716 printf (_("2 bytes\n"));
16719 printf (_("4 bytes\n"));
16722 printf ("??? (%d)\n", val
);
16727 case Tag_ABI_stack_align_needed
:
16728 printf (" Tag_ABI_stack_align_needed: ");
16729 READ_ULEB (val
, p
, end
);
16733 printf (_("8-byte\n"));
16736 printf (_("16-byte\n"));
16739 printf ("??? (%d)\n", val
);
16744 case Tag_ABI_stack_align_preserved
:
16745 READ_ULEB (val
, p
, end
);
16746 printf (" Tag_ABI_stack_align_preserved: ");
16750 printf (_("8-byte\n"));
16753 printf (_("16-byte\n"));
16756 printf ("??? (%d)\n", val
);
16762 READ_ULEB (val
, p
, end
);
16763 printf (" Tag_ABI_DSBT: ");
16767 printf (_("DSBT addressing not used\n"));
16770 printf (_("DSBT addressing used\n"));
16773 printf ("??? (%d)\n", val
);
16779 READ_ULEB (val
, p
, end
);
16780 printf (" Tag_ABI_PID: ");
16784 printf (_("Data addressing position-dependent\n"));
16787 printf (_("Data addressing position-independent, GOT near DP\n"));
16790 printf (_("Data addressing position-independent, GOT far from DP\n"));
16793 printf ("??? (%d)\n", val
);
16799 READ_ULEB (val
, p
, end
);
16800 printf (" Tag_ABI_PIC: ");
16804 printf (_("Code addressing position-dependent\n"));
16807 printf (_("Code addressing position-independent\n"));
16810 printf ("??? (%d)\n", val
);
16815 case Tag_ABI_array_object_alignment
:
16816 READ_ULEB (val
, p
, end
);
16817 printf (" Tag_ABI_array_object_alignment: ");
16821 printf (_("8-byte\n"));
16824 printf (_("4-byte\n"));
16827 printf (_("16-byte\n"));
16830 printf ("??? (%d)\n", val
);
16835 case Tag_ABI_array_object_align_expected
:
16836 READ_ULEB (val
, p
, end
);
16837 printf (" Tag_ABI_array_object_align_expected: ");
16841 printf (_("8-byte\n"));
16844 printf (_("4-byte\n"));
16847 printf (_("16-byte\n"));
16850 printf ("??? (%d)\n", val
);
16855 case Tag_ABI_compatibility
:
16857 READ_ULEB (val
, p
, end
);
16858 printf (" Tag_ABI_compatibility: ");
16859 printf (_("flag = %d, vendor = "), val
);
16862 size_t maxlen
= (end
- p
) - 1;
16864 print_symbol ((int) maxlen
, (const char *) p
);
16865 p
+= strnlen ((char *) p
, maxlen
) + 1;
16869 printf (_("<corrupt>"));
16870 p
= (unsigned char *) end
;
16876 case Tag_ABI_conformance
:
16878 printf (" Tag_ABI_conformance: \"");
16881 size_t maxlen
= (end
- p
) - 1;
16883 print_symbol ((int) maxlen
, (const char *) p
);
16884 p
+= strnlen ((char *) p
, maxlen
) + 1;
16888 printf (_("<corrupt>"));
16889 p
= (unsigned char *) end
;
16896 return display_tag_value (tag
, p
, end
);
16900 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
16902 unsigned long addr
= 0;
16903 size_t bytes
= end
- p
;
16910 int lbytes
= (bytes
> 16 ? 16 : bytes
);
16912 printf (" 0x%8.8lx ", addr
);
16914 for (j
= 0; j
< 16; j
++)
16917 printf ("%2.2x", p
[j
]);
16925 for (j
= 0; j
< lbytes
; j
++)
16928 if (k
>= ' ' && k
< 0x7f)
16944 static unsigned char *
16945 display_msp430_attribute (unsigned char * p
,
16946 const unsigned char * const end
)
16951 READ_ULEB (tag
, p
, end
);
16955 case OFBA_MSPABI_Tag_ISA
:
16956 printf (" Tag_ISA: ");
16957 READ_ULEB (val
, p
, end
);
16960 case 0: printf (_("None\n")); break;
16961 case 1: printf (_("MSP430\n")); break;
16962 case 2: printf (_("MSP430X\n")); break;
16963 default: printf ("??? (%d)\n", val
); break;
16967 case OFBA_MSPABI_Tag_Code_Model
:
16968 printf (" Tag_Code_Model: ");
16969 READ_ULEB (val
, p
, end
);
16972 case 0: printf (_("None\n")); break;
16973 case 1: printf (_("Small\n")); break;
16974 case 2: printf (_("Large\n")); break;
16975 default: printf ("??? (%d)\n", val
); break;
16979 case OFBA_MSPABI_Tag_Data_Model
:
16980 printf (" Tag_Data_Model: ");
16981 READ_ULEB (val
, p
, end
);
16984 case 0: printf (_("None\n")); break;
16985 case 1: printf (_("Small\n")); break;
16986 case 2: printf (_("Large\n")); break;
16987 case 3: printf (_("Restricted Large\n")); break;
16988 default: printf ("??? (%d)\n", val
); break;
16993 printf (_(" <unknown tag %d>: "), tag
);
17000 size_t maxlen
= (end
- p
) - 1;
17002 print_symbol ((int) maxlen
, (const char *) p
);
17003 p
+= strnlen ((char *) p
, maxlen
) + 1;
17007 printf (_("<corrupt>"));
17008 p
= (unsigned char *) end
;
17014 READ_ULEB (val
, p
, end
);
17015 printf ("%d (0x%x)\n", val
, val
);
17024 static unsigned char *
17025 display_msp430_gnu_attribute (unsigned char * p
,
17027 const unsigned char * const end
)
17029 if (tag
== Tag_GNU_MSP430_Data_Region
)
17033 printf (" Tag_GNU_MSP430_Data_Region: ");
17034 READ_ULEB (val
, p
, end
);
17038 case Val_GNU_MSP430_Data_Region_Any
:
17039 printf (_("Any Region\n"));
17041 case Val_GNU_MSP430_Data_Region_Lower
:
17042 printf (_("Lower Region Only\n"));
17045 printf ("??? (%u)\n", val
);
17049 return display_tag_value (tag
& 1, p
, end
);
17052 struct riscv_attr_tag_t
{
17057 static struct riscv_attr_tag_t riscv_attr_tag
[] =
17059 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
17062 T(priv_spec_minor
),
17063 T(priv_spec_revision
),
17064 T(unaligned_access
),
17069 static unsigned char *
17070 display_riscv_attribute (unsigned char *p
,
17071 const unsigned char * const end
)
17075 struct riscv_attr_tag_t
*attr
= NULL
;
17078 READ_ULEB (tag
, p
, end
);
17080 /* Find the name of attribute. */
17081 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
17083 if (riscv_attr_tag
[i
].tag
== tag
)
17085 attr
= &riscv_attr_tag
[i
];
17091 printf (" %s: ", attr
->name
);
17093 return display_tag_value (tag
, p
, end
);
17097 case Tag_RISCV_priv_spec
:
17098 case Tag_RISCV_priv_spec_minor
:
17099 case Tag_RISCV_priv_spec_revision
:
17100 READ_ULEB (val
, p
, end
);
17101 printf (_("%u\n"), val
);
17103 case Tag_RISCV_unaligned_access
:
17104 READ_ULEB (val
, p
, end
);
17108 printf (_("No unaligned access\n"));
17111 printf (_("Unaligned access\n"));
17115 case Tag_RISCV_stack_align
:
17116 READ_ULEB (val
, p
, end
);
17117 printf (_("%u-bytes\n"), val
);
17119 case Tag_RISCV_arch
:
17120 p
= display_tag_value (-1, p
, end
);
17123 return display_tag_value (tag
, p
, end
);
17129 static unsigned char *
17130 display_csky_attribute (unsigned char * p
,
17131 const unsigned char * const end
)
17135 READ_ULEB (tag
, p
, end
);
17137 if (tag
>= Tag_CSKY_MAX
)
17139 return display_tag_value (-1, p
, end
);
17144 case Tag_CSKY_ARCH_NAME
:
17145 printf (" Tag_CSKY_ARCH_NAME:\t\t");
17146 return display_tag_value (-1, p
, end
);
17147 case Tag_CSKY_CPU_NAME
:
17148 printf (" Tag_CSKY_CPU_NAME:\t\t");
17149 return display_tag_value (-1, p
, end
);
17151 case Tag_CSKY_ISA_FLAGS
:
17152 printf (" Tag_CSKY_ISA_FLAGS:\t\t");
17153 return display_tag_value (0, p
, end
);
17154 case Tag_CSKY_ISA_EXT_FLAGS
:
17155 printf (" Tag_CSKY_ISA_EXT_FLAGS:\t");
17156 return display_tag_value (0, p
, end
);
17158 case Tag_CSKY_DSP_VERSION
:
17159 printf (" Tag_CSKY_DSP_VERSION:\t\t");
17160 READ_ULEB (val
, p
, end
);
17161 if (val
== VAL_CSKY_DSP_VERSION_EXTENSION
)
17162 printf ("DSP Extension\n");
17163 else if (val
== VAL_CSKY_DSP_VERSION_2
)
17164 printf ("DSP 2.0\n");
17167 case Tag_CSKY_VDSP_VERSION
:
17168 printf (" Tag_CSKY_VDSP_VERSION:\t");
17169 READ_ULEB (val
, p
, end
);
17170 printf ("VDSP Version %d\n", val
);
17173 case Tag_CSKY_FPU_VERSION
:
17174 printf (" Tag_CSKY_FPU_VERSION:\t\t");
17175 READ_ULEB (val
, p
, end
);
17176 if (val
== VAL_CSKY_FPU_VERSION_1
)
17177 printf ("ABIV1 FPU Version 1\n");
17178 else if (val
== VAL_CSKY_FPU_VERSION_2
)
17179 printf ("FPU Version 2\n");
17182 case Tag_CSKY_FPU_ABI
:
17183 printf (" Tag_CSKY_FPU_ABI:\t\t");
17184 READ_ULEB (val
, p
, end
);
17185 if (val
== VAL_CSKY_FPU_ABI_HARD
)
17187 else if (val
== VAL_CSKY_FPU_ABI_SOFTFP
)
17188 printf ("SoftFP\n");
17189 else if (val
== VAL_CSKY_FPU_ABI_SOFT
)
17192 case Tag_CSKY_FPU_ROUNDING
:
17193 READ_ULEB (val
, p
, end
);
17195 printf (" Tag_CSKY_FPU_ROUNDING:\t");
17196 printf ("Needed\n");
17199 case Tag_CSKY_FPU_DENORMAL
:
17200 READ_ULEB (val
, p
, end
);
17202 printf (" Tag_CSKY_FPU_DENORMAL:\t");
17203 printf ("Needed\n");
17206 case Tag_CSKY_FPU_Exception
:
17207 READ_ULEB (val
, p
, end
);
17209 printf (" Tag_CSKY_FPU_Exception:\t");
17210 printf ("Needed\n");
17213 case Tag_CSKY_FPU_NUMBER_MODULE
:
17214 printf (" Tag_CSKY_FPU_NUMBER_MODULE:\t");
17215 return display_tag_value (-1, p
, end
);
17216 case Tag_CSKY_FPU_HARDFP
:
17217 printf (" Tag_CSKY_FPU_HARDFP:\t\t");
17218 READ_ULEB (val
, p
, end
);
17219 if (val
& VAL_CSKY_FPU_HARDFP_HALF
)
17221 if (val
& VAL_CSKY_FPU_HARDFP_SINGLE
)
17222 printf (" Single");
17223 if (val
& VAL_CSKY_FPU_HARDFP_DOUBLE
)
17224 printf (" Double");
17228 return display_tag_value (tag
, p
, end
);
17234 process_attributes (Filedata
* filedata
,
17235 const char * public_name
,
17236 unsigned int proc_type
,
17237 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
17238 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
17240 Elf_Internal_Shdr
* sect
;
17244 /* Find the section header so that we get the size. */
17245 for (i
= 0, sect
= filedata
->section_headers
;
17246 i
< filedata
->file_header
.e_shnum
;
17249 unsigned char * contents
;
17252 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
17255 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17256 sect
->sh_size
, _("attributes"));
17257 if (contents
== NULL
)
17264 /* The first character is the version of the attributes.
17265 Currently only version 1, (aka 'A') is recognised here. */
17268 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
17273 bfd_vma section_len
;
17275 section_len
= sect
->sh_size
- 1;
17278 while (section_len
> 0)
17281 unsigned int namelen
;
17282 bool public_section
;
17285 if (section_len
<= 4)
17287 error (_("Tag section ends prematurely\n"));
17291 attr_len
= byte_get (p
, 4);
17294 if (attr_len
> section_len
)
17296 error (_("Bad attribute length (%u > %u)\n"),
17297 (unsigned) attr_len
, (unsigned) section_len
);
17298 attr_len
= section_len
;
17301 /* PR 17531: file: 001-101425-0.004 */
17302 else if (attr_len
< 5)
17304 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
17309 section_len
-= attr_len
;
17312 namelen
= strnlen ((char *) p
, attr_len
) + 1;
17313 if (namelen
== 0 || namelen
>= attr_len
)
17315 error (_("Corrupt attribute section name\n"));
17320 printf (_("Attribute Section: "));
17321 print_symbol (INT_MAX
, (const char *) p
);
17324 if (public_name
&& streq ((char *) p
, public_name
))
17325 public_section
= true;
17327 public_section
= false;
17329 if (streq ((char *) p
, "gnu"))
17330 gnu_section
= true;
17332 gnu_section
= false;
17335 attr_len
-= namelen
;
17337 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
17342 unsigned char * end
;
17344 /* PR binutils/17531: Safe handling of corrupt files. */
17347 error (_("Unused bytes at end of section\n"));
17354 size
= byte_get (p
, 4);
17355 if (size
> attr_len
)
17357 error (_("Bad subsection length (%u > %u)\n"),
17358 (unsigned) size
, (unsigned) attr_len
);
17362 /* PR binutils/17531: Safe handling of corrupt files. */
17365 error (_("Bad subsection length (%u < 6)\n"),
17373 end
= p
+ size
- 1;
17374 assert (end
<= contents
+ sect
->sh_size
);
17380 printf (_("File Attributes\n"));
17383 printf (_("Section Attributes:"));
17386 printf (_("Symbol Attributes:"));
17387 /* Fall through. */
17391 READ_ULEB (val
, p
, end
);
17394 printf (" %d", val
);
17399 printf (_("Unknown tag: %d\n"), tag
);
17400 public_section
= false;
17404 if (public_section
&& display_pub_attribute
!= NULL
)
17407 p
= display_pub_attribute (p
, end
);
17410 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
17413 p
= display_gnu_attribute (p
,
17414 display_proc_gnu_attribute
,
17420 printf (_(" Unknown attribute:\n"));
17421 display_raw_attribute (p
, end
);
17436 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
17437 Print the Address, Access and Initial fields of an entry at VMA ADDR
17438 and return the VMA of the next entry, or -1 if there was a problem.
17439 Does not read from DATA_END or beyond. */
17442 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
17443 unsigned char * data_end
)
17446 print_vma (addr
, LONG_HEX
);
17448 if (addr
< pltgot
+ 0xfff0)
17449 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
17451 printf ("%10s", "");
17454 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
17458 unsigned char * from
= data
+ addr
- pltgot
;
17460 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
17462 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
17463 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
17464 return (bfd_vma
) -1;
17468 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
17469 print_vma (entry
, LONG_HEX
);
17472 return addr
+ (is_32bit_elf
? 4 : 8);
17475 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
17476 PLTGOT. Print the Address and Initial fields of an entry at VMA
17477 ADDR and return the VMA of the next entry. */
17480 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
17483 print_vma (addr
, LONG_HEX
);
17486 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
17491 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
17492 print_vma (entry
, LONG_HEX
);
17494 return addr
+ (is_32bit_elf
? 4 : 8);
17498 print_mips_ases (unsigned int mask
)
17500 if (mask
& AFL_ASE_DSP
)
17501 fputs ("\n\tDSP ASE", stdout
);
17502 if (mask
& AFL_ASE_DSPR2
)
17503 fputs ("\n\tDSP R2 ASE", stdout
);
17504 if (mask
& AFL_ASE_DSPR3
)
17505 fputs ("\n\tDSP R3 ASE", stdout
);
17506 if (mask
& AFL_ASE_EVA
)
17507 fputs ("\n\tEnhanced VA Scheme", stdout
);
17508 if (mask
& AFL_ASE_MCU
)
17509 fputs ("\n\tMCU (MicroController) ASE", stdout
);
17510 if (mask
& AFL_ASE_MDMX
)
17511 fputs ("\n\tMDMX ASE", stdout
);
17512 if (mask
& AFL_ASE_MIPS3D
)
17513 fputs ("\n\tMIPS-3D ASE", stdout
);
17514 if (mask
& AFL_ASE_MT
)
17515 fputs ("\n\tMT ASE", stdout
);
17516 if (mask
& AFL_ASE_SMARTMIPS
)
17517 fputs ("\n\tSmartMIPS ASE", stdout
);
17518 if (mask
& AFL_ASE_VIRT
)
17519 fputs ("\n\tVZ ASE", stdout
);
17520 if (mask
& AFL_ASE_MSA
)
17521 fputs ("\n\tMSA ASE", stdout
);
17522 if (mask
& AFL_ASE_MIPS16
)
17523 fputs ("\n\tMIPS16 ASE", stdout
);
17524 if (mask
& AFL_ASE_MICROMIPS
)
17525 fputs ("\n\tMICROMIPS ASE", stdout
);
17526 if (mask
& AFL_ASE_XPA
)
17527 fputs ("\n\tXPA ASE", stdout
);
17528 if (mask
& AFL_ASE_MIPS16E2
)
17529 fputs ("\n\tMIPS16e2 ASE", stdout
);
17530 if (mask
& AFL_ASE_CRC
)
17531 fputs ("\n\tCRC ASE", stdout
);
17532 if (mask
& AFL_ASE_GINV
)
17533 fputs ("\n\tGINV ASE", stdout
);
17534 if (mask
& AFL_ASE_LOONGSON_MMI
)
17535 fputs ("\n\tLoongson MMI ASE", stdout
);
17536 if (mask
& AFL_ASE_LOONGSON_CAM
)
17537 fputs ("\n\tLoongson CAM ASE", stdout
);
17538 if (mask
& AFL_ASE_LOONGSON_EXT
)
17539 fputs ("\n\tLoongson EXT ASE", stdout
);
17540 if (mask
& AFL_ASE_LOONGSON_EXT2
)
17541 fputs ("\n\tLoongson EXT2 ASE", stdout
);
17543 fprintf (stdout
, "\n\t%s", _("None"));
17544 else if ((mask
& ~AFL_ASE_MASK
) != 0)
17545 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
17549 print_mips_isa_ext (unsigned int isa_ext
)
17554 fputs (_("None"), stdout
);
17557 fputs ("RMI XLR", stdout
);
17559 case AFL_EXT_OCTEON3
:
17560 fputs ("Cavium Networks Octeon3", stdout
);
17562 case AFL_EXT_OCTEON2
:
17563 fputs ("Cavium Networks Octeon2", stdout
);
17565 case AFL_EXT_OCTEONP
:
17566 fputs ("Cavium Networks OcteonP", stdout
);
17568 case AFL_EXT_OCTEON
:
17569 fputs ("Cavium Networks Octeon", stdout
);
17572 fputs ("Toshiba R5900", stdout
);
17575 fputs ("MIPS R4650", stdout
);
17578 fputs ("LSI R4010", stdout
);
17581 fputs ("NEC VR4100", stdout
);
17584 fputs ("Toshiba R3900", stdout
);
17586 case AFL_EXT_10000
:
17587 fputs ("MIPS R10000", stdout
);
17590 fputs ("Broadcom SB-1", stdout
);
17593 fputs ("NEC VR4111/VR4181", stdout
);
17596 fputs ("NEC VR4120", stdout
);
17599 fputs ("NEC VR5400", stdout
);
17602 fputs ("NEC VR5500", stdout
);
17604 case AFL_EXT_LOONGSON_2E
:
17605 fputs ("ST Microelectronics Loongson 2E", stdout
);
17607 case AFL_EXT_LOONGSON_2F
:
17608 fputs ("ST Microelectronics Loongson 2F", stdout
);
17610 case AFL_EXT_INTERAPTIV_MR2
:
17611 fputs ("Imagination interAptiv MR2", stdout
);
17614 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
17619 get_mips_reg_size (int reg_size
)
17621 return (reg_size
== AFL_REG_NONE
) ? 0
17622 : (reg_size
== AFL_REG_32
) ? 32
17623 : (reg_size
== AFL_REG_64
) ? 64
17624 : (reg_size
== AFL_REG_128
) ? 128
17629 process_mips_specific (Filedata
* filedata
)
17631 Elf_Internal_Dyn
* entry
;
17632 Elf_Internal_Shdr
*sect
= NULL
;
17633 size_t liblist_offset
= 0;
17634 size_t liblistno
= 0;
17635 size_t conflictsno
= 0;
17636 size_t options_offset
= 0;
17637 size_t conflicts_offset
= 0;
17638 size_t pltrelsz
= 0;
17640 bfd_vma pltgot
= 0;
17641 bfd_vma mips_pltgot
= 0;
17642 bfd_vma jmprel
= 0;
17643 bfd_vma local_gotno
= 0;
17644 bfd_vma gotsym
= 0;
17645 bfd_vma symtabno
= 0;
17648 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17649 display_mips_gnu_attribute
))
17652 sect
= find_section (filedata
, ".MIPS.abiflags");
17656 Elf_External_ABIFlags_v0
*abiflags_ext
;
17657 Elf_Internal_ABIFlags_v0 abiflags_in
;
17659 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
17661 error (_("Corrupt MIPS ABI Flags section.\n"));
17666 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17667 sect
->sh_size
, _("MIPS ABI Flags section"));
17670 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
17671 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
17672 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
17673 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
17674 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
17675 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
17676 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
17677 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
17678 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
17679 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
17680 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
17682 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
17683 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
17684 if (abiflags_in
.isa_rev
> 1)
17685 printf ("r%d", abiflags_in
.isa_rev
);
17686 printf ("\nGPR size: %d",
17687 get_mips_reg_size (abiflags_in
.gpr_size
));
17688 printf ("\nCPR1 size: %d",
17689 get_mips_reg_size (abiflags_in
.cpr1_size
));
17690 printf ("\nCPR2 size: %d",
17691 get_mips_reg_size (abiflags_in
.cpr2_size
));
17692 fputs ("\nFP ABI: ", stdout
);
17693 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
17694 fputs ("ISA Extension: ", stdout
);
17695 print_mips_isa_ext (abiflags_in
.isa_ext
);
17696 fputs ("\nASEs:", stdout
);
17697 print_mips_ases (abiflags_in
.ases
);
17698 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
17699 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
17700 fputc ('\n', stdout
);
17701 free (abiflags_ext
);
17706 /* We have a lot of special sections. Thanks SGI! */
17707 if (filedata
->dynamic_section
== NULL
)
17709 /* No dynamic information available. See if there is static GOT. */
17710 sect
= find_section (filedata
, ".got");
17713 unsigned char *data_end
;
17714 unsigned char *data
;
17718 pltgot
= sect
->sh_addr
;
17721 addr_size
= (is_32bit_elf
? 4 : 8);
17722 end
= pltgot
+ sect
->sh_size
;
17724 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
17726 _("Global Offset Table data"));
17727 /* PR 12855: Null data is handled gracefully throughout. */
17728 data_end
= data
+ (end
- pltgot
);
17730 printf (_("\nStatic GOT:\n"));
17731 printf (_(" Canonical gp value: "));
17732 print_vma (ent
+ 0x7ff0, LONG_HEX
);
17735 /* In a dynamic binary GOT[0] is reserved for the dynamic
17736 loader to store the lazy resolver pointer, however in
17737 a static binary it may well have been omitted and GOT
17738 reduced to a table of addresses.
17739 PR 21344: Check for the entry being fully available
17740 before fetching it. */
17742 && data
+ ent
- pltgot
+ addr_size
<= data_end
17743 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
17745 printf (_(" Reserved entries:\n"));
17746 printf (_(" %*s %10s %*s\n"),
17747 addr_size
* 2, _("Address"), _("Access"),
17748 addr_size
* 2, _("Value"));
17749 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17751 if (ent
== (bfd_vma
) -1)
17752 goto sgot_print_fail
;
17754 /* Check for the MSB of GOT[1] being set, identifying a
17755 GNU object. This entry will be used by some runtime
17756 loaders, to store the module pointer. Otherwise this
17757 is an ordinary local entry.
17758 PR 21344: Check for the entry being fully available
17759 before fetching it. */
17761 && data
+ ent
- pltgot
+ addr_size
<= data_end
17762 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17763 >> (addr_size
* 8 - 1)) != 0)
17765 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17767 if (ent
== (bfd_vma
) -1)
17768 goto sgot_print_fail
;
17773 if (data
!= NULL
&& ent
< end
)
17775 printf (_(" Local entries:\n"));
17776 printf (" %*s %10s %*s\n",
17777 addr_size
* 2, _("Address"), _("Access"),
17778 addr_size
* 2, _("Value"));
17781 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17783 if (ent
== (bfd_vma
) -1)
17784 goto sgot_print_fail
;
17795 for (entry
= filedata
->dynamic_section
;
17796 /* PR 17531 file: 012-50589-0.004. */
17797 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
17798 && entry
->d_tag
!= DT_NULL
);
17800 switch (entry
->d_tag
)
17802 case DT_MIPS_LIBLIST
:
17804 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
17805 liblistno
* sizeof (Elf32_External_Lib
));
17807 case DT_MIPS_LIBLISTNO
:
17808 liblistno
= entry
->d_un
.d_val
;
17810 case DT_MIPS_OPTIONS
:
17811 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
17813 case DT_MIPS_CONFLICT
:
17815 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
17816 conflictsno
* sizeof (Elf32_External_Conflict
));
17818 case DT_MIPS_CONFLICTNO
:
17819 conflictsno
= entry
->d_un
.d_val
;
17822 pltgot
= entry
->d_un
.d_ptr
;
17824 case DT_MIPS_LOCAL_GOTNO
:
17825 local_gotno
= entry
->d_un
.d_val
;
17827 case DT_MIPS_GOTSYM
:
17828 gotsym
= entry
->d_un
.d_val
;
17830 case DT_MIPS_SYMTABNO
:
17831 symtabno
= entry
->d_un
.d_val
;
17833 case DT_MIPS_PLTGOT
:
17834 mips_pltgot
= entry
->d_un
.d_ptr
;
17837 pltrel
= entry
->d_un
.d_val
;
17840 pltrelsz
= entry
->d_un
.d_val
;
17843 jmprel
= entry
->d_un
.d_ptr
;
17849 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
17851 Elf32_External_Lib
* elib
;
17854 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
17855 sizeof (Elf32_External_Lib
),
17857 _("liblist section data"));
17860 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
17861 "\nSection '.liblist' contains %lu entries:\n",
17862 (unsigned long) liblistno
),
17863 (unsigned long) liblistno
);
17864 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
17867 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
17874 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17875 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17876 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17877 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17878 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17880 tmp
= gmtime (&atime
);
17881 snprintf (timebuf
, sizeof (timebuf
),
17882 "%04u-%02u-%02uT%02u:%02u:%02u",
17883 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17884 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17886 printf ("%3lu: ", (unsigned long) cnt
);
17887 if (VALID_DYNAMIC_NAME (filedata
, liblist
.l_name
))
17888 print_symbol (20, GET_DYNAMIC_NAME (filedata
, liblist
.l_name
));
17890 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
17891 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
17892 liblist
.l_version
);
17894 if (liblist
.l_flags
== 0)
17898 static const struct
17905 { " EXACT_MATCH", LL_EXACT_MATCH
},
17906 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
17907 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
17908 { " EXPORTS", LL_EXPORTS
},
17909 { " DELAY_LOAD", LL_DELAY_LOAD
},
17910 { " DELTA", LL_DELTA
}
17912 int flags
= liblist
.l_flags
;
17915 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
17916 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
17918 fputs (l_flags_vals
[fcnt
].name
, stdout
);
17919 flags
^= l_flags_vals
[fcnt
].bit
;
17922 printf (" %#x", (unsigned int) flags
);
17934 if (options_offset
!= 0)
17936 Elf_External_Options
* eopt
;
17939 sect
= filedata
->section_headers
;
17941 /* Find the section header so that we get the size. */
17942 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
17943 /* PR 17533 file: 012-277276-0.004. */
17946 error (_("No MIPS_OPTIONS header found\n"));
17950 if (sect
->sh_size
< sizeof (* eopt
))
17952 error (_("The MIPS options section is too small.\n"));
17956 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
17957 sect
->sh_size
, _("options"));
17960 Elf_Internal_Options option
;
17963 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
17965 Elf_External_Options
* eoption
;
17966 unsigned int optsize
;
17968 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
17970 optsize
= BYTE_GET (eoption
->size
);
17972 /* PR 17531: file: ffa0fa3b. */
17973 if (optsize
< sizeof (* eopt
)
17974 || optsize
> sect
->sh_size
- offset
)
17976 error (_("Invalid size (%u) for MIPS option\n"),
17985 printf (ngettext ("\nSection '%s' contains %d entry:\n",
17986 "\nSection '%s' contains %d entries:\n",
17988 printable_section_name (filedata
, sect
), cnt
);
17994 Elf_External_Options
* eoption
;
17996 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
17998 option
.kind
= BYTE_GET (eoption
->kind
);
17999 option
.size
= BYTE_GET (eoption
->size
);
18000 option
.section
= BYTE_GET (eoption
->section
);
18001 option
.info
= BYTE_GET (eoption
->info
);
18003 switch (option
.kind
)
18006 /* This shouldn't happen. */
18007 printf (" NULL %" PRId16
" %" PRIx32
,
18008 option
.section
, option
.info
);
18012 printf (" REGINFO ");
18013 if (filedata
->file_header
.e_machine
== EM_MIPS
)
18015 Elf32_External_RegInfo
* ereg
;
18016 Elf32_RegInfo reginfo
;
18019 if (option
.size
< (sizeof (Elf_External_Options
)
18020 + sizeof (Elf32_External_RegInfo
)))
18022 printf (_("<corrupt>\n"));
18023 error (_("Truncated MIPS REGINFO option\n"));
18028 ereg
= (Elf32_External_RegInfo
*) (eoption
+ 1);
18030 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
18031 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
18032 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
18033 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
18034 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
18035 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
18037 printf ("GPR %08" PRIx32
" GP 0x%" PRIx32
"\n",
18038 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
18040 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
18041 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
18042 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
18043 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
18048 Elf64_External_RegInfo
* ereg
;
18049 Elf64_Internal_RegInfo reginfo
;
18051 if (option
.size
< (sizeof (Elf_External_Options
)
18052 + sizeof (Elf64_External_RegInfo
)))
18054 printf (_("<corrupt>\n"));
18055 error (_("Truncated MIPS REGINFO option\n"));
18060 ereg
= (Elf64_External_RegInfo
*) (eoption
+ 1);
18061 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
18062 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
18063 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
18064 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
18065 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
18066 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
18068 printf ("GPR %08" PRIx32
" GP 0x%" PRIx64
"\n",
18069 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
18071 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
18072 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
18073 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
18074 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
18076 offset
+= option
.size
;
18079 case ODK_EXCEPTIONS
:
18080 fputs (" EXCEPTIONS fpe_min(", stdout
);
18081 process_mips_fpe_exception (option
.info
& OEX_FPU_MIN
);
18082 fputs (") fpe_max(", stdout
);
18083 process_mips_fpe_exception ((option
.info
& OEX_FPU_MAX
) >> 8);
18084 fputs (")", stdout
);
18086 if (option
.info
& OEX_PAGE0
)
18087 fputs (" PAGE0", stdout
);
18088 if (option
.info
& OEX_SMM
)
18089 fputs (" SMM", stdout
);
18090 if (option
.info
& OEX_FPDBUG
)
18091 fputs (" FPDBUG", stdout
);
18092 if (option
.info
& OEX_DISMISS
)
18093 fputs (" DISMISS", stdout
);
18097 fputs (" PAD ", stdout
);
18098 if (option
.info
& OPAD_PREFIX
)
18099 fputs (" PREFIX", stdout
);
18100 if (option
.info
& OPAD_POSTFIX
)
18101 fputs (" POSTFIX", stdout
);
18102 if (option
.info
& OPAD_SYMBOL
)
18103 fputs (" SYMBOL", stdout
);
18107 fputs (" HWPATCH ", stdout
);
18108 if (option
.info
& OHW_R4KEOP
)
18109 fputs (" R4KEOP", stdout
);
18110 if (option
.info
& OHW_R8KPFETCH
)
18111 fputs (" R8KPFETCH", stdout
);
18112 if (option
.info
& OHW_R5KEOP
)
18113 fputs (" R5KEOP", stdout
);
18114 if (option
.info
& OHW_R5KCVTL
)
18115 fputs (" R5KCVTL", stdout
);
18119 fputs (" FILL ", stdout
);
18120 /* XXX Print content of info word? */
18124 fputs (" TAGS ", stdout
);
18125 /* XXX Print content of info word? */
18129 fputs (" HWAND ", stdout
);
18130 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
18131 fputs (" R4KEOP_CHECKED", stdout
);
18132 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
18133 fputs (" R4KEOP_CLEAN", stdout
);
18137 fputs (" HWOR ", stdout
);
18138 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
18139 fputs (" R4KEOP_CHECKED", stdout
);
18140 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
18141 fputs (" R4KEOP_CLEAN", stdout
);
18145 printf (" GP_GROUP %#06x self-contained %#06x",
18146 option
.info
& OGP_GROUP
,
18147 (option
.info
& OGP_SELF
) >> 16);
18151 printf (" IDENT %#06x self-contained %#06x",
18152 option
.info
& OGP_GROUP
,
18153 (option
.info
& OGP_SELF
) >> 16);
18157 /* This shouldn't happen. */
18158 printf (" %3d ??? %" PRId16
" %" PRIx32
,
18159 option
.kind
, option
.section
, option
.info
);
18163 len
= sizeof (* eopt
);
18164 while (len
< option
.size
)
18166 unsigned char datum
= *((unsigned char *) eoption
+ len
);
18168 if (ISPRINT (datum
))
18169 printf ("%c", datum
);
18171 printf ("\\%03o", datum
);
18174 fputs ("\n", stdout
);
18176 offset
+= option
.size
;
18184 if (conflicts_offset
!= 0 && conflictsno
!= 0)
18186 Elf32_Conflict
* iconf
;
18189 if (filedata
->dynamic_symbols
== NULL
)
18191 error (_("conflict list found without a dynamic symbol table\n"));
18195 /* PR 21345 - print a slightly more helpful error message
18196 if we are sure that the cmalloc will fail. */
18197 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
18199 error (_("Overlarge number of conflicts detected: %lx\n"),
18200 (long) conflictsno
);
18204 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
18207 error (_("Out of memory allocating space for dynamic conflicts\n"));
18213 Elf32_External_Conflict
* econf32
;
18215 econf32
= (Elf32_External_Conflict
*)
18216 get_data (NULL
, filedata
, conflicts_offset
,
18217 sizeof (*econf32
), conflictsno
, _("conflict"));
18224 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18225 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
18231 Elf64_External_Conflict
* econf64
;
18233 econf64
= (Elf64_External_Conflict
*)
18234 get_data (NULL
, filedata
, conflicts_offset
,
18235 sizeof (*econf64
), conflictsno
, _("conflict"));
18242 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18243 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
18248 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
18249 "\nSection '.conflict' contains %lu entries:\n",
18250 (unsigned long) conflictsno
),
18251 (unsigned long) conflictsno
);
18252 puts (_(" Num: Index Value Name"));
18254 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18256 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
18258 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
18259 printf (_("<corrupt symbol index>"));
18262 Elf_Internal_Sym
* psym
;
18264 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
18265 print_vma (psym
->st_value
, FULL_HEX
);
18267 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
18268 print_symbol (25, GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
18270 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18278 if (pltgot
!= 0 && local_gotno
!= 0)
18280 bfd_vma ent
, local_end
, global_end
;
18282 unsigned char * data
;
18283 unsigned char * data_end
;
18287 addr_size
= (is_32bit_elf
? 4 : 8);
18288 local_end
= pltgot
+ local_gotno
* addr_size
;
18290 /* PR binutils/17533 file: 012-111227-0.004 */
18291 if (symtabno
< gotsym
)
18293 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
18294 (unsigned long) gotsym
, (unsigned long) symtabno
);
18298 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
18299 /* PR 17531: file: 54c91a34. */
18300 if (global_end
< local_end
)
18302 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
18306 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
18307 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
18308 global_end
- pltgot
, 1,
18309 _("Global Offset Table data"));
18310 /* PR 12855: Null data is handled gracefully throughout. */
18311 data_end
= data
+ (global_end
- pltgot
);
18313 printf (_("\nPrimary GOT:\n"));
18314 printf (_(" Canonical gp value: "));
18315 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
18318 printf (_(" Reserved entries:\n"));
18319 printf (_(" %*s %10s %*s Purpose\n"),
18320 addr_size
* 2, _("Address"), _("Access"),
18321 addr_size
* 2, _("Initial"));
18322 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18323 printf (_(" Lazy resolver\n"));
18324 if (ent
== (bfd_vma
) -1)
18325 goto got_print_fail
;
18327 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
18328 This entry will be used by some runtime loaders, to store the
18329 module pointer. Otherwise this is an ordinary local entry.
18330 PR 21344: Check for the entry being fully available before
18333 && data
+ ent
- pltgot
+ addr_size
<= data_end
18334 && (byte_get (data
+ ent
- pltgot
, addr_size
)
18335 >> (addr_size
* 8 - 1)) != 0)
18337 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18338 printf (_(" Module pointer (GNU extension)\n"));
18339 if (ent
== (bfd_vma
) -1)
18340 goto got_print_fail
;
18344 if (data
!= NULL
&& ent
< local_end
)
18346 printf (_(" Local entries:\n"));
18347 printf (" %*s %10s %*s\n",
18348 addr_size
* 2, _("Address"), _("Access"),
18349 addr_size
* 2, _("Initial"));
18350 while (ent
< local_end
)
18352 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18354 if (ent
== (bfd_vma
) -1)
18355 goto got_print_fail
;
18360 if (data
!= NULL
&& gotsym
< symtabno
)
18364 printf (_(" Global entries:\n"));
18365 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
18366 addr_size
* 2, _("Address"),
18368 addr_size
* 2, _("Initial"),
18369 addr_size
* 2, _("Sym.Val."),
18371 /* Note for translators: "Ndx" = abbreviated form of "Index". */
18372 _("Ndx"), _("Name"));
18374 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
18376 for (i
= gotsym
; i
< symtabno
; i
++)
18378 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18381 if (filedata
->dynamic_symbols
== NULL
)
18382 printf (_("<no dynamic symbols>"));
18383 else if (i
< filedata
->num_dynamic_syms
)
18385 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
18387 print_vma (psym
->st_value
, LONG_HEX
);
18388 printf (" %-7s %3s ",
18389 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
18390 get_symbol_index_type (filedata
, psym
->st_shndx
));
18392 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
18393 print_symbol (sym_width
,
18394 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
18396 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18399 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
18400 (unsigned long) i
);
18403 if (ent
== (bfd_vma
) -1)
18413 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
18416 size_t offset
, rel_offset
;
18417 unsigned long count
, i
;
18418 unsigned char * data
;
18419 int addr_size
, sym_width
;
18420 Elf_Internal_Rela
* rels
;
18422 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
18423 if (pltrel
== DT_RELA
)
18425 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
18430 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
18435 addr_size
= (is_32bit_elf
? 4 : 8);
18436 end
= mips_pltgot
+ (2 + count
) * addr_size
;
18438 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
18439 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
18440 1, _("Procedure Linkage Table data"));
18447 printf ("\nPLT GOT:\n\n");
18448 printf (_(" Reserved entries:\n"));
18449 printf (_(" %*s %*s Purpose\n"),
18450 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
18451 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18452 printf (_(" PLT lazy resolver\n"));
18453 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18454 printf (_(" Module pointer\n"));
18457 printf (_(" Entries:\n"));
18458 printf (" %*s %*s %*s %-7s %3s %s\n",
18459 addr_size
* 2, _("Address"),
18460 addr_size
* 2, _("Initial"),
18461 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
18462 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
18463 for (i
= 0; i
< count
; i
++)
18465 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
18467 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18470 if (idx
>= filedata
->num_dynamic_syms
)
18471 printf (_("<corrupt symbol index: %lu>"), idx
);
18474 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
18476 print_vma (psym
->st_value
, LONG_HEX
);
18477 printf (" %-7s %3s ",
18478 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
18479 get_symbol_index_type (filedata
, psym
->st_shndx
));
18480 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
18481 print_symbol (sym_width
,
18482 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
18484 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18498 process_nds32_specific (Filedata
* filedata
)
18500 Elf_Internal_Shdr
*sect
= NULL
;
18502 sect
= find_section (filedata
, ".nds32_e_flags");
18503 if (sect
!= NULL
&& sect
->sh_size
>= 4)
18505 unsigned char *buf
;
18508 printf ("\nNDS32 elf flags section:\n");
18509 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
18510 _("NDS32 elf flags section"));
18515 flag
= byte_get (buf
, 4);
18517 switch (flag
& 0x3)
18520 printf ("(VEC_SIZE):\tNo entry.\n");
18523 printf ("(VEC_SIZE):\t4 bytes\n");
18526 printf ("(VEC_SIZE):\t16 bytes\n");
18529 printf ("(VEC_SIZE):\treserved\n");
18538 process_gnu_liblist (Filedata
* filedata
)
18540 Elf_Internal_Shdr
* section
;
18541 Elf_Internal_Shdr
* string_sec
;
18542 Elf32_External_Lib
* elib
;
18544 size_t strtab_size
;
18546 unsigned long num_liblist
;
18553 for (i
= 0, section
= filedata
->section_headers
;
18554 i
< filedata
->file_header
.e_shnum
;
18557 switch (section
->sh_type
)
18559 case SHT_GNU_LIBLIST
:
18560 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
18563 elib
= (Elf32_External_Lib
*)
18564 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
18565 _("liblist section data"));
18573 string_sec
= filedata
->section_headers
+ section
->sh_link
;
18574 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
18575 string_sec
->sh_size
,
18576 _("liblist string table"));
18578 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
18585 strtab_size
= string_sec
->sh_size
;
18587 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
18588 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
18589 "\nLibrary list section '%s' contains %lu entries:\n",
18591 printable_section_name (filedata
, section
),
18594 puts (_(" Library Time Stamp Checksum Version Flags"));
18596 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
18604 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
18605 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
18606 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
18607 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
18608 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
18610 tmp
= gmtime (&atime
);
18611 snprintf (timebuf
, sizeof (timebuf
),
18612 "%04u-%02u-%02uT%02u:%02u:%02u",
18613 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
18614 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
18616 printf ("%3lu: ", (unsigned long) cnt
);
18618 printf ("%-20s", liblist
.l_name
< strtab_size
18619 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
18621 printf ("%-20.20s", liblist
.l_name
< strtab_size
18622 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
18623 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
18624 liblist
.l_version
, liblist
.l_flags
);
18635 static const char *
18636 get_note_type (Filedata
* filedata
, unsigned e_type
)
18638 static char buff
[64];
18640 if (filedata
->file_header
.e_type
== ET_CORE
)
18644 return _("NT_AUXV (auxiliary vector)");
18646 return _("NT_PRSTATUS (prstatus structure)");
18648 return _("NT_FPREGSET (floating point registers)");
18650 return _("NT_PRPSINFO (prpsinfo structure)");
18651 case NT_TASKSTRUCT
:
18652 return _("NT_TASKSTRUCT (task structure)");
18654 return _("NT_GDB_TDESC (GDB XML target description)");
18656 return _("NT_PRXFPREG (user_xfpregs structure)");
18658 return _("NT_PPC_VMX (ppc Altivec registers)");
18660 return _("NT_PPC_VSX (ppc VSX registers)");
18662 return _("NT_PPC_TAR (ppc TAR register)");
18664 return _("NT_PPC_PPR (ppc PPR register)");
18666 return _("NT_PPC_DSCR (ppc DSCR register)");
18668 return _("NT_PPC_EBB (ppc EBB registers)");
18670 return _("NT_PPC_PMU (ppc PMU registers)");
18671 case NT_PPC_TM_CGPR
:
18672 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
18673 case NT_PPC_TM_CFPR
:
18674 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
18675 case NT_PPC_TM_CVMX
:
18676 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
18677 case NT_PPC_TM_CVSX
:
18678 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
18679 case NT_PPC_TM_SPR
:
18680 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
18681 case NT_PPC_TM_CTAR
:
18682 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
18683 case NT_PPC_TM_CPPR
:
18684 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
18685 case NT_PPC_TM_CDSCR
:
18686 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
18688 return _("NT_386_TLS (x86 TLS information)");
18689 case NT_386_IOPERM
:
18690 return _("NT_386_IOPERM (x86 I/O permissions)");
18691 case NT_X86_XSTATE
:
18692 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
18694 return _("NT_X86_CET (x86 CET state)");
18695 case NT_S390_HIGH_GPRS
:
18696 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
18697 case NT_S390_TIMER
:
18698 return _("NT_S390_TIMER (s390 timer register)");
18699 case NT_S390_TODCMP
:
18700 return _("NT_S390_TODCMP (s390 TOD comparator register)");
18701 case NT_S390_TODPREG
:
18702 return _("NT_S390_TODPREG (s390 TOD programmable register)");
18704 return _("NT_S390_CTRS (s390 control registers)");
18705 case NT_S390_PREFIX
:
18706 return _("NT_S390_PREFIX (s390 prefix register)");
18707 case NT_S390_LAST_BREAK
:
18708 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
18709 case NT_S390_SYSTEM_CALL
:
18710 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
18712 return _("NT_S390_TDB (s390 transaction diagnostic block)");
18713 case NT_S390_VXRS_LOW
:
18714 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
18715 case NT_S390_VXRS_HIGH
:
18716 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
18717 case NT_S390_GS_CB
:
18718 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
18719 case NT_S390_GS_BC
:
18720 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
18722 return _("NT_ARM_VFP (arm VFP registers)");
18724 return _("NT_ARM_TLS (AArch TLS registers)");
18725 case NT_ARM_HW_BREAK
:
18726 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
18727 case NT_ARM_HW_WATCH
:
18728 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
18730 return _("NT_ARM_SVE (AArch SVE registers)");
18731 case NT_ARM_PAC_MASK
:
18732 return _("NT_ARM_PAC_MASK (AArch pointer authentication code masks)");
18733 case NT_ARM_TAGGED_ADDR_CTRL
:
18734 return _("NT_ARM_TAGGED_ADDR_CTRL (AArch tagged address control)");
18736 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
18738 return _("NT_RISCV_CSR (RISC-V control and status registers)");
18740 return _("NT_PSTATUS (pstatus structure)");
18742 return _("NT_FPREGS (floating point registers)");
18744 return _("NT_PSINFO (psinfo structure)");
18746 return _("NT_LWPSTATUS (lwpstatus_t structure)");
18748 return _("NT_LWPSINFO (lwpsinfo_t structure)");
18749 case NT_WIN32PSTATUS
:
18750 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
18752 return _("NT_SIGINFO (siginfo_t data)");
18754 return _("NT_FILE (mapped files)");
18756 return _("NT_MEMTAG (memory tags)");
18764 return _("NT_VERSION (version)");
18766 return _("NT_ARCH (architecture)");
18767 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
18769 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
18775 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18780 print_core_note (Elf_Internal_Note
*pnote
)
18782 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
18783 bfd_vma count
, page_size
;
18784 unsigned char *descdata
, *filenames
, *descend
;
18786 if (pnote
->type
!= NT_FILE
)
18796 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
18797 /* Still "successful". */
18802 if (pnote
->descsz
< 2 * addr_size
)
18804 error (_(" Malformed note - too short for header\n"));
18808 descdata
= (unsigned char *) pnote
->descdata
;
18809 descend
= descdata
+ pnote
->descsz
;
18811 if (descdata
[pnote
->descsz
- 1] != '\0')
18813 error (_(" Malformed note - does not end with \\0\n"));
18817 count
= byte_get (descdata
, addr_size
);
18818 descdata
+= addr_size
;
18820 page_size
= byte_get (descdata
, addr_size
);
18821 descdata
+= addr_size
;
18823 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
18824 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
18826 error (_(" Malformed note - too short for supplied file count\n"));
18830 printf (_(" Page size: "));
18831 print_vma (page_size
, DEC
);
18834 printf (_(" %*s%*s%*s\n"),
18835 (int) (2 + 2 * addr_size
), _("Start"),
18836 (int) (4 + 2 * addr_size
), _("End"),
18837 (int) (4 + 2 * addr_size
), _("Page Offset"));
18838 filenames
= descdata
+ count
* 3 * addr_size
;
18839 while (count
-- > 0)
18841 bfd_vma start
, end
, file_ofs
;
18843 if (filenames
== descend
)
18845 error (_(" Malformed note - filenames end too early\n"));
18849 start
= byte_get (descdata
, addr_size
);
18850 descdata
+= addr_size
;
18851 end
= byte_get (descdata
, addr_size
);
18852 descdata
+= addr_size
;
18853 file_ofs
= byte_get (descdata
, addr_size
);
18854 descdata
+= addr_size
;
18857 print_vma (start
, FULL_HEX
);
18859 print_vma (end
, FULL_HEX
);
18861 print_vma (file_ofs
, FULL_HEX
);
18862 printf ("\n %s\n", filenames
);
18864 filenames
+= 1 + strlen ((char *) filenames
);
18870 static const char *
18871 get_gnu_elf_note_type (unsigned e_type
)
18873 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
18876 case NT_GNU_ABI_TAG
:
18877 return _("NT_GNU_ABI_TAG (ABI version tag)");
18879 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
18880 case NT_GNU_BUILD_ID
:
18881 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
18882 case NT_GNU_GOLD_VERSION
:
18883 return _("NT_GNU_GOLD_VERSION (gold version)");
18884 case NT_GNU_PROPERTY_TYPE_0
:
18885 return _("NT_GNU_PROPERTY_TYPE_0");
18886 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
18887 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
18888 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
18889 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
18892 static char buff
[64];
18894 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18901 decode_x86_compat_isa (unsigned int bitmask
)
18905 unsigned int bit
= bitmask
& (- bitmask
);
18910 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
18913 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
18916 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
18919 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
18922 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
18925 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
18928 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
18931 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
18934 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
18937 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
18940 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
18943 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
18944 printf ("AVX512F");
18946 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
18947 printf ("AVX512CD");
18949 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
18950 printf ("AVX512ER");
18952 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
18953 printf ("AVX512PF");
18955 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
18956 printf ("AVX512VL");
18958 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
18959 printf ("AVX512DQ");
18961 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
18962 printf ("AVX512BW");
18965 printf (_("<unknown: %x>"), bit
);
18974 decode_x86_compat_2_isa (unsigned int bitmask
)
18978 printf (_("<None>"));
18984 unsigned int bit
= bitmask
& (- bitmask
);
18989 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_CMOV
:
18992 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE
:
18995 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE2
:
18998 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE3
:
19001 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSSE3
:
19004 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_1
:
19007 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_2
:
19010 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX
:
19013 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX2
:
19016 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_FMA
:
19019 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512F
:
19020 printf ("AVX512F");
19022 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512CD
:
19023 printf ("AVX512CD");
19025 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512ER
:
19026 printf ("AVX512ER");
19028 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512PF
:
19029 printf ("AVX512PF");
19031 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512VL
:
19032 printf ("AVX512VL");
19034 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512DQ
:
19035 printf ("AVX512DQ");
19037 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512BW
:
19038 printf ("AVX512BW");
19040 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4FMAPS
:
19041 printf ("AVX512_4FMAPS");
19043 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4VNNIW
:
19044 printf ("AVX512_4VNNIW");
19046 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BITALG
:
19047 printf ("AVX512_BITALG");
19049 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_IFMA
:
19050 printf ("AVX512_IFMA");
19052 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI
:
19053 printf ("AVX512_VBMI");
19055 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI2
:
19056 printf ("AVX512_VBMI2");
19058 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VNNI
:
19059 printf ("AVX512_VNNI");
19061 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BF16
:
19062 printf ("AVX512_BF16");
19065 printf (_("<unknown: %x>"), bit
);
19074 decode_x86_isa (unsigned int bitmask
)
19078 unsigned int bit
= bitmask
& (- bitmask
);
19083 case GNU_PROPERTY_X86_ISA_1_BASELINE
:
19084 printf ("x86-64-baseline");
19086 case GNU_PROPERTY_X86_ISA_1_V2
:
19087 printf ("x86-64-v2");
19089 case GNU_PROPERTY_X86_ISA_1_V3
:
19090 printf ("x86-64-v3");
19092 case GNU_PROPERTY_X86_ISA_1_V4
:
19093 printf ("x86-64-v4");
19096 printf (_("<unknown: %x>"), bit
);
19105 decode_x86_feature_1 (unsigned int bitmask
)
19109 printf (_("<None>"));
19115 unsigned int bit
= bitmask
& (- bitmask
);
19120 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
19123 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
19126 case GNU_PROPERTY_X86_FEATURE_1_LAM_U48
:
19127 printf ("LAM_U48");
19129 case GNU_PROPERTY_X86_FEATURE_1_LAM_U57
:
19130 printf ("LAM_U57");
19133 printf (_("<unknown: %x>"), bit
);
19142 decode_x86_feature_2 (unsigned int bitmask
)
19146 printf (_("<None>"));
19152 unsigned int bit
= bitmask
& (- bitmask
);
19157 case GNU_PROPERTY_X86_FEATURE_2_X86
:
19160 case GNU_PROPERTY_X86_FEATURE_2_X87
:
19163 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
19166 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
19169 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
19172 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
19175 case GNU_PROPERTY_X86_FEATURE_2_TMM
:
19178 case GNU_PROPERTY_X86_FEATURE_2_MASK
:
19181 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
19184 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
19187 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
19188 printf ("XSAVEOPT");
19190 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
19194 printf (_("<unknown: %x>"), bit
);
19203 decode_aarch64_feature_1_and (unsigned int bitmask
)
19207 unsigned int bit
= bitmask
& (- bitmask
);
19212 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
19216 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
19221 printf (_("<unknown: %x>"), bit
);
19230 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
19232 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
19233 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
19234 unsigned int size
= is_32bit_elf
? 4 : 8;
19236 printf (_(" Properties: "));
19238 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
19240 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
19244 while (ptr
< ptr_end
)
19248 unsigned int datasz
;
19250 if ((size_t) (ptr_end
- ptr
) < 8)
19252 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
19256 type
= byte_get (ptr
, 4);
19257 datasz
= byte_get (ptr
+ 4, 4);
19261 if (datasz
> (size_t) (ptr_end
- ptr
))
19263 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
19268 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
19270 if (filedata
->file_header
.e_machine
== EM_X86_64
19271 || filedata
->file_header
.e_machine
== EM_IAMCU
19272 || filedata
->file_header
.e_machine
== EM_386
)
19274 unsigned int bitmask
;
19277 bitmask
= byte_get (ptr
, 4);
19283 case GNU_PROPERTY_X86_ISA_1_USED
:
19285 printf (_("x86 ISA used: <corrupt length: %#x> "),
19289 printf ("x86 ISA used: ");
19290 decode_x86_isa (bitmask
);
19294 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
19296 printf (_("x86 ISA needed: <corrupt length: %#x> "),
19300 printf ("x86 ISA needed: ");
19301 decode_x86_isa (bitmask
);
19305 case GNU_PROPERTY_X86_FEATURE_1_AND
:
19307 printf (_("x86 feature: <corrupt length: %#x> "),
19311 printf ("x86 feature: ");
19312 decode_x86_feature_1 (bitmask
);
19316 case GNU_PROPERTY_X86_FEATURE_2_USED
:
19318 printf (_("x86 feature used: <corrupt length: %#x> "),
19322 printf ("x86 feature used: ");
19323 decode_x86_feature_2 (bitmask
);
19327 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
19329 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
19332 printf ("x86 feature needed: ");
19333 decode_x86_feature_2 (bitmask
);
19337 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
19339 printf (_("x86 ISA used: <corrupt length: %#x> "),
19343 printf ("x86 ISA used: ");
19344 decode_x86_compat_isa (bitmask
);
19348 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
19350 printf (_("x86 ISA needed: <corrupt length: %#x> "),
19354 printf ("x86 ISA needed: ");
19355 decode_x86_compat_isa (bitmask
);
19359 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_USED
:
19361 printf (_("x86 ISA used: <corrupt length: %#x> "),
19365 printf ("x86 ISA used: ");
19366 decode_x86_compat_2_isa (bitmask
);
19370 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_NEEDED
:
19372 printf (_("x86 ISA needed: <corrupt length: %#x> "),
19376 printf ("x86 ISA needed: ");
19377 decode_x86_compat_2_isa (bitmask
);
19385 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
19387 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
19389 printf ("AArch64 feature: ");
19391 printf (_("<corrupt length: %#x> "), datasz
);
19393 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
19402 case GNU_PROPERTY_STACK_SIZE
:
19403 printf (_("stack size: "));
19404 if (datasz
!= size
)
19405 printf (_("<corrupt length: %#x> "), datasz
);
19407 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
19410 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
19411 printf ("no copy on protected ");
19413 printf (_("<corrupt length: %#x> "), datasz
);
19421 if (type
< GNU_PROPERTY_LOPROC
)
19422 printf (_("<unknown type %#x data: "), type
);
19423 else if (type
< GNU_PROPERTY_LOUSER
)
19424 printf (_("<processor-specific type %#x data: "), type
);
19426 printf (_("<application-specific type %#x data: "), type
);
19427 for (j
= 0; j
< datasz
; ++j
)
19428 printf ("%02x ", ptr
[j
] & 0xff);
19432 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
19433 if (ptr
== ptr_end
)
19446 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
19448 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
19449 switch (pnote
->type
)
19451 case NT_GNU_BUILD_ID
:
19455 printf (_(" Build ID: "));
19456 for (i
= 0; i
< pnote
->descsz
; ++i
)
19457 printf ("%02x", pnote
->descdata
[i
] & 0xff);
19462 case NT_GNU_ABI_TAG
:
19464 unsigned long os
, major
, minor
, subminor
;
19465 const char *osname
;
19467 /* PR 17531: file: 030-599401-0.004. */
19468 if (pnote
->descsz
< 16)
19470 printf (_(" <corrupt GNU_ABI_TAG>\n"));
19474 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19475 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19476 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
19477 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
19481 case GNU_ABI_TAG_LINUX
:
19484 case GNU_ABI_TAG_HURD
:
19487 case GNU_ABI_TAG_SOLARIS
:
19488 osname
= "Solaris";
19490 case GNU_ABI_TAG_FREEBSD
:
19491 osname
= "FreeBSD";
19493 case GNU_ABI_TAG_NETBSD
:
19496 case GNU_ABI_TAG_SYLLABLE
:
19497 osname
= "Syllable";
19499 case GNU_ABI_TAG_NACL
:
19503 osname
= "Unknown";
19507 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
19508 major
, minor
, subminor
);
19512 case NT_GNU_GOLD_VERSION
:
19516 printf (_(" Version: "));
19517 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
19518 printf ("%c", pnote
->descdata
[i
]);
19525 unsigned long num_entries
, mask
;
19527 /* Hardware capabilities information. Word 0 is the number of entries.
19528 Word 1 is a bitmask of enabled entries. The rest of the descriptor
19529 is a series of entries, where each entry is a single byte followed
19530 by a nul terminated string. The byte gives the bit number to test
19531 if enabled in the bitmask. */
19532 printf (_(" Hardware Capabilities: "));
19533 if (pnote
->descsz
< 8)
19535 error (_("<corrupt GNU_HWCAP>\n"));
19538 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19539 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19540 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
19541 /* FIXME: Add code to display the entries... */
19545 case NT_GNU_PROPERTY_TYPE_0
:
19546 print_gnu_property_note (filedata
, pnote
);
19550 /* Handle unrecognised types. An error message should have already been
19551 created by get_gnu_elf_note_type(), so all that we need to do is to
19552 display the data. */
19556 printf (_(" Description data: "));
19557 for (i
= 0; i
< pnote
->descsz
; ++i
)
19558 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19567 static const char *
19568 get_v850_elf_note_type (enum v850_notes n_type
)
19570 static char buff
[64];
19574 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
19575 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
19576 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
19577 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
19578 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
19579 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
19581 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
19587 print_v850_note (Elf_Internal_Note
* pnote
)
19591 if (pnote
->descsz
!= 4)
19594 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
19598 printf (_("not set\n"));
19602 switch (pnote
->type
)
19604 case V850_NOTE_ALIGNMENT
:
19607 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return true;
19608 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return true;
19612 case V850_NOTE_DATA_SIZE
:
19615 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return true;
19616 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return true;
19620 case V850_NOTE_FPU_INFO
:
19623 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return true;
19624 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return true;
19628 case V850_NOTE_MMU_INFO
:
19629 case V850_NOTE_CACHE_INFO
:
19630 case V850_NOTE_SIMD_INFO
:
19631 if (val
== EF_RH850_SIMD
)
19633 printf (_("yes\n"));
19639 /* An 'unknown note type' message will already have been displayed. */
19643 printf (_("unknown value: %x\n"), val
);
19648 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
19650 unsigned int version
;
19652 switch (pnote
->type
)
19654 case NT_NETBSD_IDENT
:
19655 if (pnote
->descsz
< 1)
19657 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
19658 if ((version
/ 10000) % 100)
19659 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
19660 version
, version
/ 100000000, (version
/ 1000000) % 100,
19661 (version
/ 10000) % 100 > 26 ? "Z" : "",
19662 'A' + (version
/ 10000) % 26);
19664 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
19665 version
, version
/ 100000000, (version
/ 1000000) % 100,
19666 (version
/ 100) % 100);
19669 case NT_NETBSD_MARCH
:
19670 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
19674 case NT_NETBSD_PAX
:
19675 if (pnote
->descsz
< 1)
19677 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
19678 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
19679 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
19680 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
19681 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
19682 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
19683 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
19684 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
19688 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
19689 pnote
->descsz
, pnote
->type
);
19693 static const char *
19694 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
19698 case NT_FREEBSD_THRMISC
:
19699 return _("NT_THRMISC (thrmisc structure)");
19700 case NT_FREEBSD_PROCSTAT_PROC
:
19701 return _("NT_PROCSTAT_PROC (proc data)");
19702 case NT_FREEBSD_PROCSTAT_FILES
:
19703 return _("NT_PROCSTAT_FILES (files data)");
19704 case NT_FREEBSD_PROCSTAT_VMMAP
:
19705 return _("NT_PROCSTAT_VMMAP (vmmap data)");
19706 case NT_FREEBSD_PROCSTAT_GROUPS
:
19707 return _("NT_PROCSTAT_GROUPS (groups data)");
19708 case NT_FREEBSD_PROCSTAT_UMASK
:
19709 return _("NT_PROCSTAT_UMASK (umask data)");
19710 case NT_FREEBSD_PROCSTAT_RLIMIT
:
19711 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
19712 case NT_FREEBSD_PROCSTAT_OSREL
:
19713 return _("NT_PROCSTAT_OSREL (osreldate data)");
19714 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
19715 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
19716 case NT_FREEBSD_PROCSTAT_AUXV
:
19717 return _("NT_PROCSTAT_AUXV (auxv data)");
19718 case NT_FREEBSD_PTLWPINFO
:
19719 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
19721 return get_note_type (filedata
, e_type
);
19724 static const char *
19725 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
19727 static char buff
[64];
19731 case NT_NETBSDCORE_PROCINFO
:
19732 /* NetBSD core "procinfo" structure. */
19733 return _("NetBSD procinfo structure");
19735 case NT_NETBSDCORE_AUXV
:
19736 return _("NetBSD ELF auxiliary vector data");
19738 case NT_NETBSDCORE_LWPSTATUS
:
19739 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
19742 /* As of Jan 2020 there are no other machine-independent notes
19743 defined for NetBSD core files. If the note type is less
19744 than the start of the machine-dependent note types, we don't
19747 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
19749 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19755 switch (filedata
->file_header
.e_machine
)
19757 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
19758 and PT_GETFPREGS == mach+2. */
19763 case EM_SPARC32PLUS
:
19767 case NT_NETBSDCORE_FIRSTMACH
+ 0:
19768 return _("PT_GETREGS (reg structure)");
19769 case NT_NETBSDCORE_FIRSTMACH
+ 2:
19770 return _("PT_GETFPREGS (fpreg structure)");
19776 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
19777 There's also old PT___GETREGS40 == mach + 1 for old reg
19778 structure which lacks GBR. */
19782 case NT_NETBSDCORE_FIRSTMACH
+ 1:
19783 return _("PT___GETREGS40 (old reg structure)");
19784 case NT_NETBSDCORE_FIRSTMACH
+ 3:
19785 return _("PT_GETREGS (reg structure)");
19786 case NT_NETBSDCORE_FIRSTMACH
+ 5:
19787 return _("PT_GETFPREGS (fpreg structure)");
19793 /* On all other arch's, PT_GETREGS == mach+1 and
19794 PT_GETFPREGS == mach+3. */
19798 case NT_NETBSDCORE_FIRSTMACH
+ 1:
19799 return _("PT_GETREGS (reg structure)");
19800 case NT_NETBSDCORE_FIRSTMACH
+ 3:
19801 return _("PT_GETFPREGS (fpreg structure)");
19807 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
19808 e_type
- NT_NETBSDCORE_FIRSTMACH
);
19812 static const char *
19813 get_stapsdt_note_type (unsigned e_type
)
19815 static char buff
[64];
19820 return _("NT_STAPSDT (SystemTap probe descriptors)");
19826 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19831 print_stapsdt_note (Elf_Internal_Note
*pnote
)
19833 size_t len
, maxlen
;
19834 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
19835 char *data
= pnote
->descdata
;
19836 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
19837 bfd_vma pc
, base_addr
, semaphore
;
19838 char *provider
, *probe
, *arg_fmt
;
19840 if (pnote
->descsz
< (addr_size
* 3))
19841 goto stapdt_note_too_small
;
19843 pc
= byte_get ((unsigned char *) data
, addr_size
);
19846 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
19849 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
19852 if (data
>= data_end
)
19853 goto stapdt_note_too_small
;
19854 maxlen
= data_end
- data
;
19855 len
= strnlen (data
, maxlen
);
19862 goto stapdt_note_too_small
;
19864 if (data
>= data_end
)
19865 goto stapdt_note_too_small
;
19866 maxlen
= data_end
- data
;
19867 len
= strnlen (data
, maxlen
);
19874 goto stapdt_note_too_small
;
19876 if (data
>= data_end
)
19877 goto stapdt_note_too_small
;
19878 maxlen
= data_end
- data
;
19879 len
= strnlen (data
, maxlen
);
19886 goto stapdt_note_too_small
;
19888 printf (_(" Provider: %s\n"), provider
);
19889 printf (_(" Name: %s\n"), probe
);
19890 printf (_(" Location: "));
19891 print_vma (pc
, FULL_HEX
);
19892 printf (_(", Base: "));
19893 print_vma (base_addr
, FULL_HEX
);
19894 printf (_(", Semaphore: "));
19895 print_vma (semaphore
, FULL_HEX
);
19897 printf (_(" Arguments: %s\n"), arg_fmt
);
19899 return data
== data_end
;
19901 stapdt_note_too_small
:
19902 printf (_(" <corrupt - note is too small>\n"));
19903 error (_("corrupt stapdt note - the data size is too small\n"));
19907 static const char *
19908 get_ia64_vms_note_type (unsigned e_type
)
19910 static char buff
[64];
19915 return _("NT_VMS_MHD (module header)");
19917 return _("NT_VMS_LNM (language name)");
19919 return _("NT_VMS_SRC (source files)");
19921 return "NT_VMS_TITLE";
19923 return _("NT_VMS_EIDC (consistency check)");
19924 case NT_VMS_FPMODE
:
19925 return _("NT_VMS_FPMODE (FP mode)");
19926 case NT_VMS_LINKTIME
:
19927 return "NT_VMS_LINKTIME";
19928 case NT_VMS_IMGNAM
:
19929 return _("NT_VMS_IMGNAM (image name)");
19931 return _("NT_VMS_IMGID (image id)");
19932 case NT_VMS_LINKID
:
19933 return _("NT_VMS_LINKID (link id)");
19934 case NT_VMS_IMGBID
:
19935 return _("NT_VMS_IMGBID (build id)");
19936 case NT_VMS_GSTNAM
:
19937 return _("NT_VMS_GSTNAM (sym table name)");
19938 case NT_VMS_ORIG_DYN
:
19939 return "NT_VMS_ORIG_DYN";
19940 case NT_VMS_PATCHTIME
:
19941 return "NT_VMS_PATCHTIME";
19943 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19949 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
19951 int maxlen
= pnote
->descsz
;
19953 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
19954 goto desc_size_fail
;
19956 switch (pnote
->type
)
19960 goto desc_size_fail
;
19962 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
19964 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
19965 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
19966 if (l
+ 34 < maxlen
)
19968 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
19969 if (l
+ 35 < maxlen
)
19970 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
19972 printf (_(" Module version : <missing>\n"));
19976 printf (_(" Module name : <missing>\n"));
19977 printf (_(" Module version : <missing>\n"));
19982 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
19986 case NT_VMS_FPMODE
:
19987 printf (_(" Floating Point mode: "));
19989 goto desc_size_fail
;
19990 /* FIXME: Generate an error if descsz > 8 ? */
19992 printf ("0x%016" BFD_VMA_FMT
"x\n",
19993 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19996 case NT_VMS_LINKTIME
:
19997 printf (_(" Link time: "));
19999 goto desc_size_fail
;
20000 /* FIXME: Generate an error if descsz > 8 ? */
20003 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
20007 case NT_VMS_PATCHTIME
:
20008 printf (_(" Patch time: "));
20010 goto desc_size_fail
;
20011 /* FIXME: Generate an error if descsz > 8 ? */
20014 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
20018 case NT_VMS_ORIG_DYN
:
20020 goto desc_size_fail
;
20022 printf (_(" Major id: %u, minor id: %u\n"),
20023 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
20024 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
20025 printf (_(" Last modified : "));
20027 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
20028 printf (_("\n Link flags : "));
20029 printf ("0x%016" BFD_VMA_FMT
"x\n",
20030 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
20031 printf (_(" Header flags: 0x%08x\n"),
20032 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
20033 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
20037 case NT_VMS_IMGNAM
:
20038 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
20041 case NT_VMS_GSTNAM
:
20042 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
20046 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
20049 case NT_VMS_LINKID
:
20050 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
20060 printf (_(" <corrupt - data size is too small>\n"));
20061 error (_("corrupt IA64 note: data size is too small\n"));
20065 struct build_attr_cache
{
20066 Filedata
*filedata
;
20068 unsigned long strtablen
;
20069 Elf_Internal_Sym
*symtab
;
20070 unsigned long nsyms
;
20073 /* Find the symbol associated with a build attribute that is attached
20074 to address OFFSET. If PNAME is non-NULL then store the name of
20075 the symbol (if found) in the provided pointer, Returns NULL if a
20076 symbol could not be found. */
20078 static Elf_Internal_Sym
*
20079 get_symbol_for_build_attribute (Filedata
*filedata
,
20080 unsigned long offset
,
20082 const char **pname
)
20084 Elf_Internal_Sym
*saved_sym
= NULL
;
20085 Elf_Internal_Sym
*sym
;
20087 if (filedata
->section_headers
!= NULL
20088 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
20090 Elf_Internal_Shdr
* symsec
;
20092 free (ba_cache
.strtab
);
20093 ba_cache
.strtab
= NULL
;
20094 free (ba_cache
.symtab
);
20095 ba_cache
.symtab
= NULL
;
20097 /* Load the symbol and string sections. */
20098 for (symsec
= filedata
->section_headers
;
20099 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
20102 if (symsec
->sh_type
== SHT_SYMTAB
20103 && get_symtab (filedata
, symsec
,
20104 &ba_cache
.symtab
, &ba_cache
.nsyms
,
20105 &ba_cache
.strtab
, &ba_cache
.strtablen
))
20108 ba_cache
.filedata
= filedata
;
20111 if (ba_cache
.symtab
== NULL
)
20114 /* Find a symbol whose value matches offset. */
20115 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
20116 if (sym
->st_value
== offset
)
20118 if (sym
->st_name
>= ba_cache
.strtablen
)
20119 /* Huh ? This should not happen. */
20122 if (ba_cache
.strtab
[sym
->st_name
] == 0)
20125 /* The AArch64 and ARM architectures define mapping symbols
20126 (eg $d, $x, $t) which we want to ignore. */
20127 if (ba_cache
.strtab
[sym
->st_name
] == '$'
20128 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
20129 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
20134 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
20135 and FILE or OBJECT symbols over NOTYPE symbols. We skip
20136 FUNC symbols entirely. */
20137 switch (ELF_ST_TYPE (sym
->st_info
))
20144 /* If the symbol has a size associated
20145 with it then we can stop searching. */
20146 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
20151 /* Ignore function symbols. */
20158 switch (ELF_ST_BIND (sym
->st_info
))
20161 if (saved_sym
== NULL
20162 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
20167 if (saved_sym
== NULL
)
20177 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
20185 if (saved_sym
&& pname
)
20186 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
20191 /* Returns true iff addr1 and addr2 are in the same section. */
20194 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
20196 Elf_Internal_Shdr
* a1
;
20197 Elf_Internal_Shdr
* a2
;
20199 a1
= find_section_by_address (filedata
, addr1
);
20200 a2
= find_section_by_address (filedata
, addr2
);
20202 return a1
== a2
&& a1
!= NULL
;
20206 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
20207 Filedata
* filedata
)
20209 static unsigned long global_offset
= 0;
20210 static unsigned long global_end
= 0;
20211 static unsigned long func_offset
= 0;
20212 static unsigned long func_end
= 0;
20214 Elf_Internal_Sym
*sym
;
20216 unsigned long start
;
20218 bool is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
20220 switch (pnote
->descsz
)
20223 /* A zero-length description means that the range of
20224 the previous note of the same type should be used. */
20227 if (global_end
> global_offset
)
20228 printf (_(" Applies to region from %#lx to %#lx\n"),
20229 global_offset
, global_end
);
20231 printf (_(" Applies to region from %#lx\n"), global_offset
);
20235 if (func_end
> func_offset
)
20236 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
20238 printf (_(" Applies to region from %#lx\n"), func_offset
);
20243 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20248 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20249 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
20253 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
20254 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
20258 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
20259 printf (_(" <invalid descsz>"));
20264 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
20265 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
20266 in order to avoid them being confused with the start address of the
20267 first function in the file... */
20268 if (sym
== NULL
&& is_open_attr
)
20269 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
20272 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
20273 end
= start
+ sym
->st_size
;
20277 /* FIXME: Need to properly allow for section alignment.
20278 16 is just the alignment used on x86_64. */
20280 && start
> BFD_ALIGN (global_end
, 16)
20281 /* Build notes are not guaranteed to be organised in order of
20282 increasing address, but we should find the all of the notes
20283 for one section in the same place. */
20284 && same_section (filedata
, start
, global_end
))
20285 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
20286 global_end
+ 1, start
- 1);
20288 printf (_(" Applies to region from %#lx"), start
);
20289 global_offset
= start
;
20293 printf (_(" to %#lx"), end
);
20299 printf (_(" Applies to region from %#lx"), start
);
20300 func_offset
= start
;
20304 printf (_(" to %#lx"), end
);
20310 printf (_(" (%s)"), name
);
20317 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
20319 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
20320 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
20321 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
20323 char name_attribute
;
20324 const char * expected_types
;
20325 const char * name
= pnote
->namedata
;
20329 if (name
== NULL
|| pnote
->namesz
< 2)
20331 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
20332 print_symbol (-20, _(" <corrupt name>"));
20341 /* Version 2 of the spec adds a "GA" prefix to the name field. */
20342 if (name
[0] == 'G' && name
[1] == 'A')
20344 if (pnote
->namesz
< 4)
20346 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
20347 print_symbol (-20, _(" <corrupt name>"));
20356 switch ((name_type
= * name
))
20358 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
20359 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
20360 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
20361 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
20362 printf ("%c", * name
);
20366 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
20367 print_symbol (-20, _("<unknown name type>"));
20374 switch ((name_attribute
= * name
))
20376 case GNU_BUILD_ATTRIBUTE_VERSION
:
20377 text
= _("<version>");
20378 expected_types
= string_expected
;
20381 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
20382 text
= _("<stack prot>");
20383 expected_types
= "!+*";
20386 case GNU_BUILD_ATTRIBUTE_RELRO
:
20387 text
= _("<relro>");
20388 expected_types
= bool_expected
;
20391 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
20392 text
= _("<stack size>");
20393 expected_types
= number_expected
;
20396 case GNU_BUILD_ATTRIBUTE_TOOL
:
20397 text
= _("<tool>");
20398 expected_types
= string_expected
;
20401 case GNU_BUILD_ATTRIBUTE_ABI
:
20403 expected_types
= "$*";
20406 case GNU_BUILD_ATTRIBUTE_PIC
:
20408 expected_types
= number_expected
;
20411 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
20412 text
= _("<short enum>");
20413 expected_types
= bool_expected
;
20417 if (ISPRINT (* name
))
20419 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
20421 if (len
> left
&& ! do_wide
)
20423 printf ("%.*s:", len
, name
);
20429 static char tmpbuf
[128];
20431 error (_("unrecognised byte in name field: %d\n"), * name
);
20432 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
20436 expected_types
= "*$!+";
20441 left
-= printf ("%s", text
);
20443 if (strchr (expected_types
, name_type
) == NULL
)
20444 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
20446 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
20448 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
20449 (unsigned long) pnote
->namesz
,
20450 (long) (name
- pnote
->namedata
));
20454 if (left
< 1 && ! do_wide
)
20459 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
20461 unsigned int bytes
;
20462 unsigned long long val
= 0;
20463 unsigned int shift
= 0;
20464 char * decoded
= NULL
;
20466 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
20468 /* The -1 is because the name field is always 0 terminated, and we
20469 want to be able to ensure that the shift in the while loop below
20470 will not overflow. */
20473 if (bytes
> sizeof (val
))
20475 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
20477 bytes
= sizeof (val
);
20479 /* We do not bother to warn if bytes == 0 as this can
20480 happen with some early versions of the gcc plugin. */
20484 unsigned long long byte
= *name
++ & 0xff;
20486 val
|= byte
<< shift
;
20490 switch (name_attribute
)
20492 case GNU_BUILD_ATTRIBUTE_PIC
:
20495 case 0: decoded
= "static"; break;
20496 case 1: decoded
= "pic"; break;
20497 case 2: decoded
= "PIC"; break;
20498 case 3: decoded
= "pie"; break;
20499 case 4: decoded
= "PIE"; break;
20503 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
20506 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
20507 case 0: decoded
= "off"; break;
20508 case 1: decoded
= "on"; break;
20509 case 2: decoded
= "all"; break;
20510 case 3: decoded
= "strong"; break;
20511 case 4: decoded
= "explicit"; break;
20519 if (decoded
!= NULL
)
20521 print_symbol (-left
, decoded
);
20532 left
-= printf ("0x%llx", val
);
20534 left
-= printf ("0x%-.*llx", left
, val
);
20538 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
20539 left
-= print_symbol (- left
, name
);
20541 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
20542 left
-= print_symbol (- left
, "true");
20544 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
20545 left
-= print_symbol (- left
, "false");
20549 if (do_wide
&& left
> 0)
20550 printf ("%-*s", left
, " ");
20555 /* Note that by the ELF standard, the name field is already null byte
20556 terminated, and namesz includes the terminating null byte.
20557 I.E. the value of namesz for the name "FSF" is 4.
20559 If the value of namesz is zero, there is no name present. */
20562 process_note (Elf_Internal_Note
* pnote
,
20563 Filedata
* filedata
)
20565 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
20568 if (pnote
->namesz
== 0)
20569 /* If there is no note name, then use the default set of
20570 note type strings. */
20571 nt
= get_note_type (filedata
, pnote
->type
);
20573 else if (startswith (pnote
->namedata
, "GNU"))
20574 /* GNU-specific object file notes. */
20575 nt
= get_gnu_elf_note_type (pnote
->type
);
20577 else if (startswith (pnote
->namedata
, "FreeBSD"))
20578 /* FreeBSD-specific core file notes. */
20579 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
20581 else if (startswith (pnote
->namedata
, "NetBSD-CORE"))
20582 /* NetBSD-specific core file notes. */
20583 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
20585 else if (startswith (pnote
->namedata
, "NetBSD"))
20586 /* NetBSD-specific core file notes. */
20587 return process_netbsd_elf_note (pnote
);
20589 else if (startswith (pnote
->namedata
, "PaX"))
20590 /* NetBSD-specific core file notes. */
20591 return process_netbsd_elf_note (pnote
);
20593 else if (startswith (pnote
->namedata
, "SPU/"))
20595 /* SPU-specific core file notes. */
20596 nt
= pnote
->namedata
+ 4;
20600 else if (startswith (pnote
->namedata
, "IPF/VMS"))
20601 /* VMS/ia64-specific file notes. */
20602 nt
= get_ia64_vms_note_type (pnote
->type
);
20604 else if (startswith (pnote
->namedata
, "stapsdt"))
20605 nt
= get_stapsdt_note_type (pnote
->type
);
20608 /* Don't recognize this note name; just use the default set of
20609 note type strings. */
20610 nt
= get_note_type (filedata
, pnote
->type
);
20614 if (((startswith (pnote
->namedata
, "GA")
20615 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
20616 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
20617 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
20618 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
20619 print_gnu_build_attribute_name (pnote
);
20621 print_symbol (-20, name
);
20624 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
20626 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
20628 if (startswith (pnote
->namedata
, "IPF/VMS"))
20629 return print_ia64_vms_note (pnote
);
20630 else if (startswith (pnote
->namedata
, "GNU"))
20631 return print_gnu_note (filedata
, pnote
);
20632 else if (startswith (pnote
->namedata
, "stapsdt"))
20633 return print_stapsdt_note (pnote
);
20634 else if (startswith (pnote
->namedata
, "CORE"))
20635 return print_core_note (pnote
);
20636 else if (((startswith (pnote
->namedata
, "GA")
20637 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
20638 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
20639 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
20640 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
20641 return print_gnu_build_attribute_description (pnote
, filedata
);
20647 printf (_(" description data: "));
20648 for (i
= 0; i
< pnote
->descsz
; i
++)
20649 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
20661 process_notes_at (Filedata
* filedata
,
20662 Elf_Internal_Shdr
* section
,
20667 Elf_External_Note
*pnotes
;
20668 Elf_External_Note
*external
;
20677 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
20680 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
20688 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
20691 if (pnotes
== NULL
)
20696 if (filedata
->is_separate
)
20697 printf (_("In linked file '%s': "), filedata
->file_name
);
20701 printf (_("Displaying notes found in: %s\n"), printable_section_name (filedata
, section
));
20703 printf (_("Displaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
20704 (unsigned long) offset
, (unsigned long) length
);
20706 /* NB: Some note sections may have alignment value of 0 or 1. gABI
20707 specifies that notes should be aligned to 4 bytes in 32-bit
20708 objects and to 8 bytes in 64-bit objects. As a Linux extension,
20709 we also support 4 byte alignment in 64-bit objects. If section
20710 alignment is less than 4, we treate alignment as 4 bytes. */
20713 else if (align
!= 4 && align
!= 8)
20715 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
20721 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
20723 end
= (char *) pnotes
+ length
;
20724 while ((char *) external
< end
)
20726 Elf_Internal_Note inote
;
20729 char * temp
= NULL
;
20730 size_t data_remaining
= end
- (char *) external
;
20732 if (!is_ia64_vms (filedata
))
20734 /* PR binutils/15191
20735 Make sure that there is enough data to read. */
20736 min_notesz
= offsetof (Elf_External_Note
, name
);
20737 if (data_remaining
< min_notesz
)
20739 warn (ngettext ("Corrupt note: only %ld byte remains, "
20740 "not enough for a full note\n",
20741 "Corrupt note: only %ld bytes remain, "
20742 "not enough for a full note\n",
20744 (long) data_remaining
);
20747 data_remaining
-= min_notesz
;
20749 inote
.type
= BYTE_GET (external
->type
);
20750 inote
.namesz
= BYTE_GET (external
->namesz
);
20751 inote
.namedata
= external
->name
;
20752 inote
.descsz
= BYTE_GET (external
->descsz
);
20753 inote
.descdata
= ((char *) external
20754 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
20755 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20756 next
= ((char *) external
20757 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
20761 Elf64_External_VMS_Note
*vms_external
;
20763 /* PR binutils/15191
20764 Make sure that there is enough data to read. */
20765 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
20766 if (data_remaining
< min_notesz
)
20768 warn (ngettext ("Corrupt note: only %ld byte remains, "
20769 "not enough for a full note\n",
20770 "Corrupt note: only %ld bytes remain, "
20771 "not enough for a full note\n",
20773 (long) data_remaining
);
20776 data_remaining
-= min_notesz
;
20778 vms_external
= (Elf64_External_VMS_Note
*) external
;
20779 inote
.type
= BYTE_GET (vms_external
->type
);
20780 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
20781 inote
.namedata
= vms_external
->name
;
20782 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
20783 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
20784 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20785 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
20788 /* PR 17531: file: 3443835e. */
20789 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
20790 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
20791 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
20792 || (size_t) (next
- inote
.descdata
) < inote
.descsz
20793 || ((size_t) (next
- inote
.descdata
)
20794 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
20796 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
20797 (unsigned long) ((char *) external
- (char *) pnotes
));
20798 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
20799 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
20803 external
= (Elf_External_Note
*) next
;
20805 /* Verify that name is null terminated. It appears that at least
20806 one version of Linux (RedHat 6.0) generates corefiles that don't
20807 comply with the ELF spec by failing to include the null byte in
20809 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
20811 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
20813 temp
= (char *) malloc (inote
.namesz
+ 1);
20816 error (_("Out of memory allocating space for inote name\n"));
20821 memcpy (temp
, inote
.namedata
, inote
.namesz
);
20822 inote
.namedata
= temp
;
20824 inote
.namedata
[inote
.namesz
] = 0;
20827 if (! process_note (& inote
, filedata
))
20840 process_corefile_note_segments (Filedata
* filedata
)
20842 Elf_Internal_Phdr
*segment
;
20846 if (! get_program_headers (filedata
))
20849 for (i
= 0, segment
= filedata
->program_headers
;
20850 i
< filedata
->file_header
.e_phnum
;
20853 if (segment
->p_type
== PT_NOTE
)
20854 if (! process_notes_at (filedata
, NULL
,
20855 (bfd_vma
) segment
->p_offset
,
20856 (bfd_vma
) segment
->p_filesz
,
20857 (bfd_vma
) segment
->p_align
))
20865 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
20867 Elf_External_Note
* pnotes
;
20868 Elf_External_Note
* external
;
20875 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
20877 if (pnotes
== NULL
)
20881 end
= (char*) pnotes
+ length
;
20883 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
20884 (unsigned long) offset
, (unsigned long) length
);
20886 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
20888 Elf_External_Note
* next
;
20889 Elf_Internal_Note inote
;
20891 inote
.type
= BYTE_GET (external
->type
);
20892 inote
.namesz
= BYTE_GET (external
->namesz
);
20893 inote
.namedata
= external
->name
;
20894 inote
.descsz
= BYTE_GET (external
->descsz
);
20895 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
20896 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20898 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
20900 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
20901 inote
.descdata
= inote
.namedata
;
20905 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
20907 if ( ((char *) next
> end
)
20908 || ((char *) next
< (char *) pnotes
))
20910 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
20911 (unsigned long) ((char *) external
- (char *) pnotes
));
20912 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
20913 inote
.type
, inote
.namesz
, inote
.descsz
);
20919 /* Prevent out-of-bounds indexing. */
20920 if ( inote
.namedata
+ inote
.namesz
> end
20921 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
20923 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
20924 (unsigned long) ((char *) external
- (char *) pnotes
));
20925 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
20926 inote
.type
, inote
.namesz
, inote
.descsz
);
20930 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
20932 if (! print_v850_note (& inote
))
20935 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
20936 inote
.namesz
, inote
.descsz
);
20946 process_note_sections (Filedata
* filedata
)
20948 Elf_Internal_Shdr
*section
;
20950 unsigned int n
= 0;
20953 for (i
= 0, section
= filedata
->section_headers
;
20954 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
20957 if (section
->sh_type
== SHT_NOTE
)
20959 if (! process_notes_at (filedata
, section
,
20960 (bfd_vma
) section
->sh_offset
,
20961 (bfd_vma
) section
->sh_size
,
20962 (bfd_vma
) section
->sh_addralign
))
20967 if (( filedata
->file_header
.e_machine
== EM_V800
20968 || filedata
->file_header
.e_machine
== EM_V850
20969 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
20970 && section
->sh_type
== SHT_RENESAS_INFO
)
20972 if (! process_v850_notes (filedata
,
20973 (bfd_vma
) section
->sh_offset
,
20974 (bfd_vma
) section
->sh_size
))
20981 /* Try processing NOTE segments instead. */
20982 return process_corefile_note_segments (filedata
);
20988 process_notes (Filedata
* filedata
)
20990 /* If we have not been asked to display the notes then do nothing. */
20994 if (filedata
->file_header
.e_type
!= ET_CORE
)
20995 return process_note_sections (filedata
);
20997 /* No program headers means no NOTE segment. */
20998 if (filedata
->file_header
.e_phnum
> 0)
20999 return process_corefile_note_segments (filedata
);
21001 if (filedata
->is_separate
)
21002 printf (_("No notes found in linked file '%s'.\n"),
21003 filedata
->file_name
);
21005 printf (_("No notes found file.\n"));
21010 static unsigned char *
21011 display_public_gnu_attributes (unsigned char * start
,
21012 const unsigned char * const end
)
21014 printf (_(" Unknown GNU attribute: %s\n"), start
);
21016 start
+= strnlen ((char *) start
, end
- start
);
21017 display_raw_attribute (start
, end
);
21019 return (unsigned char *) end
;
21022 static unsigned char *
21023 display_generic_attribute (unsigned char * start
,
21025 const unsigned char * const end
)
21028 return (unsigned char *) end
;
21030 return display_tag_value (tag
, start
, end
);
21034 process_arch_specific (Filedata
* filedata
)
21039 switch (filedata
->file_header
.e_machine
)
21042 case EM_ARC_COMPACT
:
21043 case EM_ARC_COMPACT2
:
21044 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
21045 display_arc_attribute
,
21046 display_generic_attribute
);
21048 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
21049 display_arm_attribute
,
21050 display_generic_attribute
);
21053 case EM_MIPS_RS3_LE
:
21054 return process_mips_specific (filedata
);
21057 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
21058 display_msp430_attribute
,
21059 display_msp430_gnu_attribute
);
21062 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
21063 display_riscv_attribute
,
21064 display_generic_attribute
);
21067 return process_nds32_specific (filedata
);
21070 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21071 display_m68k_gnu_attribute
);
21075 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21076 display_power_gnu_attribute
);
21080 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21081 display_s390_gnu_attribute
);
21084 case EM_SPARC32PLUS
:
21086 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21087 display_sparc_gnu_attribute
);
21090 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
21091 display_tic6x_attribute
,
21092 display_generic_attribute
);
21095 return process_attributes (filedata
, "csky", SHT_CSKY_ATTRIBUTES
,
21096 display_csky_attribute
, NULL
);
21099 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
21100 display_public_gnu_attributes
,
21101 display_generic_attribute
);
21106 get_file_header (Filedata
* filedata
)
21108 /* Read in the identity array. */
21109 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
21112 /* Determine how to read the rest of the header. */
21113 switch (filedata
->file_header
.e_ident
[EI_DATA
])
21118 byte_get
= byte_get_little_endian
;
21119 byte_put
= byte_put_little_endian
;
21122 byte_get
= byte_get_big_endian
;
21123 byte_put
= byte_put_big_endian
;
21127 /* For now we only support 32 bit and 64 bit ELF files. */
21128 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
21130 /* Read in the rest of the header. */
21133 Elf32_External_Ehdr ehdr32
;
21135 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
21138 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
21139 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
21140 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
21141 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
21142 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
21143 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
21144 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
21145 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
21146 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
21147 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
21148 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
21149 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
21150 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
21154 Elf64_External_Ehdr ehdr64
;
21156 /* If we have been compiled with sizeof (bfd_vma) == 4, then
21157 we will not be able to cope with the 64bit data found in
21158 64 ELF files. Detect this now and abort before we start
21159 overwriting things. */
21160 if (sizeof (bfd_vma
) < 8)
21162 error (_("This instance of readelf has been built without support for a\n\
21163 64 bit data type and so it cannot read 64 bit ELF files.\n"));
21167 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
21170 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
21171 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
21172 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
21173 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
21174 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
21175 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
21176 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
21177 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
21178 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
21179 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
21180 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
21181 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
21182 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
21189 free_filedata (Filedata
*filedata
)
21191 free (filedata
->program_interpreter
);
21192 free (filedata
->program_headers
);
21193 free (filedata
->section_headers
);
21194 free (filedata
->string_table
);
21195 free (filedata
->dump
.dump_sects
);
21196 free (filedata
->dynamic_strings
);
21197 free (filedata
->dynamic_symbols
);
21198 free (filedata
->dynamic_syminfo
);
21199 free (filedata
->dynamic_section
);
21201 while (filedata
->symtab_shndx_list
!= NULL
)
21203 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
21204 free (filedata
->symtab_shndx_list
);
21205 filedata
->symtab_shndx_list
= next
;
21208 free (filedata
->section_headers_groups
);
21210 if (filedata
->section_groups
)
21213 struct group_list
* g
;
21214 struct group_list
* next
;
21216 for (i
= 0; i
< filedata
->group_count
; i
++)
21218 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
21225 free (filedata
->section_groups
);
21227 memset (&filedata
->section_headers
, 0,
21228 sizeof (Filedata
) - offsetof (Filedata
, section_headers
));
21232 close_file (Filedata
* filedata
)
21236 if (filedata
->handle
)
21237 fclose (filedata
->handle
);
21243 close_debug_file (void * data
)
21245 free_filedata ((Filedata
*) data
);
21246 close_file ((Filedata
*) data
);
21250 open_file (const char * pathname
, bool is_separate
)
21252 struct stat statbuf
;
21253 Filedata
* filedata
= NULL
;
21255 if (stat (pathname
, & statbuf
) < 0
21256 || ! S_ISREG (statbuf
.st_mode
))
21259 filedata
= calloc (1, sizeof * filedata
);
21260 if (filedata
== NULL
)
21263 filedata
->handle
= fopen (pathname
, "rb");
21264 if (filedata
->handle
== NULL
)
21267 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
21268 filedata
->file_name
= pathname
;
21269 filedata
->is_separate
= is_separate
;
21271 if (! get_file_header (filedata
))
21274 if (!get_section_headers (filedata
, false))
21282 if (filedata
->handle
)
21283 fclose (filedata
->handle
);
21290 open_debug_file (const char * pathname
)
21292 return open_file (pathname
, true);
21296 initialise_dump_sects (Filedata
* filedata
)
21298 /* Initialise the dump_sects array from the cmdline_dump_sects array.
21299 Note we do this even if cmdline_dump_sects is empty because we
21300 must make sure that the dump_sets array is zeroed out before each
21301 object file is processed. */
21302 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
21303 memset (filedata
->dump
.dump_sects
, 0,
21304 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
21306 if (cmdline
.num_dump_sects
> 0)
21308 if (filedata
->dump
.num_dump_sects
== 0)
21309 /* A sneaky way of allocating the dump_sects array. */
21310 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
21312 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
21313 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
21314 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
21318 /* Process one ELF object file according to the command line options.
21319 This file may actually be stored in an archive. The file is
21320 positioned at the start of the ELF object. Returns TRUE if no
21321 problems were encountered, FALSE otherwise. */
21324 process_object (Filedata
* filedata
)
21326 bool have_separate_files
;
21330 if (! get_file_header (filedata
))
21332 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
21336 /* Initialise per file variables. */
21337 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
21338 filedata
->version_info
[i
] = 0;
21340 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
21341 filedata
->dynamic_info
[i
] = 0;
21342 filedata
->dynamic_info_DT_GNU_HASH
= 0;
21343 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
21345 /* Process the file. */
21347 printf (_("\nFile: %s\n"), filedata
->file_name
);
21349 initialise_dump_sects (filedata
);
21351 /* There may be some extensions in the first section header. Don't
21352 bomb if we can't read it. */
21353 get_section_headers (filedata
, true);
21355 if (! process_file_header (filedata
))
21361 /* Throw away the single section header read above, so that we
21362 re-read the entire set. */
21363 free (filedata
->section_headers
);
21364 filedata
->section_headers
= NULL
;
21366 if (! process_section_headers (filedata
))
21368 /* Without loaded section headers we cannot process lots of things. */
21369 do_unwind
= do_version
= do_dump
= do_arch
= false;
21371 if (! do_using_dynamic
)
21372 do_syms
= do_dyn_syms
= do_reloc
= false;
21375 if (! process_section_groups (filedata
))
21376 /* Without loaded section groups we cannot process unwind. */
21379 res
= process_program_headers (filedata
);
21381 res
= process_dynamic_section (filedata
);
21383 if (! process_relocs (filedata
))
21386 if (! process_unwind (filedata
))
21389 if (! process_symbol_table (filedata
))
21392 if (! process_lto_symbol_tables (filedata
))
21395 if (! process_syminfo (filedata
))
21398 if (! process_version_sections (filedata
))
21401 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
21402 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
21404 have_separate_files
= false;
21406 if (! process_section_contents (filedata
))
21409 if (have_separate_files
)
21413 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
21415 initialise_dump_sects (d
->handle
);
21417 if (process_links
&& ! process_file_header (d
->handle
))
21419 else if (! process_section_headers (d
->handle
))
21421 else if (! process_section_contents (d
->handle
))
21423 else if (process_links
)
21425 if (! process_section_groups (d
->handle
))
21427 if (! process_program_headers (d
->handle
))
21429 if (! process_dynamic_section (d
->handle
))
21431 if (! process_relocs (d
->handle
))
21433 if (! process_unwind (d
->handle
))
21435 if (! process_symbol_table (d
->handle
))
21437 if (! process_lto_symbol_tables (d
->handle
))
21439 if (! process_syminfo (d
->handle
))
21441 if (! process_version_sections (d
->handle
))
21443 if (! process_notes (d
->handle
))
21448 /* The file handles are closed by the call to free_debug_memory() below. */
21451 if (! process_notes (filedata
))
21454 if (! process_gnu_liblist (filedata
))
21457 if (! process_arch_specific (filedata
))
21461 free_filedata (filedata
);
21463 free_debug_memory ();
21468 /* Process an ELF archive.
21469 On entry the file is positioned just after the ARMAG string.
21470 Returns TRUE upon success, FALSE otherwise. */
21473 process_archive (Filedata
* filedata
, bool is_thin_archive
)
21475 struct archive_info arch
;
21476 struct archive_info nested_arch
;
21482 /* The ARCH structure is used to hold information about this archive. */
21483 arch
.file_name
= NULL
;
21485 arch
.index_array
= NULL
;
21486 arch
.sym_table
= NULL
;
21487 arch
.longnames
= NULL
;
21489 /* The NESTED_ARCH structure is used as a single-item cache of information
21490 about a nested archive (when members of a thin archive reside within
21491 another regular archive file). */
21492 nested_arch
.file_name
= NULL
;
21493 nested_arch
.file
= NULL
;
21494 nested_arch
.index_array
= NULL
;
21495 nested_arch
.sym_table
= NULL
;
21496 nested_arch
.longnames
= NULL
;
21498 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
21499 filedata
->file_size
, is_thin_archive
,
21500 do_archive_index
) != 0)
21506 if (do_archive_index
)
21508 if (arch
.sym_table
== NULL
)
21509 error (_("%s: unable to dump the index as none was found\n"),
21510 filedata
->file_name
);
21513 unsigned long i
, l
;
21514 unsigned long current_pos
;
21516 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
21517 "in the symbol table)\n"),
21518 filedata
->file_name
, (unsigned long) arch
.index_num
,
21521 current_pos
= ftell (filedata
->handle
);
21523 for (i
= l
= 0; i
< arch
.index_num
; i
++)
21526 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
21529 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
21532 if (member_name
!= NULL
)
21534 char * qualified_name
21535 = make_qualified_name (&arch
, &nested_arch
,
21538 if (qualified_name
!= NULL
)
21540 printf (_("Contents of binary %s at offset "),
21542 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
21544 free (qualified_name
);
21546 free (member_name
);
21550 if (l
>= arch
.sym_size
)
21552 error (_("%s: end of the symbol table reached "
21553 "before the end of the index\n"),
21554 filedata
->file_name
);
21558 /* PR 17531: file: 0b6630b2. */
21559 printf ("\t%.*s\n",
21560 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
21561 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
21564 if (arch
.uses_64bit_indices
)
21569 if (l
< arch
.sym_size
)
21571 error (ngettext ("%s: %ld byte remains in the symbol table, "
21572 "but without corresponding entries in "
21573 "the index table\n",
21574 "%s: %ld bytes remain in the symbol table, "
21575 "but without corresponding entries in "
21576 "the index table\n",
21577 arch
.sym_size
- l
),
21578 filedata
->file_name
, arch
.sym_size
- l
);
21582 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
21584 error (_("%s: failed to seek back to start of object files "
21585 "in the archive\n"),
21586 filedata
->file_name
);
21592 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
21593 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
21594 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
21595 && !do_section_groups
&& !do_dyn_syms
)
21597 ret
= true; /* Archive index only. */
21606 char * qualified_name
;
21608 /* Read the next archive header. */
21609 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
21611 error (_("%s: failed to seek to next archive header\n"),
21616 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
21617 if (got
!= sizeof arch
.arhdr
)
21621 /* PR 24049 - we cannot use filedata->file_name as this will
21622 have already been freed. */
21623 error (_("%s: failed to read archive header\n"), arch
.file_name
);
21628 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
21630 error (_("%s: did not find a valid archive header\n"),
21636 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
21638 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
21639 if (filedata
->archive_file_size
& 01)
21640 ++filedata
->archive_file_size
;
21642 name
= get_archive_member_name (&arch
, &nested_arch
);
21645 error (_("%s: bad archive file name\n"), arch
.file_name
);
21649 namelen
= strlen (name
);
21651 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
21652 if (qualified_name
== NULL
)
21654 error (_("%s: bad archive file name\n"), arch
.file_name
);
21660 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
21662 /* This is a proxy for an external member of a thin archive. */
21663 Filedata
* member_filedata
;
21664 char * member_file_name
= adjust_relative_path
21665 (filedata
->file_name
, name
, namelen
);
21668 if (member_file_name
== NULL
)
21670 free (qualified_name
);
21675 member_filedata
= open_file (member_file_name
, false);
21676 if (member_filedata
== NULL
)
21678 error (_("Input file '%s' is not readable.\n"), member_file_name
);
21679 free (member_file_name
);
21680 free (qualified_name
);
21685 filedata
->archive_file_offset
= arch
.nested_member_origin
;
21686 member_filedata
->file_name
= qualified_name
;
21688 if (! process_object (member_filedata
))
21691 close_file (member_filedata
);
21692 free (member_file_name
);
21694 else if (is_thin_archive
)
21696 Filedata thin_filedata
;
21698 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
21700 /* PR 15140: Allow for corrupt thin archives. */
21701 if (nested_arch
.file
== NULL
)
21703 error (_("%s: contains corrupt thin archive: %s\n"),
21704 qualified_name
, name
);
21705 free (qualified_name
);
21712 /* This is a proxy for a member of a nested archive. */
21713 filedata
->archive_file_offset
21714 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
21716 /* The nested archive file will have been opened and setup by
21717 get_archive_member_name. */
21718 if (fseek (nested_arch
.file
, filedata
->archive_file_offset
,
21721 error (_("%s: failed to seek to archive member.\n"),
21722 nested_arch
.file_name
);
21723 free (qualified_name
);
21728 thin_filedata
.handle
= nested_arch
.file
;
21729 thin_filedata
.file_name
= qualified_name
;
21731 if (! process_object (& thin_filedata
))
21737 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
21738 filedata
->file_name
= qualified_name
;
21739 if (! process_object (filedata
))
21741 arch
.next_arhdr_offset
+= filedata
->archive_file_size
;
21742 /* Stop looping with "negative" archive_file_size. */
21743 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
21744 arch
.next_arhdr_offset
= -1ul;
21747 free (qualified_name
);
21751 if (nested_arch
.file
!= NULL
)
21752 fclose (nested_arch
.file
);
21753 release_archive (&nested_arch
);
21754 release_archive (&arch
);
21760 process_file (char * file_name
)
21762 Filedata
* filedata
= NULL
;
21763 struct stat statbuf
;
21764 char armag
[SARMAG
];
21767 if (stat (file_name
, &statbuf
) < 0)
21769 if (errno
== ENOENT
)
21770 error (_("'%s': No such file\n"), file_name
);
21772 error (_("Could not locate '%s'. System error message: %s\n"),
21773 file_name
, strerror (errno
));
21777 if (! S_ISREG (statbuf
.st_mode
))
21779 error (_("'%s' is not an ordinary file\n"), file_name
);
21783 filedata
= calloc (1, sizeof * filedata
);
21784 if (filedata
== NULL
)
21786 error (_("Out of memory allocating file data structure\n"));
21790 filedata
->file_name
= file_name
;
21791 filedata
->handle
= fopen (file_name
, "rb");
21792 if (filedata
->handle
== NULL
)
21794 error (_("Input file '%s' is not readable.\n"), file_name
);
21799 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
21801 error (_("%s: Failed to read file's magic number\n"), file_name
);
21802 fclose (filedata
->handle
);
21807 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
21808 filedata
->is_separate
= false;
21810 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
21812 if (! process_archive (filedata
, false))
21815 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
21817 if ( ! process_archive (filedata
, true))
21822 if (do_archive_index
&& !check_all
)
21823 error (_("File %s is not an archive so its index cannot be displayed.\n"),
21826 rewind (filedata
->handle
);
21827 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
21829 if (! process_object (filedata
))
21833 fclose (filedata
->handle
);
21834 free (filedata
->section_headers
);
21835 free (filedata
->program_headers
);
21836 free (filedata
->string_table
);
21837 free (filedata
->dump
.dump_sects
);
21840 free (ba_cache
.strtab
);
21841 ba_cache
.strtab
= NULL
;
21842 free (ba_cache
.symtab
);
21843 ba_cache
.symtab
= NULL
;
21844 ba_cache
.filedata
= NULL
;
21849 #ifdef SUPPORT_DISASSEMBLY
21850 /* Needed by the i386 disassembler. For extra credit, someone could
21851 fix this so that we insert symbolic addresses here, esp for GOT/PLT
21855 print_address (unsigned int addr
, FILE * outfile
)
21857 fprintf (outfile
,"0x%8.8x", addr
);
21860 /* Needed by the i386 disassembler. */
21863 db_task_printsym (unsigned int addr
)
21865 print_address (addr
, stderr
);
21870 main (int argc
, char ** argv
)
21874 #ifdef HAVE_LC_MESSAGES
21875 setlocale (LC_MESSAGES
, "");
21877 setlocale (LC_CTYPE
, "");
21878 bindtextdomain (PACKAGE
, LOCALEDIR
);
21879 textdomain (PACKAGE
);
21881 expandargv (&argc
, &argv
);
21883 parse_args (& cmdline
, argc
, argv
);
21885 if (optind
< (argc
- 1))
21886 /* When displaying information for more than one file,
21887 prefix the information with the file name. */
21889 else if (optind
>= argc
)
21891 /* Ensure that the warning is always displayed. */
21894 warn (_("Nothing to do.\n"));
21899 while (optind
< argc
)
21900 if (! process_file (argv
[optind
++]))
21903 free (cmdline
.dump_sects
);
21905 free (dump_ctf_symtab_name
);
21906 free (dump_ctf_strtab_name
);
21907 free (dump_ctf_parent_name
);
21909 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;