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
;
5245 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5246 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
5249 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5251 Elf32_External_Phdr
* phdrs
;
5252 Elf32_External_Phdr
* external
;
5253 Elf_Internal_Phdr
* internal
;
5255 unsigned int size
= filedata
->file_header
.e_phentsize
;
5256 unsigned int num
= filedata
->file_header
.e_phnum
;
5258 /* PR binutils/17531: Cope with unexpected section header sizes. */
5259 if (size
== 0 || num
== 0)
5261 if (size
< sizeof * phdrs
)
5263 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5266 if (size
> sizeof * phdrs
)
5267 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5269 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5270 size
, num
, _("program headers"));
5274 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5275 i
< filedata
->file_header
.e_phnum
;
5276 i
++, internal
++, external
++)
5278 internal
->p_type
= BYTE_GET (external
->p_type
);
5279 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5280 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5281 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5282 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5283 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5284 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5285 internal
->p_align
= BYTE_GET (external
->p_align
);
5292 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5293 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5296 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5298 Elf64_External_Phdr
* phdrs
;
5299 Elf64_External_Phdr
* external
;
5300 Elf_Internal_Phdr
* internal
;
5302 unsigned int size
= filedata
->file_header
.e_phentsize
;
5303 unsigned int num
= filedata
->file_header
.e_phnum
;
5305 /* PR binutils/17531: Cope with unexpected section header sizes. */
5306 if (size
== 0 || num
== 0)
5308 if (size
< sizeof * phdrs
)
5310 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5313 if (size
> sizeof * phdrs
)
5314 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5316 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5317 size
, num
, _("program headers"));
5321 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5322 i
< filedata
->file_header
.e_phnum
;
5323 i
++, internal
++, external
++)
5325 internal
->p_type
= BYTE_GET (external
->p_type
);
5326 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5327 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5328 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5329 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5330 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5331 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5332 internal
->p_align
= BYTE_GET (external
->p_align
);
5339 /* Returns TRUE if the program headers were read into `program_headers'. */
5342 get_program_headers (Filedata
* filedata
)
5344 Elf_Internal_Phdr
* phdrs
;
5346 /* Check cache of prior read. */
5347 if (filedata
->program_headers
!= NULL
)
5350 /* Be kind to memory checkers by looking for
5351 e_phnum values which we know must be invalid. */
5352 if (filedata
->file_header
.e_phnum
5353 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5354 >= filedata
->file_size
)
5356 error (_("Too many program headers - %#x - the file is not that big\n"),
5357 filedata
->file_header
.e_phnum
);
5361 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5362 sizeof (Elf_Internal_Phdr
));
5365 error (_("Out of memory reading %u program headers\n"),
5366 filedata
->file_header
.e_phnum
);
5371 ? get_32bit_program_headers (filedata
, phdrs
)
5372 : get_64bit_program_headers (filedata
, phdrs
))
5374 filedata
->program_headers
= phdrs
;
5382 /* Returns TRUE if the program headers were loaded. */
5385 process_program_headers (Filedata
* filedata
)
5387 Elf_Internal_Phdr
* segment
;
5389 Elf_Internal_Phdr
* previous_load
= NULL
;
5391 filedata
->dynamic_addr
= 0;
5392 filedata
->dynamic_size
= 0;
5394 if (filedata
->file_header
.e_phnum
== 0)
5396 /* PR binutils/12467. */
5397 if (filedata
->file_header
.e_phoff
!= 0)
5399 warn (_("possibly corrupt ELF header - it has a non-zero program"
5400 " header offset, but no program headers\n"));
5403 else if (do_segments
)
5405 if (filedata
->is_separate
)
5406 printf (_("\nThere are no program headers in linked file '%s'.\n"),
5407 filedata
->file_name
);
5409 printf (_("\nThere are no program headers in this file.\n"));
5414 if (do_segments
&& !do_header
)
5416 if (filedata
->is_separate
)
5417 printf ("\nIn linked file '%s' the ELF file type is %s\n",
5418 filedata
->file_name
,
5419 get_file_type (filedata
->file_header
.e_type
));
5421 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5422 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5423 printf (ngettext ("There is %d program header, starting at offset %s\n",
5424 "There are %d program headers, starting at offset %s\n",
5425 filedata
->file_header
.e_phnum
),
5426 filedata
->file_header
.e_phnum
,
5427 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5430 if (! get_program_headers (filedata
))
5435 if (filedata
->file_header
.e_phnum
> 1)
5436 printf (_("\nProgram Headers:\n"));
5438 printf (_("\nProgram Headers:\n"));
5442 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5445 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5449 (_(" Type Offset VirtAddr PhysAddr\n"));
5451 (_(" FileSiz MemSiz Flags Align\n"));
5455 for (i
= 0, segment
= filedata
->program_headers
;
5456 i
< filedata
->file_header
.e_phnum
;
5461 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5465 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5466 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5467 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5468 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5469 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5471 (segment
->p_flags
& PF_R
? 'R' : ' '),
5472 (segment
->p_flags
& PF_W
? 'W' : ' '),
5473 (segment
->p_flags
& PF_X
? 'E' : ' '));
5474 printf ("%#lx", (unsigned long) segment
->p_align
);
5478 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5479 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5482 print_vma (segment
->p_offset
, FULL_HEX
);
5486 print_vma (segment
->p_vaddr
, FULL_HEX
);
5488 print_vma (segment
->p_paddr
, FULL_HEX
);
5491 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5492 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5495 print_vma (segment
->p_filesz
, FULL_HEX
);
5499 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5500 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5503 print_vma (segment
->p_memsz
, FULL_HEX
);
5507 (segment
->p_flags
& PF_R
? 'R' : ' '),
5508 (segment
->p_flags
& PF_W
? 'W' : ' '),
5509 (segment
->p_flags
& PF_X
? 'E' : ' '));
5511 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5512 printf ("%#lx", (unsigned long) segment
->p_align
);
5515 print_vma (segment
->p_align
, PREFIX_HEX
);
5520 print_vma (segment
->p_offset
, FULL_HEX
);
5522 print_vma (segment
->p_vaddr
, FULL_HEX
);
5524 print_vma (segment
->p_paddr
, FULL_HEX
);
5526 print_vma (segment
->p_filesz
, FULL_HEX
);
5528 print_vma (segment
->p_memsz
, FULL_HEX
);
5530 (segment
->p_flags
& PF_R
? 'R' : ' '),
5531 (segment
->p_flags
& PF_W
? 'W' : ' '),
5532 (segment
->p_flags
& PF_X
? 'E' : ' '));
5533 print_vma (segment
->p_align
, PREFIX_HEX
);
5536 putc ('\n', stdout
);
5539 switch (segment
->p_type
)
5542 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5543 required by the ELF standard, several programs, including the Linux
5544 kernel, make use of non-ordered segments. */
5546 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5547 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5549 if (segment
->p_memsz
< segment
->p_filesz
)
5550 error (_("the segment's file size is larger than its memory size\n"));
5551 previous_load
= segment
;
5555 /* PR 20815 - Verify that the program header is loaded into memory. */
5556 if (i
> 0 && previous_load
!= NULL
)
5557 error (_("the PHDR segment must occur before any LOAD segment\n"));
5558 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5562 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5564 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
5565 if (load
->p_type
== PT_LOAD
5566 && load
->p_offset
<= segment
->p_offset
5567 && (load
->p_offset
+ load
->p_filesz
5568 >= segment
->p_offset
+ segment
->p_filesz
)
5569 && load
->p_vaddr
<= segment
->p_vaddr
5570 && (load
->p_vaddr
+ load
->p_filesz
5571 >= segment
->p_vaddr
+ segment
->p_filesz
))
5574 if (j
== filedata
->file_header
.e_phnum
)
5575 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5580 if (filedata
->dynamic_addr
)
5581 error (_("more than one dynamic segment\n"));
5583 /* By default, assume that the .dynamic section is the first
5584 section in the DYNAMIC segment. */
5585 filedata
->dynamic_addr
= segment
->p_offset
;
5586 filedata
->dynamic_size
= segment
->p_filesz
;
5588 /* Try to locate the .dynamic section. If there is
5589 a section header table, we can easily locate it. */
5590 if (filedata
->section_headers
!= NULL
)
5592 Elf_Internal_Shdr
* sec
;
5594 sec
= find_section (filedata
, ".dynamic");
5595 if (sec
== NULL
|| sec
->sh_size
== 0)
5597 /* A corresponding .dynamic section is expected, but on
5598 IA-64/OpenVMS it is OK for it to be missing. */
5599 if (!is_ia64_vms (filedata
))
5600 error (_("no .dynamic section in the dynamic segment\n"));
5604 if (sec
->sh_type
== SHT_NOBITS
)
5606 filedata
->dynamic_size
= 0;
5610 filedata
->dynamic_addr
= sec
->sh_offset
;
5611 filedata
->dynamic_size
= sec
->sh_size
;
5613 /* The PT_DYNAMIC segment, which is used by the run-time
5614 loader, should exactly match the .dynamic section. */
5616 && (filedata
->dynamic_addr
!= segment
->p_offset
5617 || filedata
->dynamic_size
!= segment
->p_filesz
))
5619 the .dynamic section is not the same as the dynamic segment\n"));
5622 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5623 segment. Check this after matching against the section headers
5624 so we don't warn on debuginfo file (which have NOBITS .dynamic
5626 if (filedata
->dynamic_addr
> filedata
->file_size
5627 || (filedata
->dynamic_size
5628 > filedata
->file_size
- filedata
->dynamic_addr
))
5630 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5631 filedata
->dynamic_addr
= filedata
->dynamic_size
= 0;
5636 if (segment
->p_offset
>= filedata
->file_size
5637 || segment
->p_filesz
> filedata
->file_size
- segment
->p_offset
5638 || segment
->p_filesz
- 1 >= (size_t) -2
5639 || fseek (filedata
->handle
,
5640 filedata
->archive_file_offset
+ (long) segment
->p_offset
,
5642 error (_("Unable to find program interpreter name\n"));
5645 size_t len
= segment
->p_filesz
;
5646 free (filedata
->program_interpreter
);
5647 filedata
->program_interpreter
= xmalloc (len
+ 1);
5648 len
= fread (filedata
->program_interpreter
, 1, len
,
5650 filedata
->program_interpreter
[len
] = 0;
5653 printf (_(" [Requesting program interpreter: %s]\n"),
5654 filedata
->program_interpreter
);
5661 && filedata
->section_headers
!= NULL
5662 && filedata
->string_table
!= NULL
)
5664 printf (_("\n Section to Segment mapping:\n"));
5665 printf (_(" Segment Sections...\n"));
5667 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5670 Elf_Internal_Shdr
* section
;
5672 segment
= filedata
->program_headers
+ i
;
5673 section
= filedata
->section_headers
+ 1;
5675 printf (" %2.2d ", i
);
5677 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5679 if (!ELF_TBSS_SPECIAL (section
, segment
)
5680 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5681 printf ("%s ", printable_section_name (filedata
, section
));
5692 /* Find the file offset corresponding to VMA by using the program headers. */
5695 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5697 Elf_Internal_Phdr
* seg
;
5699 if (! get_program_headers (filedata
))
5701 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5705 for (seg
= filedata
->program_headers
;
5706 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5709 if (seg
->p_type
!= PT_LOAD
)
5712 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5713 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5714 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5717 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5718 (unsigned long) vma
);
5723 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5724 If PROBE is true, this is just a probe and we do not generate any error
5725 messages if the load fails. */
5728 get_32bit_section_headers (Filedata
* filedata
, bool probe
)
5730 Elf32_External_Shdr
* shdrs
;
5731 Elf_Internal_Shdr
* internal
;
5733 unsigned int size
= filedata
->file_header
.e_shentsize
;
5734 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5736 /* PR binutils/17531: Cope with unexpected section header sizes. */
5737 if (size
== 0 || num
== 0)
5739 if (size
< sizeof * shdrs
)
5742 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5745 if (!probe
&& size
> sizeof * shdrs
)
5746 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5748 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5750 probe
? NULL
: _("section headers"));
5754 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5755 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5756 if (filedata
->section_headers
== NULL
)
5759 error (_("Out of memory reading %u section headers\n"), num
);
5764 for (i
= 0, internal
= filedata
->section_headers
;
5768 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5769 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5770 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5771 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5772 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5773 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5774 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5775 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5776 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5777 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5778 if (!probe
&& internal
->sh_link
> num
)
5779 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5780 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5781 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5788 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5791 get_64bit_section_headers (Filedata
* filedata
, bool probe
)
5793 Elf64_External_Shdr
* shdrs
;
5794 Elf_Internal_Shdr
* internal
;
5796 unsigned int size
= filedata
->file_header
.e_shentsize
;
5797 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5799 /* PR binutils/17531: Cope with unexpected section header sizes. */
5800 if (size
== 0 || num
== 0)
5803 if (size
< sizeof * shdrs
)
5806 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5810 if (! probe
&& size
> sizeof * shdrs
)
5811 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5813 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5814 filedata
->file_header
.e_shoff
,
5816 probe
? NULL
: _("section headers"));
5820 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5821 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5822 if (filedata
->section_headers
== NULL
)
5825 error (_("Out of memory reading %u section headers\n"), num
);
5830 for (i
= 0, internal
= filedata
->section_headers
;
5834 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5835 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5836 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5837 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5838 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5839 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5840 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5841 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5842 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5843 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5844 if (!probe
&& internal
->sh_link
> num
)
5845 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5846 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5847 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5855 get_section_headers (Filedata
*filedata
, bool probe
)
5857 if (filedata
->section_headers
!= NULL
)
5861 return get_32bit_section_headers (filedata
, probe
);
5863 return get_64bit_section_headers (filedata
, probe
);
5866 static Elf_Internal_Sym
*
5867 get_32bit_elf_symbols (Filedata
* filedata
,
5868 Elf_Internal_Shdr
* section
,
5869 unsigned long * num_syms_return
)
5871 unsigned long number
= 0;
5872 Elf32_External_Sym
* esyms
= NULL
;
5873 Elf_External_Sym_Shndx
* shndx
= NULL
;
5874 Elf_Internal_Sym
* isyms
= NULL
;
5875 Elf_Internal_Sym
* psym
;
5877 elf_section_list
* entry
;
5879 if (section
->sh_size
== 0)
5881 if (num_syms_return
!= NULL
)
5882 * num_syms_return
= 0;
5886 /* Run some sanity checks first. */
5887 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5889 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5890 printable_section_name (filedata
, section
),
5891 (unsigned long) section
->sh_entsize
);
5895 if (section
->sh_size
> filedata
->file_size
)
5897 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5898 printable_section_name (filedata
, section
),
5899 (unsigned long) section
->sh_size
);
5903 number
= section
->sh_size
/ section
->sh_entsize
;
5905 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5907 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5908 (unsigned long) section
->sh_size
,
5909 printable_section_name (filedata
, section
),
5910 (unsigned long) section
->sh_entsize
);
5914 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5915 section
->sh_size
, _("symbols"));
5920 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5922 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5927 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5931 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5932 entry
->hdr
->sh_offset
,
5933 1, entry
->hdr
->sh_size
,
5934 _("symbol table section indices"));
5938 /* PR17531: file: heap-buffer-overflow */
5939 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5941 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5942 printable_section_name (filedata
, entry
->hdr
),
5943 (unsigned long) entry
->hdr
->sh_size
,
5944 (unsigned long) section
->sh_size
);
5949 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5953 error (_("Out of memory reading %lu symbols\n"),
5954 (unsigned long) number
);
5958 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5960 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5961 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5962 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5963 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5964 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5966 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5967 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5968 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5969 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5970 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5977 if (num_syms_return
!= NULL
)
5978 * num_syms_return
= isyms
== NULL
? 0 : number
;
5983 static Elf_Internal_Sym
*
5984 get_64bit_elf_symbols (Filedata
* filedata
,
5985 Elf_Internal_Shdr
* section
,
5986 unsigned long * num_syms_return
)
5988 unsigned long number
= 0;
5989 Elf64_External_Sym
* esyms
= NULL
;
5990 Elf_External_Sym_Shndx
* shndx
= NULL
;
5991 Elf_Internal_Sym
* isyms
= NULL
;
5992 Elf_Internal_Sym
* psym
;
5994 elf_section_list
* entry
;
5996 if (section
->sh_size
== 0)
5998 if (num_syms_return
!= NULL
)
5999 * num_syms_return
= 0;
6003 /* Run some sanity checks first. */
6004 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
6006 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
6007 printable_section_name (filedata
, section
),
6008 (unsigned long) section
->sh_entsize
);
6012 if (section
->sh_size
> filedata
->file_size
)
6014 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
6015 printable_section_name (filedata
, section
),
6016 (unsigned long) section
->sh_size
);
6020 number
= section
->sh_size
/ section
->sh_entsize
;
6022 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
6024 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
6025 (unsigned long) section
->sh_size
,
6026 printable_section_name (filedata
, section
),
6027 (unsigned long) section
->sh_entsize
);
6031 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
6032 section
->sh_size
, _("symbols"));
6037 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
6039 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
6044 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
6048 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
6049 entry
->hdr
->sh_offset
,
6050 1, entry
->hdr
->sh_size
,
6051 _("symbol table section indices"));
6055 /* PR17531: file: heap-buffer-overflow */
6056 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
6058 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
6059 printable_section_name (filedata
, entry
->hdr
),
6060 (unsigned long) entry
->hdr
->sh_size
,
6061 (unsigned long) section
->sh_size
);
6066 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
6070 error (_("Out of memory reading %lu symbols\n"),
6071 (unsigned long) number
);
6075 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
6077 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
6078 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
6079 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
6080 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
6082 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
6084 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
6085 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
6086 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
6088 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
6089 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
6096 if (num_syms_return
!= NULL
)
6097 * num_syms_return
= isyms
== NULL
? 0 : number
;
6102 static Elf_Internal_Sym
*
6103 get_elf_symbols (Filedata
*filedata
,
6104 Elf_Internal_Shdr
*section
,
6105 unsigned long *num_syms_return
)
6108 return get_32bit_elf_symbols (filedata
, section
, num_syms_return
);
6110 return get_64bit_elf_symbols (filedata
, section
, num_syms_return
);
6114 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
6116 static char buff
[1024];
6118 unsigned int field_size
= is_32bit_elf
? 8 : 16;
6120 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
6121 bfd_vma os_flags
= 0;
6122 bfd_vma proc_flags
= 0;
6123 bfd_vma unknown_flags
= 0;
6131 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
6132 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
6133 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
6134 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
6135 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
6136 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
6137 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
6138 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
6139 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
6140 /* 9 */ { STRING_COMMA_LEN ("TLS") },
6141 /* IA-64 specific. */
6142 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
6143 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
6144 /* IA-64 OpenVMS specific. */
6145 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
6146 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
6147 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
6148 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
6149 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
6150 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
6152 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
6153 /* SPARC specific. */
6154 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
6155 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
6157 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
6158 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
6159 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
6161 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
6163 /* 25 */ { STRING_COMMA_LEN ("VLE") },
6165 /* 26 */ { STRING_COMMA_LEN ("GNU_RETAIN") },
6168 if (do_section_details
)
6170 sprintf (buff
, "[%*.*lx]: ",
6171 field_size
, field_size
, (unsigned long) sh_flags
);
6172 p
+= field_size
+ 4;
6179 flag
= sh_flags
& - sh_flags
;
6182 if (do_section_details
)
6186 case SHF_WRITE
: sindex
= 0; break;
6187 case SHF_ALLOC
: sindex
= 1; break;
6188 case SHF_EXECINSTR
: sindex
= 2; break;
6189 case SHF_MERGE
: sindex
= 3; break;
6190 case SHF_STRINGS
: sindex
= 4; break;
6191 case SHF_INFO_LINK
: sindex
= 5; break;
6192 case SHF_LINK_ORDER
: sindex
= 6; break;
6193 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
6194 case SHF_GROUP
: sindex
= 8; break;
6195 case SHF_TLS
: sindex
= 9; break;
6196 case SHF_EXCLUDE
: sindex
= 18; break;
6197 case SHF_COMPRESSED
: sindex
= 20; break;
6201 switch (filedata
->file_header
.e_machine
)
6204 if (flag
== SHF_IA_64_SHORT
)
6206 else if (flag
== SHF_IA_64_NORECOV
)
6209 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
6212 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
6213 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
6214 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
6215 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
6216 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
6217 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
6228 case EM_OLD_SPARCV9
:
6229 case EM_SPARC32PLUS
:
6232 if (flag
== SHF_ORDERED
)
6239 case SHF_ENTRYSECT
: sindex
= 21; break;
6240 case SHF_ARM_PURECODE
: sindex
= 22; break;
6241 case SHF_COMDEF
: sindex
= 23; break;
6246 if (flag
== SHF_PPC_VLE
)
6253 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
6256 case ELFOSABI_FREEBSD
:
6257 if (flag
== SHF_GNU_RETAIN
)
6261 if (flag
== SHF_GNU_MBIND
)
6262 /* We should not recognize SHF_GNU_MBIND for
6263 ELFOSABI_NONE, but binutils as of 2019-07-23 did
6264 not set the EI_OSABI header byte. */
6275 if (p
!= buff
+ field_size
+ 4)
6277 if (size
< (10 + 2))
6279 warn (_("Internal error: not enough buffer room for section flag info"));
6280 return _("<unknown>");
6287 size
-= flags
[sindex
].len
;
6288 p
= stpcpy (p
, flags
[sindex
].str
);
6290 else if (flag
& SHF_MASKOS
)
6292 else if (flag
& SHF_MASKPROC
)
6295 unknown_flags
|= flag
;
6301 case SHF_WRITE
: *p
= 'W'; break;
6302 case SHF_ALLOC
: *p
= 'A'; break;
6303 case SHF_EXECINSTR
: *p
= 'X'; break;
6304 case SHF_MERGE
: *p
= 'M'; break;
6305 case SHF_STRINGS
: *p
= 'S'; break;
6306 case SHF_INFO_LINK
: *p
= 'I'; break;
6307 case SHF_LINK_ORDER
: *p
= 'L'; break;
6308 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
6309 case SHF_GROUP
: *p
= 'G'; break;
6310 case SHF_TLS
: *p
= 'T'; break;
6311 case SHF_EXCLUDE
: *p
= 'E'; break;
6312 case SHF_COMPRESSED
: *p
= 'C'; break;
6315 if ((filedata
->file_header
.e_machine
== EM_X86_64
6316 || filedata
->file_header
.e_machine
== EM_L1OM
6317 || filedata
->file_header
.e_machine
== EM_K1OM
)
6318 && flag
== SHF_X86_64_LARGE
)
6320 else if (filedata
->file_header
.e_machine
== EM_ARM
6321 && flag
== SHF_ARM_PURECODE
)
6323 else if (filedata
->file_header
.e_machine
== EM_PPC
6324 && flag
== SHF_PPC_VLE
)
6326 else if (flag
& SHF_MASKOS
)
6328 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
6331 case ELFOSABI_FREEBSD
:
6332 if (flag
== SHF_GNU_RETAIN
)
6339 if (flag
== SHF_GNU_MBIND
)
6341 /* We should not recognize SHF_GNU_MBIND for
6342 ELFOSABI_NONE, but binutils as of 2019-07-23 did
6343 not set the EI_OSABI header byte. */
6350 sh_flags
&= ~SHF_MASKOS
;
6354 else if (flag
& SHF_MASKPROC
)
6357 sh_flags
&= ~ SHF_MASKPROC
;
6367 if (do_section_details
)
6371 size
-= 5 + field_size
;
6372 if (p
!= buff
+ field_size
+ 4)
6376 warn (_("Internal error: not enough buffer room for section flag info"));
6377 return _("<unknown>");
6383 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6384 (unsigned long) os_flags
);
6385 p
+= 5 + field_size
;
6389 size
-= 7 + field_size
;
6390 if (p
!= buff
+ field_size
+ 4)
6394 warn (_("Internal error: not enough buffer room for section flag info"));
6395 return _("<unknown>");
6401 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6402 (unsigned long) proc_flags
);
6403 p
+= 7 + field_size
;
6407 size
-= 10 + field_size
;
6408 if (p
!= buff
+ field_size
+ 4)
6412 warn (_("Internal error: not enough buffer room for section flag info"));
6413 return _("<unknown>");
6419 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6420 (unsigned long) unknown_flags
);
6421 p
+= 10 + field_size
;
6429 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
6430 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6434 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6436 if (size
< sizeof (* echdr
))
6438 error (_("Compressed section is too small even for a compression header\n"));
6442 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6443 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6444 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6445 return sizeof (*echdr
);
6449 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6451 if (size
< sizeof (* echdr
))
6453 error (_("Compressed section is too small even for a compression header\n"));
6457 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6458 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6459 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6460 return sizeof (*echdr
);
6465 process_section_headers (Filedata
* filedata
)
6467 Elf_Internal_Shdr
* section
;
6470 if (filedata
->file_header
.e_shnum
== 0)
6472 /* PR binutils/12467. */
6473 if (filedata
->file_header
.e_shoff
!= 0)
6475 warn (_("possibly corrupt ELF file header - it has a non-zero"
6476 " section header offset, but no section headers\n"));
6479 else if (do_sections
)
6480 printf (_("\nThere are no sections in this file.\n"));
6485 if (do_sections
&& !do_header
)
6487 if (filedata
->is_separate
&& process_links
)
6488 printf (_("In linked file '%s': "), filedata
->file_name
);
6489 if (! filedata
->is_separate
|| process_links
)
6490 printf (ngettext ("There is %d section header, "
6491 "starting at offset 0x%lx:\n",
6492 "There are %d section headers, "
6493 "starting at offset 0x%lx:\n",
6494 filedata
->file_header
.e_shnum
),
6495 filedata
->file_header
.e_shnum
,
6496 (unsigned long) filedata
->file_header
.e_shoff
);
6499 if (!get_section_headers (filedata
, false))
6502 /* Read in the string table, so that we have names to display. */
6503 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6504 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6506 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6508 if (section
->sh_size
!= 0)
6510 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6511 1, section
->sh_size
,
6514 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6518 /* Scan the sections for the dynamic symbol table
6519 and dynamic string table and debug sections. */
6520 eh_addr_size
= is_32bit_elf
? 4 : 8;
6521 switch (filedata
->file_header
.e_machine
)
6524 case EM_MIPS_RS3_LE
:
6525 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6526 FDE addresses. However, the ABI also has a semi-official ILP32
6527 variant for which the normal FDE address size rules apply.
6529 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6530 section, where XX is the size of longs in bits. Unfortunately,
6531 earlier compilers provided no way of distinguishing ILP32 objects
6532 from LP64 objects, so if there's any doubt, we should assume that
6533 the official LP64 form is being used. */
6534 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6535 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6541 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6543 case E_H8_MACH_H8300
:
6544 case E_H8_MACH_H8300HN
:
6545 case E_H8_MACH_H8300SN
:
6546 case E_H8_MACH_H8300SXN
:
6549 case E_H8_MACH_H8300H
:
6550 case E_H8_MACH_H8300S
:
6551 case E_H8_MACH_H8300SX
:
6559 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6561 case EF_M32C_CPU_M16C
:
6568 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6571 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6572 if (section->sh_entsize != expected_entsize) \
6575 sprintf_vma (buf, section->sh_entsize); \
6576 /* Note: coded this way so that there is a single string for \
6578 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6579 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6580 (unsigned) expected_entsize); \
6581 section->sh_entsize = expected_entsize; \
6586 #define CHECK_ENTSIZE(section, i, type) \
6587 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6588 sizeof (Elf64_External_##type))
6590 for (i
= 0, section
= filedata
->section_headers
;
6591 i
< filedata
->file_header
.e_shnum
;
6594 char * name
= SECTION_NAME_PRINT (section
);
6596 /* Run some sanity checks on the headers and
6597 possibly fill in some file data as well. */
6598 switch (section
->sh_type
)
6601 if (filedata
->dynamic_symbols
!= NULL
)
6603 error (_("File contains multiple dynamic symbol tables\n"));
6607 CHECK_ENTSIZE (section
, i
, Sym
);
6608 filedata
->dynamic_symbols
6609 = get_elf_symbols (filedata
, section
, &filedata
->num_dynamic_syms
);
6610 filedata
->dynamic_symtab_section
= section
;
6614 if (streq (name
, ".dynstr"))
6616 if (filedata
->dynamic_strings
!= NULL
)
6618 error (_("File contains multiple dynamic string tables\n"));
6622 filedata
->dynamic_strings
6623 = (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6624 1, section
->sh_size
, _("dynamic strings"));
6625 filedata
->dynamic_strings_length
6626 = filedata
->dynamic_strings
== NULL
? 0 : section
->sh_size
;
6627 filedata
->dynamic_strtab_section
= section
;
6631 case SHT_SYMTAB_SHNDX
:
6633 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6635 entry
->hdr
= section
;
6636 entry
->next
= filedata
->symtab_shndx_list
;
6637 filedata
->symtab_shndx_list
= entry
;
6642 CHECK_ENTSIZE (section
, i
, Sym
);
6646 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6650 CHECK_ENTSIZE (section
, i
, Rel
);
6651 if (do_checks
&& section
->sh_size
== 0)
6652 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6656 CHECK_ENTSIZE (section
, i
, Rela
);
6657 if (do_checks
&& section
->sh_size
== 0)
6658 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6663 /* Having a zero sized section is not illegal according to the
6664 ELF standard, but it might be an indication that something
6665 is wrong. So issue a warning if we are running in lint mode. */
6666 if (do_checks
&& section
->sh_size
== 0)
6667 warn (_("Section '%s': has a size of zero - is this intended ?\n"), name
);
6674 if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6675 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6676 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6677 || do_debug_str
|| do_debug_str_offsets
|| do_debug_loc
6679 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6680 && (startswith (name
, ".debug_")
6681 || startswith (name
, ".zdebug_")))
6684 name
+= sizeof (".zdebug_") - 1;
6686 name
+= sizeof (".debug_") - 1;
6689 || (do_debug_info
&& startswith (name
, "info"))
6690 || (do_debug_info
&& startswith (name
, "types"))
6691 || (do_debug_abbrevs
&& startswith (name
, "abbrev"))
6692 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6693 || (do_debug_lines
&& startswith (name
, "line."))
6694 || (do_debug_pubnames
&& startswith (name
, "pubnames"))
6695 || (do_debug_pubtypes
&& startswith (name
, "pubtypes"))
6696 || (do_debug_pubnames
&& startswith (name
, "gnu_pubnames"))
6697 || (do_debug_pubtypes
&& startswith (name
, "gnu_pubtypes"))
6698 || (do_debug_aranges
&& startswith (name
, "aranges"))
6699 || (do_debug_ranges
&& startswith (name
, "ranges"))
6700 || (do_debug_ranges
&& startswith (name
, "rnglists"))
6701 || (do_debug_frames
&& startswith (name
, "frame"))
6702 || (do_debug_macinfo
&& startswith (name
, "macinfo"))
6703 || (do_debug_macinfo
&& startswith (name
, "macro"))
6704 || (do_debug_str
&& startswith (name
, "str"))
6705 || (do_debug_links
&& startswith (name
, "sup"))
6706 || (do_debug_str_offsets
&& startswith (name
, "str_offsets"))
6707 || (do_debug_loc
&& startswith (name
, "loc"))
6708 || (do_debug_loc
&& startswith (name
, "loclists"))
6709 || (do_debug_addr
&& startswith (name
, "addr"))
6710 || (do_debug_cu_index
&& startswith (name
, "cu_index"))
6711 || (do_debug_cu_index
&& startswith (name
, "tu_index"))
6713 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6715 /* Linkonce section to be combined with .debug_info at link time. */
6716 else if ((do_debugging
|| do_debug_info
)
6717 && startswith (name
, ".gnu.linkonce.wi."))
6718 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6719 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6720 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6721 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6722 || streq (name
, ".debug_names")))
6723 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6724 /* Trace sections for Itanium VMS. */
6725 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6726 || do_trace_aranges
)
6727 && startswith (name
, ".trace_"))
6729 name
+= sizeof (".trace_") - 1;
6732 || (do_trace_info
&& streq (name
, "info"))
6733 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6734 || (do_trace_aranges
&& streq (name
, "aranges"))
6736 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6738 else if ((do_debugging
|| do_debug_links
)
6739 && (startswith (name
, ".gnu_debuglink")
6740 || startswith (name
, ".gnu_debugaltlink")))
6741 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6747 if (filedata
->is_separate
&& ! process_links
)
6750 if (filedata
->is_separate
)
6751 printf (_("\nSection Headers in linked file '%s':\n"), filedata
->file_name
);
6752 else if (filedata
->file_header
.e_shnum
> 1)
6753 printf (_("\nSection Headers:\n"));
6755 printf (_("\nSection Header:\n"));
6759 if (do_section_details
)
6761 printf (_(" [Nr] Name\n"));
6762 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6766 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6770 if (do_section_details
)
6772 printf (_(" [Nr] Name\n"));
6773 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6777 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6781 if (do_section_details
)
6783 printf (_(" [Nr] Name\n"));
6784 printf (_(" Type Address Offset Link\n"));
6785 printf (_(" Size EntSize Info Align\n"));
6789 printf (_(" [Nr] Name Type Address Offset\n"));
6790 printf (_(" Size EntSize Flags Link Info Align\n"));
6794 if (do_section_details
)
6795 printf (_(" Flags\n"));
6797 for (i
= 0, section
= filedata
->section_headers
;
6798 i
< filedata
->file_header
.e_shnum
;
6801 /* Run some sanity checks on the section header. */
6803 /* Check the sh_link field. */
6804 switch (section
->sh_type
)
6808 if (section
->sh_link
== 0
6809 && (filedata
->file_header
.e_type
== ET_EXEC
6810 || filedata
->file_header
.e_type
== ET_DYN
))
6811 /* A dynamic relocation section where all entries use a
6812 zero symbol index need not specify a symtab section. */
6815 case SHT_SYMTAB_SHNDX
:
6819 case SHT_GNU_versym
:
6820 if (section
->sh_link
== 0
6821 || section
->sh_link
>= filedata
->file_header
.e_shnum
6822 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6823 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6824 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6825 i
, section
->sh_link
);
6831 case SHT_GNU_verneed
:
6832 case SHT_GNU_verdef
:
6833 case SHT_GNU_LIBLIST
:
6834 if (section
->sh_link
== 0
6835 || section
->sh_link
>= filedata
->file_header
.e_shnum
6836 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6837 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6838 i
, section
->sh_link
);
6841 case SHT_INIT_ARRAY
:
6842 case SHT_FINI_ARRAY
:
6843 case SHT_PREINIT_ARRAY
:
6844 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6845 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6846 i
, section
->sh_link
);
6850 /* FIXME: Add support for target specific section types. */
6851 #if 0 /* Currently we do not check other section types as there are too
6852 many special cases. Stab sections for example have a type
6853 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6855 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6856 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6857 i
, section
->sh_link
);
6862 /* Check the sh_info field. */
6863 switch (section
->sh_type
)
6867 if (section
->sh_info
== 0
6868 && (filedata
->file_header
.e_type
== ET_EXEC
6869 || filedata
->file_header
.e_type
== ET_DYN
))
6870 /* Dynamic relocations apply to segments, so they do not
6871 need to specify the section they relocate. */
6873 if (section
->sh_info
== 0
6874 || section
->sh_info
>= filedata
->file_header
.e_shnum
6875 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6876 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6877 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6878 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6879 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6880 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6881 /* FIXME: Are other section types valid ? */
6882 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6883 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6884 i
, section
->sh_info
);
6889 case SHT_SYMTAB_SHNDX
:
6890 case SHT_INIT_ARRAY
:
6891 case SHT_FINI_ARRAY
:
6892 case SHT_PREINIT_ARRAY
:
6893 if (section
->sh_info
!= 0)
6894 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6895 i
, section
->sh_info
);
6901 /* A symbol index - we assume that it is valid. */
6905 /* FIXME: Add support for target specific section types. */
6906 if (section
->sh_type
== SHT_NOBITS
)
6907 /* NOBITS section headers with non-zero sh_info fields can be
6908 created when a binary is stripped of everything but its debug
6909 information. The stripped sections have their headers
6910 preserved but their types set to SHT_NOBITS. So do not check
6911 this type of section. */
6913 else if (section
->sh_flags
& SHF_INFO_LINK
)
6915 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6916 warn (_("[%2u]: Expected link to another section in info field"), i
);
6918 else if (section
->sh_type
< SHT_LOOS
6919 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6920 && section
->sh_info
!= 0)
6921 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6922 i
, section
->sh_info
);
6926 /* Check the sh_size field. */
6927 if (section
->sh_size
> filedata
->file_size
6928 && section
->sh_type
!= SHT_NOBITS
6929 && section
->sh_type
!= SHT_NULL
6930 && section
->sh_type
< SHT_LOOS
)
6931 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6933 printf (" [%2u] ", i
);
6934 if (do_section_details
)
6935 printf ("%s\n ", printable_section_name (filedata
, section
));
6937 print_symbol (-17, SECTION_NAME_PRINT (section
));
6939 printf (do_wide
? " %-15s " : " %-15.15s ",
6940 get_section_type_name (filedata
, section
->sh_type
));
6944 const char * link_too_big
= NULL
;
6946 print_vma (section
->sh_addr
, LONG_HEX
);
6948 printf ( " %6.6lx %6.6lx %2.2lx",
6949 (unsigned long) section
->sh_offset
,
6950 (unsigned long) section
->sh_size
,
6951 (unsigned long) section
->sh_entsize
);
6953 if (do_section_details
)
6954 fputs (" ", stdout
);
6956 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6958 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6961 /* The sh_link value is out of range. Normally this indicates
6962 an error but it can have special values in Solaris binaries. */
6963 switch (filedata
->file_header
.e_machine
)
6970 case EM_OLD_SPARCV9
:
6971 case EM_SPARC32PLUS
:
6974 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6975 link_too_big
= "BEFORE";
6976 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6977 link_too_big
= "AFTER";
6984 if (do_section_details
)
6986 if (link_too_big
!= NULL
&& * link_too_big
)
6987 printf ("<%s> ", link_too_big
);
6989 printf ("%2u ", section
->sh_link
);
6990 printf ("%3u %2lu\n", section
->sh_info
,
6991 (unsigned long) section
->sh_addralign
);
6994 printf ("%2u %3u %2lu\n",
6997 (unsigned long) section
->sh_addralign
);
6999 if (link_too_big
&& ! * link_too_big
)
7000 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
7001 i
, section
->sh_link
);
7005 print_vma (section
->sh_addr
, LONG_HEX
);
7007 if ((long) section
->sh_offset
== section
->sh_offset
)
7008 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
7012 print_vma (section
->sh_offset
, LONG_HEX
);
7015 if ((unsigned long) section
->sh_size
== section
->sh_size
)
7016 printf (" %6.6lx", (unsigned long) section
->sh_size
);
7020 print_vma (section
->sh_size
, LONG_HEX
);
7023 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
7024 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
7028 print_vma (section
->sh_entsize
, LONG_HEX
);
7031 if (do_section_details
)
7032 fputs (" ", stdout
);
7034 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
7036 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
7038 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
7039 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
7042 print_vma (section
->sh_addralign
, DEC
);
7046 else if (do_section_details
)
7049 print_vma (section
->sh_addr
, LONG_HEX
);
7050 if ((long) section
->sh_offset
== section
->sh_offset
)
7051 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
7055 print_vma (section
->sh_offset
, LONG_HEX
);
7057 printf (" %u\n ", section
->sh_link
);
7058 print_vma (section
->sh_size
, LONG_HEX
);
7060 print_vma (section
->sh_entsize
, LONG_HEX
);
7062 printf (" %-16u %lu\n",
7064 (unsigned long) section
->sh_addralign
);
7069 print_vma (section
->sh_addr
, LONG_HEX
);
7070 if ((long) section
->sh_offset
== section
->sh_offset
)
7071 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
7075 print_vma (section
->sh_offset
, LONG_HEX
);
7078 print_vma (section
->sh_size
, LONG_HEX
);
7080 print_vma (section
->sh_entsize
, LONG_HEX
);
7082 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
7084 printf (" %2u %3u %lu\n",
7087 (unsigned long) section
->sh_addralign
);
7090 if (do_section_details
)
7092 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
7093 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
7095 /* Minimum section size is 12 bytes for 32-bit compression
7096 header + 12 bytes for compressed data header. */
7097 unsigned char buf
[24];
7099 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
7100 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
7101 sizeof (buf
), _("compression header")))
7103 Elf_Internal_Chdr chdr
;
7105 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
7106 printf (_(" [<corrupt>]\n"));
7109 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
7112 printf (_(" [<unknown>: 0x%x], "),
7114 print_vma (chdr
.ch_size
, LONG_HEX
);
7115 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
7122 if (!do_section_details
)
7124 /* The ordering of the letters shown here matches the ordering of the
7125 corresponding SHF_xxx values, and hence the order in which these
7126 letters will be displayed to the user. */
7127 printf (_("Key to Flags:\n\
7128 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
7129 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
7130 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
7131 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
7134 case ELFOSABI_FREEBSD
:
7135 printf (_("R (retain), "));
7138 printf (_("D (mbind), "));
7143 if (filedata
->file_header
.e_machine
== EM_X86_64
7144 || filedata
->file_header
.e_machine
== EM_L1OM
7145 || filedata
->file_header
.e_machine
== EM_K1OM
)
7146 printf (_("l (large), "));
7147 else if (filedata
->file_header
.e_machine
== EM_ARM
)
7148 printf (_("y (purecode), "));
7149 else if (filedata
->file_header
.e_machine
== EM_PPC
)
7150 printf (_("v (VLE), "));
7151 printf ("p (processor specific)\n");
7158 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
7159 Elf_Internal_Sym
**symtab
, unsigned long *nsyms
,
7160 char **strtab
, unsigned long *strtablen
)
7164 *symtab
= get_elf_symbols (filedata
, symsec
, nsyms
);
7166 if (*symtab
== NULL
)
7169 if (symsec
->sh_link
!= 0)
7171 Elf_Internal_Shdr
*strsec
;
7173 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
7175 error (_("Bad sh_link in symbol table section\n"));
7182 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7184 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7185 1, strsec
->sh_size
, _("string table"));
7186 if (*strtab
== NULL
)
7193 *strtablen
= strsec
->sh_size
;
7199 get_group_flags (unsigned int flags
)
7201 static char buff
[128];
7205 else if (flags
== GRP_COMDAT
)
7208 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
7210 flags
& GRP_MASKOS
? _("<OS specific>") : "",
7211 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
7212 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
7213 ? _("<unknown>") : ""));
7219 process_section_groups (Filedata
* filedata
)
7221 Elf_Internal_Shdr
* section
;
7223 struct group
* group
;
7224 Elf_Internal_Shdr
* symtab_sec
;
7225 Elf_Internal_Shdr
* strtab_sec
;
7226 Elf_Internal_Sym
* symtab
;
7227 unsigned long num_syms
;
7231 /* Don't process section groups unless needed. */
7232 if (!do_unwind
&& !do_section_groups
)
7235 if (filedata
->file_header
.e_shnum
== 0)
7237 if (do_section_groups
)
7239 if (filedata
->is_separate
)
7240 printf (_("\nThere are no sections group in linked file '%s'.\n"),
7241 filedata
->file_name
);
7243 printf (_("\nThere are no section groups in this file.\n"));
7248 if (filedata
->section_headers
== NULL
)
7250 error (_("Section headers are not available!\n"));
7251 /* PR 13622: This can happen with a corrupt ELF header. */
7255 filedata
->section_headers_groups
7256 = (struct group
**) calloc (filedata
->file_header
.e_shnum
,
7257 sizeof (struct group
*));
7259 if (filedata
->section_headers_groups
== NULL
)
7261 error (_("Out of memory reading %u section group headers\n"),
7262 filedata
->file_header
.e_shnum
);
7266 /* Scan the sections for the group section. */
7267 filedata
->group_count
= 0;
7268 for (i
= 0, section
= filedata
->section_headers
;
7269 i
< filedata
->file_header
.e_shnum
;
7271 if (section
->sh_type
== SHT_GROUP
)
7272 filedata
->group_count
++;
7274 if (filedata
->group_count
== 0)
7276 if (do_section_groups
)
7278 if (filedata
->is_separate
)
7279 printf (_("\nThere are no section groups in linked file '%s'.\n"),
7280 filedata
->file_name
);
7282 printf (_("\nThere are no section groups in this file.\n"));
7288 filedata
->section_groups
= (struct group
*) calloc (filedata
->group_count
,
7289 sizeof (struct group
));
7291 if (filedata
->section_groups
== NULL
)
7293 error (_("Out of memory reading %lu groups\n"),
7294 (unsigned long) filedata
->group_count
);
7305 if (filedata
->is_separate
)
7306 printf (_("Section groups in linked file '%s'\n"), filedata
->file_name
);
7308 for (i
= 0, section
= filedata
->section_headers
, group
= filedata
->section_groups
;
7309 i
< filedata
->file_header
.e_shnum
;
7312 if (section
->sh_type
== SHT_GROUP
)
7314 const char * name
= printable_section_name (filedata
, section
);
7315 const char * group_name
;
7316 unsigned char * start
;
7317 unsigned char * indices
;
7318 unsigned int entry
, j
, size
;
7319 Elf_Internal_Shdr
* sec
;
7320 Elf_Internal_Sym
* sym
;
7322 /* Get the symbol table. */
7323 if (section
->sh_link
>= filedata
->file_header
.e_shnum
7324 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
7327 error (_("Bad sh_link in group section `%s'\n"), name
);
7331 if (symtab_sec
!= sec
)
7335 symtab
= get_elf_symbols (filedata
, symtab_sec
, & num_syms
);
7340 error (_("Corrupt header in group section `%s'\n"), name
);
7344 if (section
->sh_info
>= num_syms
)
7346 error (_("Bad sh_info in group section `%s'\n"), name
);
7350 sym
= symtab
+ section
->sh_info
;
7352 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
7354 if (sym
->st_shndx
== 0
7355 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
7357 error (_("Bad sh_info in group section `%s'\n"), name
);
7361 group_name
= SECTION_NAME_PRINT (filedata
->section_headers
7370 /* Get the string table. */
7371 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
7379 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
7384 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
7385 1, strtab_sec
->sh_size
,
7387 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
7389 group_name
= sym
->st_name
< strtab_size
7390 ? strtab
+ sym
->st_name
: _("<corrupt>");
7393 /* PR 17531: file: loop. */
7394 if (section
->sh_entsize
> section
->sh_size
)
7396 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7397 printable_section_name (filedata
, section
),
7398 (unsigned long) section
->sh_entsize
,
7399 (unsigned long) section
->sh_size
);
7403 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
7404 1, section
->sh_size
,
7410 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
7411 entry
= byte_get (indices
, 4);
7414 if (do_section_groups
)
7416 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7417 get_group_flags (entry
), i
, name
, group_name
, size
);
7419 printf (_(" [Index] Name\n"));
7422 group
->group_index
= i
;
7424 for (j
= 0; j
< size
; j
++)
7426 struct group_list
* g
;
7428 entry
= byte_get (indices
, 4);
7431 if (entry
>= filedata
->file_header
.e_shnum
)
7433 static unsigned num_group_errors
= 0;
7435 if (num_group_errors
++ < 10)
7437 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7438 entry
, i
, filedata
->file_header
.e_shnum
- 1);
7439 if (num_group_errors
== 10)
7440 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7445 if (filedata
->section_headers_groups
[entry
] != NULL
)
7449 static unsigned num_errs
= 0;
7451 if (num_errs
++ < 10)
7453 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7455 filedata
->section_headers_groups
[entry
]->group_index
);
7457 warn (_("Further error messages about already contained group sections suppressed\n"));
7463 /* Intel C/C++ compiler may put section 0 in a
7464 section group. We just warn it the first time
7465 and ignore it afterwards. */
7466 static bool warned
= false;
7469 error (_("section 0 in group section [%5u]\n"),
7470 filedata
->section_headers_groups
[entry
]->group_index
);
7476 filedata
->section_headers_groups
[entry
] = group
;
7478 if (do_section_groups
)
7480 sec
= filedata
->section_headers
+ entry
;
7481 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7484 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7485 g
->section_index
= entry
;
7486 g
->next
= group
->root
;
7501 /* Data used to display dynamic fixups. */
7503 struct ia64_vms_dynfixup
7505 bfd_vma needed_ident
; /* Library ident number. */
7506 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7507 bfd_vma fixup_needed
; /* Index of the library. */
7508 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7509 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7512 /* Data used to display dynamic relocations. */
7514 struct ia64_vms_dynimgrela
7516 bfd_vma img_rela_cnt
; /* Number of relocations. */
7517 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7520 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7524 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7525 struct ia64_vms_dynfixup
* fixup
,
7526 const char * strtab
,
7527 unsigned int strtab_sz
)
7529 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7531 const char * lib_name
;
7533 imfs
= get_data (NULL
, filedata
,
7534 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
7535 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
7536 _("dynamic section image fixups"));
7540 if (fixup
->needed
< strtab_sz
)
7541 lib_name
= strtab
+ fixup
->needed
;
7544 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7545 (unsigned long) fixup
->needed
);
7549 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7550 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7552 (_("Seg Offset Type SymVec DataType\n"));
7554 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7559 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7560 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7561 type
= BYTE_GET (imfs
[i
].type
);
7562 rtype
= elf_ia64_reloc_type (type
);
7564 printf (" 0x%08x ", type
);
7566 printf (" %-32s ", rtype
);
7567 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7568 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7575 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7578 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7580 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7583 imrs
= get_data (NULL
, filedata
,
7584 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
7585 sizeof (*imrs
), imgrela
->img_rela_cnt
,
7586 _("dynamic section image relocations"));
7590 printf (_("\nImage relocs\n"));
7592 (_("Seg Offset Type Addend Seg Sym Off\n"));
7594 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7599 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7600 printf ("%08" BFD_VMA_FMT
"x ",
7601 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7602 type
= BYTE_GET (imrs
[i
].type
);
7603 rtype
= elf_ia64_reloc_type (type
);
7605 printf ("0x%08x ", type
);
7607 printf ("%-31s ", rtype
);
7608 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7609 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7610 printf ("%08" BFD_VMA_FMT
"x\n",
7611 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7618 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7621 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7623 struct ia64_vms_dynfixup fixup
;
7624 struct ia64_vms_dynimgrela imgrela
;
7625 Elf_Internal_Dyn
*entry
;
7626 bfd_vma strtab_off
= 0;
7627 bfd_vma strtab_sz
= 0;
7628 char *strtab
= NULL
;
7631 memset (&fixup
, 0, sizeof (fixup
));
7632 memset (&imgrela
, 0, sizeof (imgrela
));
7634 /* Note: the order of the entries is specified by the OpenVMS specs. */
7635 for (entry
= filedata
->dynamic_section
;
7636 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
7639 switch (entry
->d_tag
)
7641 case DT_IA_64_VMS_STRTAB_OFFSET
:
7642 strtab_off
= entry
->d_un
.d_val
;
7645 strtab_sz
= entry
->d_un
.d_val
;
7647 strtab
= get_data (NULL
, filedata
,
7648 filedata
->dynamic_addr
+ strtab_off
,
7649 1, strtab_sz
, _("dynamic string section"));
7654 case DT_IA_64_VMS_NEEDED_IDENT
:
7655 fixup
.needed_ident
= entry
->d_un
.d_val
;
7658 fixup
.needed
= entry
->d_un
.d_val
;
7660 case DT_IA_64_VMS_FIXUP_NEEDED
:
7661 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7663 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7664 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7666 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7667 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7668 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7671 case DT_IA_64_VMS_IMG_RELA_CNT
:
7672 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7674 case DT_IA_64_VMS_IMG_RELA_OFF
:
7675 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7676 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7697 dynamic_relocations
[] =
7699 { "REL", DT_REL
, DT_RELSZ
, false },
7700 { "RELA", DT_RELA
, DT_RELASZ
, true },
7701 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7704 /* Process the reloc section. */
7707 process_relocs (Filedata
* filedata
)
7709 unsigned long rel_size
;
7710 unsigned long rel_offset
;
7715 if (do_using_dynamic
)
7719 bool has_dynamic_reloc
;
7722 has_dynamic_reloc
= false;
7724 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7726 is_rela
= dynamic_relocations
[i
].rela
;
7727 name
= dynamic_relocations
[i
].name
;
7728 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
7729 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
7732 has_dynamic_reloc
= true;
7734 if (is_rela
== UNKNOWN
)
7736 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7737 switch (filedata
->dynamic_info
[DT_PLTREL
])
7750 if (filedata
->is_separate
)
7752 (_("\nIn linked file '%s' section '%s' at offset 0x%lx contains %ld bytes:\n"),
7753 filedata
->file_name
, name
, rel_offset
, rel_size
);
7756 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7757 name
, rel_offset
, rel_size
);
7759 dump_relocations (filedata
,
7760 offset_from_vma (filedata
, rel_offset
, rel_size
),
7762 filedata
->dynamic_symbols
,
7763 filedata
->num_dynamic_syms
,
7764 filedata
->dynamic_strings
,
7765 filedata
->dynamic_strings_length
,
7766 is_rela
, true /* is_dynamic */);
7770 if (is_ia64_vms (filedata
))
7771 if (process_ia64_vms_dynamic_relocs (filedata
))
7772 has_dynamic_reloc
= true;
7774 if (! has_dynamic_reloc
)
7776 if (filedata
->is_separate
)
7777 printf (_("\nThere are no dynamic relocations in linked file '%s'.\n"),
7778 filedata
->file_name
);
7780 printf (_("\nThere are no dynamic relocations in this file.\n"));
7785 Elf_Internal_Shdr
* section
;
7789 for (i
= 0, section
= filedata
->section_headers
;
7790 i
< filedata
->file_header
.e_shnum
;
7793 if ( section
->sh_type
!= SHT_RELA
7794 && section
->sh_type
!= SHT_REL
)
7797 rel_offset
= section
->sh_offset
;
7798 rel_size
= section
->sh_size
;
7803 unsigned long num_rela
;
7805 if (filedata
->is_separate
)
7806 printf (_("\nIn linked file '%s' relocation section "),
7807 filedata
->file_name
);
7809 printf (_("\nRelocation section "));
7811 if (filedata
->string_table
== NULL
)
7812 printf ("%d", section
->sh_name
);
7814 printf ("'%s'", printable_section_name (filedata
, section
));
7816 num_rela
= rel_size
/ section
->sh_entsize
;
7817 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7818 " at offset 0x%lx contains %lu entries:\n",
7820 rel_offset
, num_rela
);
7822 is_rela
= section
->sh_type
== SHT_RELA
;
7824 if (section
->sh_link
!= 0
7825 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7827 Elf_Internal_Shdr
* symsec
;
7828 Elf_Internal_Sym
* symtab
;
7829 unsigned long nsyms
;
7830 unsigned long strtablen
= 0;
7831 char * strtab
= NULL
;
7833 symsec
= filedata
->section_headers
+ section
->sh_link
;
7834 if (symsec
->sh_type
!= SHT_SYMTAB
7835 && symsec
->sh_type
!= SHT_DYNSYM
)
7838 if (!get_symtab (filedata
, symsec
,
7839 &symtab
, &nsyms
, &strtab
, &strtablen
))
7842 dump_relocations (filedata
, rel_offset
, rel_size
,
7843 symtab
, nsyms
, strtab
, strtablen
,
7845 symsec
->sh_type
== SHT_DYNSYM
);
7850 dump_relocations (filedata
, rel_offset
, rel_size
,
7851 NULL
, 0, NULL
, 0, is_rela
,
7852 false /* is_dynamic */);
7860 /* Users sometimes forget the -D option, so try to be helpful. */
7861 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7863 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
7865 if (filedata
->is_separate
)
7866 printf (_("\nThere are no static relocations in linked file '%s'."),
7867 filedata
->file_name
);
7869 printf (_("\nThere are no static relocations in this file."));
7870 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7875 if (i
== ARRAY_SIZE (dynamic_relocations
))
7877 if (filedata
->is_separate
)
7878 printf (_("\nThere are no relocations in linked file '%s'.\n"),
7879 filedata
->file_name
);
7881 printf (_("\nThere are no relocations in this file.\n"));
7889 /* An absolute address consists of a section and an offset. If the
7890 section is NULL, the offset itself is the address, otherwise, the
7891 address equals to LOAD_ADDRESS(section) + offset. */
7895 unsigned short section
;
7899 /* Find the nearest symbol at or below ADDR. Returns the symbol
7900 name, if found, and the offset from the symbol to ADDR. */
7903 find_symbol_for_address (Filedata
* filedata
,
7904 Elf_Internal_Sym
* symtab
,
7905 unsigned long nsyms
,
7906 const char * strtab
,
7907 unsigned long strtab_size
,
7908 struct absaddr addr
,
7909 const char ** symname
,
7912 bfd_vma dist
= 0x100000;
7913 Elf_Internal_Sym
* sym
;
7914 Elf_Internal_Sym
* beg
;
7915 Elf_Internal_Sym
* end
;
7916 Elf_Internal_Sym
* best
= NULL
;
7918 REMOVE_ARCH_BITS (addr
.offset
);
7920 end
= symtab
+ nsyms
;
7926 sym
= beg
+ (end
- beg
) / 2;
7928 value
= sym
->st_value
;
7929 REMOVE_ARCH_BITS (value
);
7931 if (sym
->st_name
!= 0
7932 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7933 && addr
.offset
>= value
7934 && addr
.offset
- value
< dist
)
7937 dist
= addr
.offset
- value
;
7942 if (addr
.offset
< value
)
7950 *symname
= (best
->st_name
>= strtab_size
7951 ? _("<corrupt>") : strtab
+ best
->st_name
);
7957 *offset
= addr
.offset
;
7960 static /* signed */ int
7961 symcmp (const void *p
, const void *q
)
7963 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7964 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7966 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7969 /* Process the unwind section. */
7971 #include "unwind-ia64.h"
7973 struct ia64_unw_table_entry
7975 struct absaddr start
;
7977 struct absaddr info
;
7980 struct ia64_unw_aux_info
7982 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7983 unsigned long table_len
; /* Length of unwind table. */
7984 unsigned char * info
; /* Unwind info. */
7985 unsigned long info_size
; /* Size of unwind info. */
7986 bfd_vma info_addr
; /* Starting address of unwind info. */
7987 bfd_vma seg_base
; /* Starting address of segment. */
7988 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7989 unsigned long nsyms
; /* Number of symbols. */
7990 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7991 unsigned long nfuns
; /* Number of entries in funtab. */
7992 char * strtab
; /* The string table. */
7993 unsigned long strtab_size
; /* Size of string table. */
7997 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7999 struct ia64_unw_table_entry
* tp
;
8000 unsigned long j
, nfuns
;
8004 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8005 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8006 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8007 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8009 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8011 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8015 const unsigned char * dp
;
8016 const unsigned char * head
;
8017 const unsigned char * end
;
8018 const char * procname
;
8020 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8021 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
8023 fputs ("\n<", stdout
);
8027 fputs (procname
, stdout
);
8030 printf ("+%lx", (unsigned long) offset
);
8033 fputs (">: [", stdout
);
8034 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8035 fputc ('-', stdout
);
8036 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8037 printf ("], info at +0x%lx\n",
8038 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
8040 /* PR 17531: file: 86232b32. */
8041 if (aux
->info
== NULL
)
8044 offset
= tp
->info
.offset
;
8045 if (tp
->info
.section
)
8047 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
8049 warn (_("Invalid section %u in table entry %ld\n"),
8050 tp
->info
.section
, (long) (tp
- aux
->table
));
8054 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
8056 offset
-= aux
->info_addr
;
8057 /* PR 17531: file: 0997b4d1. */
8058 if (offset
>= aux
->info_size
8059 || aux
->info_size
- offset
< 8)
8061 warn (_("Invalid offset %lx in table entry %ld\n"),
8062 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
8067 head
= aux
->info
+ offset
;
8068 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
8070 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
8071 (unsigned) UNW_VER (stamp
),
8072 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
8073 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
8074 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
8075 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
8077 if (UNW_VER (stamp
) != 1)
8079 printf (_("\tUnknown version.\n"));
8084 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
8085 /* PR 17531: file: 16ceda89. */
8086 if (end
> aux
->info
+ aux
->info_size
)
8087 end
= aux
->info
+ aux
->info_size
;
8088 for (dp
= head
+ 8; dp
< end
;)
8089 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
8098 slurp_ia64_unwind_table (Filedata
* filedata
,
8099 struct ia64_unw_aux_info
* aux
,
8100 Elf_Internal_Shdr
* sec
)
8102 unsigned long size
, nrelas
, i
;
8103 Elf_Internal_Phdr
* seg
;
8104 struct ia64_unw_table_entry
* tep
;
8105 Elf_Internal_Shdr
* relsec
;
8106 Elf_Internal_Rela
* rela
;
8107 Elf_Internal_Rela
* rp
;
8108 unsigned char * table
;
8110 Elf_Internal_Sym
* sym
;
8111 const char * relname
;
8115 /* First, find the starting address of the segment that includes
8118 if (filedata
->file_header
.e_phnum
)
8120 if (! get_program_headers (filedata
))
8123 for (seg
= filedata
->program_headers
;
8124 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8127 if (seg
->p_type
!= PT_LOAD
)
8130 if (sec
->sh_addr
>= seg
->p_vaddr
8131 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8133 aux
->seg_base
= seg
->p_vaddr
;
8139 /* Second, build the unwind table from the contents of the unwind section: */
8140 size
= sec
->sh_size
;
8141 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8146 aux
->table_len
= size
/ (3 * eh_addr_size
);
8147 aux
->table
= (struct ia64_unw_table_entry
*)
8148 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
8151 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
8153 tep
->start
.section
= SHN_UNDEF
;
8154 tep
->end
.section
= SHN_UNDEF
;
8155 tep
->info
.section
= SHN_UNDEF
;
8156 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8157 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8158 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8159 tep
->start
.offset
+= aux
->seg_base
;
8160 tep
->end
.offset
+= aux
->seg_base
;
8161 tep
->info
.offset
+= aux
->seg_base
;
8165 /* Third, apply any relocations to the unwind table: */
8166 for (relsec
= filedata
->section_headers
;
8167 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8170 if (relsec
->sh_type
!= SHT_RELA
8171 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8172 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8175 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8184 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8186 unsigned int sym_ndx
;
8187 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8188 relname
= elf_ia64_reloc_type (r_type
);
8190 /* PR 17531: file: 9fa67536. */
8191 if (relname
== NULL
)
8193 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8197 if (! startswith (relname
, "R_IA64_SEGREL"))
8199 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8203 i
= rp
->r_offset
/ (3 * eh_addr_size
);
8205 /* PR 17531: file: 5bc8d9bf. */
8206 if (i
>= aux
->table_len
)
8208 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8212 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8213 if (sym_ndx
>= aux
->nsyms
)
8215 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8219 sym
= aux
->symtab
+ sym_ndx
;
8221 switch (rp
->r_offset
/ eh_addr_size
% 3)
8224 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8225 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
8228 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8229 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
8232 aux
->table
[i
].info
.section
= sym
->st_shndx
;
8233 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
8247 ia64_process_unwind (Filedata
* filedata
)
8249 Elf_Internal_Shdr
* sec
;
8250 Elf_Internal_Shdr
* unwsec
= NULL
;
8251 unsigned long i
, unwcount
= 0, unwstart
= 0;
8252 struct ia64_unw_aux_info aux
;
8255 memset (& aux
, 0, sizeof (aux
));
8257 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8259 if (sec
->sh_type
== SHT_SYMTAB
)
8263 error (_("Multiple symbol tables encountered\n"));
8269 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8270 &aux
.strtab
, &aux
.strtab_size
))
8273 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8278 printf (_("\nThere are no unwind sections in this file.\n"));
8280 while (unwcount
-- > 0)
8285 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
8286 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8287 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8292 /* We have already counted the number of SHT_IA64_UNWIND
8293 sections so the loop above should never fail. */
8294 assert (unwsec
!= NULL
);
8297 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
8299 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
8301 /* We need to find which section group it is in. */
8302 struct group_list
* g
;
8304 if (filedata
->section_headers_groups
== NULL
8305 || filedata
->section_headers_groups
[i
] == NULL
)
8306 i
= filedata
->file_header
.e_shnum
;
8309 g
= filedata
->section_headers_groups
[i
]->root
;
8311 for (; g
!= NULL
; g
= g
->next
)
8313 sec
= filedata
->section_headers
+ g
->section_index
;
8315 if (SECTION_NAME_VALID (sec
)
8316 && streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
8321 i
= filedata
->file_header
.e_shnum
;
8324 else if (SECTION_NAME_VALID (unwsec
)
8325 && startswith (SECTION_NAME (unwsec
),
8326 ELF_STRING_ia64_unwind_once
))
8328 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
8329 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
8330 suffix
= SECTION_NAME (unwsec
) + len
;
8331 for (i
= 0, sec
= filedata
->section_headers
;
8332 i
< filedata
->file_header
.e_shnum
;
8334 if (SECTION_NAME_VALID (sec
)
8335 && startswith (SECTION_NAME (sec
),
8336 ELF_STRING_ia64_unwind_info_once
)
8337 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8342 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
8343 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
8344 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
8345 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
8347 if (SECTION_NAME_VALID (unwsec
)
8348 && startswith (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
))
8349 suffix
= SECTION_NAME (unwsec
) + len
;
8350 for (i
= 0, sec
= filedata
->section_headers
;
8351 i
< filedata
->file_header
.e_shnum
;
8353 if (SECTION_NAME_VALID (sec
)
8354 && startswith (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
)
8355 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8359 if (i
== filedata
->file_header
.e_shnum
)
8361 printf (_("\nCould not find unwind info section for "));
8363 if (filedata
->string_table
== NULL
)
8364 printf ("%d", unwsec
->sh_name
);
8366 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8370 aux
.info_addr
= sec
->sh_addr
;
8371 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
8374 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
8376 printf (_("\nUnwind section "));
8378 if (filedata
->string_table
== NULL
)
8379 printf ("%d", unwsec
->sh_name
);
8381 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8383 printf (_(" at offset 0x%lx contains %lu entries:\n"),
8384 (unsigned long) unwsec
->sh_offset
,
8385 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
8387 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
8388 && aux
.table_len
> 0)
8389 dump_ia64_unwind (filedata
, & aux
);
8391 free ((char *) aux
.table
);
8392 free ((char *) aux
.info
);
8399 free ((char *) aux
.strtab
);
8404 struct hppa_unw_table_entry
8406 struct absaddr start
;
8408 unsigned int Cannot_unwind
:1; /* 0 */
8409 unsigned int Millicode
:1; /* 1 */
8410 unsigned int Millicode_save_sr0
:1; /* 2 */
8411 unsigned int Region_description
:2; /* 3..4 */
8412 unsigned int reserved1
:1; /* 5 */
8413 unsigned int Entry_SR
:1; /* 6 */
8414 unsigned int Entry_FR
:4; /* Number saved 7..10 */
8415 unsigned int Entry_GR
:5; /* Number saved 11..15 */
8416 unsigned int Args_stored
:1; /* 16 */
8417 unsigned int Variable_Frame
:1; /* 17 */
8418 unsigned int Separate_Package_Body
:1; /* 18 */
8419 unsigned int Frame_Extension_Millicode
:1; /* 19 */
8420 unsigned int Stack_Overflow_Check
:1; /* 20 */
8421 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
8422 unsigned int Ada_Region
:1; /* 22 */
8423 unsigned int cxx_info
:1; /* 23 */
8424 unsigned int cxx_try_catch
:1; /* 24 */
8425 unsigned int sched_entry_seq
:1; /* 25 */
8426 unsigned int reserved2
:1; /* 26 */
8427 unsigned int Save_SP
:1; /* 27 */
8428 unsigned int Save_RP
:1; /* 28 */
8429 unsigned int Save_MRP_in_frame
:1; /* 29 */
8430 unsigned int extn_ptr_defined
:1; /* 30 */
8431 unsigned int Cleanup_defined
:1; /* 31 */
8433 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
8434 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
8435 unsigned int Large_frame
:1; /* 2 */
8436 unsigned int Pseudo_SP_Set
:1; /* 3 */
8437 unsigned int reserved4
:1; /* 4 */
8438 unsigned int Total_frame_size
:27; /* 5..31 */
8441 struct hppa_unw_aux_info
8443 struct hppa_unw_table_entry
* table
; /* Unwind table. */
8444 unsigned long table_len
; /* Length of unwind table. */
8445 bfd_vma seg_base
; /* Starting address of segment. */
8446 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8447 unsigned long nsyms
; /* Number of symbols. */
8448 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8449 unsigned long nfuns
; /* Number of entries in funtab. */
8450 char * strtab
; /* The string table. */
8451 unsigned long strtab_size
; /* Size of string table. */
8455 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8457 struct hppa_unw_table_entry
* tp
;
8458 unsigned long j
, nfuns
;
8461 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8462 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8463 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8464 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8466 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8468 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8471 const char * procname
;
8473 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8474 aux
->strtab_size
, tp
->start
, &procname
,
8477 fputs ("\n<", stdout
);
8481 fputs (procname
, stdout
);
8484 printf ("+%lx", (unsigned long) offset
);
8487 fputs (">: [", stdout
);
8488 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8489 fputc ('-', stdout
);
8490 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8493 #define PF(_m) if (tp->_m) printf (#_m " ");
8494 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8497 PF(Millicode_save_sr0
);
8498 /* PV(Region_description); */
8504 PF(Separate_Package_Body
);
8505 PF(Frame_Extension_Millicode
);
8506 PF(Stack_Overflow_Check
);
8507 PF(Two_Instruction_SP_Increment
);
8511 PF(sched_entry_seq
);
8514 PF(Save_MRP_in_frame
);
8515 PF(extn_ptr_defined
);
8516 PF(Cleanup_defined
);
8517 PF(MPE_XL_interrupt_marker
);
8518 PF(HP_UX_interrupt_marker
);
8521 PV(Total_frame_size
);
8534 slurp_hppa_unwind_table (Filedata
* filedata
,
8535 struct hppa_unw_aux_info
* aux
,
8536 Elf_Internal_Shdr
* sec
)
8538 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8539 Elf_Internal_Phdr
* seg
;
8540 struct hppa_unw_table_entry
* tep
;
8541 Elf_Internal_Shdr
* relsec
;
8542 Elf_Internal_Rela
* rela
;
8543 Elf_Internal_Rela
* rp
;
8544 unsigned char * table
;
8546 Elf_Internal_Sym
* sym
;
8547 const char * relname
;
8549 /* First, find the starting address of the segment that includes
8551 if (filedata
->file_header
.e_phnum
)
8553 if (! get_program_headers (filedata
))
8556 for (seg
= filedata
->program_headers
;
8557 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8560 if (seg
->p_type
!= PT_LOAD
)
8563 if (sec
->sh_addr
>= seg
->p_vaddr
8564 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8566 aux
->seg_base
= seg
->p_vaddr
;
8572 /* Second, build the unwind table from the contents of the unwind
8574 size
= sec
->sh_size
;
8575 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8581 nentries
= size
/ unw_ent_size
;
8582 size
= unw_ent_size
* nentries
;
8584 aux
->table_len
= nentries
;
8585 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8586 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8588 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8590 unsigned int tmp1
, tmp2
;
8592 tep
->start
.section
= SHN_UNDEF
;
8593 tep
->end
.section
= SHN_UNDEF
;
8595 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8596 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8597 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8598 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8600 tep
->start
.offset
+= aux
->seg_base
;
8601 tep
->end
.offset
+= aux
->seg_base
;
8603 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8604 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8605 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8606 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8607 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8608 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8609 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8610 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8611 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8612 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8613 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8614 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8615 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8616 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8617 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8618 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8619 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8620 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8621 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8622 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8623 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8624 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8625 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8626 tep
->Cleanup_defined
= tmp1
& 0x1;
8628 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8629 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8630 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8631 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8632 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8633 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8637 /* Third, apply any relocations to the unwind table. */
8638 for (relsec
= filedata
->section_headers
;
8639 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8642 if (relsec
->sh_type
!= SHT_RELA
8643 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8644 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8647 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8651 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8653 unsigned int sym_ndx
;
8654 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8655 relname
= elf_hppa_reloc_type (r_type
);
8657 if (relname
== NULL
)
8659 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8663 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8664 if (! startswith (relname
, "R_PARISC_SEGREL"))
8666 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8670 i
= rp
->r_offset
/ unw_ent_size
;
8671 if (i
>= aux
->table_len
)
8673 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8677 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8678 if (sym_ndx
>= aux
->nsyms
)
8680 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8684 sym
= aux
->symtab
+ sym_ndx
;
8686 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8689 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8690 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8693 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8694 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8708 hppa_process_unwind (Filedata
* filedata
)
8710 struct hppa_unw_aux_info aux
;
8711 Elf_Internal_Shdr
* unwsec
= NULL
;
8712 Elf_Internal_Shdr
* sec
;
8716 if (filedata
->string_table
== NULL
)
8719 memset (& aux
, 0, sizeof (aux
));
8721 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8723 if (sec
->sh_type
== SHT_SYMTAB
)
8727 error (_("Multiple symbol tables encountered\n"));
8733 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8734 &aux
.strtab
, &aux
.strtab_size
))
8737 else if (SECTION_NAME_VALID (sec
)
8738 && streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8743 printf (_("\nThere are no unwind sections in this file.\n"));
8745 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8747 if (SECTION_NAME_VALID (sec
)
8748 && streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8750 unsigned long num_unwind
= sec
->sh_size
/ 16;
8752 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8753 "contains %lu entry:\n",
8754 "\nUnwind section '%s' at offset 0x%lx "
8755 "contains %lu entries:\n",
8757 printable_section_name (filedata
, sec
),
8758 (unsigned long) sec
->sh_offset
,
8761 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8764 if (res
&& aux
.table_len
> 0)
8766 if (! dump_hppa_unwind (filedata
, &aux
))
8770 free ((char *) aux
.table
);
8776 free ((char *) aux
.strtab
);
8783 unsigned char * data
; /* The unwind data. */
8784 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8785 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8786 unsigned long nrelas
; /* The number of relocations. */
8787 unsigned int rel_type
; /* REL or RELA ? */
8788 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8791 struct arm_unw_aux_info
8793 Filedata
* filedata
; /* The file containing the unwind sections. */
8794 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8795 unsigned long nsyms
; /* Number of symbols. */
8796 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8797 unsigned long nfuns
; /* Number of these symbols. */
8798 char * strtab
; /* The file's string table. */
8799 unsigned long strtab_size
; /* Size of string table. */
8803 arm_print_vma_and_name (Filedata
* filedata
,
8804 struct arm_unw_aux_info
* aux
,
8806 struct absaddr addr
)
8808 const char *procname
;
8811 if (addr
.section
== SHN_UNDEF
)
8814 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8815 aux
->strtab_size
, addr
, &procname
,
8818 print_vma (fn
, PREFIX_HEX
);
8822 fputs (" <", stdout
);
8823 fputs (procname
, stdout
);
8826 printf ("+0x%lx", (unsigned long) sym_offset
);
8827 fputc ('>', stdout
);
8834 arm_free_section (struct arm_section
*arm_sec
)
8836 free (arm_sec
->data
);
8837 free (arm_sec
->rela
);
8840 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8841 cached section and install SEC instead.
8842 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8843 and return its valued in * WORDP, relocating if necessary.
8844 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8845 relocation's offset in ADDR.
8846 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8847 into the string table of the symbol associated with the reloc. If no
8848 reloc was applied store -1 there.
8849 5) Return TRUE upon success, FALSE otherwise. */
8852 get_unwind_section_word (Filedata
* filedata
,
8853 struct arm_unw_aux_info
* aux
,
8854 struct arm_section
* arm_sec
,
8855 Elf_Internal_Shdr
* sec
,
8856 bfd_vma word_offset
,
8857 unsigned int * wordp
,
8858 struct absaddr
* addr
,
8861 Elf_Internal_Rela
*rp
;
8862 Elf_Internal_Sym
*sym
;
8863 const char * relname
;
8867 if (sec
== NULL
|| arm_sec
== NULL
)
8870 addr
->section
= SHN_UNDEF
;
8873 if (sym_name
!= NULL
)
8874 *sym_name
= (bfd_vma
) -1;
8876 /* If necessary, update the section cache. */
8877 if (sec
!= arm_sec
->sec
)
8879 Elf_Internal_Shdr
*relsec
;
8881 arm_free_section (arm_sec
);
8884 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8885 sec
->sh_size
, _("unwind data"));
8886 arm_sec
->rela
= NULL
;
8887 arm_sec
->nrelas
= 0;
8889 for (relsec
= filedata
->section_headers
;
8890 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8893 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8894 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8895 /* PR 15745: Check the section type as well. */
8896 || (relsec
->sh_type
!= SHT_REL
8897 && relsec
->sh_type
!= SHT_RELA
))
8900 arm_sec
->rel_type
= relsec
->sh_type
;
8901 if (relsec
->sh_type
== SHT_REL
)
8903 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8905 & arm_sec
->rela
, & arm_sec
->nrelas
))
8908 else /* relsec->sh_type == SHT_RELA */
8910 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8912 & arm_sec
->rela
, & arm_sec
->nrelas
))
8918 arm_sec
->next_rela
= arm_sec
->rela
;
8921 /* If there is no unwind data we can do nothing. */
8922 if (arm_sec
->data
== NULL
)
8925 /* If the offset is invalid then fail. */
8926 if (/* PR 21343 *//* PR 18879 */
8928 || word_offset
> (sec
->sh_size
- 4)
8929 || ((bfd_signed_vma
) word_offset
) < 0)
8932 /* Get the word at the required offset. */
8933 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8935 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8936 if (arm_sec
->rela
== NULL
)
8942 /* Look through the relocs to find the one that applies to the provided offset. */
8944 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8946 bfd_vma prelval
, offset
;
8948 if (rp
->r_offset
> word_offset
&& !wrapped
)
8953 if (rp
->r_offset
> word_offset
)
8956 if (rp
->r_offset
& 3)
8958 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8959 (unsigned long) rp
->r_offset
);
8963 if (rp
->r_offset
< word_offset
)
8966 /* PR 17531: file: 027-161405-0.004 */
8967 if (aux
->symtab
== NULL
)
8970 if (arm_sec
->rel_type
== SHT_REL
)
8972 offset
= word
& 0x7fffffff;
8973 if (offset
& 0x40000000)
8974 offset
|= ~ (bfd_vma
) 0x7fffffff;
8976 else if (arm_sec
->rel_type
== SHT_RELA
)
8977 offset
= rp
->r_addend
;
8980 error (_("Unknown section relocation type %d encountered\n"),
8985 /* PR 17531 file: 027-1241568-0.004. */
8986 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8988 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8989 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8993 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8994 offset
+= sym
->st_value
;
8995 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8997 /* Check that we are processing the expected reloc type. */
8998 if (filedata
->file_header
.e_machine
== EM_ARM
)
9000 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
9001 if (relname
== NULL
)
9003 warn (_("Skipping unknown ARM relocation type: %d\n"),
9004 (int) ELF32_R_TYPE (rp
->r_info
));
9008 if (streq (relname
, "R_ARM_NONE"))
9011 if (! streq (relname
, "R_ARM_PREL31"))
9013 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
9017 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9019 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
9020 if (relname
== NULL
)
9022 warn (_("Skipping unknown C6000 relocation type: %d\n"),
9023 (int) ELF32_R_TYPE (rp
->r_info
));
9027 if (streq (relname
, "R_C6000_NONE"))
9030 if (! streq (relname
, "R_C6000_PREL31"))
9032 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
9040 /* This function currently only supports ARM and TI unwinders. */
9041 warn (_("Only TI and ARM unwinders are currently supported\n"));
9045 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
9046 addr
->section
= sym
->st_shndx
;
9047 addr
->offset
= offset
;
9050 * sym_name
= sym
->st_name
;
9055 arm_sec
->next_rela
= rp
;
9060 static const char *tic6x_unwind_regnames
[16] =
9062 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
9063 "A14", "A13", "A12", "A11", "A10",
9064 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
9068 decode_tic6x_unwind_regmask (unsigned int mask
)
9072 for (i
= 12; mask
; mask
>>= 1, i
--)
9076 fputs (tic6x_unwind_regnames
[i
], stdout
);
9078 fputs (", ", stdout
);
9084 if (remaining == 0 && more_words) \
9087 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
9088 data_offset, & word, & addr, NULL)) \
9094 #define GET_OP(OP) \
9099 (OP) = word >> 24; \
9104 printf (_("[Truncated opcode]\n")); \
9107 printf ("0x%02x ", OP)
9110 decode_arm_unwind_bytecode (Filedata
* filedata
,
9111 struct arm_unw_aux_info
* aux
,
9113 unsigned int remaining
,
9114 unsigned int more_words
,
9115 bfd_vma data_offset
,
9116 Elf_Internal_Shdr
* data_sec
,
9117 struct arm_section
* data_arm_sec
)
9119 struct absaddr addr
;
9122 /* Decode the unwinding instructions. */
9125 unsigned int op
, op2
;
9134 printf (" 0x%02x ", op
);
9136 if ((op
& 0xc0) == 0x00)
9138 int offset
= ((op
& 0x3f) << 2) + 4;
9140 printf (" vsp = vsp + %d", offset
);
9142 else if ((op
& 0xc0) == 0x40)
9144 int offset
= ((op
& 0x3f) << 2) + 4;
9146 printf (" vsp = vsp - %d", offset
);
9148 else if ((op
& 0xf0) == 0x80)
9151 if (op
== 0x80 && op2
== 0)
9152 printf (_("Refuse to unwind"));
9155 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
9160 for (i
= 0; i
< 12; i
++)
9161 if (mask
& (1 << i
))
9167 printf ("r%d", 4 + i
);
9172 else if ((op
& 0xf0) == 0x90)
9174 if (op
== 0x9d || op
== 0x9f)
9175 printf (_(" [Reserved]"));
9177 printf (" vsp = r%d", op
& 0x0f);
9179 else if ((op
& 0xf0) == 0xa0)
9181 int end
= 4 + (op
& 0x07);
9186 for (i
= 4; i
<= end
; i
++)
9202 else if (op
== 0xb0)
9203 printf (_(" finish"));
9204 else if (op
== 0xb1)
9207 if (op2
== 0 || (op2
& 0xf0) != 0)
9208 printf (_("[Spare]"));
9211 unsigned int mask
= op2
& 0x0f;
9216 for (i
= 0; i
< 12; i
++)
9217 if (mask
& (1 << i
))
9228 else if (op
== 0xb2)
9230 unsigned char buf
[9];
9231 unsigned int i
, len
;
9232 unsigned long offset
;
9234 for (i
= 0; i
< sizeof (buf
); i
++)
9237 if ((buf
[i
] & 0x80) == 0)
9240 if (i
== sizeof (buf
))
9242 error (_("corrupt change to vsp\n"));
9247 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
9248 assert (len
== i
+ 1);
9249 offset
= offset
* 4 + 0x204;
9250 printf ("vsp = vsp + %ld", offset
);
9253 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
9255 unsigned int first
, last
;
9262 printf ("pop {D%d", first
);
9264 printf ("-D%d", first
+ last
);
9267 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
9269 unsigned int count
= op
& 0x07;
9273 printf ("-D%d", 8 + count
);
9276 else if (op
>= 0xc0 && op
<= 0xc5)
9278 unsigned int count
= op
& 0x07;
9280 printf (" pop {wR10");
9282 printf ("-wR%d", 10 + count
);
9285 else if (op
== 0xc6)
9287 unsigned int first
, last
;
9292 printf ("pop {wR%d", first
);
9294 printf ("-wR%d", first
+ last
);
9297 else if (op
== 0xc7)
9300 if (op2
== 0 || (op2
& 0xf0) != 0)
9301 printf (_("[Spare]"));
9304 unsigned int mask
= op2
& 0x0f;
9309 for (i
= 0; i
< 4; i
++)
9310 if (mask
& (1 << i
))
9316 printf ("wCGR%d", i
);
9323 printf (_(" [unsupported opcode]"));
9334 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
9335 struct arm_unw_aux_info
* aux
,
9337 unsigned int remaining
,
9338 unsigned int more_words
,
9339 bfd_vma data_offset
,
9340 Elf_Internal_Shdr
* data_sec
,
9341 struct arm_section
* data_arm_sec
)
9343 struct absaddr addr
;
9345 /* Decode the unwinding instructions. */
9348 unsigned int op
, op2
;
9357 printf (" 0x%02x ", op
);
9359 if ((op
& 0xc0) == 0x00)
9361 int offset
= ((op
& 0x3f) << 3) + 8;
9362 printf (" sp = sp + %d", offset
);
9364 else if ((op
& 0xc0) == 0x80)
9367 if (op
== 0x80 && op2
== 0)
9368 printf (_("Refuse to unwind"));
9371 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
9373 printf ("pop compact {");
9377 decode_tic6x_unwind_regmask (mask
);
9381 else if ((op
& 0xf0) == 0xc0)
9389 unsigned int offset
;
9393 /* Scan entire instruction first so that GET_OP output is not
9394 interleaved with disassembly. */
9396 for (i
= 0; nregs
< (op
& 0xf); i
++)
9402 regpos
[nregs
].offset
= i
* 2;
9403 regpos
[nregs
].reg
= reg
;
9410 regpos
[nregs
].offset
= i
* 2 + 1;
9411 regpos
[nregs
].reg
= reg
;
9416 printf (_("pop frame {"));
9419 printf (_("*corrupt* - no registers specified"));
9424 for (i
= i
* 2; i
> 0; i
--)
9426 if (regpos
[reg
].offset
== i
- 1)
9428 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
9435 fputs (name
, stdout
);
9443 else if (op
== 0xd0)
9444 printf (" MOV FP, SP");
9445 else if (op
== 0xd1)
9446 printf (" __c6xabi_pop_rts");
9447 else if (op
== 0xd2)
9449 unsigned char buf
[9];
9450 unsigned int i
, len
;
9451 unsigned long offset
;
9453 for (i
= 0; i
< sizeof (buf
); i
++)
9456 if ((buf
[i
] & 0x80) == 0)
9459 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9460 if (i
== sizeof (buf
))
9462 warn (_("Corrupt stack pointer adjustment detected\n"));
9466 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
9467 assert (len
== i
+ 1);
9468 offset
= offset
* 8 + 0x408;
9469 printf (_("sp = sp + %ld"), offset
);
9471 else if ((op
& 0xf0) == 0xe0)
9473 if ((op
& 0x0f) == 7)
9476 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9480 printf (_(" [unsupported opcode]"));
9489 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9493 offset
= word
& 0x7fffffff;
9494 if (offset
& 0x40000000)
9495 offset
|= ~ (bfd_vma
) 0x7fffffff;
9497 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9500 return offset
+ where
;
9504 decode_arm_unwind (Filedata
* filedata
,
9505 struct arm_unw_aux_info
* aux
,
9507 unsigned int remaining
,
9508 bfd_vma data_offset
,
9509 Elf_Internal_Shdr
* data_sec
,
9510 struct arm_section
* data_arm_sec
)
9513 unsigned int more_words
= 0;
9514 struct absaddr addr
;
9515 bfd_vma sym_name
= (bfd_vma
) -1;
9520 /* Fetch the first word.
9521 Note - when decoding an object file the address extracted
9522 here will always be 0. So we also pass in the sym_name
9523 parameter so that we can find the symbol associated with
9524 the personality routine. */
9525 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9526 & word
, & addr
, & sym_name
))
9533 addr
.section
= SHN_UNDEF
;
9537 if ((word
& 0x80000000) == 0)
9539 /* Expand prel31 for personality routine. */
9541 const char *procname
;
9543 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9544 printf (_(" Personality routine: "));
9546 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9547 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9549 procname
= aux
->strtab
+ sym_name
;
9550 print_vma (fn
, PREFIX_HEX
);
9553 fputs (" <", stdout
);
9554 fputs (procname
, stdout
);
9555 fputc ('>', stdout
);
9559 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9560 fputc ('\n', stdout
);
9562 /* The GCC personality routines use the standard compact
9563 encoding, starting with one byte giving the number of
9565 if (procname
!= NULL
9566 && (startswith (procname
, "__gcc_personality_v0")
9567 || startswith (procname
, "__gxx_personality_v0")
9568 || startswith (procname
, "__gcj_personality_v0")
9569 || startswith (procname
, "__gnu_objc_personality_v0")))
9576 printf (_(" [Truncated data]\n"));
9579 more_words
= word
>> 24;
9589 /* ARM EHABI Section 6.3:
9591 An exception-handling table entry for the compact model looks like:
9595 1 0 index Data for personalityRoutine[index] */
9597 if (filedata
->file_header
.e_machine
== EM_ARM
9598 && (word
& 0x70000000))
9600 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9604 per_index
= (word
>> 24) & 0x7f;
9605 printf (_(" Compact model index: %d\n"), per_index
);
9612 else if (per_index
< 3)
9614 more_words
= (word
>> 16) & 0xff;
9620 switch (filedata
->file_header
.e_machine
)
9625 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9626 data_offset
, data_sec
, data_arm_sec
))
9631 warn (_("Unknown ARM compact model index encountered\n"));
9632 printf (_(" [reserved]\n"));
9640 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9641 data_offset
, data_sec
, data_arm_sec
))
9644 else if (per_index
< 5)
9646 if (((word
>> 17) & 0x7f) == 0x7f)
9647 printf (_(" Restore stack from frame pointer\n"));
9649 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9650 printf (_(" Registers restored: "));
9652 printf (" (compact) ");
9653 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9655 printf (_(" Return register: %s\n"),
9656 tic6x_unwind_regnames
[word
& 0xf]);
9659 printf (_(" [reserved (%d)]\n"), per_index
);
9663 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9664 filedata
->file_header
.e_machine
);
9668 /* Decode the descriptors. Not implemented. */
9674 dump_arm_unwind (Filedata
* filedata
,
9675 struct arm_unw_aux_info
* aux
,
9676 Elf_Internal_Shdr
* exidx_sec
)
9678 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9679 unsigned int i
, exidx_len
;
9680 unsigned long j
, nfuns
;
9683 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9684 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9685 exidx_len
= exidx_sec
->sh_size
/ 8;
9687 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9688 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9689 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9690 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9692 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9694 for (i
= 0; i
< exidx_len
; i
++)
9696 unsigned int exidx_fn
, exidx_entry
;
9697 struct absaddr fn_addr
, entry_addr
;
9700 fputc ('\n', stdout
);
9702 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9703 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9704 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9705 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9708 arm_free_section (& exidx_arm_sec
);
9709 arm_free_section (& extab_arm_sec
);
9713 /* ARM EHABI, Section 5:
9714 An index table entry consists of 2 words.
9715 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9716 if (exidx_fn
& 0x80000000)
9718 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9722 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9724 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9725 fputs (": ", stdout
);
9727 if (exidx_entry
== 1)
9729 print_vma (exidx_entry
, PREFIX_HEX
);
9730 fputs (" [cantunwind]\n", stdout
);
9732 else if (exidx_entry
& 0x80000000)
9734 print_vma (exidx_entry
, PREFIX_HEX
);
9735 fputc ('\n', stdout
);
9736 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9740 bfd_vma table
, table_offset
= 0;
9741 Elf_Internal_Shdr
*table_sec
;
9743 fputs ("@", stdout
);
9744 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9745 print_vma (table
, PREFIX_HEX
);
9748 /* Locate the matching .ARM.extab. */
9749 if (entry_addr
.section
!= SHN_UNDEF
9750 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9752 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9753 table_offset
= entry_addr
.offset
;
9755 if (table_offset
> table_sec
->sh_size
9756 || ((bfd_signed_vma
) table_offset
) < 0)
9758 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9759 (unsigned long) table_offset
,
9760 printable_section_name (filedata
, table_sec
));
9767 table_sec
= find_section_by_address (filedata
, table
);
9768 if (table_sec
!= NULL
)
9769 table_offset
= table
- table_sec
->sh_addr
;
9772 if (table_sec
== NULL
)
9774 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9775 (unsigned long) table
);
9780 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9789 arm_free_section (&exidx_arm_sec
);
9790 arm_free_section (&extab_arm_sec
);
9795 /* Used for both ARM and C6X unwinding tables. */
9798 arm_process_unwind (Filedata
* filedata
)
9800 struct arm_unw_aux_info aux
;
9801 Elf_Internal_Shdr
*unwsec
= NULL
;
9802 Elf_Internal_Shdr
*sec
;
9804 unsigned int sec_type
;
9807 switch (filedata
->file_header
.e_machine
)
9810 sec_type
= SHT_ARM_EXIDX
;
9814 sec_type
= SHT_C6000_UNWIND
;
9818 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9819 filedata
->file_header
.e_machine
);
9823 if (filedata
->string_table
== NULL
)
9826 memset (& aux
, 0, sizeof (aux
));
9827 aux
.filedata
= filedata
;
9829 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9831 if (sec
->sh_type
== SHT_SYMTAB
)
9835 error (_("Multiple symbol tables encountered\n"));
9841 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9842 &aux
.strtab
, &aux
.strtab_size
))
9845 else if (sec
->sh_type
== sec_type
)
9850 printf (_("\nThere are no unwind sections in this file.\n"));
9852 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9854 if (sec
->sh_type
== sec_type
)
9856 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9857 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9858 "contains %lu entry:\n",
9859 "\nUnwind section '%s' at offset 0x%lx "
9860 "contains %lu entries:\n",
9862 printable_section_name (filedata
, sec
),
9863 (unsigned long) sec
->sh_offset
,
9866 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9872 free ((char *) aux
.strtab
);
9878 no_processor_specific_unwind (Filedata
* filedata ATTRIBUTE_UNUSED
)
9880 printf (_("No processor specific unwind information to decode\n"));
9885 process_unwind (Filedata
* filedata
)
9887 struct unwind_handler
9889 unsigned int machtype
;
9890 bool (* handler
)(Filedata
*);
9893 { EM_ARM
, arm_process_unwind
},
9894 { EM_IA_64
, ia64_process_unwind
},
9895 { EM_PARISC
, hppa_process_unwind
},
9896 { EM_TI_C6000
, arm_process_unwind
},
9897 { EM_386
, no_processor_specific_unwind
},
9898 { EM_X86_64
, no_processor_specific_unwind
},
9906 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9907 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9908 return handlers
[i
].handler (filedata
);
9910 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9911 get_machine_name (filedata
->file_header
.e_machine
));
9916 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9918 switch (entry
->d_tag
)
9920 case DT_AARCH64_BTI_PLT
:
9921 case DT_AARCH64_PAC_PLT
:
9924 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9931 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
9933 switch (entry
->d_tag
)
9936 if (entry
->d_un
.d_val
== 0)
9940 static const char * opts
[] =
9942 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9943 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9944 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9945 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9951 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9952 if (entry
->d_un
.d_val
& (1 << cnt
))
9954 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9960 case DT_MIPS_IVERSION
:
9961 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
9962 printf (_("Interface Version: %s"),
9963 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
9967 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9968 /* Note: coded this way so that there is a single string for translation. */
9969 printf (_("<corrupt: %s>"), buf
);
9973 case DT_MIPS_TIME_STAMP
:
9977 time_t atime
= entry
->d_un
.d_val
;
9979 tmp
= gmtime (&atime
);
9980 /* PR 17531: file: 6accc532. */
9982 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9984 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9985 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9986 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9987 printf (_("Time Stamp: %s"), timebuf
);
9991 case DT_MIPS_RLD_VERSION
:
9992 case DT_MIPS_LOCAL_GOTNO
:
9993 case DT_MIPS_CONFLICTNO
:
9994 case DT_MIPS_LIBLISTNO
:
9995 case DT_MIPS_SYMTABNO
:
9996 case DT_MIPS_UNREFEXTNO
:
9997 case DT_MIPS_HIPAGENO
:
9998 case DT_MIPS_DELTA_CLASS_NO
:
9999 case DT_MIPS_DELTA_INSTANCE_NO
:
10000 case DT_MIPS_DELTA_RELOC_NO
:
10001 case DT_MIPS_DELTA_SYM_NO
:
10002 case DT_MIPS_DELTA_CLASSSYM_NO
:
10003 case DT_MIPS_COMPACT_SIZE
:
10004 print_vma (entry
->d_un
.d_val
, DEC
);
10007 case DT_MIPS_XHASH
:
10008 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10009 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10010 /* Falls through. */
10013 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10019 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
10021 switch (entry
->d_tag
)
10023 case DT_HP_DLD_FLAGS
:
10032 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
10033 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
10034 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
10035 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
10036 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
10037 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
10038 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
10039 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
10040 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
10041 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
10042 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
10043 { DT_HP_GST
, "HP_GST" },
10044 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
10045 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
10046 { DT_HP_NODELETE
, "HP_NODELETE" },
10047 { DT_HP_GROUP
, "HP_GROUP" },
10048 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
10052 bfd_vma val
= entry
->d_un
.d_val
;
10054 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
10055 if (val
& flags
[cnt
].bit
)
10059 fputs (flags
[cnt
].str
, stdout
);
10061 val
^= flags
[cnt
].bit
;
10064 if (val
!= 0 || first
)
10068 print_vma (val
, HEX
);
10074 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10082 /* VMS vs Unix time offset and factor. */
10084 #define VMS_EPOCH_OFFSET 35067168000000000LL
10085 #define VMS_GRANULARITY_FACTOR 10000000
10087 #define INT64_MIN (-9223372036854775807LL - 1)
10090 /* Display a VMS time in a human readable format. */
10093 print_vms_time (bfd_int64_t vmstime
)
10095 struct tm
*tm
= NULL
;
10098 if (vmstime
>= INT64_MIN
+ VMS_EPOCH_OFFSET
)
10100 vmstime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
10102 if (unxtime
== vmstime
)
10103 tm
= gmtime (&unxtime
);
10106 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
10107 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
10108 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
10113 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
10115 switch (entry
->d_tag
)
10117 case DT_IA_64_PLT_RESERVE
:
10118 /* First 3 slots reserved. */
10119 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10121 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
10124 case DT_IA_64_VMS_LINKTIME
:
10126 print_vms_time (entry
->d_un
.d_val
);
10130 case DT_IA_64_VMS_LNKFLAGS
:
10131 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10132 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
10133 printf (" CALL_DEBUG");
10134 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
10135 printf (" NOP0BUFS");
10136 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
10137 printf (" P0IMAGE");
10138 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
10139 printf (" MKTHREADS");
10140 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
10141 printf (" UPCALLS");
10142 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
10143 printf (" IMGSTA");
10144 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
10145 printf (" INITIALIZE");
10146 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
10148 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
10149 printf (" EXE_INIT");
10150 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
10151 printf (" TBK_IN_IMG");
10152 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
10153 printf (" DBG_IN_IMG");
10154 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
10155 printf (" TBK_IN_DSF");
10156 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
10157 printf (" DBG_IN_DSF");
10158 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
10159 printf (" SIGNATURES");
10160 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
10161 printf (" REL_SEG_OFF");
10165 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10172 get_32bit_dynamic_section (Filedata
* filedata
)
10174 Elf32_External_Dyn
* edyn
;
10175 Elf32_External_Dyn
* ext
;
10176 Elf_Internal_Dyn
* entry
;
10178 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
10179 filedata
->dynamic_addr
, 1,
10180 filedata
->dynamic_size
,
10181 _("dynamic section"));
10185 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
10186 might not have the luxury of section headers. Look for the DT_NULL
10187 terminator to determine the number of entries. */
10188 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
10189 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
10192 filedata
->dynamic_nent
++;
10193 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
10197 filedata
->dynamic_section
10198 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
10199 if (filedata
->dynamic_section
== NULL
)
10201 error (_("Out of memory allocating space for %lu dynamic entries\n"),
10202 (unsigned long) filedata
->dynamic_nent
);
10207 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10208 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10211 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10212 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10221 get_64bit_dynamic_section (Filedata
* filedata
)
10223 Elf64_External_Dyn
* edyn
;
10224 Elf64_External_Dyn
* ext
;
10225 Elf_Internal_Dyn
* entry
;
10227 /* Read in the data. */
10228 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
10229 filedata
->dynamic_addr
, 1,
10230 filedata
->dynamic_size
,
10231 _("dynamic section"));
10235 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
10236 might not have the luxury of section headers. Look for the DT_NULL
10237 terminator to determine the number of entries. */
10238 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
10239 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
10240 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
10243 filedata
->dynamic_nent
++;
10244 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
10248 filedata
->dynamic_section
10249 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
10250 if (filedata
->dynamic_section
== NULL
)
10252 error (_("Out of memory allocating space for %lu dynamic entries\n"),
10253 (unsigned long) filedata
->dynamic_nent
);
10258 /* Convert from external to internal formats. */
10259 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10260 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10263 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10264 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10273 get_dynamic_section (Filedata
*filedata
)
10275 if (filedata
->dynamic_section
)
10279 return get_32bit_dynamic_section (filedata
);
10281 return get_64bit_dynamic_section (filedata
);
10285 print_dynamic_flags (bfd_vma flags
)
10293 flag
= flags
& - flags
;
10299 putc (' ', stdout
);
10303 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
10304 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
10305 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
10306 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
10307 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
10308 default: fputs (_("unknown"), stdout
); break;
10315 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
10317 unsigned char * e_data
;
10320 /* If the size_t type is smaller than the bfd_size_type, eg because
10321 you are building a 32-bit tool on a 64-bit host, then make sure
10322 that when (number) is cast to (size_t) no information is lost. */
10323 if (sizeof (size_t) < sizeof (bfd_size_type
)
10324 && (bfd_size_type
) ((size_t) number
) != number
)
10326 error (_("Size truncation prevents reading %s elements of size %u\n"),
10327 bfd_vmatoa ("u", number
), ent_size
);
10331 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
10332 attempting to allocate memory when the read is bound to fail. */
10333 if (ent_size
* number
> filedata
->file_size
)
10335 error (_("Invalid number of dynamic entries: %s\n"),
10336 bfd_vmatoa ("u", number
));
10340 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10341 if (e_data
== NULL
)
10343 error (_("Out of memory reading %s dynamic entries\n"),
10344 bfd_vmatoa ("u", number
));
10348 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
10350 error (_("Unable to read in %s bytes of dynamic data\n"),
10351 bfd_vmatoa ("u", number
* ent_size
));
10356 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10357 if (i_data
== NULL
)
10359 error (_("Out of memory allocating space for %s dynamic entries\n"),
10360 bfd_vmatoa ("u", number
));
10366 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10373 static unsigned long
10374 get_num_dynamic_syms (Filedata
* filedata
)
10376 unsigned long num_of_syms
= 0;
10378 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
10379 return num_of_syms
;
10381 if (filedata
->dynamic_info
[DT_HASH
])
10383 unsigned char nb
[8];
10384 unsigned char nc
[8];
10385 unsigned int hash_ent_size
= 4;
10387 if ((filedata
->file_header
.e_machine
== EM_ALPHA
10388 || filedata
->file_header
.e_machine
== EM_S390
10389 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
10390 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10393 if (fseek (filedata
->handle
,
10394 (filedata
->archive_file_offset
10395 + offset_from_vma (filedata
, filedata
->dynamic_info
[DT_HASH
],
10396 sizeof nb
+ sizeof nc
)),
10399 error (_("Unable to seek to start of dynamic information\n"));
10403 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
10405 error (_("Failed to read in number of buckets\n"));
10409 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
10411 error (_("Failed to read in number of chains\n"));
10415 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
10416 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
10418 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
10420 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
10422 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
10425 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
10426 num_of_syms
= filedata
->nchains
;
10429 if (num_of_syms
== 0)
10431 free (filedata
->buckets
);
10432 filedata
->buckets
= NULL
;
10433 free (filedata
->chains
);
10434 filedata
->chains
= NULL
;
10435 filedata
->nbuckets
= 0;
10439 if (filedata
->dynamic_info_DT_GNU_HASH
)
10441 unsigned char nb
[16];
10442 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10443 bfd_vma buckets_vma
;
10446 if (fseek (filedata
->handle
,
10447 (filedata
->archive_file_offset
10448 + offset_from_vma (filedata
,
10449 filedata
->dynamic_info_DT_GNU_HASH
,
10453 error (_("Unable to seek to start of dynamic information\n"));
10457 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
10459 error (_("Failed to read in number of buckets\n"));
10463 filedata
->ngnubuckets
= byte_get (nb
, 4);
10464 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
10465 bitmaskwords
= byte_get (nb
+ 8, 4);
10466 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
10468 buckets_vma
+= bitmaskwords
* 4;
10470 buckets_vma
+= bitmaskwords
* 8;
10472 if (fseek (filedata
->handle
,
10473 (filedata
->archive_file_offset
10474 + offset_from_vma (filedata
, buckets_vma
, 4)),
10477 error (_("Unable to seek to start of dynamic information\n"));
10481 filedata
->gnubuckets
10482 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
10484 if (filedata
->gnubuckets
== NULL
)
10487 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
10488 if (filedata
->gnubuckets
[i
] != 0)
10490 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
10493 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
10494 maxchain
= filedata
->gnubuckets
[i
];
10497 if (maxchain
== 0xffffffff)
10500 maxchain
-= filedata
->gnusymidx
;
10502 if (fseek (filedata
->handle
,
10503 (filedata
->archive_file_offset
10504 + offset_from_vma (filedata
,
10505 buckets_vma
+ 4 * (filedata
->ngnubuckets
10510 error (_("Unable to seek to start of dynamic information\n"));
10516 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
10518 error (_("Failed to determine last chain length\n"));
10522 if (maxchain
+ 1 == 0)
10527 while ((byte_get (nb
, 4) & 1) == 0);
10529 if (fseek (filedata
->handle
,
10530 (filedata
->archive_file_offset
10531 + offset_from_vma (filedata
, (buckets_vma
10532 + 4 * filedata
->ngnubuckets
),
10536 error (_("Unable to seek to start of dynamic information\n"));
10540 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
10541 filedata
->ngnuchains
= maxchain
;
10543 if (filedata
->gnuchains
== NULL
)
10546 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10548 if (fseek (filedata
->handle
,
10549 (filedata
->archive_file_offset
10550 + offset_from_vma (filedata
, (buckets_vma
10551 + 4 * (filedata
->ngnubuckets
10555 error (_("Unable to seek to start of dynamic information\n"));
10559 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
10560 if (filedata
->mipsxlat
== NULL
)
10564 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
10565 if (filedata
->gnubuckets
[hn
] != 0)
10567 bfd_vma si
= filedata
->gnubuckets
[hn
];
10568 bfd_vma off
= si
- filedata
->gnusymidx
;
10572 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10574 if (off
< filedata
->ngnuchains
10575 && filedata
->mipsxlat
[off
] >= num_of_syms
)
10576 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
10580 if (si
>= num_of_syms
)
10581 num_of_syms
= si
+ 1;
10585 while (off
< filedata
->ngnuchains
10586 && (filedata
->gnuchains
[off
++] & 1) == 0);
10589 if (num_of_syms
== 0)
10592 free (filedata
->mipsxlat
);
10593 filedata
->mipsxlat
= NULL
;
10594 free (filedata
->gnuchains
);
10595 filedata
->gnuchains
= NULL
;
10596 free (filedata
->gnubuckets
);
10597 filedata
->gnubuckets
= NULL
;
10598 filedata
->ngnubuckets
= 0;
10599 filedata
->ngnuchains
= 0;
10603 return num_of_syms
;
10606 /* Parse and display the contents of the dynamic section. */
10609 process_dynamic_section (Filedata
* filedata
)
10611 Elf_Internal_Dyn
* entry
;
10613 if (filedata
->dynamic_size
== 0)
10617 if (filedata
->is_separate
)
10618 printf (_("\nThere is no dynamic section in linked file '%s'.\n"),
10619 filedata
->file_name
);
10621 printf (_("\nThere is no dynamic section in this file.\n"));
10627 if (!get_dynamic_section (filedata
))
10630 /* Find the appropriate symbol table. */
10631 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
10633 unsigned long num_of_syms
;
10635 for (entry
= filedata
->dynamic_section
;
10636 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10638 if (entry
->d_tag
== DT_SYMTAB
)
10639 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
10640 else if (entry
->d_tag
== DT_SYMENT
)
10641 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
10642 else if (entry
->d_tag
== DT_HASH
)
10643 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
10644 else if (entry
->d_tag
== DT_GNU_HASH
)
10645 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10646 else if ((filedata
->file_header
.e_machine
== EM_MIPS
10647 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
10648 && entry
->d_tag
== DT_MIPS_XHASH
)
10650 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10651 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10654 num_of_syms
= get_num_dynamic_syms (filedata
);
10656 if (num_of_syms
!= 0
10657 && filedata
->dynamic_symbols
== NULL
10658 && filedata
->dynamic_info
[DT_SYMTAB
]
10659 && filedata
->dynamic_info
[DT_SYMENT
])
10661 Elf_Internal_Phdr
*seg
;
10662 bfd_vma vma
= filedata
->dynamic_info
[DT_SYMTAB
];
10664 if (! get_program_headers (filedata
))
10666 error (_("Cannot interpret virtual addresses "
10667 "without program headers.\n"));
10671 for (seg
= filedata
->program_headers
;
10672 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
10675 if (seg
->p_type
!= PT_LOAD
)
10678 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
10680 /* See PR 21379 for a reproducer. */
10681 error (_("Invalid PT_LOAD entry\n"));
10685 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
10686 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
10688 /* Since we do not know how big the symbol table is,
10689 we default to reading in up to the end of PT_LOAD
10690 segment and processing that. This is overkill, I
10691 know, but it should work. */
10692 Elf_Internal_Shdr section
;
10693 section
.sh_offset
= (vma
- seg
->p_vaddr
10695 section
.sh_size
= (num_of_syms
10696 * filedata
->dynamic_info
[DT_SYMENT
]);
10697 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
10700 && filedata
->dynamic_symtab_section
!= NULL
10701 && ((filedata
->dynamic_symtab_section
->sh_offset
10702 != section
.sh_offset
)
10703 || (filedata
->dynamic_symtab_section
->sh_size
10704 != section
.sh_size
)
10705 || (filedata
->dynamic_symtab_section
->sh_entsize
10706 != section
.sh_entsize
)))
10708 the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
10710 section
.sh_name
= filedata
->string_table_length
;
10711 filedata
->dynamic_symbols
10712 = get_elf_symbols (filedata
, §ion
,
10713 &filedata
->num_dynamic_syms
);
10714 if (filedata
->dynamic_symbols
== NULL
10715 || filedata
->num_dynamic_syms
!= num_of_syms
)
10717 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
10726 /* Similarly find a string table. */
10727 if (filedata
->dynamic_strings
== NULL
)
10728 for (entry
= filedata
->dynamic_section
;
10729 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10732 if (entry
->d_tag
== DT_STRTAB
)
10733 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
10735 if (entry
->d_tag
== DT_STRSZ
)
10736 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
10738 if (filedata
->dynamic_info
[DT_STRTAB
]
10739 && filedata
->dynamic_info
[DT_STRSZ
])
10741 unsigned long offset
;
10742 bfd_size_type str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
10744 offset
= offset_from_vma (filedata
,
10745 filedata
->dynamic_info
[DT_STRTAB
],
10748 && filedata
->dynamic_strtab_section
10749 && ((filedata
->dynamic_strtab_section
->sh_offset
10750 != (file_ptr
) offset
)
10751 || (filedata
->dynamic_strtab_section
->sh_size
10754 the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
10756 filedata
->dynamic_strings
10757 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
10758 _("dynamic string table"));
10759 if (filedata
->dynamic_strings
== NULL
)
10761 error (_("Corrupt DT_STRTAB dynamic entry\n"));
10765 filedata
->dynamic_strings_length
= str_tab_len
;
10770 /* And find the syminfo section if available. */
10771 if (filedata
->dynamic_syminfo
== NULL
)
10773 unsigned long syminsz
= 0;
10775 for (entry
= filedata
->dynamic_section
;
10776 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10779 if (entry
->d_tag
== DT_SYMINENT
)
10781 /* Note: these braces are necessary to avoid a syntax
10782 error from the SunOS4 C compiler. */
10783 /* PR binutils/17531: A corrupt file can trigger this test.
10784 So do not use an assert, instead generate an error message. */
10785 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
10786 error (_("Bad value (%d) for SYMINENT entry\n"),
10787 (int) entry
->d_un
.d_val
);
10789 else if (entry
->d_tag
== DT_SYMINSZ
)
10790 syminsz
= entry
->d_un
.d_val
;
10791 else if (entry
->d_tag
== DT_SYMINFO
)
10792 filedata
->dynamic_syminfo_offset
10793 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
10796 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
10798 Elf_External_Syminfo
* extsyminfo
;
10799 Elf_External_Syminfo
* extsym
;
10800 Elf_Internal_Syminfo
* syminfo
;
10802 /* There is a syminfo section. Read the data. */
10803 extsyminfo
= (Elf_External_Syminfo
*)
10804 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
10805 1, syminsz
, _("symbol information"));
10809 if (filedata
->dynamic_syminfo
!= NULL
)
10811 error (_("Multiple dynamic symbol information sections found\n"));
10812 free (filedata
->dynamic_syminfo
);
10814 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10815 if (filedata
->dynamic_syminfo
== NULL
)
10817 error (_("Out of memory allocating %lu bytes "
10818 "for dynamic symbol info\n"),
10819 (unsigned long) syminsz
);
10823 filedata
->dynamic_syminfo_nent
10824 = syminsz
/ sizeof (Elf_External_Syminfo
);
10825 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
10826 syminfo
< (filedata
->dynamic_syminfo
10827 + filedata
->dynamic_syminfo_nent
);
10828 ++syminfo
, ++extsym
)
10830 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10831 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10838 if (do_dynamic
&& filedata
->dynamic_addr
)
10840 if (filedata
->dynamic_nent
== 1)
10842 if (filedata
->is_separate
)
10843 printf (_("\nIn linked file '%s' the dynamic section at offset 0x%lx contains 1 entry:\n"),
10844 filedata
->file_name
,
10845 filedata
->dynamic_addr
);
10847 printf (_("\nDynamic section at offset 0x%lx contains 1 entry:\n"),
10848 filedata
->dynamic_addr
);
10852 if (filedata
->is_separate
)
10853 printf (_("\nIn linked file '%s' the dynamic section at offset 0x%lx contains %lu entries:\n"),
10854 filedata
->file_name
,
10855 filedata
->dynamic_addr
,
10856 (unsigned long) filedata
->dynamic_nent
);
10858 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
10859 filedata
->dynamic_addr
,
10860 (unsigned long) filedata
->dynamic_nent
);
10864 printf (_(" Tag Type Name/Value\n"));
10866 for (entry
= filedata
->dynamic_section
;
10867 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10872 const char * dtype
;
10875 print_vma (entry
->d_tag
, FULL_HEX
);
10876 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10877 printf (" (%s)%*s", dtype
,
10878 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10881 switch (entry
->d_tag
)
10885 print_dynamic_flags (entry
->d_un
.d_val
);
10895 switch (entry
->d_tag
)
10898 printf (_("Auxiliary library"));
10902 printf (_("Filter library"));
10906 printf (_("Configuration file"));
10910 printf (_("Dependency audit library"));
10914 printf (_("Audit library"));
10918 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10919 printf (": [%s]\n",
10920 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
10924 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10933 printf (_("Flags:"));
10935 if (entry
->d_un
.d_val
== 0)
10936 printf (_(" None\n"));
10939 unsigned long int val
= entry
->d_un
.d_val
;
10941 if (val
& DTF_1_PARINIT
)
10943 printf (" PARINIT");
10944 val
^= DTF_1_PARINIT
;
10946 if (val
& DTF_1_CONFEXP
)
10948 printf (" CONFEXP");
10949 val
^= DTF_1_CONFEXP
;
10952 printf (" %lx", val
);
10961 printf (_("Flags:"));
10963 if (entry
->d_un
.d_val
== 0)
10964 printf (_(" None\n"));
10967 unsigned long int val
= entry
->d_un
.d_val
;
10969 if (val
& DF_P1_LAZYLOAD
)
10971 printf (" LAZYLOAD");
10972 val
^= DF_P1_LAZYLOAD
;
10974 if (val
& DF_P1_GROUPPERM
)
10976 printf (" GROUPPERM");
10977 val
^= DF_P1_GROUPPERM
;
10980 printf (" %lx", val
);
10989 printf (_("Flags:"));
10990 if (entry
->d_un
.d_val
== 0)
10991 printf (_(" None\n"));
10994 unsigned long int val
= entry
->d_un
.d_val
;
10996 if (val
& DF_1_NOW
)
11001 if (val
& DF_1_GLOBAL
)
11003 printf (" GLOBAL");
11004 val
^= DF_1_GLOBAL
;
11006 if (val
& DF_1_GROUP
)
11011 if (val
& DF_1_NODELETE
)
11013 printf (" NODELETE");
11014 val
^= DF_1_NODELETE
;
11016 if (val
& DF_1_LOADFLTR
)
11018 printf (" LOADFLTR");
11019 val
^= DF_1_LOADFLTR
;
11021 if (val
& DF_1_INITFIRST
)
11023 printf (" INITFIRST");
11024 val
^= DF_1_INITFIRST
;
11026 if (val
& DF_1_NOOPEN
)
11028 printf (" NOOPEN");
11029 val
^= DF_1_NOOPEN
;
11031 if (val
& DF_1_ORIGIN
)
11033 printf (" ORIGIN");
11034 val
^= DF_1_ORIGIN
;
11036 if (val
& DF_1_DIRECT
)
11038 printf (" DIRECT");
11039 val
^= DF_1_DIRECT
;
11041 if (val
& DF_1_TRANS
)
11046 if (val
& DF_1_INTERPOSE
)
11048 printf (" INTERPOSE");
11049 val
^= DF_1_INTERPOSE
;
11051 if (val
& DF_1_NODEFLIB
)
11053 printf (" NODEFLIB");
11054 val
^= DF_1_NODEFLIB
;
11056 if (val
& DF_1_NODUMP
)
11058 printf (" NODUMP");
11059 val
^= DF_1_NODUMP
;
11061 if (val
& DF_1_CONFALT
)
11063 printf (" CONFALT");
11064 val
^= DF_1_CONFALT
;
11066 if (val
& DF_1_ENDFILTEE
)
11068 printf (" ENDFILTEE");
11069 val
^= DF_1_ENDFILTEE
;
11071 if (val
& DF_1_DISPRELDNE
)
11073 printf (" DISPRELDNE");
11074 val
^= DF_1_DISPRELDNE
;
11076 if (val
& DF_1_DISPRELPND
)
11078 printf (" DISPRELPND");
11079 val
^= DF_1_DISPRELPND
;
11081 if (val
& DF_1_NODIRECT
)
11083 printf (" NODIRECT");
11084 val
^= DF_1_NODIRECT
;
11086 if (val
& DF_1_IGNMULDEF
)
11088 printf (" IGNMULDEF");
11089 val
^= DF_1_IGNMULDEF
;
11091 if (val
& DF_1_NOKSYMS
)
11093 printf (" NOKSYMS");
11094 val
^= DF_1_NOKSYMS
;
11096 if (val
& DF_1_NOHDR
)
11101 if (val
& DF_1_EDITED
)
11103 printf (" EDITED");
11104 val
^= DF_1_EDITED
;
11106 if (val
& DF_1_NORELOC
)
11108 printf (" NORELOC");
11109 val
^= DF_1_NORELOC
;
11111 if (val
& DF_1_SYMINTPOSE
)
11113 printf (" SYMINTPOSE");
11114 val
^= DF_1_SYMINTPOSE
;
11116 if (val
& DF_1_GLOBAUDIT
)
11118 printf (" GLOBAUDIT");
11119 val
^= DF_1_GLOBAUDIT
;
11121 if (val
& DF_1_SINGLETON
)
11123 printf (" SINGLETON");
11124 val
^= DF_1_SINGLETON
;
11126 if (val
& DF_1_STUB
)
11131 if (val
& DF_1_PIE
)
11136 if (val
& DF_1_KMOD
)
11141 if (val
& DF_1_WEAKFILTER
)
11143 printf (" WEAKFILTER");
11144 val
^= DF_1_WEAKFILTER
;
11146 if (val
& DF_1_NOCOMMON
)
11148 printf (" NOCOMMON");
11149 val
^= DF_1_NOCOMMON
;
11152 printf (" %lx", val
);
11159 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11161 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
11181 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11187 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
11188 name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
11194 switch (entry
->d_tag
)
11197 printf (_("Shared library: [%s]"), name
);
11199 if (filedata
->program_interpreter
11200 && streq (name
, filedata
->program_interpreter
))
11201 printf (_(" program interpreter"));
11205 printf (_("Library soname: [%s]"), name
);
11209 printf (_("Library rpath: [%s]"), name
);
11213 printf (_("Library runpath: [%s]"), name
);
11217 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11222 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11235 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11236 /* Fall through. */
11240 case DT_INIT_ARRAYSZ
:
11241 case DT_FINI_ARRAYSZ
:
11242 case DT_GNU_CONFLICTSZ
:
11243 case DT_GNU_LIBLISTSZ
:
11246 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11247 printf (_(" (bytes)\n"));
11252 case DT_VERNEEDNUM
:
11257 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11266 case DT_INIT_ARRAY
:
11267 case DT_FINI_ARRAY
:
11270 if (entry
->d_tag
== DT_USED
11271 && VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
11273 char * name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
11277 printf (_("Not needed object: [%s]\n"), name
);
11282 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11288 /* The value of this entry is ignored. */
11293 case DT_GNU_PRELINKED
:
11297 time_t atime
= entry
->d_un
.d_val
;
11299 tmp
= gmtime (&atime
);
11300 /* PR 17533 file: 041-1244816-0.004. */
11302 printf (_("<corrupt time val: %lx"),
11303 (unsigned long) atime
);
11305 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
11306 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11307 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11313 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11316 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11321 case DT_GNU_FLAGS_1
:
11324 printf (_("Flags:"));
11325 if (entry
->d_un
.d_val
== 0)
11326 printf (_(" None\n"));
11329 unsigned long int val
= entry
->d_un
.d_val
;
11331 if (val
& DF_GNU_1_UNIQUE
)
11333 printf (" UNIQUE");
11334 val
^= DF_GNU_1_UNIQUE
;
11337 printf (" %lx", val
);
11344 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
11345 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
11346 = entry
->d_un
.d_val
;
11350 switch (filedata
->file_header
.e_machine
)
11353 dynamic_section_aarch64_val (entry
);
11356 case EM_MIPS_RS3_LE
:
11357 dynamic_section_mips_val (filedata
, entry
);
11360 dynamic_section_parisc_val (entry
);
11363 dynamic_section_ia64_val (entry
);
11366 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11378 get_ver_flags (unsigned int flags
)
11380 static char buff
[128];
11387 if (flags
& VER_FLG_BASE
)
11388 strcat (buff
, "BASE");
11390 if (flags
& VER_FLG_WEAK
)
11392 if (flags
& VER_FLG_BASE
)
11393 strcat (buff
, " | ");
11395 strcat (buff
, "WEAK");
11398 if (flags
& VER_FLG_INFO
)
11400 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
11401 strcat (buff
, " | ");
11403 strcat (buff
, "INFO");
11406 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11408 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11409 strcat (buff
, " | ");
11411 strcat (buff
, _("<unknown>"));
11417 /* Display the contents of the version sections. */
11420 process_version_sections (Filedata
* filedata
)
11422 Elf_Internal_Shdr
* section
;
11424 bool found
= false;
11429 for (i
= 0, section
= filedata
->section_headers
;
11430 i
< filedata
->file_header
.e_shnum
;
11433 switch (section
->sh_type
)
11435 case SHT_GNU_verdef
:
11437 Elf_External_Verdef
* edefs
;
11444 if (filedata
->is_separate
)
11445 printf (ngettext ("\nIn linked file '%s' the version definition section '%s' contains %u entry:\n",
11446 "\nIn linked file '%s' the version definition section '%s' contains %u entries:\n",
11448 filedata
->file_name
,
11449 printable_section_name (filedata
, section
),
11452 printf (ngettext ("\nVersion definition section '%s' "
11453 "contains %u entry:\n",
11454 "\nVersion definition section '%s' "
11455 "contains %u entries:\n",
11457 printable_section_name (filedata
, section
),
11460 printf (_(" Addr: 0x"));
11461 printf_vma (section
->sh_addr
);
11462 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11463 (unsigned long) section
->sh_offset
, section
->sh_link
,
11464 printable_section_name_from_index (filedata
, section
->sh_link
));
11466 edefs
= (Elf_External_Verdef
*)
11467 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
11468 _("version definition section"));
11471 endbuf
= (char *) edefs
+ section
->sh_size
;
11473 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11476 Elf_External_Verdef
* edef
;
11477 Elf_Internal_Verdef ent
;
11478 Elf_External_Verdaux
* eaux
;
11479 Elf_Internal_Verdaux aux
;
11480 unsigned long isum
;
11483 vstart
= ((char *) edefs
) + idx
;
11484 if (vstart
+ sizeof (*edef
) > endbuf
)
11487 edef
= (Elf_External_Verdef
*) vstart
;
11489 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
11490 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
11491 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
11492 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
11493 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
11494 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
11495 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
11497 printf (_(" %#06lx: Rev: %d Flags: %s"),
11498 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
11500 printf (_(" Index: %d Cnt: %d "),
11501 ent
.vd_ndx
, ent
.vd_cnt
);
11503 /* Check for overflow. */
11504 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
11507 vstart
+= ent
.vd_aux
;
11509 if (vstart
+ sizeof (*eaux
) > endbuf
)
11511 eaux
= (Elf_External_Verdaux
*) vstart
;
11513 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11514 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11516 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11517 printf (_("Name: %s\n"),
11518 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11520 printf (_("Name index: %ld\n"), aux
.vda_name
);
11522 isum
= idx
+ ent
.vd_aux
;
11524 for (j
= 1; j
< ent
.vd_cnt
; j
++)
11526 if (aux
.vda_next
< sizeof (*eaux
)
11527 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
11529 warn (_("Invalid vda_next field of %lx\n"),
11534 /* Check for overflow. */
11535 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
11538 isum
+= aux
.vda_next
;
11539 vstart
+= aux
.vda_next
;
11541 if (vstart
+ sizeof (*eaux
) > endbuf
)
11543 eaux
= (Elf_External_Verdaux
*) vstart
;
11545 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11546 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11548 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11549 printf (_(" %#06lx: Parent %d: %s\n"),
11551 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11553 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
11554 isum
, j
, aux
.vda_name
);
11557 if (j
< ent
.vd_cnt
)
11558 printf (_(" Version def aux past end of section\n"));
11561 file: id:000001,src:000172+005151,op:splice,rep:2. */
11562 if (ent
.vd_next
< sizeof (*edef
)
11563 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
11565 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
11566 cnt
= section
->sh_info
;
11569 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
11572 idx
+= ent
.vd_next
;
11575 if (cnt
< section
->sh_info
)
11576 printf (_(" Version definition past end of section\n"));
11582 case SHT_GNU_verneed
:
11584 Elf_External_Verneed
* eneed
;
11591 if (filedata
->is_separate
)
11592 printf (ngettext ("\nIn linked file '%s' the version needs section '%s' contains %u entry:\n",
11593 "\nIn linked file '%s' the version needs section '%s' contains %u entries:\n",
11595 filedata
->file_name
,
11596 printable_section_name (filedata
, section
),
11599 printf (ngettext ("\nVersion needs section '%s' "
11600 "contains %u entry:\n",
11601 "\nVersion needs section '%s' "
11602 "contains %u entries:\n",
11604 printable_section_name (filedata
, section
),
11607 printf (_(" Addr: 0x"));
11608 printf_vma (section
->sh_addr
);
11609 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11610 (unsigned long) section
->sh_offset
, section
->sh_link
,
11611 printable_section_name_from_index (filedata
, section
->sh_link
));
11613 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
11614 section
->sh_offset
, 1,
11616 _("Version Needs section"));
11619 endbuf
= (char *) eneed
+ section
->sh_size
;
11621 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11623 Elf_External_Verneed
* entry
;
11624 Elf_Internal_Verneed ent
;
11625 unsigned long isum
;
11629 vstart
= ((char *) eneed
) + idx
;
11630 if (vstart
+ sizeof (*entry
) > endbuf
)
11633 entry
= (Elf_External_Verneed
*) vstart
;
11635 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
11636 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
11637 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
11638 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
11639 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
11641 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
11643 if (VALID_DYNAMIC_NAME (filedata
, ent
.vn_file
))
11644 printf (_(" File: %s"),
11645 GET_DYNAMIC_NAME (filedata
, ent
.vn_file
));
11647 printf (_(" File: %lx"), ent
.vn_file
);
11649 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
11651 /* Check for overflow. */
11652 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
11654 vstart
+= ent
.vn_aux
;
11656 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
11658 Elf_External_Vernaux
* eaux
;
11659 Elf_Internal_Vernaux aux
;
11661 if (vstart
+ sizeof (*eaux
) > endbuf
)
11663 eaux
= (Elf_External_Vernaux
*) vstart
;
11665 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
11666 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
11667 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
11668 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
11669 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
11671 if (VALID_DYNAMIC_NAME (filedata
, aux
.vna_name
))
11672 printf (_(" %#06lx: Name: %s"),
11673 isum
, GET_DYNAMIC_NAME (filedata
, aux
.vna_name
));
11675 printf (_(" %#06lx: Name index: %lx"),
11676 isum
, aux
.vna_name
);
11678 printf (_(" Flags: %s Version: %d\n"),
11679 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
11681 if (aux
.vna_next
< sizeof (*eaux
)
11682 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
11684 warn (_("Invalid vna_next field of %lx\n"),
11689 /* Check for overflow. */
11690 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
11692 isum
+= aux
.vna_next
;
11693 vstart
+= aux
.vna_next
;
11696 if (j
< ent
.vn_cnt
)
11697 warn (_("Missing Version Needs auxiliary information\n"));
11699 if (ent
.vn_next
< sizeof (*entry
)
11700 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
11702 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
11703 cnt
= section
->sh_info
;
11706 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
11708 idx
+= ent
.vn_next
;
11711 if (cnt
< section
->sh_info
)
11712 warn (_("Missing Version Needs information\n"));
11718 case SHT_GNU_versym
:
11720 Elf_Internal_Shdr
* link_section
;
11723 unsigned char * edata
;
11724 unsigned short * data
;
11726 Elf_Internal_Sym
* symbols
;
11727 Elf_Internal_Shdr
* string_sec
;
11728 unsigned long num_syms
;
11731 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
11734 link_section
= filedata
->section_headers
+ section
->sh_link
;
11735 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
11737 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
11742 symbols
= get_elf_symbols (filedata
, link_section
, & num_syms
);
11743 if (symbols
== NULL
)
11746 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
11748 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
11749 string_sec
->sh_size
,
11750 _("version string table"));
11757 if (filedata
->is_separate
)
11758 printf (ngettext ("\nIn linked file '%s' the version symbols section '%s' contains %lu entry:\n",
11759 "\nIn linked file '%s' the version symbols section '%s' contains %lu entries:\n",
11761 filedata
->file_name
,
11762 printable_section_name (filedata
, section
),
11763 (unsigned long) total
);
11765 printf (ngettext ("\nVersion symbols section '%s' "
11766 "contains %lu entry:\n",
11767 "\nVersion symbols section '%s' "
11768 "contains %lu entries:\n",
11770 printable_section_name (filedata
, section
),
11771 (unsigned long) total
);
11773 printf (_(" Addr: 0x"));
11774 printf_vma (section
->sh_addr
);
11775 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11776 (unsigned long) section
->sh_offset
, section
->sh_link
,
11777 printable_section_name (filedata
, link_section
));
11779 off
= offset_from_vma (filedata
,
11780 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11781 total
* sizeof (short));
11782 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
11783 sizeof (short), total
,
11784 _("version symbol data"));
11792 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
11794 for (cnt
= total
; cnt
--;)
11795 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
11800 for (cnt
= 0; cnt
< total
; cnt
+= 4)
11804 char *invalid
= _("*invalid*");
11806 printf (" %03x:", cnt
);
11808 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
11809 switch (data
[cnt
+ j
])
11812 fputs (_(" 0 (*local*) "), stdout
);
11816 fputs (_(" 1 (*global*) "), stdout
);
11820 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
11821 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
11823 /* If this index value is greater than the size of the symbols
11824 array, break to avoid an out-of-bounds read. */
11825 if ((unsigned long)(cnt
+ j
) >= num_syms
)
11827 warn (_("invalid index into symbol array\n"));
11832 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11834 Elf_Internal_Verneed ivn
;
11835 unsigned long offset
;
11837 offset
= offset_from_vma
11839 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11840 sizeof (Elf_External_Verneed
));
11844 Elf_Internal_Vernaux ivna
;
11845 Elf_External_Verneed evn
;
11846 Elf_External_Vernaux evna
;
11847 unsigned long a_off
;
11849 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11850 _("version need")) == NULL
)
11853 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11854 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11856 a_off
= offset
+ ivn
.vn_aux
;
11860 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
11861 1, _("version need aux (2)")) == NULL
)
11864 ivna
.vna_other
= 0;
11868 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11869 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11872 a_off
+= ivna
.vna_next
;
11874 while (ivna
.vna_other
!= data
[cnt
+ j
]
11875 && ivna
.vna_next
!= 0);
11877 if (ivna
.vna_other
== data
[cnt
+ j
])
11879 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11881 if (ivna
.vna_name
>= string_sec
->sh_size
)
11884 name
= strtab
+ ivna
.vna_name
;
11888 offset
+= ivn
.vn_next
;
11890 while (ivn
.vn_next
);
11893 if (data
[cnt
+ j
] != 0x8001
11894 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11896 Elf_Internal_Verdef ivd
;
11897 Elf_External_Verdef evd
;
11898 unsigned long offset
;
11900 offset
= offset_from_vma
11902 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11907 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11908 _("version def")) == NULL
)
11911 /* PR 17531: file: 046-1082287-0.004. */
11912 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11917 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11918 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11921 offset
+= ivd
.vd_next
;
11923 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11924 && ivd
.vd_next
!= 0);
11926 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11928 Elf_External_Verdaux evda
;
11929 Elf_Internal_Verdaux ivda
;
11931 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11933 if (get_data (&evda
, filedata
,
11934 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11936 _("version def aux")) == NULL
)
11939 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11941 if (ivda
.vda_name
>= string_sec
->sh_size
)
11943 else if (name
!= NULL
&& name
!= invalid
)
11944 name
= _("*both*");
11946 name
= strtab
+ ivda
.vda_name
;
11950 nn
+= printf ("(%s%-*s",
11952 12 - (int) strlen (name
),
11956 printf ("%*c", 18 - nn
, ' ');
11975 if (filedata
->is_separate
)
11976 printf (_("\nNo version information found in linked file '%s'.\n"),
11977 filedata
->file_name
);
11979 printf (_("\nNo version information found in this file.\n"));
11985 static const char *
11986 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11988 static char buff
[64];
11992 case STB_LOCAL
: return "LOCAL";
11993 case STB_GLOBAL
: return "GLOBAL";
11994 case STB_WEAK
: return "WEAK";
11996 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11997 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11999 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
12001 if (binding
== STB_GNU_UNIQUE
12002 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
12004 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
12007 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
12012 static const char *
12013 get_symbol_type (Filedata
* filedata
, unsigned int type
)
12015 static char buff
[64];
12019 case STT_NOTYPE
: return "NOTYPE";
12020 case STT_OBJECT
: return "OBJECT";
12021 case STT_FUNC
: return "FUNC";
12022 case STT_SECTION
: return "SECTION";
12023 case STT_FILE
: return "FILE";
12024 case STT_COMMON
: return "COMMON";
12025 case STT_TLS
: return "TLS";
12026 case STT_RELC
: return "RELC";
12027 case STT_SRELC
: return "SRELC";
12029 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
12031 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
12032 return "THUMB_FUNC";
12034 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
12037 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
12038 return "PARISC_MILLI";
12040 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
12042 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
12044 if (filedata
->file_header
.e_machine
== EM_PARISC
)
12046 if (type
== STT_HP_OPAQUE
)
12047 return "HP_OPAQUE";
12048 if (type
== STT_HP_STUB
)
12052 if (type
== STT_GNU_IFUNC
12053 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
12054 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
12057 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
12060 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
12065 static const char *
12066 get_symbol_visibility (unsigned int visibility
)
12068 switch (visibility
)
12070 case STV_DEFAULT
: return "DEFAULT";
12071 case STV_INTERNAL
: return "INTERNAL";
12072 case STV_HIDDEN
: return "HIDDEN";
12073 case STV_PROTECTED
: return "PROTECTED";
12075 error (_("Unrecognized visibility value: %u\n"), visibility
);
12076 return _("<unknown>");
12080 static const char *
12081 get_alpha_symbol_other (unsigned int other
)
12085 case STO_ALPHA_NOPV
: return "NOPV";
12086 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
12088 error (_("Unrecognized alpha specific other value: %u\n"), other
);
12089 return _("<unknown>");
12093 static const char *
12094 get_solaris_symbol_visibility (unsigned int visibility
)
12096 switch (visibility
)
12098 case 4: return "EXPORTED";
12099 case 5: return "SINGLETON";
12100 case 6: return "ELIMINATE";
12101 default: return get_symbol_visibility (visibility
);
12105 static const char *
12106 get_aarch64_symbol_other (unsigned int other
)
12108 static char buf
[32];
12110 if (other
& STO_AARCH64_VARIANT_PCS
)
12112 other
&= ~STO_AARCH64_VARIANT_PCS
;
12114 return "VARIANT_PCS";
12115 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
12121 static const char *
12122 get_mips_symbol_other (unsigned int other
)
12126 case STO_OPTIONAL
: return "OPTIONAL";
12127 case STO_MIPS_PLT
: return "MIPS PLT";
12128 case STO_MIPS_PIC
: return "MIPS PIC";
12129 case STO_MICROMIPS
: return "MICROMIPS";
12130 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
12131 case STO_MIPS16
: return "MIPS16";
12132 default: return NULL
;
12136 static const char *
12137 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
12139 if (is_ia64_vms (filedata
))
12141 static char res
[32];
12145 /* Function types is for images and .STB files only. */
12146 switch (filedata
->file_header
.e_type
)
12150 switch (VMS_ST_FUNC_TYPE (other
))
12152 case VMS_SFT_CODE_ADDR
:
12153 strcat (res
, " CA");
12155 case VMS_SFT_SYMV_IDX
:
12156 strcat (res
, " VEC");
12159 strcat (res
, " FD");
12161 case VMS_SFT_RESERVE
:
12162 strcat (res
, " RSV");
12165 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
12166 VMS_ST_FUNC_TYPE (other
));
12167 strcat (res
, " <unknown>");
12174 switch (VMS_ST_LINKAGE (other
))
12176 case VMS_STL_IGNORE
:
12177 strcat (res
, " IGN");
12179 case VMS_STL_RESERVE
:
12180 strcat (res
, " RSV");
12183 strcat (res
, " STD");
12186 strcat (res
, " LNK");
12189 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
12190 VMS_ST_LINKAGE (other
));
12191 strcat (res
, " <unknown>");
12203 static const char *
12204 get_ppc64_symbol_other (unsigned int other
)
12206 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
12209 other
>>= STO_PPC64_LOCAL_BIT
;
12212 static char buf
[64];
12214 other
= ppc64_decode_local_entry (other
);
12215 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
12221 static const char *
12222 get_symbol_other (Filedata
* filedata
, unsigned int other
)
12224 const char * result
= NULL
;
12225 static char buff
[64];
12230 switch (filedata
->file_header
.e_machine
)
12233 result
= get_alpha_symbol_other (other
);
12236 result
= get_aarch64_symbol_other (other
);
12239 result
= get_mips_symbol_other (other
);
12242 result
= get_ia64_symbol_other (filedata
, other
);
12245 result
= get_ppc64_symbol_other (other
);
12255 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
12259 static const char *
12260 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
12262 static char buff
[32];
12266 case SHN_UNDEF
: return "UND";
12267 case SHN_ABS
: return "ABS";
12268 case SHN_COMMON
: return "COM";
12270 if (type
== SHN_IA_64_ANSI_COMMON
12271 && filedata
->file_header
.e_machine
== EM_IA_64
12272 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
12274 else if ((filedata
->file_header
.e_machine
== EM_X86_64
12275 || filedata
->file_header
.e_machine
== EM_L1OM
12276 || filedata
->file_header
.e_machine
== EM_K1OM
)
12277 && type
== SHN_X86_64_LCOMMON
)
12278 return "LARGE_COM";
12279 else if ((type
== SHN_MIPS_SCOMMON
12280 && filedata
->file_header
.e_machine
== EM_MIPS
)
12281 || (type
== SHN_TIC6X_SCOMMON
12282 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
12284 else if (type
== SHN_MIPS_SUNDEFINED
12285 && filedata
->file_header
.e_machine
== EM_MIPS
)
12287 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
12288 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
12289 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
12290 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
12291 else if (type
>= SHN_LORESERVE
)
12292 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
12293 else if (filedata
->file_header
.e_shnum
!= 0
12294 && type
>= filedata
->file_header
.e_shnum
)
12295 sprintf (buff
, _("bad section index[%3d]"), type
);
12297 sprintf (buff
, "%3d", type
);
12304 static const char *
12305 get_symbol_version_string (Filedata
* filedata
,
12307 const char * strtab
,
12308 unsigned long int strtab_size
,
12310 Elf_Internal_Sym
* psym
,
12311 enum versioned_symbol_info
* sym_info
,
12312 unsigned short * vna_other
)
12314 unsigned char data
[2];
12315 unsigned short vers_data
;
12316 unsigned long offset
;
12317 unsigned short max_vd_ndx
;
12320 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
12323 offset
= offset_from_vma (filedata
,
12324 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
12325 sizeof data
+ si
* sizeof (vers_data
));
12327 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
12328 sizeof (data
), 1, _("version data")) == NULL
)
12331 vers_data
= byte_get (data
, 2);
12333 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
12336 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
12339 /* Usually we'd only see verdef for defined symbols, and verneed for
12340 undefined symbols. However, symbols defined by the linker in
12341 .dynbss for variables copied from a shared library in order to
12342 avoid text relocations are defined yet have verneed. We could
12343 use a heuristic to detect the special case, for example, check
12344 for verneed first on symbols defined in SHT_NOBITS sections, but
12345 it is simpler and more reliable to just look for both verdef and
12346 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
12348 if (psym
->st_shndx
!= SHN_UNDEF
12349 && vers_data
!= 0x8001
12350 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
12352 Elf_Internal_Verdef ivd
;
12353 Elf_Internal_Verdaux ivda
;
12354 Elf_External_Verdaux evda
;
12357 off
= offset_from_vma (filedata
,
12358 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
12359 sizeof (Elf_External_Verdef
));
12363 Elf_External_Verdef evd
;
12365 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
12366 _("version def")) == NULL
)
12375 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
12376 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
12377 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
12378 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
12381 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
12382 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
12384 off
+= ivd
.vd_next
;
12386 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
12388 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
12390 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
12393 off
-= ivd
.vd_next
;
12396 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
12397 _("version def aux")) != NULL
)
12399 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
12401 if (psym
->st_name
!= ivda
.vda_name
)
12402 return (ivda
.vda_name
< strtab_size
12403 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
12408 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
12410 Elf_External_Verneed evn
;
12411 Elf_Internal_Verneed ivn
;
12412 Elf_Internal_Vernaux ivna
;
12414 offset
= offset_from_vma (filedata
,
12415 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
12419 unsigned long vna_off
;
12421 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
12422 _("version need")) == NULL
)
12425 ivna
.vna_other
= 0;
12430 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
12431 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
12433 vna_off
= offset
+ ivn
.vn_aux
;
12437 Elf_External_Vernaux evna
;
12439 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
12440 _("version need aux (3)")) == NULL
)
12443 ivna
.vna_other
= 0;
12448 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
12449 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
12450 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
12453 vna_off
+= ivna
.vna_next
;
12455 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
12457 if (ivna
.vna_other
== vers_data
)
12460 offset
+= ivn
.vn_next
;
12462 while (ivn
.vn_next
!= 0);
12464 if (ivna
.vna_other
== vers_data
)
12466 *sym_info
= symbol_undefined
;
12467 *vna_other
= ivna
.vna_other
;
12468 return (ivna
.vna_name
< strtab_size
12469 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
12471 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
12472 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
12473 return _("<corrupt>");
12478 /* Display a symbol size on stdout. Format is based on --sym-base setting. */
12480 static unsigned int
12481 print_dynamic_symbol_size (bfd_vma vma
, int base
)
12486 return print_vma (vma
, OCTAL_5
);
12489 return print_vma (vma
, UNSIGNED_5
);
12492 return print_vma (vma
, PREFIX_HEX_5
);
12496 return print_vma (vma
, DEC_5
);
12501 print_dynamic_symbol (Filedata
*filedata
, unsigned long si
,
12502 Elf_Internal_Sym
*symtab
,
12503 Elf_Internal_Shdr
*section
,
12504 char *strtab
, size_t strtab_size
)
12506 const char *version_string
;
12507 enum versioned_symbol_info sym_info
;
12508 unsigned short vna_other
;
12511 Elf_Internal_Sym
*psym
= symtab
+ si
;
12513 printf ("%6ld: ", si
);
12514 print_vma (psym
->st_value
, LONG_HEX
);
12516 print_dynamic_symbol_size (psym
->st_size
, sym_base
);
12517 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12518 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12519 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12520 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12523 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12525 printf (" %-7s", get_symbol_visibility (vis
));
12526 /* Check to see if any other bits in the st_other field are set.
12527 Note - displaying this information disrupts the layout of the
12528 table being generated, but for the moment this case is very rare. */
12529 if (psym
->st_other
^ vis
)
12530 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12532 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12534 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
12535 && psym
->st_shndx
< filedata
->file_header
.e_shnum
12536 && psym
->st_name
== 0)
12538 is_valid
= SECTION_NAME_VALID (filedata
->section_headers
+ psym
->st_shndx
);
12540 SECTION_NAME_PRINT (filedata
->section_headers
+ psym
->st_shndx
)
12545 is_valid
= VALID_SYMBOL_NAME (strtab
, strtab_size
, psym
->st_name
);
12546 sstr
= is_valid
? strtab
+ psym
->st_name
: _("<corrupt>");
12550 = get_symbol_version_string (filedata
,
12552 || section
->sh_type
== SHT_DYNSYM
),
12553 strtab
, strtab_size
, si
,
12554 psym
, &sym_info
, &vna_other
);
12556 int len_avail
= 21;
12557 if (! do_wide
&& version_string
!= NULL
)
12561 len_avail
-= 1 + strlen (version_string
);
12563 if (sym_info
== symbol_undefined
)
12564 len_avail
-= sprintf (buffer
," (%d)", vna_other
);
12565 else if (sym_info
!= symbol_hidden
)
12569 print_symbol (len_avail
, sstr
);
12571 if (version_string
)
12573 if (sym_info
== symbol_undefined
)
12574 printf ("@%s (%d)", version_string
, vna_other
);
12576 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12582 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12584 && si
>= section
->sh_info
12585 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12586 && filedata
->file_header
.e_machine
!= EM_MIPS
12587 /* Solaris binaries have been found to violate this requirement as
12588 well. Not sure if this is a bug or an ABI requirement. */
12589 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12590 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12591 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12594 static const char *
12595 get_lto_kind (unsigned int kind
)
12599 case 0: return "DEF";
12600 case 1: return "WEAKDEF";
12601 case 2: return "UNDEF";
12602 case 3: return "WEAKUNDEF";
12603 case 4: return "COMMON";
12608 static char buffer
[30];
12609 error (_("Unknown LTO symbol definition encountered: %u\n"), kind
);
12610 sprintf (buffer
, "<unknown: %u>", kind
);
12614 static const char *
12615 get_lto_visibility (unsigned int visibility
)
12617 switch (visibility
)
12619 case 0: return "DEFAULT";
12620 case 1: return "PROTECTED";
12621 case 2: return "INTERNAL";
12622 case 3: return "HIDDEN";
12627 static char buffer
[30];
12628 error (_("Unknown LTO symbol visibility encountered: %u\n"), visibility
);
12629 sprintf (buffer
, "<unknown: %u>", visibility
);
12633 static const char *
12634 get_lto_sym_type (unsigned int sym_type
)
12638 case 0: return "UNKNOWN";
12639 case 1: return "FUNCTION";
12640 case 2: return "VARIABLE";
12645 static char buffer
[30];
12646 error (_("Unknown LTO symbol type encountered: %u\n"), sym_type
);
12647 sprintf (buffer
, "<unknown: %u>", sym_type
);
12651 /* Display an LTO format symbol table.
12652 FIXME: The format of LTO symbol tables is not formalized.
12653 So this code could need changing in the future. */
12656 display_lto_symtab (Filedata
* filedata
,
12657 Elf_Internal_Shdr
* section
)
12659 if (section
->sh_size
== 0)
12661 if (filedata
->is_separate
)
12662 printf (_("\nThe LTO Symbol table section '%s' in linked file '%s' is empty!\n"),
12663 printable_section_name (filedata
, section
),
12664 filedata
->file_name
);
12666 printf (_("\nLTO Symbol table '%s' is empty!\n"),
12667 printable_section_name (filedata
, section
));
12672 if (section
->sh_size
> filedata
->file_size
)
12674 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
12675 printable_section_name (filedata
, section
),
12676 (unsigned long) section
->sh_size
);
12680 void * alloced_data
= get_data (NULL
, filedata
, section
->sh_offset
,
12681 section
->sh_size
, 1, _("LTO symbols"));
12682 if (alloced_data
== NULL
)
12685 /* Look for extended data for the symbol table. */
12686 Elf_Internal_Shdr
* ext
;
12687 void * ext_data_orig
= NULL
;
12688 char * ext_data
= NULL
;
12689 char * ext_data_end
= NULL
;
12690 char * ext_name
= NULL
;
12692 if (asprintf (& ext_name
, ".gnu.lto_.ext_symtab.%s",
12693 SECTION_NAME (section
) + sizeof (".gnu.lto_.symtab.") - 1) > 0
12694 && ext_name
!= NULL
/* Paranoia. */
12695 && (ext
= find_section (filedata
, ext_name
)) != NULL
)
12697 if (ext
->sh_size
< 3)
12698 error (_("LTO Symbol extension table '%s' is empty!\n"),
12699 printable_section_name (filedata
, ext
));
12702 ext_data_orig
= ext_data
= get_data (NULL
, filedata
, ext
->sh_offset
,
12704 _("LTO ext symbol data"));
12705 if (ext_data
!= NULL
)
12707 ext_data_end
= ext_data
+ ext
->sh_size
;
12708 if (* ext_data
++ != 1)
12709 error (_("Unexpected version number in symbol extension table\n"));
12714 const unsigned char * data
= (const unsigned char *) alloced_data
;
12715 const unsigned char * end
= data
+ section
->sh_size
;
12717 if (filedata
->is_separate
)
12718 printf (_("\nIn linked file '%s': "), filedata
->file_name
);
12722 if (ext_data_orig
!= NULL
)
12725 printf (_("LTO Symbol table '%s' and extension table '%s' contain:\n"),
12726 printable_section_name (filedata
, section
),
12727 printable_section_name (filedata
, ext
));
12730 printf (_("LTO Symbol table '%s'\n"),
12731 printable_section_name (filedata
, section
));
12732 printf (_(" and extension table '%s' contain:\n"),
12733 printable_section_name (filedata
, ext
));
12737 printf (_("LTO Symbol table '%s' contains:\n"),
12738 printable_section_name (filedata
, section
));
12740 /* FIXME: Add a wide version. */
12741 if (ext_data_orig
!= NULL
)
12742 printf (_(" Comdat_Key Kind Visibility Size Slot Type Section Name\n"));
12744 printf (_(" Comdat_Key Kind Visibility Size Slot Name\n"));
12746 /* FIXME: We do not handle style prefixes. */
12750 const unsigned char * sym_name
= data
;
12751 data
+= strnlen ((const char *) sym_name
, end
- data
) + 1;
12755 const unsigned char * comdat_key
= data
;
12756 data
+= strnlen ((const char *) comdat_key
, end
- data
) + 1;
12760 if (data
+ 2 + 8 + 4 > end
)
12763 unsigned int kind
= *data
++;
12764 unsigned int visibility
= *data
++;
12766 elf_vma size
= byte_get (data
, 8);
12769 elf_vma slot
= byte_get (data
, 4);
12772 if (ext_data
!= NULL
)
12774 if (ext_data
< (ext_data_end
- 1))
12776 unsigned int sym_type
= * ext_data
++;
12777 unsigned int sec_kind
= * ext_data
++;
12779 printf (" %10s %10s %11s %08lx %08lx %9s %08lx _",
12780 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
12781 get_lto_kind (kind
),
12782 get_lto_visibility (visibility
),
12785 get_lto_sym_type (sym_type
),
12787 print_symbol (6, (const char *) sym_name
);
12791 error (_("Ran out of LTO symbol extension data\n"));
12793 /* FIXME: return FAIL result ? */
12798 printf (" %10s %10s %11s %08lx %08lx _",
12799 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
12800 get_lto_kind (kind
),
12801 get_lto_visibility (visibility
),
12804 print_symbol (21, (const char *) sym_name
);
12809 if (ext_data
!= NULL
&& ext_data
< ext_data_end
)
12811 error (_("Data remains in the LTO symbol extension table\n"));
12815 free (alloced_data
);
12816 free (ext_data_orig
);
12821 error (_("Buffer overrun encountered whilst decoding LTO symbol table\n"));
12822 free (alloced_data
);
12823 free (ext_data_orig
);
12828 /* Display LTO symbol tables. */
12831 process_lto_symbol_tables (Filedata
* filedata
)
12833 Elf_Internal_Shdr
* section
;
12840 if (filedata
->section_headers
== NULL
)
12843 for (i
= 0, section
= filedata
->section_headers
;
12844 i
< filedata
->file_header
.e_shnum
;
12846 if (SECTION_NAME_VALID (section
)
12847 && startswith (SECTION_NAME (section
), ".gnu.lto_.symtab."))
12848 res
&= display_lto_symtab (filedata
, section
);
12853 /* Dump the symbol table. */
12856 process_symbol_table (Filedata
* filedata
)
12858 Elf_Internal_Shdr
* section
;
12860 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
12863 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
12865 && do_using_dynamic
12866 && filedata
->dynamic_strings
!= NULL
12867 && filedata
->dynamic_symbols
!= NULL
)
12871 if (filedata
->is_separate
)
12873 printf (ngettext ("\nIn linked file '%s' the dynamic symbol table contains %lu entry:\n",
12874 "\nIn linked file '%s' the dynamic symbol table contains %lu entries:\n",
12875 filedata
->num_dynamic_syms
),
12876 filedata
->file_name
,
12877 filedata
->num_dynamic_syms
);
12881 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
12882 "\nSymbol table for image contains %lu entries:\n",
12883 filedata
->num_dynamic_syms
),
12884 filedata
->num_dynamic_syms
);
12887 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12889 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12891 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
12892 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
12893 filedata
->dynamic_strings
,
12894 filedata
->dynamic_strings_length
);
12896 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
12897 && filedata
->section_headers
!= NULL
)
12901 for (i
= 0, section
= filedata
->section_headers
;
12902 i
< filedata
->file_header
.e_shnum
;
12905 char * strtab
= NULL
;
12906 unsigned long int strtab_size
= 0;
12907 Elf_Internal_Sym
* symtab
;
12908 unsigned long si
, num_syms
;
12910 if ((section
->sh_type
!= SHT_SYMTAB
12911 && section
->sh_type
!= SHT_DYNSYM
)
12913 && section
->sh_type
== SHT_SYMTAB
))
12916 if (section
->sh_entsize
== 0)
12918 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12919 printable_section_name (filedata
, section
));
12923 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12925 if (filedata
->is_separate
)
12926 printf (ngettext ("\nIn linked file '%s' symbol section '%s' contains %lu entry:\n",
12927 "\nIn linked file '%s' symbol section '%s' contains %lu entries:\n",
12929 filedata
->file_name
,
12930 printable_section_name (filedata
, section
),
12933 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12934 "\nSymbol table '%s' contains %lu entries:\n",
12936 printable_section_name (filedata
, section
),
12940 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12942 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12944 symtab
= get_elf_symbols (filedata
, section
, & num_syms
);
12945 if (symtab
== NULL
)
12948 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12950 strtab
= filedata
->string_table
;
12951 strtab_size
= filedata
->string_table_length
;
12953 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12955 Elf_Internal_Shdr
* string_sec
;
12957 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12959 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12960 1, string_sec
->sh_size
,
12961 _("string table"));
12962 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12965 for (si
= 0; si
< num_syms
; si
++)
12966 print_dynamic_symbol (filedata
, si
, symtab
, section
,
12967 strtab
, strtab_size
);
12970 if (strtab
!= filedata
->string_table
)
12976 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12978 if (do_histogram
&& filedata
->buckets
!= NULL
)
12980 unsigned long * lengths
;
12981 unsigned long * counts
;
12984 unsigned long maxlength
= 0;
12985 unsigned long nzero_counts
= 0;
12986 unsigned long nsyms
= 0;
12989 printf (ngettext ("\nHistogram for bucket list length "
12990 "(total of %lu bucket):\n",
12991 "\nHistogram for bucket list length "
12992 "(total of %lu buckets):\n",
12993 (unsigned long) filedata
->nbuckets
),
12994 (unsigned long) filedata
->nbuckets
);
12996 lengths
= (unsigned long *) calloc (filedata
->nbuckets
,
12997 sizeof (*lengths
));
12998 if (lengths
== NULL
)
13000 error (_("Out of memory allocating space for histogram buckets\n"));
13003 visited
= xcmalloc (filedata
->nchains
, 1);
13004 memset (visited
, 0, filedata
->nchains
);
13006 printf (_(" Length Number %% of total Coverage\n"));
13007 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
13009 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
13012 if (maxlength
< ++lengths
[hn
])
13014 if (si
>= filedata
->nchains
|| visited
[si
])
13016 error (_("histogram chain is corrupt\n"));
13024 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
13025 if (counts
== NULL
)
13028 error (_("Out of memory allocating space for histogram counts\n"));
13032 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
13033 ++counts
[lengths
[hn
]];
13035 if (filedata
->nbuckets
> 0)
13038 printf (" 0 %-10lu (%5.1f%%)\n",
13039 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
13040 for (i
= 1; i
<= maxlength
; ++i
)
13042 nzero_counts
+= counts
[i
] * i
;
13043 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
13044 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
13045 (nzero_counts
* 100.0) / nsyms
);
13053 free (filedata
->buckets
);
13054 filedata
->buckets
= NULL
;
13055 filedata
->nbuckets
= 0;
13056 free (filedata
->chains
);
13057 filedata
->chains
= NULL
;
13059 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
13061 unsigned long * lengths
;
13062 unsigned long * counts
;
13064 unsigned long maxlength
= 0;
13065 unsigned long nzero_counts
= 0;
13066 unsigned long nsyms
= 0;
13068 printf (ngettext ("\nHistogram for `%s' bucket list length "
13069 "(total of %lu bucket):\n",
13070 "\nHistogram for `%s' bucket list length "
13071 "(total of %lu buckets):\n",
13072 (unsigned long) filedata
->ngnubuckets
),
13073 GNU_HASH_SECTION_NAME (filedata
),
13074 (unsigned long) filedata
->ngnubuckets
);
13076 lengths
= (unsigned long *) calloc (filedata
->ngnubuckets
,
13077 sizeof (*lengths
));
13078 if (lengths
== NULL
)
13080 error (_("Out of memory allocating space for gnu histogram buckets\n"));
13084 printf (_(" Length Number %% of total Coverage\n"));
13086 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
13087 if (filedata
->gnubuckets
[hn
] != 0)
13089 bfd_vma off
, length
= 1;
13091 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
13092 /* PR 17531 file: 010-77222-0.004. */
13093 off
< filedata
->ngnuchains
13094 && (filedata
->gnuchains
[off
] & 1) == 0;
13097 lengths
[hn
] = length
;
13098 if (length
> maxlength
)
13099 maxlength
= length
;
13103 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
13104 if (counts
== NULL
)
13107 error (_("Out of memory allocating space for gnu histogram counts\n"));
13111 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
13112 ++counts
[lengths
[hn
]];
13114 if (filedata
->ngnubuckets
> 0)
13117 printf (" 0 %-10lu (%5.1f%%)\n",
13118 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
13119 for (j
= 1; j
<= maxlength
; ++j
)
13121 nzero_counts
+= counts
[j
] * j
;
13122 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
13123 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
13124 (nzero_counts
* 100.0) / nsyms
);
13131 free (filedata
->gnubuckets
);
13132 filedata
->gnubuckets
= NULL
;
13133 filedata
->ngnubuckets
= 0;
13134 free (filedata
->gnuchains
);
13135 filedata
->gnuchains
= NULL
;
13136 filedata
->ngnuchains
= 0;
13137 free (filedata
->mipsxlat
);
13138 filedata
->mipsxlat
= NULL
;
13142 free (filedata
->gnubuckets
);
13143 filedata
->gnubuckets
= NULL
;
13144 filedata
->ngnubuckets
= 0;
13145 free (filedata
->gnuchains
);
13146 filedata
->gnuchains
= NULL
;
13147 filedata
->ngnuchains
= 0;
13148 free (filedata
->mipsxlat
);
13149 filedata
->mipsxlat
= NULL
;
13150 free (filedata
->buckets
);
13151 filedata
->buckets
= NULL
;
13152 filedata
->nbuckets
= 0;
13153 free (filedata
->chains
);
13154 filedata
->chains
= NULL
;
13159 process_syminfo (Filedata
* filedata
)
13163 if (filedata
->dynamic_syminfo
== NULL
13165 /* No syminfo, this is ok. */
13168 /* There better should be a dynamic symbol section. */
13169 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
13172 if (filedata
->is_separate
)
13173 printf (ngettext ("\nIn linked file '%s: the dynamic info segment at offset 0x%lx contains %d entry:\n",
13174 "\nIn linked file '%s: the dynamic info segment at offset 0x%lx contains %d entries:\n",
13175 filedata
->dynamic_syminfo_nent
),
13176 filedata
->file_name
,
13177 filedata
->dynamic_syminfo_offset
,
13178 filedata
->dynamic_syminfo_nent
);
13180 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
13181 "contains %d entry:\n",
13182 "\nDynamic info segment at offset 0x%lx "
13183 "contains %d entries:\n",
13184 filedata
->dynamic_syminfo_nent
),
13185 filedata
->dynamic_syminfo_offset
,
13186 filedata
->dynamic_syminfo_nent
);
13188 printf (_(" Num: Name BoundTo Flags\n"));
13189 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
13191 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
13193 printf ("%4d: ", i
);
13194 if (i
>= filedata
->num_dynamic_syms
)
13195 printf (_("<corrupt index>"));
13196 else if (VALID_DYNAMIC_NAME (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
13197 print_symbol (30, GET_DYNAMIC_NAME (filedata
,
13198 filedata
->dynamic_symbols
[i
].st_name
));
13200 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
13203 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
13205 case SYMINFO_BT_SELF
:
13206 fputs ("SELF ", stdout
);
13208 case SYMINFO_BT_PARENT
:
13209 fputs ("PARENT ", stdout
);
13212 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
13213 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
13214 && VALID_DYNAMIC_NAME (filedata
,
13215 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
13217 print_symbol (10, GET_DYNAMIC_NAME (filedata
,
13218 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
13222 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
13226 if (flags
& SYMINFO_FLG_DIRECT
)
13227 printf (" DIRECT");
13228 if (flags
& SYMINFO_FLG_PASSTHRU
)
13229 printf (" PASSTHRU");
13230 if (flags
& SYMINFO_FLG_COPY
)
13232 if (flags
& SYMINFO_FLG_LAZYLOAD
)
13233 printf (" LAZYLOAD");
13241 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
13242 is contained by the region START .. END. The types of ADDR, START
13243 and END should all be the same. Note both ADDR + NELEM and END
13244 point to just beyond the end of the regions that are being tested. */
13245 #define IN_RANGE(START,END,ADDR,NELEM) \
13246 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
13248 /* Check to see if the given reloc needs to be handled in a target specific
13249 manner. If so then process the reloc and return TRUE otherwise return
13252 If called with reloc == NULL, then this is a signal that reloc processing
13253 for the current section has finished, and any saved state should be
13257 target_specific_reloc_handling (Filedata
* filedata
,
13258 Elf_Internal_Rela
* reloc
,
13259 unsigned char * start
,
13260 unsigned char * end
,
13261 Elf_Internal_Sym
* symtab
,
13262 unsigned long num_syms
)
13264 unsigned int reloc_type
= 0;
13265 unsigned long sym_index
= 0;
13269 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
13270 sym_index
= get_reloc_symindex (reloc
->r_info
);
13273 switch (filedata
->file_header
.e_machine
)
13276 case EM_MSP430_OLD
:
13278 static Elf_Internal_Sym
* saved_sym
= NULL
;
13286 switch (reloc_type
)
13288 case 10: /* R_MSP430_SYM_DIFF */
13289 case 12: /* R_MSP430_GNU_SUB_ULEB128 */
13290 if (uses_msp430x_relocs (filedata
))
13292 /* Fall through. */
13293 case 21: /* R_MSP430X_SYM_DIFF */
13294 case 23: /* R_MSP430X_GNU_SUB_ULEB128 */
13296 if (sym_index
>= num_syms
)
13297 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
13300 saved_sym
= symtab
+ sym_index
;
13303 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
13304 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
13305 goto handle_sym_diff
;
13307 case 5: /* R_MSP430_16_BYTE */
13308 case 9: /* R_MSP430_8 */
13309 case 11: /* R_MSP430_GNU_SET_ULEB128 */
13310 if (uses_msp430x_relocs (filedata
))
13312 goto handle_sym_diff
;
13314 case 2: /* R_MSP430_ABS16 */
13315 case 15: /* R_MSP430X_ABS16 */
13316 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
13317 if (! uses_msp430x_relocs (filedata
))
13319 goto handle_sym_diff
;
13322 if (saved_sym
!= NULL
)
13325 unsigned int reloc_size
= 0;
13327 switch (reloc_type
)
13329 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
13332 case 11: /* R_MSP430_GNU_SET_ULEB128 */
13333 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
13334 if (reloc
->r_offset
< (size_t) (end
- start
))
13335 read_leb128 (start
+ reloc
->r_offset
, end
, false,
13336 &reloc_size
, &leb_ret
);
13343 if (leb_ret
!= 0 || reloc_size
== 0 || reloc_size
> 8)
13344 error (_("MSP430 ULEB128 field at 0x%lx contains invalid "
13345 "ULEB128 value\n"),
13346 (long) reloc
->r_offset
);
13347 else if (sym_index
>= num_syms
)
13348 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
13352 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
13353 - saved_sym
->st_value
);
13355 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
13356 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
13359 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
13360 (long) reloc
->r_offset
);
13369 if (saved_sym
!= NULL
)
13370 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13377 case EM_CYGNUS_MN10300
:
13379 static Elf_Internal_Sym
* saved_sym
= NULL
;
13387 switch (reloc_type
)
13389 case 34: /* R_MN10300_ALIGN */
13391 case 33: /* R_MN10300_SYM_DIFF */
13392 if (sym_index
>= num_syms
)
13393 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
13396 saved_sym
= symtab
+ sym_index
;
13399 case 1: /* R_MN10300_32 */
13400 case 2: /* R_MN10300_16 */
13401 if (saved_sym
!= NULL
)
13403 int reloc_size
= reloc_type
== 1 ? 4 : 2;
13406 if (sym_index
>= num_syms
)
13407 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
13411 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
13412 - saved_sym
->st_value
);
13414 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
13415 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
13417 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
13418 (long) reloc
->r_offset
);
13426 if (saved_sym
!= NULL
)
13427 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
13435 static bfd_vma saved_sym1
= 0;
13436 static bfd_vma saved_sym2
= 0;
13437 static bfd_vma value
;
13441 saved_sym1
= saved_sym2
= 0;
13445 switch (reloc_type
)
13447 case 0x80: /* R_RL78_SYM. */
13448 saved_sym1
= saved_sym2
;
13449 if (sym_index
>= num_syms
)
13450 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
13454 saved_sym2
= symtab
[sym_index
].st_value
;
13455 saved_sym2
+= reloc
->r_addend
;
13459 case 0x83: /* R_RL78_OPsub. */
13460 value
= saved_sym1
- saved_sym2
;
13461 saved_sym2
= saved_sym1
= 0;
13465 case 0x41: /* R_RL78_ABS32. */
13466 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
13467 byte_put (start
+ reloc
->r_offset
, value
, 4);
13469 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
13470 (long) reloc
->r_offset
);
13474 case 0x43: /* R_RL78_ABS16. */
13475 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
13476 byte_put (start
+ reloc
->r_offset
, value
, 2);
13478 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
13479 (long) reloc
->r_offset
);
13493 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
13494 DWARF debug sections. This is a target specific test. Note - we do not
13495 go through the whole including-target-headers-multiple-times route, (as
13496 we have already done with <elf/h8.h>) because this would become very
13497 messy and even then this function would have to contain target specific
13498 information (the names of the relocs instead of their numeric values).
13499 FIXME: This is not the correct way to solve this problem. The proper way
13500 is to have target specific reloc sizing and typing functions created by
13501 the reloc-macros.h header, in the same way that it already creates the
13502 reloc naming functions. */
13505 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13507 /* Please keep this table alpha-sorted for ease of visual lookup. */
13508 switch (filedata
->file_header
.e_machine
)
13512 return reloc_type
== 1; /* R_386_32. */
13514 return reloc_type
== 1; /* R_68K_32. */
13516 return reloc_type
== 1; /* R_860_32. */
13518 return reloc_type
== 2; /* R_960_32. */
13520 return (reloc_type
== 258
13521 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
13523 return reloc_type
== 11; /* R_BPF_DATA_32 */
13524 case EM_ADAPTEVA_EPIPHANY
:
13525 return reloc_type
== 3;
13527 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
13529 return reloc_type
== 1; /* R_ARC_32. */
13530 case EM_ARC_COMPACT
:
13531 case EM_ARC_COMPACT2
:
13532 return reloc_type
== 4; /* R_ARC_32. */
13534 return reloc_type
== 2; /* R_ARM_ABS32 */
13537 return reloc_type
== 1;
13539 return reloc_type
== 0x12; /* R_byte4_data. */
13541 return reloc_type
== 3; /* R_CRIS_32. */
13543 return reloc_type
== 3; /* R_CR16_NUM32. */
13545 return reloc_type
== 15; /* R_CRX_NUM32. */
13547 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
13548 case EM_CYGNUS_FRV
:
13549 return reloc_type
== 1;
13550 case EM_CYGNUS_D10V
:
13552 return reloc_type
== 6; /* R_D10V_32. */
13553 case EM_CYGNUS_D30V
:
13555 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
13557 return reloc_type
== 3; /* R_DLX_RELOC_32. */
13558 case EM_CYGNUS_FR30
:
13560 return reloc_type
== 3; /* R_FR30_32. */
13562 return reloc_type
== 1; /* R_FT32_32. */
13566 return reloc_type
== 1; /* R_H8_DIR32. */
13568 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
13569 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
13570 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
13571 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
13574 return reloc_type
== 2; /* R_IP2K_32. */
13576 return reloc_type
== 2; /* R_IQ2000_32. */
13577 case EM_LATTICEMICO32
:
13578 return reloc_type
== 3; /* R_LM32_32. */
13581 return reloc_type
== 3; /* R_M32C_32. */
13583 return reloc_type
== 34; /* R_M32R_32_RELA. */
13586 return reloc_type
== 6; /* R_M68HC11_32. */
13588 return reloc_type
== 7 || /* R_S12Z_EXT32 */
13589 reloc_type
== 6; /* R_S12Z_CW32. */
13591 return reloc_type
== 1; /* R_MCORE_ADDR32. */
13592 case EM_CYGNUS_MEP
:
13593 return reloc_type
== 4; /* R_MEP_32. */
13595 return reloc_type
== 2; /* R_METAG_ADDR32. */
13596 case EM_MICROBLAZE
:
13597 return reloc_type
== 1; /* R_MICROBLAZE_32. */
13599 return reloc_type
== 2; /* R_MIPS_32. */
13601 return reloc_type
== 4; /* R_MMIX_32. */
13602 case EM_CYGNUS_MN10200
:
13604 return reloc_type
== 1; /* R_MN10200_32. */
13605 case EM_CYGNUS_MN10300
:
13607 return reloc_type
== 1; /* R_MN10300_32. */
13609 return reloc_type
== 1; /* R_MOXIE_32. */
13610 case EM_MSP430_OLD
:
13612 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
13614 return reloc_type
== 2; /* R_MT_32. */
13616 return reloc_type
== 20; /* R_NDS32_RELA. */
13617 case EM_ALTERA_NIOS2
:
13618 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
13620 return reloc_type
== 1; /* R_NIOS_32. */
13622 return reloc_type
== 1; /* R_OR1K_32. */
13624 return (reloc_type
== 1 /* R_PARISC_DIR32. */
13625 || reloc_type
== 2 /* R_PARISC_DIR21L. */
13626 || reloc_type
== 41); /* R_PARISC_SECREL32. */
13629 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
13631 return reloc_type
== 1; /* R_PPC64_ADDR32. */
13633 return reloc_type
== 1; /* R_PPC_ADDR32. */
13635 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
13637 return reloc_type
== 1; /* R_RISCV_32. */
13639 return reloc_type
== 1; /* R_RL78_DIR32. */
13641 return reloc_type
== 1; /* R_RX_DIR32. */
13643 return reloc_type
== 1; /* R_I370_ADDR31. */
13646 return reloc_type
== 4; /* R_S390_32. */
13648 return reloc_type
== 8; /* R_SCORE_ABS32. */
13650 return reloc_type
== 1; /* R_SH_DIR32. */
13651 case EM_SPARC32PLUS
:
13654 return reloc_type
== 3 /* R_SPARC_32. */
13655 || reloc_type
== 23; /* R_SPARC_UA32. */
13657 return reloc_type
== 6; /* R_SPU_ADDR32 */
13659 return reloc_type
== 1; /* R_C6000_ABS32. */
13661 return reloc_type
== 2; /* R_TILEGX_32. */
13663 return reloc_type
== 1; /* R_TILEPRO_32. */
13664 case EM_CYGNUS_V850
:
13666 return reloc_type
== 6; /* R_V850_ABS32. */
13668 return reloc_type
== 0x33; /* R_V810_WORD. */
13670 return reloc_type
== 1; /* R_VAX_32. */
13672 return reloc_type
== 3; /* R_VISIUM_32. */
13673 case EM_WEBASSEMBLY
:
13674 return reloc_type
== 1; /* R_WASM32_32. */
13678 return reloc_type
== 10; /* R_X86_64_32. */
13681 return reloc_type
== 3; /* R_XC16C_ABS_32. */
13683 return reloc_type
== 4; /* R_XGATE_32. */
13685 return reloc_type
== 1; /* R_XSTROMY16_32. */
13686 case EM_XTENSA_OLD
:
13688 return reloc_type
== 1; /* R_XTENSA_32. */
13690 return reloc_type
== 6; /* R_Z80_32. */
13693 static unsigned int prev_warn
= 0;
13695 /* Avoid repeating the same warning multiple times. */
13696 if (prev_warn
!= filedata
->file_header
.e_machine
)
13697 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
13698 filedata
->file_header
.e_machine
);
13699 prev_warn
= filedata
->file_header
.e_machine
;
13705 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13706 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
13709 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13711 switch (filedata
->file_header
.e_machine
)
13712 /* Please keep this table alpha-sorted for ease of visual lookup. */
13716 return reloc_type
== 2; /* R_386_PC32. */
13718 return reloc_type
== 4; /* R_68K_PC32. */
13720 return reloc_type
== 261; /* R_AARCH64_PREL32 */
13721 case EM_ADAPTEVA_EPIPHANY
:
13722 return reloc_type
== 6;
13724 return reloc_type
== 10; /* R_ALPHA_SREL32. */
13725 case EM_ARC_COMPACT
:
13726 case EM_ARC_COMPACT2
:
13727 return reloc_type
== 49; /* R_ARC_32_PCREL. */
13729 return reloc_type
== 3; /* R_ARM_REL32 */
13732 return reloc_type
== 36; /* R_AVR_32_PCREL. */
13733 case EM_MICROBLAZE
:
13734 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
13736 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
13738 return reloc_type
== 9; /* R_PARISC_PCREL32. */
13740 return reloc_type
== 26; /* R_PPC_REL32. */
13742 return reloc_type
== 26; /* R_PPC64_REL32. */
13744 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
13747 return reloc_type
== 5; /* R_390_PC32. */
13749 return reloc_type
== 2; /* R_SH_REL32. */
13750 case EM_SPARC32PLUS
:
13753 return reloc_type
== 6; /* R_SPARC_DISP32. */
13755 return reloc_type
== 13; /* R_SPU_REL32. */
13757 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
13759 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
13761 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
13765 return reloc_type
== 2; /* R_X86_64_PC32. */
13767 return reloc_type
== 4; /* R_VAX_PCREL32. */
13768 case EM_XTENSA_OLD
:
13770 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
13772 /* Do not abort or issue an error message here. Not all targets use
13773 pc-relative 32-bit relocs in their DWARF debug information and we
13774 have already tested for target coverage in is_32bit_abs_reloc. A
13775 more helpful warning message will be generated by apply_relocations
13776 anyway, so just return. */
13781 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13782 a 64-bit absolute RELA relocation used in DWARF debug sections. */
13785 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13787 switch (filedata
->file_header
.e_machine
)
13790 return reloc_type
== 257; /* R_AARCH64_ABS64. */
13792 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
13794 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
13795 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
13797 return reloc_type
== 80; /* R_PARISC_DIR64. */
13799 return reloc_type
== 38; /* R_PPC64_ADDR64. */
13801 return reloc_type
== 2; /* R_RISCV_64. */
13802 case EM_SPARC32PLUS
:
13805 return reloc_type
== 32 /* R_SPARC_64. */
13806 || reloc_type
== 54; /* R_SPARC_UA64. */
13810 return reloc_type
== 1; /* R_X86_64_64. */
13813 return reloc_type
== 22; /* R_S390_64. */
13815 return reloc_type
== 1; /* R_TILEGX_64. */
13817 return reloc_type
== 18; /* R_MIPS_64. */
13823 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
13824 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
13827 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13829 switch (filedata
->file_header
.e_machine
)
13832 return reloc_type
== 260; /* R_AARCH64_PREL64. */
13834 return reloc_type
== 11; /* R_ALPHA_SREL64. */
13836 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
13837 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
13839 return reloc_type
== 72; /* R_PARISC_PCREL64. */
13841 return reloc_type
== 44; /* R_PPC64_REL64. */
13842 case EM_SPARC32PLUS
:
13845 return reloc_type
== 46; /* R_SPARC_DISP64. */
13849 return reloc_type
== 24; /* R_X86_64_PC64. */
13852 return reloc_type
== 23; /* R_S390_PC64. */
13854 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
13860 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13861 a 24-bit absolute RELA relocation used in DWARF debug sections. */
13864 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13866 switch (filedata
->file_header
.e_machine
)
13868 case EM_CYGNUS_MN10200
:
13870 return reloc_type
== 4; /* R_MN10200_24. */
13872 return reloc_type
== 5; /* R_FT32_20. */
13874 return reloc_type
== 5; /* R_Z80_24. */
13880 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13881 a 16-bit absolute RELA relocation used in DWARF debug sections. */
13884 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13886 /* Please keep this table alpha-sorted for ease of visual lookup. */
13887 switch (filedata
->file_header
.e_machine
)
13890 case EM_ARC_COMPACT
:
13891 case EM_ARC_COMPACT2
:
13892 return reloc_type
== 2; /* R_ARC_16. */
13893 case EM_ADAPTEVA_EPIPHANY
:
13894 return reloc_type
== 5;
13897 return reloc_type
== 4; /* R_AVR_16. */
13898 case EM_CYGNUS_D10V
:
13900 return reloc_type
== 3; /* R_D10V_16. */
13902 return reloc_type
== 2; /* R_FT32_16. */
13906 return reloc_type
== R_H8_DIR16
;
13909 return reloc_type
== 1; /* R_IP2K_16. */
13912 return reloc_type
== 1; /* R_M32C_16 */
13913 case EM_CYGNUS_MN10200
:
13915 return reloc_type
== 2; /* R_MN10200_16. */
13916 case EM_CYGNUS_MN10300
:
13918 return reloc_type
== 2; /* R_MN10300_16. */
13920 if (uses_msp430x_relocs (filedata
))
13921 return reloc_type
== 2; /* R_MSP430_ABS16. */
13922 /* Fall through. */
13923 case EM_MSP430_OLD
:
13924 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13926 return reloc_type
== 19; /* R_NDS32_RELA. */
13927 case EM_ALTERA_NIOS2
:
13928 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13930 return reloc_type
== 9; /* R_NIOS_16. */
13932 return reloc_type
== 2; /* R_OR1K_16. */
13934 return reloc_type
== 55; /* R_RISCV_SET16. */
13936 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13938 return reloc_type
== 2; /* R_C6000_ABS16. */
13940 return reloc_type
== 2; /* R_VISIUM_16. */
13943 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13945 return reloc_type
== 3; /* R_XGATE_16. */
13947 return reloc_type
== 4; /* R_Z80_16. */
13953 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13954 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13957 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13959 switch (filedata
->file_header
.e_machine
)
13962 return reloc_type
== 54; /* R_RISCV_SET8. */
13964 return reloc_type
== 1; /* R_Z80_8. */
13970 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13971 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13974 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13976 switch (filedata
->file_header
.e_machine
)
13979 return reloc_type
== 53; /* R_RISCV_SET6. */
13985 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13986 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13989 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13991 /* Please keep this table alpha-sorted for ease of visual lookup. */
13992 switch (filedata
->file_header
.e_machine
)
13995 return reloc_type
== 35; /* R_RISCV_ADD32. */
14001 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14002 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
14005 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14007 /* Please keep this table alpha-sorted for ease of visual lookup. */
14008 switch (filedata
->file_header
.e_machine
)
14011 return reloc_type
== 39; /* R_RISCV_SUB32. */
14017 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14018 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
14021 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14023 /* Please keep this table alpha-sorted for ease of visual lookup. */
14024 switch (filedata
->file_header
.e_machine
)
14027 return reloc_type
== 36; /* R_RISCV_ADD64. */
14033 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14034 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
14037 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14039 /* Please keep this table alpha-sorted for ease of visual lookup. */
14040 switch (filedata
->file_header
.e_machine
)
14043 return reloc_type
== 40; /* R_RISCV_SUB64. */
14049 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14050 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
14053 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14055 /* Please keep this table alpha-sorted for ease of visual lookup. */
14056 switch (filedata
->file_header
.e_machine
)
14059 return reloc_type
== 34; /* R_RISCV_ADD16. */
14065 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14066 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
14069 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14071 /* Please keep this table alpha-sorted for ease of visual lookup. */
14072 switch (filedata
->file_header
.e_machine
)
14075 return reloc_type
== 38; /* R_RISCV_SUB16. */
14081 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14082 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
14085 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14087 /* Please keep this table alpha-sorted for ease of visual lookup. */
14088 switch (filedata
->file_header
.e_machine
)
14091 return reloc_type
== 33; /* R_RISCV_ADD8. */
14097 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14098 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
14101 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14103 /* Please keep this table alpha-sorted for ease of visual lookup. */
14104 switch (filedata
->file_header
.e_machine
)
14107 return reloc_type
== 37; /* R_RISCV_SUB8. */
14113 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14114 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
14117 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14119 switch (filedata
->file_header
.e_machine
)
14122 return reloc_type
== 52; /* R_RISCV_SUB6. */
14128 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
14129 relocation entries (possibly formerly used for SHT_GROUP sections). */
14132 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14134 switch (filedata
->file_header
.e_machine
)
14136 case EM_386
: /* R_386_NONE. */
14137 case EM_68K
: /* R_68K_NONE. */
14138 case EM_ADAPTEVA_EPIPHANY
:
14139 case EM_ALPHA
: /* R_ALPHA_NONE. */
14140 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
14141 case EM_ARC
: /* R_ARC_NONE. */
14142 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
14143 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
14144 case EM_ARM
: /* R_ARM_NONE. */
14145 case EM_C166
: /* R_XC16X_NONE. */
14146 case EM_CRIS
: /* R_CRIS_NONE. */
14147 case EM_FT32
: /* R_FT32_NONE. */
14148 case EM_IA_64
: /* R_IA64_NONE. */
14149 case EM_K1OM
: /* R_X86_64_NONE. */
14150 case EM_L1OM
: /* R_X86_64_NONE. */
14151 case EM_M32R
: /* R_M32R_NONE. */
14152 case EM_MIPS
: /* R_MIPS_NONE. */
14153 case EM_MN10300
: /* R_MN10300_NONE. */
14154 case EM_MOXIE
: /* R_MOXIE_NONE. */
14155 case EM_NIOS32
: /* R_NIOS_NONE. */
14156 case EM_OR1K
: /* R_OR1K_NONE. */
14157 case EM_PARISC
: /* R_PARISC_NONE. */
14158 case EM_PPC64
: /* R_PPC64_NONE. */
14159 case EM_PPC
: /* R_PPC_NONE. */
14160 case EM_RISCV
: /* R_RISCV_NONE. */
14161 case EM_S390
: /* R_390_NONE. */
14163 case EM_SH
: /* R_SH_NONE. */
14164 case EM_SPARC32PLUS
:
14165 case EM_SPARC
: /* R_SPARC_NONE. */
14167 case EM_TILEGX
: /* R_TILEGX_NONE. */
14168 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
14169 case EM_TI_C6000
:/* R_C6000_NONE. */
14170 case EM_X86_64
: /* R_X86_64_NONE. */
14172 case EM_Z80
: /* R_Z80_NONE. */
14173 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
14174 return reloc_type
== 0;
14177 return reloc_type
== 0 || reloc_type
== 256;
14180 return (reloc_type
== 0 /* R_AVR_NONE. */
14181 || reloc_type
== 30 /* R_AVR_DIFF8. */
14182 || reloc_type
== 31 /* R_AVR_DIFF16. */
14183 || reloc_type
== 32 /* R_AVR_DIFF32. */);
14185 return reloc_type
== 3; /* R_METAG_NONE. */
14187 return (reloc_type
== 0 /* R_XTENSA_NONE. */
14188 || reloc_type
== 204 /* R_NDS32_DIFF8. */
14189 || reloc_type
== 205 /* R_NDS32_DIFF16. */
14190 || reloc_type
== 206 /* R_NDS32_DIFF32. */
14191 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
14193 return (reloc_type
== 0 /* R_PRU_NONE. */
14194 || reloc_type
== 65 /* R_PRU_DIFF8. */
14195 || reloc_type
== 66 /* R_PRU_DIFF16. */
14196 || reloc_type
== 67 /* R_PRU_DIFF32. */);
14197 case EM_XTENSA_OLD
:
14199 return (reloc_type
== 0 /* R_XTENSA_NONE. */
14200 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
14201 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
14202 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
14203 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
14204 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
14205 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
14206 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
14207 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
14208 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
14213 /* Returns TRUE if there is a relocation against
14214 section NAME at OFFSET bytes. */
14217 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
14219 Elf_Internal_Rela
* relocs
;
14220 Elf_Internal_Rela
* rp
;
14222 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
14225 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
14227 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
14228 if (rp
->r_offset
== offset
)
14234 /* Apply relocations to a section.
14235 Returns TRUE upon success, FALSE otherwise.
14236 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
14237 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
14238 will be set to the number of relocs loaded.
14240 Note: So far support has been added only for those relocations
14241 which can be found in debug sections. FIXME: Add support for
14242 more relocations ? */
14245 apply_relocations (Filedata
* filedata
,
14246 const Elf_Internal_Shdr
* section
,
14247 unsigned char * start
,
14248 bfd_size_type size
,
14249 void ** relocs_return
,
14250 unsigned long * num_relocs_return
)
14252 Elf_Internal_Shdr
* relsec
;
14253 unsigned char * end
= start
+ size
;
14255 if (relocs_return
!= NULL
)
14257 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
14258 * num_relocs_return
= 0;
14261 if (filedata
->file_header
.e_type
!= ET_REL
)
14262 /* No relocs to apply. */
14265 /* Find the reloc section associated with the section. */
14266 for (relsec
= filedata
->section_headers
;
14267 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14271 unsigned long num_relocs
;
14272 Elf_Internal_Rela
* relocs
;
14273 Elf_Internal_Rela
* rp
;
14274 Elf_Internal_Shdr
* symsec
;
14275 Elf_Internal_Sym
* symtab
;
14276 unsigned long num_syms
;
14277 Elf_Internal_Sym
* sym
;
14279 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14280 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14281 || filedata
->section_headers
+ relsec
->sh_info
!= section
14282 || relsec
->sh_size
== 0
14283 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14286 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
14287 if (symsec
->sh_type
!= SHT_SYMTAB
14288 && symsec
->sh_type
!= SHT_DYNSYM
)
14291 is_rela
= relsec
->sh_type
== SHT_RELA
;
14295 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
14296 relsec
->sh_size
, & relocs
, & num_relocs
))
14301 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
14302 relsec
->sh_size
, & relocs
, & num_relocs
))
14306 /* SH uses RELA but uses in place value instead of the addend field. */
14307 if (filedata
->file_header
.e_machine
== EM_SH
)
14310 symtab
= get_elf_symbols (filedata
, symsec
, & num_syms
);
14312 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
14315 unsigned int reloc_type
;
14316 unsigned int reloc_size
;
14317 bool reloc_inplace
= false;
14318 bool reloc_subtract
= false;
14319 unsigned char *rloc
;
14320 unsigned long sym_index
;
14322 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
14324 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
14326 else if (is_none_reloc (filedata
, reloc_type
))
14328 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
14329 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
14331 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
14332 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
14334 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
14336 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
14338 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
14339 || is_6bit_abs_reloc (filedata
, reloc_type
))
14341 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
14343 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
14346 reloc_inplace
= true;
14348 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
14350 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
14353 reloc_inplace
= true;
14355 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
14357 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
14360 reloc_inplace
= true;
14362 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
14364 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
14367 reloc_inplace
= true;
14369 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
14373 reloc_inplace
= true;
14377 static unsigned int prev_reloc
= 0;
14379 if (reloc_type
!= prev_reloc
)
14380 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
14381 reloc_type
, printable_section_name (filedata
, section
));
14382 prev_reloc
= reloc_type
;
14386 rloc
= start
+ rp
->r_offset
;
14387 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
14389 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
14390 (unsigned long) rp
->r_offset
,
14391 printable_section_name (filedata
, section
));
14395 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
14396 if (sym_index
>= num_syms
)
14398 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
14399 sym_index
, printable_section_name (filedata
, section
));
14402 sym
= symtab
+ sym_index
;
14404 /* If the reloc has a symbol associated with it,
14405 make sure that it is of an appropriate type.
14407 Relocations against symbols without type can happen.
14408 Gcc -feliminate-dwarf2-dups may generate symbols
14409 without type for debug info.
14411 Icc generates relocations against function symbols
14412 instead of local labels.
14414 Relocations against object symbols can happen, eg when
14415 referencing a global array. For an example of this see
14416 the _clz.o binary in libgcc.a. */
14418 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
14419 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
14421 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
14422 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
14423 printable_section_name (filedata
, relsec
),
14424 (long int)(rp
- relocs
));
14430 addend
+= rp
->r_addend
;
14431 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
14432 partial_inplace. */
14434 || (filedata
->file_header
.e_machine
== EM_XTENSA
14435 && reloc_type
== 1)
14436 || ((filedata
->file_header
.e_machine
== EM_PJ
14437 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
14438 && reloc_type
== 1)
14439 || ((filedata
->file_header
.e_machine
== EM_D30V
14440 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
14441 && reloc_type
== 12)
14444 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
14445 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
14447 addend
+= byte_get (rloc
, reloc_size
);
14450 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
14451 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
14453 /* On HPPA, all pc-relative relocations are biased by 8. */
14454 if (filedata
->file_header
.e_machine
== EM_PARISC
)
14456 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
14459 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
14460 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
14462 if (reloc_subtract
)
14463 addend
-= sym
->st_value
;
14465 addend
+= sym
->st_value
;
14466 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
14467 byte_put (rloc
, addend
, reloc_size
);
14469 else if (reloc_subtract
)
14470 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
14472 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
14476 /* Let the target specific reloc processing code know that
14477 we have finished with these relocs. */
14478 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
14482 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
14483 * num_relocs_return
= num_relocs
;
14494 #ifdef SUPPORT_DISASSEMBLY
14496 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14498 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
14500 /* FIXME: XXX -- to be done --- XXX */
14506 /* Reads in the contents of SECTION from FILE, returning a pointer
14507 to a malloc'ed buffer or NULL if something went wrong. */
14510 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14512 bfd_size_type num_bytes
= section
->sh_size
;
14514 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
14516 printf (_("Section '%s' has no data to dump.\n"),
14517 printable_section_name (filedata
, section
));
14521 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
14522 _("section contents"));
14525 /* Uncompresses a section that was compressed using zlib, in place. */
14528 uncompress_section_contents (unsigned char ** buffer
,
14529 dwarf_size_type uncompressed_size
,
14530 dwarf_size_type
* size
)
14532 dwarf_size_type compressed_size
= *size
;
14533 unsigned char * compressed_buffer
= *buffer
;
14534 unsigned char * uncompressed_buffer
;
14538 /* It is possible the section consists of several compressed
14539 buffers concatenated together, so we uncompress in a loop. */
14540 /* PR 18313: The state field in the z_stream structure is supposed
14541 to be invisible to the user (ie us), but some compilers will
14542 still complain about it being used without initialisation. So
14543 we first zero the entire z_stream structure and then set the fields
14545 memset (& strm
, 0, sizeof strm
);
14546 strm
.avail_in
= compressed_size
;
14547 strm
.next_in
= (Bytef
*) compressed_buffer
;
14548 strm
.avail_out
= uncompressed_size
;
14549 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
14551 rc
= inflateInit (& strm
);
14552 while (strm
.avail_in
> 0)
14556 strm
.next_out
= ((Bytef
*) uncompressed_buffer
14557 + (uncompressed_size
- strm
.avail_out
));
14558 rc
= inflate (&strm
, Z_FINISH
);
14559 if (rc
!= Z_STREAM_END
)
14561 rc
= inflateReset (& strm
);
14563 if (inflateEnd (& strm
) != Z_OK
14565 || strm
.avail_out
!= 0)
14568 *buffer
= uncompressed_buffer
;
14569 *size
= uncompressed_size
;
14573 free (uncompressed_buffer
);
14574 /* Indicate decompression failure. */
14580 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14582 Elf_Internal_Shdr
*relsec
;
14583 bfd_size_type num_bytes
;
14584 unsigned char *data
;
14585 unsigned char *end
;
14586 unsigned char *real_start
;
14587 unsigned char *start
;
14588 bool some_strings_shown
;
14590 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
14592 /* PR 21820: Do not fail if the section was empty. */
14593 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
14595 num_bytes
= section
->sh_size
;
14597 if (filedata
->is_separate
)
14598 printf (_("\nString dump of section '%s' in linked file %s:\n"),
14599 printable_section_name (filedata
, section
),
14600 filedata
->file_name
);
14602 printf (_("\nString dump of section '%s':\n"),
14603 printable_section_name (filedata
, section
));
14605 if (decompress_dumps
)
14607 dwarf_size_type new_size
= num_bytes
;
14608 dwarf_size_type uncompressed_size
= 0;
14610 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14612 Elf_Internal_Chdr chdr
;
14613 unsigned int compression_header_size
14614 = get_compression_header (& chdr
, (unsigned char *) start
,
14616 if (compression_header_size
== 0)
14617 /* An error message will have already been generated
14618 by get_compression_header. */
14621 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14623 warn (_("section '%s' has unsupported compress type: %d\n"),
14624 printable_section_name (filedata
, section
), chdr
.ch_type
);
14627 uncompressed_size
= chdr
.ch_size
;
14628 start
+= compression_header_size
;
14629 new_size
-= compression_header_size
;
14631 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14633 /* Read the zlib header. In this case, it should be "ZLIB"
14634 followed by the uncompressed section size, 8 bytes in
14635 big-endian order. */
14636 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14637 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14638 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14639 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14640 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14641 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14642 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14643 uncompressed_size
+= start
[11];
14648 if (uncompressed_size
)
14650 if (uncompress_section_contents (& start
,
14651 uncompressed_size
, & new_size
))
14652 num_bytes
= new_size
;
14655 error (_("Unable to decompress section %s\n"),
14656 printable_section_name (filedata
, section
));
14661 start
= real_start
;
14664 /* If the section being dumped has relocations against it the user might
14665 be expecting these relocations to have been applied. Check for this
14666 case and issue a warning message in order to avoid confusion.
14667 FIXME: Maybe we ought to have an option that dumps a section with
14668 relocs applied ? */
14669 for (relsec
= filedata
->section_headers
;
14670 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14673 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14674 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14675 || filedata
->section_headers
+ relsec
->sh_info
!= section
14676 || relsec
->sh_size
== 0
14677 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14680 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14685 end
= start
+ num_bytes
;
14686 some_strings_shown
= false;
14688 #ifdef HAVE_MBSTATE_T
14690 /* Initialise the multibyte conversion state. */
14691 memset (& state
, 0, sizeof (state
));
14694 bool continuing
= false;
14698 while (!ISPRINT (* data
))
14699 if (++ data
>= end
)
14704 size_t maxlen
= end
- data
;
14709 continuing
= false;
14713 printf (" [%6lx] ", (unsigned long) (data
- start
));
14727 /* PR 25543: Treat new-lines as string-ending characters. */
14736 /* Do not print control characters directly as they can affect terminal
14737 settings. Such characters usually appear in the names generated
14738 by the assembler for local labels. */
14741 printf ("^%c", c
+ 0x40);
14743 else if (ISPRINT (c
))
14750 #ifdef HAVE_MBSTATE_T
14753 /* Let printf do the hard work of displaying multibyte characters. */
14754 printf ("%.1s", data
- 1);
14755 #ifdef HAVE_MBSTATE_T
14756 /* Try to find out how many bytes made up the character that was
14757 just printed. Advance the symbol pointer past the bytes that
14759 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
14763 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
14773 printf (_("<corrupt>\n"));
14776 some_strings_shown
= true;
14780 if (! some_strings_shown
)
14781 printf (_(" No strings found in this section."));
14794 dump_section_as_bytes (Elf_Internal_Shdr
*section
,
14795 Filedata
*filedata
,
14798 Elf_Internal_Shdr
* relsec
;
14799 bfd_size_type bytes
;
14800 bfd_size_type section_size
;
14802 unsigned char * data
;
14803 unsigned char * real_start
;
14804 unsigned char * start
;
14806 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
14808 /* PR 21820: Do not fail if the section was empty. */
14809 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
14811 section_size
= section
->sh_size
;
14813 if (filedata
->is_separate
)
14814 printf (_("\nHex dump of section '%s' in linked file %s:\n"),
14815 printable_section_name (filedata
, section
),
14816 filedata
->file_name
);
14818 printf (_("\nHex dump of section '%s':\n"),
14819 printable_section_name (filedata
, section
));
14821 if (decompress_dumps
)
14823 dwarf_size_type new_size
= section_size
;
14824 dwarf_size_type uncompressed_size
= 0;
14826 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14828 Elf_Internal_Chdr chdr
;
14829 unsigned int compression_header_size
14830 = get_compression_header (& chdr
, start
, section_size
);
14832 if (compression_header_size
== 0)
14833 /* An error message will have already been generated
14834 by get_compression_header. */
14837 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14839 warn (_("section '%s' has unsupported compress type: %d\n"),
14840 printable_section_name (filedata
, section
), chdr
.ch_type
);
14843 uncompressed_size
= chdr
.ch_size
;
14844 start
+= compression_header_size
;
14845 new_size
-= compression_header_size
;
14847 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14849 /* Read the zlib header. In this case, it should be "ZLIB"
14850 followed by the uncompressed section size, 8 bytes in
14851 big-endian order. */
14852 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14853 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14854 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14855 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14856 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14857 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14858 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14859 uncompressed_size
+= start
[11];
14864 if (uncompressed_size
)
14866 if (uncompress_section_contents (& start
, uncompressed_size
,
14869 section_size
= new_size
;
14873 error (_("Unable to decompress section %s\n"),
14874 printable_section_name (filedata
, section
));
14875 /* FIXME: Print the section anyway ? */
14880 start
= real_start
;
14885 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
14890 /* If the section being dumped has relocations against it the user might
14891 be expecting these relocations to have been applied. Check for this
14892 case and issue a warning message in order to avoid confusion.
14893 FIXME: Maybe we ought to have an option that dumps a section with
14894 relocs applied ? */
14895 for (relsec
= filedata
->section_headers
;
14896 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14899 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14900 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14901 || filedata
->section_headers
+ relsec
->sh_info
!= section
14902 || relsec
->sh_size
== 0
14903 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14906 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14911 addr
= section
->sh_addr
;
14912 bytes
= section_size
;
14921 lbytes
= (bytes
> 16 ? 16 : bytes
);
14923 printf (" 0x%8.8lx ", (unsigned long) addr
);
14925 for (j
= 0; j
< 16; j
++)
14928 printf ("%2.2x", data
[j
]);
14936 for (j
= 0; j
< lbytes
; j
++)
14939 if (k
>= ' ' && k
< 0x7f)
14962 #ifdef ENABLE_LIBCTF
14963 static ctf_sect_t
*
14964 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14966 buf
->cts_name
= SECTION_NAME_PRINT (shdr
);
14967 buf
->cts_size
= shdr
->sh_size
;
14968 buf
->cts_entsize
= shdr
->sh_entsize
;
14973 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14974 it is passed, or a pointer to newly-allocated storage, in which case
14975 dump_ctf() will free it when it no longer needs it. */
14978 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14979 char *s
, void *arg
)
14981 const char *blanks
= arg
;
14984 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14989 /* Dump CTF errors/warnings. */
14991 dump_ctf_errs (ctf_dict_t
*fp
)
14993 ctf_next_t
*it
= NULL
;
14998 /* Dump accumulated errors and warnings. */
14999 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
15001 error (_("%s: %s"), is_warning
? _("warning"): _("error"),
15005 if (err
!= ECTF_NEXT_END
)
15006 error (_("CTF error: cannot get CTF errors: `%s'"), ctf_errmsg (err
));
15009 /* Dump one CTF archive member. */
15012 dump_ctf_archive_member (ctf_dict_t
*ctf
, const char *name
, void *arg
)
15014 ctf_dict_t
*parent
= (ctf_dict_t
*) arg
;
15015 const char *things
[] = {"Header", "Labels", "Data objects",
15016 "Function objects", "Variables", "Types", "Strings",
15018 const char **thing
;
15022 /* Only print out the name of non-default-named archive members.
15023 The name .ctf appears everywhere, even for things that aren't
15024 really archives, so printing it out is liable to be confusing.
15026 The parent, if there is one, is the default-owned archive member:
15027 avoid importing it into itself. (This does no harm, but looks
15030 if (strcmp (name
, ".ctf") != 0)
15032 printf (_("\nCTF archive member: %s:\n"), name
);
15033 ctf_import (ctf
, parent
);
15036 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
15038 ctf_dump_state_t
*s
= NULL
;
15041 printf ("\n %s:\n", *thing
);
15042 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
15043 (void *) " ")) != NULL
)
15045 printf ("%s\n", item
);
15049 if (ctf_errno (ctf
))
15051 error (_("Iteration failed: %s, %s\n"), *thing
,
15052 ctf_errmsg (ctf_errno (ctf
)));
15059 dump_ctf_errs (ctf
);
15064 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15066 Elf_Internal_Shdr
* parent_sec
= NULL
;
15067 Elf_Internal_Shdr
* symtab_sec
= NULL
;
15068 Elf_Internal_Shdr
* strtab_sec
= NULL
;
15069 void * data
= NULL
;
15070 void * symdata
= NULL
;
15071 void * strdata
= NULL
;
15072 void * parentdata
= NULL
;
15073 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
15074 ctf_sect_t
* symsectp
= NULL
;
15075 ctf_sect_t
* strsectp
= NULL
;
15076 ctf_archive_t
* ctfa
= NULL
;
15077 ctf_archive_t
* parenta
= NULL
, *lookparent
;
15078 ctf_dict_t
* parent
= NULL
;
15083 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
15084 data
= get_section_contents (section
, filedata
);
15085 ctfsect
.cts_data
= data
;
15087 if (!dump_ctf_symtab_name
)
15088 dump_ctf_symtab_name
= strdup (".dynsym");
15090 if (!dump_ctf_strtab_name
)
15091 dump_ctf_strtab_name
= strdup (".dynstr");
15093 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
15095 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
15097 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
15100 if ((symdata
= (void *) get_data (NULL
, filedata
,
15101 symtab_sec
->sh_offset
, 1,
15102 symtab_sec
->sh_size
,
15103 _("symbols"))) == NULL
)
15105 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
15106 symsect
.cts_data
= symdata
;
15109 if (dump_ctf_strtab_name
&& dump_ctf_strtab_name
[0] != 0)
15111 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
15113 error (_("No string table section named %s\n"),
15114 dump_ctf_strtab_name
);
15117 if ((strdata
= (void *) get_data (NULL
, filedata
,
15118 strtab_sec
->sh_offset
, 1,
15119 strtab_sec
->sh_size
,
15120 _("strings"))) == NULL
)
15122 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
15123 strsect
.cts_data
= strdata
;
15126 if (dump_ctf_parent_name
)
15128 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
15130 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
15133 if ((parentdata
= (void *) get_data (NULL
, filedata
,
15134 parent_sec
->sh_offset
, 1,
15135 parent_sec
->sh_size
,
15136 _("CTF parent"))) == NULL
)
15138 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
15139 parentsect
.cts_data
= parentdata
;
15142 /* Load the CTF file and dump it. It may be a raw CTF section, or an archive:
15143 libctf papers over the difference, so we can pretend it is always an
15144 archive. Possibly open the parent as well, if one was specified. */
15146 if ((ctfa
= ctf_arc_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
15148 dump_ctf_errs (NULL
);
15149 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15153 ctf_arc_symsect_endianness (ctfa
, filedata
->file_header
.e_ident
[EI_DATA
]
15158 if ((parenta
= ctf_arc_bufopen (&parentsect
, symsectp
, strsectp
,
15161 dump_ctf_errs (NULL
);
15162 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15165 lookparent
= parenta
;
15170 /* Assume that the applicable parent archive member is the default one.
15171 (This is what all known implementations are expected to do, if they
15172 put CTFs and their parents in archives together.) */
15173 if ((parent
= ctf_dict_open (lookparent
, NULL
, &err
)) == NULL
)
15175 dump_ctf_errs (NULL
);
15176 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15182 if (filedata
->is_separate
)
15183 printf (_("\nDump of CTF section '%s' in linked file %s:\n"),
15184 printable_section_name (filedata
, section
),
15185 filedata
->file_name
);
15187 printf (_("\nDump of CTF section '%s':\n"),
15188 printable_section_name (filedata
, section
));
15190 if ((err
= ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
)) != 0)
15192 dump_ctf_errs (NULL
);
15193 error (_("CTF member open failure: %s\n"), ctf_errmsg (err
));
15198 ctf_dict_close (parent
);
15200 ctf_close (parenta
);
15210 load_specific_debug_section (enum dwarf_section_display_enum debug
,
15211 const Elf_Internal_Shdr
* sec
,
15214 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15216 Filedata
* filedata
= (Filedata
*) data
;
15218 if (section
->start
!= NULL
)
15220 /* If it is already loaded, do nothing. */
15221 if (streq (section
->filename
, filedata
->file_name
))
15223 free (section
->start
);
15226 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
15227 section
->address
= sec
->sh_addr
;
15228 section
->filename
= filedata
->file_name
;
15229 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
15231 sec
->sh_size
, buf
);
15232 if (section
->start
== NULL
)
15236 unsigned char *start
= section
->start
;
15237 dwarf_size_type size
= sec
->sh_size
;
15238 dwarf_size_type uncompressed_size
= 0;
15240 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
15242 Elf_Internal_Chdr chdr
;
15243 unsigned int compression_header_size
;
15245 if (size
< (is_32bit_elf
15246 ? sizeof (Elf32_External_Chdr
)
15247 : sizeof (Elf64_External_Chdr
)))
15249 warn (_("compressed section %s is too small to contain a compression header\n"),
15254 compression_header_size
= get_compression_header (&chdr
, start
, size
);
15255 if (compression_header_size
== 0)
15256 /* An error message will have already been generated
15257 by get_compression_header. */
15260 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
15262 warn (_("section '%s' has unsupported compress type: %d\n"),
15263 section
->name
, chdr
.ch_type
);
15266 uncompressed_size
= chdr
.ch_size
;
15267 start
+= compression_header_size
;
15268 size
-= compression_header_size
;
15270 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
15272 /* Read the zlib header. In this case, it should be "ZLIB"
15273 followed by the uncompressed section size, 8 bytes in
15274 big-endian order. */
15275 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
15276 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
15277 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
15278 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
15279 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
15280 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
15281 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
15282 uncompressed_size
+= start
[11];
15287 if (uncompressed_size
)
15289 if (uncompress_section_contents (&start
, uncompressed_size
,
15292 /* Free the compressed buffer, update the section buffer
15293 and the section size if uncompress is successful. */
15294 free (section
->start
);
15295 section
->start
= start
;
15299 error (_("Unable to decompress section %s\n"),
15300 printable_section_name (filedata
, sec
));
15305 section
->size
= size
;
15308 if (section
->start
== NULL
)
15311 if (debug_displays
[debug
].relocate
)
15313 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
15314 & section
->reloc_info
, & section
->num_relocs
))
15319 section
->reloc_info
= NULL
;
15320 section
->num_relocs
= 0;
15326 #if HAVE_LIBDEBUGINFOD
15327 /* Return a hex string representation of the build-id. */
15329 get_build_id (void * data
)
15331 Filedata
* filedata
= (Filedata
*) data
;
15332 Elf_Internal_Shdr
* shdr
;
15335 /* Iterate through notes to find note.gnu.build-id.
15336 FIXME: Only the first note in any note section is examined. */
15337 for (i
= 0, shdr
= filedata
->section_headers
;
15338 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
15341 if (shdr
->sh_type
!= SHT_NOTE
)
15346 size_t data_remaining
;
15348 Elf_External_Note
* enote
;
15349 Elf_Internal_Note inote
;
15351 bfd_vma offset
= shdr
->sh_offset
;
15352 bfd_vma align
= shdr
->sh_addralign
;
15353 bfd_vma length
= shdr
->sh_size
;
15355 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
15361 else if (align
!= 4 && align
!= 8)
15367 end
= (char *) enote
+ length
;
15368 data_remaining
= end
- (char *) enote
;
15370 if (!is_ia64_vms (filedata
))
15372 min_notesz
= offsetof (Elf_External_Note
, name
);
15373 if (data_remaining
< min_notesz
)
15376 malformed note encountered in section %s whilst scanning for build-id note\n"),
15377 printable_section_name (filedata
, shdr
));
15381 data_remaining
-= min_notesz
;
15383 inote
.type
= BYTE_GET (enote
->type
);
15384 inote
.namesz
= BYTE_GET (enote
->namesz
);
15385 inote
.namedata
= enote
->name
;
15386 inote
.descsz
= BYTE_GET (enote
->descsz
);
15387 inote
.descdata
= ((char *) enote
15388 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
15389 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
15390 next
= ((char *) enote
15391 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
15395 Elf64_External_VMS_Note
*vms_enote
;
15397 /* PR binutils/15191
15398 Make sure that there is enough data to read. */
15399 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
15400 if (data_remaining
< min_notesz
)
15403 malformed note encountered in section %s whilst scanning for build-id note\n"),
15404 printable_section_name (filedata
, shdr
));
15408 data_remaining
-= min_notesz
;
15410 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
15411 inote
.type
= BYTE_GET (vms_enote
->type
);
15412 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
15413 inote
.namedata
= vms_enote
->name
;
15414 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
15415 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
15416 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
15417 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
15420 /* Skip malformed notes. */
15421 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
15422 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
15423 || (size_t) (next
- inote
.descdata
) < inote
.descsz
15424 || ((size_t) (next
- inote
.descdata
)
15425 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
15428 malformed note encountered in section %s whilst scanning for build-id note\n"),
15429 printable_section_name (filedata
, shdr
));
15434 /* Check if this is the build-id note. If so then convert the build-id
15435 bytes to a hex string. */
15436 if (inote
.namesz
> 0
15437 && startswith (inote
.namedata
, "GNU")
15438 && inote
.type
== NT_GNU_BUILD_ID
)
15443 build_id
= malloc (inote
.descsz
* 2 + 1);
15444 if (build_id
== NULL
)
15450 for (j
= 0; j
< inote
.descsz
; ++j
)
15451 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
15452 build_id
[inote
.descsz
* 2] = '\0';
15455 return (unsigned char *) build_id
;
15462 #endif /* HAVE_LIBDEBUGINFOD */
15464 /* If this is not NULL, load_debug_section will only look for sections
15465 within the list of sections given here. */
15466 static unsigned int * section_subset
= NULL
;
15469 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
15471 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15472 Elf_Internal_Shdr
* sec
;
15473 Filedata
* filedata
= (Filedata
*) data
;
15475 /* Without section headers we cannot find any sections. */
15476 if (filedata
->section_headers
== NULL
)
15479 if (filedata
->string_table
== NULL
15480 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
15481 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
15483 Elf_Internal_Shdr
* strs
;
15485 /* Read in the string table, so that we have section names to scan. */
15486 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
15488 if (strs
!= NULL
&& strs
->sh_size
!= 0)
15490 filedata
->string_table
15491 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
15492 1, strs
->sh_size
, _("string table"));
15494 filedata
->string_table_length
15495 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
15499 /* Locate the debug section. */
15500 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
15502 section
->name
= section
->uncompressed_name
;
15505 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
15507 section
->name
= section
->compressed_name
;
15512 /* If we're loading from a subset of sections, and we've loaded
15513 a section matching this name before, it's likely that it's a
15515 if (section_subset
!= NULL
)
15516 free_debug_section (debug
);
15518 return load_specific_debug_section (debug
, sec
, data
);
15522 free_debug_section (enum dwarf_section_display_enum debug
)
15524 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15526 if (section
->start
== NULL
)
15529 free ((char *) section
->start
);
15530 section
->start
= NULL
;
15531 section
->address
= 0;
15534 free (section
->reloc_info
);
15535 section
->reloc_info
= NULL
;
15536 section
->num_relocs
= 0;
15540 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15542 char * name
= SECTION_NAME_VALID (section
) ? SECTION_NAME (section
) : "";
15543 const char * print_name
= printable_section_name (filedata
, section
);
15544 bfd_size_type length
;
15545 bool result
= true;
15548 length
= section
->sh_size
;
15551 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
15554 if (section
->sh_type
== SHT_NOBITS
)
15556 /* There is no point in dumping the contents of a debugging section
15557 which has the NOBITS type - the bits in the file will be random.
15558 This can happen when a file containing a .eh_frame section is
15559 stripped with the --only-keep-debug command line option. */
15560 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
15565 if (startswith (name
, ".gnu.linkonce.wi."))
15566 name
= ".debug_info";
15568 /* See if we know how to display the contents of this section. */
15569 for (i
= 0; i
< max
; i
++)
15571 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
15572 struct dwarf_section_display
* display
= debug_displays
+ i
;
15573 struct dwarf_section
* sec
= & display
->section
;
15575 if (streq (sec
->uncompressed_name
, name
)
15576 || (id
== line
&& startswith (name
, ".debug_line."))
15577 || streq (sec
->compressed_name
, name
))
15579 bool secondary
= (section
!= find_section (filedata
, name
));
15582 free_debug_section (id
);
15584 if (i
== line
&& startswith (name
, ".debug_line."))
15586 else if (streq (sec
->uncompressed_name
, name
))
15587 sec
->name
= sec
->uncompressed_name
;
15589 sec
->name
= sec
->compressed_name
;
15591 if (load_specific_debug_section (id
, section
, filedata
))
15593 /* If this debug section is part of a CU/TU set in a .dwp file,
15594 restrict load_debug_section to the sections in that set. */
15595 section_subset
= find_cu_tu_set (filedata
, shndx
);
15597 result
&= display
->display (sec
, filedata
);
15599 section_subset
= NULL
;
15601 if (secondary
|| (id
!= info
&& id
!= abbrev
&& id
!= debug_addr
))
15602 free_debug_section (id
);
15610 printf (_("Unrecognized debug section: %s\n"), print_name
);
15617 /* Set DUMP_SECTS for all sections where dumps were requested
15618 based on section name. */
15621 initialise_dumps_byname (Filedata
* filedata
)
15623 struct dump_list_entry
* cur
;
15625 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
15630 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
15631 if (SECTION_NAME_VALID (filedata
->section_headers
+ i
)
15632 && streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
15634 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
15638 if (!any
&& !filedata
->is_separate
)
15639 warn (_("Section '%s' was not dumped because it does not exist\n"),
15645 process_section_contents (Filedata
* filedata
)
15647 Elf_Internal_Shdr
* section
;
15654 initialise_dumps_byname (filedata
);
15656 for (i
= 0, section
= filedata
->section_headers
;
15657 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
15660 dump_type dump
= filedata
->dump
.dump_sects
[i
];
15662 if (filedata
->is_separate
&& ! process_links
)
15663 dump
&= DEBUG_DUMP
;
15665 #ifdef SUPPORT_DISASSEMBLY
15666 if (dump
& DISASS_DUMP
)
15668 if (! disassemble_section (section
, filedata
))
15672 if (dump
& HEX_DUMP
)
15674 if (! dump_section_as_bytes (section
, filedata
, false))
15678 if (dump
& RELOC_DUMP
)
15680 if (! dump_section_as_bytes (section
, filedata
, true))
15684 if (dump
& STRING_DUMP
)
15686 if (! dump_section_as_strings (section
, filedata
))
15690 if (dump
& DEBUG_DUMP
)
15692 if (! display_debug_section (i
, section
, filedata
))
15696 #ifdef ENABLE_LIBCTF
15697 if (dump
& CTF_DUMP
)
15699 if (! dump_section_as_ctf (section
, filedata
))
15705 if (! filedata
->is_separate
)
15707 /* Check to see if the user requested a
15708 dump of a section that does not exist. */
15709 for (; i
< filedata
->dump
.num_dump_sects
; i
++)
15710 if (filedata
->dump
.dump_sects
[i
])
15712 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
15721 process_mips_fpe_exception (int mask
)
15727 if (mask
& OEX_FPU_INEX
)
15728 fputs ("INEX", stdout
), first
= false;
15729 if (mask
& OEX_FPU_UFLO
)
15730 printf ("%sUFLO", first
? "" : "|"), first
= false;
15731 if (mask
& OEX_FPU_OFLO
)
15732 printf ("%sOFLO", first
? "" : "|"), first
= false;
15733 if (mask
& OEX_FPU_DIV0
)
15734 printf ("%sDIV0", first
? "" : "|"), first
= false;
15735 if (mask
& OEX_FPU_INVAL
)
15736 printf ("%sINVAL", first
? "" : "|");
15739 fputs ("0", stdout
);
15742 /* Display's the value of TAG at location P. If TAG is
15743 greater than 0 it is assumed to be an unknown tag, and
15744 a message is printed to this effect. Otherwise it is
15745 assumed that a message has already been printed.
15747 If the bottom bit of TAG is set it assumed to have a
15748 string value, otherwise it is assumed to have an integer
15751 Returns an updated P pointing to the first unread byte
15752 beyond the end of TAG's value.
15754 Reads at or beyond END will not be made. */
15756 static unsigned char *
15757 display_tag_value (signed int tag
,
15759 const unsigned char * const end
)
15764 printf (" Tag_unknown_%d: ", tag
);
15768 warn (_("<corrupt tag>\n"));
15772 /* PR 17531 file: 027-19978-0.004. */
15773 size_t maxlen
= (end
- p
) - 1;
15778 print_symbol ((int) maxlen
, (const char *) p
);
15779 p
+= strnlen ((char *) p
, maxlen
) + 1;
15783 printf (_("<corrupt string tag>"));
15784 p
= (unsigned char *) end
;
15790 READ_ULEB (val
, p
, end
);
15791 printf ("%ld (0x%lx)\n", val
, val
);
15798 /* ARC ABI attributes section. */
15800 static unsigned char *
15801 display_arc_attribute (unsigned char * p
,
15802 const unsigned char * const end
)
15807 READ_ULEB (tag
, p
, end
);
15811 case Tag_ARC_PCS_config
:
15812 READ_ULEB (val
, p
, end
);
15813 printf (" Tag_ARC_PCS_config: ");
15817 printf (_("Absent/Non standard\n"));
15820 printf (_("Bare metal/mwdt\n"));
15823 printf (_("Bare metal/newlib\n"));
15826 printf (_("Linux/uclibc\n"));
15829 printf (_("Linux/glibc\n"));
15832 printf (_("Unknown\n"));
15837 case Tag_ARC_CPU_base
:
15838 READ_ULEB (val
, p
, end
);
15839 printf (" Tag_ARC_CPU_base: ");
15844 printf (_("Absent\n"));
15846 case TAG_CPU_ARC6xx
:
15847 printf ("ARC6xx\n");
15849 case TAG_CPU_ARC7xx
:
15850 printf ("ARC7xx\n");
15852 case TAG_CPU_ARCEM
:
15853 printf ("ARCEM\n");
15855 case TAG_CPU_ARCHS
:
15856 printf ("ARCHS\n");
15861 case Tag_ARC_CPU_variation
:
15862 READ_ULEB (val
, p
, end
);
15863 printf (" Tag_ARC_CPU_variation: ");
15867 if (val
> 0 && val
< 16)
15868 printf ("Core%d\n", val
);
15870 printf ("Unknown\n");
15874 printf (_("Absent\n"));
15879 case Tag_ARC_CPU_name
:
15880 printf (" Tag_ARC_CPU_name: ");
15881 p
= display_tag_value (-1, p
, end
);
15884 case Tag_ARC_ABI_rf16
:
15885 READ_ULEB (val
, p
, end
);
15886 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
15889 case Tag_ARC_ABI_osver
:
15890 READ_ULEB (val
, p
, end
);
15891 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
15894 case Tag_ARC_ABI_pic
:
15895 case Tag_ARC_ABI_sda
:
15896 READ_ULEB (val
, p
, end
);
15897 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
15898 : " Tag_ARC_ABI_pic: ");
15902 printf (_("Absent\n"));
15911 printf (_("Unknown\n"));
15916 case Tag_ARC_ABI_tls
:
15917 READ_ULEB (val
, p
, end
);
15918 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
15921 case Tag_ARC_ABI_enumsize
:
15922 READ_ULEB (val
, p
, end
);
15923 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
15927 case Tag_ARC_ABI_exceptions
:
15928 READ_ULEB (val
, p
, end
);
15929 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
15933 case Tag_ARC_ABI_double_size
:
15934 READ_ULEB (val
, p
, end
);
15935 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
15938 case Tag_ARC_ISA_config
:
15939 printf (" Tag_ARC_ISA_config: ");
15940 p
= display_tag_value (-1, p
, end
);
15943 case Tag_ARC_ISA_apex
:
15944 printf (" Tag_ARC_ISA_apex: ");
15945 p
= display_tag_value (-1, p
, end
);
15948 case Tag_ARC_ISA_mpy_option
:
15949 READ_ULEB (val
, p
, end
);
15950 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
15953 case Tag_ARC_ATR_version
:
15954 READ_ULEB (val
, p
, end
);
15955 printf (" Tag_ARC_ATR_version: %d\n", val
);
15959 return display_tag_value (tag
& 1, p
, end
);
15965 /* ARM EABI attributes section. */
15970 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
15972 const char *const *table
;
15973 } arm_attr_public_tag
;
15975 static const char *const arm_attr_tag_CPU_arch
[] =
15976 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
15977 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
15978 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
15979 static const char *const arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
15980 static const char *const arm_attr_tag_THUMB_ISA_use
[] =
15981 {"No", "Thumb-1", "Thumb-2", "Yes"};
15982 static const char *const arm_attr_tag_FP_arch
[] =
15983 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
15984 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
15985 static const char *const arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
15986 static const char *const arm_attr_tag_Advanced_SIMD_arch
[] =
15987 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
15988 "NEON for ARMv8.1"};
15989 static const char *const arm_attr_tag_PCS_config
[] =
15990 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
15991 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
15992 static const char *const arm_attr_tag_ABI_PCS_R9_use
[] =
15993 {"V6", "SB", "TLS", "Unused"};
15994 static const char *const arm_attr_tag_ABI_PCS_RW_data
[] =
15995 {"Absolute", "PC-relative", "SB-relative", "None"};
15996 static const char *const arm_attr_tag_ABI_PCS_RO_data
[] =
15997 {"Absolute", "PC-relative", "None"};
15998 static const char *const arm_attr_tag_ABI_PCS_GOT_use
[] =
15999 {"None", "direct", "GOT-indirect"};
16000 static const char *const arm_attr_tag_ABI_PCS_wchar_t
[] =
16001 {"None", "??? 1", "2", "??? 3", "4"};
16002 static const char *const arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
16003 static const char *const arm_attr_tag_ABI_FP_denormal
[] =
16004 {"Unused", "Needed", "Sign only"};
16005 static const char *const arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
16006 static const char *const arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
16007 static const char *const arm_attr_tag_ABI_FP_number_model
[] =
16008 {"Unused", "Finite", "RTABI", "IEEE 754"};
16009 static const char *const arm_attr_tag_ABI_enum_size
[] =
16010 {"Unused", "small", "int", "forced to int"};
16011 static const char *const arm_attr_tag_ABI_HardFP_use
[] =
16012 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
16013 static const char *const arm_attr_tag_ABI_VFP_args
[] =
16014 {"AAPCS", "VFP registers", "custom", "compatible"};
16015 static const char *const arm_attr_tag_ABI_WMMX_args
[] =
16016 {"AAPCS", "WMMX registers", "custom"};
16017 static const char *const arm_attr_tag_ABI_optimization_goals
[] =
16018 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
16019 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
16020 static const char *const arm_attr_tag_ABI_FP_optimization_goals
[] =
16021 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
16022 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
16023 static const char *const arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
16024 static const char *const arm_attr_tag_FP_HP_extension
[] =
16025 {"Not Allowed", "Allowed"};
16026 static const char *const arm_attr_tag_ABI_FP_16bit_format
[] =
16027 {"None", "IEEE 754", "Alternative Format"};
16028 static const char *const arm_attr_tag_DSP_extension
[] =
16029 {"Follow architecture", "Allowed"};
16030 static const char *const arm_attr_tag_MPextension_use
[] =
16031 {"Not Allowed", "Allowed"};
16032 static const char *const arm_attr_tag_DIV_use
[] =
16033 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
16034 "Allowed in v7-A with integer division extension"};
16035 static const char *const arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
16036 static const char *const arm_attr_tag_Virtualization_use
[] =
16037 {"Not Allowed", "TrustZone", "Virtualization Extensions",
16038 "TrustZone and Virtualization Extensions"};
16039 static const char *const arm_attr_tag_MPextension_use_legacy
[] =
16040 {"Not Allowed", "Allowed"};
16042 static const char *const arm_attr_tag_MVE_arch
[] =
16043 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
16045 #define LOOKUP(id, name) \
16046 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
16047 static arm_attr_public_tag arm_attr_public_tags
[] =
16049 {4, "CPU_raw_name", 1, NULL
},
16050 {5, "CPU_name", 1, NULL
},
16051 LOOKUP(6, CPU_arch
),
16052 {7, "CPU_arch_profile", 0, NULL
},
16053 LOOKUP(8, ARM_ISA_use
),
16054 LOOKUP(9, THUMB_ISA_use
),
16055 LOOKUP(10, FP_arch
),
16056 LOOKUP(11, WMMX_arch
),
16057 LOOKUP(12, Advanced_SIMD_arch
),
16058 LOOKUP(13, PCS_config
),
16059 LOOKUP(14, ABI_PCS_R9_use
),
16060 LOOKUP(15, ABI_PCS_RW_data
),
16061 LOOKUP(16, ABI_PCS_RO_data
),
16062 LOOKUP(17, ABI_PCS_GOT_use
),
16063 LOOKUP(18, ABI_PCS_wchar_t
),
16064 LOOKUP(19, ABI_FP_rounding
),
16065 LOOKUP(20, ABI_FP_denormal
),
16066 LOOKUP(21, ABI_FP_exceptions
),
16067 LOOKUP(22, ABI_FP_user_exceptions
),
16068 LOOKUP(23, ABI_FP_number_model
),
16069 {24, "ABI_align_needed", 0, NULL
},
16070 {25, "ABI_align_preserved", 0, NULL
},
16071 LOOKUP(26, ABI_enum_size
),
16072 LOOKUP(27, ABI_HardFP_use
),
16073 LOOKUP(28, ABI_VFP_args
),
16074 LOOKUP(29, ABI_WMMX_args
),
16075 LOOKUP(30, ABI_optimization_goals
),
16076 LOOKUP(31, ABI_FP_optimization_goals
),
16077 {32, "compatibility", 0, NULL
},
16078 LOOKUP(34, CPU_unaligned_access
),
16079 LOOKUP(36, FP_HP_extension
),
16080 LOOKUP(38, ABI_FP_16bit_format
),
16081 LOOKUP(42, MPextension_use
),
16082 LOOKUP(44, DIV_use
),
16083 LOOKUP(46, DSP_extension
),
16084 LOOKUP(48, MVE_arch
),
16085 {64, "nodefaults", 0, NULL
},
16086 {65, "also_compatible_with", 0, NULL
},
16087 LOOKUP(66, T2EE_use
),
16088 {67, "conformance", 1, NULL
},
16089 LOOKUP(68, Virtualization_use
),
16090 LOOKUP(70, MPextension_use_legacy
)
16094 static unsigned char *
16095 display_arm_attribute (unsigned char * p
,
16096 const unsigned char * const end
)
16100 arm_attr_public_tag
* attr
;
16104 READ_ULEB (tag
, p
, end
);
16106 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
16108 if (arm_attr_public_tags
[i
].tag
== tag
)
16110 attr
= &arm_attr_public_tags
[i
];
16117 printf (" Tag_%s: ", attr
->name
);
16118 switch (attr
->type
)
16123 case 7: /* Tag_CPU_arch_profile. */
16124 READ_ULEB (val
, p
, end
);
16127 case 0: printf (_("None\n")); break;
16128 case 'A': printf (_("Application\n")); break;
16129 case 'R': printf (_("Realtime\n")); break;
16130 case 'M': printf (_("Microcontroller\n")); break;
16131 case 'S': printf (_("Application or Realtime\n")); break;
16132 default: printf ("??? (%d)\n", val
); break;
16136 case 24: /* Tag_align_needed. */
16137 READ_ULEB (val
, p
, end
);
16140 case 0: printf (_("None\n")); break;
16141 case 1: printf (_("8-byte\n")); break;
16142 case 2: printf (_("4-byte\n")); break;
16143 case 3: printf ("??? 3\n"); break;
16146 printf (_("8-byte and up to %d-byte extended\n"),
16149 printf ("??? (%d)\n", val
);
16154 case 25: /* Tag_align_preserved. */
16155 READ_ULEB (val
, p
, end
);
16158 case 0: printf (_("None\n")); break;
16159 case 1: printf (_("8-byte, except leaf SP\n")); break;
16160 case 2: printf (_("8-byte\n")); break;
16161 case 3: printf ("??? 3\n"); break;
16164 printf (_("8-byte and up to %d-byte extended\n"),
16167 printf ("??? (%d)\n", val
);
16172 case 32: /* Tag_compatibility. */
16174 READ_ULEB (val
, p
, end
);
16175 printf (_("flag = %d, vendor = "), val
);
16178 size_t maxlen
= (end
- p
) - 1;
16180 print_symbol ((int) maxlen
, (const char *) p
);
16181 p
+= strnlen ((char *) p
, maxlen
) + 1;
16185 printf (_("<corrupt>"));
16186 p
= (unsigned char *) end
;
16192 case 64: /* Tag_nodefaults. */
16193 /* PR 17531: file: 001-505008-0.01. */
16196 printf (_("True\n"));
16199 case 65: /* Tag_also_compatible_with. */
16200 READ_ULEB (val
, p
, end
);
16201 if (val
== 6 /* Tag_CPU_arch. */)
16203 READ_ULEB (val
, p
, end
);
16204 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
16205 printf ("??? (%d)\n", val
);
16207 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
16211 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
16216 printf (_("<unknown: %d>\n"), tag
);
16222 return display_tag_value (-1, p
, end
);
16224 return display_tag_value (0, p
, end
);
16227 assert (attr
->type
& 0x80);
16228 READ_ULEB (val
, p
, end
);
16229 type
= attr
->type
& 0x7f;
16231 printf ("??? (%d)\n", val
);
16233 printf ("%s\n", attr
->table
[val
]);
16238 return display_tag_value (tag
, p
, end
);
16241 static unsigned char *
16242 display_gnu_attribute (unsigned char * p
,
16243 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
16244 const unsigned char * const end
)
16249 READ_ULEB (tag
, p
, end
);
16251 /* Tag_compatibility is the only generic GNU attribute defined at
16255 READ_ULEB (val
, p
, end
);
16257 printf (_("flag = %d, vendor = "), val
);
16260 printf (_("<corrupt>\n"));
16261 warn (_("corrupt vendor attribute\n"));
16267 size_t maxlen
= (end
- p
) - 1;
16269 print_symbol ((int) maxlen
, (const char *) p
);
16270 p
+= strnlen ((char *) p
, maxlen
) + 1;
16274 printf (_("<corrupt>"));
16275 p
= (unsigned char *) end
;
16282 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
16283 return display_proc_gnu_attribute (p
, tag
, end
);
16285 return display_tag_value (tag
, p
, end
);
16288 static unsigned char *
16289 display_m68k_gnu_attribute (unsigned char * p
,
16291 const unsigned char * const end
)
16295 if (tag
== Tag_GNU_M68K_ABI_FP
)
16297 printf (" Tag_GNU_M68K_ABI_FP: ");
16300 printf (_("<corrupt>\n"));
16303 READ_ULEB (val
, p
, end
);
16306 printf ("(%#x), ", val
);
16311 printf (_("unspecified hard/soft float\n"));
16314 printf (_("hard float\n"));
16317 printf (_("soft float\n"));
16323 return display_tag_value (tag
& 1, p
, end
);
16326 static unsigned char *
16327 display_power_gnu_attribute (unsigned char * p
,
16329 const unsigned char * const end
)
16333 if (tag
== Tag_GNU_Power_ABI_FP
)
16335 printf (" Tag_GNU_Power_ABI_FP: ");
16338 printf (_("<corrupt>\n"));
16341 READ_ULEB (val
, p
, end
);
16344 printf ("(%#x), ", val
);
16349 printf (_("unspecified hard/soft float, "));
16352 printf (_("hard float, "));
16355 printf (_("soft float, "));
16358 printf (_("single-precision hard float, "));
16365 printf (_("unspecified long double\n"));
16368 printf (_("128-bit IBM long double\n"));
16371 printf (_("64-bit long double\n"));
16374 printf (_("128-bit IEEE long double\n"));
16380 if (tag
== Tag_GNU_Power_ABI_Vector
)
16382 printf (" Tag_GNU_Power_ABI_Vector: ");
16385 printf (_("<corrupt>\n"));
16388 READ_ULEB (val
, p
, end
);
16391 printf ("(%#x), ", val
);
16396 printf (_("unspecified\n"));
16399 printf (_("generic\n"));
16402 printf ("AltiVec\n");
16411 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
16413 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
16416 printf (_("<corrupt>\n"));
16419 READ_ULEB (val
, p
, end
);
16422 printf ("(%#x), ", val
);
16427 printf (_("unspecified\n"));
16430 printf ("r3/r4\n");
16433 printf (_("memory\n"));
16442 return display_tag_value (tag
& 1, p
, end
);
16445 static unsigned char *
16446 display_s390_gnu_attribute (unsigned char * p
,
16448 const unsigned char * const end
)
16452 if (tag
== Tag_GNU_S390_ABI_Vector
)
16454 printf (" Tag_GNU_S390_ABI_Vector: ");
16455 READ_ULEB (val
, p
, end
);
16460 printf (_("any\n"));
16463 printf (_("software\n"));
16466 printf (_("hardware\n"));
16469 printf ("??? (%d)\n", val
);
16475 return display_tag_value (tag
& 1, p
, end
);
16479 display_sparc_hwcaps (unsigned int mask
)
16485 if (mask
& ELF_SPARC_HWCAP_MUL32
)
16486 fputs ("mul32", stdout
), first
= false;
16487 if (mask
& ELF_SPARC_HWCAP_DIV32
)
16488 printf ("%sdiv32", first
? "" : "|"), first
= false;
16489 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
16490 printf ("%sfsmuld", first
? "" : "|"), first
= false;
16491 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
16492 printf ("%sv8plus", first
? "" : "|"), first
= false;
16493 if (mask
& ELF_SPARC_HWCAP_POPC
)
16494 printf ("%spopc", first
? "" : "|"), first
= false;
16495 if (mask
& ELF_SPARC_HWCAP_VIS
)
16496 printf ("%svis", first
? "" : "|"), first
= false;
16497 if (mask
& ELF_SPARC_HWCAP_VIS2
)
16498 printf ("%svis2", first
? "" : "|"), first
= false;
16499 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
16500 printf ("%sASIBlkInit", first
? "" : "|"), first
= false;
16501 if (mask
& ELF_SPARC_HWCAP_FMAF
)
16502 printf ("%sfmaf", first
? "" : "|"), first
= false;
16503 if (mask
& ELF_SPARC_HWCAP_VIS3
)
16504 printf ("%svis3", first
? "" : "|"), first
= false;
16505 if (mask
& ELF_SPARC_HWCAP_HPC
)
16506 printf ("%shpc", first
? "" : "|"), first
= false;
16507 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
16508 printf ("%srandom", first
? "" : "|"), first
= false;
16509 if (mask
& ELF_SPARC_HWCAP_TRANS
)
16510 printf ("%strans", first
? "" : "|"), first
= false;
16511 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
16512 printf ("%sfjfmau", first
? "" : "|"), first
= false;
16513 if (mask
& ELF_SPARC_HWCAP_IMA
)
16514 printf ("%sima", first
? "" : "|"), first
= false;
16515 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
16516 printf ("%scspare", first
? "" : "|"), first
= false;
16519 fputc ('0', stdout
);
16520 fputc ('\n', stdout
);
16524 display_sparc_hwcaps2 (unsigned int mask
)
16530 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
16531 fputs ("fjathplus", stdout
), first
= false;
16532 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
16533 printf ("%svis3b", first
? "" : "|"), first
= false;
16534 if (mask
& ELF_SPARC_HWCAP2_ADP
)
16535 printf ("%sadp", first
? "" : "|"), first
= false;
16536 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
16537 printf ("%ssparc5", first
? "" : "|"), first
= false;
16538 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
16539 printf ("%smwait", first
? "" : "|"), first
= false;
16540 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
16541 printf ("%sxmpmul", first
? "" : "|"), first
= false;
16542 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
16543 printf ("%sxmont2", first
? "" : "|"), first
= false;
16544 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
16545 printf ("%snsec", first
? "" : "|"), first
= false;
16546 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
16547 printf ("%sfjathhpc", first
? "" : "|"), first
= false;
16548 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
16549 printf ("%sfjdes", first
? "" : "|"), first
= false;
16550 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
16551 printf ("%sfjaes", first
? "" : "|"), first
= false;
16554 fputc ('0', stdout
);
16555 fputc ('\n', stdout
);
16558 static unsigned char *
16559 display_sparc_gnu_attribute (unsigned char * p
,
16561 const unsigned char * const end
)
16565 if (tag
== Tag_GNU_Sparc_HWCAPS
)
16567 READ_ULEB (val
, p
, end
);
16568 printf (" Tag_GNU_Sparc_HWCAPS: ");
16569 display_sparc_hwcaps (val
);
16572 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
16574 READ_ULEB (val
, p
, end
);
16575 printf (" Tag_GNU_Sparc_HWCAPS2: ");
16576 display_sparc_hwcaps2 (val
);
16580 return display_tag_value (tag
, p
, end
);
16584 print_mips_fp_abi_value (unsigned int val
)
16588 case Val_GNU_MIPS_ABI_FP_ANY
:
16589 printf (_("Hard or soft float\n"));
16591 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
16592 printf (_("Hard float (double precision)\n"));
16594 case Val_GNU_MIPS_ABI_FP_SINGLE
:
16595 printf (_("Hard float (single precision)\n"));
16597 case Val_GNU_MIPS_ABI_FP_SOFT
:
16598 printf (_("Soft float\n"));
16600 case Val_GNU_MIPS_ABI_FP_OLD_64
:
16601 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
16603 case Val_GNU_MIPS_ABI_FP_XX
:
16604 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
16606 case Val_GNU_MIPS_ABI_FP_64
:
16607 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
16609 case Val_GNU_MIPS_ABI_FP_64A
:
16610 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
16612 case Val_GNU_MIPS_ABI_FP_NAN2008
:
16613 printf (_("NaN 2008 compatibility\n"));
16616 printf ("??? (%d)\n", val
);
16621 static unsigned char *
16622 display_mips_gnu_attribute (unsigned char * p
,
16624 const unsigned char * const end
)
16626 if (tag
== Tag_GNU_MIPS_ABI_FP
)
16630 printf (" Tag_GNU_MIPS_ABI_FP: ");
16631 READ_ULEB (val
, p
, end
);
16632 print_mips_fp_abi_value (val
);
16636 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
16640 printf (" Tag_GNU_MIPS_ABI_MSA: ");
16641 READ_ULEB (val
, p
, end
);
16645 case Val_GNU_MIPS_ABI_MSA_ANY
:
16646 printf (_("Any MSA or not\n"));
16648 case Val_GNU_MIPS_ABI_MSA_128
:
16649 printf (_("128-bit MSA\n"));
16652 printf ("??? (%d)\n", val
);
16658 return display_tag_value (tag
& 1, p
, end
);
16661 static unsigned char *
16662 display_tic6x_attribute (unsigned char * p
,
16663 const unsigned char * const end
)
16668 READ_ULEB (tag
, p
, end
);
16673 printf (" Tag_ISA: ");
16674 READ_ULEB (val
, p
, end
);
16678 case C6XABI_Tag_ISA_none
:
16679 printf (_("None\n"));
16681 case C6XABI_Tag_ISA_C62X
:
16684 case C6XABI_Tag_ISA_C67X
:
16687 case C6XABI_Tag_ISA_C67XP
:
16688 printf ("C67x+\n");
16690 case C6XABI_Tag_ISA_C64X
:
16693 case C6XABI_Tag_ISA_C64XP
:
16694 printf ("C64x+\n");
16696 case C6XABI_Tag_ISA_C674X
:
16697 printf ("C674x\n");
16700 printf ("??? (%d)\n", val
);
16705 case Tag_ABI_wchar_t
:
16706 printf (" Tag_ABI_wchar_t: ");
16707 READ_ULEB (val
, p
, end
);
16711 printf (_("Not used\n"));
16714 printf (_("2 bytes\n"));
16717 printf (_("4 bytes\n"));
16720 printf ("??? (%d)\n", val
);
16725 case Tag_ABI_stack_align_needed
:
16726 printf (" Tag_ABI_stack_align_needed: ");
16727 READ_ULEB (val
, p
, end
);
16731 printf (_("8-byte\n"));
16734 printf (_("16-byte\n"));
16737 printf ("??? (%d)\n", val
);
16742 case Tag_ABI_stack_align_preserved
:
16743 READ_ULEB (val
, p
, end
);
16744 printf (" Tag_ABI_stack_align_preserved: ");
16748 printf (_("8-byte\n"));
16751 printf (_("16-byte\n"));
16754 printf ("??? (%d)\n", val
);
16760 READ_ULEB (val
, p
, end
);
16761 printf (" Tag_ABI_DSBT: ");
16765 printf (_("DSBT addressing not used\n"));
16768 printf (_("DSBT addressing used\n"));
16771 printf ("??? (%d)\n", val
);
16777 READ_ULEB (val
, p
, end
);
16778 printf (" Tag_ABI_PID: ");
16782 printf (_("Data addressing position-dependent\n"));
16785 printf (_("Data addressing position-independent, GOT near DP\n"));
16788 printf (_("Data addressing position-independent, GOT far from DP\n"));
16791 printf ("??? (%d)\n", val
);
16797 READ_ULEB (val
, p
, end
);
16798 printf (" Tag_ABI_PIC: ");
16802 printf (_("Code addressing position-dependent\n"));
16805 printf (_("Code addressing position-independent\n"));
16808 printf ("??? (%d)\n", val
);
16813 case Tag_ABI_array_object_alignment
:
16814 READ_ULEB (val
, p
, end
);
16815 printf (" Tag_ABI_array_object_alignment: ");
16819 printf (_("8-byte\n"));
16822 printf (_("4-byte\n"));
16825 printf (_("16-byte\n"));
16828 printf ("??? (%d)\n", val
);
16833 case Tag_ABI_array_object_align_expected
:
16834 READ_ULEB (val
, p
, end
);
16835 printf (" Tag_ABI_array_object_align_expected: ");
16839 printf (_("8-byte\n"));
16842 printf (_("4-byte\n"));
16845 printf (_("16-byte\n"));
16848 printf ("??? (%d)\n", val
);
16853 case Tag_ABI_compatibility
:
16855 READ_ULEB (val
, p
, end
);
16856 printf (" Tag_ABI_compatibility: ");
16857 printf (_("flag = %d, vendor = "), val
);
16860 size_t maxlen
= (end
- p
) - 1;
16862 print_symbol ((int) maxlen
, (const char *) p
);
16863 p
+= strnlen ((char *) p
, maxlen
) + 1;
16867 printf (_("<corrupt>"));
16868 p
= (unsigned char *) end
;
16874 case Tag_ABI_conformance
:
16876 printf (" Tag_ABI_conformance: \"");
16879 size_t maxlen
= (end
- p
) - 1;
16881 print_symbol ((int) maxlen
, (const char *) p
);
16882 p
+= strnlen ((char *) p
, maxlen
) + 1;
16886 printf (_("<corrupt>"));
16887 p
= (unsigned char *) end
;
16894 return display_tag_value (tag
, p
, end
);
16898 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
16900 unsigned long addr
= 0;
16901 size_t bytes
= end
- p
;
16908 int lbytes
= (bytes
> 16 ? 16 : bytes
);
16910 printf (" 0x%8.8lx ", addr
);
16912 for (j
= 0; j
< 16; j
++)
16915 printf ("%2.2x", p
[j
]);
16923 for (j
= 0; j
< lbytes
; j
++)
16926 if (k
>= ' ' && k
< 0x7f)
16942 static unsigned char *
16943 display_msp430_attribute (unsigned char * p
,
16944 const unsigned char * const end
)
16949 READ_ULEB (tag
, p
, end
);
16953 case OFBA_MSPABI_Tag_ISA
:
16954 printf (" Tag_ISA: ");
16955 READ_ULEB (val
, p
, end
);
16958 case 0: printf (_("None\n")); break;
16959 case 1: printf (_("MSP430\n")); break;
16960 case 2: printf (_("MSP430X\n")); break;
16961 default: printf ("??? (%d)\n", val
); break;
16965 case OFBA_MSPABI_Tag_Code_Model
:
16966 printf (" Tag_Code_Model: ");
16967 READ_ULEB (val
, p
, end
);
16970 case 0: printf (_("None\n")); break;
16971 case 1: printf (_("Small\n")); break;
16972 case 2: printf (_("Large\n")); break;
16973 default: printf ("??? (%d)\n", val
); break;
16977 case OFBA_MSPABI_Tag_Data_Model
:
16978 printf (" Tag_Data_Model: ");
16979 READ_ULEB (val
, p
, end
);
16982 case 0: printf (_("None\n")); break;
16983 case 1: printf (_("Small\n")); break;
16984 case 2: printf (_("Large\n")); break;
16985 case 3: printf (_("Restricted Large\n")); break;
16986 default: printf ("??? (%d)\n", val
); break;
16991 printf (_(" <unknown tag %d>: "), tag
);
16998 size_t maxlen
= (end
- p
) - 1;
17000 print_symbol ((int) maxlen
, (const char *) p
);
17001 p
+= strnlen ((char *) p
, maxlen
) + 1;
17005 printf (_("<corrupt>"));
17006 p
= (unsigned char *) end
;
17012 READ_ULEB (val
, p
, end
);
17013 printf ("%d (0x%x)\n", val
, val
);
17022 static unsigned char *
17023 display_msp430_gnu_attribute (unsigned char * p
,
17025 const unsigned char * const end
)
17027 if (tag
== Tag_GNU_MSP430_Data_Region
)
17031 printf (" Tag_GNU_MSP430_Data_Region: ");
17032 READ_ULEB (val
, p
, end
);
17036 case Val_GNU_MSP430_Data_Region_Any
:
17037 printf (_("Any Region\n"));
17039 case Val_GNU_MSP430_Data_Region_Lower
:
17040 printf (_("Lower Region Only\n"));
17043 printf ("??? (%u)\n", val
);
17047 return display_tag_value (tag
& 1, p
, end
);
17050 struct riscv_attr_tag_t
{
17055 static struct riscv_attr_tag_t riscv_attr_tag
[] =
17057 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
17060 T(priv_spec_minor
),
17061 T(priv_spec_revision
),
17062 T(unaligned_access
),
17067 static unsigned char *
17068 display_riscv_attribute (unsigned char *p
,
17069 const unsigned char * const end
)
17073 struct riscv_attr_tag_t
*attr
= NULL
;
17076 READ_ULEB (tag
, p
, end
);
17078 /* Find the name of attribute. */
17079 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
17081 if (riscv_attr_tag
[i
].tag
== tag
)
17083 attr
= &riscv_attr_tag
[i
];
17089 printf (" %s: ", attr
->name
);
17091 return display_tag_value (tag
, p
, end
);
17095 case Tag_RISCV_priv_spec
:
17096 case Tag_RISCV_priv_spec_minor
:
17097 case Tag_RISCV_priv_spec_revision
:
17098 READ_ULEB (val
, p
, end
);
17099 printf (_("%u\n"), val
);
17101 case Tag_RISCV_unaligned_access
:
17102 READ_ULEB (val
, p
, end
);
17106 printf (_("No unaligned access\n"));
17109 printf (_("Unaligned access\n"));
17113 case Tag_RISCV_stack_align
:
17114 READ_ULEB (val
, p
, end
);
17115 printf (_("%u-bytes\n"), val
);
17117 case Tag_RISCV_arch
:
17118 p
= display_tag_value (-1, p
, end
);
17121 return display_tag_value (tag
, p
, end
);
17127 static unsigned char *
17128 display_csky_attribute (unsigned char * p
,
17129 const unsigned char * const end
)
17133 READ_ULEB (tag
, p
, end
);
17135 if (tag
>= Tag_CSKY_MAX
)
17137 return display_tag_value (-1, p
, end
);
17142 case Tag_CSKY_ARCH_NAME
:
17143 printf (" Tag_CSKY_ARCH_NAME:\t\t");
17144 return display_tag_value (-1, p
, end
);
17145 case Tag_CSKY_CPU_NAME
:
17146 printf (" Tag_CSKY_CPU_NAME:\t\t");
17147 return display_tag_value (-1, p
, end
);
17149 case Tag_CSKY_ISA_FLAGS
:
17150 printf (" Tag_CSKY_ISA_FLAGS:\t\t");
17151 return display_tag_value (0, p
, end
);
17152 case Tag_CSKY_ISA_EXT_FLAGS
:
17153 printf (" Tag_CSKY_ISA_EXT_FLAGS:\t");
17154 return display_tag_value (0, p
, end
);
17156 case Tag_CSKY_DSP_VERSION
:
17157 printf (" Tag_CSKY_DSP_VERSION:\t\t");
17158 READ_ULEB (val
, p
, end
);
17159 if (val
== VAL_CSKY_DSP_VERSION_EXTENSION
)
17160 printf ("DSP Extension\n");
17161 else if (val
== VAL_CSKY_DSP_VERSION_2
)
17162 printf ("DSP 2.0\n");
17165 case Tag_CSKY_VDSP_VERSION
:
17166 printf (" Tag_CSKY_VDSP_VERSION:\t");
17167 READ_ULEB (val
, p
, end
);
17168 printf ("VDSP Version %d\n", val
);
17171 case Tag_CSKY_FPU_VERSION
:
17172 printf (" Tag_CSKY_FPU_VERSION:\t\t");
17173 READ_ULEB (val
, p
, end
);
17174 if (val
== VAL_CSKY_FPU_VERSION_1
)
17175 printf ("ABIV1 FPU Version 1\n");
17176 else if (val
== VAL_CSKY_FPU_VERSION_2
)
17177 printf ("FPU Version 2\n");
17180 case Tag_CSKY_FPU_ABI
:
17181 printf (" Tag_CSKY_FPU_ABI:\t\t");
17182 READ_ULEB (val
, p
, end
);
17183 if (val
== VAL_CSKY_FPU_ABI_HARD
)
17185 else if (val
== VAL_CSKY_FPU_ABI_SOFTFP
)
17186 printf ("SoftFP\n");
17187 else if (val
== VAL_CSKY_FPU_ABI_SOFT
)
17190 case Tag_CSKY_FPU_ROUNDING
:
17191 READ_ULEB (val
, p
, end
);
17193 printf (" Tag_CSKY_FPU_ROUNDING:\t");
17194 printf ("Needed\n");
17197 case Tag_CSKY_FPU_DENORMAL
:
17198 READ_ULEB (val
, p
, end
);
17200 printf (" Tag_CSKY_FPU_DENORMAL:\t");
17201 printf ("Needed\n");
17204 case Tag_CSKY_FPU_Exception
:
17205 READ_ULEB (val
, p
, end
);
17207 printf (" Tag_CSKY_FPU_Exception:\t");
17208 printf ("Needed\n");
17211 case Tag_CSKY_FPU_NUMBER_MODULE
:
17212 printf (" Tag_CSKY_FPU_NUMBER_MODULE:\t");
17213 return display_tag_value (-1, p
, end
);
17214 case Tag_CSKY_FPU_HARDFP
:
17215 printf (" Tag_CSKY_FPU_HARDFP:\t\t");
17216 READ_ULEB (val
, p
, end
);
17217 if (val
& VAL_CSKY_FPU_HARDFP_HALF
)
17219 if (val
& VAL_CSKY_FPU_HARDFP_SINGLE
)
17220 printf (" Single");
17221 if (val
& VAL_CSKY_FPU_HARDFP_DOUBLE
)
17222 printf (" Double");
17226 return display_tag_value (tag
, p
, end
);
17232 process_attributes (Filedata
* filedata
,
17233 const char * public_name
,
17234 unsigned int proc_type
,
17235 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
17236 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
17238 Elf_Internal_Shdr
* sect
;
17242 /* Find the section header so that we get the size. */
17243 for (i
= 0, sect
= filedata
->section_headers
;
17244 i
< filedata
->file_header
.e_shnum
;
17247 unsigned char * contents
;
17250 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
17253 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17254 sect
->sh_size
, _("attributes"));
17255 if (contents
== NULL
)
17262 /* The first character is the version of the attributes.
17263 Currently only version 1, (aka 'A') is recognised here. */
17266 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
17271 bfd_vma section_len
;
17273 section_len
= sect
->sh_size
- 1;
17276 while (section_len
> 0)
17279 unsigned int namelen
;
17280 bool public_section
;
17283 if (section_len
<= 4)
17285 error (_("Tag section ends prematurely\n"));
17289 attr_len
= byte_get (p
, 4);
17292 if (attr_len
> section_len
)
17294 error (_("Bad attribute length (%u > %u)\n"),
17295 (unsigned) attr_len
, (unsigned) section_len
);
17296 attr_len
= section_len
;
17299 /* PR 17531: file: 001-101425-0.004 */
17300 else if (attr_len
< 5)
17302 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
17307 section_len
-= attr_len
;
17310 namelen
= strnlen ((char *) p
, attr_len
) + 1;
17311 if (namelen
== 0 || namelen
>= attr_len
)
17313 error (_("Corrupt attribute section name\n"));
17318 printf (_("Attribute Section: "));
17319 print_symbol (INT_MAX
, (const char *) p
);
17322 if (public_name
&& streq ((char *) p
, public_name
))
17323 public_section
= true;
17325 public_section
= false;
17327 if (streq ((char *) p
, "gnu"))
17328 gnu_section
= true;
17330 gnu_section
= false;
17333 attr_len
-= namelen
;
17335 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
17340 unsigned char * end
;
17342 /* PR binutils/17531: Safe handling of corrupt files. */
17345 error (_("Unused bytes at end of section\n"));
17352 size
= byte_get (p
, 4);
17353 if (size
> attr_len
)
17355 error (_("Bad subsection length (%u > %u)\n"),
17356 (unsigned) size
, (unsigned) attr_len
);
17360 /* PR binutils/17531: Safe handling of corrupt files. */
17363 error (_("Bad subsection length (%u < 6)\n"),
17371 end
= p
+ size
- 1;
17372 assert (end
<= contents
+ sect
->sh_size
);
17378 printf (_("File Attributes\n"));
17381 printf (_("Section Attributes:"));
17384 printf (_("Symbol Attributes:"));
17385 /* Fall through. */
17389 READ_ULEB (val
, p
, end
);
17392 printf (" %d", val
);
17397 printf (_("Unknown tag: %d\n"), tag
);
17398 public_section
= false;
17402 if (public_section
&& display_pub_attribute
!= NULL
)
17405 p
= display_pub_attribute (p
, end
);
17408 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
17411 p
= display_gnu_attribute (p
,
17412 display_proc_gnu_attribute
,
17418 printf (_(" Unknown attribute:\n"));
17419 display_raw_attribute (p
, end
);
17434 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
17435 Print the Address, Access and Initial fields of an entry at VMA ADDR
17436 and return the VMA of the next entry, or -1 if there was a problem.
17437 Does not read from DATA_END or beyond. */
17440 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
17441 unsigned char * data_end
)
17444 print_vma (addr
, LONG_HEX
);
17446 if (addr
< pltgot
+ 0xfff0)
17447 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
17449 printf ("%10s", "");
17452 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
17456 unsigned char * from
= data
+ addr
- pltgot
;
17458 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
17460 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
17461 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
17462 return (bfd_vma
) -1;
17466 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
17467 print_vma (entry
, LONG_HEX
);
17470 return addr
+ (is_32bit_elf
? 4 : 8);
17473 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
17474 PLTGOT. Print the Address and Initial fields of an entry at VMA
17475 ADDR and return the VMA of the next entry. */
17478 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
17481 print_vma (addr
, LONG_HEX
);
17484 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
17489 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
17490 print_vma (entry
, LONG_HEX
);
17492 return addr
+ (is_32bit_elf
? 4 : 8);
17496 print_mips_ases (unsigned int mask
)
17498 if (mask
& AFL_ASE_DSP
)
17499 fputs ("\n\tDSP ASE", stdout
);
17500 if (mask
& AFL_ASE_DSPR2
)
17501 fputs ("\n\tDSP R2 ASE", stdout
);
17502 if (mask
& AFL_ASE_DSPR3
)
17503 fputs ("\n\tDSP R3 ASE", stdout
);
17504 if (mask
& AFL_ASE_EVA
)
17505 fputs ("\n\tEnhanced VA Scheme", stdout
);
17506 if (mask
& AFL_ASE_MCU
)
17507 fputs ("\n\tMCU (MicroController) ASE", stdout
);
17508 if (mask
& AFL_ASE_MDMX
)
17509 fputs ("\n\tMDMX ASE", stdout
);
17510 if (mask
& AFL_ASE_MIPS3D
)
17511 fputs ("\n\tMIPS-3D ASE", stdout
);
17512 if (mask
& AFL_ASE_MT
)
17513 fputs ("\n\tMT ASE", stdout
);
17514 if (mask
& AFL_ASE_SMARTMIPS
)
17515 fputs ("\n\tSmartMIPS ASE", stdout
);
17516 if (mask
& AFL_ASE_VIRT
)
17517 fputs ("\n\tVZ ASE", stdout
);
17518 if (mask
& AFL_ASE_MSA
)
17519 fputs ("\n\tMSA ASE", stdout
);
17520 if (mask
& AFL_ASE_MIPS16
)
17521 fputs ("\n\tMIPS16 ASE", stdout
);
17522 if (mask
& AFL_ASE_MICROMIPS
)
17523 fputs ("\n\tMICROMIPS ASE", stdout
);
17524 if (mask
& AFL_ASE_XPA
)
17525 fputs ("\n\tXPA ASE", stdout
);
17526 if (mask
& AFL_ASE_MIPS16E2
)
17527 fputs ("\n\tMIPS16e2 ASE", stdout
);
17528 if (mask
& AFL_ASE_CRC
)
17529 fputs ("\n\tCRC ASE", stdout
);
17530 if (mask
& AFL_ASE_GINV
)
17531 fputs ("\n\tGINV ASE", stdout
);
17532 if (mask
& AFL_ASE_LOONGSON_MMI
)
17533 fputs ("\n\tLoongson MMI ASE", stdout
);
17534 if (mask
& AFL_ASE_LOONGSON_CAM
)
17535 fputs ("\n\tLoongson CAM ASE", stdout
);
17536 if (mask
& AFL_ASE_LOONGSON_EXT
)
17537 fputs ("\n\tLoongson EXT ASE", stdout
);
17538 if (mask
& AFL_ASE_LOONGSON_EXT2
)
17539 fputs ("\n\tLoongson EXT2 ASE", stdout
);
17541 fprintf (stdout
, "\n\t%s", _("None"));
17542 else if ((mask
& ~AFL_ASE_MASK
) != 0)
17543 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
17547 print_mips_isa_ext (unsigned int isa_ext
)
17552 fputs (_("None"), stdout
);
17555 fputs ("RMI XLR", stdout
);
17557 case AFL_EXT_OCTEON3
:
17558 fputs ("Cavium Networks Octeon3", stdout
);
17560 case AFL_EXT_OCTEON2
:
17561 fputs ("Cavium Networks Octeon2", stdout
);
17563 case AFL_EXT_OCTEONP
:
17564 fputs ("Cavium Networks OcteonP", stdout
);
17566 case AFL_EXT_OCTEON
:
17567 fputs ("Cavium Networks Octeon", stdout
);
17570 fputs ("Toshiba R5900", stdout
);
17573 fputs ("MIPS R4650", stdout
);
17576 fputs ("LSI R4010", stdout
);
17579 fputs ("NEC VR4100", stdout
);
17582 fputs ("Toshiba R3900", stdout
);
17584 case AFL_EXT_10000
:
17585 fputs ("MIPS R10000", stdout
);
17588 fputs ("Broadcom SB-1", stdout
);
17591 fputs ("NEC VR4111/VR4181", stdout
);
17594 fputs ("NEC VR4120", stdout
);
17597 fputs ("NEC VR5400", stdout
);
17600 fputs ("NEC VR5500", stdout
);
17602 case AFL_EXT_LOONGSON_2E
:
17603 fputs ("ST Microelectronics Loongson 2E", stdout
);
17605 case AFL_EXT_LOONGSON_2F
:
17606 fputs ("ST Microelectronics Loongson 2F", stdout
);
17608 case AFL_EXT_INTERAPTIV_MR2
:
17609 fputs ("Imagination interAptiv MR2", stdout
);
17612 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
17617 get_mips_reg_size (int reg_size
)
17619 return (reg_size
== AFL_REG_NONE
) ? 0
17620 : (reg_size
== AFL_REG_32
) ? 32
17621 : (reg_size
== AFL_REG_64
) ? 64
17622 : (reg_size
== AFL_REG_128
) ? 128
17627 process_mips_specific (Filedata
* filedata
)
17629 Elf_Internal_Dyn
* entry
;
17630 Elf_Internal_Shdr
*sect
= NULL
;
17631 size_t liblist_offset
= 0;
17632 size_t liblistno
= 0;
17633 size_t conflictsno
= 0;
17634 size_t options_offset
= 0;
17635 size_t conflicts_offset
= 0;
17636 size_t pltrelsz
= 0;
17638 bfd_vma pltgot
= 0;
17639 bfd_vma mips_pltgot
= 0;
17640 bfd_vma jmprel
= 0;
17641 bfd_vma local_gotno
= 0;
17642 bfd_vma gotsym
= 0;
17643 bfd_vma symtabno
= 0;
17646 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17647 display_mips_gnu_attribute
))
17650 sect
= find_section (filedata
, ".MIPS.abiflags");
17654 Elf_External_ABIFlags_v0
*abiflags_ext
;
17655 Elf_Internal_ABIFlags_v0 abiflags_in
;
17657 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
17659 error (_("Corrupt MIPS ABI Flags section.\n"));
17664 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17665 sect
->sh_size
, _("MIPS ABI Flags section"));
17668 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
17669 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
17670 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
17671 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
17672 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
17673 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
17674 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
17675 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
17676 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
17677 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
17678 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
17680 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
17681 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
17682 if (abiflags_in
.isa_rev
> 1)
17683 printf ("r%d", abiflags_in
.isa_rev
);
17684 printf ("\nGPR size: %d",
17685 get_mips_reg_size (abiflags_in
.gpr_size
));
17686 printf ("\nCPR1 size: %d",
17687 get_mips_reg_size (abiflags_in
.cpr1_size
));
17688 printf ("\nCPR2 size: %d",
17689 get_mips_reg_size (abiflags_in
.cpr2_size
));
17690 fputs ("\nFP ABI: ", stdout
);
17691 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
17692 fputs ("ISA Extension: ", stdout
);
17693 print_mips_isa_ext (abiflags_in
.isa_ext
);
17694 fputs ("\nASEs:", stdout
);
17695 print_mips_ases (abiflags_in
.ases
);
17696 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
17697 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
17698 fputc ('\n', stdout
);
17699 free (abiflags_ext
);
17704 /* We have a lot of special sections. Thanks SGI! */
17705 if (filedata
->dynamic_section
== NULL
)
17707 /* No dynamic information available. See if there is static GOT. */
17708 sect
= find_section (filedata
, ".got");
17711 unsigned char *data_end
;
17712 unsigned char *data
;
17716 pltgot
= sect
->sh_addr
;
17719 addr_size
= (is_32bit_elf
? 4 : 8);
17720 end
= pltgot
+ sect
->sh_size
;
17722 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
17724 _("Global Offset Table data"));
17725 /* PR 12855: Null data is handled gracefully throughout. */
17726 data_end
= data
+ (end
- pltgot
);
17728 printf (_("\nStatic GOT:\n"));
17729 printf (_(" Canonical gp value: "));
17730 print_vma (ent
+ 0x7ff0, LONG_HEX
);
17733 /* In a dynamic binary GOT[0] is reserved for the dynamic
17734 loader to store the lazy resolver pointer, however in
17735 a static binary it may well have been omitted and GOT
17736 reduced to a table of addresses.
17737 PR 21344: Check for the entry being fully available
17738 before fetching it. */
17740 && data
+ ent
- pltgot
+ addr_size
<= data_end
17741 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
17743 printf (_(" Reserved entries:\n"));
17744 printf (_(" %*s %10s %*s\n"),
17745 addr_size
* 2, _("Address"), _("Access"),
17746 addr_size
* 2, _("Value"));
17747 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17749 if (ent
== (bfd_vma
) -1)
17750 goto sgot_print_fail
;
17752 /* Check for the MSB of GOT[1] being set, identifying a
17753 GNU object. This entry will be used by some runtime
17754 loaders, to store the module pointer. Otherwise this
17755 is an ordinary local entry.
17756 PR 21344: Check for the entry being fully available
17757 before fetching it. */
17759 && data
+ ent
- pltgot
+ addr_size
<= data_end
17760 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17761 >> (addr_size
* 8 - 1)) != 0)
17763 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17765 if (ent
== (bfd_vma
) -1)
17766 goto sgot_print_fail
;
17771 if (data
!= NULL
&& ent
< end
)
17773 printf (_(" Local entries:\n"));
17774 printf (" %*s %10s %*s\n",
17775 addr_size
* 2, _("Address"), _("Access"),
17776 addr_size
* 2, _("Value"));
17779 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17781 if (ent
== (bfd_vma
) -1)
17782 goto sgot_print_fail
;
17793 for (entry
= filedata
->dynamic_section
;
17794 /* PR 17531 file: 012-50589-0.004. */
17795 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
17796 && entry
->d_tag
!= DT_NULL
);
17798 switch (entry
->d_tag
)
17800 case DT_MIPS_LIBLIST
:
17802 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
17803 liblistno
* sizeof (Elf32_External_Lib
));
17805 case DT_MIPS_LIBLISTNO
:
17806 liblistno
= entry
->d_un
.d_val
;
17808 case DT_MIPS_OPTIONS
:
17809 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
17811 case DT_MIPS_CONFLICT
:
17813 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
17814 conflictsno
* sizeof (Elf32_External_Conflict
));
17816 case DT_MIPS_CONFLICTNO
:
17817 conflictsno
= entry
->d_un
.d_val
;
17820 pltgot
= entry
->d_un
.d_ptr
;
17822 case DT_MIPS_LOCAL_GOTNO
:
17823 local_gotno
= entry
->d_un
.d_val
;
17825 case DT_MIPS_GOTSYM
:
17826 gotsym
= entry
->d_un
.d_val
;
17828 case DT_MIPS_SYMTABNO
:
17829 symtabno
= entry
->d_un
.d_val
;
17831 case DT_MIPS_PLTGOT
:
17832 mips_pltgot
= entry
->d_un
.d_ptr
;
17835 pltrel
= entry
->d_un
.d_val
;
17838 pltrelsz
= entry
->d_un
.d_val
;
17841 jmprel
= entry
->d_un
.d_ptr
;
17847 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
17849 Elf32_External_Lib
* elib
;
17852 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
17853 sizeof (Elf32_External_Lib
),
17855 _("liblist section data"));
17858 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
17859 "\nSection '.liblist' contains %lu entries:\n",
17860 (unsigned long) liblistno
),
17861 (unsigned long) liblistno
);
17862 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
17865 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
17872 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17873 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17874 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17875 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17876 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17878 tmp
= gmtime (&atime
);
17879 snprintf (timebuf
, sizeof (timebuf
),
17880 "%04u-%02u-%02uT%02u:%02u:%02u",
17881 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17882 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17884 printf ("%3lu: ", (unsigned long) cnt
);
17885 if (VALID_DYNAMIC_NAME (filedata
, liblist
.l_name
))
17886 print_symbol (20, GET_DYNAMIC_NAME (filedata
, liblist
.l_name
));
17888 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
17889 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
17890 liblist
.l_version
);
17892 if (liblist
.l_flags
== 0)
17896 static const struct
17903 { " EXACT_MATCH", LL_EXACT_MATCH
},
17904 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
17905 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
17906 { " EXPORTS", LL_EXPORTS
},
17907 { " DELAY_LOAD", LL_DELAY_LOAD
},
17908 { " DELTA", LL_DELTA
}
17910 int flags
= liblist
.l_flags
;
17913 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
17914 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
17916 fputs (l_flags_vals
[fcnt
].name
, stdout
);
17917 flags
^= l_flags_vals
[fcnt
].bit
;
17920 printf (" %#x", (unsigned int) flags
);
17932 if (options_offset
!= 0)
17934 Elf_External_Options
* eopt
;
17937 sect
= filedata
->section_headers
;
17939 /* Find the section header so that we get the size. */
17940 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
17941 /* PR 17533 file: 012-277276-0.004. */
17944 error (_("No MIPS_OPTIONS header found\n"));
17948 if (sect
->sh_size
< sizeof (* eopt
))
17950 error (_("The MIPS options section is too small.\n"));
17954 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
17955 sect
->sh_size
, _("options"));
17958 Elf_Internal_Options option
;
17961 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
17963 Elf_External_Options
* eoption
;
17964 unsigned int optsize
;
17966 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
17968 optsize
= BYTE_GET (eoption
->size
);
17970 /* PR 17531: file: ffa0fa3b. */
17971 if (optsize
< sizeof (* eopt
)
17972 || optsize
> sect
->sh_size
- offset
)
17974 error (_("Invalid size (%u) for MIPS option\n"),
17983 printf (ngettext ("\nSection '%s' contains %d entry:\n",
17984 "\nSection '%s' contains %d entries:\n",
17986 printable_section_name (filedata
, sect
), cnt
);
17992 Elf_External_Options
* eoption
;
17994 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
17996 option
.kind
= BYTE_GET (eoption
->kind
);
17997 option
.size
= BYTE_GET (eoption
->size
);
17998 option
.section
= BYTE_GET (eoption
->section
);
17999 option
.info
= BYTE_GET (eoption
->info
);
18001 switch (option
.kind
)
18004 /* This shouldn't happen. */
18005 printf (" NULL %" PRId16
" %" PRIx32
,
18006 option
.section
, option
.info
);
18010 printf (" REGINFO ");
18011 if (filedata
->file_header
.e_machine
== EM_MIPS
)
18013 Elf32_External_RegInfo
* ereg
;
18014 Elf32_RegInfo reginfo
;
18017 if (option
.size
< (sizeof (Elf_External_Options
)
18018 + sizeof (Elf32_External_RegInfo
)))
18020 printf (_("<corrupt>\n"));
18021 error (_("Truncated MIPS REGINFO option\n"));
18026 ereg
= (Elf32_External_RegInfo
*) (eoption
+ 1);
18028 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
18029 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
18030 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
18031 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
18032 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
18033 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
18035 printf ("GPR %08" PRIx32
" GP 0x%" PRIx32
"\n",
18036 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
18038 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
18039 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
18040 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
18041 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
18046 Elf64_External_RegInfo
* ereg
;
18047 Elf64_Internal_RegInfo reginfo
;
18049 if (option
.size
< (sizeof (Elf_External_Options
)
18050 + sizeof (Elf64_External_RegInfo
)))
18052 printf (_("<corrupt>\n"));
18053 error (_("Truncated MIPS REGINFO option\n"));
18058 ereg
= (Elf64_External_RegInfo
*) (eoption
+ 1);
18059 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
18060 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
18061 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
18062 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
18063 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
18064 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
18066 printf ("GPR %08" PRIx32
" GP 0x%" PRIx64
"\n",
18067 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
18069 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
18070 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
18071 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
18072 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
18074 offset
+= option
.size
;
18077 case ODK_EXCEPTIONS
:
18078 fputs (" EXCEPTIONS fpe_min(", stdout
);
18079 process_mips_fpe_exception (option
.info
& OEX_FPU_MIN
);
18080 fputs (") fpe_max(", stdout
);
18081 process_mips_fpe_exception ((option
.info
& OEX_FPU_MAX
) >> 8);
18082 fputs (")", stdout
);
18084 if (option
.info
& OEX_PAGE0
)
18085 fputs (" PAGE0", stdout
);
18086 if (option
.info
& OEX_SMM
)
18087 fputs (" SMM", stdout
);
18088 if (option
.info
& OEX_FPDBUG
)
18089 fputs (" FPDBUG", stdout
);
18090 if (option
.info
& OEX_DISMISS
)
18091 fputs (" DISMISS", stdout
);
18095 fputs (" PAD ", stdout
);
18096 if (option
.info
& OPAD_PREFIX
)
18097 fputs (" PREFIX", stdout
);
18098 if (option
.info
& OPAD_POSTFIX
)
18099 fputs (" POSTFIX", stdout
);
18100 if (option
.info
& OPAD_SYMBOL
)
18101 fputs (" SYMBOL", stdout
);
18105 fputs (" HWPATCH ", stdout
);
18106 if (option
.info
& OHW_R4KEOP
)
18107 fputs (" R4KEOP", stdout
);
18108 if (option
.info
& OHW_R8KPFETCH
)
18109 fputs (" R8KPFETCH", stdout
);
18110 if (option
.info
& OHW_R5KEOP
)
18111 fputs (" R5KEOP", stdout
);
18112 if (option
.info
& OHW_R5KCVTL
)
18113 fputs (" R5KCVTL", stdout
);
18117 fputs (" FILL ", stdout
);
18118 /* XXX Print content of info word? */
18122 fputs (" TAGS ", stdout
);
18123 /* XXX Print content of info word? */
18127 fputs (" HWAND ", stdout
);
18128 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
18129 fputs (" R4KEOP_CHECKED", stdout
);
18130 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
18131 fputs (" R4KEOP_CLEAN", stdout
);
18135 fputs (" HWOR ", stdout
);
18136 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
18137 fputs (" R4KEOP_CHECKED", stdout
);
18138 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
18139 fputs (" R4KEOP_CLEAN", stdout
);
18143 printf (" GP_GROUP %#06x self-contained %#06x",
18144 option
.info
& OGP_GROUP
,
18145 (option
.info
& OGP_SELF
) >> 16);
18149 printf (" IDENT %#06x self-contained %#06x",
18150 option
.info
& OGP_GROUP
,
18151 (option
.info
& OGP_SELF
) >> 16);
18155 /* This shouldn't happen. */
18156 printf (" %3d ??? %" PRId16
" %" PRIx32
,
18157 option
.kind
, option
.section
, option
.info
);
18161 len
= sizeof (* eopt
);
18162 while (len
< option
.size
)
18164 unsigned char datum
= *((unsigned char *) eoption
+ len
);
18166 if (ISPRINT (datum
))
18167 printf ("%c", datum
);
18169 printf ("\\%03o", datum
);
18172 fputs ("\n", stdout
);
18174 offset
+= option
.size
;
18182 if (conflicts_offset
!= 0 && conflictsno
!= 0)
18184 Elf32_Conflict
* iconf
;
18187 if (filedata
->dynamic_symbols
== NULL
)
18189 error (_("conflict list found without a dynamic symbol table\n"));
18193 /* PR 21345 - print a slightly more helpful error message
18194 if we are sure that the cmalloc will fail. */
18195 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
18197 error (_("Overlarge number of conflicts detected: %lx\n"),
18198 (long) conflictsno
);
18202 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
18205 error (_("Out of memory allocating space for dynamic conflicts\n"));
18211 Elf32_External_Conflict
* econf32
;
18213 econf32
= (Elf32_External_Conflict
*)
18214 get_data (NULL
, filedata
, conflicts_offset
,
18215 sizeof (*econf32
), conflictsno
, _("conflict"));
18222 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18223 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
18229 Elf64_External_Conflict
* econf64
;
18231 econf64
= (Elf64_External_Conflict
*)
18232 get_data (NULL
, filedata
, conflicts_offset
,
18233 sizeof (*econf64
), conflictsno
, _("conflict"));
18240 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18241 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
18246 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
18247 "\nSection '.conflict' contains %lu entries:\n",
18248 (unsigned long) conflictsno
),
18249 (unsigned long) conflictsno
);
18250 puts (_(" Num: Index Value Name"));
18252 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18254 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
18256 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
18257 printf (_("<corrupt symbol index>"));
18260 Elf_Internal_Sym
* psym
;
18262 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
18263 print_vma (psym
->st_value
, FULL_HEX
);
18265 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
18266 print_symbol (25, GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
18268 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18276 if (pltgot
!= 0 && local_gotno
!= 0)
18278 bfd_vma ent
, local_end
, global_end
;
18280 unsigned char * data
;
18281 unsigned char * data_end
;
18285 addr_size
= (is_32bit_elf
? 4 : 8);
18286 local_end
= pltgot
+ local_gotno
* addr_size
;
18288 /* PR binutils/17533 file: 012-111227-0.004 */
18289 if (symtabno
< gotsym
)
18291 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
18292 (unsigned long) gotsym
, (unsigned long) symtabno
);
18296 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
18297 /* PR 17531: file: 54c91a34. */
18298 if (global_end
< local_end
)
18300 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
18304 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
18305 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
18306 global_end
- pltgot
, 1,
18307 _("Global Offset Table data"));
18308 /* PR 12855: Null data is handled gracefully throughout. */
18309 data_end
= data
+ (global_end
- pltgot
);
18311 printf (_("\nPrimary GOT:\n"));
18312 printf (_(" Canonical gp value: "));
18313 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
18316 printf (_(" Reserved entries:\n"));
18317 printf (_(" %*s %10s %*s Purpose\n"),
18318 addr_size
* 2, _("Address"), _("Access"),
18319 addr_size
* 2, _("Initial"));
18320 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18321 printf (_(" Lazy resolver\n"));
18322 if (ent
== (bfd_vma
) -1)
18323 goto got_print_fail
;
18325 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
18326 This entry will be used by some runtime loaders, to store the
18327 module pointer. Otherwise this is an ordinary local entry.
18328 PR 21344: Check for the entry being fully available before
18331 && data
+ ent
- pltgot
+ addr_size
<= data_end
18332 && (byte_get (data
+ ent
- pltgot
, addr_size
)
18333 >> (addr_size
* 8 - 1)) != 0)
18335 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18336 printf (_(" Module pointer (GNU extension)\n"));
18337 if (ent
== (bfd_vma
) -1)
18338 goto got_print_fail
;
18342 if (data
!= NULL
&& ent
< local_end
)
18344 printf (_(" Local entries:\n"));
18345 printf (" %*s %10s %*s\n",
18346 addr_size
* 2, _("Address"), _("Access"),
18347 addr_size
* 2, _("Initial"));
18348 while (ent
< local_end
)
18350 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18352 if (ent
== (bfd_vma
) -1)
18353 goto got_print_fail
;
18358 if (data
!= NULL
&& gotsym
< symtabno
)
18362 printf (_(" Global entries:\n"));
18363 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
18364 addr_size
* 2, _("Address"),
18366 addr_size
* 2, _("Initial"),
18367 addr_size
* 2, _("Sym.Val."),
18369 /* Note for translators: "Ndx" = abbreviated form of "Index". */
18370 _("Ndx"), _("Name"));
18372 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
18374 for (i
= gotsym
; i
< symtabno
; i
++)
18376 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18379 if (filedata
->dynamic_symbols
== NULL
)
18380 printf (_("<no dynamic symbols>"));
18381 else if (i
< filedata
->num_dynamic_syms
)
18383 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
18385 print_vma (psym
->st_value
, LONG_HEX
);
18386 printf (" %-7s %3s ",
18387 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
18388 get_symbol_index_type (filedata
, psym
->st_shndx
));
18390 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
18391 print_symbol (sym_width
,
18392 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
18394 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18397 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
18398 (unsigned long) i
);
18401 if (ent
== (bfd_vma
) -1)
18411 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
18414 size_t offset
, rel_offset
;
18415 unsigned long count
, i
;
18416 unsigned char * data
;
18417 int addr_size
, sym_width
;
18418 Elf_Internal_Rela
* rels
;
18420 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
18421 if (pltrel
== DT_RELA
)
18423 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
18428 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
18433 addr_size
= (is_32bit_elf
? 4 : 8);
18434 end
= mips_pltgot
+ (2 + count
) * addr_size
;
18436 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
18437 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
18438 1, _("Procedure Linkage Table data"));
18445 printf ("\nPLT GOT:\n\n");
18446 printf (_(" Reserved entries:\n"));
18447 printf (_(" %*s %*s Purpose\n"),
18448 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
18449 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18450 printf (_(" PLT lazy resolver\n"));
18451 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18452 printf (_(" Module pointer\n"));
18455 printf (_(" Entries:\n"));
18456 printf (" %*s %*s %*s %-7s %3s %s\n",
18457 addr_size
* 2, _("Address"),
18458 addr_size
* 2, _("Initial"),
18459 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
18460 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
18461 for (i
= 0; i
< count
; i
++)
18463 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
18465 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18468 if (idx
>= filedata
->num_dynamic_syms
)
18469 printf (_("<corrupt symbol index: %lu>"), idx
);
18472 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
18474 print_vma (psym
->st_value
, LONG_HEX
);
18475 printf (" %-7s %3s ",
18476 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
18477 get_symbol_index_type (filedata
, psym
->st_shndx
));
18478 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
18479 print_symbol (sym_width
,
18480 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
18482 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18496 process_nds32_specific (Filedata
* filedata
)
18498 Elf_Internal_Shdr
*sect
= NULL
;
18500 sect
= find_section (filedata
, ".nds32_e_flags");
18501 if (sect
!= NULL
&& sect
->sh_size
>= 4)
18503 unsigned char *buf
;
18506 printf ("\nNDS32 elf flags section:\n");
18507 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
18508 _("NDS32 elf flags section"));
18513 flag
= byte_get (buf
, 4);
18515 switch (flag
& 0x3)
18518 printf ("(VEC_SIZE):\tNo entry.\n");
18521 printf ("(VEC_SIZE):\t4 bytes\n");
18524 printf ("(VEC_SIZE):\t16 bytes\n");
18527 printf ("(VEC_SIZE):\treserved\n");
18536 process_gnu_liblist (Filedata
* filedata
)
18538 Elf_Internal_Shdr
* section
;
18539 Elf_Internal_Shdr
* string_sec
;
18540 Elf32_External_Lib
* elib
;
18542 size_t strtab_size
;
18544 unsigned long num_liblist
;
18551 for (i
= 0, section
= filedata
->section_headers
;
18552 i
< filedata
->file_header
.e_shnum
;
18555 switch (section
->sh_type
)
18557 case SHT_GNU_LIBLIST
:
18558 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
18561 elib
= (Elf32_External_Lib
*)
18562 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
18563 _("liblist section data"));
18571 string_sec
= filedata
->section_headers
+ section
->sh_link
;
18572 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
18573 string_sec
->sh_size
,
18574 _("liblist string table"));
18576 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
18583 strtab_size
= string_sec
->sh_size
;
18585 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
18586 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
18587 "\nLibrary list section '%s' contains %lu entries:\n",
18589 printable_section_name (filedata
, section
),
18592 puts (_(" Library Time Stamp Checksum Version Flags"));
18594 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
18602 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
18603 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
18604 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
18605 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
18606 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
18608 tmp
= gmtime (&atime
);
18609 snprintf (timebuf
, sizeof (timebuf
),
18610 "%04u-%02u-%02uT%02u:%02u:%02u",
18611 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
18612 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
18614 printf ("%3lu: ", (unsigned long) cnt
);
18616 printf ("%-20s", liblist
.l_name
< strtab_size
18617 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
18619 printf ("%-20.20s", liblist
.l_name
< strtab_size
18620 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
18621 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
18622 liblist
.l_version
, liblist
.l_flags
);
18633 static const char *
18634 get_note_type (Filedata
* filedata
, unsigned e_type
)
18636 static char buff
[64];
18638 if (filedata
->file_header
.e_type
== ET_CORE
)
18642 return _("NT_AUXV (auxiliary vector)");
18644 return _("NT_PRSTATUS (prstatus structure)");
18646 return _("NT_FPREGSET (floating point registers)");
18648 return _("NT_PRPSINFO (prpsinfo structure)");
18649 case NT_TASKSTRUCT
:
18650 return _("NT_TASKSTRUCT (task structure)");
18652 return _("NT_GDB_TDESC (GDB XML target description)");
18654 return _("NT_PRXFPREG (user_xfpregs structure)");
18656 return _("NT_PPC_VMX (ppc Altivec registers)");
18658 return _("NT_PPC_VSX (ppc VSX registers)");
18660 return _("NT_PPC_TAR (ppc TAR register)");
18662 return _("NT_PPC_PPR (ppc PPR register)");
18664 return _("NT_PPC_DSCR (ppc DSCR register)");
18666 return _("NT_PPC_EBB (ppc EBB registers)");
18668 return _("NT_PPC_PMU (ppc PMU registers)");
18669 case NT_PPC_TM_CGPR
:
18670 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
18671 case NT_PPC_TM_CFPR
:
18672 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
18673 case NT_PPC_TM_CVMX
:
18674 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
18675 case NT_PPC_TM_CVSX
:
18676 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
18677 case NT_PPC_TM_SPR
:
18678 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
18679 case NT_PPC_TM_CTAR
:
18680 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
18681 case NT_PPC_TM_CPPR
:
18682 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
18683 case NT_PPC_TM_CDSCR
:
18684 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
18686 return _("NT_386_TLS (x86 TLS information)");
18687 case NT_386_IOPERM
:
18688 return _("NT_386_IOPERM (x86 I/O permissions)");
18689 case NT_X86_XSTATE
:
18690 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
18692 return _("NT_X86_CET (x86 CET state)");
18693 case NT_S390_HIGH_GPRS
:
18694 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
18695 case NT_S390_TIMER
:
18696 return _("NT_S390_TIMER (s390 timer register)");
18697 case NT_S390_TODCMP
:
18698 return _("NT_S390_TODCMP (s390 TOD comparator register)");
18699 case NT_S390_TODPREG
:
18700 return _("NT_S390_TODPREG (s390 TOD programmable register)");
18702 return _("NT_S390_CTRS (s390 control registers)");
18703 case NT_S390_PREFIX
:
18704 return _("NT_S390_PREFIX (s390 prefix register)");
18705 case NT_S390_LAST_BREAK
:
18706 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
18707 case NT_S390_SYSTEM_CALL
:
18708 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
18710 return _("NT_S390_TDB (s390 transaction diagnostic block)");
18711 case NT_S390_VXRS_LOW
:
18712 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
18713 case NT_S390_VXRS_HIGH
:
18714 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
18715 case NT_S390_GS_CB
:
18716 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
18717 case NT_S390_GS_BC
:
18718 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
18720 return _("NT_ARM_VFP (arm VFP registers)");
18722 return _("NT_ARM_TLS (AArch TLS registers)");
18723 case NT_ARM_HW_BREAK
:
18724 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
18725 case NT_ARM_HW_WATCH
:
18726 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
18728 return _("NT_ARM_SVE (AArch SVE registers)");
18729 case NT_ARM_PAC_MASK
:
18730 return _("NT_ARM_PAC_MASK (AArch pointer authentication code masks)");
18731 case NT_ARM_TAGGED_ADDR_CTRL
:
18732 return _("NT_ARM_TAGGED_ADDR_CTRL (AArch tagged address control)");
18734 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
18736 return _("NT_RISCV_CSR (RISC-V control and status registers)");
18738 return _("NT_PSTATUS (pstatus structure)");
18740 return _("NT_FPREGS (floating point registers)");
18742 return _("NT_PSINFO (psinfo structure)");
18744 return _("NT_LWPSTATUS (lwpstatus_t structure)");
18746 return _("NT_LWPSINFO (lwpsinfo_t structure)");
18747 case NT_WIN32PSTATUS
:
18748 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
18750 return _("NT_SIGINFO (siginfo_t data)");
18752 return _("NT_FILE (mapped files)");
18754 return _("NT_MEMTAG (memory tags)");
18762 return _("NT_VERSION (version)");
18764 return _("NT_ARCH (architecture)");
18765 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
18767 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
18773 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18778 print_core_note (Elf_Internal_Note
*pnote
)
18780 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
18781 bfd_vma count
, page_size
;
18782 unsigned char *descdata
, *filenames
, *descend
;
18784 if (pnote
->type
!= NT_FILE
)
18794 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
18795 /* Still "successful". */
18800 if (pnote
->descsz
< 2 * addr_size
)
18802 error (_(" Malformed note - too short for header\n"));
18806 descdata
= (unsigned char *) pnote
->descdata
;
18807 descend
= descdata
+ pnote
->descsz
;
18809 if (descdata
[pnote
->descsz
- 1] != '\0')
18811 error (_(" Malformed note - does not end with \\0\n"));
18815 count
= byte_get (descdata
, addr_size
);
18816 descdata
+= addr_size
;
18818 page_size
= byte_get (descdata
, addr_size
);
18819 descdata
+= addr_size
;
18821 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
18822 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
18824 error (_(" Malformed note - too short for supplied file count\n"));
18828 printf (_(" Page size: "));
18829 print_vma (page_size
, DEC
);
18832 printf (_(" %*s%*s%*s\n"),
18833 (int) (2 + 2 * addr_size
), _("Start"),
18834 (int) (4 + 2 * addr_size
), _("End"),
18835 (int) (4 + 2 * addr_size
), _("Page Offset"));
18836 filenames
= descdata
+ count
* 3 * addr_size
;
18837 while (count
-- > 0)
18839 bfd_vma start
, end
, file_ofs
;
18841 if (filenames
== descend
)
18843 error (_(" Malformed note - filenames end too early\n"));
18847 start
= byte_get (descdata
, addr_size
);
18848 descdata
+= addr_size
;
18849 end
= byte_get (descdata
, addr_size
);
18850 descdata
+= addr_size
;
18851 file_ofs
= byte_get (descdata
, addr_size
);
18852 descdata
+= addr_size
;
18855 print_vma (start
, FULL_HEX
);
18857 print_vma (end
, FULL_HEX
);
18859 print_vma (file_ofs
, FULL_HEX
);
18860 printf ("\n %s\n", filenames
);
18862 filenames
+= 1 + strlen ((char *) filenames
);
18868 static const char *
18869 get_gnu_elf_note_type (unsigned e_type
)
18871 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
18874 case NT_GNU_ABI_TAG
:
18875 return _("NT_GNU_ABI_TAG (ABI version tag)");
18877 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
18878 case NT_GNU_BUILD_ID
:
18879 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
18880 case NT_GNU_GOLD_VERSION
:
18881 return _("NT_GNU_GOLD_VERSION (gold version)");
18882 case NT_GNU_PROPERTY_TYPE_0
:
18883 return _("NT_GNU_PROPERTY_TYPE_0");
18884 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
18885 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
18886 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
18887 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
18890 static char buff
[64];
18892 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18899 decode_x86_compat_isa (unsigned int bitmask
)
18903 unsigned int bit
= bitmask
& (- bitmask
);
18908 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
18911 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
18914 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
18917 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
18920 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
18923 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
18926 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
18929 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
18932 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
18935 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
18938 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
18941 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
18942 printf ("AVX512F");
18944 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
18945 printf ("AVX512CD");
18947 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
18948 printf ("AVX512ER");
18950 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
18951 printf ("AVX512PF");
18953 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
18954 printf ("AVX512VL");
18956 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
18957 printf ("AVX512DQ");
18959 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
18960 printf ("AVX512BW");
18963 printf (_("<unknown: %x>"), bit
);
18972 decode_x86_compat_2_isa (unsigned int bitmask
)
18976 printf (_("<None>"));
18982 unsigned int bit
= bitmask
& (- bitmask
);
18987 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_CMOV
:
18990 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE
:
18993 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE2
:
18996 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE3
:
18999 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSSE3
:
19002 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_1
:
19005 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_2
:
19008 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX
:
19011 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX2
:
19014 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_FMA
:
19017 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512F
:
19018 printf ("AVX512F");
19020 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512CD
:
19021 printf ("AVX512CD");
19023 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512ER
:
19024 printf ("AVX512ER");
19026 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512PF
:
19027 printf ("AVX512PF");
19029 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512VL
:
19030 printf ("AVX512VL");
19032 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512DQ
:
19033 printf ("AVX512DQ");
19035 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512BW
:
19036 printf ("AVX512BW");
19038 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4FMAPS
:
19039 printf ("AVX512_4FMAPS");
19041 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4VNNIW
:
19042 printf ("AVX512_4VNNIW");
19044 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BITALG
:
19045 printf ("AVX512_BITALG");
19047 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_IFMA
:
19048 printf ("AVX512_IFMA");
19050 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI
:
19051 printf ("AVX512_VBMI");
19053 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI2
:
19054 printf ("AVX512_VBMI2");
19056 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VNNI
:
19057 printf ("AVX512_VNNI");
19059 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BF16
:
19060 printf ("AVX512_BF16");
19063 printf (_("<unknown: %x>"), bit
);
19072 decode_x86_isa (unsigned int bitmask
)
19076 unsigned int bit
= bitmask
& (- bitmask
);
19081 case GNU_PROPERTY_X86_ISA_1_BASELINE
:
19082 printf ("x86-64-baseline");
19084 case GNU_PROPERTY_X86_ISA_1_V2
:
19085 printf ("x86-64-v2");
19087 case GNU_PROPERTY_X86_ISA_1_V3
:
19088 printf ("x86-64-v3");
19090 case GNU_PROPERTY_X86_ISA_1_V4
:
19091 printf ("x86-64-v4");
19094 printf (_("<unknown: %x>"), bit
);
19103 decode_x86_feature_1 (unsigned int bitmask
)
19107 printf (_("<None>"));
19113 unsigned int bit
= bitmask
& (- bitmask
);
19118 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
19121 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
19124 case GNU_PROPERTY_X86_FEATURE_1_LAM_U48
:
19125 printf ("LAM_U48");
19127 case GNU_PROPERTY_X86_FEATURE_1_LAM_U57
:
19128 printf ("LAM_U57");
19131 printf (_("<unknown: %x>"), bit
);
19140 decode_x86_feature_2 (unsigned int bitmask
)
19144 printf (_("<None>"));
19150 unsigned int bit
= bitmask
& (- bitmask
);
19155 case GNU_PROPERTY_X86_FEATURE_2_X86
:
19158 case GNU_PROPERTY_X86_FEATURE_2_X87
:
19161 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
19164 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
19167 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
19170 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
19173 case GNU_PROPERTY_X86_FEATURE_2_TMM
:
19176 case GNU_PROPERTY_X86_FEATURE_2_MASK
:
19179 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
19182 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
19185 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
19186 printf ("XSAVEOPT");
19188 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
19192 printf (_("<unknown: %x>"), bit
);
19201 decode_aarch64_feature_1_and (unsigned int bitmask
)
19205 unsigned int bit
= bitmask
& (- bitmask
);
19210 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
19214 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
19219 printf (_("<unknown: %x>"), bit
);
19228 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
19230 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
19231 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
19232 unsigned int size
= is_32bit_elf
? 4 : 8;
19234 printf (_(" Properties: "));
19236 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
19238 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
19242 while (ptr
< ptr_end
)
19246 unsigned int datasz
;
19248 if ((size_t) (ptr_end
- ptr
) < 8)
19250 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
19254 type
= byte_get (ptr
, 4);
19255 datasz
= byte_get (ptr
+ 4, 4);
19259 if (datasz
> (size_t) (ptr_end
- ptr
))
19261 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
19266 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
19268 if (filedata
->file_header
.e_machine
== EM_X86_64
19269 || filedata
->file_header
.e_machine
== EM_IAMCU
19270 || filedata
->file_header
.e_machine
== EM_386
)
19272 unsigned int bitmask
;
19275 bitmask
= byte_get (ptr
, 4);
19281 case GNU_PROPERTY_X86_ISA_1_USED
:
19283 printf (_("x86 ISA used: <corrupt length: %#x> "),
19287 printf ("x86 ISA used: ");
19288 decode_x86_isa (bitmask
);
19292 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
19294 printf (_("x86 ISA needed: <corrupt length: %#x> "),
19298 printf ("x86 ISA needed: ");
19299 decode_x86_isa (bitmask
);
19303 case GNU_PROPERTY_X86_FEATURE_1_AND
:
19305 printf (_("x86 feature: <corrupt length: %#x> "),
19309 printf ("x86 feature: ");
19310 decode_x86_feature_1 (bitmask
);
19314 case GNU_PROPERTY_X86_FEATURE_2_USED
:
19316 printf (_("x86 feature used: <corrupt length: %#x> "),
19320 printf ("x86 feature used: ");
19321 decode_x86_feature_2 (bitmask
);
19325 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
19327 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
19330 printf ("x86 feature needed: ");
19331 decode_x86_feature_2 (bitmask
);
19335 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
19337 printf (_("x86 ISA used: <corrupt length: %#x> "),
19341 printf ("x86 ISA used: ");
19342 decode_x86_compat_isa (bitmask
);
19346 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
19348 printf (_("x86 ISA needed: <corrupt length: %#x> "),
19352 printf ("x86 ISA needed: ");
19353 decode_x86_compat_isa (bitmask
);
19357 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_USED
:
19359 printf (_("x86 ISA used: <corrupt length: %#x> "),
19363 printf ("x86 ISA used: ");
19364 decode_x86_compat_2_isa (bitmask
);
19368 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_NEEDED
:
19370 printf (_("x86 ISA needed: <corrupt length: %#x> "),
19374 printf ("x86 ISA needed: ");
19375 decode_x86_compat_2_isa (bitmask
);
19383 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
19385 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
19387 printf ("AArch64 feature: ");
19389 printf (_("<corrupt length: %#x> "), datasz
);
19391 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
19400 case GNU_PROPERTY_STACK_SIZE
:
19401 printf (_("stack size: "));
19402 if (datasz
!= size
)
19403 printf (_("<corrupt length: %#x> "), datasz
);
19405 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
19408 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
19409 printf ("no copy on protected ");
19411 printf (_("<corrupt length: %#x> "), datasz
);
19419 if (type
< GNU_PROPERTY_LOPROC
)
19420 printf (_("<unknown type %#x data: "), type
);
19421 else if (type
< GNU_PROPERTY_LOUSER
)
19422 printf (_("<processor-specific type %#x data: "), type
);
19424 printf (_("<application-specific type %#x data: "), type
);
19425 for (j
= 0; j
< datasz
; ++j
)
19426 printf ("%02x ", ptr
[j
] & 0xff);
19430 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
19431 if (ptr
== ptr_end
)
19444 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
19446 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
19447 switch (pnote
->type
)
19449 case NT_GNU_BUILD_ID
:
19453 printf (_(" Build ID: "));
19454 for (i
= 0; i
< pnote
->descsz
; ++i
)
19455 printf ("%02x", pnote
->descdata
[i
] & 0xff);
19460 case NT_GNU_ABI_TAG
:
19462 unsigned long os
, major
, minor
, subminor
;
19463 const char *osname
;
19465 /* PR 17531: file: 030-599401-0.004. */
19466 if (pnote
->descsz
< 16)
19468 printf (_(" <corrupt GNU_ABI_TAG>\n"));
19472 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19473 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19474 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
19475 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
19479 case GNU_ABI_TAG_LINUX
:
19482 case GNU_ABI_TAG_HURD
:
19485 case GNU_ABI_TAG_SOLARIS
:
19486 osname
= "Solaris";
19488 case GNU_ABI_TAG_FREEBSD
:
19489 osname
= "FreeBSD";
19491 case GNU_ABI_TAG_NETBSD
:
19494 case GNU_ABI_TAG_SYLLABLE
:
19495 osname
= "Syllable";
19497 case GNU_ABI_TAG_NACL
:
19501 osname
= "Unknown";
19505 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
19506 major
, minor
, subminor
);
19510 case NT_GNU_GOLD_VERSION
:
19514 printf (_(" Version: "));
19515 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
19516 printf ("%c", pnote
->descdata
[i
]);
19523 unsigned long num_entries
, mask
;
19525 /* Hardware capabilities information. Word 0 is the number of entries.
19526 Word 1 is a bitmask of enabled entries. The rest of the descriptor
19527 is a series of entries, where each entry is a single byte followed
19528 by a nul terminated string. The byte gives the bit number to test
19529 if enabled in the bitmask. */
19530 printf (_(" Hardware Capabilities: "));
19531 if (pnote
->descsz
< 8)
19533 error (_("<corrupt GNU_HWCAP>\n"));
19536 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19537 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19538 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
19539 /* FIXME: Add code to display the entries... */
19543 case NT_GNU_PROPERTY_TYPE_0
:
19544 print_gnu_property_note (filedata
, pnote
);
19548 /* Handle unrecognised types. An error message should have already been
19549 created by get_gnu_elf_note_type(), so all that we need to do is to
19550 display the data. */
19554 printf (_(" Description data: "));
19555 for (i
= 0; i
< pnote
->descsz
; ++i
)
19556 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19565 static const char *
19566 get_v850_elf_note_type (enum v850_notes n_type
)
19568 static char buff
[64];
19572 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
19573 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
19574 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
19575 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
19576 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
19577 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
19579 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
19585 print_v850_note (Elf_Internal_Note
* pnote
)
19589 if (pnote
->descsz
!= 4)
19592 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
19596 printf (_("not set\n"));
19600 switch (pnote
->type
)
19602 case V850_NOTE_ALIGNMENT
:
19605 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return true;
19606 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return true;
19610 case V850_NOTE_DATA_SIZE
:
19613 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return true;
19614 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return true;
19618 case V850_NOTE_FPU_INFO
:
19621 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return true;
19622 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return true;
19626 case V850_NOTE_MMU_INFO
:
19627 case V850_NOTE_CACHE_INFO
:
19628 case V850_NOTE_SIMD_INFO
:
19629 if (val
== EF_RH850_SIMD
)
19631 printf (_("yes\n"));
19637 /* An 'unknown note type' message will already have been displayed. */
19641 printf (_("unknown value: %x\n"), val
);
19646 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
19648 unsigned int version
;
19650 switch (pnote
->type
)
19652 case NT_NETBSD_IDENT
:
19653 if (pnote
->descsz
< 1)
19655 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
19656 if ((version
/ 10000) % 100)
19657 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
19658 version
, version
/ 100000000, (version
/ 1000000) % 100,
19659 (version
/ 10000) % 100 > 26 ? "Z" : "",
19660 'A' + (version
/ 10000) % 26);
19662 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
19663 version
, version
/ 100000000, (version
/ 1000000) % 100,
19664 (version
/ 100) % 100);
19667 case NT_NETBSD_MARCH
:
19668 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
19672 case NT_NETBSD_PAX
:
19673 if (pnote
->descsz
< 1)
19675 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
19676 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
19677 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
19678 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
19679 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
19680 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
19681 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
19682 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
19686 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
19687 pnote
->descsz
, pnote
->type
);
19691 static const char *
19692 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
19696 case NT_FREEBSD_THRMISC
:
19697 return _("NT_THRMISC (thrmisc structure)");
19698 case NT_FREEBSD_PROCSTAT_PROC
:
19699 return _("NT_PROCSTAT_PROC (proc data)");
19700 case NT_FREEBSD_PROCSTAT_FILES
:
19701 return _("NT_PROCSTAT_FILES (files data)");
19702 case NT_FREEBSD_PROCSTAT_VMMAP
:
19703 return _("NT_PROCSTAT_VMMAP (vmmap data)");
19704 case NT_FREEBSD_PROCSTAT_GROUPS
:
19705 return _("NT_PROCSTAT_GROUPS (groups data)");
19706 case NT_FREEBSD_PROCSTAT_UMASK
:
19707 return _("NT_PROCSTAT_UMASK (umask data)");
19708 case NT_FREEBSD_PROCSTAT_RLIMIT
:
19709 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
19710 case NT_FREEBSD_PROCSTAT_OSREL
:
19711 return _("NT_PROCSTAT_OSREL (osreldate data)");
19712 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
19713 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
19714 case NT_FREEBSD_PROCSTAT_AUXV
:
19715 return _("NT_PROCSTAT_AUXV (auxv data)");
19716 case NT_FREEBSD_PTLWPINFO
:
19717 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
19719 return get_note_type (filedata
, e_type
);
19722 static const char *
19723 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
19725 static char buff
[64];
19729 case NT_NETBSDCORE_PROCINFO
:
19730 /* NetBSD core "procinfo" structure. */
19731 return _("NetBSD procinfo structure");
19733 case NT_NETBSDCORE_AUXV
:
19734 return _("NetBSD ELF auxiliary vector data");
19736 case NT_NETBSDCORE_LWPSTATUS
:
19737 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
19740 /* As of Jan 2020 there are no other machine-independent notes
19741 defined for NetBSD core files. If the note type is less
19742 than the start of the machine-dependent note types, we don't
19745 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
19747 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19753 switch (filedata
->file_header
.e_machine
)
19755 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
19756 and PT_GETFPREGS == mach+2. */
19761 case EM_SPARC32PLUS
:
19765 case NT_NETBSDCORE_FIRSTMACH
+ 0:
19766 return _("PT_GETREGS (reg structure)");
19767 case NT_NETBSDCORE_FIRSTMACH
+ 2:
19768 return _("PT_GETFPREGS (fpreg structure)");
19774 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
19775 There's also old PT___GETREGS40 == mach + 1 for old reg
19776 structure which lacks GBR. */
19780 case NT_NETBSDCORE_FIRSTMACH
+ 1:
19781 return _("PT___GETREGS40 (old reg structure)");
19782 case NT_NETBSDCORE_FIRSTMACH
+ 3:
19783 return _("PT_GETREGS (reg structure)");
19784 case NT_NETBSDCORE_FIRSTMACH
+ 5:
19785 return _("PT_GETFPREGS (fpreg structure)");
19791 /* On all other arch's, PT_GETREGS == mach+1 and
19792 PT_GETFPREGS == mach+3. */
19796 case NT_NETBSDCORE_FIRSTMACH
+ 1:
19797 return _("PT_GETREGS (reg structure)");
19798 case NT_NETBSDCORE_FIRSTMACH
+ 3:
19799 return _("PT_GETFPREGS (fpreg structure)");
19805 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
19806 e_type
- NT_NETBSDCORE_FIRSTMACH
);
19810 static const char *
19811 get_stapsdt_note_type (unsigned e_type
)
19813 static char buff
[64];
19818 return _("NT_STAPSDT (SystemTap probe descriptors)");
19824 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19829 print_stapsdt_note (Elf_Internal_Note
*pnote
)
19831 size_t len
, maxlen
;
19832 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
19833 char *data
= pnote
->descdata
;
19834 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
19835 bfd_vma pc
, base_addr
, semaphore
;
19836 char *provider
, *probe
, *arg_fmt
;
19838 if (pnote
->descsz
< (addr_size
* 3))
19839 goto stapdt_note_too_small
;
19841 pc
= byte_get ((unsigned char *) data
, addr_size
);
19844 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
19847 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
19850 if (data
>= data_end
)
19851 goto stapdt_note_too_small
;
19852 maxlen
= data_end
- data
;
19853 len
= strnlen (data
, maxlen
);
19860 goto stapdt_note_too_small
;
19862 if (data
>= data_end
)
19863 goto stapdt_note_too_small
;
19864 maxlen
= data_end
- data
;
19865 len
= strnlen (data
, maxlen
);
19872 goto stapdt_note_too_small
;
19874 if (data
>= data_end
)
19875 goto stapdt_note_too_small
;
19876 maxlen
= data_end
- data
;
19877 len
= strnlen (data
, maxlen
);
19884 goto stapdt_note_too_small
;
19886 printf (_(" Provider: %s\n"), provider
);
19887 printf (_(" Name: %s\n"), probe
);
19888 printf (_(" Location: "));
19889 print_vma (pc
, FULL_HEX
);
19890 printf (_(", Base: "));
19891 print_vma (base_addr
, FULL_HEX
);
19892 printf (_(", Semaphore: "));
19893 print_vma (semaphore
, FULL_HEX
);
19895 printf (_(" Arguments: %s\n"), arg_fmt
);
19897 return data
== data_end
;
19899 stapdt_note_too_small
:
19900 printf (_(" <corrupt - note is too small>\n"));
19901 error (_("corrupt stapdt note - the data size is too small\n"));
19905 static const char *
19906 get_ia64_vms_note_type (unsigned e_type
)
19908 static char buff
[64];
19913 return _("NT_VMS_MHD (module header)");
19915 return _("NT_VMS_LNM (language name)");
19917 return _("NT_VMS_SRC (source files)");
19919 return "NT_VMS_TITLE";
19921 return _("NT_VMS_EIDC (consistency check)");
19922 case NT_VMS_FPMODE
:
19923 return _("NT_VMS_FPMODE (FP mode)");
19924 case NT_VMS_LINKTIME
:
19925 return "NT_VMS_LINKTIME";
19926 case NT_VMS_IMGNAM
:
19927 return _("NT_VMS_IMGNAM (image name)");
19929 return _("NT_VMS_IMGID (image id)");
19930 case NT_VMS_LINKID
:
19931 return _("NT_VMS_LINKID (link id)");
19932 case NT_VMS_IMGBID
:
19933 return _("NT_VMS_IMGBID (build id)");
19934 case NT_VMS_GSTNAM
:
19935 return _("NT_VMS_GSTNAM (sym table name)");
19936 case NT_VMS_ORIG_DYN
:
19937 return "NT_VMS_ORIG_DYN";
19938 case NT_VMS_PATCHTIME
:
19939 return "NT_VMS_PATCHTIME";
19941 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19947 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
19949 int maxlen
= pnote
->descsz
;
19951 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
19952 goto desc_size_fail
;
19954 switch (pnote
->type
)
19958 goto desc_size_fail
;
19960 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
19962 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
19963 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
19964 if (l
+ 34 < maxlen
)
19966 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
19967 if (l
+ 35 < maxlen
)
19968 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
19970 printf (_(" Module version : <missing>\n"));
19974 printf (_(" Module name : <missing>\n"));
19975 printf (_(" Module version : <missing>\n"));
19980 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
19984 case NT_VMS_FPMODE
:
19985 printf (_(" Floating Point mode: "));
19987 goto desc_size_fail
;
19988 /* FIXME: Generate an error if descsz > 8 ? */
19990 printf ("0x%016" BFD_VMA_FMT
"x\n",
19991 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19994 case NT_VMS_LINKTIME
:
19995 printf (_(" Link time: "));
19997 goto desc_size_fail
;
19998 /* FIXME: Generate an error if descsz > 8 ? */
20001 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
20005 case NT_VMS_PATCHTIME
:
20006 printf (_(" Patch time: "));
20008 goto desc_size_fail
;
20009 /* FIXME: Generate an error if descsz > 8 ? */
20012 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
20016 case NT_VMS_ORIG_DYN
:
20018 goto desc_size_fail
;
20020 printf (_(" Major id: %u, minor id: %u\n"),
20021 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
20022 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
20023 printf (_(" Last modified : "));
20025 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
20026 printf (_("\n Link flags : "));
20027 printf ("0x%016" BFD_VMA_FMT
"x\n",
20028 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
20029 printf (_(" Header flags: 0x%08x\n"),
20030 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
20031 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
20035 case NT_VMS_IMGNAM
:
20036 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
20039 case NT_VMS_GSTNAM
:
20040 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
20044 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
20047 case NT_VMS_LINKID
:
20048 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
20058 printf (_(" <corrupt - data size is too small>\n"));
20059 error (_("corrupt IA64 note: data size is too small\n"));
20063 struct build_attr_cache
{
20064 Filedata
*filedata
;
20066 unsigned long strtablen
;
20067 Elf_Internal_Sym
*symtab
;
20068 unsigned long nsyms
;
20071 /* Find the symbol associated with a build attribute that is attached
20072 to address OFFSET. If PNAME is non-NULL then store the name of
20073 the symbol (if found) in the provided pointer, Returns NULL if a
20074 symbol could not be found. */
20076 static Elf_Internal_Sym
*
20077 get_symbol_for_build_attribute (Filedata
*filedata
,
20078 unsigned long offset
,
20080 const char **pname
)
20082 Elf_Internal_Sym
*saved_sym
= NULL
;
20083 Elf_Internal_Sym
*sym
;
20085 if (filedata
->section_headers
!= NULL
20086 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
20088 Elf_Internal_Shdr
* symsec
;
20090 free (ba_cache
.strtab
);
20091 ba_cache
.strtab
= NULL
;
20092 free (ba_cache
.symtab
);
20093 ba_cache
.symtab
= NULL
;
20095 /* Load the symbol and string sections. */
20096 for (symsec
= filedata
->section_headers
;
20097 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
20100 if (symsec
->sh_type
== SHT_SYMTAB
20101 && get_symtab (filedata
, symsec
,
20102 &ba_cache
.symtab
, &ba_cache
.nsyms
,
20103 &ba_cache
.strtab
, &ba_cache
.strtablen
))
20106 ba_cache
.filedata
= filedata
;
20109 if (ba_cache
.symtab
== NULL
)
20112 /* Find a symbol whose value matches offset. */
20113 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
20114 if (sym
->st_value
== offset
)
20116 if (sym
->st_name
>= ba_cache
.strtablen
)
20117 /* Huh ? This should not happen. */
20120 if (ba_cache
.strtab
[sym
->st_name
] == 0)
20123 /* The AArch64 and ARM architectures define mapping symbols
20124 (eg $d, $x, $t) which we want to ignore. */
20125 if (ba_cache
.strtab
[sym
->st_name
] == '$'
20126 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
20127 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
20132 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
20133 and FILE or OBJECT symbols over NOTYPE symbols. We skip
20134 FUNC symbols entirely. */
20135 switch (ELF_ST_TYPE (sym
->st_info
))
20142 /* If the symbol has a size associated
20143 with it then we can stop searching. */
20144 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
20149 /* Ignore function symbols. */
20156 switch (ELF_ST_BIND (sym
->st_info
))
20159 if (saved_sym
== NULL
20160 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
20165 if (saved_sym
== NULL
)
20175 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
20183 if (saved_sym
&& pname
)
20184 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
20189 /* Returns true iff addr1 and addr2 are in the same section. */
20192 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
20194 Elf_Internal_Shdr
* a1
;
20195 Elf_Internal_Shdr
* a2
;
20197 a1
= find_section_by_address (filedata
, addr1
);
20198 a2
= find_section_by_address (filedata
, addr2
);
20200 return a1
== a2
&& a1
!= NULL
;
20204 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
20205 Filedata
* filedata
)
20207 static unsigned long global_offset
= 0;
20208 static unsigned long global_end
= 0;
20209 static unsigned long func_offset
= 0;
20210 static unsigned long func_end
= 0;
20212 Elf_Internal_Sym
*sym
;
20214 unsigned long start
;
20216 bool is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
20218 switch (pnote
->descsz
)
20221 /* A zero-length description means that the range of
20222 the previous note of the same type should be used. */
20225 if (global_end
> global_offset
)
20226 printf (_(" Applies to region from %#lx to %#lx\n"),
20227 global_offset
, global_end
);
20229 printf (_(" Applies to region from %#lx\n"), global_offset
);
20233 if (func_end
> func_offset
)
20234 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
20236 printf (_(" Applies to region from %#lx\n"), func_offset
);
20241 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20246 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20247 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
20251 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
20252 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
20256 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
20257 printf (_(" <invalid descsz>"));
20262 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
20263 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
20264 in order to avoid them being confused with the start address of the
20265 first function in the file... */
20266 if (sym
== NULL
&& is_open_attr
)
20267 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
20270 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
20271 end
= start
+ sym
->st_size
;
20275 /* FIXME: Need to properly allow for section alignment.
20276 16 is just the alignment used on x86_64. */
20278 && start
> BFD_ALIGN (global_end
, 16)
20279 /* Build notes are not guaranteed to be organised in order of
20280 increasing address, but we should find the all of the notes
20281 for one section in the same place. */
20282 && same_section (filedata
, start
, global_end
))
20283 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
20284 global_end
+ 1, start
- 1);
20286 printf (_(" Applies to region from %#lx"), start
);
20287 global_offset
= start
;
20291 printf (_(" to %#lx"), end
);
20297 printf (_(" Applies to region from %#lx"), start
);
20298 func_offset
= start
;
20302 printf (_(" to %#lx"), end
);
20308 printf (_(" (%s)"), name
);
20315 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
20317 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
20318 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
20319 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
20321 char name_attribute
;
20322 const char * expected_types
;
20323 const char * name
= pnote
->namedata
;
20327 if (name
== NULL
|| pnote
->namesz
< 2)
20329 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
20330 print_symbol (-20, _(" <corrupt name>"));
20339 /* Version 2 of the spec adds a "GA" prefix to the name field. */
20340 if (name
[0] == 'G' && name
[1] == 'A')
20342 if (pnote
->namesz
< 4)
20344 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
20345 print_symbol (-20, _(" <corrupt name>"));
20354 switch ((name_type
= * name
))
20356 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
20357 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
20358 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
20359 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
20360 printf ("%c", * name
);
20364 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
20365 print_symbol (-20, _("<unknown name type>"));
20372 switch ((name_attribute
= * name
))
20374 case GNU_BUILD_ATTRIBUTE_VERSION
:
20375 text
= _("<version>");
20376 expected_types
= string_expected
;
20379 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
20380 text
= _("<stack prot>");
20381 expected_types
= "!+*";
20384 case GNU_BUILD_ATTRIBUTE_RELRO
:
20385 text
= _("<relro>");
20386 expected_types
= bool_expected
;
20389 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
20390 text
= _("<stack size>");
20391 expected_types
= number_expected
;
20394 case GNU_BUILD_ATTRIBUTE_TOOL
:
20395 text
= _("<tool>");
20396 expected_types
= string_expected
;
20399 case GNU_BUILD_ATTRIBUTE_ABI
:
20401 expected_types
= "$*";
20404 case GNU_BUILD_ATTRIBUTE_PIC
:
20406 expected_types
= number_expected
;
20409 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
20410 text
= _("<short enum>");
20411 expected_types
= bool_expected
;
20415 if (ISPRINT (* name
))
20417 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
20419 if (len
> left
&& ! do_wide
)
20421 printf ("%.*s:", len
, name
);
20427 static char tmpbuf
[128];
20429 error (_("unrecognised byte in name field: %d\n"), * name
);
20430 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
20434 expected_types
= "*$!+";
20439 left
-= printf ("%s", text
);
20441 if (strchr (expected_types
, name_type
) == NULL
)
20442 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
20444 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
20446 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
20447 (unsigned long) pnote
->namesz
,
20448 (long) (name
- pnote
->namedata
));
20452 if (left
< 1 && ! do_wide
)
20457 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
20459 unsigned int bytes
;
20460 unsigned long long val
= 0;
20461 unsigned int shift
= 0;
20462 char * decoded
= NULL
;
20464 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
20466 /* The -1 is because the name field is always 0 terminated, and we
20467 want to be able to ensure that the shift in the while loop below
20468 will not overflow. */
20471 if (bytes
> sizeof (val
))
20473 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
20475 bytes
= sizeof (val
);
20477 /* We do not bother to warn if bytes == 0 as this can
20478 happen with some early versions of the gcc plugin. */
20482 unsigned long long byte
= *name
++ & 0xff;
20484 val
|= byte
<< shift
;
20488 switch (name_attribute
)
20490 case GNU_BUILD_ATTRIBUTE_PIC
:
20493 case 0: decoded
= "static"; break;
20494 case 1: decoded
= "pic"; break;
20495 case 2: decoded
= "PIC"; break;
20496 case 3: decoded
= "pie"; break;
20497 case 4: decoded
= "PIE"; break;
20501 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
20504 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
20505 case 0: decoded
= "off"; break;
20506 case 1: decoded
= "on"; break;
20507 case 2: decoded
= "all"; break;
20508 case 3: decoded
= "strong"; break;
20509 case 4: decoded
= "explicit"; break;
20517 if (decoded
!= NULL
)
20519 print_symbol (-left
, decoded
);
20530 left
-= printf ("0x%llx", val
);
20532 left
-= printf ("0x%-.*llx", left
, val
);
20536 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
20537 left
-= print_symbol (- left
, name
);
20539 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
20540 left
-= print_symbol (- left
, "true");
20542 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
20543 left
-= print_symbol (- left
, "false");
20547 if (do_wide
&& left
> 0)
20548 printf ("%-*s", left
, " ");
20553 /* Note that by the ELF standard, the name field is already null byte
20554 terminated, and namesz includes the terminating null byte.
20555 I.E. the value of namesz for the name "FSF" is 4.
20557 If the value of namesz is zero, there is no name present. */
20560 process_note (Elf_Internal_Note
* pnote
,
20561 Filedata
* filedata
)
20563 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
20566 if (pnote
->namesz
== 0)
20567 /* If there is no note name, then use the default set of
20568 note type strings. */
20569 nt
= get_note_type (filedata
, pnote
->type
);
20571 else if (startswith (pnote
->namedata
, "GNU"))
20572 /* GNU-specific object file notes. */
20573 nt
= get_gnu_elf_note_type (pnote
->type
);
20575 else if (startswith (pnote
->namedata
, "FreeBSD"))
20576 /* FreeBSD-specific core file notes. */
20577 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
20579 else if (startswith (pnote
->namedata
, "NetBSD-CORE"))
20580 /* NetBSD-specific core file notes. */
20581 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
20583 else if (startswith (pnote
->namedata
, "NetBSD"))
20584 /* NetBSD-specific core file notes. */
20585 return process_netbsd_elf_note (pnote
);
20587 else if (startswith (pnote
->namedata
, "PaX"))
20588 /* NetBSD-specific core file notes. */
20589 return process_netbsd_elf_note (pnote
);
20591 else if (startswith (pnote
->namedata
, "SPU/"))
20593 /* SPU-specific core file notes. */
20594 nt
= pnote
->namedata
+ 4;
20598 else if (startswith (pnote
->namedata
, "IPF/VMS"))
20599 /* VMS/ia64-specific file notes. */
20600 nt
= get_ia64_vms_note_type (pnote
->type
);
20602 else if (startswith (pnote
->namedata
, "stapsdt"))
20603 nt
= get_stapsdt_note_type (pnote
->type
);
20606 /* Don't recognize this note name; just use the default set of
20607 note type strings. */
20608 nt
= get_note_type (filedata
, pnote
->type
);
20612 if (((startswith (pnote
->namedata
, "GA")
20613 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
20614 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
20615 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
20616 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
20617 print_gnu_build_attribute_name (pnote
);
20619 print_symbol (-20, name
);
20622 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
20624 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
20626 if (startswith (pnote
->namedata
, "IPF/VMS"))
20627 return print_ia64_vms_note (pnote
);
20628 else if (startswith (pnote
->namedata
, "GNU"))
20629 return print_gnu_note (filedata
, pnote
);
20630 else if (startswith (pnote
->namedata
, "stapsdt"))
20631 return print_stapsdt_note (pnote
);
20632 else if (startswith (pnote
->namedata
, "CORE"))
20633 return print_core_note (pnote
);
20634 else if (((startswith (pnote
->namedata
, "GA")
20635 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
20636 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
20637 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
20638 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
20639 return print_gnu_build_attribute_description (pnote
, filedata
);
20645 printf (_(" description data: "));
20646 for (i
= 0; i
< pnote
->descsz
; i
++)
20647 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
20659 process_notes_at (Filedata
* filedata
,
20660 Elf_Internal_Shdr
* section
,
20665 Elf_External_Note
*pnotes
;
20666 Elf_External_Note
*external
;
20675 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
20678 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
20686 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
20689 if (pnotes
== NULL
)
20694 if (filedata
->is_separate
)
20695 printf (_("In linked file '%s': "), filedata
->file_name
);
20699 printf (_("Displaying notes found in: %s\n"), printable_section_name (filedata
, section
));
20701 printf (_("Displaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
20702 (unsigned long) offset
, (unsigned long) length
);
20704 /* NB: Some note sections may have alignment value of 0 or 1. gABI
20705 specifies that notes should be aligned to 4 bytes in 32-bit
20706 objects and to 8 bytes in 64-bit objects. As a Linux extension,
20707 we also support 4 byte alignment in 64-bit objects. If section
20708 alignment is less than 4, we treate alignment as 4 bytes. */
20711 else if (align
!= 4 && align
!= 8)
20713 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
20719 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
20721 end
= (char *) pnotes
+ length
;
20722 while ((char *) external
< end
)
20724 Elf_Internal_Note inote
;
20727 char * temp
= NULL
;
20728 size_t data_remaining
= end
- (char *) external
;
20730 if (!is_ia64_vms (filedata
))
20732 /* PR binutils/15191
20733 Make sure that there is enough data to read. */
20734 min_notesz
= offsetof (Elf_External_Note
, name
);
20735 if (data_remaining
< min_notesz
)
20737 warn (ngettext ("Corrupt note: only %ld byte remains, "
20738 "not enough for a full note\n",
20739 "Corrupt note: only %ld bytes remain, "
20740 "not enough for a full note\n",
20742 (long) data_remaining
);
20745 data_remaining
-= min_notesz
;
20747 inote
.type
= BYTE_GET (external
->type
);
20748 inote
.namesz
= BYTE_GET (external
->namesz
);
20749 inote
.namedata
= external
->name
;
20750 inote
.descsz
= BYTE_GET (external
->descsz
);
20751 inote
.descdata
= ((char *) external
20752 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
20753 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20754 next
= ((char *) external
20755 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
20759 Elf64_External_VMS_Note
*vms_external
;
20761 /* PR binutils/15191
20762 Make sure that there is enough data to read. */
20763 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
20764 if (data_remaining
< min_notesz
)
20766 warn (ngettext ("Corrupt note: only %ld byte remains, "
20767 "not enough for a full note\n",
20768 "Corrupt note: only %ld bytes remain, "
20769 "not enough for a full note\n",
20771 (long) data_remaining
);
20774 data_remaining
-= min_notesz
;
20776 vms_external
= (Elf64_External_VMS_Note
*) external
;
20777 inote
.type
= BYTE_GET (vms_external
->type
);
20778 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
20779 inote
.namedata
= vms_external
->name
;
20780 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
20781 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
20782 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20783 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
20786 /* PR 17531: file: 3443835e. */
20787 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
20788 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
20789 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
20790 || (size_t) (next
- inote
.descdata
) < inote
.descsz
20791 || ((size_t) (next
- inote
.descdata
)
20792 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
20794 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
20795 (unsigned long) ((char *) external
- (char *) pnotes
));
20796 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
20797 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
20801 external
= (Elf_External_Note
*) next
;
20803 /* Verify that name is null terminated. It appears that at least
20804 one version of Linux (RedHat 6.0) generates corefiles that don't
20805 comply with the ELF spec by failing to include the null byte in
20807 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
20809 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
20811 temp
= (char *) malloc (inote
.namesz
+ 1);
20814 error (_("Out of memory allocating space for inote name\n"));
20819 memcpy (temp
, inote
.namedata
, inote
.namesz
);
20820 inote
.namedata
= temp
;
20822 inote
.namedata
[inote
.namesz
] = 0;
20825 if (! process_note (& inote
, filedata
))
20838 process_corefile_note_segments (Filedata
* filedata
)
20840 Elf_Internal_Phdr
*segment
;
20844 if (! get_program_headers (filedata
))
20847 for (i
= 0, segment
= filedata
->program_headers
;
20848 i
< filedata
->file_header
.e_phnum
;
20851 if (segment
->p_type
== PT_NOTE
)
20852 if (! process_notes_at (filedata
, NULL
,
20853 (bfd_vma
) segment
->p_offset
,
20854 (bfd_vma
) segment
->p_filesz
,
20855 (bfd_vma
) segment
->p_align
))
20863 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
20865 Elf_External_Note
* pnotes
;
20866 Elf_External_Note
* external
;
20873 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
20875 if (pnotes
== NULL
)
20879 end
= (char*) pnotes
+ length
;
20881 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
20882 (unsigned long) offset
, (unsigned long) length
);
20884 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
20886 Elf_External_Note
* next
;
20887 Elf_Internal_Note inote
;
20889 inote
.type
= BYTE_GET (external
->type
);
20890 inote
.namesz
= BYTE_GET (external
->namesz
);
20891 inote
.namedata
= external
->name
;
20892 inote
.descsz
= BYTE_GET (external
->descsz
);
20893 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
20894 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20896 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
20898 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
20899 inote
.descdata
= inote
.namedata
;
20903 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
20905 if ( ((char *) next
> end
)
20906 || ((char *) next
< (char *) pnotes
))
20908 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
20909 (unsigned long) ((char *) external
- (char *) pnotes
));
20910 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
20911 inote
.type
, inote
.namesz
, inote
.descsz
);
20917 /* Prevent out-of-bounds indexing. */
20918 if ( inote
.namedata
+ inote
.namesz
> end
20919 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
20921 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
20922 (unsigned long) ((char *) external
- (char *) pnotes
));
20923 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
20924 inote
.type
, inote
.namesz
, inote
.descsz
);
20928 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
20930 if (! print_v850_note (& inote
))
20933 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
20934 inote
.namesz
, inote
.descsz
);
20944 process_note_sections (Filedata
* filedata
)
20946 Elf_Internal_Shdr
*section
;
20948 unsigned int n
= 0;
20951 for (i
= 0, section
= filedata
->section_headers
;
20952 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
20955 if (section
->sh_type
== SHT_NOTE
)
20957 if (! process_notes_at (filedata
, section
,
20958 (bfd_vma
) section
->sh_offset
,
20959 (bfd_vma
) section
->sh_size
,
20960 (bfd_vma
) section
->sh_addralign
))
20965 if (( filedata
->file_header
.e_machine
== EM_V800
20966 || filedata
->file_header
.e_machine
== EM_V850
20967 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
20968 && section
->sh_type
== SHT_RENESAS_INFO
)
20970 if (! process_v850_notes (filedata
,
20971 (bfd_vma
) section
->sh_offset
,
20972 (bfd_vma
) section
->sh_size
))
20979 /* Try processing NOTE segments instead. */
20980 return process_corefile_note_segments (filedata
);
20986 process_notes (Filedata
* filedata
)
20988 /* If we have not been asked to display the notes then do nothing. */
20992 if (filedata
->file_header
.e_type
!= ET_CORE
)
20993 return process_note_sections (filedata
);
20995 /* No program headers means no NOTE segment. */
20996 if (filedata
->file_header
.e_phnum
> 0)
20997 return process_corefile_note_segments (filedata
);
20999 if (filedata
->is_separate
)
21000 printf (_("No notes found in linked file '%s'.\n"),
21001 filedata
->file_name
);
21003 printf (_("No notes found file.\n"));
21008 static unsigned char *
21009 display_public_gnu_attributes (unsigned char * start
,
21010 const unsigned char * const end
)
21012 printf (_(" Unknown GNU attribute: %s\n"), start
);
21014 start
+= strnlen ((char *) start
, end
- start
);
21015 display_raw_attribute (start
, end
);
21017 return (unsigned char *) end
;
21020 static unsigned char *
21021 display_generic_attribute (unsigned char * start
,
21023 const unsigned char * const end
)
21026 return (unsigned char *) end
;
21028 return display_tag_value (tag
, start
, end
);
21032 process_arch_specific (Filedata
* filedata
)
21037 switch (filedata
->file_header
.e_machine
)
21040 case EM_ARC_COMPACT
:
21041 case EM_ARC_COMPACT2
:
21042 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
21043 display_arc_attribute
,
21044 display_generic_attribute
);
21046 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
21047 display_arm_attribute
,
21048 display_generic_attribute
);
21051 case EM_MIPS_RS3_LE
:
21052 return process_mips_specific (filedata
);
21055 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
21056 display_msp430_attribute
,
21057 display_msp430_gnu_attribute
);
21060 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
21061 display_riscv_attribute
,
21062 display_generic_attribute
);
21065 return process_nds32_specific (filedata
);
21068 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21069 display_m68k_gnu_attribute
);
21073 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21074 display_power_gnu_attribute
);
21078 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21079 display_s390_gnu_attribute
);
21082 case EM_SPARC32PLUS
:
21084 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21085 display_sparc_gnu_attribute
);
21088 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
21089 display_tic6x_attribute
,
21090 display_generic_attribute
);
21093 return process_attributes (filedata
, "csky", SHT_CSKY_ATTRIBUTES
,
21094 display_csky_attribute
, NULL
);
21097 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
21098 display_public_gnu_attributes
,
21099 display_generic_attribute
);
21104 get_file_header (Filedata
* filedata
)
21106 /* Read in the identity array. */
21107 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
21110 /* Determine how to read the rest of the header. */
21111 switch (filedata
->file_header
.e_ident
[EI_DATA
])
21116 byte_get
= byte_get_little_endian
;
21117 byte_put
= byte_put_little_endian
;
21120 byte_get
= byte_get_big_endian
;
21121 byte_put
= byte_put_big_endian
;
21125 /* For now we only support 32 bit and 64 bit ELF files. */
21126 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
21128 /* Read in the rest of the header. */
21131 Elf32_External_Ehdr ehdr32
;
21133 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
21136 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
21137 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
21138 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
21139 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
21140 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
21141 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
21142 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
21143 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
21144 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
21145 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
21146 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
21147 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
21148 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
21152 Elf64_External_Ehdr ehdr64
;
21154 /* If we have been compiled with sizeof (bfd_vma) == 4, then
21155 we will not be able to cope with the 64bit data found in
21156 64 ELF files. Detect this now and abort before we start
21157 overwriting things. */
21158 if (sizeof (bfd_vma
) < 8)
21160 error (_("This instance of readelf has been built without support for a\n\
21161 64 bit data type and so it cannot read 64 bit ELF files.\n"));
21165 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
21168 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
21169 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
21170 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
21171 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
21172 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
21173 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
21174 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
21175 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
21176 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
21177 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
21178 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
21179 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
21180 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
21187 free_filedata (Filedata
*filedata
)
21189 free (filedata
->program_interpreter
);
21190 free (filedata
->program_headers
);
21191 free (filedata
->section_headers
);
21192 free (filedata
->string_table
);
21193 free (filedata
->dump
.dump_sects
);
21194 free (filedata
->dynamic_strings
);
21195 free (filedata
->dynamic_symbols
);
21196 free (filedata
->dynamic_syminfo
);
21197 free (filedata
->dynamic_section
);
21199 while (filedata
->symtab_shndx_list
!= NULL
)
21201 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
21202 free (filedata
->symtab_shndx_list
);
21203 filedata
->symtab_shndx_list
= next
;
21206 free (filedata
->section_headers_groups
);
21208 if (filedata
->section_groups
)
21211 struct group_list
* g
;
21212 struct group_list
* next
;
21214 for (i
= 0; i
< filedata
->group_count
; i
++)
21216 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
21223 free (filedata
->section_groups
);
21225 memset (&filedata
->section_headers
, 0,
21226 sizeof (Filedata
) - offsetof (Filedata
, section_headers
));
21230 close_file (Filedata
* filedata
)
21234 if (filedata
->handle
)
21235 fclose (filedata
->handle
);
21241 close_debug_file (void * data
)
21243 free_filedata ((Filedata
*) data
);
21244 close_file ((Filedata
*) data
);
21248 open_file (const char * pathname
, bool is_separate
)
21250 struct stat statbuf
;
21251 Filedata
* filedata
= NULL
;
21253 if (stat (pathname
, & statbuf
) < 0
21254 || ! S_ISREG (statbuf
.st_mode
))
21257 filedata
= calloc (1, sizeof * filedata
);
21258 if (filedata
== NULL
)
21261 filedata
->handle
= fopen (pathname
, "rb");
21262 if (filedata
->handle
== NULL
)
21265 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
21266 filedata
->file_name
= pathname
;
21267 filedata
->is_separate
= is_separate
;
21269 if (! get_file_header (filedata
))
21272 if (!get_section_headers (filedata
, false))
21280 if (filedata
->handle
)
21281 fclose (filedata
->handle
);
21288 open_debug_file (const char * pathname
)
21290 return open_file (pathname
, true);
21294 initialise_dump_sects (Filedata
* filedata
)
21296 /* Initialise the dump_sects array from the cmdline_dump_sects array.
21297 Note we do this even if cmdline_dump_sects is empty because we
21298 must make sure that the dump_sets array is zeroed out before each
21299 object file is processed. */
21300 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
21301 memset (filedata
->dump
.dump_sects
, 0,
21302 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
21304 if (cmdline
.num_dump_sects
> 0)
21306 if (filedata
->dump
.num_dump_sects
== 0)
21307 /* A sneaky way of allocating the dump_sects array. */
21308 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
21310 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
21311 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
21312 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
21316 /* Process one ELF object file according to the command line options.
21317 This file may actually be stored in an archive. The file is
21318 positioned at the start of the ELF object. Returns TRUE if no
21319 problems were encountered, FALSE otherwise. */
21322 process_object (Filedata
* filedata
)
21324 bool have_separate_files
;
21328 if (! get_file_header (filedata
))
21330 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
21334 /* Initialise per file variables. */
21335 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
21336 filedata
->version_info
[i
] = 0;
21338 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
21339 filedata
->dynamic_info
[i
] = 0;
21340 filedata
->dynamic_info_DT_GNU_HASH
= 0;
21341 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
21343 /* Process the file. */
21345 printf (_("\nFile: %s\n"), filedata
->file_name
);
21347 initialise_dump_sects (filedata
);
21349 /* There may be some extensions in the first section header. Don't
21350 bomb if we can't read it. */
21351 get_section_headers (filedata
, true);
21353 if (! process_file_header (filedata
))
21359 /* Throw away the single section header read above, so that we
21360 re-read the entire set. */
21361 free (filedata
->section_headers
);
21362 filedata
->section_headers
= NULL
;
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
;