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
)
5862 if (filedata
->file_header
.e_shoff
== 0)
5866 return get_32bit_section_headers (filedata
, probe
);
5868 return get_64bit_section_headers (filedata
, probe
);
5871 static Elf_Internal_Sym
*
5872 get_32bit_elf_symbols (Filedata
* filedata
,
5873 Elf_Internal_Shdr
* section
,
5874 unsigned long * num_syms_return
)
5876 unsigned long number
= 0;
5877 Elf32_External_Sym
* esyms
= NULL
;
5878 Elf_External_Sym_Shndx
* shndx
= NULL
;
5879 Elf_Internal_Sym
* isyms
= NULL
;
5880 Elf_Internal_Sym
* psym
;
5882 elf_section_list
* entry
;
5884 if (section
->sh_size
== 0)
5886 if (num_syms_return
!= NULL
)
5887 * num_syms_return
= 0;
5891 /* Run some sanity checks first. */
5892 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5894 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5895 printable_section_name (filedata
, section
),
5896 (unsigned long) section
->sh_entsize
);
5900 if (section
->sh_size
> filedata
->file_size
)
5902 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5903 printable_section_name (filedata
, section
),
5904 (unsigned long) section
->sh_size
);
5908 number
= section
->sh_size
/ section
->sh_entsize
;
5910 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5912 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5913 (unsigned long) section
->sh_size
,
5914 printable_section_name (filedata
, section
),
5915 (unsigned long) section
->sh_entsize
);
5919 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5920 section
->sh_size
, _("symbols"));
5925 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5927 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5932 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5936 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5937 entry
->hdr
->sh_offset
,
5938 1, entry
->hdr
->sh_size
,
5939 _("symbol table section indices"));
5943 /* PR17531: file: heap-buffer-overflow */
5944 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5946 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5947 printable_section_name (filedata
, entry
->hdr
),
5948 (unsigned long) entry
->hdr
->sh_size
,
5949 (unsigned long) section
->sh_size
);
5954 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5958 error (_("Out of memory reading %lu symbols\n"),
5959 (unsigned long) number
);
5963 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5965 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5966 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5967 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5968 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5969 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5971 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5972 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5973 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5974 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5975 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5982 if (num_syms_return
!= NULL
)
5983 * num_syms_return
= isyms
== NULL
? 0 : number
;
5988 static Elf_Internal_Sym
*
5989 get_64bit_elf_symbols (Filedata
* filedata
,
5990 Elf_Internal_Shdr
* section
,
5991 unsigned long * num_syms_return
)
5993 unsigned long number
= 0;
5994 Elf64_External_Sym
* esyms
= NULL
;
5995 Elf_External_Sym_Shndx
* shndx
= NULL
;
5996 Elf_Internal_Sym
* isyms
= NULL
;
5997 Elf_Internal_Sym
* psym
;
5999 elf_section_list
* entry
;
6001 if (section
->sh_size
== 0)
6003 if (num_syms_return
!= NULL
)
6004 * num_syms_return
= 0;
6008 /* Run some sanity checks first. */
6009 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
6011 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
6012 printable_section_name (filedata
, section
),
6013 (unsigned long) section
->sh_entsize
);
6017 if (section
->sh_size
> filedata
->file_size
)
6019 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
6020 printable_section_name (filedata
, section
),
6021 (unsigned long) section
->sh_size
);
6025 number
= section
->sh_size
/ section
->sh_entsize
;
6027 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
6029 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
6030 (unsigned long) section
->sh_size
,
6031 printable_section_name (filedata
, section
),
6032 (unsigned long) section
->sh_entsize
);
6036 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
6037 section
->sh_size
, _("symbols"));
6042 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
6044 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
6049 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
6053 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
6054 entry
->hdr
->sh_offset
,
6055 1, entry
->hdr
->sh_size
,
6056 _("symbol table section indices"));
6060 /* PR17531: file: heap-buffer-overflow */
6061 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
6063 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
6064 printable_section_name (filedata
, entry
->hdr
),
6065 (unsigned long) entry
->hdr
->sh_size
,
6066 (unsigned long) section
->sh_size
);
6071 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
6075 error (_("Out of memory reading %lu symbols\n"),
6076 (unsigned long) number
);
6080 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
6082 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
6083 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
6084 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
6085 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
6087 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
6089 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
6090 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
6091 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
6093 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
6094 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
6101 if (num_syms_return
!= NULL
)
6102 * num_syms_return
= isyms
== NULL
? 0 : number
;
6107 static Elf_Internal_Sym
*
6108 get_elf_symbols (Filedata
*filedata
,
6109 Elf_Internal_Shdr
*section
,
6110 unsigned long *num_syms_return
)
6113 return get_32bit_elf_symbols (filedata
, section
, num_syms_return
);
6115 return get_64bit_elf_symbols (filedata
, section
, num_syms_return
);
6119 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
6121 static char buff
[1024];
6123 unsigned int field_size
= is_32bit_elf
? 8 : 16;
6125 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
6126 bfd_vma os_flags
= 0;
6127 bfd_vma proc_flags
= 0;
6128 bfd_vma unknown_flags
= 0;
6136 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
6137 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
6138 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
6139 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
6140 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
6141 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
6142 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
6143 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
6144 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
6145 /* 9 */ { STRING_COMMA_LEN ("TLS") },
6146 /* IA-64 specific. */
6147 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
6148 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
6149 /* IA-64 OpenVMS specific. */
6150 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
6151 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
6152 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
6153 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
6154 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
6155 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
6157 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
6158 /* SPARC specific. */
6159 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
6160 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
6162 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
6163 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
6164 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
6166 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
6168 /* 25 */ { STRING_COMMA_LEN ("VLE") },
6170 /* 26 */ { STRING_COMMA_LEN ("GNU_RETAIN") },
6173 if (do_section_details
)
6175 sprintf (buff
, "[%*.*lx]: ",
6176 field_size
, field_size
, (unsigned long) sh_flags
);
6177 p
+= field_size
+ 4;
6184 flag
= sh_flags
& - sh_flags
;
6187 if (do_section_details
)
6191 case SHF_WRITE
: sindex
= 0; break;
6192 case SHF_ALLOC
: sindex
= 1; break;
6193 case SHF_EXECINSTR
: sindex
= 2; break;
6194 case SHF_MERGE
: sindex
= 3; break;
6195 case SHF_STRINGS
: sindex
= 4; break;
6196 case SHF_INFO_LINK
: sindex
= 5; break;
6197 case SHF_LINK_ORDER
: sindex
= 6; break;
6198 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
6199 case SHF_GROUP
: sindex
= 8; break;
6200 case SHF_TLS
: sindex
= 9; break;
6201 case SHF_EXCLUDE
: sindex
= 18; break;
6202 case SHF_COMPRESSED
: sindex
= 20; break;
6206 switch (filedata
->file_header
.e_machine
)
6209 if (flag
== SHF_IA_64_SHORT
)
6211 else if (flag
== SHF_IA_64_NORECOV
)
6214 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
6217 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
6218 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
6219 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
6220 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
6221 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
6222 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
6233 case EM_OLD_SPARCV9
:
6234 case EM_SPARC32PLUS
:
6237 if (flag
== SHF_ORDERED
)
6244 case SHF_ENTRYSECT
: sindex
= 21; break;
6245 case SHF_ARM_PURECODE
: sindex
= 22; break;
6246 case SHF_COMDEF
: sindex
= 23; break;
6251 if (flag
== SHF_PPC_VLE
)
6258 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
6261 case ELFOSABI_FREEBSD
:
6262 if (flag
== SHF_GNU_RETAIN
)
6266 if (flag
== SHF_GNU_MBIND
)
6267 /* We should not recognize SHF_GNU_MBIND for
6268 ELFOSABI_NONE, but binutils as of 2019-07-23 did
6269 not set the EI_OSABI header byte. */
6280 if (p
!= buff
+ field_size
+ 4)
6282 if (size
< (10 + 2))
6284 warn (_("Internal error: not enough buffer room for section flag info"));
6285 return _("<unknown>");
6292 size
-= flags
[sindex
].len
;
6293 p
= stpcpy (p
, flags
[sindex
].str
);
6295 else if (flag
& SHF_MASKOS
)
6297 else if (flag
& SHF_MASKPROC
)
6300 unknown_flags
|= flag
;
6306 case SHF_WRITE
: *p
= 'W'; break;
6307 case SHF_ALLOC
: *p
= 'A'; break;
6308 case SHF_EXECINSTR
: *p
= 'X'; break;
6309 case SHF_MERGE
: *p
= 'M'; break;
6310 case SHF_STRINGS
: *p
= 'S'; break;
6311 case SHF_INFO_LINK
: *p
= 'I'; break;
6312 case SHF_LINK_ORDER
: *p
= 'L'; break;
6313 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
6314 case SHF_GROUP
: *p
= 'G'; break;
6315 case SHF_TLS
: *p
= 'T'; break;
6316 case SHF_EXCLUDE
: *p
= 'E'; break;
6317 case SHF_COMPRESSED
: *p
= 'C'; break;
6320 if ((filedata
->file_header
.e_machine
== EM_X86_64
6321 || filedata
->file_header
.e_machine
== EM_L1OM
6322 || filedata
->file_header
.e_machine
== EM_K1OM
)
6323 && flag
== SHF_X86_64_LARGE
)
6325 else if (filedata
->file_header
.e_machine
== EM_ARM
6326 && flag
== SHF_ARM_PURECODE
)
6328 else if (filedata
->file_header
.e_machine
== EM_PPC
6329 && flag
== SHF_PPC_VLE
)
6331 else if (flag
& SHF_MASKOS
)
6333 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
6336 case ELFOSABI_FREEBSD
:
6337 if (flag
== SHF_GNU_RETAIN
)
6344 if (flag
== SHF_GNU_MBIND
)
6346 /* We should not recognize SHF_GNU_MBIND for
6347 ELFOSABI_NONE, but binutils as of 2019-07-23 did
6348 not set the EI_OSABI header byte. */
6355 sh_flags
&= ~SHF_MASKOS
;
6359 else if (flag
& SHF_MASKPROC
)
6362 sh_flags
&= ~ SHF_MASKPROC
;
6372 if (do_section_details
)
6376 size
-= 5 + field_size
;
6377 if (p
!= buff
+ field_size
+ 4)
6381 warn (_("Internal error: not enough buffer room for section flag info"));
6382 return _("<unknown>");
6388 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6389 (unsigned long) os_flags
);
6390 p
+= 5 + field_size
;
6394 size
-= 7 + field_size
;
6395 if (p
!= buff
+ field_size
+ 4)
6399 warn (_("Internal error: not enough buffer room for section flag info"));
6400 return _("<unknown>");
6406 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6407 (unsigned long) proc_flags
);
6408 p
+= 7 + field_size
;
6412 size
-= 10 + field_size
;
6413 if (p
!= buff
+ field_size
+ 4)
6417 warn (_("Internal error: not enough buffer room for section flag info"));
6418 return _("<unknown>");
6424 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6425 (unsigned long) unknown_flags
);
6426 p
+= 10 + field_size
;
6434 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
6435 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6439 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6441 if (size
< sizeof (* echdr
))
6443 error (_("Compressed section is too small even for a compression header\n"));
6447 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6448 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6449 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6450 return sizeof (*echdr
);
6454 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6456 if (size
< sizeof (* echdr
))
6458 error (_("Compressed section is too small even for a compression header\n"));
6462 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6463 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6464 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6465 return sizeof (*echdr
);
6470 process_section_headers (Filedata
* filedata
)
6472 Elf_Internal_Shdr
* section
;
6475 if (filedata
->file_header
.e_shnum
== 0)
6477 /* PR binutils/12467. */
6478 if (filedata
->file_header
.e_shoff
!= 0)
6480 warn (_("possibly corrupt ELF file header - it has a non-zero"
6481 " section header offset, but no section headers\n"));
6484 else if (do_sections
)
6485 printf (_("\nThere are no sections in this file.\n"));
6490 if (do_sections
&& !do_header
)
6492 if (filedata
->is_separate
&& process_links
)
6493 printf (_("In linked file '%s': "), filedata
->file_name
);
6494 if (! filedata
->is_separate
|| process_links
)
6495 printf (ngettext ("There is %d section header, "
6496 "starting at offset 0x%lx:\n",
6497 "There are %d section headers, "
6498 "starting at offset 0x%lx:\n",
6499 filedata
->file_header
.e_shnum
),
6500 filedata
->file_header
.e_shnum
,
6501 (unsigned long) filedata
->file_header
.e_shoff
);
6504 if (!get_section_headers (filedata
, false))
6507 /* Read in the string table, so that we have names to display. */
6508 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6509 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6511 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6513 if (section
->sh_size
!= 0)
6515 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6516 1, section
->sh_size
,
6519 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6523 /* Scan the sections for the dynamic symbol table
6524 and dynamic string table and debug sections. */
6525 eh_addr_size
= is_32bit_elf
? 4 : 8;
6526 switch (filedata
->file_header
.e_machine
)
6529 case EM_MIPS_RS3_LE
:
6530 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6531 FDE addresses. However, the ABI also has a semi-official ILP32
6532 variant for which the normal FDE address size rules apply.
6534 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6535 section, where XX is the size of longs in bits. Unfortunately,
6536 earlier compilers provided no way of distinguishing ILP32 objects
6537 from LP64 objects, so if there's any doubt, we should assume that
6538 the official LP64 form is being used. */
6539 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6540 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6546 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6548 case E_H8_MACH_H8300
:
6549 case E_H8_MACH_H8300HN
:
6550 case E_H8_MACH_H8300SN
:
6551 case E_H8_MACH_H8300SXN
:
6554 case E_H8_MACH_H8300H
:
6555 case E_H8_MACH_H8300S
:
6556 case E_H8_MACH_H8300SX
:
6564 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6566 case EF_M32C_CPU_M16C
:
6573 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6576 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6577 if (section->sh_entsize != expected_entsize) \
6580 sprintf_vma (buf, section->sh_entsize); \
6581 /* Note: coded this way so that there is a single string for \
6583 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6584 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6585 (unsigned) expected_entsize); \
6586 section->sh_entsize = expected_entsize; \
6591 #define CHECK_ENTSIZE(section, i, type) \
6592 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6593 sizeof (Elf64_External_##type))
6595 for (i
= 0, section
= filedata
->section_headers
;
6596 i
< filedata
->file_header
.e_shnum
;
6599 char * name
= SECTION_NAME_PRINT (section
);
6601 /* Run some sanity checks on the headers and
6602 possibly fill in some file data as well. */
6603 switch (section
->sh_type
)
6606 if (filedata
->dynamic_symbols
!= NULL
)
6608 error (_("File contains multiple dynamic symbol tables\n"));
6612 CHECK_ENTSIZE (section
, i
, Sym
);
6613 filedata
->dynamic_symbols
6614 = get_elf_symbols (filedata
, section
, &filedata
->num_dynamic_syms
);
6615 filedata
->dynamic_symtab_section
= section
;
6619 if (streq (name
, ".dynstr"))
6621 if (filedata
->dynamic_strings
!= NULL
)
6623 error (_("File contains multiple dynamic string tables\n"));
6627 filedata
->dynamic_strings
6628 = (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6629 1, section
->sh_size
, _("dynamic strings"));
6630 filedata
->dynamic_strings_length
6631 = filedata
->dynamic_strings
== NULL
? 0 : section
->sh_size
;
6632 filedata
->dynamic_strtab_section
= section
;
6636 case SHT_SYMTAB_SHNDX
:
6638 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6640 entry
->hdr
= section
;
6641 entry
->next
= filedata
->symtab_shndx_list
;
6642 filedata
->symtab_shndx_list
= entry
;
6647 CHECK_ENTSIZE (section
, i
, Sym
);
6651 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6655 CHECK_ENTSIZE (section
, i
, Rel
);
6656 if (do_checks
&& section
->sh_size
== 0)
6657 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6661 CHECK_ENTSIZE (section
, i
, Rela
);
6662 if (do_checks
&& section
->sh_size
== 0)
6663 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6668 /* Having a zero sized section is not illegal according to the
6669 ELF standard, but it might be an indication that something
6670 is wrong. So issue a warning if we are running in lint mode. */
6671 if (do_checks
&& section
->sh_size
== 0)
6672 warn (_("Section '%s': has a size of zero - is this intended ?\n"), name
);
6679 if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6680 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6681 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6682 || do_debug_str
|| do_debug_str_offsets
|| do_debug_loc
6684 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6685 && (startswith (name
, ".debug_")
6686 || startswith (name
, ".zdebug_")))
6689 name
+= sizeof (".zdebug_") - 1;
6691 name
+= sizeof (".debug_") - 1;
6694 || (do_debug_info
&& startswith (name
, "info"))
6695 || (do_debug_info
&& startswith (name
, "types"))
6696 || (do_debug_abbrevs
&& startswith (name
, "abbrev"))
6697 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6698 || (do_debug_lines
&& startswith (name
, "line."))
6699 || (do_debug_pubnames
&& startswith (name
, "pubnames"))
6700 || (do_debug_pubtypes
&& startswith (name
, "pubtypes"))
6701 || (do_debug_pubnames
&& startswith (name
, "gnu_pubnames"))
6702 || (do_debug_pubtypes
&& startswith (name
, "gnu_pubtypes"))
6703 || (do_debug_aranges
&& startswith (name
, "aranges"))
6704 || (do_debug_ranges
&& startswith (name
, "ranges"))
6705 || (do_debug_ranges
&& startswith (name
, "rnglists"))
6706 || (do_debug_frames
&& startswith (name
, "frame"))
6707 || (do_debug_macinfo
&& startswith (name
, "macinfo"))
6708 || (do_debug_macinfo
&& startswith (name
, "macro"))
6709 || (do_debug_str
&& startswith (name
, "str"))
6710 || (do_debug_links
&& startswith (name
, "sup"))
6711 || (do_debug_str_offsets
&& startswith (name
, "str_offsets"))
6712 || (do_debug_loc
&& startswith (name
, "loc"))
6713 || (do_debug_loc
&& startswith (name
, "loclists"))
6714 || (do_debug_addr
&& startswith (name
, "addr"))
6715 || (do_debug_cu_index
&& startswith (name
, "cu_index"))
6716 || (do_debug_cu_index
&& startswith (name
, "tu_index"))
6718 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6720 /* Linkonce section to be combined with .debug_info at link time. */
6721 else if ((do_debugging
|| do_debug_info
)
6722 && startswith (name
, ".gnu.linkonce.wi."))
6723 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6724 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6725 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6726 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6727 || streq (name
, ".debug_names")))
6728 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6729 /* Trace sections for Itanium VMS. */
6730 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6731 || do_trace_aranges
)
6732 && startswith (name
, ".trace_"))
6734 name
+= sizeof (".trace_") - 1;
6737 || (do_trace_info
&& streq (name
, "info"))
6738 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6739 || (do_trace_aranges
&& streq (name
, "aranges"))
6741 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6743 else if ((do_debugging
|| do_debug_links
)
6744 && (startswith (name
, ".gnu_debuglink")
6745 || startswith (name
, ".gnu_debugaltlink")))
6746 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6752 if (filedata
->is_separate
&& ! process_links
)
6755 if (filedata
->is_separate
)
6756 printf (_("\nSection Headers in linked file '%s':\n"), filedata
->file_name
);
6757 else if (filedata
->file_header
.e_shnum
> 1)
6758 printf (_("\nSection Headers:\n"));
6760 printf (_("\nSection Header:\n"));
6764 if (do_section_details
)
6766 printf (_(" [Nr] Name\n"));
6767 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6771 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6775 if (do_section_details
)
6777 printf (_(" [Nr] Name\n"));
6778 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6782 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6786 if (do_section_details
)
6788 printf (_(" [Nr] Name\n"));
6789 printf (_(" Type Address Offset Link\n"));
6790 printf (_(" Size EntSize Info Align\n"));
6794 printf (_(" [Nr] Name Type Address Offset\n"));
6795 printf (_(" Size EntSize Flags Link Info Align\n"));
6799 if (do_section_details
)
6800 printf (_(" Flags\n"));
6802 for (i
= 0, section
= filedata
->section_headers
;
6803 i
< filedata
->file_header
.e_shnum
;
6806 /* Run some sanity checks on the section header. */
6808 /* Check the sh_link field. */
6809 switch (section
->sh_type
)
6813 if (section
->sh_link
== 0
6814 && (filedata
->file_header
.e_type
== ET_EXEC
6815 || filedata
->file_header
.e_type
== ET_DYN
))
6816 /* A dynamic relocation section where all entries use a
6817 zero symbol index need not specify a symtab section. */
6820 case SHT_SYMTAB_SHNDX
:
6824 case SHT_GNU_versym
:
6825 if (section
->sh_link
== 0
6826 || section
->sh_link
>= filedata
->file_header
.e_shnum
6827 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6828 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6829 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6830 i
, section
->sh_link
);
6836 case SHT_GNU_verneed
:
6837 case SHT_GNU_verdef
:
6838 case SHT_GNU_LIBLIST
:
6839 if (section
->sh_link
== 0
6840 || section
->sh_link
>= filedata
->file_header
.e_shnum
6841 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6842 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6843 i
, section
->sh_link
);
6846 case SHT_INIT_ARRAY
:
6847 case SHT_FINI_ARRAY
:
6848 case SHT_PREINIT_ARRAY
:
6849 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6850 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6851 i
, section
->sh_link
);
6855 /* FIXME: Add support for target specific section types. */
6856 #if 0 /* Currently we do not check other section types as there are too
6857 many special cases. Stab sections for example have a type
6858 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6860 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6861 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6862 i
, section
->sh_link
);
6867 /* Check the sh_info field. */
6868 switch (section
->sh_type
)
6872 if (section
->sh_info
== 0
6873 && (filedata
->file_header
.e_type
== ET_EXEC
6874 || filedata
->file_header
.e_type
== ET_DYN
))
6875 /* Dynamic relocations apply to segments, so they do not
6876 need to specify the section they relocate. */
6878 if (section
->sh_info
== 0
6879 || section
->sh_info
>= filedata
->file_header
.e_shnum
6880 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6881 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6882 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6883 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6884 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6885 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6886 /* FIXME: Are other section types valid ? */
6887 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6888 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6889 i
, section
->sh_info
);
6894 case SHT_SYMTAB_SHNDX
:
6895 case SHT_INIT_ARRAY
:
6896 case SHT_FINI_ARRAY
:
6897 case SHT_PREINIT_ARRAY
:
6898 if (section
->sh_info
!= 0)
6899 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6900 i
, section
->sh_info
);
6906 /* A symbol index - we assume that it is valid. */
6910 /* FIXME: Add support for target specific section types. */
6911 if (section
->sh_type
== SHT_NOBITS
)
6912 /* NOBITS section headers with non-zero sh_info fields can be
6913 created when a binary is stripped of everything but its debug
6914 information. The stripped sections have their headers
6915 preserved but their types set to SHT_NOBITS. So do not check
6916 this type of section. */
6918 else if (section
->sh_flags
& SHF_INFO_LINK
)
6920 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6921 warn (_("[%2u]: Expected link to another section in info field"), i
);
6923 else if (section
->sh_type
< SHT_LOOS
6924 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6925 && section
->sh_info
!= 0)
6926 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6927 i
, section
->sh_info
);
6931 /* Check the sh_size field. */
6932 if (section
->sh_size
> filedata
->file_size
6933 && section
->sh_type
!= SHT_NOBITS
6934 && section
->sh_type
!= SHT_NULL
6935 && section
->sh_type
< SHT_LOOS
)
6936 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6938 printf (" [%2u] ", i
);
6939 if (do_section_details
)
6940 printf ("%s\n ", printable_section_name (filedata
, section
));
6942 print_symbol (-17, SECTION_NAME_PRINT (section
));
6944 printf (do_wide
? " %-15s " : " %-15.15s ",
6945 get_section_type_name (filedata
, section
->sh_type
));
6949 const char * link_too_big
= NULL
;
6951 print_vma (section
->sh_addr
, LONG_HEX
);
6953 printf ( " %6.6lx %6.6lx %2.2lx",
6954 (unsigned long) section
->sh_offset
,
6955 (unsigned long) section
->sh_size
,
6956 (unsigned long) section
->sh_entsize
);
6958 if (do_section_details
)
6959 fputs (" ", stdout
);
6961 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6963 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6966 /* The sh_link value is out of range. Normally this indicates
6967 an error but it can have special values in Solaris binaries. */
6968 switch (filedata
->file_header
.e_machine
)
6975 case EM_OLD_SPARCV9
:
6976 case EM_SPARC32PLUS
:
6979 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6980 link_too_big
= "BEFORE";
6981 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6982 link_too_big
= "AFTER";
6989 if (do_section_details
)
6991 if (link_too_big
!= NULL
&& * link_too_big
)
6992 printf ("<%s> ", link_too_big
);
6994 printf ("%2u ", section
->sh_link
);
6995 printf ("%3u %2lu\n", section
->sh_info
,
6996 (unsigned long) section
->sh_addralign
);
6999 printf ("%2u %3u %2lu\n",
7002 (unsigned long) section
->sh_addralign
);
7004 if (link_too_big
&& ! * link_too_big
)
7005 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
7006 i
, section
->sh_link
);
7010 print_vma (section
->sh_addr
, LONG_HEX
);
7012 if ((long) section
->sh_offset
== section
->sh_offset
)
7013 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
7017 print_vma (section
->sh_offset
, LONG_HEX
);
7020 if ((unsigned long) section
->sh_size
== section
->sh_size
)
7021 printf (" %6.6lx", (unsigned long) section
->sh_size
);
7025 print_vma (section
->sh_size
, LONG_HEX
);
7028 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
7029 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
7033 print_vma (section
->sh_entsize
, LONG_HEX
);
7036 if (do_section_details
)
7037 fputs (" ", stdout
);
7039 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
7041 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
7043 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
7044 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
7047 print_vma (section
->sh_addralign
, DEC
);
7051 else if (do_section_details
)
7054 print_vma (section
->sh_addr
, LONG_HEX
);
7055 if ((long) section
->sh_offset
== section
->sh_offset
)
7056 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
7060 print_vma (section
->sh_offset
, LONG_HEX
);
7062 printf (" %u\n ", section
->sh_link
);
7063 print_vma (section
->sh_size
, LONG_HEX
);
7065 print_vma (section
->sh_entsize
, LONG_HEX
);
7067 printf (" %-16u %lu\n",
7069 (unsigned long) section
->sh_addralign
);
7074 print_vma (section
->sh_addr
, LONG_HEX
);
7075 if ((long) section
->sh_offset
== section
->sh_offset
)
7076 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
7080 print_vma (section
->sh_offset
, LONG_HEX
);
7083 print_vma (section
->sh_size
, LONG_HEX
);
7085 print_vma (section
->sh_entsize
, LONG_HEX
);
7087 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
7089 printf (" %2u %3u %lu\n",
7092 (unsigned long) section
->sh_addralign
);
7095 if (do_section_details
)
7097 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
7098 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
7100 /* Minimum section size is 12 bytes for 32-bit compression
7101 header + 12 bytes for compressed data header. */
7102 unsigned char buf
[24];
7104 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
7105 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
7106 sizeof (buf
), _("compression header")))
7108 Elf_Internal_Chdr chdr
;
7110 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
7111 printf (_(" [<corrupt>]\n"));
7114 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
7117 printf (_(" [<unknown>: 0x%x], "),
7119 print_vma (chdr
.ch_size
, LONG_HEX
);
7120 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
7127 if (!do_section_details
)
7129 /* The ordering of the letters shown here matches the ordering of the
7130 corresponding SHF_xxx values, and hence the order in which these
7131 letters will be displayed to the user. */
7132 printf (_("Key to Flags:\n\
7133 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
7134 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
7135 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
7136 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
7139 case ELFOSABI_FREEBSD
:
7140 printf (_("R (retain), "));
7143 printf (_("D (mbind), "));
7148 if (filedata
->file_header
.e_machine
== EM_X86_64
7149 || filedata
->file_header
.e_machine
== EM_L1OM
7150 || filedata
->file_header
.e_machine
== EM_K1OM
)
7151 printf (_("l (large), "));
7152 else if (filedata
->file_header
.e_machine
== EM_ARM
)
7153 printf (_("y (purecode), "));
7154 else if (filedata
->file_header
.e_machine
== EM_PPC
)
7155 printf (_("v (VLE), "));
7156 printf ("p (processor specific)\n");
7163 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
7164 Elf_Internal_Sym
**symtab
, unsigned long *nsyms
,
7165 char **strtab
, unsigned long *strtablen
)
7169 *symtab
= get_elf_symbols (filedata
, symsec
, nsyms
);
7171 if (*symtab
== NULL
)
7174 if (symsec
->sh_link
!= 0)
7176 Elf_Internal_Shdr
*strsec
;
7178 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
7180 error (_("Bad sh_link in symbol table section\n"));
7187 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7189 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7190 1, strsec
->sh_size
, _("string table"));
7191 if (*strtab
== NULL
)
7198 *strtablen
= strsec
->sh_size
;
7204 get_group_flags (unsigned int flags
)
7206 static char buff
[128];
7210 else if (flags
== GRP_COMDAT
)
7213 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
7215 flags
& GRP_MASKOS
? _("<OS specific>") : "",
7216 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
7217 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
7218 ? _("<unknown>") : ""));
7224 process_section_groups (Filedata
* filedata
)
7226 Elf_Internal_Shdr
* section
;
7228 struct group
* group
;
7229 Elf_Internal_Shdr
* symtab_sec
;
7230 Elf_Internal_Shdr
* strtab_sec
;
7231 Elf_Internal_Sym
* symtab
;
7232 unsigned long num_syms
;
7236 /* Don't process section groups unless needed. */
7237 if (!do_unwind
&& !do_section_groups
)
7240 if (filedata
->file_header
.e_shnum
== 0)
7242 if (do_section_groups
)
7244 if (filedata
->is_separate
)
7245 printf (_("\nThere are no sections group in linked file '%s'.\n"),
7246 filedata
->file_name
);
7248 printf (_("\nThere are no section groups in this file.\n"));
7253 if (filedata
->section_headers
== NULL
)
7255 error (_("Section headers are not available!\n"));
7256 /* PR 13622: This can happen with a corrupt ELF header. */
7260 filedata
->section_headers_groups
7261 = (struct group
**) calloc (filedata
->file_header
.e_shnum
,
7262 sizeof (struct group
*));
7264 if (filedata
->section_headers_groups
== NULL
)
7266 error (_("Out of memory reading %u section group headers\n"),
7267 filedata
->file_header
.e_shnum
);
7271 /* Scan the sections for the group section. */
7272 filedata
->group_count
= 0;
7273 for (i
= 0, section
= filedata
->section_headers
;
7274 i
< filedata
->file_header
.e_shnum
;
7276 if (section
->sh_type
== SHT_GROUP
)
7277 filedata
->group_count
++;
7279 if (filedata
->group_count
== 0)
7281 if (do_section_groups
)
7283 if (filedata
->is_separate
)
7284 printf (_("\nThere are no section groups in linked file '%s'.\n"),
7285 filedata
->file_name
);
7287 printf (_("\nThere are no section groups in this file.\n"));
7293 filedata
->section_groups
= (struct group
*) calloc (filedata
->group_count
,
7294 sizeof (struct group
));
7296 if (filedata
->section_groups
== NULL
)
7298 error (_("Out of memory reading %lu groups\n"),
7299 (unsigned long) filedata
->group_count
);
7310 if (filedata
->is_separate
)
7311 printf (_("Section groups in linked file '%s'\n"), filedata
->file_name
);
7313 for (i
= 0, section
= filedata
->section_headers
, group
= filedata
->section_groups
;
7314 i
< filedata
->file_header
.e_shnum
;
7317 if (section
->sh_type
== SHT_GROUP
)
7319 const char * name
= printable_section_name (filedata
, section
);
7320 const char * group_name
;
7321 unsigned char * start
;
7322 unsigned char * indices
;
7323 unsigned int entry
, j
, size
;
7324 Elf_Internal_Shdr
* sec
;
7325 Elf_Internal_Sym
* sym
;
7327 /* Get the symbol table. */
7328 if (section
->sh_link
>= filedata
->file_header
.e_shnum
7329 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
7332 error (_("Bad sh_link in group section `%s'\n"), name
);
7336 if (symtab_sec
!= sec
)
7340 symtab
= get_elf_symbols (filedata
, symtab_sec
, & num_syms
);
7345 error (_("Corrupt header in group section `%s'\n"), name
);
7349 if (section
->sh_info
>= num_syms
)
7351 error (_("Bad sh_info in group section `%s'\n"), name
);
7355 sym
= symtab
+ section
->sh_info
;
7357 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
7359 if (sym
->st_shndx
== 0
7360 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
7362 error (_("Bad sh_info in group section `%s'\n"), name
);
7366 group_name
= SECTION_NAME_PRINT (filedata
->section_headers
7375 /* Get the string table. */
7376 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
7384 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
7389 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
7390 1, strtab_sec
->sh_size
,
7392 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
7394 group_name
= sym
->st_name
< strtab_size
7395 ? strtab
+ sym
->st_name
: _("<corrupt>");
7398 /* PR 17531: file: loop. */
7399 if (section
->sh_entsize
> section
->sh_size
)
7401 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7402 printable_section_name (filedata
, section
),
7403 (unsigned long) section
->sh_entsize
,
7404 (unsigned long) section
->sh_size
);
7408 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
7409 1, section
->sh_size
,
7415 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
7416 entry
= byte_get (indices
, 4);
7419 if (do_section_groups
)
7421 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7422 get_group_flags (entry
), i
, name
, group_name
, size
);
7424 printf (_(" [Index] Name\n"));
7427 group
->group_index
= i
;
7429 for (j
= 0; j
< size
; j
++)
7431 struct group_list
* g
;
7433 entry
= byte_get (indices
, 4);
7436 if (entry
>= filedata
->file_header
.e_shnum
)
7438 static unsigned num_group_errors
= 0;
7440 if (num_group_errors
++ < 10)
7442 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7443 entry
, i
, filedata
->file_header
.e_shnum
- 1);
7444 if (num_group_errors
== 10)
7445 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7450 if (filedata
->section_headers_groups
[entry
] != NULL
)
7454 static unsigned num_errs
= 0;
7456 if (num_errs
++ < 10)
7458 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7460 filedata
->section_headers_groups
[entry
]->group_index
);
7462 warn (_("Further error messages about already contained group sections suppressed\n"));
7468 /* Intel C/C++ compiler may put section 0 in a
7469 section group. We just warn it the first time
7470 and ignore it afterwards. */
7471 static bool warned
= false;
7474 error (_("section 0 in group section [%5u]\n"),
7475 filedata
->section_headers_groups
[entry
]->group_index
);
7481 filedata
->section_headers_groups
[entry
] = group
;
7483 if (do_section_groups
)
7485 sec
= filedata
->section_headers
+ entry
;
7486 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7489 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7490 g
->section_index
= entry
;
7491 g
->next
= group
->root
;
7506 /* Data used to display dynamic fixups. */
7508 struct ia64_vms_dynfixup
7510 bfd_vma needed_ident
; /* Library ident number. */
7511 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7512 bfd_vma fixup_needed
; /* Index of the library. */
7513 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7514 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7517 /* Data used to display dynamic relocations. */
7519 struct ia64_vms_dynimgrela
7521 bfd_vma img_rela_cnt
; /* Number of relocations. */
7522 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7525 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7529 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7530 struct ia64_vms_dynfixup
* fixup
,
7531 const char * strtab
,
7532 unsigned int strtab_sz
)
7534 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7536 const char * lib_name
;
7538 imfs
= get_data (NULL
, filedata
,
7539 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
7540 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
7541 _("dynamic section image fixups"));
7545 if (fixup
->needed
< strtab_sz
)
7546 lib_name
= strtab
+ fixup
->needed
;
7549 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7550 (unsigned long) fixup
->needed
);
7554 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7555 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7557 (_("Seg Offset Type SymVec DataType\n"));
7559 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7564 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7565 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7566 type
= BYTE_GET (imfs
[i
].type
);
7567 rtype
= elf_ia64_reloc_type (type
);
7569 printf (" 0x%08x ", type
);
7571 printf (" %-32s ", rtype
);
7572 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7573 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7580 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7583 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7585 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7588 imrs
= get_data (NULL
, filedata
,
7589 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
7590 sizeof (*imrs
), imgrela
->img_rela_cnt
,
7591 _("dynamic section image relocations"));
7595 printf (_("\nImage relocs\n"));
7597 (_("Seg Offset Type Addend Seg Sym Off\n"));
7599 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7604 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7605 printf ("%08" BFD_VMA_FMT
"x ",
7606 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7607 type
= BYTE_GET (imrs
[i
].type
);
7608 rtype
= elf_ia64_reloc_type (type
);
7610 printf ("0x%08x ", type
);
7612 printf ("%-31s ", rtype
);
7613 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7614 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7615 printf ("%08" BFD_VMA_FMT
"x\n",
7616 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7623 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7626 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7628 struct ia64_vms_dynfixup fixup
;
7629 struct ia64_vms_dynimgrela imgrela
;
7630 Elf_Internal_Dyn
*entry
;
7631 bfd_vma strtab_off
= 0;
7632 bfd_vma strtab_sz
= 0;
7633 char *strtab
= NULL
;
7636 memset (&fixup
, 0, sizeof (fixup
));
7637 memset (&imgrela
, 0, sizeof (imgrela
));
7639 /* Note: the order of the entries is specified by the OpenVMS specs. */
7640 for (entry
= filedata
->dynamic_section
;
7641 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
7644 switch (entry
->d_tag
)
7646 case DT_IA_64_VMS_STRTAB_OFFSET
:
7647 strtab_off
= entry
->d_un
.d_val
;
7650 strtab_sz
= entry
->d_un
.d_val
;
7652 strtab
= get_data (NULL
, filedata
,
7653 filedata
->dynamic_addr
+ strtab_off
,
7654 1, strtab_sz
, _("dynamic string section"));
7659 case DT_IA_64_VMS_NEEDED_IDENT
:
7660 fixup
.needed_ident
= entry
->d_un
.d_val
;
7663 fixup
.needed
= entry
->d_un
.d_val
;
7665 case DT_IA_64_VMS_FIXUP_NEEDED
:
7666 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7668 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7669 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7671 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7672 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7673 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7676 case DT_IA_64_VMS_IMG_RELA_CNT
:
7677 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7679 case DT_IA_64_VMS_IMG_RELA_OFF
:
7680 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7681 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7702 dynamic_relocations
[] =
7704 { "REL", DT_REL
, DT_RELSZ
, false },
7705 { "RELA", DT_RELA
, DT_RELASZ
, true },
7706 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7709 /* Process the reloc section. */
7712 process_relocs (Filedata
* filedata
)
7714 unsigned long rel_size
;
7715 unsigned long rel_offset
;
7720 if (do_using_dynamic
)
7724 bool has_dynamic_reloc
;
7727 has_dynamic_reloc
= false;
7729 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7731 is_rela
= dynamic_relocations
[i
].rela
;
7732 name
= dynamic_relocations
[i
].name
;
7733 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
7734 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
7737 has_dynamic_reloc
= true;
7739 if (is_rela
== UNKNOWN
)
7741 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7742 switch (filedata
->dynamic_info
[DT_PLTREL
])
7755 if (filedata
->is_separate
)
7757 (_("\nIn linked file '%s' section '%s' at offset 0x%lx contains %ld bytes:\n"),
7758 filedata
->file_name
, name
, rel_offset
, rel_size
);
7761 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7762 name
, rel_offset
, rel_size
);
7764 dump_relocations (filedata
,
7765 offset_from_vma (filedata
, rel_offset
, rel_size
),
7767 filedata
->dynamic_symbols
,
7768 filedata
->num_dynamic_syms
,
7769 filedata
->dynamic_strings
,
7770 filedata
->dynamic_strings_length
,
7771 is_rela
, true /* is_dynamic */);
7775 if (is_ia64_vms (filedata
))
7776 if (process_ia64_vms_dynamic_relocs (filedata
))
7777 has_dynamic_reloc
= true;
7779 if (! has_dynamic_reloc
)
7781 if (filedata
->is_separate
)
7782 printf (_("\nThere are no dynamic relocations in linked file '%s'.\n"),
7783 filedata
->file_name
);
7785 printf (_("\nThere are no dynamic relocations in this file.\n"));
7790 Elf_Internal_Shdr
* section
;
7794 for (i
= 0, section
= filedata
->section_headers
;
7795 i
< filedata
->file_header
.e_shnum
;
7798 if ( section
->sh_type
!= SHT_RELA
7799 && section
->sh_type
!= SHT_REL
)
7802 rel_offset
= section
->sh_offset
;
7803 rel_size
= section
->sh_size
;
7808 unsigned long num_rela
;
7810 if (filedata
->is_separate
)
7811 printf (_("\nIn linked file '%s' relocation section "),
7812 filedata
->file_name
);
7814 printf (_("\nRelocation section "));
7816 if (filedata
->string_table
== NULL
)
7817 printf ("%d", section
->sh_name
);
7819 printf ("'%s'", printable_section_name (filedata
, section
));
7821 num_rela
= rel_size
/ section
->sh_entsize
;
7822 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7823 " at offset 0x%lx contains %lu entries:\n",
7825 rel_offset
, num_rela
);
7827 is_rela
= section
->sh_type
== SHT_RELA
;
7829 if (section
->sh_link
!= 0
7830 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7832 Elf_Internal_Shdr
* symsec
;
7833 Elf_Internal_Sym
* symtab
;
7834 unsigned long nsyms
;
7835 unsigned long strtablen
= 0;
7836 char * strtab
= NULL
;
7838 symsec
= filedata
->section_headers
+ section
->sh_link
;
7839 if (symsec
->sh_type
!= SHT_SYMTAB
7840 && symsec
->sh_type
!= SHT_DYNSYM
)
7843 if (!get_symtab (filedata
, symsec
,
7844 &symtab
, &nsyms
, &strtab
, &strtablen
))
7847 dump_relocations (filedata
, rel_offset
, rel_size
,
7848 symtab
, nsyms
, strtab
, strtablen
,
7850 symsec
->sh_type
== SHT_DYNSYM
);
7855 dump_relocations (filedata
, rel_offset
, rel_size
,
7856 NULL
, 0, NULL
, 0, is_rela
,
7857 false /* is_dynamic */);
7865 /* Users sometimes forget the -D option, so try to be helpful. */
7866 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7868 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
7870 if (filedata
->is_separate
)
7871 printf (_("\nThere are no static relocations in linked file '%s'."),
7872 filedata
->file_name
);
7874 printf (_("\nThere are no static relocations in this file."));
7875 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7880 if (i
== ARRAY_SIZE (dynamic_relocations
))
7882 if (filedata
->is_separate
)
7883 printf (_("\nThere are no relocations in linked file '%s'.\n"),
7884 filedata
->file_name
);
7886 printf (_("\nThere are no relocations in this file.\n"));
7894 /* An absolute address consists of a section and an offset. If the
7895 section is NULL, the offset itself is the address, otherwise, the
7896 address equals to LOAD_ADDRESS(section) + offset. */
7900 unsigned short section
;
7904 /* Find the nearest symbol at or below ADDR. Returns the symbol
7905 name, if found, and the offset from the symbol to ADDR. */
7908 find_symbol_for_address (Filedata
* filedata
,
7909 Elf_Internal_Sym
* symtab
,
7910 unsigned long nsyms
,
7911 const char * strtab
,
7912 unsigned long strtab_size
,
7913 struct absaddr addr
,
7914 const char ** symname
,
7917 bfd_vma dist
= 0x100000;
7918 Elf_Internal_Sym
* sym
;
7919 Elf_Internal_Sym
* beg
;
7920 Elf_Internal_Sym
* end
;
7921 Elf_Internal_Sym
* best
= NULL
;
7923 REMOVE_ARCH_BITS (addr
.offset
);
7925 end
= symtab
+ nsyms
;
7931 sym
= beg
+ (end
- beg
) / 2;
7933 value
= sym
->st_value
;
7934 REMOVE_ARCH_BITS (value
);
7936 if (sym
->st_name
!= 0
7937 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7938 && addr
.offset
>= value
7939 && addr
.offset
- value
< dist
)
7942 dist
= addr
.offset
- value
;
7947 if (addr
.offset
< value
)
7955 *symname
= (best
->st_name
>= strtab_size
7956 ? _("<corrupt>") : strtab
+ best
->st_name
);
7962 *offset
= addr
.offset
;
7965 static /* signed */ int
7966 symcmp (const void *p
, const void *q
)
7968 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7969 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7971 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7974 /* Process the unwind section. */
7976 #include "unwind-ia64.h"
7978 struct ia64_unw_table_entry
7980 struct absaddr start
;
7982 struct absaddr info
;
7985 struct ia64_unw_aux_info
7987 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7988 unsigned long table_len
; /* Length of unwind table. */
7989 unsigned char * info
; /* Unwind info. */
7990 unsigned long info_size
; /* Size of unwind info. */
7991 bfd_vma info_addr
; /* Starting address of unwind info. */
7992 bfd_vma seg_base
; /* Starting address of segment. */
7993 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7994 unsigned long nsyms
; /* Number of symbols. */
7995 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7996 unsigned long nfuns
; /* Number of entries in funtab. */
7997 char * strtab
; /* The string table. */
7998 unsigned long strtab_size
; /* Size of string table. */
8002 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
8004 struct ia64_unw_table_entry
* tp
;
8005 unsigned long j
, nfuns
;
8009 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8010 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8011 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8012 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8014 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8016 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8020 const unsigned char * dp
;
8021 const unsigned char * head
;
8022 const unsigned char * end
;
8023 const char * procname
;
8025 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8026 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
8028 fputs ("\n<", stdout
);
8032 fputs (procname
, stdout
);
8035 printf ("+%lx", (unsigned long) offset
);
8038 fputs (">: [", stdout
);
8039 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8040 fputc ('-', stdout
);
8041 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8042 printf ("], info at +0x%lx\n",
8043 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
8045 /* PR 17531: file: 86232b32. */
8046 if (aux
->info
== NULL
)
8049 offset
= tp
->info
.offset
;
8050 if (tp
->info
.section
)
8052 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
8054 warn (_("Invalid section %u in table entry %ld\n"),
8055 tp
->info
.section
, (long) (tp
- aux
->table
));
8059 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
8061 offset
-= aux
->info_addr
;
8062 /* PR 17531: file: 0997b4d1. */
8063 if (offset
>= aux
->info_size
8064 || aux
->info_size
- offset
< 8)
8066 warn (_("Invalid offset %lx in table entry %ld\n"),
8067 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
8072 head
= aux
->info
+ offset
;
8073 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
8075 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
8076 (unsigned) UNW_VER (stamp
),
8077 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
8078 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
8079 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
8080 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
8082 if (UNW_VER (stamp
) != 1)
8084 printf (_("\tUnknown version.\n"));
8089 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
8090 /* PR 17531: file: 16ceda89. */
8091 if (end
> aux
->info
+ aux
->info_size
)
8092 end
= aux
->info
+ aux
->info_size
;
8093 for (dp
= head
+ 8; dp
< end
;)
8094 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
8103 slurp_ia64_unwind_table (Filedata
* filedata
,
8104 struct ia64_unw_aux_info
* aux
,
8105 Elf_Internal_Shdr
* sec
)
8107 unsigned long size
, nrelas
, i
;
8108 Elf_Internal_Phdr
* seg
;
8109 struct ia64_unw_table_entry
* tep
;
8110 Elf_Internal_Shdr
* relsec
;
8111 Elf_Internal_Rela
* rela
;
8112 Elf_Internal_Rela
* rp
;
8113 unsigned char * table
;
8115 Elf_Internal_Sym
* sym
;
8116 const char * relname
;
8120 /* First, find the starting address of the segment that includes
8123 if (filedata
->file_header
.e_phnum
)
8125 if (! get_program_headers (filedata
))
8128 for (seg
= filedata
->program_headers
;
8129 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8132 if (seg
->p_type
!= PT_LOAD
)
8135 if (sec
->sh_addr
>= seg
->p_vaddr
8136 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8138 aux
->seg_base
= seg
->p_vaddr
;
8144 /* Second, build the unwind table from the contents of the unwind section: */
8145 size
= sec
->sh_size
;
8146 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8151 aux
->table_len
= size
/ (3 * eh_addr_size
);
8152 aux
->table
= (struct ia64_unw_table_entry
*)
8153 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
8156 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
8158 tep
->start
.section
= SHN_UNDEF
;
8159 tep
->end
.section
= SHN_UNDEF
;
8160 tep
->info
.section
= SHN_UNDEF
;
8161 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8162 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8163 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8164 tep
->start
.offset
+= aux
->seg_base
;
8165 tep
->end
.offset
+= aux
->seg_base
;
8166 tep
->info
.offset
+= aux
->seg_base
;
8170 /* Third, apply any relocations to the unwind table: */
8171 for (relsec
= filedata
->section_headers
;
8172 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8175 if (relsec
->sh_type
!= SHT_RELA
8176 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8177 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8180 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8189 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8191 unsigned int sym_ndx
;
8192 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8193 relname
= elf_ia64_reloc_type (r_type
);
8195 /* PR 17531: file: 9fa67536. */
8196 if (relname
== NULL
)
8198 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8202 if (! startswith (relname
, "R_IA64_SEGREL"))
8204 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8208 i
= rp
->r_offset
/ (3 * eh_addr_size
);
8210 /* PR 17531: file: 5bc8d9bf. */
8211 if (i
>= aux
->table_len
)
8213 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8217 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8218 if (sym_ndx
>= aux
->nsyms
)
8220 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8224 sym
= aux
->symtab
+ sym_ndx
;
8226 switch (rp
->r_offset
/ eh_addr_size
% 3)
8229 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8230 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
8233 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8234 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
8237 aux
->table
[i
].info
.section
= sym
->st_shndx
;
8238 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
8252 ia64_process_unwind (Filedata
* filedata
)
8254 Elf_Internal_Shdr
* sec
;
8255 Elf_Internal_Shdr
* unwsec
= NULL
;
8256 unsigned long i
, unwcount
= 0, unwstart
= 0;
8257 struct ia64_unw_aux_info aux
;
8260 memset (& aux
, 0, sizeof (aux
));
8262 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8264 if (sec
->sh_type
== SHT_SYMTAB
)
8268 error (_("Multiple symbol tables encountered\n"));
8274 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8275 &aux
.strtab
, &aux
.strtab_size
))
8278 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8283 printf (_("\nThere are no unwind sections in this file.\n"));
8285 while (unwcount
-- > 0)
8290 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
8291 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8292 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8297 /* We have already counted the number of SHT_IA64_UNWIND
8298 sections so the loop above should never fail. */
8299 assert (unwsec
!= NULL
);
8302 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
8304 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
8306 /* We need to find which section group it is in. */
8307 struct group_list
* g
;
8309 if (filedata
->section_headers_groups
== NULL
8310 || filedata
->section_headers_groups
[i
] == NULL
)
8311 i
= filedata
->file_header
.e_shnum
;
8314 g
= filedata
->section_headers_groups
[i
]->root
;
8316 for (; g
!= NULL
; g
= g
->next
)
8318 sec
= filedata
->section_headers
+ g
->section_index
;
8320 if (SECTION_NAME_VALID (sec
)
8321 && streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
8326 i
= filedata
->file_header
.e_shnum
;
8329 else if (SECTION_NAME_VALID (unwsec
)
8330 && startswith (SECTION_NAME (unwsec
),
8331 ELF_STRING_ia64_unwind_once
))
8333 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
8334 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
8335 suffix
= SECTION_NAME (unwsec
) + len
;
8336 for (i
= 0, sec
= filedata
->section_headers
;
8337 i
< filedata
->file_header
.e_shnum
;
8339 if (SECTION_NAME_VALID (sec
)
8340 && startswith (SECTION_NAME (sec
),
8341 ELF_STRING_ia64_unwind_info_once
)
8342 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8347 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
8348 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
8349 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
8350 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
8352 if (SECTION_NAME_VALID (unwsec
)
8353 && startswith (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
))
8354 suffix
= SECTION_NAME (unwsec
) + len
;
8355 for (i
= 0, sec
= filedata
->section_headers
;
8356 i
< filedata
->file_header
.e_shnum
;
8358 if (SECTION_NAME_VALID (sec
)
8359 && startswith (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
)
8360 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8364 if (i
== filedata
->file_header
.e_shnum
)
8366 printf (_("\nCould not find unwind info section for "));
8368 if (filedata
->string_table
== NULL
)
8369 printf ("%d", unwsec
->sh_name
);
8371 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8375 aux
.info_addr
= sec
->sh_addr
;
8376 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
8379 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
8381 printf (_("\nUnwind section "));
8383 if (filedata
->string_table
== NULL
)
8384 printf ("%d", unwsec
->sh_name
);
8386 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8388 printf (_(" at offset 0x%lx contains %lu entries:\n"),
8389 (unsigned long) unwsec
->sh_offset
,
8390 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
8392 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
8393 && aux
.table_len
> 0)
8394 dump_ia64_unwind (filedata
, & aux
);
8396 free ((char *) aux
.table
);
8397 free ((char *) aux
.info
);
8404 free ((char *) aux
.strtab
);
8409 struct hppa_unw_table_entry
8411 struct absaddr start
;
8413 unsigned int Cannot_unwind
:1; /* 0 */
8414 unsigned int Millicode
:1; /* 1 */
8415 unsigned int Millicode_save_sr0
:1; /* 2 */
8416 unsigned int Region_description
:2; /* 3..4 */
8417 unsigned int reserved1
:1; /* 5 */
8418 unsigned int Entry_SR
:1; /* 6 */
8419 unsigned int Entry_FR
:4; /* Number saved 7..10 */
8420 unsigned int Entry_GR
:5; /* Number saved 11..15 */
8421 unsigned int Args_stored
:1; /* 16 */
8422 unsigned int Variable_Frame
:1; /* 17 */
8423 unsigned int Separate_Package_Body
:1; /* 18 */
8424 unsigned int Frame_Extension_Millicode
:1; /* 19 */
8425 unsigned int Stack_Overflow_Check
:1; /* 20 */
8426 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
8427 unsigned int Ada_Region
:1; /* 22 */
8428 unsigned int cxx_info
:1; /* 23 */
8429 unsigned int cxx_try_catch
:1; /* 24 */
8430 unsigned int sched_entry_seq
:1; /* 25 */
8431 unsigned int reserved2
:1; /* 26 */
8432 unsigned int Save_SP
:1; /* 27 */
8433 unsigned int Save_RP
:1; /* 28 */
8434 unsigned int Save_MRP_in_frame
:1; /* 29 */
8435 unsigned int extn_ptr_defined
:1; /* 30 */
8436 unsigned int Cleanup_defined
:1; /* 31 */
8438 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
8439 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
8440 unsigned int Large_frame
:1; /* 2 */
8441 unsigned int Pseudo_SP_Set
:1; /* 3 */
8442 unsigned int reserved4
:1; /* 4 */
8443 unsigned int Total_frame_size
:27; /* 5..31 */
8446 struct hppa_unw_aux_info
8448 struct hppa_unw_table_entry
* table
; /* Unwind table. */
8449 unsigned long table_len
; /* Length of unwind table. */
8450 bfd_vma seg_base
; /* Starting address of segment. */
8451 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8452 unsigned long nsyms
; /* Number of symbols. */
8453 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8454 unsigned long nfuns
; /* Number of entries in funtab. */
8455 char * strtab
; /* The string table. */
8456 unsigned long strtab_size
; /* Size of string table. */
8460 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8462 struct hppa_unw_table_entry
* tp
;
8463 unsigned long j
, nfuns
;
8466 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8467 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8468 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8469 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8471 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8473 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8476 const char * procname
;
8478 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8479 aux
->strtab_size
, tp
->start
, &procname
,
8482 fputs ("\n<", stdout
);
8486 fputs (procname
, stdout
);
8489 printf ("+%lx", (unsigned long) offset
);
8492 fputs (">: [", stdout
);
8493 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8494 fputc ('-', stdout
);
8495 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8498 #define PF(_m) if (tp->_m) printf (#_m " ");
8499 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8502 PF(Millicode_save_sr0
);
8503 /* PV(Region_description); */
8509 PF(Separate_Package_Body
);
8510 PF(Frame_Extension_Millicode
);
8511 PF(Stack_Overflow_Check
);
8512 PF(Two_Instruction_SP_Increment
);
8516 PF(sched_entry_seq
);
8519 PF(Save_MRP_in_frame
);
8520 PF(extn_ptr_defined
);
8521 PF(Cleanup_defined
);
8522 PF(MPE_XL_interrupt_marker
);
8523 PF(HP_UX_interrupt_marker
);
8526 PV(Total_frame_size
);
8539 slurp_hppa_unwind_table (Filedata
* filedata
,
8540 struct hppa_unw_aux_info
* aux
,
8541 Elf_Internal_Shdr
* sec
)
8543 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8544 Elf_Internal_Phdr
* seg
;
8545 struct hppa_unw_table_entry
* tep
;
8546 Elf_Internal_Shdr
* relsec
;
8547 Elf_Internal_Rela
* rela
;
8548 Elf_Internal_Rela
* rp
;
8549 unsigned char * table
;
8551 Elf_Internal_Sym
* sym
;
8552 const char * relname
;
8554 /* First, find the starting address of the segment that includes
8556 if (filedata
->file_header
.e_phnum
)
8558 if (! get_program_headers (filedata
))
8561 for (seg
= filedata
->program_headers
;
8562 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8565 if (seg
->p_type
!= PT_LOAD
)
8568 if (sec
->sh_addr
>= seg
->p_vaddr
8569 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8571 aux
->seg_base
= seg
->p_vaddr
;
8577 /* Second, build the unwind table from the contents of the unwind
8579 size
= sec
->sh_size
;
8580 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8586 nentries
= size
/ unw_ent_size
;
8587 size
= unw_ent_size
* nentries
;
8589 aux
->table_len
= nentries
;
8590 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8591 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8593 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8595 unsigned int tmp1
, tmp2
;
8597 tep
->start
.section
= SHN_UNDEF
;
8598 tep
->end
.section
= SHN_UNDEF
;
8600 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8601 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8602 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8603 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8605 tep
->start
.offset
+= aux
->seg_base
;
8606 tep
->end
.offset
+= aux
->seg_base
;
8608 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8609 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8610 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8611 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8612 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8613 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8614 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8615 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8616 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8617 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8618 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8619 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8620 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8621 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8622 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8623 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8624 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8625 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8626 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8627 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8628 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8629 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8630 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8631 tep
->Cleanup_defined
= tmp1
& 0x1;
8633 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8634 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8635 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8636 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8637 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8638 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8642 /* Third, apply any relocations to the unwind table. */
8643 for (relsec
= filedata
->section_headers
;
8644 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8647 if (relsec
->sh_type
!= SHT_RELA
8648 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8649 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8652 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8656 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8658 unsigned int sym_ndx
;
8659 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8660 relname
= elf_hppa_reloc_type (r_type
);
8662 if (relname
== NULL
)
8664 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8668 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8669 if (! startswith (relname
, "R_PARISC_SEGREL"))
8671 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8675 i
= rp
->r_offset
/ unw_ent_size
;
8676 if (i
>= aux
->table_len
)
8678 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8682 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8683 if (sym_ndx
>= aux
->nsyms
)
8685 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8689 sym
= aux
->symtab
+ sym_ndx
;
8691 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8694 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8695 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8698 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8699 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8713 hppa_process_unwind (Filedata
* filedata
)
8715 struct hppa_unw_aux_info aux
;
8716 Elf_Internal_Shdr
* unwsec
= NULL
;
8717 Elf_Internal_Shdr
* sec
;
8721 if (filedata
->string_table
== NULL
)
8724 memset (& aux
, 0, sizeof (aux
));
8726 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8728 if (sec
->sh_type
== SHT_SYMTAB
)
8732 error (_("Multiple symbol tables encountered\n"));
8738 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8739 &aux
.strtab
, &aux
.strtab_size
))
8742 else if (SECTION_NAME_VALID (sec
)
8743 && streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8748 printf (_("\nThere are no unwind sections in this file.\n"));
8750 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8752 if (SECTION_NAME_VALID (sec
)
8753 && streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8755 unsigned long num_unwind
= sec
->sh_size
/ 16;
8757 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8758 "contains %lu entry:\n",
8759 "\nUnwind section '%s' at offset 0x%lx "
8760 "contains %lu entries:\n",
8762 printable_section_name (filedata
, sec
),
8763 (unsigned long) sec
->sh_offset
,
8766 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8769 if (res
&& aux
.table_len
> 0)
8771 if (! dump_hppa_unwind (filedata
, &aux
))
8775 free ((char *) aux
.table
);
8781 free ((char *) aux
.strtab
);
8788 unsigned char * data
; /* The unwind data. */
8789 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8790 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8791 unsigned long nrelas
; /* The number of relocations. */
8792 unsigned int rel_type
; /* REL or RELA ? */
8793 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8796 struct arm_unw_aux_info
8798 Filedata
* filedata
; /* The file containing the unwind sections. */
8799 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8800 unsigned long nsyms
; /* Number of symbols. */
8801 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8802 unsigned long nfuns
; /* Number of these symbols. */
8803 char * strtab
; /* The file's string table. */
8804 unsigned long strtab_size
; /* Size of string table. */
8808 arm_print_vma_and_name (Filedata
* filedata
,
8809 struct arm_unw_aux_info
* aux
,
8811 struct absaddr addr
)
8813 const char *procname
;
8816 if (addr
.section
== SHN_UNDEF
)
8819 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8820 aux
->strtab_size
, addr
, &procname
,
8823 print_vma (fn
, PREFIX_HEX
);
8827 fputs (" <", stdout
);
8828 fputs (procname
, stdout
);
8831 printf ("+0x%lx", (unsigned long) sym_offset
);
8832 fputc ('>', stdout
);
8839 arm_free_section (struct arm_section
*arm_sec
)
8841 free (arm_sec
->data
);
8842 free (arm_sec
->rela
);
8845 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8846 cached section and install SEC instead.
8847 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8848 and return its valued in * WORDP, relocating if necessary.
8849 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8850 relocation's offset in ADDR.
8851 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8852 into the string table of the symbol associated with the reloc. If no
8853 reloc was applied store -1 there.
8854 5) Return TRUE upon success, FALSE otherwise. */
8857 get_unwind_section_word (Filedata
* filedata
,
8858 struct arm_unw_aux_info
* aux
,
8859 struct arm_section
* arm_sec
,
8860 Elf_Internal_Shdr
* sec
,
8861 bfd_vma word_offset
,
8862 unsigned int * wordp
,
8863 struct absaddr
* addr
,
8866 Elf_Internal_Rela
*rp
;
8867 Elf_Internal_Sym
*sym
;
8868 const char * relname
;
8872 if (sec
== NULL
|| arm_sec
== NULL
)
8875 addr
->section
= SHN_UNDEF
;
8878 if (sym_name
!= NULL
)
8879 *sym_name
= (bfd_vma
) -1;
8881 /* If necessary, update the section cache. */
8882 if (sec
!= arm_sec
->sec
)
8884 Elf_Internal_Shdr
*relsec
;
8886 arm_free_section (arm_sec
);
8889 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8890 sec
->sh_size
, _("unwind data"));
8891 arm_sec
->rela
= NULL
;
8892 arm_sec
->nrelas
= 0;
8894 for (relsec
= filedata
->section_headers
;
8895 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8898 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8899 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8900 /* PR 15745: Check the section type as well. */
8901 || (relsec
->sh_type
!= SHT_REL
8902 && relsec
->sh_type
!= SHT_RELA
))
8905 arm_sec
->rel_type
= relsec
->sh_type
;
8906 if (relsec
->sh_type
== SHT_REL
)
8908 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8910 & arm_sec
->rela
, & arm_sec
->nrelas
))
8913 else /* relsec->sh_type == SHT_RELA */
8915 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8917 & arm_sec
->rela
, & arm_sec
->nrelas
))
8923 arm_sec
->next_rela
= arm_sec
->rela
;
8926 /* If there is no unwind data we can do nothing. */
8927 if (arm_sec
->data
== NULL
)
8930 /* If the offset is invalid then fail. */
8931 if (/* PR 21343 *//* PR 18879 */
8933 || word_offset
> (sec
->sh_size
- 4)
8934 || ((bfd_signed_vma
) word_offset
) < 0)
8937 /* Get the word at the required offset. */
8938 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8940 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8941 if (arm_sec
->rela
== NULL
)
8947 /* Look through the relocs to find the one that applies to the provided offset. */
8949 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8951 bfd_vma prelval
, offset
;
8953 if (rp
->r_offset
> word_offset
&& !wrapped
)
8958 if (rp
->r_offset
> word_offset
)
8961 if (rp
->r_offset
& 3)
8963 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8964 (unsigned long) rp
->r_offset
);
8968 if (rp
->r_offset
< word_offset
)
8971 /* PR 17531: file: 027-161405-0.004 */
8972 if (aux
->symtab
== NULL
)
8975 if (arm_sec
->rel_type
== SHT_REL
)
8977 offset
= word
& 0x7fffffff;
8978 if (offset
& 0x40000000)
8979 offset
|= ~ (bfd_vma
) 0x7fffffff;
8981 else if (arm_sec
->rel_type
== SHT_RELA
)
8982 offset
= rp
->r_addend
;
8985 error (_("Unknown section relocation type %d encountered\n"),
8990 /* PR 17531 file: 027-1241568-0.004. */
8991 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8993 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8994 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8998 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8999 offset
+= sym
->st_value
;
9000 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
9002 /* Check that we are processing the expected reloc type. */
9003 if (filedata
->file_header
.e_machine
== EM_ARM
)
9005 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
9006 if (relname
== NULL
)
9008 warn (_("Skipping unknown ARM relocation type: %d\n"),
9009 (int) ELF32_R_TYPE (rp
->r_info
));
9013 if (streq (relname
, "R_ARM_NONE"))
9016 if (! streq (relname
, "R_ARM_PREL31"))
9018 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
9022 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9024 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
9025 if (relname
== NULL
)
9027 warn (_("Skipping unknown C6000 relocation type: %d\n"),
9028 (int) ELF32_R_TYPE (rp
->r_info
));
9032 if (streq (relname
, "R_C6000_NONE"))
9035 if (! streq (relname
, "R_C6000_PREL31"))
9037 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
9045 /* This function currently only supports ARM and TI unwinders. */
9046 warn (_("Only TI and ARM unwinders are currently supported\n"));
9050 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
9051 addr
->section
= sym
->st_shndx
;
9052 addr
->offset
= offset
;
9055 * sym_name
= sym
->st_name
;
9060 arm_sec
->next_rela
= rp
;
9065 static const char *tic6x_unwind_regnames
[16] =
9067 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
9068 "A14", "A13", "A12", "A11", "A10",
9069 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
9073 decode_tic6x_unwind_regmask (unsigned int mask
)
9077 for (i
= 12; mask
; mask
>>= 1, i
--)
9081 fputs (tic6x_unwind_regnames
[i
], stdout
);
9083 fputs (", ", stdout
);
9089 if (remaining == 0 && more_words) \
9092 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
9093 data_offset, & word, & addr, NULL)) \
9099 #define GET_OP(OP) \
9104 (OP) = word >> 24; \
9109 printf (_("[Truncated opcode]\n")); \
9112 printf ("0x%02x ", OP)
9115 decode_arm_unwind_bytecode (Filedata
* filedata
,
9116 struct arm_unw_aux_info
* aux
,
9118 unsigned int remaining
,
9119 unsigned int more_words
,
9120 bfd_vma data_offset
,
9121 Elf_Internal_Shdr
* data_sec
,
9122 struct arm_section
* data_arm_sec
)
9124 struct absaddr addr
;
9127 /* Decode the unwinding instructions. */
9130 unsigned int op
, op2
;
9139 printf (" 0x%02x ", op
);
9141 if ((op
& 0xc0) == 0x00)
9143 int offset
= ((op
& 0x3f) << 2) + 4;
9145 printf (" vsp = vsp + %d", offset
);
9147 else if ((op
& 0xc0) == 0x40)
9149 int offset
= ((op
& 0x3f) << 2) + 4;
9151 printf (" vsp = vsp - %d", offset
);
9153 else if ((op
& 0xf0) == 0x80)
9156 if (op
== 0x80 && op2
== 0)
9157 printf (_("Refuse to unwind"));
9160 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
9165 for (i
= 0; i
< 12; i
++)
9166 if (mask
& (1 << i
))
9172 printf ("r%d", 4 + i
);
9177 else if ((op
& 0xf0) == 0x90)
9179 if (op
== 0x9d || op
== 0x9f)
9180 printf (_(" [Reserved]"));
9182 printf (" vsp = r%d", op
& 0x0f);
9184 else if ((op
& 0xf0) == 0xa0)
9186 int end
= 4 + (op
& 0x07);
9191 for (i
= 4; i
<= end
; i
++)
9207 else if (op
== 0xb0)
9208 printf (_(" finish"));
9209 else if (op
== 0xb1)
9212 if (op2
== 0 || (op2
& 0xf0) != 0)
9213 printf (_("[Spare]"));
9216 unsigned int mask
= op2
& 0x0f;
9221 for (i
= 0; i
< 12; i
++)
9222 if (mask
& (1 << i
))
9233 else if (op
== 0xb2)
9235 unsigned char buf
[9];
9236 unsigned int i
, len
;
9237 unsigned long offset
;
9239 for (i
= 0; i
< sizeof (buf
); i
++)
9242 if ((buf
[i
] & 0x80) == 0)
9245 if (i
== sizeof (buf
))
9247 error (_("corrupt change to vsp\n"));
9252 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
9253 assert (len
== i
+ 1);
9254 offset
= offset
* 4 + 0x204;
9255 printf ("vsp = vsp + %ld", offset
);
9258 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
9260 unsigned int first
, last
;
9267 printf ("pop {D%d", first
);
9269 printf ("-D%d", first
+ last
);
9272 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
9274 unsigned int count
= op
& 0x07;
9278 printf ("-D%d", 8 + count
);
9281 else if (op
>= 0xc0 && op
<= 0xc5)
9283 unsigned int count
= op
& 0x07;
9285 printf (" pop {wR10");
9287 printf ("-wR%d", 10 + count
);
9290 else if (op
== 0xc6)
9292 unsigned int first
, last
;
9297 printf ("pop {wR%d", first
);
9299 printf ("-wR%d", first
+ last
);
9302 else if (op
== 0xc7)
9305 if (op2
== 0 || (op2
& 0xf0) != 0)
9306 printf (_("[Spare]"));
9309 unsigned int mask
= op2
& 0x0f;
9314 for (i
= 0; i
< 4; i
++)
9315 if (mask
& (1 << i
))
9321 printf ("wCGR%d", i
);
9328 printf (_(" [unsupported opcode]"));
9339 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
9340 struct arm_unw_aux_info
* aux
,
9342 unsigned int remaining
,
9343 unsigned int more_words
,
9344 bfd_vma data_offset
,
9345 Elf_Internal_Shdr
* data_sec
,
9346 struct arm_section
* data_arm_sec
)
9348 struct absaddr addr
;
9350 /* Decode the unwinding instructions. */
9353 unsigned int op
, op2
;
9362 printf (" 0x%02x ", op
);
9364 if ((op
& 0xc0) == 0x00)
9366 int offset
= ((op
& 0x3f) << 3) + 8;
9367 printf (" sp = sp + %d", offset
);
9369 else if ((op
& 0xc0) == 0x80)
9372 if (op
== 0x80 && op2
== 0)
9373 printf (_("Refuse to unwind"));
9376 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
9378 printf ("pop compact {");
9382 decode_tic6x_unwind_regmask (mask
);
9386 else if ((op
& 0xf0) == 0xc0)
9394 unsigned int offset
;
9398 /* Scan entire instruction first so that GET_OP output is not
9399 interleaved with disassembly. */
9401 for (i
= 0; nregs
< (op
& 0xf); i
++)
9407 regpos
[nregs
].offset
= i
* 2;
9408 regpos
[nregs
].reg
= reg
;
9415 regpos
[nregs
].offset
= i
* 2 + 1;
9416 regpos
[nregs
].reg
= reg
;
9421 printf (_("pop frame {"));
9424 printf (_("*corrupt* - no registers specified"));
9429 for (i
= i
* 2; i
> 0; i
--)
9431 if (regpos
[reg
].offset
== i
- 1)
9433 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
9440 fputs (name
, stdout
);
9448 else if (op
== 0xd0)
9449 printf (" MOV FP, SP");
9450 else if (op
== 0xd1)
9451 printf (" __c6xabi_pop_rts");
9452 else if (op
== 0xd2)
9454 unsigned char buf
[9];
9455 unsigned int i
, len
;
9456 unsigned long offset
;
9458 for (i
= 0; i
< sizeof (buf
); i
++)
9461 if ((buf
[i
] & 0x80) == 0)
9464 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9465 if (i
== sizeof (buf
))
9467 warn (_("Corrupt stack pointer adjustment detected\n"));
9471 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
9472 assert (len
== i
+ 1);
9473 offset
= offset
* 8 + 0x408;
9474 printf (_("sp = sp + %ld"), offset
);
9476 else if ((op
& 0xf0) == 0xe0)
9478 if ((op
& 0x0f) == 7)
9481 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9485 printf (_(" [unsupported opcode]"));
9494 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9498 offset
= word
& 0x7fffffff;
9499 if (offset
& 0x40000000)
9500 offset
|= ~ (bfd_vma
) 0x7fffffff;
9502 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9505 return offset
+ where
;
9509 decode_arm_unwind (Filedata
* filedata
,
9510 struct arm_unw_aux_info
* aux
,
9512 unsigned int remaining
,
9513 bfd_vma data_offset
,
9514 Elf_Internal_Shdr
* data_sec
,
9515 struct arm_section
* data_arm_sec
)
9518 unsigned int more_words
= 0;
9519 struct absaddr addr
;
9520 bfd_vma sym_name
= (bfd_vma
) -1;
9525 /* Fetch the first word.
9526 Note - when decoding an object file the address extracted
9527 here will always be 0. So we also pass in the sym_name
9528 parameter so that we can find the symbol associated with
9529 the personality routine. */
9530 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9531 & word
, & addr
, & sym_name
))
9538 addr
.section
= SHN_UNDEF
;
9542 if ((word
& 0x80000000) == 0)
9544 /* Expand prel31 for personality routine. */
9546 const char *procname
;
9548 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9549 printf (_(" Personality routine: "));
9551 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9552 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9554 procname
= aux
->strtab
+ sym_name
;
9555 print_vma (fn
, PREFIX_HEX
);
9558 fputs (" <", stdout
);
9559 fputs (procname
, stdout
);
9560 fputc ('>', stdout
);
9564 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9565 fputc ('\n', stdout
);
9567 /* The GCC personality routines use the standard compact
9568 encoding, starting with one byte giving the number of
9570 if (procname
!= NULL
9571 && (startswith (procname
, "__gcc_personality_v0")
9572 || startswith (procname
, "__gxx_personality_v0")
9573 || startswith (procname
, "__gcj_personality_v0")
9574 || startswith (procname
, "__gnu_objc_personality_v0")))
9581 printf (_(" [Truncated data]\n"));
9584 more_words
= word
>> 24;
9594 /* ARM EHABI Section 6.3:
9596 An exception-handling table entry for the compact model looks like:
9600 1 0 index Data for personalityRoutine[index] */
9602 if (filedata
->file_header
.e_machine
== EM_ARM
9603 && (word
& 0x70000000))
9605 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9609 per_index
= (word
>> 24) & 0x7f;
9610 printf (_(" Compact model index: %d\n"), per_index
);
9617 else if (per_index
< 3)
9619 more_words
= (word
>> 16) & 0xff;
9625 switch (filedata
->file_header
.e_machine
)
9630 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9631 data_offset
, data_sec
, data_arm_sec
))
9636 warn (_("Unknown ARM compact model index encountered\n"));
9637 printf (_(" [reserved]\n"));
9645 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9646 data_offset
, data_sec
, data_arm_sec
))
9649 else if (per_index
< 5)
9651 if (((word
>> 17) & 0x7f) == 0x7f)
9652 printf (_(" Restore stack from frame pointer\n"));
9654 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9655 printf (_(" Registers restored: "));
9657 printf (" (compact) ");
9658 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9660 printf (_(" Return register: %s\n"),
9661 tic6x_unwind_regnames
[word
& 0xf]);
9664 printf (_(" [reserved (%d)]\n"), per_index
);
9668 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9669 filedata
->file_header
.e_machine
);
9673 /* Decode the descriptors. Not implemented. */
9679 dump_arm_unwind (Filedata
* filedata
,
9680 struct arm_unw_aux_info
* aux
,
9681 Elf_Internal_Shdr
* exidx_sec
)
9683 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9684 unsigned int i
, exidx_len
;
9685 unsigned long j
, nfuns
;
9688 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9689 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9690 exidx_len
= exidx_sec
->sh_size
/ 8;
9692 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9693 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9694 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9695 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9697 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9699 for (i
= 0; i
< exidx_len
; i
++)
9701 unsigned int exidx_fn
, exidx_entry
;
9702 struct absaddr fn_addr
, entry_addr
;
9705 fputc ('\n', stdout
);
9707 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9708 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9709 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9710 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9713 arm_free_section (& exidx_arm_sec
);
9714 arm_free_section (& extab_arm_sec
);
9718 /* ARM EHABI, Section 5:
9719 An index table entry consists of 2 words.
9720 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9721 if (exidx_fn
& 0x80000000)
9723 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9727 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9729 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9730 fputs (": ", stdout
);
9732 if (exidx_entry
== 1)
9734 print_vma (exidx_entry
, PREFIX_HEX
);
9735 fputs (" [cantunwind]\n", stdout
);
9737 else if (exidx_entry
& 0x80000000)
9739 print_vma (exidx_entry
, PREFIX_HEX
);
9740 fputc ('\n', stdout
);
9741 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9745 bfd_vma table
, table_offset
= 0;
9746 Elf_Internal_Shdr
*table_sec
;
9748 fputs ("@", stdout
);
9749 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9750 print_vma (table
, PREFIX_HEX
);
9753 /* Locate the matching .ARM.extab. */
9754 if (entry_addr
.section
!= SHN_UNDEF
9755 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9757 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9758 table_offset
= entry_addr
.offset
;
9760 if (table_offset
> table_sec
->sh_size
9761 || ((bfd_signed_vma
) table_offset
) < 0)
9763 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9764 (unsigned long) table_offset
,
9765 printable_section_name (filedata
, table_sec
));
9772 table_sec
= find_section_by_address (filedata
, table
);
9773 if (table_sec
!= NULL
)
9774 table_offset
= table
- table_sec
->sh_addr
;
9777 if (table_sec
== NULL
)
9779 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9780 (unsigned long) table
);
9785 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9794 arm_free_section (&exidx_arm_sec
);
9795 arm_free_section (&extab_arm_sec
);
9800 /* Used for both ARM and C6X unwinding tables. */
9803 arm_process_unwind (Filedata
* filedata
)
9805 struct arm_unw_aux_info aux
;
9806 Elf_Internal_Shdr
*unwsec
= NULL
;
9807 Elf_Internal_Shdr
*sec
;
9809 unsigned int sec_type
;
9812 switch (filedata
->file_header
.e_machine
)
9815 sec_type
= SHT_ARM_EXIDX
;
9819 sec_type
= SHT_C6000_UNWIND
;
9823 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9824 filedata
->file_header
.e_machine
);
9828 if (filedata
->string_table
== NULL
)
9831 memset (& aux
, 0, sizeof (aux
));
9832 aux
.filedata
= filedata
;
9834 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9836 if (sec
->sh_type
== SHT_SYMTAB
)
9840 error (_("Multiple symbol tables encountered\n"));
9846 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9847 &aux
.strtab
, &aux
.strtab_size
))
9850 else if (sec
->sh_type
== sec_type
)
9855 printf (_("\nThere are no unwind sections in this file.\n"));
9857 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9859 if (sec
->sh_type
== sec_type
)
9861 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9862 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9863 "contains %lu entry:\n",
9864 "\nUnwind section '%s' at offset 0x%lx "
9865 "contains %lu entries:\n",
9867 printable_section_name (filedata
, sec
),
9868 (unsigned long) sec
->sh_offset
,
9871 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9877 free ((char *) aux
.strtab
);
9883 no_processor_specific_unwind (Filedata
* filedata ATTRIBUTE_UNUSED
)
9885 printf (_("No processor specific unwind information to decode\n"));
9890 process_unwind (Filedata
* filedata
)
9892 struct unwind_handler
9894 unsigned int machtype
;
9895 bool (* handler
)(Filedata
*);
9898 { EM_ARM
, arm_process_unwind
},
9899 { EM_IA_64
, ia64_process_unwind
},
9900 { EM_PARISC
, hppa_process_unwind
},
9901 { EM_TI_C6000
, arm_process_unwind
},
9902 { EM_386
, no_processor_specific_unwind
},
9903 { EM_X86_64
, no_processor_specific_unwind
},
9911 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9912 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9913 return handlers
[i
].handler (filedata
);
9915 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9916 get_machine_name (filedata
->file_header
.e_machine
));
9921 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9923 switch (entry
->d_tag
)
9925 case DT_AARCH64_BTI_PLT
:
9926 case DT_AARCH64_PAC_PLT
:
9929 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9936 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
9938 switch (entry
->d_tag
)
9941 if (entry
->d_un
.d_val
== 0)
9945 static const char * opts
[] =
9947 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9948 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9949 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9950 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9956 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9957 if (entry
->d_un
.d_val
& (1 << cnt
))
9959 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9965 case DT_MIPS_IVERSION
:
9966 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
9967 printf (_("Interface Version: %s"),
9968 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
9972 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9973 /* Note: coded this way so that there is a single string for translation. */
9974 printf (_("<corrupt: %s>"), buf
);
9978 case DT_MIPS_TIME_STAMP
:
9982 time_t atime
= entry
->d_un
.d_val
;
9984 tmp
= gmtime (&atime
);
9985 /* PR 17531: file: 6accc532. */
9987 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9989 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9990 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9991 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9992 printf (_("Time Stamp: %s"), timebuf
);
9996 case DT_MIPS_RLD_VERSION
:
9997 case DT_MIPS_LOCAL_GOTNO
:
9998 case DT_MIPS_CONFLICTNO
:
9999 case DT_MIPS_LIBLISTNO
:
10000 case DT_MIPS_SYMTABNO
:
10001 case DT_MIPS_UNREFEXTNO
:
10002 case DT_MIPS_HIPAGENO
:
10003 case DT_MIPS_DELTA_CLASS_NO
:
10004 case DT_MIPS_DELTA_INSTANCE_NO
:
10005 case DT_MIPS_DELTA_RELOC_NO
:
10006 case DT_MIPS_DELTA_SYM_NO
:
10007 case DT_MIPS_DELTA_CLASSSYM_NO
:
10008 case DT_MIPS_COMPACT_SIZE
:
10009 print_vma (entry
->d_un
.d_val
, DEC
);
10012 case DT_MIPS_XHASH
:
10013 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10014 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10015 /* Falls through. */
10018 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10024 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
10026 switch (entry
->d_tag
)
10028 case DT_HP_DLD_FLAGS
:
10037 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
10038 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
10039 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
10040 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
10041 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
10042 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
10043 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
10044 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
10045 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
10046 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
10047 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
10048 { DT_HP_GST
, "HP_GST" },
10049 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
10050 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
10051 { DT_HP_NODELETE
, "HP_NODELETE" },
10052 { DT_HP_GROUP
, "HP_GROUP" },
10053 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
10057 bfd_vma val
= entry
->d_un
.d_val
;
10059 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
10060 if (val
& flags
[cnt
].bit
)
10064 fputs (flags
[cnt
].str
, stdout
);
10066 val
^= flags
[cnt
].bit
;
10069 if (val
!= 0 || first
)
10073 print_vma (val
, HEX
);
10079 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10087 /* VMS vs Unix time offset and factor. */
10089 #define VMS_EPOCH_OFFSET 35067168000000000LL
10090 #define VMS_GRANULARITY_FACTOR 10000000
10092 #define INT64_MIN (-9223372036854775807LL - 1)
10095 /* Display a VMS time in a human readable format. */
10098 print_vms_time (bfd_int64_t vmstime
)
10100 struct tm
*tm
= NULL
;
10103 if (vmstime
>= INT64_MIN
+ VMS_EPOCH_OFFSET
)
10105 vmstime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
10107 if (unxtime
== vmstime
)
10108 tm
= gmtime (&unxtime
);
10111 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
10112 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
10113 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
10118 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
10120 switch (entry
->d_tag
)
10122 case DT_IA_64_PLT_RESERVE
:
10123 /* First 3 slots reserved. */
10124 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10126 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
10129 case DT_IA_64_VMS_LINKTIME
:
10131 print_vms_time (entry
->d_un
.d_val
);
10135 case DT_IA_64_VMS_LNKFLAGS
:
10136 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10137 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
10138 printf (" CALL_DEBUG");
10139 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
10140 printf (" NOP0BUFS");
10141 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
10142 printf (" P0IMAGE");
10143 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
10144 printf (" MKTHREADS");
10145 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
10146 printf (" UPCALLS");
10147 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
10148 printf (" IMGSTA");
10149 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
10150 printf (" INITIALIZE");
10151 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
10153 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
10154 printf (" EXE_INIT");
10155 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
10156 printf (" TBK_IN_IMG");
10157 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
10158 printf (" DBG_IN_IMG");
10159 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
10160 printf (" TBK_IN_DSF");
10161 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
10162 printf (" DBG_IN_DSF");
10163 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
10164 printf (" SIGNATURES");
10165 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
10166 printf (" REL_SEG_OFF");
10170 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10177 get_32bit_dynamic_section (Filedata
* filedata
)
10179 Elf32_External_Dyn
* edyn
;
10180 Elf32_External_Dyn
* ext
;
10181 Elf_Internal_Dyn
* entry
;
10183 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
10184 filedata
->dynamic_addr
, 1,
10185 filedata
->dynamic_size
,
10186 _("dynamic section"));
10190 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
10191 might not have the luxury of section headers. Look for the DT_NULL
10192 terminator to determine the number of entries. */
10193 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
10194 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
10197 filedata
->dynamic_nent
++;
10198 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
10202 filedata
->dynamic_section
10203 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
10204 if (filedata
->dynamic_section
== NULL
)
10206 error (_("Out of memory allocating space for %lu dynamic entries\n"),
10207 (unsigned long) filedata
->dynamic_nent
);
10212 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10213 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10216 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10217 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10226 get_64bit_dynamic_section (Filedata
* filedata
)
10228 Elf64_External_Dyn
* edyn
;
10229 Elf64_External_Dyn
* ext
;
10230 Elf_Internal_Dyn
* entry
;
10232 /* Read in the data. */
10233 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
10234 filedata
->dynamic_addr
, 1,
10235 filedata
->dynamic_size
,
10236 _("dynamic section"));
10240 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
10241 might not have the luxury of section headers. Look for the DT_NULL
10242 terminator to determine the number of entries. */
10243 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
10244 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
10245 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
10248 filedata
->dynamic_nent
++;
10249 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
10253 filedata
->dynamic_section
10254 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
10255 if (filedata
->dynamic_section
== NULL
)
10257 error (_("Out of memory allocating space for %lu dynamic entries\n"),
10258 (unsigned long) filedata
->dynamic_nent
);
10263 /* Convert from external to internal formats. */
10264 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10265 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10268 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10269 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10278 get_dynamic_section (Filedata
*filedata
)
10280 if (filedata
->dynamic_section
)
10284 return get_32bit_dynamic_section (filedata
);
10286 return get_64bit_dynamic_section (filedata
);
10290 print_dynamic_flags (bfd_vma flags
)
10298 flag
= flags
& - flags
;
10304 putc (' ', stdout
);
10308 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
10309 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
10310 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
10311 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
10312 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
10313 default: fputs (_("unknown"), stdout
); break;
10320 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
10322 unsigned char * e_data
;
10325 /* If the size_t type is smaller than the bfd_size_type, eg because
10326 you are building a 32-bit tool on a 64-bit host, then make sure
10327 that when (number) is cast to (size_t) no information is lost. */
10328 if (sizeof (size_t) < sizeof (bfd_size_type
)
10329 && (bfd_size_type
) ((size_t) number
) != number
)
10331 error (_("Size truncation prevents reading %s elements of size %u\n"),
10332 bfd_vmatoa ("u", number
), ent_size
);
10336 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
10337 attempting to allocate memory when the read is bound to fail. */
10338 if (ent_size
* number
> filedata
->file_size
)
10340 error (_("Invalid number of dynamic entries: %s\n"),
10341 bfd_vmatoa ("u", number
));
10345 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10346 if (e_data
== NULL
)
10348 error (_("Out of memory reading %s dynamic entries\n"),
10349 bfd_vmatoa ("u", number
));
10353 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
10355 error (_("Unable to read in %s bytes of dynamic data\n"),
10356 bfd_vmatoa ("u", number
* ent_size
));
10361 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10362 if (i_data
== NULL
)
10364 error (_("Out of memory allocating space for %s dynamic entries\n"),
10365 bfd_vmatoa ("u", number
));
10371 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10378 static unsigned long
10379 get_num_dynamic_syms (Filedata
* filedata
)
10381 unsigned long num_of_syms
= 0;
10383 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
10384 return num_of_syms
;
10386 if (filedata
->dynamic_info
[DT_HASH
])
10388 unsigned char nb
[8];
10389 unsigned char nc
[8];
10390 unsigned int hash_ent_size
= 4;
10392 if ((filedata
->file_header
.e_machine
== EM_ALPHA
10393 || filedata
->file_header
.e_machine
== EM_S390
10394 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
10395 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10398 if (fseek (filedata
->handle
,
10399 (filedata
->archive_file_offset
10400 + offset_from_vma (filedata
, filedata
->dynamic_info
[DT_HASH
],
10401 sizeof nb
+ sizeof nc
)),
10404 error (_("Unable to seek to start of dynamic information\n"));
10408 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
10410 error (_("Failed to read in number of buckets\n"));
10414 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
10416 error (_("Failed to read in number of chains\n"));
10420 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
10421 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
10423 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
10425 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
10427 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
10430 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
10431 num_of_syms
= filedata
->nchains
;
10434 if (num_of_syms
== 0)
10436 free (filedata
->buckets
);
10437 filedata
->buckets
= NULL
;
10438 free (filedata
->chains
);
10439 filedata
->chains
= NULL
;
10440 filedata
->nbuckets
= 0;
10444 if (filedata
->dynamic_info_DT_GNU_HASH
)
10446 unsigned char nb
[16];
10447 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10448 bfd_vma buckets_vma
;
10451 if (fseek (filedata
->handle
,
10452 (filedata
->archive_file_offset
10453 + offset_from_vma (filedata
,
10454 filedata
->dynamic_info_DT_GNU_HASH
,
10458 error (_("Unable to seek to start of dynamic information\n"));
10462 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
10464 error (_("Failed to read in number of buckets\n"));
10468 filedata
->ngnubuckets
= byte_get (nb
, 4);
10469 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
10470 bitmaskwords
= byte_get (nb
+ 8, 4);
10471 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
10473 buckets_vma
+= bitmaskwords
* 4;
10475 buckets_vma
+= bitmaskwords
* 8;
10477 if (fseek (filedata
->handle
,
10478 (filedata
->archive_file_offset
10479 + offset_from_vma (filedata
, buckets_vma
, 4)),
10482 error (_("Unable to seek to start of dynamic information\n"));
10486 filedata
->gnubuckets
10487 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
10489 if (filedata
->gnubuckets
== NULL
)
10492 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
10493 if (filedata
->gnubuckets
[i
] != 0)
10495 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
10498 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
10499 maxchain
= filedata
->gnubuckets
[i
];
10502 if (maxchain
== 0xffffffff)
10505 maxchain
-= filedata
->gnusymidx
;
10507 if (fseek (filedata
->handle
,
10508 (filedata
->archive_file_offset
10509 + offset_from_vma (filedata
,
10510 buckets_vma
+ 4 * (filedata
->ngnubuckets
10515 error (_("Unable to seek to start of dynamic information\n"));
10521 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
10523 error (_("Failed to determine last chain length\n"));
10527 if (maxchain
+ 1 == 0)
10532 while ((byte_get (nb
, 4) & 1) == 0);
10534 if (fseek (filedata
->handle
,
10535 (filedata
->archive_file_offset
10536 + offset_from_vma (filedata
, (buckets_vma
10537 + 4 * filedata
->ngnubuckets
),
10541 error (_("Unable to seek to start of dynamic information\n"));
10545 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
10546 filedata
->ngnuchains
= maxchain
;
10548 if (filedata
->gnuchains
== NULL
)
10551 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10553 if (fseek (filedata
->handle
,
10554 (filedata
->archive_file_offset
10555 + offset_from_vma (filedata
, (buckets_vma
10556 + 4 * (filedata
->ngnubuckets
10560 error (_("Unable to seek to start of dynamic information\n"));
10564 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
10565 if (filedata
->mipsxlat
== NULL
)
10569 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
10570 if (filedata
->gnubuckets
[hn
] != 0)
10572 bfd_vma si
= filedata
->gnubuckets
[hn
];
10573 bfd_vma off
= si
- filedata
->gnusymidx
;
10577 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10579 if (off
< filedata
->ngnuchains
10580 && filedata
->mipsxlat
[off
] >= num_of_syms
)
10581 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
10585 if (si
>= num_of_syms
)
10586 num_of_syms
= si
+ 1;
10590 while (off
< filedata
->ngnuchains
10591 && (filedata
->gnuchains
[off
++] & 1) == 0);
10594 if (num_of_syms
== 0)
10597 free (filedata
->mipsxlat
);
10598 filedata
->mipsxlat
= NULL
;
10599 free (filedata
->gnuchains
);
10600 filedata
->gnuchains
= NULL
;
10601 free (filedata
->gnubuckets
);
10602 filedata
->gnubuckets
= NULL
;
10603 filedata
->ngnubuckets
= 0;
10604 filedata
->ngnuchains
= 0;
10608 return num_of_syms
;
10611 /* Parse and display the contents of the dynamic section. */
10614 process_dynamic_section (Filedata
* filedata
)
10616 Elf_Internal_Dyn
* entry
;
10618 if (filedata
->dynamic_size
== 0)
10622 if (filedata
->is_separate
)
10623 printf (_("\nThere is no dynamic section in linked file '%s'.\n"),
10624 filedata
->file_name
);
10626 printf (_("\nThere is no dynamic section in this file.\n"));
10632 if (!get_dynamic_section (filedata
))
10635 /* Find the appropriate symbol table. */
10636 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
10638 unsigned long num_of_syms
;
10640 for (entry
= filedata
->dynamic_section
;
10641 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10643 if (entry
->d_tag
== DT_SYMTAB
)
10644 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
10645 else if (entry
->d_tag
== DT_SYMENT
)
10646 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
10647 else if (entry
->d_tag
== DT_HASH
)
10648 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
10649 else if (entry
->d_tag
== DT_GNU_HASH
)
10650 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10651 else if ((filedata
->file_header
.e_machine
== EM_MIPS
10652 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
10653 && entry
->d_tag
== DT_MIPS_XHASH
)
10655 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10656 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10659 num_of_syms
= get_num_dynamic_syms (filedata
);
10661 if (num_of_syms
!= 0
10662 && filedata
->dynamic_symbols
== NULL
10663 && filedata
->dynamic_info
[DT_SYMTAB
]
10664 && filedata
->dynamic_info
[DT_SYMENT
])
10666 Elf_Internal_Phdr
*seg
;
10667 bfd_vma vma
= filedata
->dynamic_info
[DT_SYMTAB
];
10669 if (! get_program_headers (filedata
))
10671 error (_("Cannot interpret virtual addresses "
10672 "without program headers.\n"));
10676 for (seg
= filedata
->program_headers
;
10677 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
10680 if (seg
->p_type
!= PT_LOAD
)
10683 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
10685 /* See PR 21379 for a reproducer. */
10686 error (_("Invalid PT_LOAD entry\n"));
10690 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
10691 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
10693 /* Since we do not know how big the symbol table is,
10694 we default to reading in up to the end of PT_LOAD
10695 segment and processing that. This is overkill, I
10696 know, but it should work. */
10697 Elf_Internal_Shdr section
;
10698 section
.sh_offset
= (vma
- seg
->p_vaddr
10700 section
.sh_size
= (num_of_syms
10701 * filedata
->dynamic_info
[DT_SYMENT
]);
10702 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
10705 && filedata
->dynamic_symtab_section
!= NULL
10706 && ((filedata
->dynamic_symtab_section
->sh_offset
10707 != section
.sh_offset
)
10708 || (filedata
->dynamic_symtab_section
->sh_size
10709 != section
.sh_size
)
10710 || (filedata
->dynamic_symtab_section
->sh_entsize
10711 != section
.sh_entsize
)))
10713 the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
10715 section
.sh_name
= filedata
->string_table_length
;
10716 filedata
->dynamic_symbols
10717 = get_elf_symbols (filedata
, §ion
,
10718 &filedata
->num_dynamic_syms
);
10719 if (filedata
->dynamic_symbols
== NULL
10720 || filedata
->num_dynamic_syms
!= num_of_syms
)
10722 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
10731 /* Similarly find a string table. */
10732 if (filedata
->dynamic_strings
== NULL
)
10733 for (entry
= filedata
->dynamic_section
;
10734 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10737 if (entry
->d_tag
== DT_STRTAB
)
10738 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
10740 if (entry
->d_tag
== DT_STRSZ
)
10741 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
10743 if (filedata
->dynamic_info
[DT_STRTAB
]
10744 && filedata
->dynamic_info
[DT_STRSZ
])
10746 unsigned long offset
;
10747 bfd_size_type str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
10749 offset
= offset_from_vma (filedata
,
10750 filedata
->dynamic_info
[DT_STRTAB
],
10753 && filedata
->dynamic_strtab_section
10754 && ((filedata
->dynamic_strtab_section
->sh_offset
10755 != (file_ptr
) offset
)
10756 || (filedata
->dynamic_strtab_section
->sh_size
10759 the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
10761 filedata
->dynamic_strings
10762 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
10763 _("dynamic string table"));
10764 if (filedata
->dynamic_strings
== NULL
)
10766 error (_("Corrupt DT_STRTAB dynamic entry\n"));
10770 filedata
->dynamic_strings_length
= str_tab_len
;
10775 /* And find the syminfo section if available. */
10776 if (filedata
->dynamic_syminfo
== NULL
)
10778 unsigned long syminsz
= 0;
10780 for (entry
= filedata
->dynamic_section
;
10781 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10784 if (entry
->d_tag
== DT_SYMINENT
)
10786 /* Note: these braces are necessary to avoid a syntax
10787 error from the SunOS4 C compiler. */
10788 /* PR binutils/17531: A corrupt file can trigger this test.
10789 So do not use an assert, instead generate an error message. */
10790 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
10791 error (_("Bad value (%d) for SYMINENT entry\n"),
10792 (int) entry
->d_un
.d_val
);
10794 else if (entry
->d_tag
== DT_SYMINSZ
)
10795 syminsz
= entry
->d_un
.d_val
;
10796 else if (entry
->d_tag
== DT_SYMINFO
)
10797 filedata
->dynamic_syminfo_offset
10798 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
10801 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
10803 Elf_External_Syminfo
* extsyminfo
;
10804 Elf_External_Syminfo
* extsym
;
10805 Elf_Internal_Syminfo
* syminfo
;
10807 /* There is a syminfo section. Read the data. */
10808 extsyminfo
= (Elf_External_Syminfo
*)
10809 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
10810 1, syminsz
, _("symbol information"));
10814 if (filedata
->dynamic_syminfo
!= NULL
)
10816 error (_("Multiple dynamic symbol information sections found\n"));
10817 free (filedata
->dynamic_syminfo
);
10819 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10820 if (filedata
->dynamic_syminfo
== NULL
)
10822 error (_("Out of memory allocating %lu bytes "
10823 "for dynamic symbol info\n"),
10824 (unsigned long) syminsz
);
10828 filedata
->dynamic_syminfo_nent
10829 = syminsz
/ sizeof (Elf_External_Syminfo
);
10830 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
10831 syminfo
< (filedata
->dynamic_syminfo
10832 + filedata
->dynamic_syminfo_nent
);
10833 ++syminfo
, ++extsym
)
10835 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10836 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10843 if (do_dynamic
&& filedata
->dynamic_addr
)
10845 if (filedata
->dynamic_nent
== 1)
10847 if (filedata
->is_separate
)
10848 printf (_("\nIn linked file '%s' the dynamic section at offset 0x%lx contains 1 entry:\n"),
10849 filedata
->file_name
,
10850 filedata
->dynamic_addr
);
10852 printf (_("\nDynamic section at offset 0x%lx contains 1 entry:\n"),
10853 filedata
->dynamic_addr
);
10857 if (filedata
->is_separate
)
10858 printf (_("\nIn linked file '%s' the dynamic section at offset 0x%lx contains %lu entries:\n"),
10859 filedata
->file_name
,
10860 filedata
->dynamic_addr
,
10861 (unsigned long) filedata
->dynamic_nent
);
10863 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
10864 filedata
->dynamic_addr
,
10865 (unsigned long) filedata
->dynamic_nent
);
10869 printf (_(" Tag Type Name/Value\n"));
10871 for (entry
= filedata
->dynamic_section
;
10872 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10877 const char * dtype
;
10880 print_vma (entry
->d_tag
, FULL_HEX
);
10881 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10882 printf (" (%s)%*s", dtype
,
10883 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10886 switch (entry
->d_tag
)
10890 print_dynamic_flags (entry
->d_un
.d_val
);
10900 switch (entry
->d_tag
)
10903 printf (_("Auxiliary library"));
10907 printf (_("Filter library"));
10911 printf (_("Configuration file"));
10915 printf (_("Dependency audit library"));
10919 printf (_("Audit library"));
10923 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10924 printf (": [%s]\n",
10925 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
10929 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10938 printf (_("Flags:"));
10940 if (entry
->d_un
.d_val
== 0)
10941 printf (_(" None\n"));
10944 unsigned long int val
= entry
->d_un
.d_val
;
10946 if (val
& DTF_1_PARINIT
)
10948 printf (" PARINIT");
10949 val
^= DTF_1_PARINIT
;
10951 if (val
& DTF_1_CONFEXP
)
10953 printf (" CONFEXP");
10954 val
^= DTF_1_CONFEXP
;
10957 printf (" %lx", val
);
10966 printf (_("Flags:"));
10968 if (entry
->d_un
.d_val
== 0)
10969 printf (_(" None\n"));
10972 unsigned long int val
= entry
->d_un
.d_val
;
10974 if (val
& DF_P1_LAZYLOAD
)
10976 printf (" LAZYLOAD");
10977 val
^= DF_P1_LAZYLOAD
;
10979 if (val
& DF_P1_GROUPPERM
)
10981 printf (" GROUPPERM");
10982 val
^= DF_P1_GROUPPERM
;
10985 printf (" %lx", val
);
10994 printf (_("Flags:"));
10995 if (entry
->d_un
.d_val
== 0)
10996 printf (_(" None\n"));
10999 unsigned long int val
= entry
->d_un
.d_val
;
11001 if (val
& DF_1_NOW
)
11006 if (val
& DF_1_GLOBAL
)
11008 printf (" GLOBAL");
11009 val
^= DF_1_GLOBAL
;
11011 if (val
& DF_1_GROUP
)
11016 if (val
& DF_1_NODELETE
)
11018 printf (" NODELETE");
11019 val
^= DF_1_NODELETE
;
11021 if (val
& DF_1_LOADFLTR
)
11023 printf (" LOADFLTR");
11024 val
^= DF_1_LOADFLTR
;
11026 if (val
& DF_1_INITFIRST
)
11028 printf (" INITFIRST");
11029 val
^= DF_1_INITFIRST
;
11031 if (val
& DF_1_NOOPEN
)
11033 printf (" NOOPEN");
11034 val
^= DF_1_NOOPEN
;
11036 if (val
& DF_1_ORIGIN
)
11038 printf (" ORIGIN");
11039 val
^= DF_1_ORIGIN
;
11041 if (val
& DF_1_DIRECT
)
11043 printf (" DIRECT");
11044 val
^= DF_1_DIRECT
;
11046 if (val
& DF_1_TRANS
)
11051 if (val
& DF_1_INTERPOSE
)
11053 printf (" INTERPOSE");
11054 val
^= DF_1_INTERPOSE
;
11056 if (val
& DF_1_NODEFLIB
)
11058 printf (" NODEFLIB");
11059 val
^= DF_1_NODEFLIB
;
11061 if (val
& DF_1_NODUMP
)
11063 printf (" NODUMP");
11064 val
^= DF_1_NODUMP
;
11066 if (val
& DF_1_CONFALT
)
11068 printf (" CONFALT");
11069 val
^= DF_1_CONFALT
;
11071 if (val
& DF_1_ENDFILTEE
)
11073 printf (" ENDFILTEE");
11074 val
^= DF_1_ENDFILTEE
;
11076 if (val
& DF_1_DISPRELDNE
)
11078 printf (" DISPRELDNE");
11079 val
^= DF_1_DISPRELDNE
;
11081 if (val
& DF_1_DISPRELPND
)
11083 printf (" DISPRELPND");
11084 val
^= DF_1_DISPRELPND
;
11086 if (val
& DF_1_NODIRECT
)
11088 printf (" NODIRECT");
11089 val
^= DF_1_NODIRECT
;
11091 if (val
& DF_1_IGNMULDEF
)
11093 printf (" IGNMULDEF");
11094 val
^= DF_1_IGNMULDEF
;
11096 if (val
& DF_1_NOKSYMS
)
11098 printf (" NOKSYMS");
11099 val
^= DF_1_NOKSYMS
;
11101 if (val
& DF_1_NOHDR
)
11106 if (val
& DF_1_EDITED
)
11108 printf (" EDITED");
11109 val
^= DF_1_EDITED
;
11111 if (val
& DF_1_NORELOC
)
11113 printf (" NORELOC");
11114 val
^= DF_1_NORELOC
;
11116 if (val
& DF_1_SYMINTPOSE
)
11118 printf (" SYMINTPOSE");
11119 val
^= DF_1_SYMINTPOSE
;
11121 if (val
& DF_1_GLOBAUDIT
)
11123 printf (" GLOBAUDIT");
11124 val
^= DF_1_GLOBAUDIT
;
11126 if (val
& DF_1_SINGLETON
)
11128 printf (" SINGLETON");
11129 val
^= DF_1_SINGLETON
;
11131 if (val
& DF_1_STUB
)
11136 if (val
& DF_1_PIE
)
11141 if (val
& DF_1_KMOD
)
11146 if (val
& DF_1_WEAKFILTER
)
11148 printf (" WEAKFILTER");
11149 val
^= DF_1_WEAKFILTER
;
11151 if (val
& DF_1_NOCOMMON
)
11153 printf (" NOCOMMON");
11154 val
^= DF_1_NOCOMMON
;
11157 printf (" %lx", val
);
11164 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11166 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
11186 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11192 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
11193 name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
11199 switch (entry
->d_tag
)
11202 printf (_("Shared library: [%s]"), name
);
11204 if (filedata
->program_interpreter
11205 && streq (name
, filedata
->program_interpreter
))
11206 printf (_(" program interpreter"));
11210 printf (_("Library soname: [%s]"), name
);
11214 printf (_("Library rpath: [%s]"), name
);
11218 printf (_("Library runpath: [%s]"), name
);
11222 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11227 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11240 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11241 /* Fall through. */
11245 case DT_INIT_ARRAYSZ
:
11246 case DT_FINI_ARRAYSZ
:
11247 case DT_GNU_CONFLICTSZ
:
11248 case DT_GNU_LIBLISTSZ
:
11251 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11252 printf (_(" (bytes)\n"));
11257 case DT_VERNEEDNUM
:
11262 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11271 case DT_INIT_ARRAY
:
11272 case DT_FINI_ARRAY
:
11275 if (entry
->d_tag
== DT_USED
11276 && VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
11278 char * name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
11282 printf (_("Not needed object: [%s]\n"), name
);
11287 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11293 /* The value of this entry is ignored. */
11298 case DT_GNU_PRELINKED
:
11302 time_t atime
= entry
->d_un
.d_val
;
11304 tmp
= gmtime (&atime
);
11305 /* PR 17533 file: 041-1244816-0.004. */
11307 printf (_("<corrupt time val: %lx"),
11308 (unsigned long) atime
);
11310 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
11311 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11312 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11318 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11321 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11326 case DT_GNU_FLAGS_1
:
11329 printf (_("Flags:"));
11330 if (entry
->d_un
.d_val
== 0)
11331 printf (_(" None\n"));
11334 unsigned long int val
= entry
->d_un
.d_val
;
11336 if (val
& DF_GNU_1_UNIQUE
)
11338 printf (" UNIQUE");
11339 val
^= DF_GNU_1_UNIQUE
;
11342 printf (" %lx", val
);
11349 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
11350 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
11351 = entry
->d_un
.d_val
;
11355 switch (filedata
->file_header
.e_machine
)
11358 dynamic_section_aarch64_val (entry
);
11361 case EM_MIPS_RS3_LE
:
11362 dynamic_section_mips_val (filedata
, entry
);
11365 dynamic_section_parisc_val (entry
);
11368 dynamic_section_ia64_val (entry
);
11371 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11383 get_ver_flags (unsigned int flags
)
11385 static char buff
[128];
11392 if (flags
& VER_FLG_BASE
)
11393 strcat (buff
, "BASE");
11395 if (flags
& VER_FLG_WEAK
)
11397 if (flags
& VER_FLG_BASE
)
11398 strcat (buff
, " | ");
11400 strcat (buff
, "WEAK");
11403 if (flags
& VER_FLG_INFO
)
11405 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
11406 strcat (buff
, " | ");
11408 strcat (buff
, "INFO");
11411 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11413 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11414 strcat (buff
, " | ");
11416 strcat (buff
, _("<unknown>"));
11422 /* Display the contents of the version sections. */
11425 process_version_sections (Filedata
* filedata
)
11427 Elf_Internal_Shdr
* section
;
11429 bool found
= false;
11434 for (i
= 0, section
= filedata
->section_headers
;
11435 i
< filedata
->file_header
.e_shnum
;
11438 switch (section
->sh_type
)
11440 case SHT_GNU_verdef
:
11442 Elf_External_Verdef
* edefs
;
11449 if (filedata
->is_separate
)
11450 printf (ngettext ("\nIn linked file '%s' the version definition section '%s' contains %u entry:\n",
11451 "\nIn linked file '%s' the version definition section '%s' contains %u entries:\n",
11453 filedata
->file_name
,
11454 printable_section_name (filedata
, section
),
11457 printf (ngettext ("\nVersion definition section '%s' "
11458 "contains %u entry:\n",
11459 "\nVersion definition section '%s' "
11460 "contains %u entries:\n",
11462 printable_section_name (filedata
, section
),
11465 printf (_(" Addr: 0x"));
11466 printf_vma (section
->sh_addr
);
11467 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11468 (unsigned long) section
->sh_offset
, section
->sh_link
,
11469 printable_section_name_from_index (filedata
, section
->sh_link
));
11471 edefs
= (Elf_External_Verdef
*)
11472 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
11473 _("version definition section"));
11476 endbuf
= (char *) edefs
+ section
->sh_size
;
11478 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11481 Elf_External_Verdef
* edef
;
11482 Elf_Internal_Verdef ent
;
11483 Elf_External_Verdaux
* eaux
;
11484 Elf_Internal_Verdaux aux
;
11485 unsigned long isum
;
11488 vstart
= ((char *) edefs
) + idx
;
11489 if (vstart
+ sizeof (*edef
) > endbuf
)
11492 edef
= (Elf_External_Verdef
*) vstart
;
11494 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
11495 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
11496 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
11497 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
11498 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
11499 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
11500 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
11502 printf (_(" %#06lx: Rev: %d Flags: %s"),
11503 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
11505 printf (_(" Index: %d Cnt: %d "),
11506 ent
.vd_ndx
, ent
.vd_cnt
);
11508 /* Check for overflow. */
11509 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
11512 vstart
+= ent
.vd_aux
;
11514 if (vstart
+ sizeof (*eaux
) > endbuf
)
11516 eaux
= (Elf_External_Verdaux
*) vstart
;
11518 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11519 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11521 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11522 printf (_("Name: %s\n"),
11523 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11525 printf (_("Name index: %ld\n"), aux
.vda_name
);
11527 isum
= idx
+ ent
.vd_aux
;
11529 for (j
= 1; j
< ent
.vd_cnt
; j
++)
11531 if (aux
.vda_next
< sizeof (*eaux
)
11532 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
11534 warn (_("Invalid vda_next field of %lx\n"),
11539 /* Check for overflow. */
11540 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
11543 isum
+= aux
.vda_next
;
11544 vstart
+= aux
.vda_next
;
11546 if (vstart
+ sizeof (*eaux
) > endbuf
)
11548 eaux
= (Elf_External_Verdaux
*) vstart
;
11550 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11551 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11553 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11554 printf (_(" %#06lx: Parent %d: %s\n"),
11556 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11558 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
11559 isum
, j
, aux
.vda_name
);
11562 if (j
< ent
.vd_cnt
)
11563 printf (_(" Version def aux past end of section\n"));
11566 file: id:000001,src:000172+005151,op:splice,rep:2. */
11567 if (ent
.vd_next
< sizeof (*edef
)
11568 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
11570 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
11571 cnt
= section
->sh_info
;
11574 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
11577 idx
+= ent
.vd_next
;
11580 if (cnt
< section
->sh_info
)
11581 printf (_(" Version definition past end of section\n"));
11587 case SHT_GNU_verneed
:
11589 Elf_External_Verneed
* eneed
;
11596 if (filedata
->is_separate
)
11597 printf (ngettext ("\nIn linked file '%s' the version needs section '%s' contains %u entry:\n",
11598 "\nIn linked file '%s' the version needs section '%s' contains %u entries:\n",
11600 filedata
->file_name
,
11601 printable_section_name (filedata
, section
),
11604 printf (ngettext ("\nVersion needs section '%s' "
11605 "contains %u entry:\n",
11606 "\nVersion needs section '%s' "
11607 "contains %u entries:\n",
11609 printable_section_name (filedata
, section
),
11612 printf (_(" Addr: 0x"));
11613 printf_vma (section
->sh_addr
);
11614 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11615 (unsigned long) section
->sh_offset
, section
->sh_link
,
11616 printable_section_name_from_index (filedata
, section
->sh_link
));
11618 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
11619 section
->sh_offset
, 1,
11621 _("Version Needs section"));
11624 endbuf
= (char *) eneed
+ section
->sh_size
;
11626 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11628 Elf_External_Verneed
* entry
;
11629 Elf_Internal_Verneed ent
;
11630 unsigned long isum
;
11634 vstart
= ((char *) eneed
) + idx
;
11635 if (vstart
+ sizeof (*entry
) > endbuf
)
11638 entry
= (Elf_External_Verneed
*) vstart
;
11640 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
11641 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
11642 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
11643 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
11644 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
11646 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
11648 if (VALID_DYNAMIC_NAME (filedata
, ent
.vn_file
))
11649 printf (_(" File: %s"),
11650 GET_DYNAMIC_NAME (filedata
, ent
.vn_file
));
11652 printf (_(" File: %lx"), ent
.vn_file
);
11654 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
11656 /* Check for overflow. */
11657 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
11659 vstart
+= ent
.vn_aux
;
11661 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
11663 Elf_External_Vernaux
* eaux
;
11664 Elf_Internal_Vernaux aux
;
11666 if (vstart
+ sizeof (*eaux
) > endbuf
)
11668 eaux
= (Elf_External_Vernaux
*) vstart
;
11670 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
11671 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
11672 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
11673 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
11674 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
11676 if (VALID_DYNAMIC_NAME (filedata
, aux
.vna_name
))
11677 printf (_(" %#06lx: Name: %s"),
11678 isum
, GET_DYNAMIC_NAME (filedata
, aux
.vna_name
));
11680 printf (_(" %#06lx: Name index: %lx"),
11681 isum
, aux
.vna_name
);
11683 printf (_(" Flags: %s Version: %d\n"),
11684 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
11686 if (aux
.vna_next
< sizeof (*eaux
)
11687 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
11689 warn (_("Invalid vna_next field of %lx\n"),
11694 /* Check for overflow. */
11695 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
11697 isum
+= aux
.vna_next
;
11698 vstart
+= aux
.vna_next
;
11701 if (j
< ent
.vn_cnt
)
11702 warn (_("Missing Version Needs auxiliary information\n"));
11704 if (ent
.vn_next
< sizeof (*entry
)
11705 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
11707 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
11708 cnt
= section
->sh_info
;
11711 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
11713 idx
+= ent
.vn_next
;
11716 if (cnt
< section
->sh_info
)
11717 warn (_("Missing Version Needs information\n"));
11723 case SHT_GNU_versym
:
11725 Elf_Internal_Shdr
* link_section
;
11728 unsigned char * edata
;
11729 unsigned short * data
;
11731 Elf_Internal_Sym
* symbols
;
11732 Elf_Internal_Shdr
* string_sec
;
11733 unsigned long num_syms
;
11736 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
11739 link_section
= filedata
->section_headers
+ section
->sh_link
;
11740 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
11742 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
11747 symbols
= get_elf_symbols (filedata
, link_section
, & num_syms
);
11748 if (symbols
== NULL
)
11751 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
11753 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
11754 string_sec
->sh_size
,
11755 _("version string table"));
11762 if (filedata
->is_separate
)
11763 printf (ngettext ("\nIn linked file '%s' the version symbols section '%s' contains %lu entry:\n",
11764 "\nIn linked file '%s' the version symbols section '%s' contains %lu entries:\n",
11766 filedata
->file_name
,
11767 printable_section_name (filedata
, section
),
11768 (unsigned long) total
);
11770 printf (ngettext ("\nVersion symbols section '%s' "
11771 "contains %lu entry:\n",
11772 "\nVersion symbols section '%s' "
11773 "contains %lu entries:\n",
11775 printable_section_name (filedata
, section
),
11776 (unsigned long) total
);
11778 printf (_(" Addr: 0x"));
11779 printf_vma (section
->sh_addr
);
11780 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11781 (unsigned long) section
->sh_offset
, section
->sh_link
,
11782 printable_section_name (filedata
, link_section
));
11784 off
= offset_from_vma (filedata
,
11785 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11786 total
* sizeof (short));
11787 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
11788 sizeof (short), total
,
11789 _("version symbol data"));
11797 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
11799 for (cnt
= total
; cnt
--;)
11800 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
11805 for (cnt
= 0; cnt
< total
; cnt
+= 4)
11809 char *invalid
= _("*invalid*");
11811 printf (" %03x:", cnt
);
11813 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
11814 switch (data
[cnt
+ j
])
11817 fputs (_(" 0 (*local*) "), stdout
);
11821 fputs (_(" 1 (*global*) "), stdout
);
11825 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
11826 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
11828 /* If this index value is greater than the size of the symbols
11829 array, break to avoid an out-of-bounds read. */
11830 if ((unsigned long)(cnt
+ j
) >= num_syms
)
11832 warn (_("invalid index into symbol array\n"));
11837 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11839 Elf_Internal_Verneed ivn
;
11840 unsigned long offset
;
11842 offset
= offset_from_vma
11844 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11845 sizeof (Elf_External_Verneed
));
11849 Elf_Internal_Vernaux ivna
;
11850 Elf_External_Verneed evn
;
11851 Elf_External_Vernaux evna
;
11852 unsigned long a_off
;
11854 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11855 _("version need")) == NULL
)
11858 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11859 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11861 a_off
= offset
+ ivn
.vn_aux
;
11865 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
11866 1, _("version need aux (2)")) == NULL
)
11869 ivna
.vna_other
= 0;
11873 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11874 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11877 a_off
+= ivna
.vna_next
;
11879 while (ivna
.vna_other
!= data
[cnt
+ j
]
11880 && ivna
.vna_next
!= 0);
11882 if (ivna
.vna_other
== data
[cnt
+ j
])
11884 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11886 if (ivna
.vna_name
>= string_sec
->sh_size
)
11889 name
= strtab
+ ivna
.vna_name
;
11893 offset
+= ivn
.vn_next
;
11895 while (ivn
.vn_next
);
11898 if (data
[cnt
+ j
] != 0x8001
11899 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11901 Elf_Internal_Verdef ivd
;
11902 Elf_External_Verdef evd
;
11903 unsigned long offset
;
11905 offset
= offset_from_vma
11907 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11912 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11913 _("version def")) == NULL
)
11916 /* PR 17531: file: 046-1082287-0.004. */
11917 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11922 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11923 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11926 offset
+= ivd
.vd_next
;
11928 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11929 && ivd
.vd_next
!= 0);
11931 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11933 Elf_External_Verdaux evda
;
11934 Elf_Internal_Verdaux ivda
;
11936 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11938 if (get_data (&evda
, filedata
,
11939 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11941 _("version def aux")) == NULL
)
11944 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11946 if (ivda
.vda_name
>= string_sec
->sh_size
)
11948 else if (name
!= NULL
&& name
!= invalid
)
11949 name
= _("*both*");
11951 name
= strtab
+ ivda
.vda_name
;
11955 nn
+= printf ("(%s%-*s",
11957 12 - (int) strlen (name
),
11961 printf ("%*c", 18 - nn
, ' ');
11980 if (filedata
->is_separate
)
11981 printf (_("\nNo version information found in linked file '%s'.\n"),
11982 filedata
->file_name
);
11984 printf (_("\nNo version information found in this file.\n"));
11990 static const char *
11991 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11993 static char buff
[64];
11997 case STB_LOCAL
: return "LOCAL";
11998 case STB_GLOBAL
: return "GLOBAL";
11999 case STB_WEAK
: return "WEAK";
12001 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
12002 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
12004 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
12006 if (binding
== STB_GNU_UNIQUE
12007 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
12009 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
12012 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
12017 static const char *
12018 get_symbol_type (Filedata
* filedata
, unsigned int type
)
12020 static char buff
[64];
12024 case STT_NOTYPE
: return "NOTYPE";
12025 case STT_OBJECT
: return "OBJECT";
12026 case STT_FUNC
: return "FUNC";
12027 case STT_SECTION
: return "SECTION";
12028 case STT_FILE
: return "FILE";
12029 case STT_COMMON
: return "COMMON";
12030 case STT_TLS
: return "TLS";
12031 case STT_RELC
: return "RELC";
12032 case STT_SRELC
: return "SRELC";
12034 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
12036 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
12037 return "THUMB_FUNC";
12039 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
12042 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
12043 return "PARISC_MILLI";
12045 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
12047 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
12049 if (filedata
->file_header
.e_machine
== EM_PARISC
)
12051 if (type
== STT_HP_OPAQUE
)
12052 return "HP_OPAQUE";
12053 if (type
== STT_HP_STUB
)
12057 if (type
== STT_GNU_IFUNC
12058 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
12059 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
12062 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
12065 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
12070 static const char *
12071 get_symbol_visibility (unsigned int visibility
)
12073 switch (visibility
)
12075 case STV_DEFAULT
: return "DEFAULT";
12076 case STV_INTERNAL
: return "INTERNAL";
12077 case STV_HIDDEN
: return "HIDDEN";
12078 case STV_PROTECTED
: return "PROTECTED";
12080 error (_("Unrecognized visibility value: %u\n"), visibility
);
12081 return _("<unknown>");
12085 static const char *
12086 get_alpha_symbol_other (unsigned int other
)
12090 case STO_ALPHA_NOPV
: return "NOPV";
12091 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
12093 error (_("Unrecognized alpha specific other value: %u\n"), other
);
12094 return _("<unknown>");
12098 static const char *
12099 get_solaris_symbol_visibility (unsigned int visibility
)
12101 switch (visibility
)
12103 case 4: return "EXPORTED";
12104 case 5: return "SINGLETON";
12105 case 6: return "ELIMINATE";
12106 default: return get_symbol_visibility (visibility
);
12110 static const char *
12111 get_aarch64_symbol_other (unsigned int other
)
12113 static char buf
[32];
12115 if (other
& STO_AARCH64_VARIANT_PCS
)
12117 other
&= ~STO_AARCH64_VARIANT_PCS
;
12119 return "VARIANT_PCS";
12120 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
12126 static const char *
12127 get_mips_symbol_other (unsigned int other
)
12131 case STO_OPTIONAL
: return "OPTIONAL";
12132 case STO_MIPS_PLT
: return "MIPS PLT";
12133 case STO_MIPS_PIC
: return "MIPS PIC";
12134 case STO_MICROMIPS
: return "MICROMIPS";
12135 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
12136 case STO_MIPS16
: return "MIPS16";
12137 default: return NULL
;
12141 static const char *
12142 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
12144 if (is_ia64_vms (filedata
))
12146 static char res
[32];
12150 /* Function types is for images and .STB files only. */
12151 switch (filedata
->file_header
.e_type
)
12155 switch (VMS_ST_FUNC_TYPE (other
))
12157 case VMS_SFT_CODE_ADDR
:
12158 strcat (res
, " CA");
12160 case VMS_SFT_SYMV_IDX
:
12161 strcat (res
, " VEC");
12164 strcat (res
, " FD");
12166 case VMS_SFT_RESERVE
:
12167 strcat (res
, " RSV");
12170 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
12171 VMS_ST_FUNC_TYPE (other
));
12172 strcat (res
, " <unknown>");
12179 switch (VMS_ST_LINKAGE (other
))
12181 case VMS_STL_IGNORE
:
12182 strcat (res
, " IGN");
12184 case VMS_STL_RESERVE
:
12185 strcat (res
, " RSV");
12188 strcat (res
, " STD");
12191 strcat (res
, " LNK");
12194 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
12195 VMS_ST_LINKAGE (other
));
12196 strcat (res
, " <unknown>");
12208 static const char *
12209 get_ppc64_symbol_other (unsigned int other
)
12211 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
12214 other
>>= STO_PPC64_LOCAL_BIT
;
12217 static char buf
[64];
12219 other
= ppc64_decode_local_entry (other
);
12220 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
12226 static const char *
12227 get_symbol_other (Filedata
* filedata
, unsigned int other
)
12229 const char * result
= NULL
;
12230 static char buff
[64];
12235 switch (filedata
->file_header
.e_machine
)
12238 result
= get_alpha_symbol_other (other
);
12241 result
= get_aarch64_symbol_other (other
);
12244 result
= get_mips_symbol_other (other
);
12247 result
= get_ia64_symbol_other (filedata
, other
);
12250 result
= get_ppc64_symbol_other (other
);
12260 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
12264 static const char *
12265 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
12267 static char buff
[32];
12271 case SHN_UNDEF
: return "UND";
12272 case SHN_ABS
: return "ABS";
12273 case SHN_COMMON
: return "COM";
12275 if (type
== SHN_IA_64_ANSI_COMMON
12276 && filedata
->file_header
.e_machine
== EM_IA_64
12277 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
12279 else if ((filedata
->file_header
.e_machine
== EM_X86_64
12280 || filedata
->file_header
.e_machine
== EM_L1OM
12281 || filedata
->file_header
.e_machine
== EM_K1OM
)
12282 && type
== SHN_X86_64_LCOMMON
)
12283 return "LARGE_COM";
12284 else if ((type
== SHN_MIPS_SCOMMON
12285 && filedata
->file_header
.e_machine
== EM_MIPS
)
12286 || (type
== SHN_TIC6X_SCOMMON
12287 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
12289 else if (type
== SHN_MIPS_SUNDEFINED
12290 && filedata
->file_header
.e_machine
== EM_MIPS
)
12292 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
12293 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
12294 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
12295 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
12296 else if (type
>= SHN_LORESERVE
)
12297 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
12298 else if (filedata
->file_header
.e_shnum
!= 0
12299 && type
>= filedata
->file_header
.e_shnum
)
12300 sprintf (buff
, _("bad section index[%3d]"), type
);
12302 sprintf (buff
, "%3d", type
);
12309 static const char *
12310 get_symbol_version_string (Filedata
* filedata
,
12312 const char * strtab
,
12313 unsigned long int strtab_size
,
12315 Elf_Internal_Sym
* psym
,
12316 enum versioned_symbol_info
* sym_info
,
12317 unsigned short * vna_other
)
12319 unsigned char data
[2];
12320 unsigned short vers_data
;
12321 unsigned long offset
;
12322 unsigned short max_vd_ndx
;
12325 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
12328 offset
= offset_from_vma (filedata
,
12329 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
12330 sizeof data
+ si
* sizeof (vers_data
));
12332 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
12333 sizeof (data
), 1, _("version data")) == NULL
)
12336 vers_data
= byte_get (data
, 2);
12338 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
12341 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
12344 /* Usually we'd only see verdef for defined symbols, and verneed for
12345 undefined symbols. However, symbols defined by the linker in
12346 .dynbss for variables copied from a shared library in order to
12347 avoid text relocations are defined yet have verneed. We could
12348 use a heuristic to detect the special case, for example, check
12349 for verneed first on symbols defined in SHT_NOBITS sections, but
12350 it is simpler and more reliable to just look for both verdef and
12351 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
12353 if (psym
->st_shndx
!= SHN_UNDEF
12354 && vers_data
!= 0x8001
12355 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
12357 Elf_Internal_Verdef ivd
;
12358 Elf_Internal_Verdaux ivda
;
12359 Elf_External_Verdaux evda
;
12362 off
= offset_from_vma (filedata
,
12363 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
12364 sizeof (Elf_External_Verdef
));
12368 Elf_External_Verdef evd
;
12370 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
12371 _("version def")) == NULL
)
12380 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
12381 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
12382 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
12383 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
12386 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
12387 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
12389 off
+= ivd
.vd_next
;
12391 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
12393 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
12395 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
12398 off
-= ivd
.vd_next
;
12401 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
12402 _("version def aux")) != NULL
)
12404 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
12406 if (psym
->st_name
!= ivda
.vda_name
)
12407 return (ivda
.vda_name
< strtab_size
12408 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
12413 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
12415 Elf_External_Verneed evn
;
12416 Elf_Internal_Verneed ivn
;
12417 Elf_Internal_Vernaux ivna
;
12419 offset
= offset_from_vma (filedata
,
12420 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
12424 unsigned long vna_off
;
12426 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
12427 _("version need")) == NULL
)
12430 ivna
.vna_other
= 0;
12435 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
12436 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
12438 vna_off
= offset
+ ivn
.vn_aux
;
12442 Elf_External_Vernaux evna
;
12444 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
12445 _("version need aux (3)")) == NULL
)
12448 ivna
.vna_other
= 0;
12453 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
12454 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
12455 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
12458 vna_off
+= ivna
.vna_next
;
12460 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
12462 if (ivna
.vna_other
== vers_data
)
12465 offset
+= ivn
.vn_next
;
12467 while (ivn
.vn_next
!= 0);
12469 if (ivna
.vna_other
== vers_data
)
12471 *sym_info
= symbol_undefined
;
12472 *vna_other
= ivna
.vna_other
;
12473 return (ivna
.vna_name
< strtab_size
12474 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
12476 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
12477 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
12478 return _("<corrupt>");
12483 /* Display a symbol size on stdout. Format is based on --sym-base setting. */
12485 static unsigned int
12486 print_dynamic_symbol_size (bfd_vma vma
, int base
)
12491 return print_vma (vma
, OCTAL_5
);
12494 return print_vma (vma
, UNSIGNED_5
);
12497 return print_vma (vma
, PREFIX_HEX_5
);
12501 return print_vma (vma
, DEC_5
);
12506 print_dynamic_symbol (Filedata
*filedata
, unsigned long si
,
12507 Elf_Internal_Sym
*symtab
,
12508 Elf_Internal_Shdr
*section
,
12509 char *strtab
, size_t strtab_size
)
12511 const char *version_string
;
12512 enum versioned_symbol_info sym_info
;
12513 unsigned short vna_other
;
12516 Elf_Internal_Sym
*psym
= symtab
+ si
;
12518 printf ("%6ld: ", si
);
12519 print_vma (psym
->st_value
, LONG_HEX
);
12521 print_dynamic_symbol_size (psym
->st_size
, sym_base
);
12522 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12523 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12524 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12525 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12528 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12530 printf (" %-7s", get_symbol_visibility (vis
));
12531 /* Check to see if any other bits in the st_other field are set.
12532 Note - displaying this information disrupts the layout of the
12533 table being generated, but for the moment this case is very rare. */
12534 if (psym
->st_other
^ vis
)
12535 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12537 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12539 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
12540 && psym
->st_shndx
< filedata
->file_header
.e_shnum
12541 && psym
->st_name
== 0)
12543 is_valid
= SECTION_NAME_VALID (filedata
->section_headers
+ psym
->st_shndx
);
12545 SECTION_NAME_PRINT (filedata
->section_headers
+ psym
->st_shndx
)
12550 is_valid
= VALID_SYMBOL_NAME (strtab
, strtab_size
, psym
->st_name
);
12551 sstr
= is_valid
? strtab
+ psym
->st_name
: _("<corrupt>");
12555 = get_symbol_version_string (filedata
,
12557 || section
->sh_type
== SHT_DYNSYM
),
12558 strtab
, strtab_size
, si
,
12559 psym
, &sym_info
, &vna_other
);
12561 int len_avail
= 21;
12562 if (! do_wide
&& version_string
!= NULL
)
12566 len_avail
-= 1 + strlen (version_string
);
12568 if (sym_info
== symbol_undefined
)
12569 len_avail
-= sprintf (buffer
," (%d)", vna_other
);
12570 else if (sym_info
!= symbol_hidden
)
12574 print_symbol (len_avail
, sstr
);
12576 if (version_string
)
12578 if (sym_info
== symbol_undefined
)
12579 printf ("@%s (%d)", version_string
, vna_other
);
12581 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12587 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12589 && si
>= section
->sh_info
12590 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12591 && filedata
->file_header
.e_machine
!= EM_MIPS
12592 /* Solaris binaries have been found to violate this requirement as
12593 well. Not sure if this is a bug or an ABI requirement. */
12594 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12595 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12596 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12599 static const char *
12600 get_lto_kind (unsigned int kind
)
12604 case 0: return "DEF";
12605 case 1: return "WEAKDEF";
12606 case 2: return "UNDEF";
12607 case 3: return "WEAKUNDEF";
12608 case 4: return "COMMON";
12613 static char buffer
[30];
12614 error (_("Unknown LTO symbol definition encountered: %u\n"), kind
);
12615 sprintf (buffer
, "<unknown: %u>", kind
);
12619 static const char *
12620 get_lto_visibility (unsigned int visibility
)
12622 switch (visibility
)
12624 case 0: return "DEFAULT";
12625 case 1: return "PROTECTED";
12626 case 2: return "INTERNAL";
12627 case 3: return "HIDDEN";
12632 static char buffer
[30];
12633 error (_("Unknown LTO symbol visibility encountered: %u\n"), visibility
);
12634 sprintf (buffer
, "<unknown: %u>", visibility
);
12638 static const char *
12639 get_lto_sym_type (unsigned int sym_type
)
12643 case 0: return "UNKNOWN";
12644 case 1: return "FUNCTION";
12645 case 2: return "VARIABLE";
12650 static char buffer
[30];
12651 error (_("Unknown LTO symbol type encountered: %u\n"), sym_type
);
12652 sprintf (buffer
, "<unknown: %u>", sym_type
);
12656 /* Display an LTO format symbol table.
12657 FIXME: The format of LTO symbol tables is not formalized.
12658 So this code could need changing in the future. */
12661 display_lto_symtab (Filedata
* filedata
,
12662 Elf_Internal_Shdr
* section
)
12664 if (section
->sh_size
== 0)
12666 if (filedata
->is_separate
)
12667 printf (_("\nThe LTO Symbol table section '%s' in linked file '%s' is empty!\n"),
12668 printable_section_name (filedata
, section
),
12669 filedata
->file_name
);
12671 printf (_("\nLTO Symbol table '%s' is empty!\n"),
12672 printable_section_name (filedata
, section
));
12677 if (section
->sh_size
> filedata
->file_size
)
12679 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
12680 printable_section_name (filedata
, section
),
12681 (unsigned long) section
->sh_size
);
12685 void * alloced_data
= get_data (NULL
, filedata
, section
->sh_offset
,
12686 section
->sh_size
, 1, _("LTO symbols"));
12687 if (alloced_data
== NULL
)
12690 /* Look for extended data for the symbol table. */
12691 Elf_Internal_Shdr
* ext
;
12692 void * ext_data_orig
= NULL
;
12693 char * ext_data
= NULL
;
12694 char * ext_data_end
= NULL
;
12695 char * ext_name
= NULL
;
12697 if (asprintf (& ext_name
, ".gnu.lto_.ext_symtab.%s",
12698 SECTION_NAME (section
) + sizeof (".gnu.lto_.symtab.") - 1) > 0
12699 && ext_name
!= NULL
/* Paranoia. */
12700 && (ext
= find_section (filedata
, ext_name
)) != NULL
)
12702 if (ext
->sh_size
< 3)
12703 error (_("LTO Symbol extension table '%s' is empty!\n"),
12704 printable_section_name (filedata
, ext
));
12707 ext_data_orig
= ext_data
= get_data (NULL
, filedata
, ext
->sh_offset
,
12709 _("LTO ext symbol data"));
12710 if (ext_data
!= NULL
)
12712 ext_data_end
= ext_data
+ ext
->sh_size
;
12713 if (* ext_data
++ != 1)
12714 error (_("Unexpected version number in symbol extension table\n"));
12719 const unsigned char * data
= (const unsigned char *) alloced_data
;
12720 const unsigned char * end
= data
+ section
->sh_size
;
12722 if (filedata
->is_separate
)
12723 printf (_("\nIn linked file '%s': "), filedata
->file_name
);
12727 if (ext_data_orig
!= NULL
)
12730 printf (_("LTO Symbol table '%s' and extension table '%s' contain:\n"),
12731 printable_section_name (filedata
, section
),
12732 printable_section_name (filedata
, ext
));
12735 printf (_("LTO Symbol table '%s'\n"),
12736 printable_section_name (filedata
, section
));
12737 printf (_(" and extension table '%s' contain:\n"),
12738 printable_section_name (filedata
, ext
));
12742 printf (_("LTO Symbol table '%s' contains:\n"),
12743 printable_section_name (filedata
, section
));
12745 /* FIXME: Add a wide version. */
12746 if (ext_data_orig
!= NULL
)
12747 printf (_(" Comdat_Key Kind Visibility Size Slot Type Section Name\n"));
12749 printf (_(" Comdat_Key Kind Visibility Size Slot Name\n"));
12751 /* FIXME: We do not handle style prefixes. */
12755 const unsigned char * sym_name
= data
;
12756 data
+= strnlen ((const char *) sym_name
, end
- data
) + 1;
12760 const unsigned char * comdat_key
= data
;
12761 data
+= strnlen ((const char *) comdat_key
, end
- data
) + 1;
12765 if (data
+ 2 + 8 + 4 > end
)
12768 unsigned int kind
= *data
++;
12769 unsigned int visibility
= *data
++;
12771 elf_vma size
= byte_get (data
, 8);
12774 elf_vma slot
= byte_get (data
, 4);
12777 if (ext_data
!= NULL
)
12779 if (ext_data
< (ext_data_end
- 1))
12781 unsigned int sym_type
= * ext_data
++;
12782 unsigned int sec_kind
= * ext_data
++;
12784 printf (" %10s %10s %11s %08lx %08lx %9s %08lx _",
12785 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
12786 get_lto_kind (kind
),
12787 get_lto_visibility (visibility
),
12790 get_lto_sym_type (sym_type
),
12792 print_symbol (6, (const char *) sym_name
);
12796 error (_("Ran out of LTO symbol extension data\n"));
12798 /* FIXME: return FAIL result ? */
12803 printf (" %10s %10s %11s %08lx %08lx _",
12804 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
12805 get_lto_kind (kind
),
12806 get_lto_visibility (visibility
),
12809 print_symbol (21, (const char *) sym_name
);
12814 if (ext_data
!= NULL
&& ext_data
< ext_data_end
)
12816 error (_("Data remains in the LTO symbol extension table\n"));
12820 free (alloced_data
);
12821 free (ext_data_orig
);
12826 error (_("Buffer overrun encountered whilst decoding LTO symbol table\n"));
12827 free (alloced_data
);
12828 free (ext_data_orig
);
12833 /* Display LTO symbol tables. */
12836 process_lto_symbol_tables (Filedata
* filedata
)
12838 Elf_Internal_Shdr
* section
;
12845 if (filedata
->section_headers
== NULL
)
12848 for (i
= 0, section
= filedata
->section_headers
;
12849 i
< filedata
->file_header
.e_shnum
;
12851 if (SECTION_NAME_VALID (section
)
12852 && startswith (SECTION_NAME (section
), ".gnu.lto_.symtab."))
12853 res
&= display_lto_symtab (filedata
, section
);
12858 /* Dump the symbol table. */
12861 process_symbol_table (Filedata
* filedata
)
12863 Elf_Internal_Shdr
* section
;
12865 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
12868 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
12870 && do_using_dynamic
12871 && filedata
->dynamic_strings
!= NULL
12872 && filedata
->dynamic_symbols
!= NULL
)
12876 if (filedata
->is_separate
)
12878 printf (ngettext ("\nIn linked file '%s' the dynamic symbol table contains %lu entry:\n",
12879 "\nIn linked file '%s' the dynamic symbol table contains %lu entries:\n",
12880 filedata
->num_dynamic_syms
),
12881 filedata
->file_name
,
12882 filedata
->num_dynamic_syms
);
12886 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
12887 "\nSymbol table for image contains %lu entries:\n",
12888 filedata
->num_dynamic_syms
),
12889 filedata
->num_dynamic_syms
);
12892 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12894 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12896 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
12897 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
12898 filedata
->dynamic_strings
,
12899 filedata
->dynamic_strings_length
);
12901 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
12902 && filedata
->section_headers
!= NULL
)
12906 for (i
= 0, section
= filedata
->section_headers
;
12907 i
< filedata
->file_header
.e_shnum
;
12910 char * strtab
= NULL
;
12911 unsigned long int strtab_size
= 0;
12912 Elf_Internal_Sym
* symtab
;
12913 unsigned long si
, num_syms
;
12915 if ((section
->sh_type
!= SHT_SYMTAB
12916 && section
->sh_type
!= SHT_DYNSYM
)
12918 && section
->sh_type
== SHT_SYMTAB
))
12921 if (section
->sh_entsize
== 0)
12923 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12924 printable_section_name (filedata
, section
));
12928 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12930 if (filedata
->is_separate
)
12931 printf (ngettext ("\nIn linked file '%s' symbol section '%s' contains %lu entry:\n",
12932 "\nIn linked file '%s' symbol section '%s' contains %lu entries:\n",
12934 filedata
->file_name
,
12935 printable_section_name (filedata
, section
),
12938 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12939 "\nSymbol table '%s' contains %lu entries:\n",
12941 printable_section_name (filedata
, section
),
12945 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12947 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12949 symtab
= get_elf_symbols (filedata
, section
, & num_syms
);
12950 if (symtab
== NULL
)
12953 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12955 strtab
= filedata
->string_table
;
12956 strtab_size
= filedata
->string_table_length
;
12958 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12960 Elf_Internal_Shdr
* string_sec
;
12962 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12964 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12965 1, string_sec
->sh_size
,
12966 _("string table"));
12967 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12970 for (si
= 0; si
< num_syms
; si
++)
12971 print_dynamic_symbol (filedata
, si
, symtab
, section
,
12972 strtab
, strtab_size
);
12975 if (strtab
!= filedata
->string_table
)
12981 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12983 if (do_histogram
&& filedata
->buckets
!= NULL
)
12985 unsigned long * lengths
;
12986 unsigned long * counts
;
12989 unsigned long maxlength
= 0;
12990 unsigned long nzero_counts
= 0;
12991 unsigned long nsyms
= 0;
12994 printf (ngettext ("\nHistogram for bucket list length "
12995 "(total of %lu bucket):\n",
12996 "\nHistogram for bucket list length "
12997 "(total of %lu buckets):\n",
12998 (unsigned long) filedata
->nbuckets
),
12999 (unsigned long) filedata
->nbuckets
);
13001 lengths
= (unsigned long *) calloc (filedata
->nbuckets
,
13002 sizeof (*lengths
));
13003 if (lengths
== NULL
)
13005 error (_("Out of memory allocating space for histogram buckets\n"));
13008 visited
= xcmalloc (filedata
->nchains
, 1);
13009 memset (visited
, 0, filedata
->nchains
);
13011 printf (_(" Length Number %% of total Coverage\n"));
13012 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
13014 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
13017 if (maxlength
< ++lengths
[hn
])
13019 if (si
>= filedata
->nchains
|| visited
[si
])
13021 error (_("histogram chain is corrupt\n"));
13029 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
13030 if (counts
== NULL
)
13033 error (_("Out of memory allocating space for histogram counts\n"));
13037 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
13038 ++counts
[lengths
[hn
]];
13040 if (filedata
->nbuckets
> 0)
13043 printf (" 0 %-10lu (%5.1f%%)\n",
13044 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
13045 for (i
= 1; i
<= maxlength
; ++i
)
13047 nzero_counts
+= counts
[i
] * i
;
13048 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
13049 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
13050 (nzero_counts
* 100.0) / nsyms
);
13058 free (filedata
->buckets
);
13059 filedata
->buckets
= NULL
;
13060 filedata
->nbuckets
= 0;
13061 free (filedata
->chains
);
13062 filedata
->chains
= NULL
;
13064 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
13066 unsigned long * lengths
;
13067 unsigned long * counts
;
13069 unsigned long maxlength
= 0;
13070 unsigned long nzero_counts
= 0;
13071 unsigned long nsyms
= 0;
13073 printf (ngettext ("\nHistogram for `%s' bucket list length "
13074 "(total of %lu bucket):\n",
13075 "\nHistogram for `%s' bucket list length "
13076 "(total of %lu buckets):\n",
13077 (unsigned long) filedata
->ngnubuckets
),
13078 GNU_HASH_SECTION_NAME (filedata
),
13079 (unsigned long) filedata
->ngnubuckets
);
13081 lengths
= (unsigned long *) calloc (filedata
->ngnubuckets
,
13082 sizeof (*lengths
));
13083 if (lengths
== NULL
)
13085 error (_("Out of memory allocating space for gnu histogram buckets\n"));
13089 printf (_(" Length Number %% of total Coverage\n"));
13091 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
13092 if (filedata
->gnubuckets
[hn
] != 0)
13094 bfd_vma off
, length
= 1;
13096 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
13097 /* PR 17531 file: 010-77222-0.004. */
13098 off
< filedata
->ngnuchains
13099 && (filedata
->gnuchains
[off
] & 1) == 0;
13102 lengths
[hn
] = length
;
13103 if (length
> maxlength
)
13104 maxlength
= length
;
13108 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
13109 if (counts
== NULL
)
13112 error (_("Out of memory allocating space for gnu histogram counts\n"));
13116 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
13117 ++counts
[lengths
[hn
]];
13119 if (filedata
->ngnubuckets
> 0)
13122 printf (" 0 %-10lu (%5.1f%%)\n",
13123 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
13124 for (j
= 1; j
<= maxlength
; ++j
)
13126 nzero_counts
+= counts
[j
] * j
;
13127 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
13128 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
13129 (nzero_counts
* 100.0) / nsyms
);
13136 free (filedata
->gnubuckets
);
13137 filedata
->gnubuckets
= NULL
;
13138 filedata
->ngnubuckets
= 0;
13139 free (filedata
->gnuchains
);
13140 filedata
->gnuchains
= NULL
;
13141 filedata
->ngnuchains
= 0;
13142 free (filedata
->mipsxlat
);
13143 filedata
->mipsxlat
= NULL
;
13147 free (filedata
->gnubuckets
);
13148 filedata
->gnubuckets
= NULL
;
13149 filedata
->ngnubuckets
= 0;
13150 free (filedata
->gnuchains
);
13151 filedata
->gnuchains
= NULL
;
13152 filedata
->ngnuchains
= 0;
13153 free (filedata
->mipsxlat
);
13154 filedata
->mipsxlat
= NULL
;
13155 free (filedata
->buckets
);
13156 filedata
->buckets
= NULL
;
13157 filedata
->nbuckets
= 0;
13158 free (filedata
->chains
);
13159 filedata
->chains
= NULL
;
13164 process_syminfo (Filedata
* filedata
)
13168 if (filedata
->dynamic_syminfo
== NULL
13170 /* No syminfo, this is ok. */
13173 /* There better should be a dynamic symbol section. */
13174 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
13177 if (filedata
->is_separate
)
13178 printf (ngettext ("\nIn linked file '%s: the dynamic info segment at offset 0x%lx contains %d entry:\n",
13179 "\nIn linked file '%s: the dynamic info segment at offset 0x%lx contains %d entries:\n",
13180 filedata
->dynamic_syminfo_nent
),
13181 filedata
->file_name
,
13182 filedata
->dynamic_syminfo_offset
,
13183 filedata
->dynamic_syminfo_nent
);
13185 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
13186 "contains %d entry:\n",
13187 "\nDynamic info segment at offset 0x%lx "
13188 "contains %d entries:\n",
13189 filedata
->dynamic_syminfo_nent
),
13190 filedata
->dynamic_syminfo_offset
,
13191 filedata
->dynamic_syminfo_nent
);
13193 printf (_(" Num: Name BoundTo Flags\n"));
13194 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
13196 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
13198 printf ("%4d: ", i
);
13199 if (i
>= filedata
->num_dynamic_syms
)
13200 printf (_("<corrupt index>"));
13201 else if (VALID_DYNAMIC_NAME (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
13202 print_symbol (30, GET_DYNAMIC_NAME (filedata
,
13203 filedata
->dynamic_symbols
[i
].st_name
));
13205 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
13208 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
13210 case SYMINFO_BT_SELF
:
13211 fputs ("SELF ", stdout
);
13213 case SYMINFO_BT_PARENT
:
13214 fputs ("PARENT ", stdout
);
13217 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
13218 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
13219 && VALID_DYNAMIC_NAME (filedata
,
13220 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
13222 print_symbol (10, GET_DYNAMIC_NAME (filedata
,
13223 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
13227 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
13231 if (flags
& SYMINFO_FLG_DIRECT
)
13232 printf (" DIRECT");
13233 if (flags
& SYMINFO_FLG_PASSTHRU
)
13234 printf (" PASSTHRU");
13235 if (flags
& SYMINFO_FLG_COPY
)
13237 if (flags
& SYMINFO_FLG_LAZYLOAD
)
13238 printf (" LAZYLOAD");
13246 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
13247 is contained by the region START .. END. The types of ADDR, START
13248 and END should all be the same. Note both ADDR + NELEM and END
13249 point to just beyond the end of the regions that are being tested. */
13250 #define IN_RANGE(START,END,ADDR,NELEM) \
13251 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
13253 /* Check to see if the given reloc needs to be handled in a target specific
13254 manner. If so then process the reloc and return TRUE otherwise return
13257 If called with reloc == NULL, then this is a signal that reloc processing
13258 for the current section has finished, and any saved state should be
13262 target_specific_reloc_handling (Filedata
* filedata
,
13263 Elf_Internal_Rela
* reloc
,
13264 unsigned char * start
,
13265 unsigned char * end
,
13266 Elf_Internal_Sym
* symtab
,
13267 unsigned long num_syms
)
13269 unsigned int reloc_type
= 0;
13270 unsigned long sym_index
= 0;
13274 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
13275 sym_index
= get_reloc_symindex (reloc
->r_info
);
13278 switch (filedata
->file_header
.e_machine
)
13281 case EM_MSP430_OLD
:
13283 static Elf_Internal_Sym
* saved_sym
= NULL
;
13291 switch (reloc_type
)
13293 case 10: /* R_MSP430_SYM_DIFF */
13294 case 12: /* R_MSP430_GNU_SUB_ULEB128 */
13295 if (uses_msp430x_relocs (filedata
))
13297 /* Fall through. */
13298 case 21: /* R_MSP430X_SYM_DIFF */
13299 case 23: /* R_MSP430X_GNU_SUB_ULEB128 */
13301 if (sym_index
>= num_syms
)
13302 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
13305 saved_sym
= symtab
+ sym_index
;
13308 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
13309 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
13310 goto handle_sym_diff
;
13312 case 5: /* R_MSP430_16_BYTE */
13313 case 9: /* R_MSP430_8 */
13314 case 11: /* R_MSP430_GNU_SET_ULEB128 */
13315 if (uses_msp430x_relocs (filedata
))
13317 goto handle_sym_diff
;
13319 case 2: /* R_MSP430_ABS16 */
13320 case 15: /* R_MSP430X_ABS16 */
13321 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
13322 if (! uses_msp430x_relocs (filedata
))
13324 goto handle_sym_diff
;
13327 if (saved_sym
!= NULL
)
13330 unsigned int reloc_size
= 0;
13332 switch (reloc_type
)
13334 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
13337 case 11: /* R_MSP430_GNU_SET_ULEB128 */
13338 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
13339 if (reloc
->r_offset
< (size_t) (end
- start
))
13340 read_leb128 (start
+ reloc
->r_offset
, end
, false,
13341 &reloc_size
, &leb_ret
);
13348 if (leb_ret
!= 0 || reloc_size
== 0 || reloc_size
> 8)
13349 error (_("MSP430 ULEB128 field at 0x%lx contains invalid "
13350 "ULEB128 value\n"),
13351 (long) reloc
->r_offset
);
13352 else if (sym_index
>= num_syms
)
13353 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
13357 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
13358 - saved_sym
->st_value
);
13360 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
13361 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
13364 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
13365 (long) reloc
->r_offset
);
13374 if (saved_sym
!= NULL
)
13375 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13382 case EM_CYGNUS_MN10300
:
13384 static Elf_Internal_Sym
* saved_sym
= NULL
;
13392 switch (reloc_type
)
13394 case 34: /* R_MN10300_ALIGN */
13396 case 33: /* R_MN10300_SYM_DIFF */
13397 if (sym_index
>= num_syms
)
13398 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
13401 saved_sym
= symtab
+ sym_index
;
13404 case 1: /* R_MN10300_32 */
13405 case 2: /* R_MN10300_16 */
13406 if (saved_sym
!= NULL
)
13408 int reloc_size
= reloc_type
== 1 ? 4 : 2;
13411 if (sym_index
>= num_syms
)
13412 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
13416 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
13417 - saved_sym
->st_value
);
13419 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
13420 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
13422 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
13423 (long) reloc
->r_offset
);
13431 if (saved_sym
!= NULL
)
13432 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
13440 static bfd_vma saved_sym1
= 0;
13441 static bfd_vma saved_sym2
= 0;
13442 static bfd_vma value
;
13446 saved_sym1
= saved_sym2
= 0;
13450 switch (reloc_type
)
13452 case 0x80: /* R_RL78_SYM. */
13453 saved_sym1
= saved_sym2
;
13454 if (sym_index
>= num_syms
)
13455 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
13459 saved_sym2
= symtab
[sym_index
].st_value
;
13460 saved_sym2
+= reloc
->r_addend
;
13464 case 0x83: /* R_RL78_OPsub. */
13465 value
= saved_sym1
- saved_sym2
;
13466 saved_sym2
= saved_sym1
= 0;
13470 case 0x41: /* R_RL78_ABS32. */
13471 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
13472 byte_put (start
+ reloc
->r_offset
, value
, 4);
13474 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
13475 (long) reloc
->r_offset
);
13479 case 0x43: /* R_RL78_ABS16. */
13480 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
13481 byte_put (start
+ reloc
->r_offset
, value
, 2);
13483 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
13484 (long) reloc
->r_offset
);
13498 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
13499 DWARF debug sections. This is a target specific test. Note - we do not
13500 go through the whole including-target-headers-multiple-times route, (as
13501 we have already done with <elf/h8.h>) because this would become very
13502 messy and even then this function would have to contain target specific
13503 information (the names of the relocs instead of their numeric values).
13504 FIXME: This is not the correct way to solve this problem. The proper way
13505 is to have target specific reloc sizing and typing functions created by
13506 the reloc-macros.h header, in the same way that it already creates the
13507 reloc naming functions. */
13510 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13512 /* Please keep this table alpha-sorted for ease of visual lookup. */
13513 switch (filedata
->file_header
.e_machine
)
13517 return reloc_type
== 1; /* R_386_32. */
13519 return reloc_type
== 1; /* R_68K_32. */
13521 return reloc_type
== 1; /* R_860_32. */
13523 return reloc_type
== 2; /* R_960_32. */
13525 return (reloc_type
== 258
13526 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
13528 return reloc_type
== 11; /* R_BPF_DATA_32 */
13529 case EM_ADAPTEVA_EPIPHANY
:
13530 return reloc_type
== 3;
13532 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
13534 return reloc_type
== 1; /* R_ARC_32. */
13535 case EM_ARC_COMPACT
:
13536 case EM_ARC_COMPACT2
:
13537 return reloc_type
== 4; /* R_ARC_32. */
13539 return reloc_type
== 2; /* R_ARM_ABS32 */
13542 return reloc_type
== 1;
13544 return reloc_type
== 0x12; /* R_byte4_data. */
13546 return reloc_type
== 3; /* R_CRIS_32. */
13548 return reloc_type
== 3; /* R_CR16_NUM32. */
13550 return reloc_type
== 15; /* R_CRX_NUM32. */
13552 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
13553 case EM_CYGNUS_FRV
:
13554 return reloc_type
== 1;
13555 case EM_CYGNUS_D10V
:
13557 return reloc_type
== 6; /* R_D10V_32. */
13558 case EM_CYGNUS_D30V
:
13560 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
13562 return reloc_type
== 3; /* R_DLX_RELOC_32. */
13563 case EM_CYGNUS_FR30
:
13565 return reloc_type
== 3; /* R_FR30_32. */
13567 return reloc_type
== 1; /* R_FT32_32. */
13571 return reloc_type
== 1; /* R_H8_DIR32. */
13573 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
13574 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
13575 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
13576 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
13579 return reloc_type
== 2; /* R_IP2K_32. */
13581 return reloc_type
== 2; /* R_IQ2000_32. */
13582 case EM_LATTICEMICO32
:
13583 return reloc_type
== 3; /* R_LM32_32. */
13586 return reloc_type
== 3; /* R_M32C_32. */
13588 return reloc_type
== 34; /* R_M32R_32_RELA. */
13591 return reloc_type
== 6; /* R_M68HC11_32. */
13593 return reloc_type
== 7 || /* R_S12Z_EXT32 */
13594 reloc_type
== 6; /* R_S12Z_CW32. */
13596 return reloc_type
== 1; /* R_MCORE_ADDR32. */
13597 case EM_CYGNUS_MEP
:
13598 return reloc_type
== 4; /* R_MEP_32. */
13600 return reloc_type
== 2; /* R_METAG_ADDR32. */
13601 case EM_MICROBLAZE
:
13602 return reloc_type
== 1; /* R_MICROBLAZE_32. */
13604 return reloc_type
== 2; /* R_MIPS_32. */
13606 return reloc_type
== 4; /* R_MMIX_32. */
13607 case EM_CYGNUS_MN10200
:
13609 return reloc_type
== 1; /* R_MN10200_32. */
13610 case EM_CYGNUS_MN10300
:
13612 return reloc_type
== 1; /* R_MN10300_32. */
13614 return reloc_type
== 1; /* R_MOXIE_32. */
13615 case EM_MSP430_OLD
:
13617 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
13619 return reloc_type
== 2; /* R_MT_32. */
13621 return reloc_type
== 20; /* R_NDS32_RELA. */
13622 case EM_ALTERA_NIOS2
:
13623 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
13625 return reloc_type
== 1; /* R_NIOS_32. */
13627 return reloc_type
== 1; /* R_OR1K_32. */
13629 return (reloc_type
== 1 /* R_PARISC_DIR32. */
13630 || reloc_type
== 2 /* R_PARISC_DIR21L. */
13631 || reloc_type
== 41); /* R_PARISC_SECREL32. */
13634 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
13636 return reloc_type
== 1; /* R_PPC64_ADDR32. */
13638 return reloc_type
== 1; /* R_PPC_ADDR32. */
13640 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
13642 return reloc_type
== 1; /* R_RISCV_32. */
13644 return reloc_type
== 1; /* R_RL78_DIR32. */
13646 return reloc_type
== 1; /* R_RX_DIR32. */
13648 return reloc_type
== 1; /* R_I370_ADDR31. */
13651 return reloc_type
== 4; /* R_S390_32. */
13653 return reloc_type
== 8; /* R_SCORE_ABS32. */
13655 return reloc_type
== 1; /* R_SH_DIR32. */
13656 case EM_SPARC32PLUS
:
13659 return reloc_type
== 3 /* R_SPARC_32. */
13660 || reloc_type
== 23; /* R_SPARC_UA32. */
13662 return reloc_type
== 6; /* R_SPU_ADDR32 */
13664 return reloc_type
== 1; /* R_C6000_ABS32. */
13666 return reloc_type
== 2; /* R_TILEGX_32. */
13668 return reloc_type
== 1; /* R_TILEPRO_32. */
13669 case EM_CYGNUS_V850
:
13671 return reloc_type
== 6; /* R_V850_ABS32. */
13673 return reloc_type
== 0x33; /* R_V810_WORD. */
13675 return reloc_type
== 1; /* R_VAX_32. */
13677 return reloc_type
== 3; /* R_VISIUM_32. */
13678 case EM_WEBASSEMBLY
:
13679 return reloc_type
== 1; /* R_WASM32_32. */
13683 return reloc_type
== 10; /* R_X86_64_32. */
13686 return reloc_type
== 3; /* R_XC16C_ABS_32. */
13688 return reloc_type
== 4; /* R_XGATE_32. */
13690 return reloc_type
== 1; /* R_XSTROMY16_32. */
13691 case EM_XTENSA_OLD
:
13693 return reloc_type
== 1; /* R_XTENSA_32. */
13695 return reloc_type
== 6; /* R_Z80_32. */
13698 static unsigned int prev_warn
= 0;
13700 /* Avoid repeating the same warning multiple times. */
13701 if (prev_warn
!= filedata
->file_header
.e_machine
)
13702 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
13703 filedata
->file_header
.e_machine
);
13704 prev_warn
= filedata
->file_header
.e_machine
;
13710 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13711 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
13714 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13716 switch (filedata
->file_header
.e_machine
)
13717 /* Please keep this table alpha-sorted for ease of visual lookup. */
13721 return reloc_type
== 2; /* R_386_PC32. */
13723 return reloc_type
== 4; /* R_68K_PC32. */
13725 return reloc_type
== 261; /* R_AARCH64_PREL32 */
13726 case EM_ADAPTEVA_EPIPHANY
:
13727 return reloc_type
== 6;
13729 return reloc_type
== 10; /* R_ALPHA_SREL32. */
13730 case EM_ARC_COMPACT
:
13731 case EM_ARC_COMPACT2
:
13732 return reloc_type
== 49; /* R_ARC_32_PCREL. */
13734 return reloc_type
== 3; /* R_ARM_REL32 */
13737 return reloc_type
== 36; /* R_AVR_32_PCREL. */
13738 case EM_MICROBLAZE
:
13739 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
13741 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
13743 return reloc_type
== 9; /* R_PARISC_PCREL32. */
13745 return reloc_type
== 26; /* R_PPC_REL32. */
13747 return reloc_type
== 26; /* R_PPC64_REL32. */
13749 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
13752 return reloc_type
== 5; /* R_390_PC32. */
13754 return reloc_type
== 2; /* R_SH_REL32. */
13755 case EM_SPARC32PLUS
:
13758 return reloc_type
== 6; /* R_SPARC_DISP32. */
13760 return reloc_type
== 13; /* R_SPU_REL32. */
13762 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
13764 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
13766 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
13770 return reloc_type
== 2; /* R_X86_64_PC32. */
13772 return reloc_type
== 4; /* R_VAX_PCREL32. */
13773 case EM_XTENSA_OLD
:
13775 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
13777 /* Do not abort or issue an error message here. Not all targets use
13778 pc-relative 32-bit relocs in their DWARF debug information and we
13779 have already tested for target coverage in is_32bit_abs_reloc. A
13780 more helpful warning message will be generated by apply_relocations
13781 anyway, so just return. */
13786 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13787 a 64-bit absolute RELA relocation used in DWARF debug sections. */
13790 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13792 switch (filedata
->file_header
.e_machine
)
13795 return reloc_type
== 257; /* R_AARCH64_ABS64. */
13797 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
13799 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
13800 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
13802 return reloc_type
== 80; /* R_PARISC_DIR64. */
13804 return reloc_type
== 38; /* R_PPC64_ADDR64. */
13806 return reloc_type
== 2; /* R_RISCV_64. */
13807 case EM_SPARC32PLUS
:
13810 return reloc_type
== 32 /* R_SPARC_64. */
13811 || reloc_type
== 54; /* R_SPARC_UA64. */
13815 return reloc_type
== 1; /* R_X86_64_64. */
13818 return reloc_type
== 22; /* R_S390_64. */
13820 return reloc_type
== 1; /* R_TILEGX_64. */
13822 return reloc_type
== 18; /* R_MIPS_64. */
13828 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
13829 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
13832 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13834 switch (filedata
->file_header
.e_machine
)
13837 return reloc_type
== 260; /* R_AARCH64_PREL64. */
13839 return reloc_type
== 11; /* R_ALPHA_SREL64. */
13841 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
13842 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
13844 return reloc_type
== 72; /* R_PARISC_PCREL64. */
13846 return reloc_type
== 44; /* R_PPC64_REL64. */
13847 case EM_SPARC32PLUS
:
13850 return reloc_type
== 46; /* R_SPARC_DISP64. */
13854 return reloc_type
== 24; /* R_X86_64_PC64. */
13857 return reloc_type
== 23; /* R_S390_PC64. */
13859 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
13865 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13866 a 24-bit absolute RELA relocation used in DWARF debug sections. */
13869 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13871 switch (filedata
->file_header
.e_machine
)
13873 case EM_CYGNUS_MN10200
:
13875 return reloc_type
== 4; /* R_MN10200_24. */
13877 return reloc_type
== 5; /* R_FT32_20. */
13879 return reloc_type
== 5; /* R_Z80_24. */
13885 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13886 a 16-bit absolute RELA relocation used in DWARF debug sections. */
13889 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13891 /* Please keep this table alpha-sorted for ease of visual lookup. */
13892 switch (filedata
->file_header
.e_machine
)
13895 case EM_ARC_COMPACT
:
13896 case EM_ARC_COMPACT2
:
13897 return reloc_type
== 2; /* R_ARC_16. */
13898 case EM_ADAPTEVA_EPIPHANY
:
13899 return reloc_type
== 5;
13902 return reloc_type
== 4; /* R_AVR_16. */
13903 case EM_CYGNUS_D10V
:
13905 return reloc_type
== 3; /* R_D10V_16. */
13907 return reloc_type
== 2; /* R_FT32_16. */
13911 return reloc_type
== R_H8_DIR16
;
13914 return reloc_type
== 1; /* R_IP2K_16. */
13917 return reloc_type
== 1; /* R_M32C_16 */
13918 case EM_CYGNUS_MN10200
:
13920 return reloc_type
== 2; /* R_MN10200_16. */
13921 case EM_CYGNUS_MN10300
:
13923 return reloc_type
== 2; /* R_MN10300_16. */
13925 if (uses_msp430x_relocs (filedata
))
13926 return reloc_type
== 2; /* R_MSP430_ABS16. */
13927 /* Fall through. */
13928 case EM_MSP430_OLD
:
13929 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13931 return reloc_type
== 19; /* R_NDS32_RELA. */
13932 case EM_ALTERA_NIOS2
:
13933 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13935 return reloc_type
== 9; /* R_NIOS_16. */
13937 return reloc_type
== 2; /* R_OR1K_16. */
13939 return reloc_type
== 55; /* R_RISCV_SET16. */
13941 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13943 return reloc_type
== 2; /* R_C6000_ABS16. */
13945 return reloc_type
== 2; /* R_VISIUM_16. */
13948 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13950 return reloc_type
== 3; /* R_XGATE_16. */
13952 return reloc_type
== 4; /* R_Z80_16. */
13958 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13959 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13962 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13964 switch (filedata
->file_header
.e_machine
)
13967 return reloc_type
== 54; /* R_RISCV_SET8. */
13969 return reloc_type
== 1; /* R_Z80_8. */
13975 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13976 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13979 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13981 switch (filedata
->file_header
.e_machine
)
13984 return reloc_type
== 53; /* R_RISCV_SET6. */
13990 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13991 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13994 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13996 /* Please keep this table alpha-sorted for ease of visual lookup. */
13997 switch (filedata
->file_header
.e_machine
)
14000 return reloc_type
== 35; /* R_RISCV_ADD32. */
14006 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14007 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
14010 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14012 /* Please keep this table alpha-sorted for ease of visual lookup. */
14013 switch (filedata
->file_header
.e_machine
)
14016 return reloc_type
== 39; /* R_RISCV_SUB32. */
14022 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14023 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
14026 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14028 /* Please keep this table alpha-sorted for ease of visual lookup. */
14029 switch (filedata
->file_header
.e_machine
)
14032 return reloc_type
== 36; /* R_RISCV_ADD64. */
14038 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14039 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
14042 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14044 /* Please keep this table alpha-sorted for ease of visual lookup. */
14045 switch (filedata
->file_header
.e_machine
)
14048 return reloc_type
== 40; /* R_RISCV_SUB64. */
14054 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14055 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
14058 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14060 /* Please keep this table alpha-sorted for ease of visual lookup. */
14061 switch (filedata
->file_header
.e_machine
)
14064 return reloc_type
== 34; /* R_RISCV_ADD16. */
14070 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14071 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
14074 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14076 /* Please keep this table alpha-sorted for ease of visual lookup. */
14077 switch (filedata
->file_header
.e_machine
)
14080 return reloc_type
== 38; /* R_RISCV_SUB16. */
14086 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14087 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
14090 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14092 /* Please keep this table alpha-sorted for ease of visual lookup. */
14093 switch (filedata
->file_header
.e_machine
)
14096 return reloc_type
== 33; /* R_RISCV_ADD8. */
14102 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14103 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
14106 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14108 /* Please keep this table alpha-sorted for ease of visual lookup. */
14109 switch (filedata
->file_header
.e_machine
)
14112 return reloc_type
== 37; /* R_RISCV_SUB8. */
14118 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14119 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
14122 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14124 switch (filedata
->file_header
.e_machine
)
14127 return reloc_type
== 52; /* R_RISCV_SUB6. */
14133 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
14134 relocation entries (possibly formerly used for SHT_GROUP sections). */
14137 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14139 switch (filedata
->file_header
.e_machine
)
14141 case EM_386
: /* R_386_NONE. */
14142 case EM_68K
: /* R_68K_NONE. */
14143 case EM_ADAPTEVA_EPIPHANY
:
14144 case EM_ALPHA
: /* R_ALPHA_NONE. */
14145 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
14146 case EM_ARC
: /* R_ARC_NONE. */
14147 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
14148 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
14149 case EM_ARM
: /* R_ARM_NONE. */
14150 case EM_C166
: /* R_XC16X_NONE. */
14151 case EM_CRIS
: /* R_CRIS_NONE. */
14152 case EM_FT32
: /* R_FT32_NONE. */
14153 case EM_IA_64
: /* R_IA64_NONE. */
14154 case EM_K1OM
: /* R_X86_64_NONE. */
14155 case EM_L1OM
: /* R_X86_64_NONE. */
14156 case EM_M32R
: /* R_M32R_NONE. */
14157 case EM_MIPS
: /* R_MIPS_NONE. */
14158 case EM_MN10300
: /* R_MN10300_NONE. */
14159 case EM_MOXIE
: /* R_MOXIE_NONE. */
14160 case EM_NIOS32
: /* R_NIOS_NONE. */
14161 case EM_OR1K
: /* R_OR1K_NONE. */
14162 case EM_PARISC
: /* R_PARISC_NONE. */
14163 case EM_PPC64
: /* R_PPC64_NONE. */
14164 case EM_PPC
: /* R_PPC_NONE. */
14165 case EM_RISCV
: /* R_RISCV_NONE. */
14166 case EM_S390
: /* R_390_NONE. */
14168 case EM_SH
: /* R_SH_NONE. */
14169 case EM_SPARC32PLUS
:
14170 case EM_SPARC
: /* R_SPARC_NONE. */
14172 case EM_TILEGX
: /* R_TILEGX_NONE. */
14173 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
14174 case EM_TI_C6000
:/* R_C6000_NONE. */
14175 case EM_X86_64
: /* R_X86_64_NONE. */
14177 case EM_Z80
: /* R_Z80_NONE. */
14178 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
14179 return reloc_type
== 0;
14182 return reloc_type
== 0 || reloc_type
== 256;
14185 return (reloc_type
== 0 /* R_AVR_NONE. */
14186 || reloc_type
== 30 /* R_AVR_DIFF8. */
14187 || reloc_type
== 31 /* R_AVR_DIFF16. */
14188 || reloc_type
== 32 /* R_AVR_DIFF32. */);
14190 return reloc_type
== 3; /* R_METAG_NONE. */
14192 return (reloc_type
== 0 /* R_XTENSA_NONE. */
14193 || reloc_type
== 204 /* R_NDS32_DIFF8. */
14194 || reloc_type
== 205 /* R_NDS32_DIFF16. */
14195 || reloc_type
== 206 /* R_NDS32_DIFF32. */
14196 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
14198 return (reloc_type
== 0 /* R_PRU_NONE. */
14199 || reloc_type
== 65 /* R_PRU_DIFF8. */
14200 || reloc_type
== 66 /* R_PRU_DIFF16. */
14201 || reloc_type
== 67 /* R_PRU_DIFF32. */);
14202 case EM_XTENSA_OLD
:
14204 return (reloc_type
== 0 /* R_XTENSA_NONE. */
14205 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
14206 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
14207 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
14208 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
14209 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
14210 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
14211 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
14212 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
14213 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
14218 /* Returns TRUE if there is a relocation against
14219 section NAME at OFFSET bytes. */
14222 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
14224 Elf_Internal_Rela
* relocs
;
14225 Elf_Internal_Rela
* rp
;
14227 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
14230 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
14232 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
14233 if (rp
->r_offset
== offset
)
14239 /* Apply relocations to a section.
14240 Returns TRUE upon success, FALSE otherwise.
14241 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
14242 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
14243 will be set to the number of relocs loaded.
14245 Note: So far support has been added only for those relocations
14246 which can be found in debug sections. FIXME: Add support for
14247 more relocations ? */
14250 apply_relocations (Filedata
* filedata
,
14251 const Elf_Internal_Shdr
* section
,
14252 unsigned char * start
,
14253 bfd_size_type size
,
14254 void ** relocs_return
,
14255 unsigned long * num_relocs_return
)
14257 Elf_Internal_Shdr
* relsec
;
14258 unsigned char * end
= start
+ size
;
14260 if (relocs_return
!= NULL
)
14262 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
14263 * num_relocs_return
= 0;
14266 if (filedata
->file_header
.e_type
!= ET_REL
)
14267 /* No relocs to apply. */
14270 /* Find the reloc section associated with the section. */
14271 for (relsec
= filedata
->section_headers
;
14272 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14276 unsigned long num_relocs
;
14277 Elf_Internal_Rela
* relocs
;
14278 Elf_Internal_Rela
* rp
;
14279 Elf_Internal_Shdr
* symsec
;
14280 Elf_Internal_Sym
* symtab
;
14281 unsigned long num_syms
;
14282 Elf_Internal_Sym
* sym
;
14284 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14285 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14286 || filedata
->section_headers
+ relsec
->sh_info
!= section
14287 || relsec
->sh_size
== 0
14288 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14291 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
14292 if (symsec
->sh_type
!= SHT_SYMTAB
14293 && symsec
->sh_type
!= SHT_DYNSYM
)
14296 is_rela
= relsec
->sh_type
== SHT_RELA
;
14300 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
14301 relsec
->sh_size
, & relocs
, & num_relocs
))
14306 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
14307 relsec
->sh_size
, & relocs
, & num_relocs
))
14311 /* SH uses RELA but uses in place value instead of the addend field. */
14312 if (filedata
->file_header
.e_machine
== EM_SH
)
14315 symtab
= get_elf_symbols (filedata
, symsec
, & num_syms
);
14317 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
14320 unsigned int reloc_type
;
14321 unsigned int reloc_size
;
14322 bool reloc_inplace
= false;
14323 bool reloc_subtract
= false;
14324 unsigned char *rloc
;
14325 unsigned long sym_index
;
14327 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
14329 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
14331 else if (is_none_reloc (filedata
, reloc_type
))
14333 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
14334 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
14336 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
14337 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
14339 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
14341 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
14343 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
14344 || is_6bit_abs_reloc (filedata
, reloc_type
))
14346 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
14348 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
14351 reloc_inplace
= true;
14353 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
14355 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
14358 reloc_inplace
= true;
14360 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
14362 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
14365 reloc_inplace
= true;
14367 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
14369 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
14372 reloc_inplace
= true;
14374 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
14378 reloc_inplace
= true;
14382 static unsigned int prev_reloc
= 0;
14384 if (reloc_type
!= prev_reloc
)
14385 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
14386 reloc_type
, printable_section_name (filedata
, section
));
14387 prev_reloc
= reloc_type
;
14391 rloc
= start
+ rp
->r_offset
;
14392 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
14394 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
14395 (unsigned long) rp
->r_offset
,
14396 printable_section_name (filedata
, section
));
14400 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
14401 if (sym_index
>= num_syms
)
14403 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
14404 sym_index
, printable_section_name (filedata
, section
));
14407 sym
= symtab
+ sym_index
;
14409 /* If the reloc has a symbol associated with it,
14410 make sure that it is of an appropriate type.
14412 Relocations against symbols without type can happen.
14413 Gcc -feliminate-dwarf2-dups may generate symbols
14414 without type for debug info.
14416 Icc generates relocations against function symbols
14417 instead of local labels.
14419 Relocations against object symbols can happen, eg when
14420 referencing a global array. For an example of this see
14421 the _clz.o binary in libgcc.a. */
14423 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
14424 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
14426 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
14427 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
14428 printable_section_name (filedata
, relsec
),
14429 (long int)(rp
- relocs
));
14435 addend
+= rp
->r_addend
;
14436 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
14437 partial_inplace. */
14439 || (filedata
->file_header
.e_machine
== EM_XTENSA
14440 && reloc_type
== 1)
14441 || ((filedata
->file_header
.e_machine
== EM_PJ
14442 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
14443 && reloc_type
== 1)
14444 || ((filedata
->file_header
.e_machine
== EM_D30V
14445 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
14446 && reloc_type
== 12)
14449 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
14450 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
14452 addend
+= byte_get (rloc
, reloc_size
);
14455 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
14456 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
14458 /* On HPPA, all pc-relative relocations are biased by 8. */
14459 if (filedata
->file_header
.e_machine
== EM_PARISC
)
14461 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
14464 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
14465 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
14467 if (reloc_subtract
)
14468 addend
-= sym
->st_value
;
14470 addend
+= sym
->st_value
;
14471 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
14472 byte_put (rloc
, addend
, reloc_size
);
14474 else if (reloc_subtract
)
14475 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
14477 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
14481 /* Let the target specific reloc processing code know that
14482 we have finished with these relocs. */
14483 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
14487 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
14488 * num_relocs_return
= num_relocs
;
14499 #ifdef SUPPORT_DISASSEMBLY
14501 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14503 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
14505 /* FIXME: XXX -- to be done --- XXX */
14511 /* Reads in the contents of SECTION from FILE, returning a pointer
14512 to a malloc'ed buffer or NULL if something went wrong. */
14515 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14517 bfd_size_type num_bytes
= section
->sh_size
;
14519 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
14521 printf (_("Section '%s' has no data to dump.\n"),
14522 printable_section_name (filedata
, section
));
14526 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
14527 _("section contents"));
14530 /* Uncompresses a section that was compressed using zlib, in place. */
14533 uncompress_section_contents (unsigned char ** buffer
,
14534 dwarf_size_type uncompressed_size
,
14535 dwarf_size_type
* size
)
14537 dwarf_size_type compressed_size
= *size
;
14538 unsigned char * compressed_buffer
= *buffer
;
14539 unsigned char * uncompressed_buffer
;
14543 /* It is possible the section consists of several compressed
14544 buffers concatenated together, so we uncompress in a loop. */
14545 /* PR 18313: The state field in the z_stream structure is supposed
14546 to be invisible to the user (ie us), but some compilers will
14547 still complain about it being used without initialisation. So
14548 we first zero the entire z_stream structure and then set the fields
14550 memset (& strm
, 0, sizeof strm
);
14551 strm
.avail_in
= compressed_size
;
14552 strm
.next_in
= (Bytef
*) compressed_buffer
;
14553 strm
.avail_out
= uncompressed_size
;
14554 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
14556 rc
= inflateInit (& strm
);
14557 while (strm
.avail_in
> 0)
14561 strm
.next_out
= ((Bytef
*) uncompressed_buffer
14562 + (uncompressed_size
- strm
.avail_out
));
14563 rc
= inflate (&strm
, Z_FINISH
);
14564 if (rc
!= Z_STREAM_END
)
14566 rc
= inflateReset (& strm
);
14568 if (inflateEnd (& strm
) != Z_OK
14570 || strm
.avail_out
!= 0)
14573 *buffer
= uncompressed_buffer
;
14574 *size
= uncompressed_size
;
14578 free (uncompressed_buffer
);
14579 /* Indicate decompression failure. */
14585 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14587 Elf_Internal_Shdr
*relsec
;
14588 bfd_size_type num_bytes
;
14589 unsigned char *data
;
14590 unsigned char *end
;
14591 unsigned char *real_start
;
14592 unsigned char *start
;
14593 bool some_strings_shown
;
14595 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
14597 /* PR 21820: Do not fail if the section was empty. */
14598 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
14600 num_bytes
= section
->sh_size
;
14602 if (filedata
->is_separate
)
14603 printf (_("\nString dump of section '%s' in linked file %s:\n"),
14604 printable_section_name (filedata
, section
),
14605 filedata
->file_name
);
14607 printf (_("\nString dump of section '%s':\n"),
14608 printable_section_name (filedata
, section
));
14610 if (decompress_dumps
)
14612 dwarf_size_type new_size
= num_bytes
;
14613 dwarf_size_type uncompressed_size
= 0;
14615 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14617 Elf_Internal_Chdr chdr
;
14618 unsigned int compression_header_size
14619 = get_compression_header (& chdr
, (unsigned char *) start
,
14621 if (compression_header_size
== 0)
14622 /* An error message will have already been generated
14623 by get_compression_header. */
14626 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14628 warn (_("section '%s' has unsupported compress type: %d\n"),
14629 printable_section_name (filedata
, section
), chdr
.ch_type
);
14632 uncompressed_size
= chdr
.ch_size
;
14633 start
+= compression_header_size
;
14634 new_size
-= compression_header_size
;
14636 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14638 /* Read the zlib header. In this case, it should be "ZLIB"
14639 followed by the uncompressed section size, 8 bytes in
14640 big-endian order. */
14641 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14642 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14643 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14644 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14645 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14646 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14647 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14648 uncompressed_size
+= start
[11];
14653 if (uncompressed_size
)
14655 if (uncompress_section_contents (& start
,
14656 uncompressed_size
, & new_size
))
14657 num_bytes
= new_size
;
14660 error (_("Unable to decompress section %s\n"),
14661 printable_section_name (filedata
, section
));
14666 start
= real_start
;
14669 /* If the section being dumped has relocations against it the user might
14670 be expecting these relocations to have been applied. Check for this
14671 case and issue a warning message in order to avoid confusion.
14672 FIXME: Maybe we ought to have an option that dumps a section with
14673 relocs applied ? */
14674 for (relsec
= filedata
->section_headers
;
14675 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14678 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14679 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14680 || filedata
->section_headers
+ relsec
->sh_info
!= section
14681 || relsec
->sh_size
== 0
14682 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14685 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14690 end
= start
+ num_bytes
;
14691 some_strings_shown
= false;
14693 #ifdef HAVE_MBSTATE_T
14695 /* Initialise the multibyte conversion state. */
14696 memset (& state
, 0, sizeof (state
));
14699 bool continuing
= false;
14703 while (!ISPRINT (* data
))
14704 if (++ data
>= end
)
14709 size_t maxlen
= end
- data
;
14714 continuing
= false;
14718 printf (" [%6lx] ", (unsigned long) (data
- start
));
14732 /* PR 25543: Treat new-lines as string-ending characters. */
14741 /* Do not print control characters directly as they can affect terminal
14742 settings. Such characters usually appear in the names generated
14743 by the assembler for local labels. */
14746 printf ("^%c", c
+ 0x40);
14748 else if (ISPRINT (c
))
14755 #ifdef HAVE_MBSTATE_T
14758 /* Let printf do the hard work of displaying multibyte characters. */
14759 printf ("%.1s", data
- 1);
14760 #ifdef HAVE_MBSTATE_T
14761 /* Try to find out how many bytes made up the character that was
14762 just printed. Advance the symbol pointer past the bytes that
14764 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
14768 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
14778 printf (_("<corrupt>\n"));
14781 some_strings_shown
= true;
14785 if (! some_strings_shown
)
14786 printf (_(" No strings found in this section."));
14799 dump_section_as_bytes (Elf_Internal_Shdr
*section
,
14800 Filedata
*filedata
,
14803 Elf_Internal_Shdr
* relsec
;
14804 bfd_size_type bytes
;
14805 bfd_size_type section_size
;
14807 unsigned char * data
;
14808 unsigned char * real_start
;
14809 unsigned char * start
;
14811 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
14813 /* PR 21820: Do not fail if the section was empty. */
14814 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
14816 section_size
= section
->sh_size
;
14818 if (filedata
->is_separate
)
14819 printf (_("\nHex dump of section '%s' in linked file %s:\n"),
14820 printable_section_name (filedata
, section
),
14821 filedata
->file_name
);
14823 printf (_("\nHex dump of section '%s':\n"),
14824 printable_section_name (filedata
, section
));
14826 if (decompress_dumps
)
14828 dwarf_size_type new_size
= section_size
;
14829 dwarf_size_type uncompressed_size
= 0;
14831 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14833 Elf_Internal_Chdr chdr
;
14834 unsigned int compression_header_size
14835 = get_compression_header (& chdr
, start
, section_size
);
14837 if (compression_header_size
== 0)
14838 /* An error message will have already been generated
14839 by get_compression_header. */
14842 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14844 warn (_("section '%s' has unsupported compress type: %d\n"),
14845 printable_section_name (filedata
, section
), chdr
.ch_type
);
14848 uncompressed_size
= chdr
.ch_size
;
14849 start
+= compression_header_size
;
14850 new_size
-= compression_header_size
;
14852 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14854 /* Read the zlib header. In this case, it should be "ZLIB"
14855 followed by the uncompressed section size, 8 bytes in
14856 big-endian order. */
14857 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14858 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14859 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14860 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14861 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14862 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14863 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14864 uncompressed_size
+= start
[11];
14869 if (uncompressed_size
)
14871 if (uncompress_section_contents (& start
, uncompressed_size
,
14874 section_size
= new_size
;
14878 error (_("Unable to decompress section %s\n"),
14879 printable_section_name (filedata
, section
));
14880 /* FIXME: Print the section anyway ? */
14885 start
= real_start
;
14890 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
14895 /* If the section being dumped has relocations against it the user might
14896 be expecting these relocations to have been applied. Check for this
14897 case and issue a warning message in order to avoid confusion.
14898 FIXME: Maybe we ought to have an option that dumps a section with
14899 relocs applied ? */
14900 for (relsec
= filedata
->section_headers
;
14901 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14904 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14905 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14906 || filedata
->section_headers
+ relsec
->sh_info
!= section
14907 || relsec
->sh_size
== 0
14908 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14911 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14916 addr
= section
->sh_addr
;
14917 bytes
= section_size
;
14926 lbytes
= (bytes
> 16 ? 16 : bytes
);
14928 printf (" 0x%8.8lx ", (unsigned long) addr
);
14930 for (j
= 0; j
< 16; j
++)
14933 printf ("%2.2x", data
[j
]);
14941 for (j
= 0; j
< lbytes
; j
++)
14944 if (k
>= ' ' && k
< 0x7f)
14967 #ifdef ENABLE_LIBCTF
14968 static ctf_sect_t
*
14969 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14971 buf
->cts_name
= SECTION_NAME_PRINT (shdr
);
14972 buf
->cts_size
= shdr
->sh_size
;
14973 buf
->cts_entsize
= shdr
->sh_entsize
;
14978 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14979 it is passed, or a pointer to newly-allocated storage, in which case
14980 dump_ctf() will free it when it no longer needs it. */
14983 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14984 char *s
, void *arg
)
14986 const char *blanks
= arg
;
14989 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14994 /* Dump CTF errors/warnings. */
14996 dump_ctf_errs (ctf_dict_t
*fp
)
14998 ctf_next_t
*it
= NULL
;
15003 /* Dump accumulated errors and warnings. */
15004 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
15006 error (_("%s: %s"), is_warning
? _("warning"): _("error"),
15010 if (err
!= ECTF_NEXT_END
)
15011 error (_("CTF error: cannot get CTF errors: `%s'"), ctf_errmsg (err
));
15014 /* Dump one CTF archive member. */
15017 dump_ctf_archive_member (ctf_dict_t
*ctf
, const char *name
, void *arg
)
15019 ctf_dict_t
*parent
= (ctf_dict_t
*) arg
;
15020 const char *things
[] = {"Header", "Labels", "Data objects",
15021 "Function objects", "Variables", "Types", "Strings",
15023 const char **thing
;
15027 /* Only print out the name of non-default-named archive members.
15028 The name .ctf appears everywhere, even for things that aren't
15029 really archives, so printing it out is liable to be confusing.
15031 The parent, if there is one, is the default-owned archive member:
15032 avoid importing it into itself. (This does no harm, but looks
15035 if (strcmp (name
, ".ctf") != 0)
15037 printf (_("\nCTF archive member: %s:\n"), name
);
15038 ctf_import (ctf
, parent
);
15041 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
15043 ctf_dump_state_t
*s
= NULL
;
15046 printf ("\n %s:\n", *thing
);
15047 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
15048 (void *) " ")) != NULL
)
15050 printf ("%s\n", item
);
15054 if (ctf_errno (ctf
))
15056 error (_("Iteration failed: %s, %s\n"), *thing
,
15057 ctf_errmsg (ctf_errno (ctf
)));
15064 dump_ctf_errs (ctf
);
15069 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15071 Elf_Internal_Shdr
* parent_sec
= NULL
;
15072 Elf_Internal_Shdr
* symtab_sec
= NULL
;
15073 Elf_Internal_Shdr
* strtab_sec
= NULL
;
15074 void * data
= NULL
;
15075 void * symdata
= NULL
;
15076 void * strdata
= NULL
;
15077 void * parentdata
= NULL
;
15078 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
15079 ctf_sect_t
* symsectp
= NULL
;
15080 ctf_sect_t
* strsectp
= NULL
;
15081 ctf_archive_t
* ctfa
= NULL
;
15082 ctf_archive_t
* parenta
= NULL
, *lookparent
;
15083 ctf_dict_t
* parent
= NULL
;
15088 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
15089 data
= get_section_contents (section
, filedata
);
15090 ctfsect
.cts_data
= data
;
15092 if (!dump_ctf_symtab_name
)
15093 dump_ctf_symtab_name
= strdup (".dynsym");
15095 if (!dump_ctf_strtab_name
)
15096 dump_ctf_strtab_name
= strdup (".dynstr");
15098 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
15100 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
15102 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
15105 if ((symdata
= (void *) get_data (NULL
, filedata
,
15106 symtab_sec
->sh_offset
, 1,
15107 symtab_sec
->sh_size
,
15108 _("symbols"))) == NULL
)
15110 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
15111 symsect
.cts_data
= symdata
;
15114 if (dump_ctf_strtab_name
&& dump_ctf_strtab_name
[0] != 0)
15116 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
15118 error (_("No string table section named %s\n"),
15119 dump_ctf_strtab_name
);
15122 if ((strdata
= (void *) get_data (NULL
, filedata
,
15123 strtab_sec
->sh_offset
, 1,
15124 strtab_sec
->sh_size
,
15125 _("strings"))) == NULL
)
15127 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
15128 strsect
.cts_data
= strdata
;
15131 if (dump_ctf_parent_name
)
15133 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
15135 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
15138 if ((parentdata
= (void *) get_data (NULL
, filedata
,
15139 parent_sec
->sh_offset
, 1,
15140 parent_sec
->sh_size
,
15141 _("CTF parent"))) == NULL
)
15143 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
15144 parentsect
.cts_data
= parentdata
;
15147 /* Load the CTF file and dump it. It may be a raw CTF section, or an archive:
15148 libctf papers over the difference, so we can pretend it is always an
15149 archive. Possibly open the parent as well, if one was specified. */
15151 if ((ctfa
= ctf_arc_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
15153 dump_ctf_errs (NULL
);
15154 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15158 ctf_arc_symsect_endianness (ctfa
, filedata
->file_header
.e_ident
[EI_DATA
]
15163 if ((parenta
= ctf_arc_bufopen (&parentsect
, symsectp
, strsectp
,
15166 dump_ctf_errs (NULL
);
15167 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15170 lookparent
= parenta
;
15175 /* Assume that the applicable parent archive member is the default one.
15176 (This is what all known implementations are expected to do, if they
15177 put CTFs and their parents in archives together.) */
15178 if ((parent
= ctf_dict_open (lookparent
, NULL
, &err
)) == NULL
)
15180 dump_ctf_errs (NULL
);
15181 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15187 if (filedata
->is_separate
)
15188 printf (_("\nDump of CTF section '%s' in linked file %s:\n"),
15189 printable_section_name (filedata
, section
),
15190 filedata
->file_name
);
15192 printf (_("\nDump of CTF section '%s':\n"),
15193 printable_section_name (filedata
, section
));
15195 if ((err
= ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
)) != 0)
15197 dump_ctf_errs (NULL
);
15198 error (_("CTF member open failure: %s\n"), ctf_errmsg (err
));
15203 ctf_dict_close (parent
);
15205 ctf_close (parenta
);
15215 load_specific_debug_section (enum dwarf_section_display_enum debug
,
15216 const Elf_Internal_Shdr
* sec
,
15219 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15221 Filedata
* filedata
= (Filedata
*) data
;
15223 if (section
->start
!= NULL
)
15225 /* If it is already loaded, do nothing. */
15226 if (streq (section
->filename
, filedata
->file_name
))
15228 free (section
->start
);
15231 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
15232 section
->address
= sec
->sh_addr
;
15233 section
->filename
= filedata
->file_name
;
15234 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
15236 sec
->sh_size
, buf
);
15237 if (section
->start
== NULL
)
15241 unsigned char *start
= section
->start
;
15242 dwarf_size_type size
= sec
->sh_size
;
15243 dwarf_size_type uncompressed_size
= 0;
15245 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
15247 Elf_Internal_Chdr chdr
;
15248 unsigned int compression_header_size
;
15250 if (size
< (is_32bit_elf
15251 ? sizeof (Elf32_External_Chdr
)
15252 : sizeof (Elf64_External_Chdr
)))
15254 warn (_("compressed section %s is too small to contain a compression header\n"),
15259 compression_header_size
= get_compression_header (&chdr
, start
, size
);
15260 if (compression_header_size
== 0)
15261 /* An error message will have already been generated
15262 by get_compression_header. */
15265 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
15267 warn (_("section '%s' has unsupported compress type: %d\n"),
15268 section
->name
, chdr
.ch_type
);
15271 uncompressed_size
= chdr
.ch_size
;
15272 start
+= compression_header_size
;
15273 size
-= compression_header_size
;
15275 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
15277 /* Read the zlib header. In this case, it should be "ZLIB"
15278 followed by the uncompressed section size, 8 bytes in
15279 big-endian order. */
15280 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
15281 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
15282 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
15283 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
15284 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
15285 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
15286 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
15287 uncompressed_size
+= start
[11];
15292 if (uncompressed_size
)
15294 if (uncompress_section_contents (&start
, uncompressed_size
,
15297 /* Free the compressed buffer, update the section buffer
15298 and the section size if uncompress is successful. */
15299 free (section
->start
);
15300 section
->start
= start
;
15304 error (_("Unable to decompress section %s\n"),
15305 printable_section_name (filedata
, sec
));
15310 section
->size
= size
;
15313 if (section
->start
== NULL
)
15316 if (debug_displays
[debug
].relocate
)
15318 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
15319 & section
->reloc_info
, & section
->num_relocs
))
15324 section
->reloc_info
= NULL
;
15325 section
->num_relocs
= 0;
15331 #if HAVE_LIBDEBUGINFOD
15332 /* Return a hex string representation of the build-id. */
15334 get_build_id (void * data
)
15336 Filedata
* filedata
= (Filedata
*) data
;
15337 Elf_Internal_Shdr
* shdr
;
15340 /* Iterate through notes to find note.gnu.build-id.
15341 FIXME: Only the first note in any note section is examined. */
15342 for (i
= 0, shdr
= filedata
->section_headers
;
15343 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
15346 if (shdr
->sh_type
!= SHT_NOTE
)
15351 size_t data_remaining
;
15353 Elf_External_Note
* enote
;
15354 Elf_Internal_Note inote
;
15356 bfd_vma offset
= shdr
->sh_offset
;
15357 bfd_vma align
= shdr
->sh_addralign
;
15358 bfd_vma length
= shdr
->sh_size
;
15360 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
15366 else if (align
!= 4 && align
!= 8)
15372 end
= (char *) enote
+ length
;
15373 data_remaining
= end
- (char *) enote
;
15375 if (!is_ia64_vms (filedata
))
15377 min_notesz
= offsetof (Elf_External_Note
, name
);
15378 if (data_remaining
< min_notesz
)
15381 malformed note encountered in section %s whilst scanning for build-id note\n"),
15382 printable_section_name (filedata
, shdr
));
15386 data_remaining
-= min_notesz
;
15388 inote
.type
= BYTE_GET (enote
->type
);
15389 inote
.namesz
= BYTE_GET (enote
->namesz
);
15390 inote
.namedata
= enote
->name
;
15391 inote
.descsz
= BYTE_GET (enote
->descsz
);
15392 inote
.descdata
= ((char *) enote
15393 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
15394 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
15395 next
= ((char *) enote
15396 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
15400 Elf64_External_VMS_Note
*vms_enote
;
15402 /* PR binutils/15191
15403 Make sure that there is enough data to read. */
15404 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
15405 if (data_remaining
< min_notesz
)
15408 malformed note encountered in section %s whilst scanning for build-id note\n"),
15409 printable_section_name (filedata
, shdr
));
15413 data_remaining
-= min_notesz
;
15415 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
15416 inote
.type
= BYTE_GET (vms_enote
->type
);
15417 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
15418 inote
.namedata
= vms_enote
->name
;
15419 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
15420 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
15421 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
15422 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
15425 /* Skip malformed notes. */
15426 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
15427 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
15428 || (size_t) (next
- inote
.descdata
) < inote
.descsz
15429 || ((size_t) (next
- inote
.descdata
)
15430 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
15433 malformed note encountered in section %s whilst scanning for build-id note\n"),
15434 printable_section_name (filedata
, shdr
));
15439 /* Check if this is the build-id note. If so then convert the build-id
15440 bytes to a hex string. */
15441 if (inote
.namesz
> 0
15442 && startswith (inote
.namedata
, "GNU")
15443 && inote
.type
== NT_GNU_BUILD_ID
)
15448 build_id
= malloc (inote
.descsz
* 2 + 1);
15449 if (build_id
== NULL
)
15455 for (j
= 0; j
< inote
.descsz
; ++j
)
15456 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
15457 build_id
[inote
.descsz
* 2] = '\0';
15460 return (unsigned char *) build_id
;
15467 #endif /* HAVE_LIBDEBUGINFOD */
15469 /* If this is not NULL, load_debug_section will only look for sections
15470 within the list of sections given here. */
15471 static unsigned int * section_subset
= NULL
;
15474 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
15476 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15477 Elf_Internal_Shdr
* sec
;
15478 Filedata
* filedata
= (Filedata
*) data
;
15480 /* Without section headers we cannot find any sections. */
15481 if (filedata
->section_headers
== NULL
)
15484 if (filedata
->string_table
== NULL
15485 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
15486 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
15488 Elf_Internal_Shdr
* strs
;
15490 /* Read in the string table, so that we have section names to scan. */
15491 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
15493 if (strs
!= NULL
&& strs
->sh_size
!= 0)
15495 filedata
->string_table
15496 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
15497 1, strs
->sh_size
, _("string table"));
15499 filedata
->string_table_length
15500 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
15504 /* Locate the debug section. */
15505 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
15507 section
->name
= section
->uncompressed_name
;
15510 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
15512 section
->name
= section
->compressed_name
;
15517 /* If we're loading from a subset of sections, and we've loaded
15518 a section matching this name before, it's likely that it's a
15520 if (section_subset
!= NULL
)
15521 free_debug_section (debug
);
15523 return load_specific_debug_section (debug
, sec
, data
);
15527 free_debug_section (enum dwarf_section_display_enum debug
)
15529 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15531 if (section
->start
== NULL
)
15534 free ((char *) section
->start
);
15535 section
->start
= NULL
;
15536 section
->address
= 0;
15539 free (section
->reloc_info
);
15540 section
->reloc_info
= NULL
;
15541 section
->num_relocs
= 0;
15545 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15547 char * name
= SECTION_NAME_VALID (section
) ? SECTION_NAME (section
) : "";
15548 const char * print_name
= printable_section_name (filedata
, section
);
15549 bfd_size_type length
;
15550 bool result
= true;
15553 length
= section
->sh_size
;
15556 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
15559 if (section
->sh_type
== SHT_NOBITS
)
15561 /* There is no point in dumping the contents of a debugging section
15562 which has the NOBITS type - the bits in the file will be random.
15563 This can happen when a file containing a .eh_frame section is
15564 stripped with the --only-keep-debug command line option. */
15565 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
15570 if (startswith (name
, ".gnu.linkonce.wi."))
15571 name
= ".debug_info";
15573 /* See if we know how to display the contents of this section. */
15574 for (i
= 0; i
< max
; i
++)
15576 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
15577 struct dwarf_section_display
* display
= debug_displays
+ i
;
15578 struct dwarf_section
* sec
= & display
->section
;
15580 if (streq (sec
->uncompressed_name
, name
)
15581 || (id
== line
&& startswith (name
, ".debug_line."))
15582 || streq (sec
->compressed_name
, name
))
15584 bool secondary
= (section
!= find_section (filedata
, name
));
15587 free_debug_section (id
);
15589 if (i
== line
&& startswith (name
, ".debug_line."))
15591 else if (streq (sec
->uncompressed_name
, name
))
15592 sec
->name
= sec
->uncompressed_name
;
15594 sec
->name
= sec
->compressed_name
;
15596 if (load_specific_debug_section (id
, section
, filedata
))
15598 /* If this debug section is part of a CU/TU set in a .dwp file,
15599 restrict load_debug_section to the sections in that set. */
15600 section_subset
= find_cu_tu_set (filedata
, shndx
);
15602 result
&= display
->display (sec
, filedata
);
15604 section_subset
= NULL
;
15606 if (secondary
|| (id
!= info
&& id
!= abbrev
&& id
!= debug_addr
))
15607 free_debug_section (id
);
15615 printf (_("Unrecognized debug section: %s\n"), print_name
);
15622 /* Set DUMP_SECTS for all sections where dumps were requested
15623 based on section name. */
15626 initialise_dumps_byname (Filedata
* filedata
)
15628 struct dump_list_entry
* cur
;
15630 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
15635 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
15636 if (SECTION_NAME_VALID (filedata
->section_headers
+ i
)
15637 && streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
15639 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
15643 if (!any
&& !filedata
->is_separate
)
15644 warn (_("Section '%s' was not dumped because it does not exist\n"),
15650 process_section_contents (Filedata
* filedata
)
15652 Elf_Internal_Shdr
* section
;
15659 initialise_dumps_byname (filedata
);
15661 for (i
= 0, section
= filedata
->section_headers
;
15662 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
15665 dump_type dump
= filedata
->dump
.dump_sects
[i
];
15667 if (filedata
->is_separate
&& ! process_links
)
15668 dump
&= DEBUG_DUMP
;
15670 #ifdef SUPPORT_DISASSEMBLY
15671 if (dump
& DISASS_DUMP
)
15673 if (! disassemble_section (section
, filedata
))
15677 if (dump
& HEX_DUMP
)
15679 if (! dump_section_as_bytes (section
, filedata
, false))
15683 if (dump
& RELOC_DUMP
)
15685 if (! dump_section_as_bytes (section
, filedata
, true))
15689 if (dump
& STRING_DUMP
)
15691 if (! dump_section_as_strings (section
, filedata
))
15695 if (dump
& DEBUG_DUMP
)
15697 if (! display_debug_section (i
, section
, filedata
))
15701 #ifdef ENABLE_LIBCTF
15702 if (dump
& CTF_DUMP
)
15704 if (! dump_section_as_ctf (section
, filedata
))
15710 if (! filedata
->is_separate
)
15712 /* Check to see if the user requested a
15713 dump of a section that does not exist. */
15714 for (; i
< filedata
->dump
.num_dump_sects
; i
++)
15715 if (filedata
->dump
.dump_sects
[i
])
15717 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
15726 process_mips_fpe_exception (int mask
)
15732 if (mask
& OEX_FPU_INEX
)
15733 fputs ("INEX", stdout
), first
= false;
15734 if (mask
& OEX_FPU_UFLO
)
15735 printf ("%sUFLO", first
? "" : "|"), first
= false;
15736 if (mask
& OEX_FPU_OFLO
)
15737 printf ("%sOFLO", first
? "" : "|"), first
= false;
15738 if (mask
& OEX_FPU_DIV0
)
15739 printf ("%sDIV0", first
? "" : "|"), first
= false;
15740 if (mask
& OEX_FPU_INVAL
)
15741 printf ("%sINVAL", first
? "" : "|");
15744 fputs ("0", stdout
);
15747 /* Display's the value of TAG at location P. If TAG is
15748 greater than 0 it is assumed to be an unknown tag, and
15749 a message is printed to this effect. Otherwise it is
15750 assumed that a message has already been printed.
15752 If the bottom bit of TAG is set it assumed to have a
15753 string value, otherwise it is assumed to have an integer
15756 Returns an updated P pointing to the first unread byte
15757 beyond the end of TAG's value.
15759 Reads at or beyond END will not be made. */
15761 static unsigned char *
15762 display_tag_value (signed int tag
,
15764 const unsigned char * const end
)
15769 printf (" Tag_unknown_%d: ", tag
);
15773 warn (_("<corrupt tag>\n"));
15777 /* PR 17531 file: 027-19978-0.004. */
15778 size_t maxlen
= (end
- p
) - 1;
15783 print_symbol ((int) maxlen
, (const char *) p
);
15784 p
+= strnlen ((char *) p
, maxlen
) + 1;
15788 printf (_("<corrupt string tag>"));
15789 p
= (unsigned char *) end
;
15795 READ_ULEB (val
, p
, end
);
15796 printf ("%ld (0x%lx)\n", val
, val
);
15803 /* ARC ABI attributes section. */
15805 static unsigned char *
15806 display_arc_attribute (unsigned char * p
,
15807 const unsigned char * const end
)
15812 READ_ULEB (tag
, p
, end
);
15816 case Tag_ARC_PCS_config
:
15817 READ_ULEB (val
, p
, end
);
15818 printf (" Tag_ARC_PCS_config: ");
15822 printf (_("Absent/Non standard\n"));
15825 printf (_("Bare metal/mwdt\n"));
15828 printf (_("Bare metal/newlib\n"));
15831 printf (_("Linux/uclibc\n"));
15834 printf (_("Linux/glibc\n"));
15837 printf (_("Unknown\n"));
15842 case Tag_ARC_CPU_base
:
15843 READ_ULEB (val
, p
, end
);
15844 printf (" Tag_ARC_CPU_base: ");
15849 printf (_("Absent\n"));
15851 case TAG_CPU_ARC6xx
:
15852 printf ("ARC6xx\n");
15854 case TAG_CPU_ARC7xx
:
15855 printf ("ARC7xx\n");
15857 case TAG_CPU_ARCEM
:
15858 printf ("ARCEM\n");
15860 case TAG_CPU_ARCHS
:
15861 printf ("ARCHS\n");
15866 case Tag_ARC_CPU_variation
:
15867 READ_ULEB (val
, p
, end
);
15868 printf (" Tag_ARC_CPU_variation: ");
15872 if (val
> 0 && val
< 16)
15873 printf ("Core%d\n", val
);
15875 printf ("Unknown\n");
15879 printf (_("Absent\n"));
15884 case Tag_ARC_CPU_name
:
15885 printf (" Tag_ARC_CPU_name: ");
15886 p
= display_tag_value (-1, p
, end
);
15889 case Tag_ARC_ABI_rf16
:
15890 READ_ULEB (val
, p
, end
);
15891 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
15894 case Tag_ARC_ABI_osver
:
15895 READ_ULEB (val
, p
, end
);
15896 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
15899 case Tag_ARC_ABI_pic
:
15900 case Tag_ARC_ABI_sda
:
15901 READ_ULEB (val
, p
, end
);
15902 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
15903 : " Tag_ARC_ABI_pic: ");
15907 printf (_("Absent\n"));
15916 printf (_("Unknown\n"));
15921 case Tag_ARC_ABI_tls
:
15922 READ_ULEB (val
, p
, end
);
15923 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
15926 case Tag_ARC_ABI_enumsize
:
15927 READ_ULEB (val
, p
, end
);
15928 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
15932 case Tag_ARC_ABI_exceptions
:
15933 READ_ULEB (val
, p
, end
);
15934 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
15938 case Tag_ARC_ABI_double_size
:
15939 READ_ULEB (val
, p
, end
);
15940 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
15943 case Tag_ARC_ISA_config
:
15944 printf (" Tag_ARC_ISA_config: ");
15945 p
= display_tag_value (-1, p
, end
);
15948 case Tag_ARC_ISA_apex
:
15949 printf (" Tag_ARC_ISA_apex: ");
15950 p
= display_tag_value (-1, p
, end
);
15953 case Tag_ARC_ISA_mpy_option
:
15954 READ_ULEB (val
, p
, end
);
15955 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
15958 case Tag_ARC_ATR_version
:
15959 READ_ULEB (val
, p
, end
);
15960 printf (" Tag_ARC_ATR_version: %d\n", val
);
15964 return display_tag_value (tag
& 1, p
, end
);
15970 /* ARM EABI attributes section. */
15975 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
15977 const char *const *table
;
15978 } arm_attr_public_tag
;
15980 static const char *const arm_attr_tag_CPU_arch
[] =
15981 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
15982 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
15983 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
15984 static const char *const arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
15985 static const char *const arm_attr_tag_THUMB_ISA_use
[] =
15986 {"No", "Thumb-1", "Thumb-2", "Yes"};
15987 static const char *const arm_attr_tag_FP_arch
[] =
15988 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
15989 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
15990 static const char *const arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
15991 static const char *const arm_attr_tag_Advanced_SIMD_arch
[] =
15992 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
15993 "NEON for ARMv8.1"};
15994 static const char *const arm_attr_tag_PCS_config
[] =
15995 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
15996 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
15997 static const char *const arm_attr_tag_ABI_PCS_R9_use
[] =
15998 {"V6", "SB", "TLS", "Unused"};
15999 static const char *const arm_attr_tag_ABI_PCS_RW_data
[] =
16000 {"Absolute", "PC-relative", "SB-relative", "None"};
16001 static const char *const arm_attr_tag_ABI_PCS_RO_data
[] =
16002 {"Absolute", "PC-relative", "None"};
16003 static const char *const arm_attr_tag_ABI_PCS_GOT_use
[] =
16004 {"None", "direct", "GOT-indirect"};
16005 static const char *const arm_attr_tag_ABI_PCS_wchar_t
[] =
16006 {"None", "??? 1", "2", "??? 3", "4"};
16007 static const char *const arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
16008 static const char *const arm_attr_tag_ABI_FP_denormal
[] =
16009 {"Unused", "Needed", "Sign only"};
16010 static const char *const arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
16011 static const char *const arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
16012 static const char *const arm_attr_tag_ABI_FP_number_model
[] =
16013 {"Unused", "Finite", "RTABI", "IEEE 754"};
16014 static const char *const arm_attr_tag_ABI_enum_size
[] =
16015 {"Unused", "small", "int", "forced to int"};
16016 static const char *const arm_attr_tag_ABI_HardFP_use
[] =
16017 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
16018 static const char *const arm_attr_tag_ABI_VFP_args
[] =
16019 {"AAPCS", "VFP registers", "custom", "compatible"};
16020 static const char *const arm_attr_tag_ABI_WMMX_args
[] =
16021 {"AAPCS", "WMMX registers", "custom"};
16022 static const char *const arm_attr_tag_ABI_optimization_goals
[] =
16023 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
16024 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
16025 static const char *const arm_attr_tag_ABI_FP_optimization_goals
[] =
16026 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
16027 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
16028 static const char *const arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
16029 static const char *const arm_attr_tag_FP_HP_extension
[] =
16030 {"Not Allowed", "Allowed"};
16031 static const char *const arm_attr_tag_ABI_FP_16bit_format
[] =
16032 {"None", "IEEE 754", "Alternative Format"};
16033 static const char *const arm_attr_tag_DSP_extension
[] =
16034 {"Follow architecture", "Allowed"};
16035 static const char *const arm_attr_tag_MPextension_use
[] =
16036 {"Not Allowed", "Allowed"};
16037 static const char *const arm_attr_tag_DIV_use
[] =
16038 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
16039 "Allowed in v7-A with integer division extension"};
16040 static const char *const arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
16041 static const char *const arm_attr_tag_Virtualization_use
[] =
16042 {"Not Allowed", "TrustZone", "Virtualization Extensions",
16043 "TrustZone and Virtualization Extensions"};
16044 static const char *const arm_attr_tag_MPextension_use_legacy
[] =
16045 {"Not Allowed", "Allowed"};
16047 static const char *const arm_attr_tag_MVE_arch
[] =
16048 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
16050 #define LOOKUP(id, name) \
16051 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
16052 static arm_attr_public_tag arm_attr_public_tags
[] =
16054 {4, "CPU_raw_name", 1, NULL
},
16055 {5, "CPU_name", 1, NULL
},
16056 LOOKUP(6, CPU_arch
),
16057 {7, "CPU_arch_profile", 0, NULL
},
16058 LOOKUP(8, ARM_ISA_use
),
16059 LOOKUP(9, THUMB_ISA_use
),
16060 LOOKUP(10, FP_arch
),
16061 LOOKUP(11, WMMX_arch
),
16062 LOOKUP(12, Advanced_SIMD_arch
),
16063 LOOKUP(13, PCS_config
),
16064 LOOKUP(14, ABI_PCS_R9_use
),
16065 LOOKUP(15, ABI_PCS_RW_data
),
16066 LOOKUP(16, ABI_PCS_RO_data
),
16067 LOOKUP(17, ABI_PCS_GOT_use
),
16068 LOOKUP(18, ABI_PCS_wchar_t
),
16069 LOOKUP(19, ABI_FP_rounding
),
16070 LOOKUP(20, ABI_FP_denormal
),
16071 LOOKUP(21, ABI_FP_exceptions
),
16072 LOOKUP(22, ABI_FP_user_exceptions
),
16073 LOOKUP(23, ABI_FP_number_model
),
16074 {24, "ABI_align_needed", 0, NULL
},
16075 {25, "ABI_align_preserved", 0, NULL
},
16076 LOOKUP(26, ABI_enum_size
),
16077 LOOKUP(27, ABI_HardFP_use
),
16078 LOOKUP(28, ABI_VFP_args
),
16079 LOOKUP(29, ABI_WMMX_args
),
16080 LOOKUP(30, ABI_optimization_goals
),
16081 LOOKUP(31, ABI_FP_optimization_goals
),
16082 {32, "compatibility", 0, NULL
},
16083 LOOKUP(34, CPU_unaligned_access
),
16084 LOOKUP(36, FP_HP_extension
),
16085 LOOKUP(38, ABI_FP_16bit_format
),
16086 LOOKUP(42, MPextension_use
),
16087 LOOKUP(44, DIV_use
),
16088 LOOKUP(46, DSP_extension
),
16089 LOOKUP(48, MVE_arch
),
16090 {64, "nodefaults", 0, NULL
},
16091 {65, "also_compatible_with", 0, NULL
},
16092 LOOKUP(66, T2EE_use
),
16093 {67, "conformance", 1, NULL
},
16094 LOOKUP(68, Virtualization_use
),
16095 LOOKUP(70, MPextension_use_legacy
)
16099 static unsigned char *
16100 display_arm_attribute (unsigned char * p
,
16101 const unsigned char * const end
)
16105 arm_attr_public_tag
* attr
;
16109 READ_ULEB (tag
, p
, end
);
16111 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
16113 if (arm_attr_public_tags
[i
].tag
== tag
)
16115 attr
= &arm_attr_public_tags
[i
];
16122 printf (" Tag_%s: ", attr
->name
);
16123 switch (attr
->type
)
16128 case 7: /* Tag_CPU_arch_profile. */
16129 READ_ULEB (val
, p
, end
);
16132 case 0: printf (_("None\n")); break;
16133 case 'A': printf (_("Application\n")); break;
16134 case 'R': printf (_("Realtime\n")); break;
16135 case 'M': printf (_("Microcontroller\n")); break;
16136 case 'S': printf (_("Application or Realtime\n")); break;
16137 default: printf ("??? (%d)\n", val
); break;
16141 case 24: /* Tag_align_needed. */
16142 READ_ULEB (val
, p
, end
);
16145 case 0: printf (_("None\n")); break;
16146 case 1: printf (_("8-byte\n")); break;
16147 case 2: printf (_("4-byte\n")); break;
16148 case 3: printf ("??? 3\n"); break;
16151 printf (_("8-byte and up to %d-byte extended\n"),
16154 printf ("??? (%d)\n", val
);
16159 case 25: /* Tag_align_preserved. */
16160 READ_ULEB (val
, p
, end
);
16163 case 0: printf (_("None\n")); break;
16164 case 1: printf (_("8-byte, except leaf SP\n")); break;
16165 case 2: printf (_("8-byte\n")); break;
16166 case 3: printf ("??? 3\n"); break;
16169 printf (_("8-byte and up to %d-byte extended\n"),
16172 printf ("??? (%d)\n", val
);
16177 case 32: /* Tag_compatibility. */
16179 READ_ULEB (val
, p
, end
);
16180 printf (_("flag = %d, vendor = "), val
);
16183 size_t maxlen
= (end
- p
) - 1;
16185 print_symbol ((int) maxlen
, (const char *) p
);
16186 p
+= strnlen ((char *) p
, maxlen
) + 1;
16190 printf (_("<corrupt>"));
16191 p
= (unsigned char *) end
;
16197 case 64: /* Tag_nodefaults. */
16198 /* PR 17531: file: 001-505008-0.01. */
16201 printf (_("True\n"));
16204 case 65: /* Tag_also_compatible_with. */
16205 READ_ULEB (val
, p
, end
);
16206 if (val
== 6 /* Tag_CPU_arch. */)
16208 READ_ULEB (val
, p
, end
);
16209 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
16210 printf ("??? (%d)\n", val
);
16212 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
16216 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
16221 printf (_("<unknown: %d>\n"), tag
);
16227 return display_tag_value (-1, p
, end
);
16229 return display_tag_value (0, p
, end
);
16232 assert (attr
->type
& 0x80);
16233 READ_ULEB (val
, p
, end
);
16234 type
= attr
->type
& 0x7f;
16236 printf ("??? (%d)\n", val
);
16238 printf ("%s\n", attr
->table
[val
]);
16243 return display_tag_value (tag
, p
, end
);
16246 static unsigned char *
16247 display_gnu_attribute (unsigned char * p
,
16248 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
16249 const unsigned char * const end
)
16254 READ_ULEB (tag
, p
, end
);
16256 /* Tag_compatibility is the only generic GNU attribute defined at
16260 READ_ULEB (val
, p
, end
);
16262 printf (_("flag = %d, vendor = "), val
);
16265 printf (_("<corrupt>\n"));
16266 warn (_("corrupt vendor attribute\n"));
16272 size_t maxlen
= (end
- p
) - 1;
16274 print_symbol ((int) maxlen
, (const char *) p
);
16275 p
+= strnlen ((char *) p
, maxlen
) + 1;
16279 printf (_("<corrupt>"));
16280 p
= (unsigned char *) end
;
16287 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
16288 return display_proc_gnu_attribute (p
, tag
, end
);
16290 return display_tag_value (tag
, p
, end
);
16293 static unsigned char *
16294 display_m68k_gnu_attribute (unsigned char * p
,
16296 const unsigned char * const end
)
16300 if (tag
== Tag_GNU_M68K_ABI_FP
)
16302 printf (" Tag_GNU_M68K_ABI_FP: ");
16305 printf (_("<corrupt>\n"));
16308 READ_ULEB (val
, p
, end
);
16311 printf ("(%#x), ", val
);
16316 printf (_("unspecified hard/soft float\n"));
16319 printf (_("hard float\n"));
16322 printf (_("soft float\n"));
16328 return display_tag_value (tag
& 1, p
, end
);
16331 static unsigned char *
16332 display_power_gnu_attribute (unsigned char * p
,
16334 const unsigned char * const end
)
16338 if (tag
== Tag_GNU_Power_ABI_FP
)
16340 printf (" Tag_GNU_Power_ABI_FP: ");
16343 printf (_("<corrupt>\n"));
16346 READ_ULEB (val
, p
, end
);
16349 printf ("(%#x), ", val
);
16354 printf (_("unspecified hard/soft float, "));
16357 printf (_("hard float, "));
16360 printf (_("soft float, "));
16363 printf (_("single-precision hard float, "));
16370 printf (_("unspecified long double\n"));
16373 printf (_("128-bit IBM long double\n"));
16376 printf (_("64-bit long double\n"));
16379 printf (_("128-bit IEEE long double\n"));
16385 if (tag
== Tag_GNU_Power_ABI_Vector
)
16387 printf (" Tag_GNU_Power_ABI_Vector: ");
16390 printf (_("<corrupt>\n"));
16393 READ_ULEB (val
, p
, end
);
16396 printf ("(%#x), ", val
);
16401 printf (_("unspecified\n"));
16404 printf (_("generic\n"));
16407 printf ("AltiVec\n");
16416 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
16418 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
16421 printf (_("<corrupt>\n"));
16424 READ_ULEB (val
, p
, end
);
16427 printf ("(%#x), ", val
);
16432 printf (_("unspecified\n"));
16435 printf ("r3/r4\n");
16438 printf (_("memory\n"));
16447 return display_tag_value (tag
& 1, p
, end
);
16450 static unsigned char *
16451 display_s390_gnu_attribute (unsigned char * p
,
16453 const unsigned char * const end
)
16457 if (tag
== Tag_GNU_S390_ABI_Vector
)
16459 printf (" Tag_GNU_S390_ABI_Vector: ");
16460 READ_ULEB (val
, p
, end
);
16465 printf (_("any\n"));
16468 printf (_("software\n"));
16471 printf (_("hardware\n"));
16474 printf ("??? (%d)\n", val
);
16480 return display_tag_value (tag
& 1, p
, end
);
16484 display_sparc_hwcaps (unsigned int mask
)
16490 if (mask
& ELF_SPARC_HWCAP_MUL32
)
16491 fputs ("mul32", stdout
), first
= false;
16492 if (mask
& ELF_SPARC_HWCAP_DIV32
)
16493 printf ("%sdiv32", first
? "" : "|"), first
= false;
16494 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
16495 printf ("%sfsmuld", first
? "" : "|"), first
= false;
16496 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
16497 printf ("%sv8plus", first
? "" : "|"), first
= false;
16498 if (mask
& ELF_SPARC_HWCAP_POPC
)
16499 printf ("%spopc", first
? "" : "|"), first
= false;
16500 if (mask
& ELF_SPARC_HWCAP_VIS
)
16501 printf ("%svis", first
? "" : "|"), first
= false;
16502 if (mask
& ELF_SPARC_HWCAP_VIS2
)
16503 printf ("%svis2", first
? "" : "|"), first
= false;
16504 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
16505 printf ("%sASIBlkInit", first
? "" : "|"), first
= false;
16506 if (mask
& ELF_SPARC_HWCAP_FMAF
)
16507 printf ("%sfmaf", first
? "" : "|"), first
= false;
16508 if (mask
& ELF_SPARC_HWCAP_VIS3
)
16509 printf ("%svis3", first
? "" : "|"), first
= false;
16510 if (mask
& ELF_SPARC_HWCAP_HPC
)
16511 printf ("%shpc", first
? "" : "|"), first
= false;
16512 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
16513 printf ("%srandom", first
? "" : "|"), first
= false;
16514 if (mask
& ELF_SPARC_HWCAP_TRANS
)
16515 printf ("%strans", first
? "" : "|"), first
= false;
16516 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
16517 printf ("%sfjfmau", first
? "" : "|"), first
= false;
16518 if (mask
& ELF_SPARC_HWCAP_IMA
)
16519 printf ("%sima", first
? "" : "|"), first
= false;
16520 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
16521 printf ("%scspare", first
? "" : "|"), first
= false;
16524 fputc ('0', stdout
);
16525 fputc ('\n', stdout
);
16529 display_sparc_hwcaps2 (unsigned int mask
)
16535 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
16536 fputs ("fjathplus", stdout
), first
= false;
16537 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
16538 printf ("%svis3b", first
? "" : "|"), first
= false;
16539 if (mask
& ELF_SPARC_HWCAP2_ADP
)
16540 printf ("%sadp", first
? "" : "|"), first
= false;
16541 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
16542 printf ("%ssparc5", first
? "" : "|"), first
= false;
16543 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
16544 printf ("%smwait", first
? "" : "|"), first
= false;
16545 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
16546 printf ("%sxmpmul", first
? "" : "|"), first
= false;
16547 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
16548 printf ("%sxmont2", first
? "" : "|"), first
= false;
16549 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
16550 printf ("%snsec", first
? "" : "|"), first
= false;
16551 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
16552 printf ("%sfjathhpc", first
? "" : "|"), first
= false;
16553 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
16554 printf ("%sfjdes", first
? "" : "|"), first
= false;
16555 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
16556 printf ("%sfjaes", first
? "" : "|"), first
= false;
16559 fputc ('0', stdout
);
16560 fputc ('\n', stdout
);
16563 static unsigned char *
16564 display_sparc_gnu_attribute (unsigned char * p
,
16566 const unsigned char * const end
)
16570 if (tag
== Tag_GNU_Sparc_HWCAPS
)
16572 READ_ULEB (val
, p
, end
);
16573 printf (" Tag_GNU_Sparc_HWCAPS: ");
16574 display_sparc_hwcaps (val
);
16577 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
16579 READ_ULEB (val
, p
, end
);
16580 printf (" Tag_GNU_Sparc_HWCAPS2: ");
16581 display_sparc_hwcaps2 (val
);
16585 return display_tag_value (tag
, p
, end
);
16589 print_mips_fp_abi_value (unsigned int val
)
16593 case Val_GNU_MIPS_ABI_FP_ANY
:
16594 printf (_("Hard or soft float\n"));
16596 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
16597 printf (_("Hard float (double precision)\n"));
16599 case Val_GNU_MIPS_ABI_FP_SINGLE
:
16600 printf (_("Hard float (single precision)\n"));
16602 case Val_GNU_MIPS_ABI_FP_SOFT
:
16603 printf (_("Soft float\n"));
16605 case Val_GNU_MIPS_ABI_FP_OLD_64
:
16606 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
16608 case Val_GNU_MIPS_ABI_FP_XX
:
16609 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
16611 case Val_GNU_MIPS_ABI_FP_64
:
16612 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
16614 case Val_GNU_MIPS_ABI_FP_64A
:
16615 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
16617 case Val_GNU_MIPS_ABI_FP_NAN2008
:
16618 printf (_("NaN 2008 compatibility\n"));
16621 printf ("??? (%d)\n", val
);
16626 static unsigned char *
16627 display_mips_gnu_attribute (unsigned char * p
,
16629 const unsigned char * const end
)
16631 if (tag
== Tag_GNU_MIPS_ABI_FP
)
16635 printf (" Tag_GNU_MIPS_ABI_FP: ");
16636 READ_ULEB (val
, p
, end
);
16637 print_mips_fp_abi_value (val
);
16641 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
16645 printf (" Tag_GNU_MIPS_ABI_MSA: ");
16646 READ_ULEB (val
, p
, end
);
16650 case Val_GNU_MIPS_ABI_MSA_ANY
:
16651 printf (_("Any MSA or not\n"));
16653 case Val_GNU_MIPS_ABI_MSA_128
:
16654 printf (_("128-bit MSA\n"));
16657 printf ("??? (%d)\n", val
);
16663 return display_tag_value (tag
& 1, p
, end
);
16666 static unsigned char *
16667 display_tic6x_attribute (unsigned char * p
,
16668 const unsigned char * const end
)
16673 READ_ULEB (tag
, p
, end
);
16678 printf (" Tag_ISA: ");
16679 READ_ULEB (val
, p
, end
);
16683 case C6XABI_Tag_ISA_none
:
16684 printf (_("None\n"));
16686 case C6XABI_Tag_ISA_C62X
:
16689 case C6XABI_Tag_ISA_C67X
:
16692 case C6XABI_Tag_ISA_C67XP
:
16693 printf ("C67x+\n");
16695 case C6XABI_Tag_ISA_C64X
:
16698 case C6XABI_Tag_ISA_C64XP
:
16699 printf ("C64x+\n");
16701 case C6XABI_Tag_ISA_C674X
:
16702 printf ("C674x\n");
16705 printf ("??? (%d)\n", val
);
16710 case Tag_ABI_wchar_t
:
16711 printf (" Tag_ABI_wchar_t: ");
16712 READ_ULEB (val
, p
, end
);
16716 printf (_("Not used\n"));
16719 printf (_("2 bytes\n"));
16722 printf (_("4 bytes\n"));
16725 printf ("??? (%d)\n", val
);
16730 case Tag_ABI_stack_align_needed
:
16731 printf (" Tag_ABI_stack_align_needed: ");
16732 READ_ULEB (val
, p
, end
);
16736 printf (_("8-byte\n"));
16739 printf (_("16-byte\n"));
16742 printf ("??? (%d)\n", val
);
16747 case Tag_ABI_stack_align_preserved
:
16748 READ_ULEB (val
, p
, end
);
16749 printf (" Tag_ABI_stack_align_preserved: ");
16753 printf (_("8-byte\n"));
16756 printf (_("16-byte\n"));
16759 printf ("??? (%d)\n", val
);
16765 READ_ULEB (val
, p
, end
);
16766 printf (" Tag_ABI_DSBT: ");
16770 printf (_("DSBT addressing not used\n"));
16773 printf (_("DSBT addressing used\n"));
16776 printf ("??? (%d)\n", val
);
16782 READ_ULEB (val
, p
, end
);
16783 printf (" Tag_ABI_PID: ");
16787 printf (_("Data addressing position-dependent\n"));
16790 printf (_("Data addressing position-independent, GOT near DP\n"));
16793 printf (_("Data addressing position-independent, GOT far from DP\n"));
16796 printf ("??? (%d)\n", val
);
16802 READ_ULEB (val
, p
, end
);
16803 printf (" Tag_ABI_PIC: ");
16807 printf (_("Code addressing position-dependent\n"));
16810 printf (_("Code addressing position-independent\n"));
16813 printf ("??? (%d)\n", val
);
16818 case Tag_ABI_array_object_alignment
:
16819 READ_ULEB (val
, p
, end
);
16820 printf (" Tag_ABI_array_object_alignment: ");
16824 printf (_("8-byte\n"));
16827 printf (_("4-byte\n"));
16830 printf (_("16-byte\n"));
16833 printf ("??? (%d)\n", val
);
16838 case Tag_ABI_array_object_align_expected
:
16839 READ_ULEB (val
, p
, end
);
16840 printf (" Tag_ABI_array_object_align_expected: ");
16844 printf (_("8-byte\n"));
16847 printf (_("4-byte\n"));
16850 printf (_("16-byte\n"));
16853 printf ("??? (%d)\n", val
);
16858 case Tag_ABI_compatibility
:
16860 READ_ULEB (val
, p
, end
);
16861 printf (" Tag_ABI_compatibility: ");
16862 printf (_("flag = %d, vendor = "), val
);
16865 size_t maxlen
= (end
- p
) - 1;
16867 print_symbol ((int) maxlen
, (const char *) p
);
16868 p
+= strnlen ((char *) p
, maxlen
) + 1;
16872 printf (_("<corrupt>"));
16873 p
= (unsigned char *) end
;
16879 case Tag_ABI_conformance
:
16881 printf (" Tag_ABI_conformance: \"");
16884 size_t maxlen
= (end
- p
) - 1;
16886 print_symbol ((int) maxlen
, (const char *) p
);
16887 p
+= strnlen ((char *) p
, maxlen
) + 1;
16891 printf (_("<corrupt>"));
16892 p
= (unsigned char *) end
;
16899 return display_tag_value (tag
, p
, end
);
16903 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
16905 unsigned long addr
= 0;
16906 size_t bytes
= end
- p
;
16913 int lbytes
= (bytes
> 16 ? 16 : bytes
);
16915 printf (" 0x%8.8lx ", addr
);
16917 for (j
= 0; j
< 16; j
++)
16920 printf ("%2.2x", p
[j
]);
16928 for (j
= 0; j
< lbytes
; j
++)
16931 if (k
>= ' ' && k
< 0x7f)
16947 static unsigned char *
16948 display_msp430_attribute (unsigned char * p
,
16949 const unsigned char * const end
)
16954 READ_ULEB (tag
, p
, end
);
16958 case OFBA_MSPABI_Tag_ISA
:
16959 printf (" Tag_ISA: ");
16960 READ_ULEB (val
, p
, end
);
16963 case 0: printf (_("None\n")); break;
16964 case 1: printf (_("MSP430\n")); break;
16965 case 2: printf (_("MSP430X\n")); break;
16966 default: printf ("??? (%d)\n", val
); break;
16970 case OFBA_MSPABI_Tag_Code_Model
:
16971 printf (" Tag_Code_Model: ");
16972 READ_ULEB (val
, p
, end
);
16975 case 0: printf (_("None\n")); break;
16976 case 1: printf (_("Small\n")); break;
16977 case 2: printf (_("Large\n")); break;
16978 default: printf ("??? (%d)\n", val
); break;
16982 case OFBA_MSPABI_Tag_Data_Model
:
16983 printf (" Tag_Data_Model: ");
16984 READ_ULEB (val
, p
, end
);
16987 case 0: printf (_("None\n")); break;
16988 case 1: printf (_("Small\n")); break;
16989 case 2: printf (_("Large\n")); break;
16990 case 3: printf (_("Restricted Large\n")); break;
16991 default: printf ("??? (%d)\n", val
); break;
16996 printf (_(" <unknown tag %d>: "), tag
);
17003 size_t maxlen
= (end
- p
) - 1;
17005 print_symbol ((int) maxlen
, (const char *) p
);
17006 p
+= strnlen ((char *) p
, maxlen
) + 1;
17010 printf (_("<corrupt>"));
17011 p
= (unsigned char *) end
;
17017 READ_ULEB (val
, p
, end
);
17018 printf ("%d (0x%x)\n", val
, val
);
17027 static unsigned char *
17028 display_msp430_gnu_attribute (unsigned char * p
,
17030 const unsigned char * const end
)
17032 if (tag
== Tag_GNU_MSP430_Data_Region
)
17036 printf (" Tag_GNU_MSP430_Data_Region: ");
17037 READ_ULEB (val
, p
, end
);
17041 case Val_GNU_MSP430_Data_Region_Any
:
17042 printf (_("Any Region\n"));
17044 case Val_GNU_MSP430_Data_Region_Lower
:
17045 printf (_("Lower Region Only\n"));
17048 printf ("??? (%u)\n", val
);
17052 return display_tag_value (tag
& 1, p
, end
);
17055 struct riscv_attr_tag_t
{
17060 static struct riscv_attr_tag_t riscv_attr_tag
[] =
17062 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
17065 T(priv_spec_minor
),
17066 T(priv_spec_revision
),
17067 T(unaligned_access
),
17072 static unsigned char *
17073 display_riscv_attribute (unsigned char *p
,
17074 const unsigned char * const end
)
17078 struct riscv_attr_tag_t
*attr
= NULL
;
17081 READ_ULEB (tag
, p
, end
);
17083 /* Find the name of attribute. */
17084 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
17086 if (riscv_attr_tag
[i
].tag
== tag
)
17088 attr
= &riscv_attr_tag
[i
];
17094 printf (" %s: ", attr
->name
);
17096 return display_tag_value (tag
, p
, end
);
17100 case Tag_RISCV_priv_spec
:
17101 case Tag_RISCV_priv_spec_minor
:
17102 case Tag_RISCV_priv_spec_revision
:
17103 READ_ULEB (val
, p
, end
);
17104 printf (_("%u\n"), val
);
17106 case Tag_RISCV_unaligned_access
:
17107 READ_ULEB (val
, p
, end
);
17111 printf (_("No unaligned access\n"));
17114 printf (_("Unaligned access\n"));
17118 case Tag_RISCV_stack_align
:
17119 READ_ULEB (val
, p
, end
);
17120 printf (_("%u-bytes\n"), val
);
17122 case Tag_RISCV_arch
:
17123 p
= display_tag_value (-1, p
, end
);
17126 return display_tag_value (tag
, p
, end
);
17132 static unsigned char *
17133 display_csky_attribute (unsigned char * p
,
17134 const unsigned char * const end
)
17138 READ_ULEB (tag
, p
, end
);
17140 if (tag
>= Tag_CSKY_MAX
)
17142 return display_tag_value (-1, p
, end
);
17147 case Tag_CSKY_ARCH_NAME
:
17148 printf (" Tag_CSKY_ARCH_NAME:\t\t");
17149 return display_tag_value (-1, p
, end
);
17150 case Tag_CSKY_CPU_NAME
:
17151 printf (" Tag_CSKY_CPU_NAME:\t\t");
17152 return display_tag_value (-1, p
, end
);
17154 case Tag_CSKY_ISA_FLAGS
:
17155 printf (" Tag_CSKY_ISA_FLAGS:\t\t");
17156 return display_tag_value (0, p
, end
);
17157 case Tag_CSKY_ISA_EXT_FLAGS
:
17158 printf (" Tag_CSKY_ISA_EXT_FLAGS:\t");
17159 return display_tag_value (0, p
, end
);
17161 case Tag_CSKY_DSP_VERSION
:
17162 printf (" Tag_CSKY_DSP_VERSION:\t\t");
17163 READ_ULEB (val
, p
, end
);
17164 if (val
== VAL_CSKY_DSP_VERSION_EXTENSION
)
17165 printf ("DSP Extension\n");
17166 else if (val
== VAL_CSKY_DSP_VERSION_2
)
17167 printf ("DSP 2.0\n");
17170 case Tag_CSKY_VDSP_VERSION
:
17171 printf (" Tag_CSKY_VDSP_VERSION:\t");
17172 READ_ULEB (val
, p
, end
);
17173 printf ("VDSP Version %d\n", val
);
17176 case Tag_CSKY_FPU_VERSION
:
17177 printf (" Tag_CSKY_FPU_VERSION:\t\t");
17178 READ_ULEB (val
, p
, end
);
17179 if (val
== VAL_CSKY_FPU_VERSION_1
)
17180 printf ("ABIV1 FPU Version 1\n");
17181 else if (val
== VAL_CSKY_FPU_VERSION_2
)
17182 printf ("FPU Version 2\n");
17185 case Tag_CSKY_FPU_ABI
:
17186 printf (" Tag_CSKY_FPU_ABI:\t\t");
17187 READ_ULEB (val
, p
, end
);
17188 if (val
== VAL_CSKY_FPU_ABI_HARD
)
17190 else if (val
== VAL_CSKY_FPU_ABI_SOFTFP
)
17191 printf ("SoftFP\n");
17192 else if (val
== VAL_CSKY_FPU_ABI_SOFT
)
17195 case Tag_CSKY_FPU_ROUNDING
:
17196 READ_ULEB (val
, p
, end
);
17198 printf (" Tag_CSKY_FPU_ROUNDING:\t");
17199 printf ("Needed\n");
17202 case Tag_CSKY_FPU_DENORMAL
:
17203 READ_ULEB (val
, p
, end
);
17205 printf (" Tag_CSKY_FPU_DENORMAL:\t");
17206 printf ("Needed\n");
17209 case Tag_CSKY_FPU_Exception
:
17210 READ_ULEB (val
, p
, end
);
17212 printf (" Tag_CSKY_FPU_Exception:\t");
17213 printf ("Needed\n");
17216 case Tag_CSKY_FPU_NUMBER_MODULE
:
17217 printf (" Tag_CSKY_FPU_NUMBER_MODULE:\t");
17218 return display_tag_value (-1, p
, end
);
17219 case Tag_CSKY_FPU_HARDFP
:
17220 printf (" Tag_CSKY_FPU_HARDFP:\t\t");
17221 READ_ULEB (val
, p
, end
);
17222 if (val
& VAL_CSKY_FPU_HARDFP_HALF
)
17224 if (val
& VAL_CSKY_FPU_HARDFP_SINGLE
)
17225 printf (" Single");
17226 if (val
& VAL_CSKY_FPU_HARDFP_DOUBLE
)
17227 printf (" Double");
17231 return display_tag_value (tag
, p
, end
);
17237 process_attributes (Filedata
* filedata
,
17238 const char * public_name
,
17239 unsigned int proc_type
,
17240 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
17241 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
17243 Elf_Internal_Shdr
* sect
;
17247 /* Find the section header so that we get the size. */
17248 for (i
= 0, sect
= filedata
->section_headers
;
17249 i
< filedata
->file_header
.e_shnum
;
17252 unsigned char * contents
;
17255 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
17258 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17259 sect
->sh_size
, _("attributes"));
17260 if (contents
== NULL
)
17267 /* The first character is the version of the attributes.
17268 Currently only version 1, (aka 'A') is recognised here. */
17271 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
17276 bfd_vma section_len
;
17278 section_len
= sect
->sh_size
- 1;
17281 while (section_len
> 0)
17284 unsigned int namelen
;
17285 bool public_section
;
17288 if (section_len
<= 4)
17290 error (_("Tag section ends prematurely\n"));
17294 attr_len
= byte_get (p
, 4);
17297 if (attr_len
> section_len
)
17299 error (_("Bad attribute length (%u > %u)\n"),
17300 (unsigned) attr_len
, (unsigned) section_len
);
17301 attr_len
= section_len
;
17304 /* PR 17531: file: 001-101425-0.004 */
17305 else if (attr_len
< 5)
17307 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
17312 section_len
-= attr_len
;
17315 namelen
= strnlen ((char *) p
, attr_len
) + 1;
17316 if (namelen
== 0 || namelen
>= attr_len
)
17318 error (_("Corrupt attribute section name\n"));
17323 printf (_("Attribute Section: "));
17324 print_symbol (INT_MAX
, (const char *) p
);
17327 if (public_name
&& streq ((char *) p
, public_name
))
17328 public_section
= true;
17330 public_section
= false;
17332 if (streq ((char *) p
, "gnu"))
17333 gnu_section
= true;
17335 gnu_section
= false;
17338 attr_len
-= namelen
;
17340 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
17345 unsigned char * end
;
17347 /* PR binutils/17531: Safe handling of corrupt files. */
17350 error (_("Unused bytes at end of section\n"));
17357 size
= byte_get (p
, 4);
17358 if (size
> attr_len
)
17360 error (_("Bad subsection length (%u > %u)\n"),
17361 (unsigned) size
, (unsigned) attr_len
);
17365 /* PR binutils/17531: Safe handling of corrupt files. */
17368 error (_("Bad subsection length (%u < 6)\n"),
17376 end
= p
+ size
- 1;
17377 assert (end
<= contents
+ sect
->sh_size
);
17383 printf (_("File Attributes\n"));
17386 printf (_("Section Attributes:"));
17389 printf (_("Symbol Attributes:"));
17390 /* Fall through. */
17394 READ_ULEB (val
, p
, end
);
17397 printf (" %d", val
);
17402 printf (_("Unknown tag: %d\n"), tag
);
17403 public_section
= false;
17407 if (public_section
&& display_pub_attribute
!= NULL
)
17410 p
= display_pub_attribute (p
, end
);
17413 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
17416 p
= display_gnu_attribute (p
,
17417 display_proc_gnu_attribute
,
17423 printf (_(" Unknown attribute:\n"));
17424 display_raw_attribute (p
, end
);
17439 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
17440 Print the Address, Access and Initial fields of an entry at VMA ADDR
17441 and return the VMA of the next entry, or -1 if there was a problem.
17442 Does not read from DATA_END or beyond. */
17445 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
17446 unsigned char * data_end
)
17449 print_vma (addr
, LONG_HEX
);
17451 if (addr
< pltgot
+ 0xfff0)
17452 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
17454 printf ("%10s", "");
17457 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
17461 unsigned char * from
= data
+ addr
- pltgot
;
17463 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
17465 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
17466 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
17467 return (bfd_vma
) -1;
17471 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
17472 print_vma (entry
, LONG_HEX
);
17475 return addr
+ (is_32bit_elf
? 4 : 8);
17478 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
17479 PLTGOT. Print the Address and Initial fields of an entry at VMA
17480 ADDR and return the VMA of the next entry. */
17483 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
17486 print_vma (addr
, LONG_HEX
);
17489 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
17494 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
17495 print_vma (entry
, LONG_HEX
);
17497 return addr
+ (is_32bit_elf
? 4 : 8);
17501 print_mips_ases (unsigned int mask
)
17503 if (mask
& AFL_ASE_DSP
)
17504 fputs ("\n\tDSP ASE", stdout
);
17505 if (mask
& AFL_ASE_DSPR2
)
17506 fputs ("\n\tDSP R2 ASE", stdout
);
17507 if (mask
& AFL_ASE_DSPR3
)
17508 fputs ("\n\tDSP R3 ASE", stdout
);
17509 if (mask
& AFL_ASE_EVA
)
17510 fputs ("\n\tEnhanced VA Scheme", stdout
);
17511 if (mask
& AFL_ASE_MCU
)
17512 fputs ("\n\tMCU (MicroController) ASE", stdout
);
17513 if (mask
& AFL_ASE_MDMX
)
17514 fputs ("\n\tMDMX ASE", stdout
);
17515 if (mask
& AFL_ASE_MIPS3D
)
17516 fputs ("\n\tMIPS-3D ASE", stdout
);
17517 if (mask
& AFL_ASE_MT
)
17518 fputs ("\n\tMT ASE", stdout
);
17519 if (mask
& AFL_ASE_SMARTMIPS
)
17520 fputs ("\n\tSmartMIPS ASE", stdout
);
17521 if (mask
& AFL_ASE_VIRT
)
17522 fputs ("\n\tVZ ASE", stdout
);
17523 if (mask
& AFL_ASE_MSA
)
17524 fputs ("\n\tMSA ASE", stdout
);
17525 if (mask
& AFL_ASE_MIPS16
)
17526 fputs ("\n\tMIPS16 ASE", stdout
);
17527 if (mask
& AFL_ASE_MICROMIPS
)
17528 fputs ("\n\tMICROMIPS ASE", stdout
);
17529 if (mask
& AFL_ASE_XPA
)
17530 fputs ("\n\tXPA ASE", stdout
);
17531 if (mask
& AFL_ASE_MIPS16E2
)
17532 fputs ("\n\tMIPS16e2 ASE", stdout
);
17533 if (mask
& AFL_ASE_CRC
)
17534 fputs ("\n\tCRC ASE", stdout
);
17535 if (mask
& AFL_ASE_GINV
)
17536 fputs ("\n\tGINV ASE", stdout
);
17537 if (mask
& AFL_ASE_LOONGSON_MMI
)
17538 fputs ("\n\tLoongson MMI ASE", stdout
);
17539 if (mask
& AFL_ASE_LOONGSON_CAM
)
17540 fputs ("\n\tLoongson CAM ASE", stdout
);
17541 if (mask
& AFL_ASE_LOONGSON_EXT
)
17542 fputs ("\n\tLoongson EXT ASE", stdout
);
17543 if (mask
& AFL_ASE_LOONGSON_EXT2
)
17544 fputs ("\n\tLoongson EXT2 ASE", stdout
);
17546 fprintf (stdout
, "\n\t%s", _("None"));
17547 else if ((mask
& ~AFL_ASE_MASK
) != 0)
17548 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
17552 print_mips_isa_ext (unsigned int isa_ext
)
17557 fputs (_("None"), stdout
);
17560 fputs ("RMI XLR", stdout
);
17562 case AFL_EXT_OCTEON3
:
17563 fputs ("Cavium Networks Octeon3", stdout
);
17565 case AFL_EXT_OCTEON2
:
17566 fputs ("Cavium Networks Octeon2", stdout
);
17568 case AFL_EXT_OCTEONP
:
17569 fputs ("Cavium Networks OcteonP", stdout
);
17571 case AFL_EXT_OCTEON
:
17572 fputs ("Cavium Networks Octeon", stdout
);
17575 fputs ("Toshiba R5900", stdout
);
17578 fputs ("MIPS R4650", stdout
);
17581 fputs ("LSI R4010", stdout
);
17584 fputs ("NEC VR4100", stdout
);
17587 fputs ("Toshiba R3900", stdout
);
17589 case AFL_EXT_10000
:
17590 fputs ("MIPS R10000", stdout
);
17593 fputs ("Broadcom SB-1", stdout
);
17596 fputs ("NEC VR4111/VR4181", stdout
);
17599 fputs ("NEC VR4120", stdout
);
17602 fputs ("NEC VR5400", stdout
);
17605 fputs ("NEC VR5500", stdout
);
17607 case AFL_EXT_LOONGSON_2E
:
17608 fputs ("ST Microelectronics Loongson 2E", stdout
);
17610 case AFL_EXT_LOONGSON_2F
:
17611 fputs ("ST Microelectronics Loongson 2F", stdout
);
17613 case AFL_EXT_INTERAPTIV_MR2
:
17614 fputs ("Imagination interAptiv MR2", stdout
);
17617 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
17622 get_mips_reg_size (int reg_size
)
17624 return (reg_size
== AFL_REG_NONE
) ? 0
17625 : (reg_size
== AFL_REG_32
) ? 32
17626 : (reg_size
== AFL_REG_64
) ? 64
17627 : (reg_size
== AFL_REG_128
) ? 128
17632 process_mips_specific (Filedata
* filedata
)
17634 Elf_Internal_Dyn
* entry
;
17635 Elf_Internal_Shdr
*sect
= NULL
;
17636 size_t liblist_offset
= 0;
17637 size_t liblistno
= 0;
17638 size_t conflictsno
= 0;
17639 size_t options_offset
= 0;
17640 size_t conflicts_offset
= 0;
17641 size_t pltrelsz
= 0;
17643 bfd_vma pltgot
= 0;
17644 bfd_vma mips_pltgot
= 0;
17645 bfd_vma jmprel
= 0;
17646 bfd_vma local_gotno
= 0;
17647 bfd_vma gotsym
= 0;
17648 bfd_vma symtabno
= 0;
17651 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17652 display_mips_gnu_attribute
))
17655 sect
= find_section (filedata
, ".MIPS.abiflags");
17659 Elf_External_ABIFlags_v0
*abiflags_ext
;
17660 Elf_Internal_ABIFlags_v0 abiflags_in
;
17662 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
17664 error (_("Corrupt MIPS ABI Flags section.\n"));
17669 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17670 sect
->sh_size
, _("MIPS ABI Flags section"));
17673 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
17674 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
17675 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
17676 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
17677 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
17678 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
17679 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
17680 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
17681 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
17682 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
17683 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
17685 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
17686 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
17687 if (abiflags_in
.isa_rev
> 1)
17688 printf ("r%d", abiflags_in
.isa_rev
);
17689 printf ("\nGPR size: %d",
17690 get_mips_reg_size (abiflags_in
.gpr_size
));
17691 printf ("\nCPR1 size: %d",
17692 get_mips_reg_size (abiflags_in
.cpr1_size
));
17693 printf ("\nCPR2 size: %d",
17694 get_mips_reg_size (abiflags_in
.cpr2_size
));
17695 fputs ("\nFP ABI: ", stdout
);
17696 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
17697 fputs ("ISA Extension: ", stdout
);
17698 print_mips_isa_ext (abiflags_in
.isa_ext
);
17699 fputs ("\nASEs:", stdout
);
17700 print_mips_ases (abiflags_in
.ases
);
17701 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
17702 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
17703 fputc ('\n', stdout
);
17704 free (abiflags_ext
);
17709 /* We have a lot of special sections. Thanks SGI! */
17710 if (filedata
->dynamic_section
== NULL
)
17712 /* No dynamic information available. See if there is static GOT. */
17713 sect
= find_section (filedata
, ".got");
17716 unsigned char *data_end
;
17717 unsigned char *data
;
17721 pltgot
= sect
->sh_addr
;
17724 addr_size
= (is_32bit_elf
? 4 : 8);
17725 end
= pltgot
+ sect
->sh_size
;
17727 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
17729 _("Global Offset Table data"));
17730 /* PR 12855: Null data is handled gracefully throughout. */
17731 data_end
= data
+ (end
- pltgot
);
17733 printf (_("\nStatic GOT:\n"));
17734 printf (_(" Canonical gp value: "));
17735 print_vma (ent
+ 0x7ff0, LONG_HEX
);
17738 /* In a dynamic binary GOT[0] is reserved for the dynamic
17739 loader to store the lazy resolver pointer, however in
17740 a static binary it may well have been omitted and GOT
17741 reduced to a table of addresses.
17742 PR 21344: Check for the entry being fully available
17743 before fetching it. */
17745 && data
+ ent
- pltgot
+ addr_size
<= data_end
17746 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
17748 printf (_(" Reserved entries:\n"));
17749 printf (_(" %*s %10s %*s\n"),
17750 addr_size
* 2, _("Address"), _("Access"),
17751 addr_size
* 2, _("Value"));
17752 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17754 if (ent
== (bfd_vma
) -1)
17755 goto sgot_print_fail
;
17757 /* Check for the MSB of GOT[1] being set, identifying a
17758 GNU object. This entry will be used by some runtime
17759 loaders, to store the module pointer. Otherwise this
17760 is an ordinary local entry.
17761 PR 21344: Check for the entry being fully available
17762 before fetching it. */
17764 && data
+ ent
- pltgot
+ addr_size
<= data_end
17765 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17766 >> (addr_size
* 8 - 1)) != 0)
17768 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17770 if (ent
== (bfd_vma
) -1)
17771 goto sgot_print_fail
;
17776 if (data
!= NULL
&& ent
< end
)
17778 printf (_(" Local entries:\n"));
17779 printf (" %*s %10s %*s\n",
17780 addr_size
* 2, _("Address"), _("Access"),
17781 addr_size
* 2, _("Value"));
17784 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17786 if (ent
== (bfd_vma
) -1)
17787 goto sgot_print_fail
;
17798 for (entry
= filedata
->dynamic_section
;
17799 /* PR 17531 file: 012-50589-0.004. */
17800 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
17801 && entry
->d_tag
!= DT_NULL
);
17803 switch (entry
->d_tag
)
17805 case DT_MIPS_LIBLIST
:
17807 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
17808 liblistno
* sizeof (Elf32_External_Lib
));
17810 case DT_MIPS_LIBLISTNO
:
17811 liblistno
= entry
->d_un
.d_val
;
17813 case DT_MIPS_OPTIONS
:
17814 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
17816 case DT_MIPS_CONFLICT
:
17818 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
17819 conflictsno
* sizeof (Elf32_External_Conflict
));
17821 case DT_MIPS_CONFLICTNO
:
17822 conflictsno
= entry
->d_un
.d_val
;
17825 pltgot
= entry
->d_un
.d_ptr
;
17827 case DT_MIPS_LOCAL_GOTNO
:
17828 local_gotno
= entry
->d_un
.d_val
;
17830 case DT_MIPS_GOTSYM
:
17831 gotsym
= entry
->d_un
.d_val
;
17833 case DT_MIPS_SYMTABNO
:
17834 symtabno
= entry
->d_un
.d_val
;
17836 case DT_MIPS_PLTGOT
:
17837 mips_pltgot
= entry
->d_un
.d_ptr
;
17840 pltrel
= entry
->d_un
.d_val
;
17843 pltrelsz
= entry
->d_un
.d_val
;
17846 jmprel
= entry
->d_un
.d_ptr
;
17852 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
17854 Elf32_External_Lib
* elib
;
17857 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
17858 sizeof (Elf32_External_Lib
),
17860 _("liblist section data"));
17863 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
17864 "\nSection '.liblist' contains %lu entries:\n",
17865 (unsigned long) liblistno
),
17866 (unsigned long) liblistno
);
17867 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
17870 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
17877 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17878 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17879 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17880 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17881 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17883 tmp
= gmtime (&atime
);
17884 snprintf (timebuf
, sizeof (timebuf
),
17885 "%04u-%02u-%02uT%02u:%02u:%02u",
17886 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17887 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17889 printf ("%3lu: ", (unsigned long) cnt
);
17890 if (VALID_DYNAMIC_NAME (filedata
, liblist
.l_name
))
17891 print_symbol (20, GET_DYNAMIC_NAME (filedata
, liblist
.l_name
));
17893 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
17894 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
17895 liblist
.l_version
);
17897 if (liblist
.l_flags
== 0)
17901 static const struct
17908 { " EXACT_MATCH", LL_EXACT_MATCH
},
17909 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
17910 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
17911 { " EXPORTS", LL_EXPORTS
},
17912 { " DELAY_LOAD", LL_DELAY_LOAD
},
17913 { " DELTA", LL_DELTA
}
17915 int flags
= liblist
.l_flags
;
17918 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
17919 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
17921 fputs (l_flags_vals
[fcnt
].name
, stdout
);
17922 flags
^= l_flags_vals
[fcnt
].bit
;
17925 printf (" %#x", (unsigned int) flags
);
17937 if (options_offset
!= 0)
17939 Elf_External_Options
* eopt
;
17942 sect
= filedata
->section_headers
;
17944 /* Find the section header so that we get the size. */
17945 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
17946 /* PR 17533 file: 012-277276-0.004. */
17949 error (_("No MIPS_OPTIONS header found\n"));
17953 if (sect
->sh_size
< sizeof (* eopt
))
17955 error (_("The MIPS options section is too small.\n"));
17959 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
17960 sect
->sh_size
, _("options"));
17963 Elf_Internal_Options option
;
17966 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
17968 Elf_External_Options
* eoption
;
17969 unsigned int optsize
;
17971 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
17973 optsize
= BYTE_GET (eoption
->size
);
17975 /* PR 17531: file: ffa0fa3b. */
17976 if (optsize
< sizeof (* eopt
)
17977 || optsize
> sect
->sh_size
- offset
)
17979 error (_("Invalid size (%u) for MIPS option\n"),
17988 printf (ngettext ("\nSection '%s' contains %d entry:\n",
17989 "\nSection '%s' contains %d entries:\n",
17991 printable_section_name (filedata
, sect
), cnt
);
17997 Elf_External_Options
* eoption
;
17999 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
18001 option
.kind
= BYTE_GET (eoption
->kind
);
18002 option
.size
= BYTE_GET (eoption
->size
);
18003 option
.section
= BYTE_GET (eoption
->section
);
18004 option
.info
= BYTE_GET (eoption
->info
);
18006 switch (option
.kind
)
18009 /* This shouldn't happen. */
18010 printf (" NULL %" PRId16
" %" PRIx32
,
18011 option
.section
, option
.info
);
18015 printf (" REGINFO ");
18016 if (filedata
->file_header
.e_machine
== EM_MIPS
)
18018 Elf32_External_RegInfo
* ereg
;
18019 Elf32_RegInfo reginfo
;
18022 if (option
.size
< (sizeof (Elf_External_Options
)
18023 + sizeof (Elf32_External_RegInfo
)))
18025 printf (_("<corrupt>\n"));
18026 error (_("Truncated MIPS REGINFO option\n"));
18031 ereg
= (Elf32_External_RegInfo
*) (eoption
+ 1);
18033 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
18034 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
18035 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
18036 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
18037 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
18038 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
18040 printf ("GPR %08" PRIx32
" GP 0x%" PRIx32
"\n",
18041 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
18043 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
18044 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
18045 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
18046 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
18051 Elf64_External_RegInfo
* ereg
;
18052 Elf64_Internal_RegInfo reginfo
;
18054 if (option
.size
< (sizeof (Elf_External_Options
)
18055 + sizeof (Elf64_External_RegInfo
)))
18057 printf (_("<corrupt>\n"));
18058 error (_("Truncated MIPS REGINFO option\n"));
18063 ereg
= (Elf64_External_RegInfo
*) (eoption
+ 1);
18064 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
18065 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
18066 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
18067 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
18068 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
18069 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
18071 printf ("GPR %08" PRIx32
" GP 0x%" PRIx64
"\n",
18072 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
18074 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
18075 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
18076 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
18077 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
18079 offset
+= option
.size
;
18082 case ODK_EXCEPTIONS
:
18083 fputs (" EXCEPTIONS fpe_min(", stdout
);
18084 process_mips_fpe_exception (option
.info
& OEX_FPU_MIN
);
18085 fputs (") fpe_max(", stdout
);
18086 process_mips_fpe_exception ((option
.info
& OEX_FPU_MAX
) >> 8);
18087 fputs (")", stdout
);
18089 if (option
.info
& OEX_PAGE0
)
18090 fputs (" PAGE0", stdout
);
18091 if (option
.info
& OEX_SMM
)
18092 fputs (" SMM", stdout
);
18093 if (option
.info
& OEX_FPDBUG
)
18094 fputs (" FPDBUG", stdout
);
18095 if (option
.info
& OEX_DISMISS
)
18096 fputs (" DISMISS", stdout
);
18100 fputs (" PAD ", stdout
);
18101 if (option
.info
& OPAD_PREFIX
)
18102 fputs (" PREFIX", stdout
);
18103 if (option
.info
& OPAD_POSTFIX
)
18104 fputs (" POSTFIX", stdout
);
18105 if (option
.info
& OPAD_SYMBOL
)
18106 fputs (" SYMBOL", stdout
);
18110 fputs (" HWPATCH ", stdout
);
18111 if (option
.info
& OHW_R4KEOP
)
18112 fputs (" R4KEOP", stdout
);
18113 if (option
.info
& OHW_R8KPFETCH
)
18114 fputs (" R8KPFETCH", stdout
);
18115 if (option
.info
& OHW_R5KEOP
)
18116 fputs (" R5KEOP", stdout
);
18117 if (option
.info
& OHW_R5KCVTL
)
18118 fputs (" R5KCVTL", stdout
);
18122 fputs (" FILL ", stdout
);
18123 /* XXX Print content of info word? */
18127 fputs (" TAGS ", stdout
);
18128 /* XXX Print content of info word? */
18132 fputs (" HWAND ", stdout
);
18133 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
18134 fputs (" R4KEOP_CHECKED", stdout
);
18135 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
18136 fputs (" R4KEOP_CLEAN", stdout
);
18140 fputs (" HWOR ", stdout
);
18141 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
18142 fputs (" R4KEOP_CHECKED", stdout
);
18143 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
18144 fputs (" R4KEOP_CLEAN", stdout
);
18148 printf (" GP_GROUP %#06x self-contained %#06x",
18149 option
.info
& OGP_GROUP
,
18150 (option
.info
& OGP_SELF
) >> 16);
18154 printf (" IDENT %#06x self-contained %#06x",
18155 option
.info
& OGP_GROUP
,
18156 (option
.info
& OGP_SELF
) >> 16);
18160 /* This shouldn't happen. */
18161 printf (" %3d ??? %" PRId16
" %" PRIx32
,
18162 option
.kind
, option
.section
, option
.info
);
18166 len
= sizeof (* eopt
);
18167 while (len
< option
.size
)
18169 unsigned char datum
= *((unsigned char *) eoption
+ len
);
18171 if (ISPRINT (datum
))
18172 printf ("%c", datum
);
18174 printf ("\\%03o", datum
);
18177 fputs ("\n", stdout
);
18179 offset
+= option
.size
;
18187 if (conflicts_offset
!= 0 && conflictsno
!= 0)
18189 Elf32_Conflict
* iconf
;
18192 if (filedata
->dynamic_symbols
== NULL
)
18194 error (_("conflict list found without a dynamic symbol table\n"));
18198 /* PR 21345 - print a slightly more helpful error message
18199 if we are sure that the cmalloc will fail. */
18200 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
18202 error (_("Overlarge number of conflicts detected: %lx\n"),
18203 (long) conflictsno
);
18207 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
18210 error (_("Out of memory allocating space for dynamic conflicts\n"));
18216 Elf32_External_Conflict
* econf32
;
18218 econf32
= (Elf32_External_Conflict
*)
18219 get_data (NULL
, filedata
, conflicts_offset
,
18220 sizeof (*econf32
), conflictsno
, _("conflict"));
18227 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18228 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
18234 Elf64_External_Conflict
* econf64
;
18236 econf64
= (Elf64_External_Conflict
*)
18237 get_data (NULL
, filedata
, conflicts_offset
,
18238 sizeof (*econf64
), conflictsno
, _("conflict"));
18245 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18246 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
18251 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
18252 "\nSection '.conflict' contains %lu entries:\n",
18253 (unsigned long) conflictsno
),
18254 (unsigned long) conflictsno
);
18255 puts (_(" Num: Index Value Name"));
18257 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18259 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
18261 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
18262 printf (_("<corrupt symbol index>"));
18265 Elf_Internal_Sym
* psym
;
18267 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
18268 print_vma (psym
->st_value
, FULL_HEX
);
18270 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
18271 print_symbol (25, GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
18273 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18281 if (pltgot
!= 0 && local_gotno
!= 0)
18283 bfd_vma ent
, local_end
, global_end
;
18285 unsigned char * data
;
18286 unsigned char * data_end
;
18290 addr_size
= (is_32bit_elf
? 4 : 8);
18291 local_end
= pltgot
+ local_gotno
* addr_size
;
18293 /* PR binutils/17533 file: 012-111227-0.004 */
18294 if (symtabno
< gotsym
)
18296 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
18297 (unsigned long) gotsym
, (unsigned long) symtabno
);
18301 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
18302 /* PR 17531: file: 54c91a34. */
18303 if (global_end
< local_end
)
18305 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
18309 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
18310 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
18311 global_end
- pltgot
, 1,
18312 _("Global Offset Table data"));
18313 /* PR 12855: Null data is handled gracefully throughout. */
18314 data_end
= data
+ (global_end
- pltgot
);
18316 printf (_("\nPrimary GOT:\n"));
18317 printf (_(" Canonical gp value: "));
18318 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
18321 printf (_(" Reserved entries:\n"));
18322 printf (_(" %*s %10s %*s Purpose\n"),
18323 addr_size
* 2, _("Address"), _("Access"),
18324 addr_size
* 2, _("Initial"));
18325 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18326 printf (_(" Lazy resolver\n"));
18327 if (ent
== (bfd_vma
) -1)
18328 goto got_print_fail
;
18330 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
18331 This entry will be used by some runtime loaders, to store the
18332 module pointer. Otherwise this is an ordinary local entry.
18333 PR 21344: Check for the entry being fully available before
18336 && data
+ ent
- pltgot
+ addr_size
<= data_end
18337 && (byte_get (data
+ ent
- pltgot
, addr_size
)
18338 >> (addr_size
* 8 - 1)) != 0)
18340 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18341 printf (_(" Module pointer (GNU extension)\n"));
18342 if (ent
== (bfd_vma
) -1)
18343 goto got_print_fail
;
18347 if (data
!= NULL
&& ent
< local_end
)
18349 printf (_(" Local entries:\n"));
18350 printf (" %*s %10s %*s\n",
18351 addr_size
* 2, _("Address"), _("Access"),
18352 addr_size
* 2, _("Initial"));
18353 while (ent
< local_end
)
18355 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18357 if (ent
== (bfd_vma
) -1)
18358 goto got_print_fail
;
18363 if (data
!= NULL
&& gotsym
< symtabno
)
18367 printf (_(" Global entries:\n"));
18368 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
18369 addr_size
* 2, _("Address"),
18371 addr_size
* 2, _("Initial"),
18372 addr_size
* 2, _("Sym.Val."),
18374 /* Note for translators: "Ndx" = abbreviated form of "Index". */
18375 _("Ndx"), _("Name"));
18377 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
18379 for (i
= gotsym
; i
< symtabno
; i
++)
18381 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18384 if (filedata
->dynamic_symbols
== NULL
)
18385 printf (_("<no dynamic symbols>"));
18386 else if (i
< filedata
->num_dynamic_syms
)
18388 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
18390 print_vma (psym
->st_value
, LONG_HEX
);
18391 printf (" %-7s %3s ",
18392 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
18393 get_symbol_index_type (filedata
, psym
->st_shndx
));
18395 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
18396 print_symbol (sym_width
,
18397 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
18399 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18402 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
18403 (unsigned long) i
);
18406 if (ent
== (bfd_vma
) -1)
18416 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
18419 size_t offset
, rel_offset
;
18420 unsigned long count
, i
;
18421 unsigned char * data
;
18422 int addr_size
, sym_width
;
18423 Elf_Internal_Rela
* rels
;
18425 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
18426 if (pltrel
== DT_RELA
)
18428 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
18433 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
18438 addr_size
= (is_32bit_elf
? 4 : 8);
18439 end
= mips_pltgot
+ (2 + count
) * addr_size
;
18441 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
18442 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
18443 1, _("Procedure Linkage Table data"));
18450 printf ("\nPLT GOT:\n\n");
18451 printf (_(" Reserved entries:\n"));
18452 printf (_(" %*s %*s Purpose\n"),
18453 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
18454 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18455 printf (_(" PLT lazy resolver\n"));
18456 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18457 printf (_(" Module pointer\n"));
18460 printf (_(" Entries:\n"));
18461 printf (" %*s %*s %*s %-7s %3s %s\n",
18462 addr_size
* 2, _("Address"),
18463 addr_size
* 2, _("Initial"),
18464 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
18465 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
18466 for (i
= 0; i
< count
; i
++)
18468 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
18470 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18473 if (idx
>= filedata
->num_dynamic_syms
)
18474 printf (_("<corrupt symbol index: %lu>"), idx
);
18477 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
18479 print_vma (psym
->st_value
, LONG_HEX
);
18480 printf (" %-7s %3s ",
18481 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
18482 get_symbol_index_type (filedata
, psym
->st_shndx
));
18483 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
18484 print_symbol (sym_width
,
18485 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
18487 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18501 process_nds32_specific (Filedata
* filedata
)
18503 Elf_Internal_Shdr
*sect
= NULL
;
18505 sect
= find_section (filedata
, ".nds32_e_flags");
18506 if (sect
!= NULL
&& sect
->sh_size
>= 4)
18508 unsigned char *buf
;
18511 printf ("\nNDS32 elf flags section:\n");
18512 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
18513 _("NDS32 elf flags section"));
18518 flag
= byte_get (buf
, 4);
18520 switch (flag
& 0x3)
18523 printf ("(VEC_SIZE):\tNo entry.\n");
18526 printf ("(VEC_SIZE):\t4 bytes\n");
18529 printf ("(VEC_SIZE):\t16 bytes\n");
18532 printf ("(VEC_SIZE):\treserved\n");
18541 process_gnu_liblist (Filedata
* filedata
)
18543 Elf_Internal_Shdr
* section
;
18544 Elf_Internal_Shdr
* string_sec
;
18545 Elf32_External_Lib
* elib
;
18547 size_t strtab_size
;
18549 unsigned long num_liblist
;
18556 for (i
= 0, section
= filedata
->section_headers
;
18557 i
< filedata
->file_header
.e_shnum
;
18560 switch (section
->sh_type
)
18562 case SHT_GNU_LIBLIST
:
18563 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
18566 elib
= (Elf32_External_Lib
*)
18567 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
18568 _("liblist section data"));
18576 string_sec
= filedata
->section_headers
+ section
->sh_link
;
18577 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
18578 string_sec
->sh_size
,
18579 _("liblist string table"));
18581 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
18588 strtab_size
= string_sec
->sh_size
;
18590 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
18591 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
18592 "\nLibrary list section '%s' contains %lu entries:\n",
18594 printable_section_name (filedata
, section
),
18597 puts (_(" Library Time Stamp Checksum Version Flags"));
18599 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
18607 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
18608 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
18609 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
18610 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
18611 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
18613 tmp
= gmtime (&atime
);
18614 snprintf (timebuf
, sizeof (timebuf
),
18615 "%04u-%02u-%02uT%02u:%02u:%02u",
18616 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
18617 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
18619 printf ("%3lu: ", (unsigned long) cnt
);
18621 printf ("%-20s", liblist
.l_name
< strtab_size
18622 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
18624 printf ("%-20.20s", liblist
.l_name
< strtab_size
18625 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
18626 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
18627 liblist
.l_version
, liblist
.l_flags
);
18638 static const char *
18639 get_note_type (Filedata
* filedata
, unsigned e_type
)
18641 static char buff
[64];
18643 if (filedata
->file_header
.e_type
== ET_CORE
)
18647 return _("NT_AUXV (auxiliary vector)");
18649 return _("NT_PRSTATUS (prstatus structure)");
18651 return _("NT_FPREGSET (floating point registers)");
18653 return _("NT_PRPSINFO (prpsinfo structure)");
18654 case NT_TASKSTRUCT
:
18655 return _("NT_TASKSTRUCT (task structure)");
18657 return _("NT_GDB_TDESC (GDB XML target description)");
18659 return _("NT_PRXFPREG (user_xfpregs structure)");
18661 return _("NT_PPC_VMX (ppc Altivec registers)");
18663 return _("NT_PPC_VSX (ppc VSX registers)");
18665 return _("NT_PPC_TAR (ppc TAR register)");
18667 return _("NT_PPC_PPR (ppc PPR register)");
18669 return _("NT_PPC_DSCR (ppc DSCR register)");
18671 return _("NT_PPC_EBB (ppc EBB registers)");
18673 return _("NT_PPC_PMU (ppc PMU registers)");
18674 case NT_PPC_TM_CGPR
:
18675 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
18676 case NT_PPC_TM_CFPR
:
18677 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
18678 case NT_PPC_TM_CVMX
:
18679 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
18680 case NT_PPC_TM_CVSX
:
18681 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
18682 case NT_PPC_TM_SPR
:
18683 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
18684 case NT_PPC_TM_CTAR
:
18685 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
18686 case NT_PPC_TM_CPPR
:
18687 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
18688 case NT_PPC_TM_CDSCR
:
18689 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
18691 return _("NT_386_TLS (x86 TLS information)");
18692 case NT_386_IOPERM
:
18693 return _("NT_386_IOPERM (x86 I/O permissions)");
18694 case NT_X86_XSTATE
:
18695 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
18697 return _("NT_X86_CET (x86 CET state)");
18698 case NT_S390_HIGH_GPRS
:
18699 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
18700 case NT_S390_TIMER
:
18701 return _("NT_S390_TIMER (s390 timer register)");
18702 case NT_S390_TODCMP
:
18703 return _("NT_S390_TODCMP (s390 TOD comparator register)");
18704 case NT_S390_TODPREG
:
18705 return _("NT_S390_TODPREG (s390 TOD programmable register)");
18707 return _("NT_S390_CTRS (s390 control registers)");
18708 case NT_S390_PREFIX
:
18709 return _("NT_S390_PREFIX (s390 prefix register)");
18710 case NT_S390_LAST_BREAK
:
18711 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
18712 case NT_S390_SYSTEM_CALL
:
18713 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
18715 return _("NT_S390_TDB (s390 transaction diagnostic block)");
18716 case NT_S390_VXRS_LOW
:
18717 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
18718 case NT_S390_VXRS_HIGH
:
18719 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
18720 case NT_S390_GS_CB
:
18721 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
18722 case NT_S390_GS_BC
:
18723 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
18725 return _("NT_ARM_VFP (arm VFP registers)");
18727 return _("NT_ARM_TLS (AArch TLS registers)");
18728 case NT_ARM_HW_BREAK
:
18729 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
18730 case NT_ARM_HW_WATCH
:
18731 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
18733 return _("NT_ARM_SVE (AArch SVE registers)");
18734 case NT_ARM_PAC_MASK
:
18735 return _("NT_ARM_PAC_MASK (AArch pointer authentication code masks)");
18736 case NT_ARM_TAGGED_ADDR_CTRL
:
18737 return _("NT_ARM_TAGGED_ADDR_CTRL (AArch tagged address control)");
18739 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
18741 return _("NT_RISCV_CSR (RISC-V control and status registers)");
18743 return _("NT_PSTATUS (pstatus structure)");
18745 return _("NT_FPREGS (floating point registers)");
18747 return _("NT_PSINFO (psinfo structure)");
18749 return _("NT_LWPSTATUS (lwpstatus_t structure)");
18751 return _("NT_LWPSINFO (lwpsinfo_t structure)");
18752 case NT_WIN32PSTATUS
:
18753 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
18755 return _("NT_SIGINFO (siginfo_t data)");
18757 return _("NT_FILE (mapped files)");
18759 return _("NT_MEMTAG (memory tags)");
18767 return _("NT_VERSION (version)");
18769 return _("NT_ARCH (architecture)");
18770 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
18772 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
18778 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18783 print_core_note (Elf_Internal_Note
*pnote
)
18785 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
18786 bfd_vma count
, page_size
;
18787 unsigned char *descdata
, *filenames
, *descend
;
18789 if (pnote
->type
!= NT_FILE
)
18799 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
18800 /* Still "successful". */
18805 if (pnote
->descsz
< 2 * addr_size
)
18807 error (_(" Malformed note - too short for header\n"));
18811 descdata
= (unsigned char *) pnote
->descdata
;
18812 descend
= descdata
+ pnote
->descsz
;
18814 if (descdata
[pnote
->descsz
- 1] != '\0')
18816 error (_(" Malformed note - does not end with \\0\n"));
18820 count
= byte_get (descdata
, addr_size
);
18821 descdata
+= addr_size
;
18823 page_size
= byte_get (descdata
, addr_size
);
18824 descdata
+= addr_size
;
18826 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
18827 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
18829 error (_(" Malformed note - too short for supplied file count\n"));
18833 printf (_(" Page size: "));
18834 print_vma (page_size
, DEC
);
18837 printf (_(" %*s%*s%*s\n"),
18838 (int) (2 + 2 * addr_size
), _("Start"),
18839 (int) (4 + 2 * addr_size
), _("End"),
18840 (int) (4 + 2 * addr_size
), _("Page Offset"));
18841 filenames
= descdata
+ count
* 3 * addr_size
;
18842 while (count
-- > 0)
18844 bfd_vma start
, end
, file_ofs
;
18846 if (filenames
== descend
)
18848 error (_(" Malformed note - filenames end too early\n"));
18852 start
= byte_get (descdata
, addr_size
);
18853 descdata
+= addr_size
;
18854 end
= byte_get (descdata
, addr_size
);
18855 descdata
+= addr_size
;
18856 file_ofs
= byte_get (descdata
, addr_size
);
18857 descdata
+= addr_size
;
18860 print_vma (start
, FULL_HEX
);
18862 print_vma (end
, FULL_HEX
);
18864 print_vma (file_ofs
, FULL_HEX
);
18865 printf ("\n %s\n", filenames
);
18867 filenames
+= 1 + strlen ((char *) filenames
);
18873 static const char *
18874 get_gnu_elf_note_type (unsigned e_type
)
18876 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
18879 case NT_GNU_ABI_TAG
:
18880 return _("NT_GNU_ABI_TAG (ABI version tag)");
18882 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
18883 case NT_GNU_BUILD_ID
:
18884 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
18885 case NT_GNU_GOLD_VERSION
:
18886 return _("NT_GNU_GOLD_VERSION (gold version)");
18887 case NT_GNU_PROPERTY_TYPE_0
:
18888 return _("NT_GNU_PROPERTY_TYPE_0");
18889 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
18890 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
18891 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
18892 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
18895 static char buff
[64];
18897 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18904 decode_x86_compat_isa (unsigned int bitmask
)
18908 unsigned int bit
= bitmask
& (- bitmask
);
18913 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
18916 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
18919 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
18922 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
18925 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
18928 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
18931 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
18934 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
18937 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
18940 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
18943 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
18946 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
18947 printf ("AVX512F");
18949 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
18950 printf ("AVX512CD");
18952 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
18953 printf ("AVX512ER");
18955 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
18956 printf ("AVX512PF");
18958 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
18959 printf ("AVX512VL");
18961 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
18962 printf ("AVX512DQ");
18964 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
18965 printf ("AVX512BW");
18968 printf (_("<unknown: %x>"), bit
);
18977 decode_x86_compat_2_isa (unsigned int bitmask
)
18981 printf (_("<None>"));
18987 unsigned int bit
= bitmask
& (- bitmask
);
18992 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_CMOV
:
18995 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE
:
18998 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE2
:
19001 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE3
:
19004 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSSE3
:
19007 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_1
:
19010 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_2
:
19013 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX
:
19016 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX2
:
19019 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_FMA
:
19022 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512F
:
19023 printf ("AVX512F");
19025 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512CD
:
19026 printf ("AVX512CD");
19028 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512ER
:
19029 printf ("AVX512ER");
19031 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512PF
:
19032 printf ("AVX512PF");
19034 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512VL
:
19035 printf ("AVX512VL");
19037 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512DQ
:
19038 printf ("AVX512DQ");
19040 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512BW
:
19041 printf ("AVX512BW");
19043 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4FMAPS
:
19044 printf ("AVX512_4FMAPS");
19046 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4VNNIW
:
19047 printf ("AVX512_4VNNIW");
19049 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BITALG
:
19050 printf ("AVX512_BITALG");
19052 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_IFMA
:
19053 printf ("AVX512_IFMA");
19055 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI
:
19056 printf ("AVX512_VBMI");
19058 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI2
:
19059 printf ("AVX512_VBMI2");
19061 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VNNI
:
19062 printf ("AVX512_VNNI");
19064 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BF16
:
19065 printf ("AVX512_BF16");
19068 printf (_("<unknown: %x>"), bit
);
19077 decode_x86_isa (unsigned int bitmask
)
19081 unsigned int bit
= bitmask
& (- bitmask
);
19086 case GNU_PROPERTY_X86_ISA_1_BASELINE
:
19087 printf ("x86-64-baseline");
19089 case GNU_PROPERTY_X86_ISA_1_V2
:
19090 printf ("x86-64-v2");
19092 case GNU_PROPERTY_X86_ISA_1_V3
:
19093 printf ("x86-64-v3");
19095 case GNU_PROPERTY_X86_ISA_1_V4
:
19096 printf ("x86-64-v4");
19099 printf (_("<unknown: %x>"), bit
);
19108 decode_x86_feature_1 (unsigned int bitmask
)
19112 printf (_("<None>"));
19118 unsigned int bit
= bitmask
& (- bitmask
);
19123 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
19126 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
19129 case GNU_PROPERTY_X86_FEATURE_1_LAM_U48
:
19130 printf ("LAM_U48");
19132 case GNU_PROPERTY_X86_FEATURE_1_LAM_U57
:
19133 printf ("LAM_U57");
19136 printf (_("<unknown: %x>"), bit
);
19145 decode_x86_feature_2 (unsigned int bitmask
)
19149 printf (_("<None>"));
19155 unsigned int bit
= bitmask
& (- bitmask
);
19160 case GNU_PROPERTY_X86_FEATURE_2_X86
:
19163 case GNU_PROPERTY_X86_FEATURE_2_X87
:
19166 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
19169 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
19172 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
19175 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
19178 case GNU_PROPERTY_X86_FEATURE_2_TMM
:
19181 case GNU_PROPERTY_X86_FEATURE_2_MASK
:
19184 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
19187 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
19190 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
19191 printf ("XSAVEOPT");
19193 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
19197 printf (_("<unknown: %x>"), bit
);
19206 decode_aarch64_feature_1_and (unsigned int bitmask
)
19210 unsigned int bit
= bitmask
& (- bitmask
);
19215 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
19219 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
19224 printf (_("<unknown: %x>"), bit
);
19233 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
19235 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
19236 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
19237 unsigned int size
= is_32bit_elf
? 4 : 8;
19239 printf (_(" Properties: "));
19241 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
19243 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
19247 while (ptr
< ptr_end
)
19251 unsigned int datasz
;
19253 if ((size_t) (ptr_end
- ptr
) < 8)
19255 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
19259 type
= byte_get (ptr
, 4);
19260 datasz
= byte_get (ptr
+ 4, 4);
19264 if (datasz
> (size_t) (ptr_end
- ptr
))
19266 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
19271 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
19273 if (filedata
->file_header
.e_machine
== EM_X86_64
19274 || filedata
->file_header
.e_machine
== EM_IAMCU
19275 || filedata
->file_header
.e_machine
== EM_386
)
19277 unsigned int bitmask
;
19280 bitmask
= byte_get (ptr
, 4);
19286 case GNU_PROPERTY_X86_ISA_1_USED
:
19288 printf (_("x86 ISA used: <corrupt length: %#x> "),
19292 printf ("x86 ISA used: ");
19293 decode_x86_isa (bitmask
);
19297 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
19299 printf (_("x86 ISA needed: <corrupt length: %#x> "),
19303 printf ("x86 ISA needed: ");
19304 decode_x86_isa (bitmask
);
19308 case GNU_PROPERTY_X86_FEATURE_1_AND
:
19310 printf (_("x86 feature: <corrupt length: %#x> "),
19314 printf ("x86 feature: ");
19315 decode_x86_feature_1 (bitmask
);
19319 case GNU_PROPERTY_X86_FEATURE_2_USED
:
19321 printf (_("x86 feature used: <corrupt length: %#x> "),
19325 printf ("x86 feature used: ");
19326 decode_x86_feature_2 (bitmask
);
19330 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
19332 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
19335 printf ("x86 feature needed: ");
19336 decode_x86_feature_2 (bitmask
);
19340 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
19342 printf (_("x86 ISA used: <corrupt length: %#x> "),
19346 printf ("x86 ISA used: ");
19347 decode_x86_compat_isa (bitmask
);
19351 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
19353 printf (_("x86 ISA needed: <corrupt length: %#x> "),
19357 printf ("x86 ISA needed: ");
19358 decode_x86_compat_isa (bitmask
);
19362 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_USED
:
19364 printf (_("x86 ISA used: <corrupt length: %#x> "),
19368 printf ("x86 ISA used: ");
19369 decode_x86_compat_2_isa (bitmask
);
19373 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_NEEDED
:
19375 printf (_("x86 ISA needed: <corrupt length: %#x> "),
19379 printf ("x86 ISA needed: ");
19380 decode_x86_compat_2_isa (bitmask
);
19388 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
19390 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
19392 printf ("AArch64 feature: ");
19394 printf (_("<corrupt length: %#x> "), datasz
);
19396 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
19405 case GNU_PROPERTY_STACK_SIZE
:
19406 printf (_("stack size: "));
19407 if (datasz
!= size
)
19408 printf (_("<corrupt length: %#x> "), datasz
);
19410 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
19413 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
19414 printf ("no copy on protected ");
19416 printf (_("<corrupt length: %#x> "), datasz
);
19424 if (type
< GNU_PROPERTY_LOPROC
)
19425 printf (_("<unknown type %#x data: "), type
);
19426 else if (type
< GNU_PROPERTY_LOUSER
)
19427 printf (_("<processor-specific type %#x data: "), type
);
19429 printf (_("<application-specific type %#x data: "), type
);
19430 for (j
= 0; j
< datasz
; ++j
)
19431 printf ("%02x ", ptr
[j
] & 0xff);
19435 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
19436 if (ptr
== ptr_end
)
19449 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
19451 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
19452 switch (pnote
->type
)
19454 case NT_GNU_BUILD_ID
:
19458 printf (_(" Build ID: "));
19459 for (i
= 0; i
< pnote
->descsz
; ++i
)
19460 printf ("%02x", pnote
->descdata
[i
] & 0xff);
19465 case NT_GNU_ABI_TAG
:
19467 unsigned long os
, major
, minor
, subminor
;
19468 const char *osname
;
19470 /* PR 17531: file: 030-599401-0.004. */
19471 if (pnote
->descsz
< 16)
19473 printf (_(" <corrupt GNU_ABI_TAG>\n"));
19477 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19478 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19479 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
19480 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
19484 case GNU_ABI_TAG_LINUX
:
19487 case GNU_ABI_TAG_HURD
:
19490 case GNU_ABI_TAG_SOLARIS
:
19491 osname
= "Solaris";
19493 case GNU_ABI_TAG_FREEBSD
:
19494 osname
= "FreeBSD";
19496 case GNU_ABI_TAG_NETBSD
:
19499 case GNU_ABI_TAG_SYLLABLE
:
19500 osname
= "Syllable";
19502 case GNU_ABI_TAG_NACL
:
19506 osname
= "Unknown";
19510 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
19511 major
, minor
, subminor
);
19515 case NT_GNU_GOLD_VERSION
:
19519 printf (_(" Version: "));
19520 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
19521 printf ("%c", pnote
->descdata
[i
]);
19528 unsigned long num_entries
, mask
;
19530 /* Hardware capabilities information. Word 0 is the number of entries.
19531 Word 1 is a bitmask of enabled entries. The rest of the descriptor
19532 is a series of entries, where each entry is a single byte followed
19533 by a nul terminated string. The byte gives the bit number to test
19534 if enabled in the bitmask. */
19535 printf (_(" Hardware Capabilities: "));
19536 if (pnote
->descsz
< 8)
19538 error (_("<corrupt GNU_HWCAP>\n"));
19541 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19542 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19543 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
19544 /* FIXME: Add code to display the entries... */
19548 case NT_GNU_PROPERTY_TYPE_0
:
19549 print_gnu_property_note (filedata
, pnote
);
19553 /* Handle unrecognised types. An error message should have already been
19554 created by get_gnu_elf_note_type(), so all that we need to do is to
19555 display the data. */
19559 printf (_(" Description data: "));
19560 for (i
= 0; i
< pnote
->descsz
; ++i
)
19561 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19570 static const char *
19571 get_v850_elf_note_type (enum v850_notes n_type
)
19573 static char buff
[64];
19577 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
19578 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
19579 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
19580 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
19581 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
19582 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
19584 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
19590 print_v850_note (Elf_Internal_Note
* pnote
)
19594 if (pnote
->descsz
!= 4)
19597 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
19601 printf (_("not set\n"));
19605 switch (pnote
->type
)
19607 case V850_NOTE_ALIGNMENT
:
19610 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return true;
19611 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return true;
19615 case V850_NOTE_DATA_SIZE
:
19618 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return true;
19619 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return true;
19623 case V850_NOTE_FPU_INFO
:
19626 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return true;
19627 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return true;
19631 case V850_NOTE_MMU_INFO
:
19632 case V850_NOTE_CACHE_INFO
:
19633 case V850_NOTE_SIMD_INFO
:
19634 if (val
== EF_RH850_SIMD
)
19636 printf (_("yes\n"));
19642 /* An 'unknown note type' message will already have been displayed. */
19646 printf (_("unknown value: %x\n"), val
);
19651 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
19653 unsigned int version
;
19655 switch (pnote
->type
)
19657 case NT_NETBSD_IDENT
:
19658 if (pnote
->descsz
< 1)
19660 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
19661 if ((version
/ 10000) % 100)
19662 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
19663 version
, version
/ 100000000, (version
/ 1000000) % 100,
19664 (version
/ 10000) % 100 > 26 ? "Z" : "",
19665 'A' + (version
/ 10000) % 26);
19667 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
19668 version
, version
/ 100000000, (version
/ 1000000) % 100,
19669 (version
/ 100) % 100);
19672 case NT_NETBSD_MARCH
:
19673 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
19677 case NT_NETBSD_PAX
:
19678 if (pnote
->descsz
< 1)
19680 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
19681 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
19682 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
19683 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
19684 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
19685 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
19686 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
19687 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
19691 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
19692 pnote
->descsz
, pnote
->type
);
19696 static const char *
19697 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
19701 case NT_FREEBSD_THRMISC
:
19702 return _("NT_THRMISC (thrmisc structure)");
19703 case NT_FREEBSD_PROCSTAT_PROC
:
19704 return _("NT_PROCSTAT_PROC (proc data)");
19705 case NT_FREEBSD_PROCSTAT_FILES
:
19706 return _("NT_PROCSTAT_FILES (files data)");
19707 case NT_FREEBSD_PROCSTAT_VMMAP
:
19708 return _("NT_PROCSTAT_VMMAP (vmmap data)");
19709 case NT_FREEBSD_PROCSTAT_GROUPS
:
19710 return _("NT_PROCSTAT_GROUPS (groups data)");
19711 case NT_FREEBSD_PROCSTAT_UMASK
:
19712 return _("NT_PROCSTAT_UMASK (umask data)");
19713 case NT_FREEBSD_PROCSTAT_RLIMIT
:
19714 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
19715 case NT_FREEBSD_PROCSTAT_OSREL
:
19716 return _("NT_PROCSTAT_OSREL (osreldate data)");
19717 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
19718 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
19719 case NT_FREEBSD_PROCSTAT_AUXV
:
19720 return _("NT_PROCSTAT_AUXV (auxv data)");
19721 case NT_FREEBSD_PTLWPINFO
:
19722 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
19724 return get_note_type (filedata
, e_type
);
19727 static const char *
19728 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
19730 static char buff
[64];
19734 case NT_NETBSDCORE_PROCINFO
:
19735 /* NetBSD core "procinfo" structure. */
19736 return _("NetBSD procinfo structure");
19738 case NT_NETBSDCORE_AUXV
:
19739 return _("NetBSD ELF auxiliary vector data");
19741 case NT_NETBSDCORE_LWPSTATUS
:
19742 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
19745 /* As of Jan 2020 there are no other machine-independent notes
19746 defined for NetBSD core files. If the note type is less
19747 than the start of the machine-dependent note types, we don't
19750 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
19752 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19758 switch (filedata
->file_header
.e_machine
)
19760 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
19761 and PT_GETFPREGS == mach+2. */
19766 case EM_SPARC32PLUS
:
19770 case NT_NETBSDCORE_FIRSTMACH
+ 0:
19771 return _("PT_GETREGS (reg structure)");
19772 case NT_NETBSDCORE_FIRSTMACH
+ 2:
19773 return _("PT_GETFPREGS (fpreg structure)");
19779 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
19780 There's also old PT___GETREGS40 == mach + 1 for old reg
19781 structure which lacks GBR. */
19785 case NT_NETBSDCORE_FIRSTMACH
+ 1:
19786 return _("PT___GETREGS40 (old reg structure)");
19787 case NT_NETBSDCORE_FIRSTMACH
+ 3:
19788 return _("PT_GETREGS (reg structure)");
19789 case NT_NETBSDCORE_FIRSTMACH
+ 5:
19790 return _("PT_GETFPREGS (fpreg structure)");
19796 /* On all other arch's, PT_GETREGS == mach+1 and
19797 PT_GETFPREGS == mach+3. */
19801 case NT_NETBSDCORE_FIRSTMACH
+ 1:
19802 return _("PT_GETREGS (reg structure)");
19803 case NT_NETBSDCORE_FIRSTMACH
+ 3:
19804 return _("PT_GETFPREGS (fpreg structure)");
19810 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
19811 e_type
- NT_NETBSDCORE_FIRSTMACH
);
19815 static const char *
19816 get_stapsdt_note_type (unsigned e_type
)
19818 static char buff
[64];
19823 return _("NT_STAPSDT (SystemTap probe descriptors)");
19829 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19834 print_stapsdt_note (Elf_Internal_Note
*pnote
)
19836 size_t len
, maxlen
;
19837 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
19838 char *data
= pnote
->descdata
;
19839 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
19840 bfd_vma pc
, base_addr
, semaphore
;
19841 char *provider
, *probe
, *arg_fmt
;
19843 if (pnote
->descsz
< (addr_size
* 3))
19844 goto stapdt_note_too_small
;
19846 pc
= byte_get ((unsigned char *) data
, addr_size
);
19849 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
19852 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
19855 if (data
>= data_end
)
19856 goto stapdt_note_too_small
;
19857 maxlen
= data_end
- data
;
19858 len
= strnlen (data
, maxlen
);
19865 goto stapdt_note_too_small
;
19867 if (data
>= data_end
)
19868 goto stapdt_note_too_small
;
19869 maxlen
= data_end
- data
;
19870 len
= strnlen (data
, maxlen
);
19877 goto stapdt_note_too_small
;
19879 if (data
>= data_end
)
19880 goto stapdt_note_too_small
;
19881 maxlen
= data_end
- data
;
19882 len
= strnlen (data
, maxlen
);
19889 goto stapdt_note_too_small
;
19891 printf (_(" Provider: %s\n"), provider
);
19892 printf (_(" Name: %s\n"), probe
);
19893 printf (_(" Location: "));
19894 print_vma (pc
, FULL_HEX
);
19895 printf (_(", Base: "));
19896 print_vma (base_addr
, FULL_HEX
);
19897 printf (_(", Semaphore: "));
19898 print_vma (semaphore
, FULL_HEX
);
19900 printf (_(" Arguments: %s\n"), arg_fmt
);
19902 return data
== data_end
;
19904 stapdt_note_too_small
:
19905 printf (_(" <corrupt - note is too small>\n"));
19906 error (_("corrupt stapdt note - the data size is too small\n"));
19910 static const char *
19911 get_ia64_vms_note_type (unsigned e_type
)
19913 static char buff
[64];
19918 return _("NT_VMS_MHD (module header)");
19920 return _("NT_VMS_LNM (language name)");
19922 return _("NT_VMS_SRC (source files)");
19924 return "NT_VMS_TITLE";
19926 return _("NT_VMS_EIDC (consistency check)");
19927 case NT_VMS_FPMODE
:
19928 return _("NT_VMS_FPMODE (FP mode)");
19929 case NT_VMS_LINKTIME
:
19930 return "NT_VMS_LINKTIME";
19931 case NT_VMS_IMGNAM
:
19932 return _("NT_VMS_IMGNAM (image name)");
19934 return _("NT_VMS_IMGID (image id)");
19935 case NT_VMS_LINKID
:
19936 return _("NT_VMS_LINKID (link id)");
19937 case NT_VMS_IMGBID
:
19938 return _("NT_VMS_IMGBID (build id)");
19939 case NT_VMS_GSTNAM
:
19940 return _("NT_VMS_GSTNAM (sym table name)");
19941 case NT_VMS_ORIG_DYN
:
19942 return "NT_VMS_ORIG_DYN";
19943 case NT_VMS_PATCHTIME
:
19944 return "NT_VMS_PATCHTIME";
19946 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19952 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
19954 int maxlen
= pnote
->descsz
;
19956 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
19957 goto desc_size_fail
;
19959 switch (pnote
->type
)
19963 goto desc_size_fail
;
19965 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
19967 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
19968 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
19969 if (l
+ 34 < maxlen
)
19971 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
19972 if (l
+ 35 < maxlen
)
19973 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
19975 printf (_(" Module version : <missing>\n"));
19979 printf (_(" Module name : <missing>\n"));
19980 printf (_(" Module version : <missing>\n"));
19985 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
19989 case NT_VMS_FPMODE
:
19990 printf (_(" Floating Point mode: "));
19992 goto desc_size_fail
;
19993 /* FIXME: Generate an error if descsz > 8 ? */
19995 printf ("0x%016" BFD_VMA_FMT
"x\n",
19996 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19999 case NT_VMS_LINKTIME
:
20000 printf (_(" Link time: "));
20002 goto desc_size_fail
;
20003 /* FIXME: Generate an error if descsz > 8 ? */
20006 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
20010 case NT_VMS_PATCHTIME
:
20011 printf (_(" Patch time: "));
20013 goto desc_size_fail
;
20014 /* FIXME: Generate an error if descsz > 8 ? */
20017 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
20021 case NT_VMS_ORIG_DYN
:
20023 goto desc_size_fail
;
20025 printf (_(" Major id: %u, minor id: %u\n"),
20026 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
20027 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
20028 printf (_(" Last modified : "));
20030 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
20031 printf (_("\n Link flags : "));
20032 printf ("0x%016" BFD_VMA_FMT
"x\n",
20033 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
20034 printf (_(" Header flags: 0x%08x\n"),
20035 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
20036 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
20040 case NT_VMS_IMGNAM
:
20041 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
20044 case NT_VMS_GSTNAM
:
20045 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
20049 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
20052 case NT_VMS_LINKID
:
20053 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
20063 printf (_(" <corrupt - data size is too small>\n"));
20064 error (_("corrupt IA64 note: data size is too small\n"));
20068 struct build_attr_cache
{
20069 Filedata
*filedata
;
20071 unsigned long strtablen
;
20072 Elf_Internal_Sym
*symtab
;
20073 unsigned long nsyms
;
20076 /* Find the symbol associated with a build attribute that is attached
20077 to address OFFSET. If PNAME is non-NULL then store the name of
20078 the symbol (if found) in the provided pointer, Returns NULL if a
20079 symbol could not be found. */
20081 static Elf_Internal_Sym
*
20082 get_symbol_for_build_attribute (Filedata
*filedata
,
20083 unsigned long offset
,
20085 const char **pname
)
20087 Elf_Internal_Sym
*saved_sym
= NULL
;
20088 Elf_Internal_Sym
*sym
;
20090 if (filedata
->section_headers
!= NULL
20091 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
20093 Elf_Internal_Shdr
* symsec
;
20095 free (ba_cache
.strtab
);
20096 ba_cache
.strtab
= NULL
;
20097 free (ba_cache
.symtab
);
20098 ba_cache
.symtab
= NULL
;
20100 /* Load the symbol and string sections. */
20101 for (symsec
= filedata
->section_headers
;
20102 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
20105 if (symsec
->sh_type
== SHT_SYMTAB
20106 && get_symtab (filedata
, symsec
,
20107 &ba_cache
.symtab
, &ba_cache
.nsyms
,
20108 &ba_cache
.strtab
, &ba_cache
.strtablen
))
20111 ba_cache
.filedata
= filedata
;
20114 if (ba_cache
.symtab
== NULL
)
20117 /* Find a symbol whose value matches offset. */
20118 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
20119 if (sym
->st_value
== offset
)
20121 if (sym
->st_name
>= ba_cache
.strtablen
)
20122 /* Huh ? This should not happen. */
20125 if (ba_cache
.strtab
[sym
->st_name
] == 0)
20128 /* The AArch64 and ARM architectures define mapping symbols
20129 (eg $d, $x, $t) which we want to ignore. */
20130 if (ba_cache
.strtab
[sym
->st_name
] == '$'
20131 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
20132 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
20137 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
20138 and FILE or OBJECT symbols over NOTYPE symbols. We skip
20139 FUNC symbols entirely. */
20140 switch (ELF_ST_TYPE (sym
->st_info
))
20147 /* If the symbol has a size associated
20148 with it then we can stop searching. */
20149 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
20154 /* Ignore function symbols. */
20161 switch (ELF_ST_BIND (sym
->st_info
))
20164 if (saved_sym
== NULL
20165 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
20170 if (saved_sym
== NULL
)
20180 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
20188 if (saved_sym
&& pname
)
20189 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
20194 /* Returns true iff addr1 and addr2 are in the same section. */
20197 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
20199 Elf_Internal_Shdr
* a1
;
20200 Elf_Internal_Shdr
* a2
;
20202 a1
= find_section_by_address (filedata
, addr1
);
20203 a2
= find_section_by_address (filedata
, addr2
);
20205 return a1
== a2
&& a1
!= NULL
;
20209 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
20210 Filedata
* filedata
)
20212 static unsigned long global_offset
= 0;
20213 static unsigned long global_end
= 0;
20214 static unsigned long func_offset
= 0;
20215 static unsigned long func_end
= 0;
20217 Elf_Internal_Sym
*sym
;
20219 unsigned long start
;
20221 bool is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
20223 switch (pnote
->descsz
)
20226 /* A zero-length description means that the range of
20227 the previous note of the same type should be used. */
20230 if (global_end
> global_offset
)
20231 printf (_(" Applies to region from %#lx to %#lx\n"),
20232 global_offset
, global_end
);
20234 printf (_(" Applies to region from %#lx\n"), global_offset
);
20238 if (func_end
> func_offset
)
20239 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
20241 printf (_(" Applies to region from %#lx\n"), func_offset
);
20246 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20251 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20252 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
20256 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
20257 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
20261 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
20262 printf (_(" <invalid descsz>"));
20267 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
20268 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
20269 in order to avoid them being confused with the start address of the
20270 first function in the file... */
20271 if (sym
== NULL
&& is_open_attr
)
20272 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
20275 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
20276 end
= start
+ sym
->st_size
;
20280 /* FIXME: Need to properly allow for section alignment.
20281 16 is just the alignment used on x86_64. */
20283 && start
> BFD_ALIGN (global_end
, 16)
20284 /* Build notes are not guaranteed to be organised in order of
20285 increasing address, but we should find the all of the notes
20286 for one section in the same place. */
20287 && same_section (filedata
, start
, global_end
))
20288 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
20289 global_end
+ 1, start
- 1);
20291 printf (_(" Applies to region from %#lx"), start
);
20292 global_offset
= start
;
20296 printf (_(" to %#lx"), end
);
20302 printf (_(" Applies to region from %#lx"), start
);
20303 func_offset
= start
;
20307 printf (_(" to %#lx"), end
);
20313 printf (_(" (%s)"), name
);
20320 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
20322 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
20323 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
20324 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
20326 char name_attribute
;
20327 const char * expected_types
;
20328 const char * name
= pnote
->namedata
;
20332 if (name
== NULL
|| pnote
->namesz
< 2)
20334 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
20335 print_symbol (-20, _(" <corrupt name>"));
20344 /* Version 2 of the spec adds a "GA" prefix to the name field. */
20345 if (name
[0] == 'G' && name
[1] == 'A')
20347 if (pnote
->namesz
< 4)
20349 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
20350 print_symbol (-20, _(" <corrupt name>"));
20359 switch ((name_type
= * name
))
20361 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
20362 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
20363 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
20364 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
20365 printf ("%c", * name
);
20369 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
20370 print_symbol (-20, _("<unknown name type>"));
20377 switch ((name_attribute
= * name
))
20379 case GNU_BUILD_ATTRIBUTE_VERSION
:
20380 text
= _("<version>");
20381 expected_types
= string_expected
;
20384 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
20385 text
= _("<stack prot>");
20386 expected_types
= "!+*";
20389 case GNU_BUILD_ATTRIBUTE_RELRO
:
20390 text
= _("<relro>");
20391 expected_types
= bool_expected
;
20394 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
20395 text
= _("<stack size>");
20396 expected_types
= number_expected
;
20399 case GNU_BUILD_ATTRIBUTE_TOOL
:
20400 text
= _("<tool>");
20401 expected_types
= string_expected
;
20404 case GNU_BUILD_ATTRIBUTE_ABI
:
20406 expected_types
= "$*";
20409 case GNU_BUILD_ATTRIBUTE_PIC
:
20411 expected_types
= number_expected
;
20414 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
20415 text
= _("<short enum>");
20416 expected_types
= bool_expected
;
20420 if (ISPRINT (* name
))
20422 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
20424 if (len
> left
&& ! do_wide
)
20426 printf ("%.*s:", len
, name
);
20432 static char tmpbuf
[128];
20434 error (_("unrecognised byte in name field: %d\n"), * name
);
20435 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
20439 expected_types
= "*$!+";
20444 left
-= printf ("%s", text
);
20446 if (strchr (expected_types
, name_type
) == NULL
)
20447 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
20449 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
20451 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
20452 (unsigned long) pnote
->namesz
,
20453 (long) (name
- pnote
->namedata
));
20457 if (left
< 1 && ! do_wide
)
20462 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
20464 unsigned int bytes
;
20465 unsigned long long val
= 0;
20466 unsigned int shift
= 0;
20467 char * decoded
= NULL
;
20469 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
20471 /* The -1 is because the name field is always 0 terminated, and we
20472 want to be able to ensure that the shift in the while loop below
20473 will not overflow. */
20476 if (bytes
> sizeof (val
))
20478 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
20480 bytes
= sizeof (val
);
20482 /* We do not bother to warn if bytes == 0 as this can
20483 happen with some early versions of the gcc plugin. */
20487 unsigned long long byte
= *name
++ & 0xff;
20489 val
|= byte
<< shift
;
20493 switch (name_attribute
)
20495 case GNU_BUILD_ATTRIBUTE_PIC
:
20498 case 0: decoded
= "static"; break;
20499 case 1: decoded
= "pic"; break;
20500 case 2: decoded
= "PIC"; break;
20501 case 3: decoded
= "pie"; break;
20502 case 4: decoded
= "PIE"; break;
20506 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
20509 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
20510 case 0: decoded
= "off"; break;
20511 case 1: decoded
= "on"; break;
20512 case 2: decoded
= "all"; break;
20513 case 3: decoded
= "strong"; break;
20514 case 4: decoded
= "explicit"; break;
20522 if (decoded
!= NULL
)
20524 print_symbol (-left
, decoded
);
20535 left
-= printf ("0x%llx", val
);
20537 left
-= printf ("0x%-.*llx", left
, val
);
20541 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
20542 left
-= print_symbol (- left
, name
);
20544 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
20545 left
-= print_symbol (- left
, "true");
20547 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
20548 left
-= print_symbol (- left
, "false");
20552 if (do_wide
&& left
> 0)
20553 printf ("%-*s", left
, " ");
20558 /* Note that by the ELF standard, the name field is already null byte
20559 terminated, and namesz includes the terminating null byte.
20560 I.E. the value of namesz for the name "FSF" is 4.
20562 If the value of namesz is zero, there is no name present. */
20565 process_note (Elf_Internal_Note
* pnote
,
20566 Filedata
* filedata
)
20568 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
20571 if (pnote
->namesz
== 0)
20572 /* If there is no note name, then use the default set of
20573 note type strings. */
20574 nt
= get_note_type (filedata
, pnote
->type
);
20576 else if (startswith (pnote
->namedata
, "GNU"))
20577 /* GNU-specific object file notes. */
20578 nt
= get_gnu_elf_note_type (pnote
->type
);
20580 else if (startswith (pnote
->namedata
, "FreeBSD"))
20581 /* FreeBSD-specific core file notes. */
20582 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
20584 else if (startswith (pnote
->namedata
, "NetBSD-CORE"))
20585 /* NetBSD-specific core file notes. */
20586 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
20588 else if (startswith (pnote
->namedata
, "NetBSD"))
20589 /* NetBSD-specific core file notes. */
20590 return process_netbsd_elf_note (pnote
);
20592 else if (startswith (pnote
->namedata
, "PaX"))
20593 /* NetBSD-specific core file notes. */
20594 return process_netbsd_elf_note (pnote
);
20596 else if (startswith (pnote
->namedata
, "SPU/"))
20598 /* SPU-specific core file notes. */
20599 nt
= pnote
->namedata
+ 4;
20603 else if (startswith (pnote
->namedata
, "IPF/VMS"))
20604 /* VMS/ia64-specific file notes. */
20605 nt
= get_ia64_vms_note_type (pnote
->type
);
20607 else if (startswith (pnote
->namedata
, "stapsdt"))
20608 nt
= get_stapsdt_note_type (pnote
->type
);
20611 /* Don't recognize this note name; just use the default set of
20612 note type strings. */
20613 nt
= get_note_type (filedata
, pnote
->type
);
20617 if (((startswith (pnote
->namedata
, "GA")
20618 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
20619 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
20620 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
20621 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
20622 print_gnu_build_attribute_name (pnote
);
20624 print_symbol (-20, name
);
20627 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
20629 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
20631 if (startswith (pnote
->namedata
, "IPF/VMS"))
20632 return print_ia64_vms_note (pnote
);
20633 else if (startswith (pnote
->namedata
, "GNU"))
20634 return print_gnu_note (filedata
, pnote
);
20635 else if (startswith (pnote
->namedata
, "stapsdt"))
20636 return print_stapsdt_note (pnote
);
20637 else if (startswith (pnote
->namedata
, "CORE"))
20638 return print_core_note (pnote
);
20639 else if (((startswith (pnote
->namedata
, "GA")
20640 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
20641 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
20642 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
20643 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
20644 return print_gnu_build_attribute_description (pnote
, filedata
);
20650 printf (_(" description data: "));
20651 for (i
= 0; i
< pnote
->descsz
; i
++)
20652 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
20664 process_notes_at (Filedata
* filedata
,
20665 Elf_Internal_Shdr
* section
,
20670 Elf_External_Note
*pnotes
;
20671 Elf_External_Note
*external
;
20680 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
20683 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
20691 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
20694 if (pnotes
== NULL
)
20699 if (filedata
->is_separate
)
20700 printf (_("In linked file '%s': "), filedata
->file_name
);
20704 printf (_("Displaying notes found in: %s\n"), printable_section_name (filedata
, section
));
20706 printf (_("Displaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
20707 (unsigned long) offset
, (unsigned long) length
);
20709 /* NB: Some note sections may have alignment value of 0 or 1. gABI
20710 specifies that notes should be aligned to 4 bytes in 32-bit
20711 objects and to 8 bytes in 64-bit objects. As a Linux extension,
20712 we also support 4 byte alignment in 64-bit objects. If section
20713 alignment is less than 4, we treate alignment as 4 bytes. */
20716 else if (align
!= 4 && align
!= 8)
20718 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
20724 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
20726 end
= (char *) pnotes
+ length
;
20727 while ((char *) external
< end
)
20729 Elf_Internal_Note inote
;
20732 char * temp
= NULL
;
20733 size_t data_remaining
= end
- (char *) external
;
20735 if (!is_ia64_vms (filedata
))
20737 /* PR binutils/15191
20738 Make sure that there is enough data to read. */
20739 min_notesz
= offsetof (Elf_External_Note
, name
);
20740 if (data_remaining
< min_notesz
)
20742 warn (ngettext ("Corrupt note: only %ld byte remains, "
20743 "not enough for a full note\n",
20744 "Corrupt note: only %ld bytes remain, "
20745 "not enough for a full note\n",
20747 (long) data_remaining
);
20750 data_remaining
-= min_notesz
;
20752 inote
.type
= BYTE_GET (external
->type
);
20753 inote
.namesz
= BYTE_GET (external
->namesz
);
20754 inote
.namedata
= external
->name
;
20755 inote
.descsz
= BYTE_GET (external
->descsz
);
20756 inote
.descdata
= ((char *) external
20757 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
20758 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20759 next
= ((char *) external
20760 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
20764 Elf64_External_VMS_Note
*vms_external
;
20766 /* PR binutils/15191
20767 Make sure that there is enough data to read. */
20768 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
20769 if (data_remaining
< min_notesz
)
20771 warn (ngettext ("Corrupt note: only %ld byte remains, "
20772 "not enough for a full note\n",
20773 "Corrupt note: only %ld bytes remain, "
20774 "not enough for a full note\n",
20776 (long) data_remaining
);
20779 data_remaining
-= min_notesz
;
20781 vms_external
= (Elf64_External_VMS_Note
*) external
;
20782 inote
.type
= BYTE_GET (vms_external
->type
);
20783 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
20784 inote
.namedata
= vms_external
->name
;
20785 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
20786 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
20787 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20788 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
20791 /* PR 17531: file: 3443835e. */
20792 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
20793 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
20794 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
20795 || (size_t) (next
- inote
.descdata
) < inote
.descsz
20796 || ((size_t) (next
- inote
.descdata
)
20797 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
20799 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
20800 (unsigned long) ((char *) external
- (char *) pnotes
));
20801 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
20802 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
20806 external
= (Elf_External_Note
*) next
;
20808 /* Verify that name is null terminated. It appears that at least
20809 one version of Linux (RedHat 6.0) generates corefiles that don't
20810 comply with the ELF spec by failing to include the null byte in
20812 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
20814 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
20816 temp
= (char *) malloc (inote
.namesz
+ 1);
20819 error (_("Out of memory allocating space for inote name\n"));
20824 memcpy (temp
, inote
.namedata
, inote
.namesz
);
20825 inote
.namedata
= temp
;
20827 inote
.namedata
[inote
.namesz
] = 0;
20830 if (! process_note (& inote
, filedata
))
20843 process_corefile_note_segments (Filedata
* filedata
)
20845 Elf_Internal_Phdr
*segment
;
20849 if (! get_program_headers (filedata
))
20852 for (i
= 0, segment
= filedata
->program_headers
;
20853 i
< filedata
->file_header
.e_phnum
;
20856 if (segment
->p_type
== PT_NOTE
)
20857 if (! process_notes_at (filedata
, NULL
,
20858 (bfd_vma
) segment
->p_offset
,
20859 (bfd_vma
) segment
->p_filesz
,
20860 (bfd_vma
) segment
->p_align
))
20868 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
20870 Elf_External_Note
* pnotes
;
20871 Elf_External_Note
* external
;
20878 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
20880 if (pnotes
== NULL
)
20884 end
= (char*) pnotes
+ length
;
20886 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
20887 (unsigned long) offset
, (unsigned long) length
);
20889 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
20891 Elf_External_Note
* next
;
20892 Elf_Internal_Note inote
;
20894 inote
.type
= BYTE_GET (external
->type
);
20895 inote
.namesz
= BYTE_GET (external
->namesz
);
20896 inote
.namedata
= external
->name
;
20897 inote
.descsz
= BYTE_GET (external
->descsz
);
20898 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
20899 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20901 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
20903 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
20904 inote
.descdata
= inote
.namedata
;
20908 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
20910 if ( ((char *) next
> end
)
20911 || ((char *) next
< (char *) pnotes
))
20913 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
20914 (unsigned long) ((char *) external
- (char *) pnotes
));
20915 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
20916 inote
.type
, inote
.namesz
, inote
.descsz
);
20922 /* Prevent out-of-bounds indexing. */
20923 if ( inote
.namedata
+ inote
.namesz
> end
20924 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
20926 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
20927 (unsigned long) ((char *) external
- (char *) pnotes
));
20928 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
20929 inote
.type
, inote
.namesz
, inote
.descsz
);
20933 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
20935 if (! print_v850_note (& inote
))
20938 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
20939 inote
.namesz
, inote
.descsz
);
20949 process_note_sections (Filedata
* filedata
)
20951 Elf_Internal_Shdr
*section
;
20953 unsigned int n
= 0;
20956 for (i
= 0, section
= filedata
->section_headers
;
20957 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
20960 if (section
->sh_type
== SHT_NOTE
)
20962 if (! process_notes_at (filedata
, section
,
20963 (bfd_vma
) section
->sh_offset
,
20964 (bfd_vma
) section
->sh_size
,
20965 (bfd_vma
) section
->sh_addralign
))
20970 if (( filedata
->file_header
.e_machine
== EM_V800
20971 || filedata
->file_header
.e_machine
== EM_V850
20972 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
20973 && section
->sh_type
== SHT_RENESAS_INFO
)
20975 if (! process_v850_notes (filedata
,
20976 (bfd_vma
) section
->sh_offset
,
20977 (bfd_vma
) section
->sh_size
))
20984 /* Try processing NOTE segments instead. */
20985 return process_corefile_note_segments (filedata
);
20991 process_notes (Filedata
* filedata
)
20993 /* If we have not been asked to display the notes then do nothing. */
20997 if (filedata
->file_header
.e_type
!= ET_CORE
)
20998 return process_note_sections (filedata
);
21000 /* No program headers means no NOTE segment. */
21001 if (filedata
->file_header
.e_phnum
> 0)
21002 return process_corefile_note_segments (filedata
);
21004 if (filedata
->is_separate
)
21005 printf (_("No notes found in linked file '%s'.\n"),
21006 filedata
->file_name
);
21008 printf (_("No notes found file.\n"));
21013 static unsigned char *
21014 display_public_gnu_attributes (unsigned char * start
,
21015 const unsigned char * const end
)
21017 printf (_(" Unknown GNU attribute: %s\n"), start
);
21019 start
+= strnlen ((char *) start
, end
- start
);
21020 display_raw_attribute (start
, end
);
21022 return (unsigned char *) end
;
21025 static unsigned char *
21026 display_generic_attribute (unsigned char * start
,
21028 const unsigned char * const end
)
21031 return (unsigned char *) end
;
21033 return display_tag_value (tag
, start
, end
);
21037 process_arch_specific (Filedata
* filedata
)
21042 switch (filedata
->file_header
.e_machine
)
21045 case EM_ARC_COMPACT
:
21046 case EM_ARC_COMPACT2
:
21047 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
21048 display_arc_attribute
,
21049 display_generic_attribute
);
21051 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
21052 display_arm_attribute
,
21053 display_generic_attribute
);
21056 case EM_MIPS_RS3_LE
:
21057 return process_mips_specific (filedata
);
21060 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
21061 display_msp430_attribute
,
21062 display_msp430_gnu_attribute
);
21065 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
21066 display_riscv_attribute
,
21067 display_generic_attribute
);
21070 return process_nds32_specific (filedata
);
21073 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21074 display_m68k_gnu_attribute
);
21078 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21079 display_power_gnu_attribute
);
21083 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21084 display_s390_gnu_attribute
);
21087 case EM_SPARC32PLUS
:
21089 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21090 display_sparc_gnu_attribute
);
21093 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
21094 display_tic6x_attribute
,
21095 display_generic_attribute
);
21098 return process_attributes (filedata
, "csky", SHT_CSKY_ATTRIBUTES
,
21099 display_csky_attribute
, NULL
);
21102 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
21103 display_public_gnu_attributes
,
21104 display_generic_attribute
);
21109 get_file_header (Filedata
* filedata
)
21111 /* Read in the identity array. */
21112 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
21115 /* Determine how to read the rest of the header. */
21116 switch (filedata
->file_header
.e_ident
[EI_DATA
])
21121 byte_get
= byte_get_little_endian
;
21122 byte_put
= byte_put_little_endian
;
21125 byte_get
= byte_get_big_endian
;
21126 byte_put
= byte_put_big_endian
;
21130 /* For now we only support 32 bit and 64 bit ELF files. */
21131 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
21133 /* Read in the rest of the header. */
21136 Elf32_External_Ehdr ehdr32
;
21138 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
21141 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
21142 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
21143 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
21144 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
21145 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
21146 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
21147 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
21148 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
21149 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
21150 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
21151 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
21152 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
21153 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
21157 Elf64_External_Ehdr ehdr64
;
21159 /* If we have been compiled with sizeof (bfd_vma) == 4, then
21160 we will not be able to cope with the 64bit data found in
21161 64 ELF files. Detect this now and abort before we start
21162 overwriting things. */
21163 if (sizeof (bfd_vma
) < 8)
21165 error (_("This instance of readelf has been built without support for a\n\
21166 64 bit data type and so it cannot read 64 bit ELF files.\n"));
21170 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
21173 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
21174 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
21175 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
21176 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
21177 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
21178 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
21179 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
21180 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
21181 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
21182 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
21183 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
21184 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
21185 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
21192 free_filedata (Filedata
*filedata
)
21194 free (filedata
->program_interpreter
);
21195 free (filedata
->program_headers
);
21196 free (filedata
->section_headers
);
21197 free (filedata
->string_table
);
21198 free (filedata
->dump
.dump_sects
);
21199 free (filedata
->dynamic_strings
);
21200 free (filedata
->dynamic_symbols
);
21201 free (filedata
->dynamic_syminfo
);
21202 free (filedata
->dynamic_section
);
21204 while (filedata
->symtab_shndx_list
!= NULL
)
21206 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
21207 free (filedata
->symtab_shndx_list
);
21208 filedata
->symtab_shndx_list
= next
;
21211 free (filedata
->section_headers_groups
);
21213 if (filedata
->section_groups
)
21216 struct group_list
* g
;
21217 struct group_list
* next
;
21219 for (i
= 0; i
< filedata
->group_count
; i
++)
21221 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
21228 free (filedata
->section_groups
);
21230 memset (&filedata
->section_headers
, 0,
21231 sizeof (Filedata
) - offsetof (Filedata
, section_headers
));
21235 close_file (Filedata
* filedata
)
21239 if (filedata
->handle
)
21240 fclose (filedata
->handle
);
21246 close_debug_file (void * data
)
21248 free_filedata ((Filedata
*) data
);
21249 close_file ((Filedata
*) data
);
21253 open_file (const char * pathname
, bool is_separate
)
21255 struct stat statbuf
;
21256 Filedata
* filedata
= NULL
;
21258 if (stat (pathname
, & statbuf
) < 0
21259 || ! S_ISREG (statbuf
.st_mode
))
21262 filedata
= calloc (1, sizeof * filedata
);
21263 if (filedata
== NULL
)
21266 filedata
->handle
= fopen (pathname
, "rb");
21267 if (filedata
->handle
== NULL
)
21270 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
21271 filedata
->file_name
= pathname
;
21272 filedata
->is_separate
= is_separate
;
21274 if (! get_file_header (filedata
))
21277 if (!get_section_headers (filedata
, false))
21285 if (filedata
->handle
)
21286 fclose (filedata
->handle
);
21293 open_debug_file (const char * pathname
)
21295 return open_file (pathname
, true);
21299 initialise_dump_sects (Filedata
* filedata
)
21301 /* Initialise the dump_sects array from the cmdline_dump_sects array.
21302 Note we do this even if cmdline_dump_sects is empty because we
21303 must make sure that the dump_sets array is zeroed out before each
21304 object file is processed. */
21305 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
21306 memset (filedata
->dump
.dump_sects
, 0,
21307 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
21309 if (cmdline
.num_dump_sects
> 0)
21311 if (filedata
->dump
.num_dump_sects
== 0)
21312 /* A sneaky way of allocating the dump_sects array. */
21313 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
21315 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
21316 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
21317 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
21321 /* Process one ELF object file according to the command line options.
21322 This file may actually be stored in an archive. The file is
21323 positioned at the start of the ELF object. Returns TRUE if no
21324 problems were encountered, FALSE otherwise. */
21327 process_object (Filedata
* filedata
)
21329 bool have_separate_files
;
21333 if (! get_file_header (filedata
))
21335 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
21339 /* Initialise per file variables. */
21340 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
21341 filedata
->version_info
[i
] = 0;
21343 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
21344 filedata
->dynamic_info
[i
] = 0;
21345 filedata
->dynamic_info_DT_GNU_HASH
= 0;
21346 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
21348 /* Process the file. */
21350 printf (_("\nFile: %s\n"), filedata
->file_name
);
21352 initialise_dump_sects (filedata
);
21354 /* There may be some extensions in the first section header. Don't
21355 bomb if we can't read it. */
21356 get_section_headers (filedata
, true);
21358 if (! process_file_header (filedata
))
21364 if (! process_section_headers (filedata
))
21366 /* Without loaded section headers we cannot process lots of things. */
21367 do_unwind
= do_version
= do_dump
= do_arch
= false;
21369 if (! do_using_dynamic
)
21370 do_syms
= do_dyn_syms
= do_reloc
= false;
21373 if (! process_section_groups (filedata
))
21374 /* Without loaded section groups we cannot process unwind. */
21377 res
= process_program_headers (filedata
);
21379 res
= process_dynamic_section (filedata
);
21381 if (! process_relocs (filedata
))
21384 if (! process_unwind (filedata
))
21387 if (! process_symbol_table (filedata
))
21390 if (! process_lto_symbol_tables (filedata
))
21393 if (! process_syminfo (filedata
))
21396 if (! process_version_sections (filedata
))
21399 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
21400 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
21402 have_separate_files
= false;
21404 if (! process_section_contents (filedata
))
21407 if (have_separate_files
)
21411 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
21413 initialise_dump_sects (d
->handle
);
21415 if (process_links
&& ! process_file_header (d
->handle
))
21417 else if (! process_section_headers (d
->handle
))
21419 else if (! process_section_contents (d
->handle
))
21421 else if (process_links
)
21423 if (! process_section_groups (d
->handle
))
21425 if (! process_program_headers (d
->handle
))
21427 if (! process_dynamic_section (d
->handle
))
21429 if (! process_relocs (d
->handle
))
21431 if (! process_unwind (d
->handle
))
21433 if (! process_symbol_table (d
->handle
))
21435 if (! process_lto_symbol_tables (d
->handle
))
21437 if (! process_syminfo (d
->handle
))
21439 if (! process_version_sections (d
->handle
))
21441 if (! process_notes (d
->handle
))
21446 /* The file handles are closed by the call to free_debug_memory() below. */
21449 if (! process_notes (filedata
))
21452 if (! process_gnu_liblist (filedata
))
21455 if (! process_arch_specific (filedata
))
21459 free_filedata (filedata
);
21461 free_debug_memory ();
21466 /* Process an ELF archive.
21467 On entry the file is positioned just after the ARMAG string.
21468 Returns TRUE upon success, FALSE otherwise. */
21471 process_archive (Filedata
* filedata
, bool is_thin_archive
)
21473 struct archive_info arch
;
21474 struct archive_info nested_arch
;
21480 /* The ARCH structure is used to hold information about this archive. */
21481 arch
.file_name
= NULL
;
21483 arch
.index_array
= NULL
;
21484 arch
.sym_table
= NULL
;
21485 arch
.longnames
= NULL
;
21487 /* The NESTED_ARCH structure is used as a single-item cache of information
21488 about a nested archive (when members of a thin archive reside within
21489 another regular archive file). */
21490 nested_arch
.file_name
= NULL
;
21491 nested_arch
.file
= NULL
;
21492 nested_arch
.index_array
= NULL
;
21493 nested_arch
.sym_table
= NULL
;
21494 nested_arch
.longnames
= NULL
;
21496 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
21497 filedata
->file_size
, is_thin_archive
,
21498 do_archive_index
) != 0)
21504 if (do_archive_index
)
21506 if (arch
.sym_table
== NULL
)
21507 error (_("%s: unable to dump the index as none was found\n"),
21508 filedata
->file_name
);
21511 unsigned long i
, l
;
21512 unsigned long current_pos
;
21514 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
21515 "in the symbol table)\n"),
21516 filedata
->file_name
, (unsigned long) arch
.index_num
,
21519 current_pos
= ftell (filedata
->handle
);
21521 for (i
= l
= 0; i
< arch
.index_num
; i
++)
21524 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
21527 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
21530 if (member_name
!= NULL
)
21532 char * qualified_name
21533 = make_qualified_name (&arch
, &nested_arch
,
21536 if (qualified_name
!= NULL
)
21538 printf (_("Contents of binary %s at offset "),
21540 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
21542 free (qualified_name
);
21544 free (member_name
);
21548 if (l
>= arch
.sym_size
)
21550 error (_("%s: end of the symbol table reached "
21551 "before the end of the index\n"),
21552 filedata
->file_name
);
21556 /* PR 17531: file: 0b6630b2. */
21557 printf ("\t%.*s\n",
21558 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
21559 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
21562 if (arch
.uses_64bit_indices
)
21567 if (l
< arch
.sym_size
)
21569 error (ngettext ("%s: %ld byte remains in the symbol table, "
21570 "but without corresponding entries in "
21571 "the index table\n",
21572 "%s: %ld bytes remain in the symbol table, "
21573 "but without corresponding entries in "
21574 "the index table\n",
21575 arch
.sym_size
- l
),
21576 filedata
->file_name
, arch
.sym_size
- l
);
21580 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
21582 error (_("%s: failed to seek back to start of object files "
21583 "in the archive\n"),
21584 filedata
->file_name
);
21590 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
21591 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
21592 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
21593 && !do_section_groups
&& !do_dyn_syms
)
21595 ret
= true; /* Archive index only. */
21604 char * qualified_name
;
21606 /* Read the next archive header. */
21607 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
21609 error (_("%s: failed to seek to next archive header\n"),
21614 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
21615 if (got
!= sizeof arch
.arhdr
)
21619 /* PR 24049 - we cannot use filedata->file_name as this will
21620 have already been freed. */
21621 error (_("%s: failed to read archive header\n"), arch
.file_name
);
21626 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
21628 error (_("%s: did not find a valid archive header\n"),
21634 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
21636 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
21637 if (filedata
->archive_file_size
& 01)
21638 ++filedata
->archive_file_size
;
21640 name
= get_archive_member_name (&arch
, &nested_arch
);
21643 error (_("%s: bad archive file name\n"), arch
.file_name
);
21647 namelen
= strlen (name
);
21649 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
21650 if (qualified_name
== NULL
)
21652 error (_("%s: bad archive file name\n"), arch
.file_name
);
21658 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
21660 /* This is a proxy for an external member of a thin archive. */
21661 Filedata
* member_filedata
;
21662 char * member_file_name
= adjust_relative_path
21663 (filedata
->file_name
, name
, namelen
);
21666 if (member_file_name
== NULL
)
21668 free (qualified_name
);
21673 member_filedata
= open_file (member_file_name
, false);
21674 if (member_filedata
== NULL
)
21676 error (_("Input file '%s' is not readable.\n"), member_file_name
);
21677 free (member_file_name
);
21678 free (qualified_name
);
21683 filedata
->archive_file_offset
= arch
.nested_member_origin
;
21684 member_filedata
->file_name
= qualified_name
;
21686 if (! process_object (member_filedata
))
21689 close_file (member_filedata
);
21690 free (member_file_name
);
21692 else if (is_thin_archive
)
21694 Filedata thin_filedata
;
21696 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
21698 /* PR 15140: Allow for corrupt thin archives. */
21699 if (nested_arch
.file
== NULL
)
21701 error (_("%s: contains corrupt thin archive: %s\n"),
21702 qualified_name
, name
);
21703 free (qualified_name
);
21710 /* This is a proxy for a member of a nested archive. */
21711 filedata
->archive_file_offset
21712 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
21714 /* The nested archive file will have been opened and setup by
21715 get_archive_member_name. */
21716 if (fseek (nested_arch
.file
, filedata
->archive_file_offset
,
21719 error (_("%s: failed to seek to archive member.\n"),
21720 nested_arch
.file_name
);
21721 free (qualified_name
);
21726 thin_filedata
.handle
= nested_arch
.file
;
21727 thin_filedata
.file_name
= qualified_name
;
21729 if (! process_object (& thin_filedata
))
21735 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
21736 filedata
->file_name
= qualified_name
;
21737 if (! process_object (filedata
))
21739 arch
.next_arhdr_offset
+= filedata
->archive_file_size
;
21740 /* Stop looping with "negative" archive_file_size. */
21741 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
21742 arch
.next_arhdr_offset
= -1ul;
21745 free (qualified_name
);
21749 if (nested_arch
.file
!= NULL
)
21750 fclose (nested_arch
.file
);
21751 release_archive (&nested_arch
);
21752 release_archive (&arch
);
21758 process_file (char * file_name
)
21760 Filedata
* filedata
= NULL
;
21761 struct stat statbuf
;
21762 char armag
[SARMAG
];
21765 if (stat (file_name
, &statbuf
) < 0)
21767 if (errno
== ENOENT
)
21768 error (_("'%s': No such file\n"), file_name
);
21770 error (_("Could not locate '%s'. System error message: %s\n"),
21771 file_name
, strerror (errno
));
21775 if (! S_ISREG (statbuf
.st_mode
))
21777 error (_("'%s' is not an ordinary file\n"), file_name
);
21781 filedata
= calloc (1, sizeof * filedata
);
21782 if (filedata
== NULL
)
21784 error (_("Out of memory allocating file data structure\n"));
21788 filedata
->file_name
= file_name
;
21789 filedata
->handle
= fopen (file_name
, "rb");
21790 if (filedata
->handle
== NULL
)
21792 error (_("Input file '%s' is not readable.\n"), file_name
);
21797 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
21799 error (_("%s: Failed to read file's magic number\n"), file_name
);
21800 fclose (filedata
->handle
);
21805 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
21806 filedata
->is_separate
= false;
21808 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
21810 if (! process_archive (filedata
, false))
21813 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
21815 if ( ! process_archive (filedata
, true))
21820 if (do_archive_index
&& !check_all
)
21821 error (_("File %s is not an archive so its index cannot be displayed.\n"),
21824 rewind (filedata
->handle
);
21825 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
21827 if (! process_object (filedata
))
21831 fclose (filedata
->handle
);
21832 free (filedata
->section_headers
);
21833 free (filedata
->program_headers
);
21834 free (filedata
->string_table
);
21835 free (filedata
->dump
.dump_sects
);
21838 free (ba_cache
.strtab
);
21839 ba_cache
.strtab
= NULL
;
21840 free (ba_cache
.symtab
);
21841 ba_cache
.symtab
= NULL
;
21842 ba_cache
.filedata
= NULL
;
21847 #ifdef SUPPORT_DISASSEMBLY
21848 /* Needed by the i386 disassembler. For extra credit, someone could
21849 fix this so that we insert symbolic addresses here, esp for GOT/PLT
21853 print_address (unsigned int addr
, FILE * outfile
)
21855 fprintf (outfile
,"0x%8.8x", addr
);
21858 /* Needed by the i386 disassembler. */
21861 db_task_printsym (unsigned int addr
)
21863 print_address (addr
, stderr
);
21868 main (int argc
, char ** argv
)
21872 #ifdef HAVE_LC_MESSAGES
21873 setlocale (LC_MESSAGES
, "");
21875 setlocale (LC_CTYPE
, "");
21876 bindtextdomain (PACKAGE
, LOCALEDIR
);
21877 textdomain (PACKAGE
);
21879 expandargv (&argc
, &argv
);
21881 parse_args (& cmdline
, argc
, argv
);
21883 if (optind
< (argc
- 1))
21884 /* When displaying information for more than one file,
21885 prefix the information with the file name. */
21887 else if (optind
>= argc
)
21889 /* Ensure that the warning is always displayed. */
21892 warn (_("Nothing to do.\n"));
21897 while (optind
< argc
)
21898 if (! process_file (argv
[optind
++]))
21901 free (cmdline
.dump_sects
);
21903 free (dump_ctf_symtab_name
);
21904 free (dump_ctf_strtab_name
);
21905 free (dump_ctf_parent_name
);
21907 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;