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 Elf_Internal_Shdr
* section_headers
;
267 Elf_Internal_Phdr
* program_headers
;
269 unsigned long string_table_length
;
270 unsigned long archive_file_offset
;
271 unsigned long archive_file_size
;
272 unsigned long dynamic_addr
;
273 bfd_size_type dynamic_size
;
275 Elf_Internal_Dyn
* dynamic_section
;
276 Elf_Internal_Shdr
* dynamic_strtab_section
;
277 char * dynamic_strings
;
278 unsigned long dynamic_strings_length
;
279 Elf_Internal_Shdr
* dynamic_symtab_section
;
280 unsigned long num_dynamic_syms
;
281 Elf_Internal_Sym
* dynamic_symbols
;
282 bfd_vma version_info
[16];
283 unsigned int dynamic_syminfo_nent
;
284 Elf_Internal_Syminfo
* dynamic_syminfo
;
285 unsigned long dynamic_syminfo_offset
;
286 bfd_size_type nbuckets
;
287 bfd_size_type nchains
;
290 bfd_size_type ngnubuckets
;
291 bfd_size_type ngnuchains
;
292 bfd_vma
* gnubuckets
;
296 char * program_interpreter
;
297 bfd_vma dynamic_info
[DT_ENCODING
];
298 bfd_vma dynamic_info_DT_GNU_HASH
;
299 bfd_vma dynamic_info_DT_MIPS_XHASH
;
300 elf_section_list
* symtab_shndx_list
;
302 struct group
* section_groups
;
303 struct group
** section_headers_groups
;
304 /* A dynamic array of flags indicating for which sections a dump of
305 some kind has been requested. It is reset on a per-object file
306 basis and then initialised from the cmdline_dump_sects array,
307 the results of interpreting the -w switch, and the
308 dump_sects_byname list. */
309 struct dump_data dump
;
312 /* How to print a vma value. */
313 typedef enum print_mode
330 /* Versioned symbol info. */
331 enum versioned_symbol_info
338 static const char * get_symbol_version_string
339 (Filedata
*, bool, const char *, unsigned long, unsigned,
340 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
344 #define SECTION_NAME(X) \
345 (filedata->string_table + (X)->sh_name)
347 #define SECTION_NAME_VALID(X) \
349 && filedata->string_table != NULL \
350 && (X)->sh_name < filedata->string_table_length)
352 #define SECTION_NAME_PRINT(X) \
353 ((X) == NULL ? _("<none>") \
354 : filedata->string_table == NULL ? _("<no-strings>") \
355 : (X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
356 : filedata->string_table + (X)->sh_name)
358 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
360 #define GET_ELF_SYMBOLS(file, section, sym_count) \
361 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
362 : get_64bit_elf_symbols (file, section, sym_count))
364 #define VALID_SYMBOL_NAME(strtab, strtab_size, offset) \
365 (strtab != NULL && offset < strtab_size)
366 #define VALID_DYNAMIC_NAME(filedata, offset) \
367 VALID_SYMBOL_NAME (filedata->dynamic_strings, \
368 filedata->dynamic_strings_length, offset)
369 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
370 already been called and verified that the string exists. */
371 #define GET_DYNAMIC_NAME(filedata, offset) \
372 (filedata->dynamic_strings + offset)
374 #define REMOVE_ARCH_BITS(ADDR) \
377 if (filedata->file_header.e_machine == EM_ARM) \
382 /* Get the correct GNU hash section name. */
383 #define GNU_HASH_SECTION_NAME(filedata) \
384 filedata->dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
386 /* Print a BFD_VMA to an internal buffer, for use in error messages.
387 BFD_FMA_FMT can't be used in translated strings. */
390 bfd_vmatoa (char *fmtch
, bfd_vma value
)
392 /* bfd_vmatoa is used more then once in a printf call for output.
393 Cycle through an array of buffers. */
394 static int buf_pos
= 0;
395 static struct bfd_vmatoa_buf
402 ret
= buf
[buf_pos
++].place
;
403 buf_pos
%= ARRAY_SIZE (buf
);
405 sprintf (fmt
, "%%%s%s", BFD_VMA_FMT
, fmtch
);
406 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
410 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
411 OFFSET + the offset of the current archive member, if we are examining an
412 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
413 allocate a buffer using malloc and fill that. In either case return the
414 pointer to the start of the retrieved data or NULL if something went wrong.
415 If something does go wrong and REASON is not NULL then emit an error
416 message using REASON as part of the context. */
419 get_data (void * var
,
421 unsigned long offset
,
427 bfd_size_type amt
= size
* nmemb
;
429 if (size
== 0 || nmemb
== 0)
432 /* If the size_t type is smaller than the bfd_size_type, eg because
433 you are building a 32-bit tool on a 64-bit host, then make sure
434 that when the sizes are cast to (size_t) no information is lost. */
435 if ((size_t) size
!= size
436 || (size_t) nmemb
!= nmemb
437 || (size_t) amt
!= amt
)
440 error (_("Size truncation prevents reading %s"
441 " elements of size %s for %s\n"),
442 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
446 /* Check for size overflow. */
447 if (amt
/ size
!= nmemb
|| (size_t) amt
+ 1 == 0)
450 error (_("Size overflow prevents reading %s"
451 " elements of size %s for %s\n"),
452 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
456 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
457 attempting to allocate memory when the read is bound to fail. */
458 if (filedata
->archive_file_offset
> filedata
->file_size
459 || offset
> filedata
->file_size
- filedata
->archive_file_offset
460 || amt
> filedata
->file_size
- filedata
->archive_file_offset
- offset
)
463 error (_("Reading %s bytes extends past end of file for %s\n"),
464 bfd_vmatoa ("u", amt
), reason
);
468 if (fseek (filedata
->handle
, filedata
->archive_file_offset
+ offset
,
472 error (_("Unable to seek to 0x%lx for %s\n"),
473 filedata
->archive_file_offset
+ offset
, reason
);
480 /* + 1 so that we can '\0' terminate invalid string table sections. */
481 mvar
= malloc ((size_t) amt
+ 1);
486 error (_("Out of memory allocating %s bytes for %s\n"),
487 bfd_vmatoa ("u", amt
), reason
);
491 ((char *) mvar
)[amt
] = '\0';
494 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
497 error (_("Unable to read in %s bytes of %s\n"),
498 bfd_vmatoa ("u", amt
), reason
);
507 /* Print a VMA value in the MODE specified.
508 Returns the number of characters displayed. */
511 print_vma (bfd_vma vma
, print_mode mode
)
523 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
530 return printf ("%5" BFD_VMA_FMT
"d", vma
);
536 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
542 return nc
+ printf ("%05" BFD_VMA_FMT
"x", vma
);
545 return printf ("%" BFD_VMA_FMT
"d", vma
);
548 return printf ("%" BFD_VMA_FMT
"u", vma
);
551 return printf ("%5" BFD_VMA_FMT
"u", vma
);
554 return printf ("%" BFD_VMA_FMT
"o", vma
);
557 return printf ("%5" BFD_VMA_FMT
"o", vma
);
560 /* FIXME: Report unrecognised mode ? */
566 /* Display a symbol on stdout. Handles the display of control characters and
567 multibye characters (assuming the host environment supports them).
569 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
571 If truncation will happen and do_not_show_symbol_truncation is FALSE then display
572 abs(WIDTH) - 5 characters followed by "[...]".
574 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
575 padding as necessary.
577 Returns the number of emitted characters. */
580 print_symbol (signed int width
, const char * symbol
)
582 bool extra_padding
= false;
583 bool do_dots
= false;
584 signed int num_printed
= 0;
585 #ifdef HAVE_MBSTATE_T
588 unsigned int width_remaining
;
589 const void * alloced_symbol
= NULL
;
593 /* Keep the width positive. This helps the code below. */
595 extra_padding
= true;
601 /* Set the remaining width to a very large value.
602 This simplifies the code below. */
603 width_remaining
= INT_MAX
;
606 width_remaining
= width
;
607 if (! do_not_show_symbol_truncation
608 && (int) strlen (symbol
) > width
)
610 width_remaining
-= 5;
611 if ((int) width_remaining
< 0)
617 #ifdef HAVE_MBSTATE_T
618 /* Initialise the multibyte conversion state. */
619 memset (& state
, 0, sizeof (state
));
622 if (do_demangle
&& *symbol
)
624 const char * res
= cplus_demangle (symbol
, demangle_flags
);
627 alloced_symbol
= symbol
= res
;
630 while (width_remaining
)
633 const char c
= *symbol
++;
638 /* Do not print control characters directly as they can affect terminal
639 settings. Such characters usually appear in the names generated
640 by the assembler for local labels. */
643 if (width_remaining
< 2)
646 printf ("^%c", c
+ 0x40);
647 width_remaining
-= 2;
650 else if (ISPRINT (c
))
658 #ifdef HAVE_MBSTATE_T
661 /* Let printf do the hard work of displaying multibyte characters. */
662 printf ("%.1s", symbol
- 1);
666 #ifdef HAVE_MBSTATE_T
667 /* Try to find out how many bytes made up the character that was
668 just printed. Advance the symbol pointer past the bytes that
670 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
674 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
680 num_printed
+= printf ("[...]");
682 if (extra_padding
&& num_printed
< width
)
684 /* Fill in the remaining spaces. */
685 printf ("%-*s", width
- num_printed
, " ");
689 free ((void *) alloced_symbol
);
693 /* Returns a pointer to a static buffer containing a printable version of
694 the given section's name. Like print_symbol, except that it does not try
695 to print multibyte characters, it just interprets them as hex values. */
698 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
700 #define MAX_PRINT_SEC_NAME_LEN 256
701 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
702 const char * name
= SECTION_NAME_PRINT (sec
);
703 char * buf
= sec_name_buf
;
705 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
707 while ((c
= * name
++) != 0)
718 else if (ISPRINT (c
))
725 static char hex
[17] = "0123456789ABCDEF";
730 * buf
++ = hex
[(c
& 0xf0) >> 4];
731 * buf
++ = hex
[c
& 0x0f];
745 printable_section_name_from_index (Filedata
* filedata
, unsigned long ndx
)
747 if (ndx
>= filedata
->file_header
.e_shnum
)
748 return _("<corrupt>");
750 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
753 /* Return a pointer to section NAME, or NULL if no such section exists. */
755 static Elf_Internal_Shdr
*
756 find_section (Filedata
* filedata
, const char * name
)
760 if (filedata
->section_headers
== NULL
)
763 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
764 if (SECTION_NAME_VALID (filedata
->section_headers
+ i
)
765 && streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
766 return filedata
->section_headers
+ i
;
771 /* Return a pointer to a section containing ADDR, or NULL if no such
774 static Elf_Internal_Shdr
*
775 find_section_by_address (Filedata
* filedata
, bfd_vma addr
)
779 if (filedata
->section_headers
== NULL
)
782 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
784 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
786 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
793 static Elf_Internal_Shdr
*
794 find_section_by_type (Filedata
* filedata
, unsigned int type
)
798 if (filedata
->section_headers
== NULL
)
801 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
803 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
805 if (sec
->sh_type
== type
)
812 /* Return a pointer to section NAME, or NULL if no such section exists,
813 restricted to the list of sections given in SET. */
815 static Elf_Internal_Shdr
*
816 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
820 if (filedata
->section_headers
== NULL
)
825 while ((i
= *set
++) > 0)
827 /* See PR 21156 for a reproducer. */
828 if (i
>= filedata
->file_header
.e_shnum
)
829 continue; /* FIXME: Should we issue an error message ? */
831 if (SECTION_NAME_VALID (filedata
->section_headers
+ i
)
832 && streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
833 return filedata
->section_headers
+ i
;
837 return find_section (filedata
, name
);
840 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
841 This OS has so many departures from the ELF standard that we test it at
845 is_ia64_vms (Filedata
* filedata
)
847 return filedata
->file_header
.e_machine
== EM_IA_64
848 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
851 /* Guess the relocation size commonly used by the specific machines. */
854 guess_is_rela (unsigned int e_machine
)
858 /* Targets that use REL relocations. */
875 /* Targets that use RELA relocations. */
879 case EM_ADAPTEVA_EPIPHANY
:
881 case EM_ALTERA_NIOS2
:
884 case EM_ARC_COMPACT2
:
905 case EM_LATTICEMICO32
:
914 case EM_CYGNUS_MN10200
:
916 case EM_CYGNUS_MN10300
:
952 case EM_MICROBLAZE_OLD
:
974 warn (_("Don't know about relocations on this machine architecture\n"));
979 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
980 Returns TRUE upon success, FALSE otherwise. If successful then a
981 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
982 and the number of relocs loaded is placed in *NRELASP. It is the caller's
983 responsibility to free the allocated buffer. */
986 slurp_rela_relocs (Filedata
* filedata
,
987 unsigned long rel_offset
,
988 unsigned long rel_size
,
989 Elf_Internal_Rela
** relasp
,
990 unsigned long * nrelasp
)
992 Elf_Internal_Rela
* relas
;
998 Elf32_External_Rela
* erelas
;
1000 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
1001 rel_size
, _("32-bit relocation data"));
1005 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
1007 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
1008 sizeof (Elf_Internal_Rela
));
1013 error (_("out of memory parsing relocs\n"));
1017 for (i
= 0; i
< nrelas
; i
++)
1019 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
1020 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
1021 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
1028 Elf64_External_Rela
* erelas
;
1030 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
1031 rel_size
, _("64-bit relocation data"));
1035 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
1037 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
1038 sizeof (Elf_Internal_Rela
));
1043 error (_("out of memory parsing relocs\n"));
1047 for (i
= 0; i
< nrelas
; i
++)
1049 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
1050 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
1051 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
1053 /* The #ifdef BFD64 below is to prevent a compile time
1054 warning. We know that if we do not have a 64 bit data
1055 type that we will never execute this code anyway. */
1057 if (filedata
->file_header
.e_machine
== EM_MIPS
1058 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1060 /* In little-endian objects, r_info isn't really a
1061 64-bit little-endian value: it has a 32-bit
1062 little-endian symbol index followed by four
1063 individual byte fields. Reorder INFO
1065 bfd_vma inf
= relas
[i
].r_info
;
1066 inf
= (((inf
& 0xffffffff) << 32)
1067 | ((inf
>> 56) & 0xff)
1068 | ((inf
>> 40) & 0xff00)
1069 | ((inf
>> 24) & 0xff0000)
1070 | ((inf
>> 8) & 0xff000000));
1071 relas
[i
].r_info
= inf
;
1084 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1085 Returns TRUE upon success, FALSE otherwise. If successful then a
1086 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1087 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1088 responsibility to free the allocated buffer. */
1091 slurp_rel_relocs (Filedata
* filedata
,
1092 unsigned long rel_offset
,
1093 unsigned long rel_size
,
1094 Elf_Internal_Rela
** relsp
,
1095 unsigned long * nrelsp
)
1097 Elf_Internal_Rela
* rels
;
1103 Elf32_External_Rel
* erels
;
1105 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1106 rel_size
, _("32-bit relocation data"));
1110 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1112 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1117 error (_("out of memory parsing relocs\n"));
1121 for (i
= 0; i
< nrels
; i
++)
1123 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1124 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1125 rels
[i
].r_addend
= 0;
1132 Elf64_External_Rel
* erels
;
1134 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1135 rel_size
, _("64-bit relocation data"));
1139 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1141 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1146 error (_("out of memory parsing relocs\n"));
1150 for (i
= 0; i
< nrels
; i
++)
1152 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1153 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1154 rels
[i
].r_addend
= 0;
1156 /* The #ifdef BFD64 below is to prevent a compile time
1157 warning. We know that if we do not have a 64 bit data
1158 type that we will never execute this code anyway. */
1160 if (filedata
->file_header
.e_machine
== EM_MIPS
1161 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1163 /* In little-endian objects, r_info isn't really a
1164 64-bit little-endian value: it has a 32-bit
1165 little-endian symbol index followed by four
1166 individual byte fields. Reorder INFO
1168 bfd_vma inf
= rels
[i
].r_info
;
1169 inf
= (((inf
& 0xffffffff) << 32)
1170 | ((inf
>> 56) & 0xff)
1171 | ((inf
>> 40) & 0xff00)
1172 | ((inf
>> 24) & 0xff0000)
1173 | ((inf
>> 8) & 0xff000000));
1174 rels
[i
].r_info
= inf
;
1187 /* Returns the reloc type extracted from the reloc info field. */
1190 get_reloc_type (Filedata
* filedata
, bfd_vma reloc_info
)
1193 return ELF32_R_TYPE (reloc_info
);
1195 switch (filedata
->file_header
.e_machine
)
1198 /* Note: We assume that reloc_info has already been adjusted for us. */
1199 return ELF64_MIPS_R_TYPE (reloc_info
);
1202 return ELF64_R_TYPE_ID (reloc_info
);
1205 return ELF64_R_TYPE (reloc_info
);
1209 /* Return the symbol index extracted from the reloc info field. */
1212 get_reloc_symindex (bfd_vma reloc_info
)
1214 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1218 uses_msp430x_relocs (Filedata
* filedata
)
1221 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1222 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1223 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1224 /* TI compiler uses ELFOSABI_NONE. */
1225 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1228 /* Display the contents of the relocation data found at the specified
1232 dump_relocations (Filedata
* filedata
,
1233 unsigned long rel_offset
,
1234 unsigned long rel_size
,
1235 Elf_Internal_Sym
* symtab
,
1236 unsigned long nsyms
,
1238 unsigned long strtablen
,
1243 Elf_Internal_Rela
* rels
;
1246 if (is_rela
== UNKNOWN
)
1247 is_rela
= guess_is_rela (filedata
->file_header
.e_machine
);
1251 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1256 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1265 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1267 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1272 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1274 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1282 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1284 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1289 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1291 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1295 for (i
= 0; i
< rel_size
; i
++)
1300 bfd_vma symtab_index
;
1303 offset
= rels
[i
].r_offset
;
1304 inf
= rels
[i
].r_info
;
1306 type
= get_reloc_type (filedata
, inf
);
1307 symtab_index
= get_reloc_symindex (inf
);
1311 printf ("%8.8lx %8.8lx ",
1312 (unsigned long) offset
& 0xffffffff,
1313 (unsigned long) inf
& 0xffffffff);
1318 ? "%16.16" BFD_VMA_FMT
"x %16.16" BFD_VMA_FMT
"x "
1319 : "%12.12" BFD_VMA_FMT
"x %12.12" BFD_VMA_FMT
"x ",
1323 switch (filedata
->file_header
.e_machine
)
1330 rtype
= elf_aarch64_reloc_type (type
);
1334 case EM_CYGNUS_M32R
:
1335 rtype
= elf_m32r_reloc_type (type
);
1340 rtype
= elf_i386_reloc_type (type
);
1345 rtype
= elf_m68hc11_reloc_type (type
);
1349 rtype
= elf_s12z_reloc_type (type
);
1353 rtype
= elf_m68k_reloc_type (type
);
1357 rtype
= elf_i960_reloc_type (type
);
1362 rtype
= elf_avr_reloc_type (type
);
1365 case EM_OLD_SPARCV9
:
1366 case EM_SPARC32PLUS
:
1369 rtype
= elf_sparc_reloc_type (type
);
1373 rtype
= elf_spu_reloc_type (type
);
1377 rtype
= v800_reloc_type (type
);
1380 case EM_CYGNUS_V850
:
1381 rtype
= v850_reloc_type (type
);
1385 case EM_CYGNUS_D10V
:
1386 rtype
= elf_d10v_reloc_type (type
);
1390 case EM_CYGNUS_D30V
:
1391 rtype
= elf_d30v_reloc_type (type
);
1395 rtype
= elf_dlx_reloc_type (type
);
1399 rtype
= elf_sh_reloc_type (type
);
1403 case EM_CYGNUS_MN10300
:
1404 rtype
= elf_mn10300_reloc_type (type
);
1408 case EM_CYGNUS_MN10200
:
1409 rtype
= elf_mn10200_reloc_type (type
);
1413 case EM_CYGNUS_FR30
:
1414 rtype
= elf_fr30_reloc_type (type
);
1418 rtype
= elf_frv_reloc_type (type
);
1422 rtype
= elf_csky_reloc_type (type
);
1426 rtype
= elf_ft32_reloc_type (type
);
1430 rtype
= elf_mcore_reloc_type (type
);
1434 rtype
= elf_mmix_reloc_type (type
);
1438 rtype
= elf_moxie_reloc_type (type
);
1442 if (uses_msp430x_relocs (filedata
))
1444 rtype
= elf_msp430x_reloc_type (type
);
1449 rtype
= elf_msp430_reloc_type (type
);
1453 rtype
= elf_nds32_reloc_type (type
);
1457 rtype
= elf_ppc_reloc_type (type
);
1461 rtype
= elf_ppc64_reloc_type (type
);
1465 case EM_MIPS_RS3_LE
:
1466 rtype
= elf_mips_reloc_type (type
);
1470 rtype
= elf_riscv_reloc_type (type
);
1474 rtype
= elf_alpha_reloc_type (type
);
1478 rtype
= elf_arm_reloc_type (type
);
1482 case EM_ARC_COMPACT
:
1483 case EM_ARC_COMPACT2
:
1484 rtype
= elf_arc_reloc_type (type
);
1488 rtype
= elf_hppa_reloc_type (type
);
1494 rtype
= elf_h8_reloc_type (type
);
1498 rtype
= elf_or1k_reloc_type (type
);
1503 rtype
= elf_pj_reloc_type (type
);
1506 rtype
= elf_ia64_reloc_type (type
);
1510 rtype
= elf_cris_reloc_type (type
);
1514 rtype
= elf_i860_reloc_type (type
);
1520 rtype
= elf_x86_64_reloc_type (type
);
1524 rtype
= i370_reloc_type (type
);
1529 rtype
= elf_s390_reloc_type (type
);
1533 rtype
= elf_score_reloc_type (type
);
1537 rtype
= elf_xstormy16_reloc_type (type
);
1541 rtype
= elf_crx_reloc_type (type
);
1545 rtype
= elf_vax_reloc_type (type
);
1549 rtype
= elf_visium_reloc_type (type
);
1553 rtype
= elf_bpf_reloc_type (type
);
1556 case EM_ADAPTEVA_EPIPHANY
:
1557 rtype
= elf_epiphany_reloc_type (type
);
1562 rtype
= elf_ip2k_reloc_type (type
);
1566 rtype
= elf_iq2000_reloc_type (type
);
1571 rtype
= elf_xtensa_reloc_type (type
);
1574 case EM_LATTICEMICO32
:
1575 rtype
= elf_lm32_reloc_type (type
);
1580 rtype
= elf_m32c_reloc_type (type
);
1584 rtype
= elf_mt_reloc_type (type
);
1588 rtype
= elf_bfin_reloc_type (type
);
1592 rtype
= elf_mep_reloc_type (type
);
1596 rtype
= elf_cr16_reloc_type (type
);
1600 case EM_MICROBLAZE_OLD
:
1601 rtype
= elf_microblaze_reloc_type (type
);
1605 rtype
= elf_rl78_reloc_type (type
);
1609 rtype
= elf_rx_reloc_type (type
);
1613 rtype
= elf_metag_reloc_type (type
);
1618 rtype
= elf_xc16x_reloc_type (type
);
1622 rtype
= elf_tic6x_reloc_type (type
);
1626 rtype
= elf_tilegx_reloc_type (type
);
1630 rtype
= elf_tilepro_reloc_type (type
);
1633 case EM_WEBASSEMBLY
:
1634 rtype
= elf_wasm32_reloc_type (type
);
1638 rtype
= elf_xgate_reloc_type (type
);
1641 case EM_ALTERA_NIOS2
:
1642 rtype
= elf_nios2_reloc_type (type
);
1646 rtype
= elf_pru_reloc_type (type
);
1650 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
1651 rtype
= elf_nfp3200_reloc_type (type
);
1653 rtype
= elf_nfp_reloc_type (type
);
1657 rtype
= elf_z80_reloc_type (type
);
1662 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1664 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1666 if (filedata
->file_header
.e_machine
== EM_ALPHA
1668 && streq (rtype
, "R_ALPHA_LITUSE")
1671 switch (rels
[i
].r_addend
)
1673 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1674 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1675 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1676 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1677 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1678 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1679 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1680 default: rtype
= NULL
;
1684 printf (" (%s)", rtype
);
1688 printf (_("<unknown addend: %lx>"),
1689 (unsigned long) rels
[i
].r_addend
);
1693 else if (symtab_index
)
1695 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1697 error (_(" bad symbol index: %08lx in reloc\n"),
1698 (unsigned long) symtab_index
);
1703 Elf_Internal_Sym
* psym
;
1704 const char * version_string
;
1705 enum versioned_symbol_info sym_info
;
1706 unsigned short vna_other
;
1708 psym
= symtab
+ symtab_index
;
1711 = get_symbol_version_string (filedata
, is_dynsym
,
1720 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1724 unsigned int width
= is_32bit_elf
? 8 : 14;
1726 /* Relocations against GNU_IFUNC symbols do not use the value
1727 of the symbol as the address to relocate against. Instead
1728 they invoke the function named by the symbol and use its
1729 result as the address for relocation.
1731 To indicate this to the user, do not display the value of
1732 the symbol in the "Symbols's Value" field. Instead show
1733 its name followed by () as a hint that the symbol is
1737 || psym
->st_name
== 0
1738 || psym
->st_name
>= strtablen
)
1741 name
= strtab
+ psym
->st_name
;
1743 len
= print_symbol (width
, name
);
1745 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1747 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1751 print_vma (psym
->st_value
, LONG_HEX
);
1753 printf (is_32bit_elf
? " " : " ");
1756 if (psym
->st_name
== 0)
1758 const char * sec_name
= "<null>";
1761 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1763 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
)
1764 sec_name
= SECTION_NAME_PRINT (filedata
->section_headers
1766 else if (psym
->st_shndx
== SHN_ABS
)
1768 else if (psym
->st_shndx
== SHN_COMMON
)
1769 sec_name
= "COMMON";
1770 else if ((filedata
->file_header
.e_machine
== EM_MIPS
1771 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1772 || (filedata
->file_header
.e_machine
== EM_TI_C6000
1773 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1774 sec_name
= "SCOMMON";
1775 else if (filedata
->file_header
.e_machine
== EM_MIPS
1776 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1777 sec_name
= "SUNDEF";
1778 else if ((filedata
->file_header
.e_machine
== EM_X86_64
1779 || filedata
->file_header
.e_machine
== EM_L1OM
1780 || filedata
->file_header
.e_machine
== EM_K1OM
)
1781 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1782 sec_name
= "LARGE_COMMON";
1783 else if (filedata
->file_header
.e_machine
== EM_IA_64
1784 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1785 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1786 sec_name
= "ANSI_COM";
1787 else if (is_ia64_vms (filedata
)
1788 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1789 sec_name
= "VMS_SYMVEC";
1792 sprintf (name_buf
, "<section 0x%x>",
1793 (unsigned int) psym
->st_shndx
);
1794 sec_name
= name_buf
;
1797 print_symbol (22, sec_name
);
1799 else if (strtab
== NULL
)
1800 printf (_("<string table index: %3ld>"), psym
->st_name
);
1801 else if (psym
->st_name
>= strtablen
)
1803 error (_("<corrupt string table index: %3ld>\n"),
1809 print_symbol (22, strtab
+ psym
->st_name
);
1811 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1817 bfd_vma off
= rels
[i
].r_addend
;
1819 if ((bfd_signed_vma
) off
< 0)
1820 printf (" - %" BFD_VMA_FMT
"x", - off
);
1822 printf (" + %" BFD_VMA_FMT
"x", off
);
1828 bfd_vma off
= rels
[i
].r_addend
;
1830 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1831 if ((bfd_signed_vma
) off
< 0)
1832 printf ("-%" BFD_VMA_FMT
"x", - off
);
1834 printf ("%" BFD_VMA_FMT
"x", off
);
1837 if (filedata
->file_header
.e_machine
== EM_SPARCV9
1839 && streq (rtype
, "R_SPARC_OLO10"))
1840 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1845 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
1847 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1848 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1849 const char * rtype2
= elf_mips_reloc_type (type2
);
1850 const char * rtype3
= elf_mips_reloc_type (type3
);
1852 printf (" Type2: ");
1855 printf (_("unrecognized: %-7lx"),
1856 (unsigned long) type2
& 0xffffffff);
1858 printf ("%-17.17s", rtype2
);
1860 printf ("\n Type3: ");
1863 printf (_("unrecognized: %-7lx"),
1864 (unsigned long) type3
& 0xffffffff);
1866 printf ("%-17.17s", rtype3
);
1879 get_aarch64_dynamic_type (unsigned long type
)
1883 case DT_AARCH64_BTI_PLT
: return "AARCH64_BTI_PLT";
1884 case DT_AARCH64_PAC_PLT
: return "AARCH64_PAC_PLT";
1885 case DT_AARCH64_VARIANT_PCS
: return "AARCH64_VARIANT_PCS";
1892 get_mips_dynamic_type (unsigned long type
)
1896 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1897 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1898 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1899 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1900 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1901 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1902 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1903 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1904 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1905 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1906 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1907 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1908 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1909 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1910 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1911 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1912 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1913 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1914 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1915 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1916 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1917 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1918 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1919 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1920 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1921 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1922 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1923 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1924 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1925 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1926 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1927 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1928 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1929 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1930 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1931 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1932 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1933 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1934 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1935 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1936 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1937 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1938 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1939 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1940 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1941 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1942 case DT_MIPS_XHASH
: return "MIPS_XHASH";
1949 get_sparc64_dynamic_type (unsigned long type
)
1953 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1960 get_ppc_dynamic_type (unsigned long type
)
1964 case DT_PPC_GOT
: return "PPC_GOT";
1965 case DT_PPC_OPT
: return "PPC_OPT";
1972 get_ppc64_dynamic_type (unsigned long type
)
1976 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1977 case DT_PPC64_OPD
: return "PPC64_OPD";
1978 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1979 case DT_PPC64_OPT
: return "PPC64_OPT";
1986 get_parisc_dynamic_type (unsigned long type
)
1990 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1991 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1992 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1993 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1994 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1995 case DT_HP_PREINIT
: return "HP_PREINIT";
1996 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1997 case DT_HP_NEEDED
: return "HP_NEEDED";
1998 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1999 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
2000 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
2001 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
2002 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
2003 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
2004 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
2005 case DT_HP_FILTERED
: return "HP_FILTERED";
2006 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
2007 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
2008 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
2009 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
2010 case DT_PLT
: return "PLT";
2011 case DT_PLT_SIZE
: return "PLT_SIZE";
2012 case DT_DLT
: return "DLT";
2013 case DT_DLT_SIZE
: return "DLT_SIZE";
2020 get_ia64_dynamic_type (unsigned long type
)
2024 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
2025 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
2026 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
2027 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
2028 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
2029 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
2030 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
2031 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
2032 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
2033 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
2034 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
2035 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
2036 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
2037 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
2038 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
2039 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
2040 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
2041 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
2042 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
2043 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
2044 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
2045 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
2046 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
2047 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
2048 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
2049 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
2050 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
2051 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
2052 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
2053 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
2054 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
2061 get_solaris_section_type (unsigned long type
)
2065 case 0x6fffffee: return "SUNW_ancillary";
2066 case 0x6fffffef: return "SUNW_capchain";
2067 case 0x6ffffff0: return "SUNW_capinfo";
2068 case 0x6ffffff1: return "SUNW_symsort";
2069 case 0x6ffffff2: return "SUNW_tlssort";
2070 case 0x6ffffff3: return "SUNW_LDYNSYM";
2071 case 0x6ffffff4: return "SUNW_dof";
2072 case 0x6ffffff5: return "SUNW_cap";
2073 case 0x6ffffff6: return "SUNW_SIGNATURE";
2074 case 0x6ffffff7: return "SUNW_ANNOTATE";
2075 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2076 case 0x6ffffff9: return "SUNW_DEBUG";
2077 case 0x6ffffffa: return "SUNW_move";
2078 case 0x6ffffffb: return "SUNW_COMDAT";
2079 case 0x6ffffffc: return "SUNW_syminfo";
2080 case 0x6ffffffd: return "SUNW_verdef";
2081 case 0x6ffffffe: return "SUNW_verneed";
2082 case 0x6fffffff: return "SUNW_versym";
2083 case 0x70000000: return "SPARC_GOTDATA";
2084 default: return NULL
;
2089 get_alpha_dynamic_type (unsigned long type
)
2093 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2094 default: return NULL
;
2099 get_score_dynamic_type (unsigned long type
)
2103 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2104 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2105 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2106 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2107 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2108 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2109 default: return NULL
;
2114 get_tic6x_dynamic_type (unsigned long type
)
2118 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2119 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2120 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2121 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2122 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2123 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2124 default: return NULL
;
2129 get_nios2_dynamic_type (unsigned long type
)
2133 case DT_NIOS2_GP
: return "NIOS2_GP";
2134 default: return NULL
;
2139 get_solaris_dynamic_type (unsigned long type
)
2143 case 0x6000000d: return "SUNW_AUXILIARY";
2144 case 0x6000000e: return "SUNW_RTLDINF";
2145 case 0x6000000f: return "SUNW_FILTER";
2146 case 0x60000010: return "SUNW_CAP";
2147 case 0x60000011: return "SUNW_SYMTAB";
2148 case 0x60000012: return "SUNW_SYMSZ";
2149 case 0x60000013: return "SUNW_SORTENT";
2150 case 0x60000014: return "SUNW_SYMSORT";
2151 case 0x60000015: return "SUNW_SYMSORTSZ";
2152 case 0x60000016: return "SUNW_TLSSORT";
2153 case 0x60000017: return "SUNW_TLSSORTSZ";
2154 case 0x60000018: return "SUNW_CAPINFO";
2155 case 0x60000019: return "SUNW_STRPAD";
2156 case 0x6000001a: return "SUNW_CAPCHAIN";
2157 case 0x6000001b: return "SUNW_LDMACH";
2158 case 0x6000001d: return "SUNW_CAPCHAINENT";
2159 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2160 case 0x60000021: return "SUNW_PARENT";
2161 case 0x60000023: return "SUNW_ASLR";
2162 case 0x60000025: return "SUNW_RELAX";
2163 case 0x60000029: return "SUNW_NXHEAP";
2164 case 0x6000002b: return "SUNW_NXSTACK";
2166 case 0x70000001: return "SPARC_REGISTER";
2167 case 0x7ffffffd: return "AUXILIARY";
2168 case 0x7ffffffe: return "USED";
2169 case 0x7fffffff: return "FILTER";
2171 default: return NULL
;
2176 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2178 static char buff
[64];
2182 case DT_NULL
: return "NULL";
2183 case DT_NEEDED
: return "NEEDED";
2184 case DT_PLTRELSZ
: return "PLTRELSZ";
2185 case DT_PLTGOT
: return "PLTGOT";
2186 case DT_HASH
: return "HASH";
2187 case DT_STRTAB
: return "STRTAB";
2188 case DT_SYMTAB
: return "SYMTAB";
2189 case DT_RELA
: return "RELA";
2190 case DT_RELASZ
: return "RELASZ";
2191 case DT_RELAENT
: return "RELAENT";
2192 case DT_STRSZ
: return "STRSZ";
2193 case DT_SYMENT
: return "SYMENT";
2194 case DT_INIT
: return "INIT";
2195 case DT_FINI
: return "FINI";
2196 case DT_SONAME
: return "SONAME";
2197 case DT_RPATH
: return "RPATH";
2198 case DT_SYMBOLIC
: return "SYMBOLIC";
2199 case DT_REL
: return "REL";
2200 case DT_RELSZ
: return "RELSZ";
2201 case DT_RELENT
: return "RELENT";
2202 case DT_PLTREL
: return "PLTREL";
2203 case DT_DEBUG
: return "DEBUG";
2204 case DT_TEXTREL
: return "TEXTREL";
2205 case DT_JMPREL
: return "JMPREL";
2206 case DT_BIND_NOW
: return "BIND_NOW";
2207 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2208 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2209 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2210 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2211 case DT_RUNPATH
: return "RUNPATH";
2212 case DT_FLAGS
: return "FLAGS";
2214 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2215 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2216 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2218 case DT_CHECKSUM
: return "CHECKSUM";
2219 case DT_PLTPADSZ
: return "PLTPADSZ";
2220 case DT_MOVEENT
: return "MOVEENT";
2221 case DT_MOVESZ
: return "MOVESZ";
2222 case DT_FEATURE
: return "FEATURE";
2223 case DT_POSFLAG_1
: return "POSFLAG_1";
2224 case DT_SYMINSZ
: return "SYMINSZ";
2225 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2227 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2228 case DT_CONFIG
: return "CONFIG";
2229 case DT_DEPAUDIT
: return "DEPAUDIT";
2230 case DT_AUDIT
: return "AUDIT";
2231 case DT_PLTPAD
: return "PLTPAD";
2232 case DT_MOVETAB
: return "MOVETAB";
2233 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2235 case DT_VERSYM
: return "VERSYM";
2237 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2238 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2239 case DT_RELACOUNT
: return "RELACOUNT";
2240 case DT_RELCOUNT
: return "RELCOUNT";
2241 case DT_FLAGS_1
: return "FLAGS_1";
2242 case DT_VERDEF
: return "VERDEF";
2243 case DT_VERDEFNUM
: return "VERDEFNUM";
2244 case DT_VERNEED
: return "VERNEED";
2245 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2247 case DT_AUXILIARY
: return "AUXILIARY";
2248 case DT_USED
: return "USED";
2249 case DT_FILTER
: return "FILTER";
2251 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2252 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2253 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2254 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2255 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2256 case DT_GNU_HASH
: return "GNU_HASH";
2257 case DT_GNU_FLAGS_1
: return "GNU_FLAGS_1";
2260 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2262 const char * result
;
2264 switch (filedata
->file_header
.e_machine
)
2267 result
= get_aarch64_dynamic_type (type
);
2270 case EM_MIPS_RS3_LE
:
2271 result
= get_mips_dynamic_type (type
);
2274 result
= get_sparc64_dynamic_type (type
);
2277 result
= get_ppc_dynamic_type (type
);
2280 result
= get_ppc64_dynamic_type (type
);
2283 result
= get_ia64_dynamic_type (type
);
2286 result
= get_alpha_dynamic_type (type
);
2289 result
= get_score_dynamic_type (type
);
2292 result
= get_tic6x_dynamic_type (type
);
2294 case EM_ALTERA_NIOS2
:
2295 result
= get_nios2_dynamic_type (type
);
2298 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2299 result
= get_solaris_dynamic_type (type
);
2308 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2310 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2311 || (filedata
->file_header
.e_machine
== EM_PARISC
2312 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2314 const char * result
;
2316 switch (filedata
->file_header
.e_machine
)
2319 result
= get_parisc_dynamic_type (type
);
2322 result
= get_ia64_dynamic_type (type
);
2325 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2326 result
= get_solaris_dynamic_type (type
);
2335 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2339 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2346 get_file_type (unsigned e_type
)
2348 static char buff
[64];
2352 case ET_NONE
: return _("NONE (None)");
2353 case ET_REL
: return _("REL (Relocatable file)");
2354 case ET_EXEC
: return _("EXEC (Executable file)");
2355 case ET_DYN
: return _("DYN (Shared object file)");
2356 case ET_CORE
: return _("CORE (Core file)");
2359 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2360 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2361 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2362 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2364 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2370 get_machine_name (unsigned e_machine
)
2372 static char buff
[64]; /* XXX */
2376 /* Please keep this switch table sorted by increasing EM_ value. */
2378 case EM_NONE
: return _("None");
2379 case EM_M32
: return "WE32100";
2380 case EM_SPARC
: return "Sparc";
2381 case EM_386
: return "Intel 80386";
2382 case EM_68K
: return "MC68000";
2383 case EM_88K
: return "MC88000";
2384 case EM_IAMCU
: return "Intel MCU";
2385 case EM_860
: return "Intel 80860";
2386 case EM_MIPS
: return "MIPS R3000";
2387 case EM_S370
: return "IBM System/370";
2389 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2390 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2391 case EM_PARISC
: return "HPPA";
2392 case EM_VPP550
: return "Fujitsu VPP500";
2393 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2394 case EM_960
: return "Intel 80960";
2395 case EM_PPC
: return "PowerPC";
2397 case EM_PPC64
: return "PowerPC64";
2399 case EM_S390
: return "IBM S/390";
2400 case EM_SPU
: return "SPU";
2402 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2403 case EM_FR20
: return "Fujitsu FR20";
2404 case EM_RH32
: return "TRW RH32";
2405 case EM_MCORE
: return "MCORE";
2407 case EM_ARM
: return "ARM";
2408 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2409 case EM_SH
: return "Renesas / SuperH SH";
2410 case EM_SPARCV9
: return "Sparc v9";
2411 case EM_TRICORE
: return "Siemens Tricore";
2412 case EM_ARC
: return "ARC";
2413 case EM_H8_300
: return "Renesas H8/300";
2414 case EM_H8_300H
: return "Renesas H8/300H";
2415 case EM_H8S
: return "Renesas H8S";
2416 case EM_H8_500
: return "Renesas H8/500";
2418 case EM_IA_64
: return "Intel IA-64";
2419 case EM_MIPS_X
: return "Stanford MIPS-X";
2420 case EM_COLDFIRE
: return "Motorola Coldfire";
2421 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2422 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2423 case EM_PCP
: return "Siemens PCP";
2424 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2425 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2426 case EM_STARCORE
: return "Motorola Star*Core processor";
2427 case EM_ME16
: return "Toyota ME16 processor";
2429 case EM_ST100
: return "STMicroelectronics ST100 processor";
2430 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2431 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2432 case EM_PDSP
: return "Sony DSP processor";
2433 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2434 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2435 case EM_FX66
: return "Siemens FX66 microcontroller";
2436 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2437 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2438 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2440 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2441 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2442 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2443 case EM_SVX
: return "Silicon Graphics SVx";
2444 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2445 case EM_VAX
: return "Digital VAX";
2446 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2447 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2448 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2449 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2451 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2452 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2453 case EM_PRISM
: return "Vitesse Prism";
2455 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2456 case EM_CYGNUS_FR30
:
2457 case EM_FR30
: return "Fujitsu FR30";
2458 case EM_CYGNUS_D10V
:
2459 case EM_D10V
: return "d10v";
2460 case EM_CYGNUS_D30V
:
2461 case EM_D30V
: return "d30v";
2462 case EM_CYGNUS_V850
:
2463 case EM_V850
: return "Renesas V850";
2464 case EM_CYGNUS_M32R
:
2465 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2466 case EM_CYGNUS_MN10300
:
2467 case EM_MN10300
: return "mn10300";
2469 case EM_CYGNUS_MN10200
:
2470 case EM_MN10200
: return "mn10200";
2471 case EM_PJ
: return "picoJava";
2472 case EM_OR1K
: return "OpenRISC 1000";
2473 case EM_ARC_COMPACT
: return "ARCompact";
2475 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2476 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2477 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2478 case EM_NS32K
: return "National Semiconductor 32000 series";
2479 case EM_TPC
: return "Tenor Network TPC processor";
2480 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2482 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2484 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2485 case EM_MAX
: return "MAX Processor";
2486 case EM_CR
: return "National Semiconductor CompactRISC";
2487 case EM_F2MC16
: return "Fujitsu F2MC16";
2488 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2489 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2490 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2491 case EM_SEP
: return "Sharp embedded microprocessor";
2492 case EM_ARCA
: return "Arca RISC microprocessor";
2494 case EM_UNICORE
: return "Unicore";
2495 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2496 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2497 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2498 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2499 case EM_XGATE
: return "Motorola XGATE embedded processor";
2501 case EM_XC16X
: return "Infineon Technologies xc16x";
2502 case EM_M16C
: return "Renesas M16C series microprocessors";
2503 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2504 case EM_CE
: return "Freescale Communication Engine RISC core";
2506 case EM_M32C
: return "Renesas M32c";
2508 case EM_TSK3000
: return "Altium TSK3000 core";
2509 case EM_RS08
: return "Freescale RS08 embedded processor";
2510 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2511 case EM_SCORE
: return "SUNPLUS S+Core";
2512 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2513 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2514 case EM_LATTICEMICO32
: return "Lattice Mico32";
2515 case EM_SE_C17
: return "Seiko Epson C17 family";
2517 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2518 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2519 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2520 case EM_TI_PRU
: return "TI PRU I/O processor";
2522 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2523 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2524 case EM_R32C
: return "Renesas R32C series microprocessors";
2525 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2526 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2527 case EM_8051
: return "Intel 8051 and variants";
2528 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2529 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2530 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2531 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2533 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2534 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2535 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2536 case EM_RX
: return "Renesas RX";
2537 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2538 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2539 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2542 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2543 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2544 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2546 case EM_L1OM
: return "Intel L1OM";
2547 case EM_K1OM
: return "Intel K1OM";
2548 case EM_INTEL182
: return "Intel (reserved)";
2549 case EM_AARCH64
: return "AArch64";
2550 case EM_ARM184
: return "ARM (reserved)";
2551 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2552 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2553 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2554 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2556 case EM_CUDA
: return "NVIDIA CUDA architecture";
2557 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2558 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2559 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2560 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2561 case EM_ARC_COMPACT2
: return "ARCv2";
2562 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2563 case EM_RL78
: return "Renesas RL78";
2564 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2565 case EM_78K0R
: return "Renesas 78K0R";
2567 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2568 case EM_BA1
: return "Beyond BA1 CPU architecture";
2569 case EM_BA2
: return "Beyond BA2 CPU architecture";
2570 case EM_XCORE
: return "XMOS xCORE processor family";
2571 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2572 case EM_INTELGT
: return "Intel Graphics Technology";
2574 case EM_KM32
: return "KM211 KM32 32-bit processor";
2575 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2576 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2577 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2578 case EM_KVARC
: return "KM211 KVARC processor";
2579 case EM_CDP
: return "Paneve CDP architecture family";
2580 case EM_COGE
: return "Cognitive Smart Memory Processor";
2581 case EM_COOL
: return "Bluechip Systems CoolEngine";
2582 case EM_NORC
: return "Nanoradio Optimized RISC";
2583 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2585 case EM_Z80
: return "Zilog Z80";
2586 case EM_VISIUM
: return "CDS VISIUMcore processor";
2587 case EM_FT32
: return "FTDI Chip FT32";
2588 case EM_MOXIE
: return "Moxie";
2589 case EM_AMDGPU
: return "AMD GPU";
2590 /* 230 (all reserved) */
2592 case EM_RISCV
: return "RISC-V";
2593 case EM_LANAI
: return "Lanai 32-bit processor";
2594 case EM_CEVA
: return "CEVA Processor Architecture Family";
2595 case EM_CEVA_X2
: return "CEVA X2 Processor Family";
2596 case EM_BPF
: return "Linux BPF";
2597 case EM_GRAPHCORE_IPU
: return "Graphcore Intelligent Processing Unit";
2598 case EM_IMG1
: return "Imagination Technologies";
2600 case EM_NFP
: return "Netronome Flow Processor";
2601 case EM_VE
: return "NEC Vector Engine";
2602 case EM_CSKY
: return "C-SKY";
2603 case EM_ARC_COMPACT3_64
: return "Synopsys ARCv2.3 64-bit";
2604 case EM_MCS6502
: return "MOS Technology MCS 6502 processor";
2605 case EM_ARC_COMPACT3
: return "Synopsys ARCv2.3 32-bit";
2606 case EM_KVX
: return "Kalray VLIW core of the MPPA processor family";
2607 case EM_65816
: return "WDC 65816/65C816";
2608 case EM_LOONGARCH
: return "LoongArch";
2609 case EM_KF32
: return "ChipON KungFu32";
2611 /* Large numbers... */
2612 case EM_MT
: return "Morpho Techologies MT processor";
2613 case EM_ALPHA
: return "Alpha";
2614 case EM_WEBASSEMBLY
: return "Web Assembly";
2615 case EM_DLX
: return "OpenDLX";
2616 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2617 case EM_IQ2000
: return "Vitesse IQ2000";
2619 case EM_NIOS32
: return "Altera Nios";
2620 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2621 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2622 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2623 case EM_S12Z
: return "Freescale S12Z";
2626 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2632 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2634 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2635 other compilers don't specify an architecture type in the e_flags, and
2636 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2637 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2640 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2641 but also sets a specific architecture type in the e_flags field.
2643 However, when decoding the flags we don't worry if we see an
2644 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2645 ARCEM architecture type. */
2647 switch (e_flags
& EF_ARC_MACH_MSK
)
2649 /* We only expect these to occur for EM_ARC_COMPACT2. */
2650 case EF_ARC_CPU_ARCV2EM
:
2651 strcat (buf
, ", ARC EM");
2653 case EF_ARC_CPU_ARCV2HS
:
2654 strcat (buf
, ", ARC HS");
2657 /* We only expect these to occur for EM_ARC_COMPACT. */
2658 case E_ARC_MACH_ARC600
:
2659 strcat (buf
, ", ARC600");
2661 case E_ARC_MACH_ARC601
:
2662 strcat (buf
, ", ARC601");
2664 case E_ARC_MACH_ARC700
:
2665 strcat (buf
, ", ARC700");
2668 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2669 new ELF with new architecture being read by an old version of
2670 readelf, or (c) An ELF built with non-GNU compiler that does not
2671 set the architecture in the e_flags. */
2673 if (e_machine
== EM_ARC_COMPACT
)
2674 strcat (buf
, ", Unknown ARCompact");
2676 strcat (buf
, ", Unknown ARC");
2680 switch (e_flags
& EF_ARC_OSABI_MSK
)
2682 case E_ARC_OSABI_ORIG
:
2683 strcat (buf
, ", (ABI:legacy)");
2685 case E_ARC_OSABI_V2
:
2686 strcat (buf
, ", (ABI:v2)");
2688 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2689 case E_ARC_OSABI_V3
:
2690 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2692 case E_ARC_OSABI_V4
:
2693 strcat (buf
, ", v4 ABI");
2696 strcat (buf
, ", unrecognised ARC OSABI flag");
2702 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2705 bool unknown
= false;
2707 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2708 e_flags
&= ~ EF_ARM_EABIMASK
;
2710 /* Handle "generic" ARM flags. */
2711 if (e_flags
& EF_ARM_RELEXEC
)
2713 strcat (buf
, ", relocatable executable");
2714 e_flags
&= ~ EF_ARM_RELEXEC
;
2717 if (e_flags
& EF_ARM_PIC
)
2719 strcat (buf
, ", position independent");
2720 e_flags
&= ~ EF_ARM_PIC
;
2723 /* Now handle EABI specific flags. */
2727 strcat (buf
, ", <unrecognized EABI>");
2732 case EF_ARM_EABI_VER1
:
2733 strcat (buf
, ", Version1 EABI");
2738 /* Process flags one bit at a time. */
2739 flag
= e_flags
& - e_flags
;
2744 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2745 strcat (buf
, ", sorted symbol tables");
2755 case EF_ARM_EABI_VER2
:
2756 strcat (buf
, ", Version2 EABI");
2761 /* Process flags one bit at a time. */
2762 flag
= e_flags
& - e_flags
;
2767 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2768 strcat (buf
, ", sorted symbol tables");
2771 case EF_ARM_DYNSYMSUSESEGIDX
:
2772 strcat (buf
, ", dynamic symbols use segment index");
2775 case EF_ARM_MAPSYMSFIRST
:
2776 strcat (buf
, ", mapping symbols precede others");
2786 case EF_ARM_EABI_VER3
:
2787 strcat (buf
, ", Version3 EABI");
2790 case EF_ARM_EABI_VER4
:
2791 strcat (buf
, ", Version4 EABI");
2796 /* Process flags one bit at a time. */
2797 flag
= e_flags
& - e_flags
;
2803 strcat (buf
, ", BE8");
2807 strcat (buf
, ", LE8");
2817 case EF_ARM_EABI_VER5
:
2818 strcat (buf
, ", Version5 EABI");
2823 /* Process flags one bit at a time. */
2824 flag
= e_flags
& - e_flags
;
2830 strcat (buf
, ", BE8");
2834 strcat (buf
, ", LE8");
2837 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2838 strcat (buf
, ", soft-float ABI");
2841 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2842 strcat (buf
, ", hard-float ABI");
2852 case EF_ARM_EABI_UNKNOWN
:
2853 strcat (buf
, ", GNU EABI");
2858 /* Process flags one bit at a time. */
2859 flag
= e_flags
& - e_flags
;
2864 case EF_ARM_INTERWORK
:
2865 strcat (buf
, ", interworking enabled");
2868 case EF_ARM_APCS_26
:
2869 strcat (buf
, ", uses APCS/26");
2872 case EF_ARM_APCS_FLOAT
:
2873 strcat (buf
, ", uses APCS/float");
2877 strcat (buf
, ", position independent");
2881 strcat (buf
, ", 8 bit structure alignment");
2884 case EF_ARM_NEW_ABI
:
2885 strcat (buf
, ", uses new ABI");
2888 case EF_ARM_OLD_ABI
:
2889 strcat (buf
, ", uses old ABI");
2892 case EF_ARM_SOFT_FLOAT
:
2893 strcat (buf
, ", software FP");
2896 case EF_ARM_VFP_FLOAT
:
2897 strcat (buf
, ", VFP");
2900 case EF_ARM_MAVERICK_FLOAT
:
2901 strcat (buf
, ", Maverick FP");
2912 strcat (buf
,_(", <unknown>"));
2916 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2918 --size
; /* Leave space for null terminator. */
2920 switch (e_flags
& EF_AVR_MACH
)
2922 case E_AVR_MACH_AVR1
:
2923 strncat (buf
, ", avr:1", size
);
2925 case E_AVR_MACH_AVR2
:
2926 strncat (buf
, ", avr:2", size
);
2928 case E_AVR_MACH_AVR25
:
2929 strncat (buf
, ", avr:25", size
);
2931 case E_AVR_MACH_AVR3
:
2932 strncat (buf
, ", avr:3", size
);
2934 case E_AVR_MACH_AVR31
:
2935 strncat (buf
, ", avr:31", size
);
2937 case E_AVR_MACH_AVR35
:
2938 strncat (buf
, ", avr:35", size
);
2940 case E_AVR_MACH_AVR4
:
2941 strncat (buf
, ", avr:4", size
);
2943 case E_AVR_MACH_AVR5
:
2944 strncat (buf
, ", avr:5", size
);
2946 case E_AVR_MACH_AVR51
:
2947 strncat (buf
, ", avr:51", size
);
2949 case E_AVR_MACH_AVR6
:
2950 strncat (buf
, ", avr:6", size
);
2952 case E_AVR_MACH_AVRTINY
:
2953 strncat (buf
, ", avr:100", size
);
2955 case E_AVR_MACH_XMEGA1
:
2956 strncat (buf
, ", avr:101", size
);
2958 case E_AVR_MACH_XMEGA2
:
2959 strncat (buf
, ", avr:102", size
);
2961 case E_AVR_MACH_XMEGA3
:
2962 strncat (buf
, ", avr:103", size
);
2964 case E_AVR_MACH_XMEGA4
:
2965 strncat (buf
, ", avr:104", size
);
2967 case E_AVR_MACH_XMEGA5
:
2968 strncat (buf
, ", avr:105", size
);
2970 case E_AVR_MACH_XMEGA6
:
2971 strncat (buf
, ", avr:106", size
);
2973 case E_AVR_MACH_XMEGA7
:
2974 strncat (buf
, ", avr:107", size
);
2977 strncat (buf
, ", avr:<unknown>", size
);
2981 size
-= strlen (buf
);
2982 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2983 strncat (buf
, ", link-relax", size
);
2987 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2993 bool has_fpu
= false;
2996 static const char *ABI_STRINGS
[] =
2998 "ABI v0", /* use r5 as return register; only used in N1213HC */
2999 "ABI v1", /* use r0 as return register */
3000 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
3001 "ABI v2fp", /* for FPU */
3005 static const char *VER_STRINGS
[] =
3007 "Andes ELF V1.3 or older",
3011 static const char *ARCH_STRINGS
[] =
3020 abi
= EF_NDS_ABI
& e_flags
;
3021 arch
= EF_NDS_ARCH
& e_flags
;
3022 config
= EF_NDS_INST
& e_flags
;
3023 version
= EF_NDS32_ELF_VERSION
& e_flags
;
3025 memset (buf
, 0, size
);
3032 case E_NDS_ABI_V2FP
:
3033 case E_NDS_ABI_AABI
:
3034 case E_NDS_ABI_V2FP_PLUS
:
3035 /* In case there are holes in the array. */
3036 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
3040 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
3046 case E_NDS32_ELF_VER_1_2
:
3047 case E_NDS32_ELF_VER_1_3
:
3048 case E_NDS32_ELF_VER_1_4
:
3049 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
3053 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
3057 if (E_NDS_ABI_V0
== abi
)
3059 /* OLD ABI; only used in N1213HC, has performance extension 1. */
3060 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
3061 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3062 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
3068 case E_NDS_ARCH_STAR_V1_0
:
3069 case E_NDS_ARCH_STAR_V2_0
:
3070 case E_NDS_ARCH_STAR_V3_0
:
3071 case E_NDS_ARCH_STAR_V3_M
:
3072 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
3076 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
3077 /* ARCH version determines how the e_flags are interpreted.
3078 If it is unknown, we cannot proceed. */
3082 /* Newer ABI; Now handle architecture specific flags. */
3083 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3085 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3086 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
3088 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
3089 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
3091 if (config
& E_NDS32_HAS_DIV_INST
)
3092 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
3094 if (config
& E_NDS32_HAS_16BIT_INST
)
3095 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3099 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3101 if (version
<= E_NDS32_ELF_VER_1_3
)
3102 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
3104 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
3107 if (config
& E_NDS32_HAS_MAC_DX_INST
)
3108 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
3110 if (config
& E_NDS32_HAS_DIV_DX_INST
)
3111 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
3113 if (config
& E_NDS32_HAS_16BIT_INST
)
3115 if (version
<= E_NDS32_ELF_VER_1_3
)
3116 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3118 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3122 if (config
& E_NDS32_HAS_EXT_INST
)
3123 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3125 if (config
& E_NDS32_HAS_EXT2_INST
)
3126 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3128 if (config
& E_NDS32_HAS_FPU_INST
)
3131 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3134 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3137 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3140 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3143 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3148 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3150 case E_NDS32_FPU_REG_8SP_4DP
:
3151 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3153 case E_NDS32_FPU_REG_16SP_8DP
:
3154 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3156 case E_NDS32_FPU_REG_32SP_16DP
:
3157 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3159 case E_NDS32_FPU_REG_32SP_32DP
:
3160 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3165 if (config
& E_NDS32_HAS_AUDIO_INST
)
3166 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3168 if (config
& E_NDS32_HAS_STRING_INST
)
3169 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3171 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3172 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3174 if (config
& E_NDS32_HAS_VIDEO_INST
)
3176 if (version
<= E_NDS32_ELF_VER_1_3
)
3177 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3179 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3182 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3183 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3185 if (config
& E_NDS32_HAS_L2C_INST
)
3186 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3190 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3192 static char buf
[1024];
3203 case EM_ARC_COMPACT2
:
3204 case EM_ARC_COMPACT
:
3205 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3209 decode_ARM_machine_flags (e_flags
, buf
);
3213 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3217 if (e_flags
& EF_BFIN_PIC
)
3218 strcat (buf
, ", PIC");
3220 if (e_flags
& EF_BFIN_FDPIC
)
3221 strcat (buf
, ", FDPIC");
3223 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3224 strcat (buf
, ", code in L1");
3226 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3227 strcat (buf
, ", data in L1");
3232 switch (e_flags
& EF_FRV_CPU_MASK
)
3234 case EF_FRV_CPU_GENERIC
:
3238 strcat (buf
, ", fr???");
3241 case EF_FRV_CPU_FR300
:
3242 strcat (buf
, ", fr300");
3245 case EF_FRV_CPU_FR400
:
3246 strcat (buf
, ", fr400");
3248 case EF_FRV_CPU_FR405
:
3249 strcat (buf
, ", fr405");
3252 case EF_FRV_CPU_FR450
:
3253 strcat (buf
, ", fr450");
3256 case EF_FRV_CPU_FR500
:
3257 strcat (buf
, ", fr500");
3259 case EF_FRV_CPU_FR550
:
3260 strcat (buf
, ", fr550");
3263 case EF_FRV_CPU_SIMPLE
:
3264 strcat (buf
, ", simple");
3266 case EF_FRV_CPU_TOMCAT
:
3267 strcat (buf
, ", tomcat");
3273 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3274 strcat (buf
, ", m68000");
3275 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3276 strcat (buf
, ", cpu32");
3277 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3278 strcat (buf
, ", fido_a");
3281 char const * isa
= _("unknown");
3282 char const * mac
= _("unknown mac");
3283 char const * additional
= NULL
;
3285 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3287 case EF_M68K_CF_ISA_A_NODIV
:
3289 additional
= ", nodiv";
3291 case EF_M68K_CF_ISA_A
:
3294 case EF_M68K_CF_ISA_A_PLUS
:
3297 case EF_M68K_CF_ISA_B_NOUSP
:
3299 additional
= ", nousp";
3301 case EF_M68K_CF_ISA_B
:
3304 case EF_M68K_CF_ISA_C
:
3307 case EF_M68K_CF_ISA_C_NODIV
:
3309 additional
= ", nodiv";
3312 strcat (buf
, ", cf, isa ");
3315 strcat (buf
, additional
);
3316 if (e_flags
& EF_M68K_CF_FLOAT
)
3317 strcat (buf
, ", float");
3318 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3323 case EF_M68K_CF_MAC
:
3326 case EF_M68K_CF_EMAC
:
3329 case EF_M68K_CF_EMAC_B
:
3342 switch (e_flags
& EF_MEP_CPU_MASK
)
3344 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3345 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3346 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3347 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3348 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3349 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3350 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3353 switch (e_flags
& EF_MEP_COP_MASK
)
3355 case EF_MEP_COP_NONE
: break;
3356 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3357 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3358 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3359 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3360 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3363 if (e_flags
& EF_MEP_LIBRARY
)
3364 strcat (buf
, ", Built for Library");
3366 if (e_flags
& EF_MEP_INDEX_MASK
)
3367 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3368 e_flags
& EF_MEP_INDEX_MASK
);
3370 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3371 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3372 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3376 if (e_flags
& EF_PPC_EMB
)
3377 strcat (buf
, ", emb");
3379 if (e_flags
& EF_PPC_RELOCATABLE
)
3380 strcat (buf
, _(", relocatable"));
3382 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3383 strcat (buf
, _(", relocatable-lib"));
3387 if (e_flags
& EF_PPC64_ABI
)
3389 char abi
[] = ", abiv0";
3391 abi
[6] += e_flags
& EF_PPC64_ABI
;
3397 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3398 strcat (buf
, ", RH850 ABI");
3400 if (e_flags
& EF_V800_850E3
)
3401 strcat (buf
, ", V3 architecture");
3403 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3404 strcat (buf
, ", FPU not used");
3406 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3407 strcat (buf
, ", regmode: COMMON");
3409 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3410 strcat (buf
, ", r4 not used");
3412 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3413 strcat (buf
, ", r30 not used");
3415 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3416 strcat (buf
, ", r5 not used");
3418 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3419 strcat (buf
, ", r2 not used");
3421 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3423 switch (e_flags
& - e_flags
)
3425 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3426 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3427 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3428 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3429 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3430 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3431 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3432 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3433 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3434 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3435 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3436 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3443 case EM_CYGNUS_V850
:
3444 switch (e_flags
& EF_V850_ARCH
)
3446 case E_V850E3V5_ARCH
:
3447 strcat (buf
, ", v850e3v5");
3449 case E_V850E2V3_ARCH
:
3450 strcat (buf
, ", v850e2v3");
3453 strcat (buf
, ", v850e2");
3456 strcat (buf
, ", v850e1");
3459 strcat (buf
, ", v850e");
3462 strcat (buf
, ", v850");
3465 strcat (buf
, _(", unknown v850 architecture variant"));
3471 case EM_CYGNUS_M32R
:
3472 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3473 strcat (buf
, ", m32r");
3477 case EM_MIPS_RS3_LE
:
3478 if (e_flags
& EF_MIPS_NOREORDER
)
3479 strcat (buf
, ", noreorder");
3481 if (e_flags
& EF_MIPS_PIC
)
3482 strcat (buf
, ", pic");
3484 if (e_flags
& EF_MIPS_CPIC
)
3485 strcat (buf
, ", cpic");
3487 if (e_flags
& EF_MIPS_UCODE
)
3488 strcat (buf
, ", ugen_reserved");
3490 if (e_flags
& EF_MIPS_ABI2
)
3491 strcat (buf
, ", abi2");
3493 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3494 strcat (buf
, ", odk first");
3496 if (e_flags
& EF_MIPS_32BITMODE
)
3497 strcat (buf
, ", 32bitmode");
3499 if (e_flags
& EF_MIPS_NAN2008
)
3500 strcat (buf
, ", nan2008");
3502 if (e_flags
& EF_MIPS_FP64
)
3503 strcat (buf
, ", fp64");
3505 switch ((e_flags
& EF_MIPS_MACH
))
3507 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3508 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3509 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3510 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3511 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3512 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3513 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3514 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3515 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3516 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3517 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3518 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3519 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3520 case E_MIPS_MACH_GS464
: strcat (buf
, ", gs464"); break;
3521 case E_MIPS_MACH_GS464E
: strcat (buf
, ", gs464e"); break;
3522 case E_MIPS_MACH_GS264E
: strcat (buf
, ", gs264e"); break;
3523 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3524 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3525 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3526 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3527 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3529 /* We simply ignore the field in this case to avoid confusion:
3530 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3533 default: strcat (buf
, _(", unknown CPU")); break;
3536 switch ((e_flags
& EF_MIPS_ABI
))
3538 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3539 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3540 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3541 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3543 /* We simply ignore the field in this case to avoid confusion:
3544 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3545 This means it is likely to be an o32 file, but not for
3548 default: strcat (buf
, _(", unknown ABI")); break;
3551 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3552 strcat (buf
, ", mdmx");
3554 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3555 strcat (buf
, ", mips16");
3557 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3558 strcat (buf
, ", micromips");
3560 switch ((e_flags
& EF_MIPS_ARCH
))
3562 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3563 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3564 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3565 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3566 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3567 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3568 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3569 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3570 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3571 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3572 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3573 default: strcat (buf
, _(", unknown ISA")); break;
3578 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3582 switch (EF_NFP_MACH (e_flags
))
3584 case E_NFP_MACH_3200
:
3585 strcat (buf
, ", NFP-32xx");
3587 case E_NFP_MACH_6000
:
3588 strcat (buf
, ", NFP-6xxx");
3594 if (e_flags
& EF_RISCV_RVC
)
3595 strcat (buf
, ", RVC");
3597 if (e_flags
& EF_RISCV_RVE
)
3598 strcat (buf
, ", RVE");
3600 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3602 case EF_RISCV_FLOAT_ABI_SOFT
:
3603 strcat (buf
, ", soft-float ABI");
3606 case EF_RISCV_FLOAT_ABI_SINGLE
:
3607 strcat (buf
, ", single-float ABI");
3610 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3611 strcat (buf
, ", double-float ABI");
3614 case EF_RISCV_FLOAT_ABI_QUAD
:
3615 strcat (buf
, ", quad-float ABI");
3621 switch ((e_flags
& EF_SH_MACH_MASK
))
3623 case EF_SH1
: strcat (buf
, ", sh1"); break;
3624 case EF_SH2
: strcat (buf
, ", sh2"); break;
3625 case EF_SH3
: strcat (buf
, ", sh3"); break;
3626 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3627 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3628 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3629 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3630 case EF_SH4
: strcat (buf
, ", sh4"); break;
3631 case EF_SH5
: strcat (buf
, ", sh5"); break;
3632 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3633 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3634 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3635 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3636 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3637 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3638 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3639 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3640 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3641 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3642 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3643 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3644 default: strcat (buf
, _(", unknown ISA")); break;
3647 if (e_flags
& EF_SH_PIC
)
3648 strcat (buf
, ", pic");
3650 if (e_flags
& EF_SH_FDPIC
)
3651 strcat (buf
, ", fdpic");
3655 if (e_flags
& EF_OR1K_NODELAY
)
3656 strcat (buf
, ", no delay");
3660 if (e_flags
& EF_SPARC_32PLUS
)
3661 strcat (buf
, ", v8+");
3663 if (e_flags
& EF_SPARC_SUN_US1
)
3664 strcat (buf
, ", ultrasparcI");
3666 if (e_flags
& EF_SPARC_SUN_US3
)
3667 strcat (buf
, ", ultrasparcIII");
3669 if (e_flags
& EF_SPARC_HAL_R1
)
3670 strcat (buf
, ", halr1");
3672 if (e_flags
& EF_SPARC_LEDATA
)
3673 strcat (buf
, ", ledata");
3675 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3676 strcat (buf
, ", tso");
3678 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3679 strcat (buf
, ", pso");
3681 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3682 strcat (buf
, ", rmo");
3686 switch (e_flags
& EF_PARISC_ARCH
)
3688 case EFA_PARISC_1_0
:
3689 strcpy (buf
, ", PA-RISC 1.0");
3691 case EFA_PARISC_1_1
:
3692 strcpy (buf
, ", PA-RISC 1.1");
3694 case EFA_PARISC_2_0
:
3695 strcpy (buf
, ", PA-RISC 2.0");
3700 if (e_flags
& EF_PARISC_TRAPNIL
)
3701 strcat (buf
, ", trapnil");
3702 if (e_flags
& EF_PARISC_EXT
)
3703 strcat (buf
, ", ext");
3704 if (e_flags
& EF_PARISC_LSB
)
3705 strcat (buf
, ", lsb");
3706 if (e_flags
& EF_PARISC_WIDE
)
3707 strcat (buf
, ", wide");
3708 if (e_flags
& EF_PARISC_NO_KABP
)
3709 strcat (buf
, ", no kabp");
3710 if (e_flags
& EF_PARISC_LAZYSWAP
)
3711 strcat (buf
, ", lazyswap");
3716 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3717 strcat (buf
, ", new calling convention");
3719 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3720 strcat (buf
, ", gnu calling convention");
3724 if ((e_flags
& EF_IA_64_ABI64
))
3725 strcat (buf
, ", 64-bit");
3727 strcat (buf
, ", 32-bit");
3728 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3729 strcat (buf
, ", reduced fp model");
3730 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3731 strcat (buf
, ", no function descriptors, constant gp");
3732 else if ((e_flags
& EF_IA_64_CONS_GP
))
3733 strcat (buf
, ", constant gp");
3734 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3735 strcat (buf
, ", absolute");
3736 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3738 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3739 strcat (buf
, ", vms_linkages");
3740 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3742 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3744 case EF_IA_64_VMS_COMCOD_WARNING
:
3745 strcat (buf
, ", warning");
3747 case EF_IA_64_VMS_COMCOD_ERROR
:
3748 strcat (buf
, ", error");
3750 case EF_IA_64_VMS_COMCOD_ABORT
:
3751 strcat (buf
, ", abort");
3754 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3755 e_flags
& EF_IA_64_VMS_COMCOD
);
3756 strcat (buf
, ", <unknown>");
3762 if ((e_flags
& EF_VAX_NONPIC
))
3763 strcat (buf
, ", non-PIC");
3764 if ((e_flags
& EF_VAX_DFLOAT
))
3765 strcat (buf
, ", D-Float");
3766 if ((e_flags
& EF_VAX_GFLOAT
))
3767 strcat (buf
, ", G-Float");
3771 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3772 strcat (buf
, ", mcm");
3773 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3774 strcat (buf
, ", mcm24");
3775 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3776 strcat (buf
, ", gr6");
3780 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3782 case E_FLAG_RL78_ANY_CPU
: break;
3783 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3784 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3785 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3787 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3788 strcat (buf
, ", 64-bit doubles");
3792 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3793 strcat (buf
, ", 64-bit doubles");
3794 if (e_flags
& E_FLAG_RX_DSP
)
3795 strcat (buf
, ", dsp");
3796 if (e_flags
& E_FLAG_RX_PID
)
3797 strcat (buf
, ", pid");
3798 if (e_flags
& E_FLAG_RX_ABI
)
3799 strcat (buf
, ", RX ABI");
3800 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3801 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3802 ? ", uses String instructions" : ", bans String instructions");
3803 if (e_flags
& E_FLAG_RX_V2
)
3804 strcat (buf
, ", V2");
3805 if (e_flags
& E_FLAG_RX_V3
)
3806 strcat (buf
, ", V3");
3810 if (e_flags
& EF_S390_HIGH_GPRS
)
3811 strcat (buf
, ", highgprs");
3815 if ((e_flags
& EF_C6000_REL
))
3816 strcat (buf
, ", relocatable module");
3820 strcat (buf
, _(": architecture variant: "));
3821 switch (e_flags
& EF_MSP430_MACH
)
3823 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3824 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3825 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3826 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3827 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3828 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3829 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3830 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3831 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3832 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3833 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3834 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3835 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3836 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3837 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3839 strcat (buf
, _(": unknown")); break;
3842 if (e_flags
& ~ EF_MSP430_MACH
)
3843 strcat (buf
, _(": unknown extra flag bits also present"));
3847 switch (e_flags
& EF_Z80_MACH_MSK
)
3849 case EF_Z80_MACH_Z80
: strcat (buf
, ", Z80"); break;
3850 case EF_Z80_MACH_Z180
: strcat (buf
, ", Z180"); break;
3851 case EF_Z80_MACH_R800
: strcat (buf
, ", R800"); break;
3852 case EF_Z80_MACH_EZ80_Z80
: strcat (buf
, ", EZ80"); break;
3853 case EF_Z80_MACH_EZ80_ADL
: strcat (buf
, ", EZ80, ADL"); break;
3854 case EF_Z80_MACH_GBZ80
: strcat (buf
, ", GBZ80"); break;
3855 case EF_Z80_MACH_Z80N
: strcat (buf
, ", Z80N"); break;
3857 strcat (buf
, _(", unknown")); break;
3867 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3869 static char buff
[32];
3873 case ELFOSABI_NONE
: return "UNIX - System V";
3874 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3875 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3876 case ELFOSABI_GNU
: return "UNIX - GNU";
3877 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3878 case ELFOSABI_AIX
: return "UNIX - AIX";
3879 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3880 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3881 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3882 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3883 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3884 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3885 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3886 case ELFOSABI_AROS
: return "AROS";
3887 case ELFOSABI_FENIXOS
: return "FenixOS";
3888 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3889 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3892 switch (filedata
->file_header
.e_machine
)
3897 case ELFOSABI_ARM
: return "ARM";
3898 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3909 case ELFOSABI_STANDALONE
: return _("Standalone App");
3918 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3919 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3928 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3934 get_aarch64_segment_type (unsigned long type
)
3938 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3939 default: return NULL
;
3944 get_arm_segment_type (unsigned long type
)
3948 case PT_ARM_EXIDX
: return "EXIDX";
3949 default: return NULL
;
3954 get_s390_segment_type (unsigned long type
)
3958 case PT_S390_PGSTE
: return "S390_PGSTE";
3959 default: return NULL
;
3964 get_mips_segment_type (unsigned long type
)
3968 case PT_MIPS_REGINFO
: return "REGINFO";
3969 case PT_MIPS_RTPROC
: return "RTPROC";
3970 case PT_MIPS_OPTIONS
: return "OPTIONS";
3971 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3972 default: return NULL
;
3977 get_parisc_segment_type (unsigned long type
)
3981 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3982 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3983 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3984 default: return NULL
;
3989 get_ia64_segment_type (unsigned long type
)
3993 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3994 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3995 default: return NULL
;
4000 get_tic6x_segment_type (unsigned long type
)
4004 case PT_C6000_PHATTR
: return "C6000_PHATTR";
4005 default: return NULL
;
4010 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
4012 if (e_machine
== EM_PARISC
)
4015 case PT_HP_TLS
: return "HP_TLS";
4016 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
4017 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
4018 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
4019 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
4020 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
4021 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
4022 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
4023 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
4024 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
4025 case PT_HP_PARALLEL
: return "HP_PARALLEL";
4026 case PT_HP_FASTBIND
: return "HP_FASTBIND";
4027 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
4028 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
4029 case PT_HP_STACK
: return "HP_STACK";
4030 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
4031 default: return NULL
;
4034 if (e_machine
== EM_IA_64
)
4037 case PT_HP_TLS
: return "HP_TLS";
4038 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
4039 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
4040 case PT_IA_64_HP_STACK
: return "HP_STACK";
4041 default: return NULL
;
4048 get_solaris_segment_type (unsigned long type
)
4052 case 0x6464e550: return "PT_SUNW_UNWIND";
4053 case 0x6474e550: return "PT_SUNW_EH_FRAME";
4054 case 0x6ffffff7: return "PT_LOSUNW";
4055 case 0x6ffffffa: return "PT_SUNWBSS";
4056 case 0x6ffffffb: return "PT_SUNWSTACK";
4057 case 0x6ffffffc: return "PT_SUNWDTRACE";
4058 case 0x6ffffffd: return "PT_SUNWCAP";
4059 case 0x6fffffff: return "PT_HISUNW";
4060 default: return NULL
;
4065 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
4067 static char buff
[32];
4071 case PT_NULL
: return "NULL";
4072 case PT_LOAD
: return "LOAD";
4073 case PT_DYNAMIC
: return "DYNAMIC";
4074 case PT_INTERP
: return "INTERP";
4075 case PT_NOTE
: return "NOTE";
4076 case PT_SHLIB
: return "SHLIB";
4077 case PT_PHDR
: return "PHDR";
4078 case PT_TLS
: return "TLS";
4079 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
4080 case PT_GNU_STACK
: return "GNU_STACK";
4081 case PT_GNU_RELRO
: return "GNU_RELRO";
4082 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
4084 case PT_OPENBSD_RANDOMIZE
: return "OPENBSD_RANDOMIZE";
4085 case PT_OPENBSD_WXNEEDED
: return "OPENBSD_WXNEEDED";
4086 case PT_OPENBSD_BOOTDATA
: return "OPENBSD_BOOTDATA";
4089 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
4091 const char * result
;
4093 switch (filedata
->file_header
.e_machine
)
4096 result
= get_aarch64_segment_type (p_type
);
4099 result
= get_arm_segment_type (p_type
);
4102 case EM_MIPS_RS3_LE
:
4103 result
= get_mips_segment_type (p_type
);
4106 result
= get_parisc_segment_type (p_type
);
4109 result
= get_ia64_segment_type (p_type
);
4112 result
= get_tic6x_segment_type (p_type
);
4116 result
= get_s390_segment_type (p_type
);
4126 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
4128 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
4130 const char * result
= NULL
;
4132 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
4135 case ELFOSABI_FREEBSD
:
4136 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
4138 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
4143 result
= get_hpux_segment_type (p_type
,
4144 filedata
->file_header
.e_machine
);
4146 case ELFOSABI_SOLARIS
:
4147 result
= get_solaris_segment_type (p_type
);
4155 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4158 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4165 get_arc_section_type_name (unsigned int sh_type
)
4169 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4177 get_mips_section_type_name (unsigned int sh_type
)
4181 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4182 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4183 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4184 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4185 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4186 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4187 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4188 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4189 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4190 case SHT_MIPS_RELD
: return "MIPS_RELD";
4191 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4192 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4193 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4194 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4195 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4196 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4197 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4198 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4199 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4200 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4201 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4202 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4203 case SHT_MIPS_LINE
: return "MIPS_LINE";
4204 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4205 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4206 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4207 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4208 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4209 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4210 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4211 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4212 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4213 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4214 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4215 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4216 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4217 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4218 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4219 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4220 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4221 case SHT_MIPS_XHASH
: return "MIPS_XHASH";
4229 get_parisc_section_type_name (unsigned int sh_type
)
4233 case SHT_PARISC_EXT
: return "PARISC_EXT";
4234 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4235 case SHT_PARISC_DOC
: return "PARISC_DOC";
4236 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4237 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4238 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4239 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4240 default: return NULL
;
4245 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4247 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4248 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4249 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4253 case SHT_IA_64_EXT
: return "IA_64_EXT";
4254 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4255 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4256 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4257 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4258 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4259 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4260 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4261 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4262 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4270 get_x86_64_section_type_name (unsigned int sh_type
)
4274 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4275 default: return NULL
;
4280 get_aarch64_section_type_name (unsigned int sh_type
)
4284 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4285 default: return NULL
;
4290 get_arm_section_type_name (unsigned int sh_type
)
4294 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4295 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4296 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4297 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4298 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4299 default: return NULL
;
4304 get_tic6x_section_type_name (unsigned int sh_type
)
4308 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4309 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4310 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4311 case SHT_TI_ICODE
: return "TI_ICODE";
4312 case SHT_TI_XREF
: return "TI_XREF";
4313 case SHT_TI_HANDLER
: return "TI_HANDLER";
4314 case SHT_TI_INITINFO
: return "TI_INITINFO";
4315 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4316 default: return NULL
;
4321 get_msp430_section_type_name (unsigned int sh_type
)
4325 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4326 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4327 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4328 default: return NULL
;
4333 get_nfp_section_type_name (unsigned int sh_type
)
4337 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4338 case SHT_NFP_INITREG
: return "NFP_INITREG";
4339 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4340 default: return NULL
;
4345 get_v850_section_type_name (unsigned int sh_type
)
4349 case SHT_V850_SCOMMON
: return "V850 Small Common";
4350 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4351 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4352 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4353 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4354 default: return NULL
;
4359 get_riscv_section_type_name (unsigned int sh_type
)
4363 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4364 default: return NULL
;
4369 get_csky_section_type_name (unsigned int sh_type
)
4373 case SHT_CSKY_ATTRIBUTES
: return "CSKY_ATTRIBUTES";
4374 default: return NULL
;
4379 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4381 static char buff
[32];
4382 const char * result
;
4386 case SHT_NULL
: return "NULL";
4387 case SHT_PROGBITS
: return "PROGBITS";
4388 case SHT_SYMTAB
: return "SYMTAB";
4389 case SHT_STRTAB
: return "STRTAB";
4390 case SHT_RELA
: return "RELA";
4391 case SHT_HASH
: return "HASH";
4392 case SHT_DYNAMIC
: return "DYNAMIC";
4393 case SHT_NOTE
: return "NOTE";
4394 case SHT_NOBITS
: return "NOBITS";
4395 case SHT_REL
: return "REL";
4396 case SHT_SHLIB
: return "SHLIB";
4397 case SHT_DYNSYM
: return "DYNSYM";
4398 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4399 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4400 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4401 case SHT_GNU_HASH
: return "GNU_HASH";
4402 case SHT_GROUP
: return "GROUP";
4403 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4404 case SHT_GNU_verdef
: return "VERDEF";
4405 case SHT_GNU_verneed
: return "VERNEED";
4406 case SHT_GNU_versym
: return "VERSYM";
4407 case 0x6ffffff0: return "VERSYM";
4408 case 0x6ffffffc: return "VERDEF";
4409 case 0x7ffffffd: return "AUXILIARY";
4410 case 0x7fffffff: return "FILTER";
4411 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4414 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4416 switch (filedata
->file_header
.e_machine
)
4419 case EM_ARC_COMPACT
:
4420 case EM_ARC_COMPACT2
:
4421 result
= get_arc_section_type_name (sh_type
);
4424 case EM_MIPS_RS3_LE
:
4425 result
= get_mips_section_type_name (sh_type
);
4428 result
= get_parisc_section_type_name (sh_type
);
4431 result
= get_ia64_section_type_name (filedata
, sh_type
);
4436 result
= get_x86_64_section_type_name (sh_type
);
4439 result
= get_aarch64_section_type_name (sh_type
);
4442 result
= get_arm_section_type_name (sh_type
);
4445 result
= get_tic6x_section_type_name (sh_type
);
4448 result
= get_msp430_section_type_name (sh_type
);
4451 result
= get_nfp_section_type_name (sh_type
);
4455 case EM_CYGNUS_V850
:
4456 result
= get_v850_section_type_name (sh_type
);
4459 result
= get_riscv_section_type_name (sh_type
);
4462 result
= get_csky_section_type_name (sh_type
);
4472 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4474 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4476 switch (filedata
->file_header
.e_machine
)
4479 result
= get_ia64_section_type_name (filedata
, sh_type
);
4482 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4483 result
= get_solaris_section_type (sh_type
);
4488 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4489 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4490 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4491 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4503 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4505 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4507 switch (filedata
->file_header
.e_machine
)
4511 case EM_CYGNUS_V850
:
4512 result
= get_v850_section_type_name (sh_type
);
4522 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4525 /* This message is probably going to be displayed in a 15
4526 character wide field, so put the hex value first. */
4527 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4533 enum long_option_values
4535 OPTION_DEBUG_DUMP
= 512,
4545 OPTION_WITH_SYMBOL_VERSIONS
,
4546 OPTION_RECURSE_LIMIT
,
4547 OPTION_NO_RECURSE_LIMIT
,
4548 OPTION_NO_DEMANGLING
,
4552 static struct option options
[] =
4554 /* Note - This table is alpha-sorted on the 'val'
4555 field in order to make adding new options easier. */
4556 {"arch-specific", no_argument
, 0, 'A'},
4557 {"all", no_argument
, 0, 'a'},
4558 {"demangle", optional_argument
, 0, 'C'},
4559 {"archive-index", no_argument
, 0, 'c'},
4560 {"use-dynamic", no_argument
, 0, 'D'},
4561 {"dynamic", no_argument
, 0, 'd'},
4562 {"headers", no_argument
, 0, 'e'},
4563 {"section-groups", no_argument
, 0, 'g'},
4564 {"help", no_argument
, 0, 'H'},
4565 {"file-header", no_argument
, 0, 'h'},
4566 {"histogram", no_argument
, 0, 'I'},
4567 {"lint", no_argument
, 0, 'L'},
4568 {"enable-checks", no_argument
, 0, 'L'},
4569 {"program-headers", no_argument
, 0, 'l'},
4570 {"segments", no_argument
, 0, 'l'},
4571 {"full-section-name",no_argument
, 0, 'N'},
4572 {"notes", no_argument
, 0, 'n'},
4573 {"process-links", no_argument
, 0, 'P'},
4574 {"string-dump", required_argument
, 0, 'p'},
4575 {"relocated-dump", required_argument
, 0, 'R'},
4576 {"relocs", no_argument
, 0, 'r'},
4577 {"section-headers", no_argument
, 0, 'S'},
4578 {"sections", no_argument
, 0, 'S'},
4579 {"symbols", no_argument
, 0, 's'},
4580 {"syms", no_argument
, 0, 's'},
4581 {"silent-truncation",no_argument
, 0, 'T'},
4582 {"section-details", no_argument
, 0, 't'},
4583 {"unwind", no_argument
, 0, 'u'},
4584 {"version-info", no_argument
, 0, 'V'},
4585 {"version", no_argument
, 0, 'v'},
4586 {"wide", no_argument
, 0, 'W'},
4587 {"hex-dump", required_argument
, 0, 'x'},
4588 {"decompress", no_argument
, 0, 'z'},
4590 {"no-demangle", no_argument
, 0, OPTION_NO_DEMANGLING
},
4591 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
4592 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
4593 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
4594 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4595 {"lto-syms", no_argument
, 0, OPTION_LTO_SYMS
},
4596 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4597 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4598 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4599 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4600 #ifdef ENABLE_LIBCTF
4601 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
4602 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
4603 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
4604 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
4606 {"sym-base", optional_argument
, 0, OPTION_SYM_BASE
},
4608 {0, no_argument
, 0, 0}
4612 usage (FILE * stream
)
4614 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4615 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4616 fprintf (stream
, _(" Options are:\n"));
4617 fprintf (stream
, _("\
4618 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
4619 fprintf (stream
, _("\
4620 -h --file-header Display the ELF file header\n"));
4621 fprintf (stream
, _("\
4622 -l --program-headers Display the program headers\n"));
4623 fprintf (stream
, _("\
4624 --segments An alias for --program-headers\n"));
4625 fprintf (stream
, _("\
4626 -S --section-headers Display the sections' header\n"));
4627 fprintf (stream
, _("\
4628 --sections An alias for --section-headers\n"));
4629 fprintf (stream
, _("\
4630 -g --section-groups Display the section groups\n"));
4631 fprintf (stream
, _("\
4632 -t --section-details Display the section details\n"));
4633 fprintf (stream
, _("\
4634 -e --headers Equivalent to: -h -l -S\n"));
4635 fprintf (stream
, _("\
4636 -s --syms Display the symbol table\n"));
4637 fprintf (stream
, _("\
4638 --symbols An alias for --syms\n"));
4639 fprintf (stream
, _("\
4640 --dyn-syms Display the dynamic symbol table\n"));
4641 fprintf (stream
, _("\
4642 --lto-syms Display LTO symbol tables\n"));
4643 fprintf (stream
, _("\
4644 --sym-base=[0|8|10|16] \n\
4645 Force base for symbol sizes. The options are \n\
4646 mixed (the default), octal, decimal, hexadecimal.\n"));
4647 fprintf (stream
, _("\
4648 -C --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
4649 The STYLE, if specified, can be `auto' (the default),\n\
4650 `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
4652 fprintf (stream
, _("\
4653 --no-demangle Do not demangle low-level symbol names. (default)\n"));
4654 fprintf (stream
, _("\
4655 --recurse-limit Enable a demangling recursion limit. (default)\n"));
4656 fprintf (stream
, _("\
4657 --no-recurse-limit Disable a demangling recursion limit\n"));
4658 fprintf (stream
, _("\
4659 -n --notes Display the core notes (if present)\n"));
4660 fprintf (stream
, _("\
4661 -r --relocs Display the relocations (if present)\n"));
4662 fprintf (stream
, _("\
4663 -u --unwind Display the unwind info (if present)\n"));
4664 fprintf (stream
, _("\
4665 -d --dynamic Display the dynamic section (if present)\n"));
4666 fprintf (stream
, _("\
4667 -V --version-info Display the version sections (if present)\n"));
4668 fprintf (stream
, _("\
4669 -A --arch-specific Display architecture specific information (if any)\n"));
4670 fprintf (stream
, _("\
4671 -c --archive-index Display the symbol/file index in an archive\n"));
4672 fprintf (stream
, _("\
4673 -D --use-dynamic Use the dynamic section info when displaying symbols\n"));
4674 fprintf (stream
, _("\
4675 -L --lint|--enable-checks\n\
4676 Display warning messages for possible problems\n"));
4677 fprintf (stream
, _("\
4678 -x --hex-dump=<number|name>\n\
4679 Dump the contents of section <number|name> as bytes\n"));
4680 fprintf (stream
, _("\
4681 -p --string-dump=<number|name>\n\
4682 Dump the contents of section <number|name> as strings\n"));
4683 fprintf (stream
, _("\
4684 -R --relocated-dump=<number|name>\n\
4685 Dump the relocated contents of section <number|name>\n"));
4686 fprintf (stream
, _("\
4687 -z --decompress Decompress section before dumping it\n"));
4688 fprintf (stream
, _("\
4689 -w --debug-dump[a/=abbrev, A/=addr, r/=aranges, c/=cu_index, L/=decodedline,\n\
4690 f/=frames, F/=frames-interp, g/=gdb_index, i/=info, o/=loc,\n\
4691 m/=macro, p/=pubnames, t/=pubtypes, R/=Ranges, l/=rawline,\n\
4692 s/=str, O/=str-offsets, u/=trace_abbrev, T/=trace_aranges,\n\
4694 Display the contents of DWARF debug sections\n"));
4695 fprintf (stream
, _("\
4696 -wk --debug-dump=links Display the contents of sections that link to separate\n\
4697 debuginfo files\n"));
4698 fprintf (stream
, _("\
4699 -P --process-links Display the contents of non-debug sections in separate\n\
4700 debuginfo files. (Implies -wK)\n"));
4701 #if DEFAULT_FOR_FOLLOW_LINKS
4702 fprintf (stream
, _("\
4703 -wK --debug-dump=follow-links\n\
4704 Follow links to separate debug info files (default)\n"));
4705 fprintf (stream
, _("\
4706 -wN --debug-dump=no-follow-links\n\
4707 Do not follow links to separate debug info files\n"));
4709 fprintf (stream
, _("\
4710 -wK --debug-dump=follow-links\n\
4711 Follow links to separate debug info files\n"));
4712 fprintf (stream
, _("\
4713 -wN --debug-dump=no-follow-links\n\
4714 Do not follow links to separate debug info files\n\
4717 fprintf (stream
, _("\
4718 --dwarf-depth=N Do not display DIEs at depth N or greater\n"));
4719 fprintf (stream
, _("\
4720 --dwarf-start=N Display DIEs starting at offset N\n"));
4721 #ifdef ENABLE_LIBCTF
4722 fprintf (stream
, _("\
4723 --ctf=<number|name> Display CTF info from section <number|name>\n"));
4724 fprintf (stream
, _("\
4725 --ctf-parent=<number|name>\n\
4726 Use section <number|name> as the CTF parent\n"));
4727 fprintf (stream
, _("\
4728 --ctf-symbols=<number|name>\n\
4729 Use section <number|name> as the CTF external symtab\n"));
4730 fprintf (stream
, _("\
4731 --ctf-strings=<number|name>\n\
4732 Use section <number|name> as the CTF external strtab\n"));
4735 #ifdef SUPPORT_DISASSEMBLY
4736 fprintf (stream
, _("\
4737 -i --instruction-dump=<number|name>\n\
4738 Disassemble the contents of section <number|name>\n"));
4740 fprintf (stream
, _("\
4741 -I --histogram Display histogram of bucket list lengths\n"));
4742 fprintf (stream
, _("\
4743 -W --wide Allow output width to exceed 80 characters\n"));
4744 fprintf (stream
, _("\
4745 -T --silent-truncation If a symbol name is truncated, do not add [...] suffix\n"));
4746 fprintf (stream
, _("\
4747 @<file> Read options from <file>\n"));
4748 fprintf (stream
, _("\
4749 -H --help Display this information\n"));
4750 fprintf (stream
, _("\
4751 -v --version Display the version number of readelf\n"));
4753 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4754 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4756 exit (stream
== stdout
? 0 : 1);
4759 /* Record the fact that the user wants the contents of section number
4760 SECTION to be displayed using the method(s) encoded as flags bits
4761 in TYPE. Note, TYPE can be zero if we are creating the array for
4765 request_dump_bynumber (struct dump_data
*dumpdata
,
4766 unsigned int section
, dump_type type
)
4768 if (section
>= dumpdata
->num_dump_sects
)
4770 dump_type
* new_dump_sects
;
4772 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4773 sizeof (* new_dump_sects
));
4775 if (new_dump_sects
== NULL
)
4776 error (_("Out of memory allocating dump request table.\n"));
4779 if (dumpdata
->dump_sects
)
4781 /* Copy current flag settings. */
4782 memcpy (new_dump_sects
, dumpdata
->dump_sects
,
4783 dumpdata
->num_dump_sects
* sizeof (* new_dump_sects
));
4785 free (dumpdata
->dump_sects
);
4788 dumpdata
->dump_sects
= new_dump_sects
;
4789 dumpdata
->num_dump_sects
= section
+ 1;
4793 if (dumpdata
->dump_sects
)
4794 dumpdata
->dump_sects
[section
] |= type
;
4797 /* Request a dump by section name. */
4800 request_dump_byname (const char * section
, dump_type type
)
4802 struct dump_list_entry
* new_request
;
4804 new_request
= (struct dump_list_entry
*)
4805 malloc (sizeof (struct dump_list_entry
));
4807 error (_("Out of memory allocating dump request table.\n"));
4809 new_request
->name
= strdup (section
);
4810 if (!new_request
->name
)
4811 error (_("Out of memory allocating dump request table.\n"));
4813 new_request
->type
= type
;
4815 new_request
->next
= dump_sects_byname
;
4816 dump_sects_byname
= new_request
;
4820 request_dump (struct dump_data
*dumpdata
, dump_type type
)
4826 section
= strtoul (optarg
, & cp
, 0);
4828 if (! *cp
&& section
>= 0)
4829 request_dump_bynumber (dumpdata
, section
, type
);
4831 request_dump_byname (optarg
, type
);
4835 parse_args (struct dump_data
*dumpdata
, int argc
, char ** argv
)
4842 while ((c
= getopt_long
4843 (argc
, argv
, "ACDHILNPR:STVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4861 do_section_groups
= true;
4864 do_histogram
= true;
4870 do_section_groups
= true;
4875 do_section_details
= true;
4886 do_using_dynamic
= true;
4910 do_histogram
= true;
4916 do_archive_index
= true;
4922 process_links
= true;
4923 do_follow_links
= true;
4926 request_dump (dumpdata
, HEX_DUMP
);
4929 request_dump (dumpdata
, STRING_DUMP
);
4932 request_dump (dumpdata
, RELOC_DUMP
);
4935 decompress_dumps
= true;
4941 do_debugging
= true;
4942 dwarf_select_sections_all ();
4946 do_debugging
= false;
4947 dwarf_select_sections_by_letters (optarg
);
4950 case OPTION_DEBUG_DUMP
:
4954 do_debugging
= true;
4955 dwarf_select_sections_all ();
4959 do_debugging
= false;
4960 dwarf_select_sections_by_names (optarg
);
4963 case OPTION_DWARF_DEPTH
:
4967 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4970 case OPTION_DWARF_START
:
4974 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4977 case OPTION_DWARF_CHECK
:
4980 case OPTION_CTF_DUMP
:
4982 request_dump (dumpdata
, CTF_DUMP
);
4984 case OPTION_CTF_SYMBOLS
:
4985 free (dump_ctf_symtab_name
);
4986 dump_ctf_symtab_name
= strdup (optarg
);
4988 case OPTION_CTF_STRINGS
:
4989 free (dump_ctf_strtab_name
);
4990 dump_ctf_strtab_name
= strdup (optarg
);
4992 case OPTION_CTF_PARENT
:
4993 free (dump_ctf_parent_name
);
4994 dump_ctf_parent_name
= strdup (optarg
);
4996 case OPTION_DYN_SYMS
:
4999 case OPTION_LTO_SYMS
:
5002 #ifdef SUPPORT_DISASSEMBLY
5004 request_dump (dumpdata
, DISASS_DUMP
);
5008 print_version (program_name
);
5017 do_not_show_symbol_truncation
= true;
5023 enum demangling_styles style
;
5025 style
= cplus_demangle_name_to_style (optarg
);
5026 if (style
== unknown_demangling
)
5027 error (_("unknown demangling style `%s'"), optarg
);
5029 cplus_demangle_set_style (style
);
5032 case OPTION_NO_DEMANGLING
:
5033 do_demangle
= false;
5035 case OPTION_RECURSE_LIMIT
:
5036 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
5038 case OPTION_NO_RECURSE_LIMIT
:
5039 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
5041 case OPTION_WITH_SYMBOL_VERSIONS
:
5042 /* Ignored for backward compatibility. */
5045 case OPTION_SYM_BASE
:
5049 sym_base
= strtoul (optarg
, NULL
, 0);
5066 /* xgettext:c-format */
5067 error (_("Invalid option '-%c'\n"), c
);
5074 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
5075 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
5076 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
5077 && !do_section_groups
&& !do_archive_index
5078 && !do_dyn_syms
&& !do_lto_syms
)
5083 do_dynamic
= do_syms
= do_reloc
= do_unwind
= do_sections
= true;
5084 do_segments
= do_header
= do_dump
= do_version
= true;
5085 do_histogram
= do_debugging
= do_arch
= do_notes
= true;
5086 do_section_groups
= do_archive_index
= do_dyn_syms
= true;
5095 get_elf_class (unsigned int elf_class
)
5097 static char buff
[32];
5101 case ELFCLASSNONE
: return _("none");
5102 case ELFCLASS32
: return "ELF32";
5103 case ELFCLASS64
: return "ELF64";
5105 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
5111 get_data_encoding (unsigned int encoding
)
5113 static char buff
[32];
5117 case ELFDATANONE
: return _("none");
5118 case ELFDATA2LSB
: return _("2's complement, little endian");
5119 case ELFDATA2MSB
: return _("2's complement, big endian");
5121 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
5126 /* Decode the data held in 'filedata->file_header'. */
5129 process_file_header (Filedata
* filedata
)
5131 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
5133 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
5134 || header
->e_ident
[EI_MAG1
] != ELFMAG1
5135 || header
->e_ident
[EI_MAG2
] != ELFMAG2
5136 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
5139 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
5143 if (! filedata
->is_separate
)
5144 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
5150 if (filedata
->is_separate
)
5151 printf (_("ELF Header in linked file '%s':\n"), filedata
->file_name
);
5153 printf (_("ELF Header:\n"));
5154 printf (_(" Magic: "));
5155 for (i
= 0; i
< EI_NIDENT
; i
++)
5156 printf ("%2.2x ", header
->e_ident
[i
]);
5158 printf (_(" Class: %s\n"),
5159 get_elf_class (header
->e_ident
[EI_CLASS
]));
5160 printf (_(" Data: %s\n"),
5161 get_data_encoding (header
->e_ident
[EI_DATA
]));
5162 printf (_(" Version: %d%s\n"),
5163 header
->e_ident
[EI_VERSION
],
5164 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
5166 : (header
->e_ident
[EI_VERSION
] != EV_NONE
5169 printf (_(" OS/ABI: %s\n"),
5170 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
5171 printf (_(" ABI Version: %d\n"),
5172 header
->e_ident
[EI_ABIVERSION
]);
5173 printf (_(" Type: %s\n"),
5174 get_file_type (header
->e_type
));
5175 printf (_(" Machine: %s\n"),
5176 get_machine_name (header
->e_machine
));
5177 printf (_(" Version: 0x%lx\n"),
5180 printf (_(" Entry point address: "));
5181 print_vma (header
->e_entry
, PREFIX_HEX
);
5182 printf (_("\n Start of program headers: "));
5183 print_vma (header
->e_phoff
, DEC
);
5184 printf (_(" (bytes into file)\n Start of section headers: "));
5185 print_vma (header
->e_shoff
, DEC
);
5186 printf (_(" (bytes into file)\n"));
5188 printf (_(" Flags: 0x%lx%s\n"),
5190 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
5191 printf (_(" Size of this header: %u (bytes)\n"),
5193 printf (_(" Size of program headers: %u (bytes)\n"),
5194 header
->e_phentsize
);
5195 printf (_(" Number of program headers: %u"),
5197 if (filedata
->section_headers
!= NULL
5198 && header
->e_phnum
== PN_XNUM
5199 && filedata
->section_headers
[0].sh_info
!= 0)
5201 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
5202 printf (" (%u)", header
->e_phnum
);
5204 putc ('\n', stdout
);
5205 printf (_(" Size of section headers: %u (bytes)\n"),
5206 header
->e_shentsize
);
5207 printf (_(" Number of section headers: %u"),
5209 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
5211 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5212 printf (" (%u)", header
->e_shnum
);
5214 putc ('\n', stdout
);
5215 printf (_(" Section header string table index: %u"),
5216 header
->e_shstrndx
);
5217 if (filedata
->section_headers
!= NULL
5218 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5220 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5221 printf (" (%u)", header
->e_shstrndx
);
5223 if (header
->e_shstrndx
!= SHN_UNDEF
5224 && header
->e_shstrndx
>= header
->e_shnum
)
5226 header
->e_shstrndx
= SHN_UNDEF
;
5227 printf (_(" <corrupt: out of range>"));
5229 putc ('\n', stdout
);
5232 if (filedata
->section_headers
!= NULL
)
5234 if (header
->e_phnum
== PN_XNUM
5235 && filedata
->section_headers
[0].sh_info
!= 0)
5236 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
5237 if (header
->e_shnum
== SHN_UNDEF
)
5238 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5239 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5240 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5241 if (header
->e_shstrndx
>= header
->e_shnum
)
5242 header
->e_shstrndx
= SHN_UNDEF
;
5243 free (filedata
->section_headers
);
5244 filedata
->section_headers
= NULL
;
5250 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5251 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
5254 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5256 Elf32_External_Phdr
* phdrs
;
5257 Elf32_External_Phdr
* external
;
5258 Elf_Internal_Phdr
* internal
;
5260 unsigned int size
= filedata
->file_header
.e_phentsize
;
5261 unsigned int num
= filedata
->file_header
.e_phnum
;
5263 /* PR binutils/17531: Cope with unexpected section header sizes. */
5264 if (size
== 0 || num
== 0)
5266 if (size
< sizeof * phdrs
)
5268 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5271 if (size
> sizeof * phdrs
)
5272 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5274 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5275 size
, num
, _("program headers"));
5279 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5280 i
< filedata
->file_header
.e_phnum
;
5281 i
++, internal
++, external
++)
5283 internal
->p_type
= BYTE_GET (external
->p_type
);
5284 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5285 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5286 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5287 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5288 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5289 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5290 internal
->p_align
= BYTE_GET (external
->p_align
);
5297 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5298 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5301 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5303 Elf64_External_Phdr
* phdrs
;
5304 Elf64_External_Phdr
* external
;
5305 Elf_Internal_Phdr
* internal
;
5307 unsigned int size
= filedata
->file_header
.e_phentsize
;
5308 unsigned int num
= filedata
->file_header
.e_phnum
;
5310 /* PR binutils/17531: Cope with unexpected section header sizes. */
5311 if (size
== 0 || num
== 0)
5313 if (size
< sizeof * phdrs
)
5315 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5318 if (size
> sizeof * phdrs
)
5319 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5321 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5322 size
, num
, _("program headers"));
5326 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5327 i
< filedata
->file_header
.e_phnum
;
5328 i
++, internal
++, external
++)
5330 internal
->p_type
= BYTE_GET (external
->p_type
);
5331 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5332 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5333 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5334 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5335 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5336 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5337 internal
->p_align
= BYTE_GET (external
->p_align
);
5344 /* Returns TRUE if the program headers were read into `program_headers'. */
5347 get_program_headers (Filedata
* filedata
)
5349 Elf_Internal_Phdr
* phdrs
;
5351 /* Check cache of prior read. */
5352 if (filedata
->program_headers
!= NULL
)
5355 /* Be kind to memory checkers by looking for
5356 e_phnum values which we know must be invalid. */
5357 if (filedata
->file_header
.e_phnum
5358 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5359 >= filedata
->file_size
)
5361 error (_("Too many program headers - %#x - the file is not that big\n"),
5362 filedata
->file_header
.e_phnum
);
5366 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5367 sizeof (Elf_Internal_Phdr
));
5370 error (_("Out of memory reading %u program headers\n"),
5371 filedata
->file_header
.e_phnum
);
5376 ? get_32bit_program_headers (filedata
, phdrs
)
5377 : get_64bit_program_headers (filedata
, phdrs
))
5379 filedata
->program_headers
= phdrs
;
5387 /* Returns TRUE if the program headers were loaded. */
5390 process_program_headers (Filedata
* filedata
)
5392 Elf_Internal_Phdr
* segment
;
5394 Elf_Internal_Phdr
* previous_load
= NULL
;
5396 filedata
->dynamic_addr
= 0;
5397 filedata
->dynamic_size
= 0;
5399 if (filedata
->file_header
.e_phnum
== 0)
5401 /* PR binutils/12467. */
5402 if (filedata
->file_header
.e_phoff
!= 0)
5404 warn (_("possibly corrupt ELF header - it has a non-zero program"
5405 " header offset, but no program headers\n"));
5408 else if (do_segments
)
5410 if (filedata
->is_separate
)
5411 printf (_("\nThere are no program headers in linked file '%s'.\n"),
5412 filedata
->file_name
);
5414 printf (_("\nThere are no program headers in this file.\n"));
5419 if (do_segments
&& !do_header
)
5421 if (filedata
->is_separate
)
5422 printf ("\nIn linked file '%s' the ELF file type is %s\n",
5423 filedata
->file_name
,
5424 get_file_type (filedata
->file_header
.e_type
));
5426 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5427 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5428 printf (ngettext ("There is %d program header, starting at offset %s\n",
5429 "There are %d program headers, starting at offset %s\n",
5430 filedata
->file_header
.e_phnum
),
5431 filedata
->file_header
.e_phnum
,
5432 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5435 if (! get_program_headers (filedata
))
5440 if (filedata
->file_header
.e_phnum
> 1)
5441 printf (_("\nProgram Headers:\n"));
5443 printf (_("\nProgram Headers:\n"));
5447 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5450 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5454 (_(" Type Offset VirtAddr PhysAddr\n"));
5456 (_(" FileSiz MemSiz Flags Align\n"));
5460 for (i
= 0, segment
= filedata
->program_headers
;
5461 i
< filedata
->file_header
.e_phnum
;
5466 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5470 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5471 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5472 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5473 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5474 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5476 (segment
->p_flags
& PF_R
? 'R' : ' '),
5477 (segment
->p_flags
& PF_W
? 'W' : ' '),
5478 (segment
->p_flags
& PF_X
? 'E' : ' '));
5479 printf ("%#lx", (unsigned long) segment
->p_align
);
5483 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5484 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5487 print_vma (segment
->p_offset
, FULL_HEX
);
5491 print_vma (segment
->p_vaddr
, FULL_HEX
);
5493 print_vma (segment
->p_paddr
, FULL_HEX
);
5496 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5497 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5500 print_vma (segment
->p_filesz
, FULL_HEX
);
5504 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5505 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5508 print_vma (segment
->p_memsz
, FULL_HEX
);
5512 (segment
->p_flags
& PF_R
? 'R' : ' '),
5513 (segment
->p_flags
& PF_W
? 'W' : ' '),
5514 (segment
->p_flags
& PF_X
? 'E' : ' '));
5516 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5517 printf ("%#lx", (unsigned long) segment
->p_align
);
5520 print_vma (segment
->p_align
, PREFIX_HEX
);
5525 print_vma (segment
->p_offset
, FULL_HEX
);
5527 print_vma (segment
->p_vaddr
, FULL_HEX
);
5529 print_vma (segment
->p_paddr
, FULL_HEX
);
5531 print_vma (segment
->p_filesz
, FULL_HEX
);
5533 print_vma (segment
->p_memsz
, FULL_HEX
);
5535 (segment
->p_flags
& PF_R
? 'R' : ' '),
5536 (segment
->p_flags
& PF_W
? 'W' : ' '),
5537 (segment
->p_flags
& PF_X
? 'E' : ' '));
5538 print_vma (segment
->p_align
, PREFIX_HEX
);
5541 putc ('\n', stdout
);
5544 switch (segment
->p_type
)
5547 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5548 required by the ELF standard, several programs, including the Linux
5549 kernel, make use of non-ordered segments. */
5551 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5552 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5554 if (segment
->p_memsz
< segment
->p_filesz
)
5555 error (_("the segment's file size is larger than its memory size\n"));
5556 previous_load
= segment
;
5560 /* PR 20815 - Verify that the program header is loaded into memory. */
5561 if (i
> 0 && previous_load
!= NULL
)
5562 error (_("the PHDR segment must occur before any LOAD segment\n"));
5563 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5567 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5569 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
5570 if (load
->p_type
== PT_LOAD
5571 && load
->p_offset
<= segment
->p_offset
5572 && (load
->p_offset
+ load
->p_filesz
5573 >= segment
->p_offset
+ segment
->p_filesz
)
5574 && load
->p_vaddr
<= segment
->p_vaddr
5575 && (load
->p_vaddr
+ load
->p_filesz
5576 >= segment
->p_vaddr
+ segment
->p_filesz
))
5579 if (j
== filedata
->file_header
.e_phnum
)
5580 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5585 if (filedata
->dynamic_addr
)
5586 error (_("more than one dynamic segment\n"));
5588 /* By default, assume that the .dynamic section is the first
5589 section in the DYNAMIC segment. */
5590 filedata
->dynamic_addr
= segment
->p_offset
;
5591 filedata
->dynamic_size
= segment
->p_filesz
;
5593 /* Try to locate the .dynamic section. If there is
5594 a section header table, we can easily locate it. */
5595 if (filedata
->section_headers
!= NULL
)
5597 Elf_Internal_Shdr
* sec
;
5599 sec
= find_section (filedata
, ".dynamic");
5600 if (sec
== NULL
|| sec
->sh_size
== 0)
5602 /* A corresponding .dynamic section is expected, but on
5603 IA-64/OpenVMS it is OK for it to be missing. */
5604 if (!is_ia64_vms (filedata
))
5605 error (_("no .dynamic section in the dynamic segment\n"));
5609 if (sec
->sh_type
== SHT_NOBITS
)
5611 filedata
->dynamic_size
= 0;
5615 filedata
->dynamic_addr
= sec
->sh_offset
;
5616 filedata
->dynamic_size
= sec
->sh_size
;
5618 /* The PT_DYNAMIC segment, which is used by the run-time
5619 loader, should exactly match the .dynamic section. */
5621 && (filedata
->dynamic_addr
!= segment
->p_offset
5622 || filedata
->dynamic_size
!= segment
->p_filesz
))
5624 the .dynamic section is not the same as the dynamic segment\n"));
5627 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5628 segment. Check this after matching against the section headers
5629 so we don't warn on debuginfo file (which have NOBITS .dynamic
5631 if (filedata
->dynamic_addr
> filedata
->file_size
5632 || (filedata
->dynamic_size
5633 > filedata
->file_size
- filedata
->dynamic_addr
))
5635 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5636 filedata
->dynamic_addr
= filedata
->dynamic_size
= 0;
5641 if (segment
->p_offset
>= filedata
->file_size
5642 || segment
->p_filesz
> filedata
->file_size
- segment
->p_offset
5643 || segment
->p_filesz
- 1 >= (size_t) -2
5644 || fseek (filedata
->handle
,
5645 filedata
->archive_file_offset
+ (long) segment
->p_offset
,
5647 error (_("Unable to find program interpreter name\n"));
5650 size_t len
= segment
->p_filesz
;
5651 free (filedata
->program_interpreter
);
5652 filedata
->program_interpreter
= xmalloc (len
+ 1);
5653 len
= fread (filedata
->program_interpreter
, 1, len
,
5655 filedata
->program_interpreter
[len
] = 0;
5658 printf (_(" [Requesting program interpreter: %s]\n"),
5659 filedata
->program_interpreter
);
5666 && filedata
->section_headers
!= NULL
5667 && filedata
->string_table
!= NULL
)
5669 printf (_("\n Section to Segment mapping:\n"));
5670 printf (_(" Segment Sections...\n"));
5672 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5675 Elf_Internal_Shdr
* section
;
5677 segment
= filedata
->program_headers
+ i
;
5678 section
= filedata
->section_headers
+ 1;
5680 printf (" %2.2d ", i
);
5682 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5684 if (!ELF_TBSS_SPECIAL (section
, segment
)
5685 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5686 printf ("%s ", printable_section_name (filedata
, section
));
5697 /* Find the file offset corresponding to VMA by using the program headers. */
5700 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5702 Elf_Internal_Phdr
* seg
;
5704 if (! get_program_headers (filedata
))
5706 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5710 for (seg
= filedata
->program_headers
;
5711 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5714 if (seg
->p_type
!= PT_LOAD
)
5717 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5718 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5719 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5722 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5723 (unsigned long) vma
);
5728 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5729 If PROBE is true, this is just a probe and we do not generate any error
5730 messages if the load fails. */
5733 get_32bit_section_headers (Filedata
* filedata
, bool probe
)
5735 Elf32_External_Shdr
* shdrs
;
5736 Elf_Internal_Shdr
* internal
;
5738 unsigned int size
= filedata
->file_header
.e_shentsize
;
5739 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5741 /* PR binutils/17531: Cope with unexpected section header sizes. */
5742 if (size
== 0 || num
== 0)
5744 if (size
< sizeof * shdrs
)
5747 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5750 if (!probe
&& size
> sizeof * shdrs
)
5751 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5753 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5755 probe
? NULL
: _("section headers"));
5759 free (filedata
->section_headers
);
5760 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5761 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5762 if (filedata
->section_headers
== NULL
)
5765 error (_("Out of memory reading %u section headers\n"), num
);
5770 for (i
= 0, internal
= filedata
->section_headers
;
5774 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5775 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5776 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5777 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5778 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5779 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5780 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5781 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5782 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5783 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5784 if (!probe
&& internal
->sh_link
> num
)
5785 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5786 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5787 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5794 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5797 get_64bit_section_headers (Filedata
* filedata
, bool probe
)
5799 Elf64_External_Shdr
* shdrs
;
5800 Elf_Internal_Shdr
* internal
;
5802 unsigned int size
= filedata
->file_header
.e_shentsize
;
5803 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5805 /* PR binutils/17531: Cope with unexpected section header sizes. */
5806 if (size
== 0 || num
== 0)
5809 if (size
< sizeof * shdrs
)
5812 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5816 if (! probe
&& size
> sizeof * shdrs
)
5817 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5819 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5820 filedata
->file_header
.e_shoff
,
5822 probe
? NULL
: _("section headers"));
5826 free (filedata
->section_headers
);
5827 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5828 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5829 if (filedata
->section_headers
== NULL
)
5832 error (_("Out of memory reading %u section headers\n"), num
);
5837 for (i
= 0, internal
= filedata
->section_headers
;
5841 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5842 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5843 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5844 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5845 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5846 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5847 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5848 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5849 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5850 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5851 if (!probe
&& internal
->sh_link
> num
)
5852 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5853 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5854 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5861 static Elf_Internal_Sym
*
5862 get_32bit_elf_symbols (Filedata
* filedata
,
5863 Elf_Internal_Shdr
* section
,
5864 unsigned long * num_syms_return
)
5866 unsigned long number
= 0;
5867 Elf32_External_Sym
* esyms
= NULL
;
5868 Elf_External_Sym_Shndx
* shndx
= NULL
;
5869 Elf_Internal_Sym
* isyms
= NULL
;
5870 Elf_Internal_Sym
* psym
;
5872 elf_section_list
* entry
;
5874 if (section
->sh_size
== 0)
5876 if (num_syms_return
!= NULL
)
5877 * num_syms_return
= 0;
5881 /* Run some sanity checks first. */
5882 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5884 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5885 printable_section_name (filedata
, section
),
5886 (unsigned long) section
->sh_entsize
);
5890 if (section
->sh_size
> filedata
->file_size
)
5892 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5893 printable_section_name (filedata
, section
),
5894 (unsigned long) section
->sh_size
);
5898 number
= section
->sh_size
/ section
->sh_entsize
;
5900 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5902 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5903 (unsigned long) section
->sh_size
,
5904 printable_section_name (filedata
, section
),
5905 (unsigned long) section
->sh_entsize
);
5909 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5910 section
->sh_size
, _("symbols"));
5915 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5917 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5922 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5926 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5927 entry
->hdr
->sh_offset
,
5928 1, entry
->hdr
->sh_size
,
5929 _("symbol table section indices"));
5933 /* PR17531: file: heap-buffer-overflow */
5934 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5936 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5937 printable_section_name (filedata
, entry
->hdr
),
5938 (unsigned long) entry
->hdr
->sh_size
,
5939 (unsigned long) section
->sh_size
);
5944 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5948 error (_("Out of memory reading %lu symbols\n"),
5949 (unsigned long) number
);
5953 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5955 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5956 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5957 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5958 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5959 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5961 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5962 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5963 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5964 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5965 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5972 if (num_syms_return
!= NULL
)
5973 * num_syms_return
= isyms
== NULL
? 0 : number
;
5978 static Elf_Internal_Sym
*
5979 get_64bit_elf_symbols (Filedata
* filedata
,
5980 Elf_Internal_Shdr
* section
,
5981 unsigned long * num_syms_return
)
5983 unsigned long number
= 0;
5984 Elf64_External_Sym
* esyms
= NULL
;
5985 Elf_External_Sym_Shndx
* shndx
= NULL
;
5986 Elf_Internal_Sym
* isyms
= NULL
;
5987 Elf_Internal_Sym
* psym
;
5989 elf_section_list
* entry
;
5991 if (section
->sh_size
== 0)
5993 if (num_syms_return
!= NULL
)
5994 * num_syms_return
= 0;
5998 /* Run some sanity checks first. */
5999 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
6001 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
6002 printable_section_name (filedata
, section
),
6003 (unsigned long) section
->sh_entsize
);
6007 if (section
->sh_size
> filedata
->file_size
)
6009 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
6010 printable_section_name (filedata
, section
),
6011 (unsigned long) section
->sh_size
);
6015 number
= section
->sh_size
/ section
->sh_entsize
;
6017 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
6019 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
6020 (unsigned long) section
->sh_size
,
6021 printable_section_name (filedata
, section
),
6022 (unsigned long) section
->sh_entsize
);
6026 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
6027 section
->sh_size
, _("symbols"));
6032 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
6034 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
6039 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
6043 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
6044 entry
->hdr
->sh_offset
,
6045 1, entry
->hdr
->sh_size
,
6046 _("symbol table section indices"));
6050 /* PR17531: file: heap-buffer-overflow */
6051 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
6053 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
6054 printable_section_name (filedata
, entry
->hdr
),
6055 (unsigned long) entry
->hdr
->sh_size
,
6056 (unsigned long) section
->sh_size
);
6061 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
6065 error (_("Out of memory reading %lu symbols\n"),
6066 (unsigned long) number
);
6070 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
6072 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
6073 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
6074 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
6075 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
6077 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
6079 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
6080 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
6081 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
6083 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
6084 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
6091 if (num_syms_return
!= NULL
)
6092 * num_syms_return
= isyms
== NULL
? 0 : number
;
6098 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
6100 static char buff
[1024];
6102 unsigned int field_size
= is_32bit_elf
? 8 : 16;
6104 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
6105 bfd_vma os_flags
= 0;
6106 bfd_vma proc_flags
= 0;
6107 bfd_vma unknown_flags
= 0;
6115 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
6116 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
6117 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
6118 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
6119 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
6120 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
6121 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
6122 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
6123 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
6124 /* 9 */ { STRING_COMMA_LEN ("TLS") },
6125 /* IA-64 specific. */
6126 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
6127 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
6128 /* IA-64 OpenVMS specific. */
6129 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
6130 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
6131 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
6132 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
6133 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
6134 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
6136 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
6137 /* SPARC specific. */
6138 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
6139 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
6141 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
6142 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
6143 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
6145 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
6147 /* 25 */ { STRING_COMMA_LEN ("VLE") },
6149 /* 26 */ { STRING_COMMA_LEN ("GNU_RETAIN") },
6152 if (do_section_details
)
6154 sprintf (buff
, "[%*.*lx]: ",
6155 field_size
, field_size
, (unsigned long) sh_flags
);
6156 p
+= field_size
+ 4;
6163 flag
= sh_flags
& - sh_flags
;
6166 if (do_section_details
)
6170 case SHF_WRITE
: sindex
= 0; break;
6171 case SHF_ALLOC
: sindex
= 1; break;
6172 case SHF_EXECINSTR
: sindex
= 2; break;
6173 case SHF_MERGE
: sindex
= 3; break;
6174 case SHF_STRINGS
: sindex
= 4; break;
6175 case SHF_INFO_LINK
: sindex
= 5; break;
6176 case SHF_LINK_ORDER
: sindex
= 6; break;
6177 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
6178 case SHF_GROUP
: sindex
= 8; break;
6179 case SHF_TLS
: sindex
= 9; break;
6180 case SHF_EXCLUDE
: sindex
= 18; break;
6181 case SHF_COMPRESSED
: sindex
= 20; break;
6185 switch (filedata
->file_header
.e_machine
)
6188 if (flag
== SHF_IA_64_SHORT
)
6190 else if (flag
== SHF_IA_64_NORECOV
)
6193 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
6196 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
6197 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
6198 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
6199 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
6200 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
6201 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
6212 case EM_OLD_SPARCV9
:
6213 case EM_SPARC32PLUS
:
6216 if (flag
== SHF_ORDERED
)
6223 case SHF_ENTRYSECT
: sindex
= 21; break;
6224 case SHF_ARM_PURECODE
: sindex
= 22; break;
6225 case SHF_COMDEF
: sindex
= 23; break;
6230 if (flag
== SHF_PPC_VLE
)
6237 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
6240 case ELFOSABI_FREEBSD
:
6241 if (flag
== SHF_GNU_RETAIN
)
6245 if (flag
== SHF_GNU_MBIND
)
6246 /* We should not recognize SHF_GNU_MBIND for
6247 ELFOSABI_NONE, but binutils as of 2019-07-23 did
6248 not set the EI_OSABI header byte. */
6259 if (p
!= buff
+ field_size
+ 4)
6261 if (size
< (10 + 2))
6263 warn (_("Internal error: not enough buffer room for section flag info"));
6264 return _("<unknown>");
6271 size
-= flags
[sindex
].len
;
6272 p
= stpcpy (p
, flags
[sindex
].str
);
6274 else if (flag
& SHF_MASKOS
)
6276 else if (flag
& SHF_MASKPROC
)
6279 unknown_flags
|= flag
;
6285 case SHF_WRITE
: *p
= 'W'; break;
6286 case SHF_ALLOC
: *p
= 'A'; break;
6287 case SHF_EXECINSTR
: *p
= 'X'; break;
6288 case SHF_MERGE
: *p
= 'M'; break;
6289 case SHF_STRINGS
: *p
= 'S'; break;
6290 case SHF_INFO_LINK
: *p
= 'I'; break;
6291 case SHF_LINK_ORDER
: *p
= 'L'; break;
6292 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
6293 case SHF_GROUP
: *p
= 'G'; break;
6294 case SHF_TLS
: *p
= 'T'; break;
6295 case SHF_EXCLUDE
: *p
= 'E'; break;
6296 case SHF_COMPRESSED
: *p
= 'C'; break;
6299 if ((filedata
->file_header
.e_machine
== EM_X86_64
6300 || filedata
->file_header
.e_machine
== EM_L1OM
6301 || filedata
->file_header
.e_machine
== EM_K1OM
)
6302 && flag
== SHF_X86_64_LARGE
)
6304 else if (filedata
->file_header
.e_machine
== EM_ARM
6305 && flag
== SHF_ARM_PURECODE
)
6307 else if (filedata
->file_header
.e_machine
== EM_PPC
6308 && flag
== SHF_PPC_VLE
)
6310 else if (flag
& SHF_MASKOS
)
6312 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
6315 case ELFOSABI_FREEBSD
:
6316 if (flag
== SHF_GNU_RETAIN
)
6323 if (flag
== SHF_GNU_MBIND
)
6325 /* We should not recognize SHF_GNU_MBIND for
6326 ELFOSABI_NONE, but binutils as of 2019-07-23 did
6327 not set the EI_OSABI header byte. */
6334 sh_flags
&= ~SHF_MASKOS
;
6338 else if (flag
& SHF_MASKPROC
)
6341 sh_flags
&= ~ SHF_MASKPROC
;
6351 if (do_section_details
)
6355 size
-= 5 + field_size
;
6356 if (p
!= buff
+ field_size
+ 4)
6360 warn (_("Internal error: not enough buffer room for section flag info"));
6361 return _("<unknown>");
6367 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6368 (unsigned long) os_flags
);
6369 p
+= 5 + field_size
;
6373 size
-= 7 + field_size
;
6374 if (p
!= buff
+ field_size
+ 4)
6378 warn (_("Internal error: not enough buffer room for section flag info"));
6379 return _("<unknown>");
6385 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6386 (unsigned long) proc_flags
);
6387 p
+= 7 + field_size
;
6391 size
-= 10 + field_size
;
6392 if (p
!= buff
+ field_size
+ 4)
6396 warn (_("Internal error: not enough buffer room for section flag info"));
6397 return _("<unknown>");
6403 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6404 (unsigned long) unknown_flags
);
6405 p
+= 10 + field_size
;
6413 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
6414 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6418 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6420 if (size
< sizeof (* echdr
))
6422 error (_("Compressed section is too small even for a compression header\n"));
6426 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6427 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6428 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6429 return sizeof (*echdr
);
6433 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6435 if (size
< sizeof (* echdr
))
6437 error (_("Compressed section is too small even for a compression header\n"));
6441 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6442 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6443 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6444 return sizeof (*echdr
);
6449 process_section_headers (Filedata
* filedata
)
6451 Elf_Internal_Shdr
* section
;
6454 free (filedata
->section_headers
);
6455 filedata
->section_headers
= NULL
;
6456 free (filedata
->dynamic_symbols
);
6457 filedata
->dynamic_symbols
= NULL
;
6458 filedata
->num_dynamic_syms
= 0;
6459 free (filedata
->dynamic_strings
);
6460 filedata
->dynamic_strings
= NULL
;
6461 filedata
->dynamic_strings_length
= 0;
6462 free (filedata
->dynamic_syminfo
);
6463 filedata
->dynamic_syminfo
= NULL
;
6464 while (filedata
->symtab_shndx_list
!= NULL
)
6466 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
6467 free (filedata
->symtab_shndx_list
);
6468 filedata
->symtab_shndx_list
= next
;
6471 if (filedata
->file_header
.e_shnum
== 0)
6473 /* PR binutils/12467. */
6474 if (filedata
->file_header
.e_shoff
!= 0)
6476 warn (_("possibly corrupt ELF file header - it has a non-zero"
6477 " section header offset, but no section headers\n"));
6480 else if (do_sections
)
6481 printf (_("\nThere are no sections in this file.\n"));
6486 if (do_sections
&& !do_header
)
6488 if (filedata
->is_separate
&& process_links
)
6489 printf (_("In linked file '%s': "), filedata
->file_name
);
6490 if (! filedata
->is_separate
|| process_links
)
6491 printf (ngettext ("There is %d section header, "
6492 "starting at offset 0x%lx:\n",
6493 "There are %d section headers, "
6494 "starting at offset 0x%lx:\n",
6495 filedata
->file_header
.e_shnum
),
6496 filedata
->file_header
.e_shnum
,
6497 (unsigned long) filedata
->file_header
.e_shoff
);
6502 if (! get_32bit_section_headers (filedata
, false))
6507 if (! get_64bit_section_headers (filedata
, false))
6511 /* Read in the string table, so that we have names to display. */
6512 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6513 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6515 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6517 if (section
->sh_size
!= 0)
6519 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6520 1, section
->sh_size
,
6523 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6527 /* Scan the sections for the dynamic symbol table
6528 and dynamic string table and debug sections. */
6529 eh_addr_size
= is_32bit_elf
? 4 : 8;
6530 switch (filedata
->file_header
.e_machine
)
6533 case EM_MIPS_RS3_LE
:
6534 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6535 FDE addresses. However, the ABI also has a semi-official ILP32
6536 variant for which the normal FDE address size rules apply.
6538 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6539 section, where XX is the size of longs in bits. Unfortunately,
6540 earlier compilers provided no way of distinguishing ILP32 objects
6541 from LP64 objects, so if there's any doubt, we should assume that
6542 the official LP64 form is being used. */
6543 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6544 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6550 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6552 case E_H8_MACH_H8300
:
6553 case E_H8_MACH_H8300HN
:
6554 case E_H8_MACH_H8300SN
:
6555 case E_H8_MACH_H8300SXN
:
6558 case E_H8_MACH_H8300H
:
6559 case E_H8_MACH_H8300S
:
6560 case E_H8_MACH_H8300SX
:
6568 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6570 case EF_M32C_CPU_M16C
:
6577 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6580 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6581 if (section->sh_entsize != expected_entsize) \
6584 sprintf_vma (buf, section->sh_entsize); \
6585 /* Note: coded this way so that there is a single string for \
6587 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6588 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6589 (unsigned) expected_entsize); \
6590 section->sh_entsize = expected_entsize; \
6595 #define CHECK_ENTSIZE(section, i, type) \
6596 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6597 sizeof (Elf64_External_##type))
6599 for (i
= 0, section
= filedata
->section_headers
;
6600 i
< filedata
->file_header
.e_shnum
;
6603 char * name
= SECTION_NAME_PRINT (section
);
6605 /* Run some sanity checks on the headers and
6606 possibly fill in some file data as well. */
6607 switch (section
->sh_type
)
6610 if (filedata
->dynamic_symbols
!= NULL
)
6612 error (_("File contains multiple dynamic symbol tables\n"));
6616 CHECK_ENTSIZE (section
, i
, Sym
);
6617 filedata
->dynamic_symbols
6618 = GET_ELF_SYMBOLS (filedata
, section
, &filedata
->num_dynamic_syms
);
6619 filedata
->dynamic_symtab_section
= section
;
6623 if (streq (name
, ".dynstr"))
6625 if (filedata
->dynamic_strings
!= NULL
)
6627 error (_("File contains multiple dynamic string tables\n"));
6631 filedata
->dynamic_strings
6632 = (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6633 1, section
->sh_size
, _("dynamic strings"));
6634 filedata
->dynamic_strings_length
6635 = filedata
->dynamic_strings
== NULL
? 0 : section
->sh_size
;
6636 filedata
->dynamic_strtab_section
= section
;
6640 case SHT_SYMTAB_SHNDX
:
6642 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6644 entry
->hdr
= section
;
6645 entry
->next
= filedata
->symtab_shndx_list
;
6646 filedata
->symtab_shndx_list
= entry
;
6651 CHECK_ENTSIZE (section
, i
, Sym
);
6655 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6659 CHECK_ENTSIZE (section
, i
, Rel
);
6660 if (do_checks
&& section
->sh_size
== 0)
6661 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6665 CHECK_ENTSIZE (section
, i
, Rela
);
6666 if (do_checks
&& section
->sh_size
== 0)
6667 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6672 /* Having a zero sized section is not illegal according to the
6673 ELF standard, but it might be an indication that something
6674 is wrong. So issue a warning if we are running in lint mode. */
6675 if (do_checks
&& section
->sh_size
== 0)
6676 warn (_("Section '%s': has a size of zero - is this intended ?\n"), name
);
6683 if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6684 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6685 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6686 || do_debug_str
|| do_debug_str_offsets
|| do_debug_loc
6688 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6689 && (startswith (name
, ".debug_")
6690 || startswith (name
, ".zdebug_")))
6693 name
+= sizeof (".zdebug_") - 1;
6695 name
+= sizeof (".debug_") - 1;
6698 || (do_debug_info
&& startswith (name
, "info"))
6699 || (do_debug_info
&& startswith (name
, "types"))
6700 || (do_debug_abbrevs
&& startswith (name
, "abbrev"))
6701 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6702 || (do_debug_lines
&& startswith (name
, "line."))
6703 || (do_debug_pubnames
&& startswith (name
, "pubnames"))
6704 || (do_debug_pubtypes
&& startswith (name
, "pubtypes"))
6705 || (do_debug_pubnames
&& startswith (name
, "gnu_pubnames"))
6706 || (do_debug_pubtypes
&& startswith (name
, "gnu_pubtypes"))
6707 || (do_debug_aranges
&& startswith (name
, "aranges"))
6708 || (do_debug_ranges
&& startswith (name
, "ranges"))
6709 || (do_debug_ranges
&& startswith (name
, "rnglists"))
6710 || (do_debug_frames
&& startswith (name
, "frame"))
6711 || (do_debug_macinfo
&& startswith (name
, "macinfo"))
6712 || (do_debug_macinfo
&& startswith (name
, "macro"))
6713 || (do_debug_str
&& startswith (name
, "str"))
6714 || (do_debug_links
&& startswith (name
, "sup"))
6715 || (do_debug_str_offsets
&& startswith (name
, "str_offsets"))
6716 || (do_debug_loc
&& startswith (name
, "loc"))
6717 || (do_debug_loc
&& startswith (name
, "loclists"))
6718 || (do_debug_addr
&& startswith (name
, "addr"))
6719 || (do_debug_cu_index
&& startswith (name
, "cu_index"))
6720 || (do_debug_cu_index
&& startswith (name
, "tu_index"))
6722 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6724 /* Linkonce section to be combined with .debug_info at link time. */
6725 else if ((do_debugging
|| do_debug_info
)
6726 && startswith (name
, ".gnu.linkonce.wi."))
6727 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6728 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6729 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6730 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6731 || streq (name
, ".debug_names")))
6732 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6733 /* Trace sections for Itanium VMS. */
6734 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6735 || do_trace_aranges
)
6736 && startswith (name
, ".trace_"))
6738 name
+= sizeof (".trace_") - 1;
6741 || (do_trace_info
&& streq (name
, "info"))
6742 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6743 || (do_trace_aranges
&& streq (name
, "aranges"))
6745 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6747 else if ((do_debugging
|| do_debug_links
)
6748 && (startswith (name
, ".gnu_debuglink")
6749 || startswith (name
, ".gnu_debugaltlink")))
6750 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6756 if (filedata
->is_separate
&& ! process_links
)
6759 if (filedata
->is_separate
)
6760 printf (_("\nSection Headers in linked file '%s':\n"), filedata
->file_name
);
6761 else if (filedata
->file_header
.e_shnum
> 1)
6762 printf (_("\nSection Headers:\n"));
6764 printf (_("\nSection Header:\n"));
6768 if (do_section_details
)
6770 printf (_(" [Nr] Name\n"));
6771 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6775 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6779 if (do_section_details
)
6781 printf (_(" [Nr] Name\n"));
6782 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6786 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6790 if (do_section_details
)
6792 printf (_(" [Nr] Name\n"));
6793 printf (_(" Type Address Offset Link\n"));
6794 printf (_(" Size EntSize Info Align\n"));
6798 printf (_(" [Nr] Name Type Address Offset\n"));
6799 printf (_(" Size EntSize Flags Link Info Align\n"));
6803 if (do_section_details
)
6804 printf (_(" Flags\n"));
6806 for (i
= 0, section
= filedata
->section_headers
;
6807 i
< filedata
->file_header
.e_shnum
;
6810 /* Run some sanity checks on the section header. */
6812 /* Check the sh_link field. */
6813 switch (section
->sh_type
)
6817 if (section
->sh_link
== 0
6818 && (filedata
->file_header
.e_type
== ET_EXEC
6819 || filedata
->file_header
.e_type
== ET_DYN
))
6820 /* A dynamic relocation section where all entries use a
6821 zero symbol index need not specify a symtab section. */
6824 case SHT_SYMTAB_SHNDX
:
6828 case SHT_GNU_versym
:
6829 if (section
->sh_link
== 0
6830 || section
->sh_link
>= filedata
->file_header
.e_shnum
6831 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6832 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6833 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6834 i
, section
->sh_link
);
6840 case SHT_GNU_verneed
:
6841 case SHT_GNU_verdef
:
6842 case SHT_GNU_LIBLIST
:
6843 if (section
->sh_link
== 0
6844 || section
->sh_link
>= filedata
->file_header
.e_shnum
6845 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6846 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6847 i
, section
->sh_link
);
6850 case SHT_INIT_ARRAY
:
6851 case SHT_FINI_ARRAY
:
6852 case SHT_PREINIT_ARRAY
:
6853 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6854 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6855 i
, section
->sh_link
);
6859 /* FIXME: Add support for target specific section types. */
6860 #if 0 /* Currently we do not check other section types as there are too
6861 many special cases. Stab sections for example have a type
6862 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6864 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6865 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6866 i
, section
->sh_link
);
6871 /* Check the sh_info field. */
6872 switch (section
->sh_type
)
6876 if (section
->sh_info
== 0
6877 && (filedata
->file_header
.e_type
== ET_EXEC
6878 || filedata
->file_header
.e_type
== ET_DYN
))
6879 /* Dynamic relocations apply to segments, so they do not
6880 need to specify the section they relocate. */
6882 if (section
->sh_info
== 0
6883 || section
->sh_info
>= filedata
->file_header
.e_shnum
6884 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6885 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6886 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6887 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6888 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6889 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6890 /* FIXME: Are other section types valid ? */
6891 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6892 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6893 i
, section
->sh_info
);
6898 case SHT_SYMTAB_SHNDX
:
6899 case SHT_INIT_ARRAY
:
6900 case SHT_FINI_ARRAY
:
6901 case SHT_PREINIT_ARRAY
:
6902 if (section
->sh_info
!= 0)
6903 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6904 i
, section
->sh_info
);
6910 /* A symbol index - we assume that it is valid. */
6914 /* FIXME: Add support for target specific section types. */
6915 if (section
->sh_type
== SHT_NOBITS
)
6916 /* NOBITS section headers with non-zero sh_info fields can be
6917 created when a binary is stripped of everything but its debug
6918 information. The stripped sections have their headers
6919 preserved but their types set to SHT_NOBITS. So do not check
6920 this type of section. */
6922 else if (section
->sh_flags
& SHF_INFO_LINK
)
6924 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6925 warn (_("[%2u]: Expected link to another section in info field"), i
);
6927 else if (section
->sh_type
< SHT_LOOS
6928 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6929 && section
->sh_info
!= 0)
6930 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6931 i
, section
->sh_info
);
6935 /* Check the sh_size field. */
6936 if (section
->sh_size
> filedata
->file_size
6937 && section
->sh_type
!= SHT_NOBITS
6938 && section
->sh_type
!= SHT_NULL
6939 && section
->sh_type
< SHT_LOOS
)
6940 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6942 printf (" [%2u] ", i
);
6943 if (do_section_details
)
6944 printf ("%s\n ", printable_section_name (filedata
, section
));
6946 print_symbol (-17, SECTION_NAME_PRINT (section
));
6948 printf (do_wide
? " %-15s " : " %-15.15s ",
6949 get_section_type_name (filedata
, section
->sh_type
));
6953 const char * link_too_big
= NULL
;
6955 print_vma (section
->sh_addr
, LONG_HEX
);
6957 printf ( " %6.6lx %6.6lx %2.2lx",
6958 (unsigned long) section
->sh_offset
,
6959 (unsigned long) section
->sh_size
,
6960 (unsigned long) section
->sh_entsize
);
6962 if (do_section_details
)
6963 fputs (" ", stdout
);
6965 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6967 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6970 /* The sh_link value is out of range. Normally this indicates
6971 an error but it can have special values in Solaris binaries. */
6972 switch (filedata
->file_header
.e_machine
)
6979 case EM_OLD_SPARCV9
:
6980 case EM_SPARC32PLUS
:
6983 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6984 link_too_big
= "BEFORE";
6985 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6986 link_too_big
= "AFTER";
6993 if (do_section_details
)
6995 if (link_too_big
!= NULL
&& * link_too_big
)
6996 printf ("<%s> ", link_too_big
);
6998 printf ("%2u ", section
->sh_link
);
6999 printf ("%3u %2lu\n", section
->sh_info
,
7000 (unsigned long) section
->sh_addralign
);
7003 printf ("%2u %3u %2lu\n",
7006 (unsigned long) section
->sh_addralign
);
7008 if (link_too_big
&& ! * link_too_big
)
7009 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
7010 i
, section
->sh_link
);
7014 print_vma (section
->sh_addr
, LONG_HEX
);
7016 if ((long) section
->sh_offset
== section
->sh_offset
)
7017 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
7021 print_vma (section
->sh_offset
, LONG_HEX
);
7024 if ((unsigned long) section
->sh_size
== section
->sh_size
)
7025 printf (" %6.6lx", (unsigned long) section
->sh_size
);
7029 print_vma (section
->sh_size
, LONG_HEX
);
7032 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
7033 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
7037 print_vma (section
->sh_entsize
, LONG_HEX
);
7040 if (do_section_details
)
7041 fputs (" ", stdout
);
7043 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
7045 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
7047 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
7048 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
7051 print_vma (section
->sh_addralign
, DEC
);
7055 else if (do_section_details
)
7058 print_vma (section
->sh_addr
, LONG_HEX
);
7059 if ((long) section
->sh_offset
== section
->sh_offset
)
7060 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
7064 print_vma (section
->sh_offset
, LONG_HEX
);
7066 printf (" %u\n ", section
->sh_link
);
7067 print_vma (section
->sh_size
, LONG_HEX
);
7069 print_vma (section
->sh_entsize
, LONG_HEX
);
7071 printf (" %-16u %lu\n",
7073 (unsigned long) section
->sh_addralign
);
7078 print_vma (section
->sh_addr
, LONG_HEX
);
7079 if ((long) section
->sh_offset
== section
->sh_offset
)
7080 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
7084 print_vma (section
->sh_offset
, LONG_HEX
);
7087 print_vma (section
->sh_size
, LONG_HEX
);
7089 print_vma (section
->sh_entsize
, LONG_HEX
);
7091 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
7093 printf (" %2u %3u %lu\n",
7096 (unsigned long) section
->sh_addralign
);
7099 if (do_section_details
)
7101 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
7102 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
7104 /* Minimum section size is 12 bytes for 32-bit compression
7105 header + 12 bytes for compressed data header. */
7106 unsigned char buf
[24];
7108 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
7109 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
7110 sizeof (buf
), _("compression header")))
7112 Elf_Internal_Chdr chdr
;
7114 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
7115 printf (_(" [<corrupt>]\n"));
7118 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
7121 printf (_(" [<unknown>: 0x%x], "),
7123 print_vma (chdr
.ch_size
, LONG_HEX
);
7124 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
7131 if (!do_section_details
)
7133 /* The ordering of the letters shown here matches the ordering of the
7134 corresponding SHF_xxx values, and hence the order in which these
7135 letters will be displayed to the user. */
7136 printf (_("Key to Flags:\n\
7137 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
7138 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
7139 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
7140 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
7143 case ELFOSABI_FREEBSD
:
7144 printf (_("R (retain), "));
7147 printf (_("D (mbind), "));
7152 if (filedata
->file_header
.e_machine
== EM_X86_64
7153 || filedata
->file_header
.e_machine
== EM_L1OM
7154 || filedata
->file_header
.e_machine
== EM_K1OM
)
7155 printf (_("l (large), "));
7156 else if (filedata
->file_header
.e_machine
== EM_ARM
)
7157 printf (_("y (purecode), "));
7158 else if (filedata
->file_header
.e_machine
== EM_PPC
)
7159 printf (_("v (VLE), "));
7160 printf ("p (processor specific)\n");
7167 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
7168 Elf_Internal_Sym
**symtab
, unsigned long *nsyms
,
7169 char **strtab
, unsigned long *strtablen
)
7173 *symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, nsyms
);
7175 if (*symtab
== NULL
)
7178 if (symsec
->sh_link
!= 0)
7180 Elf_Internal_Shdr
*strsec
;
7182 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
7184 error (_("Bad sh_link in symbol table section\n"));
7191 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7193 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7194 1, strsec
->sh_size
, _("string table"));
7195 if (*strtab
== NULL
)
7202 *strtablen
= strsec
->sh_size
;
7208 get_group_flags (unsigned int flags
)
7210 static char buff
[128];
7214 else if (flags
== GRP_COMDAT
)
7217 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
7219 flags
& GRP_MASKOS
? _("<OS specific>") : "",
7220 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
7221 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
7222 ? _("<unknown>") : ""));
7228 process_section_groups (Filedata
* filedata
)
7230 Elf_Internal_Shdr
* section
;
7232 struct group
* group
;
7233 Elf_Internal_Shdr
* symtab_sec
;
7234 Elf_Internal_Shdr
* strtab_sec
;
7235 Elf_Internal_Sym
* symtab
;
7236 unsigned long num_syms
;
7240 /* Don't process section groups unless needed. */
7241 if (!do_unwind
&& !do_section_groups
)
7244 if (filedata
->file_header
.e_shnum
== 0)
7246 if (do_section_groups
)
7248 if (filedata
->is_separate
)
7249 printf (_("\nThere are no sections group in linked file '%s'.\n"),
7250 filedata
->file_name
);
7252 printf (_("\nThere are no section groups in this file.\n"));
7257 if (filedata
->section_headers
== NULL
)
7259 error (_("Section headers are not available!\n"));
7260 /* PR 13622: This can happen with a corrupt ELF header. */
7264 filedata
->section_headers_groups
7265 = (struct group
**) calloc (filedata
->file_header
.e_shnum
,
7266 sizeof (struct group
*));
7268 if (filedata
->section_headers_groups
== NULL
)
7270 error (_("Out of memory reading %u section group headers\n"),
7271 filedata
->file_header
.e_shnum
);
7275 /* Scan the sections for the group section. */
7276 filedata
->group_count
= 0;
7277 for (i
= 0, section
= filedata
->section_headers
;
7278 i
< filedata
->file_header
.e_shnum
;
7280 if (section
->sh_type
== SHT_GROUP
)
7281 filedata
->group_count
++;
7283 if (filedata
->group_count
== 0)
7285 if (do_section_groups
)
7287 if (filedata
->is_separate
)
7288 printf (_("\nThere are no section groups in linked file '%s'.\n"),
7289 filedata
->file_name
);
7291 printf (_("\nThere are no section groups in this file.\n"));
7297 filedata
->section_groups
= (struct group
*) calloc (filedata
->group_count
,
7298 sizeof (struct group
));
7300 if (filedata
->section_groups
== NULL
)
7302 error (_("Out of memory reading %lu groups\n"),
7303 (unsigned long) filedata
->group_count
);
7314 if (filedata
->is_separate
)
7315 printf (_("Section groups in linked file '%s'\n"), filedata
->file_name
);
7317 for (i
= 0, section
= filedata
->section_headers
, group
= filedata
->section_groups
;
7318 i
< filedata
->file_header
.e_shnum
;
7321 if (section
->sh_type
== SHT_GROUP
)
7323 const char * name
= printable_section_name (filedata
, section
);
7324 const char * group_name
;
7325 unsigned char * start
;
7326 unsigned char * indices
;
7327 unsigned int entry
, j
, size
;
7328 Elf_Internal_Shdr
* sec
;
7329 Elf_Internal_Sym
* sym
;
7331 /* Get the symbol table. */
7332 if (section
->sh_link
>= filedata
->file_header
.e_shnum
7333 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
7336 error (_("Bad sh_link in group section `%s'\n"), name
);
7340 if (symtab_sec
!= sec
)
7344 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
7349 error (_("Corrupt header in group section `%s'\n"), name
);
7353 if (section
->sh_info
>= num_syms
)
7355 error (_("Bad sh_info in group section `%s'\n"), name
);
7359 sym
= symtab
+ section
->sh_info
;
7361 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
7363 if (sym
->st_shndx
== 0
7364 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
7366 error (_("Bad sh_info in group section `%s'\n"), name
);
7370 group_name
= SECTION_NAME_PRINT (filedata
->section_headers
7379 /* Get the string table. */
7380 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
7388 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
7393 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
7394 1, strtab_sec
->sh_size
,
7396 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
7398 group_name
= sym
->st_name
< strtab_size
7399 ? strtab
+ sym
->st_name
: _("<corrupt>");
7402 /* PR 17531: file: loop. */
7403 if (section
->sh_entsize
> section
->sh_size
)
7405 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7406 printable_section_name (filedata
, section
),
7407 (unsigned long) section
->sh_entsize
,
7408 (unsigned long) section
->sh_size
);
7412 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
7413 1, section
->sh_size
,
7419 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
7420 entry
= byte_get (indices
, 4);
7423 if (do_section_groups
)
7425 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7426 get_group_flags (entry
), i
, name
, group_name
, size
);
7428 printf (_(" [Index] Name\n"));
7431 group
->group_index
= i
;
7433 for (j
= 0; j
< size
; j
++)
7435 struct group_list
* g
;
7437 entry
= byte_get (indices
, 4);
7440 if (entry
>= filedata
->file_header
.e_shnum
)
7442 static unsigned num_group_errors
= 0;
7444 if (num_group_errors
++ < 10)
7446 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7447 entry
, i
, filedata
->file_header
.e_shnum
- 1);
7448 if (num_group_errors
== 10)
7449 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7454 if (filedata
->section_headers_groups
[entry
] != NULL
)
7458 static unsigned num_errs
= 0;
7460 if (num_errs
++ < 10)
7462 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7464 filedata
->section_headers_groups
[entry
]->group_index
);
7466 warn (_("Further error messages about already contained group sections suppressed\n"));
7472 /* Intel C/C++ compiler may put section 0 in a
7473 section group. We just warn it the first time
7474 and ignore it afterwards. */
7475 static bool warned
= false;
7478 error (_("section 0 in group section [%5u]\n"),
7479 filedata
->section_headers_groups
[entry
]->group_index
);
7485 filedata
->section_headers_groups
[entry
] = group
;
7487 if (do_section_groups
)
7489 sec
= filedata
->section_headers
+ entry
;
7490 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7493 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7494 g
->section_index
= entry
;
7495 g
->next
= group
->root
;
7510 /* Data used to display dynamic fixups. */
7512 struct ia64_vms_dynfixup
7514 bfd_vma needed_ident
; /* Library ident number. */
7515 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7516 bfd_vma fixup_needed
; /* Index of the library. */
7517 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7518 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7521 /* Data used to display dynamic relocations. */
7523 struct ia64_vms_dynimgrela
7525 bfd_vma img_rela_cnt
; /* Number of relocations. */
7526 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7529 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7533 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7534 struct ia64_vms_dynfixup
* fixup
,
7535 const char * strtab
,
7536 unsigned int strtab_sz
)
7538 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7540 const char * lib_name
;
7542 imfs
= get_data (NULL
, filedata
,
7543 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
7544 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
7545 _("dynamic section image fixups"));
7549 if (fixup
->needed
< strtab_sz
)
7550 lib_name
= strtab
+ fixup
->needed
;
7553 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7554 (unsigned long) fixup
->needed
);
7558 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7559 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7561 (_("Seg Offset Type SymVec DataType\n"));
7563 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7568 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7569 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7570 type
= BYTE_GET (imfs
[i
].type
);
7571 rtype
= elf_ia64_reloc_type (type
);
7573 printf (" 0x%08x ", type
);
7575 printf (" %-32s ", rtype
);
7576 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7577 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7584 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7587 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7589 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7592 imrs
= get_data (NULL
, filedata
,
7593 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
7594 sizeof (*imrs
), imgrela
->img_rela_cnt
,
7595 _("dynamic section image relocations"));
7599 printf (_("\nImage relocs\n"));
7601 (_("Seg Offset Type Addend Seg Sym Off\n"));
7603 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7608 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7609 printf ("%08" BFD_VMA_FMT
"x ",
7610 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7611 type
= BYTE_GET (imrs
[i
].type
);
7612 rtype
= elf_ia64_reloc_type (type
);
7614 printf ("0x%08x ", type
);
7616 printf ("%-31s ", rtype
);
7617 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7618 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7619 printf ("%08" BFD_VMA_FMT
"x\n",
7620 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7627 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7630 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7632 struct ia64_vms_dynfixup fixup
;
7633 struct ia64_vms_dynimgrela imgrela
;
7634 Elf_Internal_Dyn
*entry
;
7635 bfd_vma strtab_off
= 0;
7636 bfd_vma strtab_sz
= 0;
7637 char *strtab
= NULL
;
7640 memset (&fixup
, 0, sizeof (fixup
));
7641 memset (&imgrela
, 0, sizeof (imgrela
));
7643 /* Note: the order of the entries is specified by the OpenVMS specs. */
7644 for (entry
= filedata
->dynamic_section
;
7645 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
7648 switch (entry
->d_tag
)
7650 case DT_IA_64_VMS_STRTAB_OFFSET
:
7651 strtab_off
= entry
->d_un
.d_val
;
7654 strtab_sz
= entry
->d_un
.d_val
;
7656 strtab
= get_data (NULL
, filedata
,
7657 filedata
->dynamic_addr
+ strtab_off
,
7658 1, strtab_sz
, _("dynamic string section"));
7663 case DT_IA_64_VMS_NEEDED_IDENT
:
7664 fixup
.needed_ident
= entry
->d_un
.d_val
;
7667 fixup
.needed
= entry
->d_un
.d_val
;
7669 case DT_IA_64_VMS_FIXUP_NEEDED
:
7670 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7672 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7673 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7675 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7676 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7677 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7680 case DT_IA_64_VMS_IMG_RELA_CNT
:
7681 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7683 case DT_IA_64_VMS_IMG_RELA_OFF
:
7684 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7685 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7706 dynamic_relocations
[] =
7708 { "REL", DT_REL
, DT_RELSZ
, false },
7709 { "RELA", DT_RELA
, DT_RELASZ
, true },
7710 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7713 /* Process the reloc section. */
7716 process_relocs (Filedata
* filedata
)
7718 unsigned long rel_size
;
7719 unsigned long rel_offset
;
7724 if (do_using_dynamic
)
7728 bool has_dynamic_reloc
;
7731 has_dynamic_reloc
= false;
7733 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7735 is_rela
= dynamic_relocations
[i
].rela
;
7736 name
= dynamic_relocations
[i
].name
;
7737 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
7738 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
7741 has_dynamic_reloc
= true;
7743 if (is_rela
== UNKNOWN
)
7745 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7746 switch (filedata
->dynamic_info
[DT_PLTREL
])
7759 if (filedata
->is_separate
)
7761 (_("\nIn linked file '%s' section '%s' at offset 0x%lx contains %ld bytes:\n"),
7762 filedata
->file_name
, name
, rel_offset
, rel_size
);
7765 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7766 name
, rel_offset
, rel_size
);
7768 dump_relocations (filedata
,
7769 offset_from_vma (filedata
, rel_offset
, rel_size
),
7771 filedata
->dynamic_symbols
,
7772 filedata
->num_dynamic_syms
,
7773 filedata
->dynamic_strings
,
7774 filedata
->dynamic_strings_length
,
7775 is_rela
, true /* is_dynamic */);
7779 if (is_ia64_vms (filedata
))
7780 if (process_ia64_vms_dynamic_relocs (filedata
))
7781 has_dynamic_reloc
= true;
7783 if (! has_dynamic_reloc
)
7785 if (filedata
->is_separate
)
7786 printf (_("\nThere are no dynamic relocations in linked file '%s'.\n"),
7787 filedata
->file_name
);
7789 printf (_("\nThere are no dynamic relocations in this file.\n"));
7794 Elf_Internal_Shdr
* section
;
7798 for (i
= 0, section
= filedata
->section_headers
;
7799 i
< filedata
->file_header
.e_shnum
;
7802 if ( section
->sh_type
!= SHT_RELA
7803 && section
->sh_type
!= SHT_REL
)
7806 rel_offset
= section
->sh_offset
;
7807 rel_size
= section
->sh_size
;
7812 unsigned long num_rela
;
7814 if (filedata
->is_separate
)
7815 printf (_("\nIn linked file '%s' relocation section "),
7816 filedata
->file_name
);
7818 printf (_("\nRelocation section "));
7820 if (filedata
->string_table
== NULL
)
7821 printf ("%d", section
->sh_name
);
7823 printf ("'%s'", printable_section_name (filedata
, section
));
7825 num_rela
= rel_size
/ section
->sh_entsize
;
7826 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7827 " at offset 0x%lx contains %lu entries:\n",
7829 rel_offset
, num_rela
);
7831 is_rela
= section
->sh_type
== SHT_RELA
;
7833 if (section
->sh_link
!= 0
7834 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7836 Elf_Internal_Shdr
* symsec
;
7837 Elf_Internal_Sym
* symtab
;
7838 unsigned long nsyms
;
7839 unsigned long strtablen
= 0;
7840 char * strtab
= NULL
;
7842 symsec
= filedata
->section_headers
+ section
->sh_link
;
7843 if (symsec
->sh_type
!= SHT_SYMTAB
7844 && symsec
->sh_type
!= SHT_DYNSYM
)
7847 if (!get_symtab (filedata
, symsec
,
7848 &symtab
, &nsyms
, &strtab
, &strtablen
))
7851 dump_relocations (filedata
, rel_offset
, rel_size
,
7852 symtab
, nsyms
, strtab
, strtablen
,
7854 symsec
->sh_type
== SHT_DYNSYM
);
7859 dump_relocations (filedata
, rel_offset
, rel_size
,
7860 NULL
, 0, NULL
, 0, is_rela
,
7861 false /* is_dynamic */);
7869 /* Users sometimes forget the -D option, so try to be helpful. */
7870 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7872 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
7874 if (filedata
->is_separate
)
7875 printf (_("\nThere are no static relocations in linked file '%s'."),
7876 filedata
->file_name
);
7878 printf (_("\nThere are no static relocations in this file."));
7879 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7884 if (i
== ARRAY_SIZE (dynamic_relocations
))
7886 if (filedata
->is_separate
)
7887 printf (_("\nThere are no relocations in linked file '%s'.\n"),
7888 filedata
->file_name
);
7890 printf (_("\nThere are no relocations in this file.\n"));
7898 /* An absolute address consists of a section and an offset. If the
7899 section is NULL, the offset itself is the address, otherwise, the
7900 address equals to LOAD_ADDRESS(section) + offset. */
7904 unsigned short section
;
7908 /* Find the nearest symbol at or below ADDR. Returns the symbol
7909 name, if found, and the offset from the symbol to ADDR. */
7912 find_symbol_for_address (Filedata
* filedata
,
7913 Elf_Internal_Sym
* symtab
,
7914 unsigned long nsyms
,
7915 const char * strtab
,
7916 unsigned long strtab_size
,
7917 struct absaddr addr
,
7918 const char ** symname
,
7921 bfd_vma dist
= 0x100000;
7922 Elf_Internal_Sym
* sym
;
7923 Elf_Internal_Sym
* beg
;
7924 Elf_Internal_Sym
* end
;
7925 Elf_Internal_Sym
* best
= NULL
;
7927 REMOVE_ARCH_BITS (addr
.offset
);
7929 end
= symtab
+ nsyms
;
7935 sym
= beg
+ (end
- beg
) / 2;
7937 value
= sym
->st_value
;
7938 REMOVE_ARCH_BITS (value
);
7940 if (sym
->st_name
!= 0
7941 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7942 && addr
.offset
>= value
7943 && addr
.offset
- value
< dist
)
7946 dist
= addr
.offset
- value
;
7951 if (addr
.offset
< value
)
7959 *symname
= (best
->st_name
>= strtab_size
7960 ? _("<corrupt>") : strtab
+ best
->st_name
);
7966 *offset
= addr
.offset
;
7969 static /* signed */ int
7970 symcmp (const void *p
, const void *q
)
7972 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7973 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7975 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7978 /* Process the unwind section. */
7980 #include "unwind-ia64.h"
7982 struct ia64_unw_table_entry
7984 struct absaddr start
;
7986 struct absaddr info
;
7989 struct ia64_unw_aux_info
7991 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7992 unsigned long table_len
; /* Length of unwind table. */
7993 unsigned char * info
; /* Unwind info. */
7994 unsigned long info_size
; /* Size of unwind info. */
7995 bfd_vma info_addr
; /* Starting address of unwind info. */
7996 bfd_vma seg_base
; /* Starting address of segment. */
7997 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7998 unsigned long nsyms
; /* Number of symbols. */
7999 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8000 unsigned long nfuns
; /* Number of entries in funtab. */
8001 char * strtab
; /* The string table. */
8002 unsigned long strtab_size
; /* Size of string table. */
8006 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
8008 struct ia64_unw_table_entry
* tp
;
8009 unsigned long j
, nfuns
;
8013 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8014 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8015 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8016 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8018 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8020 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8024 const unsigned char * dp
;
8025 const unsigned char * head
;
8026 const unsigned char * end
;
8027 const char * procname
;
8029 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8030 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
8032 fputs ("\n<", stdout
);
8036 fputs (procname
, stdout
);
8039 printf ("+%lx", (unsigned long) offset
);
8042 fputs (">: [", stdout
);
8043 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8044 fputc ('-', stdout
);
8045 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8046 printf ("], info at +0x%lx\n",
8047 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
8049 /* PR 17531: file: 86232b32. */
8050 if (aux
->info
== NULL
)
8053 offset
= tp
->info
.offset
;
8054 if (tp
->info
.section
)
8056 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
8058 warn (_("Invalid section %u in table entry %ld\n"),
8059 tp
->info
.section
, (long) (tp
- aux
->table
));
8063 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
8065 offset
-= aux
->info_addr
;
8066 /* PR 17531: file: 0997b4d1. */
8067 if (offset
>= aux
->info_size
8068 || aux
->info_size
- offset
< 8)
8070 warn (_("Invalid offset %lx in table entry %ld\n"),
8071 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
8076 head
= aux
->info
+ offset
;
8077 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
8079 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
8080 (unsigned) UNW_VER (stamp
),
8081 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
8082 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
8083 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
8084 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
8086 if (UNW_VER (stamp
) != 1)
8088 printf (_("\tUnknown version.\n"));
8093 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
8094 /* PR 17531: file: 16ceda89. */
8095 if (end
> aux
->info
+ aux
->info_size
)
8096 end
= aux
->info
+ aux
->info_size
;
8097 for (dp
= head
+ 8; dp
< end
;)
8098 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
8107 slurp_ia64_unwind_table (Filedata
* filedata
,
8108 struct ia64_unw_aux_info
* aux
,
8109 Elf_Internal_Shdr
* sec
)
8111 unsigned long size
, nrelas
, i
;
8112 Elf_Internal_Phdr
* seg
;
8113 struct ia64_unw_table_entry
* tep
;
8114 Elf_Internal_Shdr
* relsec
;
8115 Elf_Internal_Rela
* rela
;
8116 Elf_Internal_Rela
* rp
;
8117 unsigned char * table
;
8119 Elf_Internal_Sym
* sym
;
8120 const char * relname
;
8124 /* First, find the starting address of the segment that includes
8127 if (filedata
->file_header
.e_phnum
)
8129 if (! get_program_headers (filedata
))
8132 for (seg
= filedata
->program_headers
;
8133 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8136 if (seg
->p_type
!= PT_LOAD
)
8139 if (sec
->sh_addr
>= seg
->p_vaddr
8140 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8142 aux
->seg_base
= seg
->p_vaddr
;
8148 /* Second, build the unwind table from the contents of the unwind section: */
8149 size
= sec
->sh_size
;
8150 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8155 aux
->table_len
= size
/ (3 * eh_addr_size
);
8156 aux
->table
= (struct ia64_unw_table_entry
*)
8157 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
8160 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
8162 tep
->start
.section
= SHN_UNDEF
;
8163 tep
->end
.section
= SHN_UNDEF
;
8164 tep
->info
.section
= SHN_UNDEF
;
8165 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8166 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8167 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8168 tep
->start
.offset
+= aux
->seg_base
;
8169 tep
->end
.offset
+= aux
->seg_base
;
8170 tep
->info
.offset
+= aux
->seg_base
;
8174 /* Third, apply any relocations to the unwind table: */
8175 for (relsec
= filedata
->section_headers
;
8176 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8179 if (relsec
->sh_type
!= SHT_RELA
8180 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8181 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8184 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8193 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8195 unsigned int sym_ndx
;
8196 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8197 relname
= elf_ia64_reloc_type (r_type
);
8199 /* PR 17531: file: 9fa67536. */
8200 if (relname
== NULL
)
8202 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8206 if (! startswith (relname
, "R_IA64_SEGREL"))
8208 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8212 i
= rp
->r_offset
/ (3 * eh_addr_size
);
8214 /* PR 17531: file: 5bc8d9bf. */
8215 if (i
>= aux
->table_len
)
8217 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8221 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8222 if (sym_ndx
>= aux
->nsyms
)
8224 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8228 sym
= aux
->symtab
+ sym_ndx
;
8230 switch (rp
->r_offset
/ eh_addr_size
% 3)
8233 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8234 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
8237 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8238 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
8241 aux
->table
[i
].info
.section
= sym
->st_shndx
;
8242 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
8256 ia64_process_unwind (Filedata
* filedata
)
8258 Elf_Internal_Shdr
* sec
;
8259 Elf_Internal_Shdr
* unwsec
= NULL
;
8260 unsigned long i
, unwcount
= 0, unwstart
= 0;
8261 struct ia64_unw_aux_info aux
;
8264 memset (& aux
, 0, sizeof (aux
));
8266 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8268 if (sec
->sh_type
== SHT_SYMTAB
)
8272 error (_("Multiple symbol tables encountered\n"));
8278 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8279 &aux
.strtab
, &aux
.strtab_size
))
8282 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8287 printf (_("\nThere are no unwind sections in this file.\n"));
8289 while (unwcount
-- > 0)
8294 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
8295 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8296 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8301 /* We have already counted the number of SHT_IA64_UNWIND
8302 sections so the loop above should never fail. */
8303 assert (unwsec
!= NULL
);
8306 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
8308 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
8310 /* We need to find which section group it is in. */
8311 struct group_list
* g
;
8313 if (filedata
->section_headers_groups
== NULL
8314 || filedata
->section_headers_groups
[i
] == NULL
)
8315 i
= filedata
->file_header
.e_shnum
;
8318 g
= filedata
->section_headers_groups
[i
]->root
;
8320 for (; g
!= NULL
; g
= g
->next
)
8322 sec
= filedata
->section_headers
+ g
->section_index
;
8324 if (SECTION_NAME_VALID (sec
)
8325 && streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
8330 i
= filedata
->file_header
.e_shnum
;
8333 else if (SECTION_NAME_VALID (unwsec
)
8334 && startswith (SECTION_NAME (unwsec
),
8335 ELF_STRING_ia64_unwind_once
))
8337 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
8338 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
8339 suffix
= SECTION_NAME (unwsec
) + len
;
8340 for (i
= 0, sec
= filedata
->section_headers
;
8341 i
< filedata
->file_header
.e_shnum
;
8343 if (SECTION_NAME_VALID (sec
)
8344 && startswith (SECTION_NAME (sec
),
8345 ELF_STRING_ia64_unwind_info_once
)
8346 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8351 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
8352 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
8353 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
8354 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
8356 if (SECTION_NAME_VALID (unwsec
)
8357 && startswith (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
))
8358 suffix
= SECTION_NAME (unwsec
) + len
;
8359 for (i
= 0, sec
= filedata
->section_headers
;
8360 i
< filedata
->file_header
.e_shnum
;
8362 if (SECTION_NAME_VALID (sec
)
8363 && startswith (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
)
8364 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8368 if (i
== filedata
->file_header
.e_shnum
)
8370 printf (_("\nCould not find unwind info section for "));
8372 if (filedata
->string_table
== NULL
)
8373 printf ("%d", unwsec
->sh_name
);
8375 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8379 aux
.info_addr
= sec
->sh_addr
;
8380 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
8383 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
8385 printf (_("\nUnwind section "));
8387 if (filedata
->string_table
== NULL
)
8388 printf ("%d", unwsec
->sh_name
);
8390 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8392 printf (_(" at offset 0x%lx contains %lu entries:\n"),
8393 (unsigned long) unwsec
->sh_offset
,
8394 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
8396 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
8397 && aux
.table_len
> 0)
8398 dump_ia64_unwind (filedata
, & aux
);
8400 free ((char *) aux
.table
);
8401 free ((char *) aux
.info
);
8408 free ((char *) aux
.strtab
);
8413 struct hppa_unw_table_entry
8415 struct absaddr start
;
8417 unsigned int Cannot_unwind
:1; /* 0 */
8418 unsigned int Millicode
:1; /* 1 */
8419 unsigned int Millicode_save_sr0
:1; /* 2 */
8420 unsigned int Region_description
:2; /* 3..4 */
8421 unsigned int reserved1
:1; /* 5 */
8422 unsigned int Entry_SR
:1; /* 6 */
8423 unsigned int Entry_FR
:4; /* Number saved 7..10 */
8424 unsigned int Entry_GR
:5; /* Number saved 11..15 */
8425 unsigned int Args_stored
:1; /* 16 */
8426 unsigned int Variable_Frame
:1; /* 17 */
8427 unsigned int Separate_Package_Body
:1; /* 18 */
8428 unsigned int Frame_Extension_Millicode
:1; /* 19 */
8429 unsigned int Stack_Overflow_Check
:1; /* 20 */
8430 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
8431 unsigned int Ada_Region
:1; /* 22 */
8432 unsigned int cxx_info
:1; /* 23 */
8433 unsigned int cxx_try_catch
:1; /* 24 */
8434 unsigned int sched_entry_seq
:1; /* 25 */
8435 unsigned int reserved2
:1; /* 26 */
8436 unsigned int Save_SP
:1; /* 27 */
8437 unsigned int Save_RP
:1; /* 28 */
8438 unsigned int Save_MRP_in_frame
:1; /* 29 */
8439 unsigned int extn_ptr_defined
:1; /* 30 */
8440 unsigned int Cleanup_defined
:1; /* 31 */
8442 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
8443 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
8444 unsigned int Large_frame
:1; /* 2 */
8445 unsigned int Pseudo_SP_Set
:1; /* 3 */
8446 unsigned int reserved4
:1; /* 4 */
8447 unsigned int Total_frame_size
:27; /* 5..31 */
8450 struct hppa_unw_aux_info
8452 struct hppa_unw_table_entry
* table
; /* Unwind table. */
8453 unsigned long table_len
; /* Length of unwind table. */
8454 bfd_vma seg_base
; /* Starting address of segment. */
8455 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8456 unsigned long nsyms
; /* Number of symbols. */
8457 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8458 unsigned long nfuns
; /* Number of entries in funtab. */
8459 char * strtab
; /* The string table. */
8460 unsigned long strtab_size
; /* Size of string table. */
8464 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8466 struct hppa_unw_table_entry
* tp
;
8467 unsigned long j
, nfuns
;
8470 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8471 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8472 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8473 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8475 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8477 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8480 const char * procname
;
8482 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8483 aux
->strtab_size
, tp
->start
, &procname
,
8486 fputs ("\n<", stdout
);
8490 fputs (procname
, stdout
);
8493 printf ("+%lx", (unsigned long) offset
);
8496 fputs (">: [", stdout
);
8497 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8498 fputc ('-', stdout
);
8499 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8502 #define PF(_m) if (tp->_m) printf (#_m " ");
8503 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8506 PF(Millicode_save_sr0
);
8507 /* PV(Region_description); */
8513 PF(Separate_Package_Body
);
8514 PF(Frame_Extension_Millicode
);
8515 PF(Stack_Overflow_Check
);
8516 PF(Two_Instruction_SP_Increment
);
8520 PF(sched_entry_seq
);
8523 PF(Save_MRP_in_frame
);
8524 PF(extn_ptr_defined
);
8525 PF(Cleanup_defined
);
8526 PF(MPE_XL_interrupt_marker
);
8527 PF(HP_UX_interrupt_marker
);
8530 PV(Total_frame_size
);
8543 slurp_hppa_unwind_table (Filedata
* filedata
,
8544 struct hppa_unw_aux_info
* aux
,
8545 Elf_Internal_Shdr
* sec
)
8547 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8548 Elf_Internal_Phdr
* seg
;
8549 struct hppa_unw_table_entry
* tep
;
8550 Elf_Internal_Shdr
* relsec
;
8551 Elf_Internal_Rela
* rela
;
8552 Elf_Internal_Rela
* rp
;
8553 unsigned char * table
;
8555 Elf_Internal_Sym
* sym
;
8556 const char * relname
;
8558 /* First, find the starting address of the segment that includes
8560 if (filedata
->file_header
.e_phnum
)
8562 if (! get_program_headers (filedata
))
8565 for (seg
= filedata
->program_headers
;
8566 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8569 if (seg
->p_type
!= PT_LOAD
)
8572 if (sec
->sh_addr
>= seg
->p_vaddr
8573 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8575 aux
->seg_base
= seg
->p_vaddr
;
8581 /* Second, build the unwind table from the contents of the unwind
8583 size
= sec
->sh_size
;
8584 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8590 nentries
= size
/ unw_ent_size
;
8591 size
= unw_ent_size
* nentries
;
8593 aux
->table_len
= nentries
;
8594 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8595 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8597 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8599 unsigned int tmp1
, tmp2
;
8601 tep
->start
.section
= SHN_UNDEF
;
8602 tep
->end
.section
= SHN_UNDEF
;
8604 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8605 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8606 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8607 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8609 tep
->start
.offset
+= aux
->seg_base
;
8610 tep
->end
.offset
+= aux
->seg_base
;
8612 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8613 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8614 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8615 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8616 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8617 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8618 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8619 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8620 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8621 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8622 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8623 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8624 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8625 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8626 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8627 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8628 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8629 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8630 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8631 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8632 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8633 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8634 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8635 tep
->Cleanup_defined
= tmp1
& 0x1;
8637 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8638 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8639 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8640 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8641 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8642 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8646 /* Third, apply any relocations to the unwind table. */
8647 for (relsec
= filedata
->section_headers
;
8648 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8651 if (relsec
->sh_type
!= SHT_RELA
8652 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8653 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8656 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8660 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8662 unsigned int sym_ndx
;
8663 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8664 relname
= elf_hppa_reloc_type (r_type
);
8666 if (relname
== NULL
)
8668 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8672 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8673 if (! startswith (relname
, "R_PARISC_SEGREL"))
8675 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8679 i
= rp
->r_offset
/ unw_ent_size
;
8680 if (i
>= aux
->table_len
)
8682 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8686 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8687 if (sym_ndx
>= aux
->nsyms
)
8689 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8693 sym
= aux
->symtab
+ sym_ndx
;
8695 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8698 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8699 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8702 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8703 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8717 hppa_process_unwind (Filedata
* filedata
)
8719 struct hppa_unw_aux_info aux
;
8720 Elf_Internal_Shdr
* unwsec
= NULL
;
8721 Elf_Internal_Shdr
* sec
;
8725 if (filedata
->string_table
== NULL
)
8728 memset (& aux
, 0, sizeof (aux
));
8730 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8732 if (sec
->sh_type
== SHT_SYMTAB
)
8736 error (_("Multiple symbol tables encountered\n"));
8742 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8743 &aux
.strtab
, &aux
.strtab_size
))
8746 else if (SECTION_NAME_VALID (sec
)
8747 && streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8752 printf (_("\nThere are no unwind sections in this file.\n"));
8754 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8756 if (SECTION_NAME_VALID (sec
)
8757 && streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8759 unsigned long num_unwind
= sec
->sh_size
/ 16;
8761 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8762 "contains %lu entry:\n",
8763 "\nUnwind section '%s' at offset 0x%lx "
8764 "contains %lu entries:\n",
8766 printable_section_name (filedata
, sec
),
8767 (unsigned long) sec
->sh_offset
,
8770 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8773 if (res
&& aux
.table_len
> 0)
8775 if (! dump_hppa_unwind (filedata
, &aux
))
8779 free ((char *) aux
.table
);
8785 free ((char *) aux
.strtab
);
8792 unsigned char * data
; /* The unwind data. */
8793 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8794 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8795 unsigned long nrelas
; /* The number of relocations. */
8796 unsigned int rel_type
; /* REL or RELA ? */
8797 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8800 struct arm_unw_aux_info
8802 Filedata
* filedata
; /* The file containing the unwind sections. */
8803 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8804 unsigned long nsyms
; /* Number of symbols. */
8805 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8806 unsigned long nfuns
; /* Number of these symbols. */
8807 char * strtab
; /* The file's string table. */
8808 unsigned long strtab_size
; /* Size of string table. */
8812 arm_print_vma_and_name (Filedata
* filedata
,
8813 struct arm_unw_aux_info
* aux
,
8815 struct absaddr addr
)
8817 const char *procname
;
8820 if (addr
.section
== SHN_UNDEF
)
8823 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8824 aux
->strtab_size
, addr
, &procname
,
8827 print_vma (fn
, PREFIX_HEX
);
8831 fputs (" <", stdout
);
8832 fputs (procname
, stdout
);
8835 printf ("+0x%lx", (unsigned long) sym_offset
);
8836 fputc ('>', stdout
);
8843 arm_free_section (struct arm_section
*arm_sec
)
8845 free (arm_sec
->data
);
8846 free (arm_sec
->rela
);
8849 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8850 cached section and install SEC instead.
8851 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8852 and return its valued in * WORDP, relocating if necessary.
8853 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8854 relocation's offset in ADDR.
8855 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8856 into the string table of the symbol associated with the reloc. If no
8857 reloc was applied store -1 there.
8858 5) Return TRUE upon success, FALSE otherwise. */
8861 get_unwind_section_word (Filedata
* filedata
,
8862 struct arm_unw_aux_info
* aux
,
8863 struct arm_section
* arm_sec
,
8864 Elf_Internal_Shdr
* sec
,
8865 bfd_vma word_offset
,
8866 unsigned int * wordp
,
8867 struct absaddr
* addr
,
8870 Elf_Internal_Rela
*rp
;
8871 Elf_Internal_Sym
*sym
;
8872 const char * relname
;
8876 if (sec
== NULL
|| arm_sec
== NULL
)
8879 addr
->section
= SHN_UNDEF
;
8882 if (sym_name
!= NULL
)
8883 *sym_name
= (bfd_vma
) -1;
8885 /* If necessary, update the section cache. */
8886 if (sec
!= arm_sec
->sec
)
8888 Elf_Internal_Shdr
*relsec
;
8890 arm_free_section (arm_sec
);
8893 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8894 sec
->sh_size
, _("unwind data"));
8895 arm_sec
->rela
= NULL
;
8896 arm_sec
->nrelas
= 0;
8898 for (relsec
= filedata
->section_headers
;
8899 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8902 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8903 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8904 /* PR 15745: Check the section type as well. */
8905 || (relsec
->sh_type
!= SHT_REL
8906 && relsec
->sh_type
!= SHT_RELA
))
8909 arm_sec
->rel_type
= relsec
->sh_type
;
8910 if (relsec
->sh_type
== SHT_REL
)
8912 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8914 & arm_sec
->rela
, & arm_sec
->nrelas
))
8917 else /* relsec->sh_type == SHT_RELA */
8919 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8921 & arm_sec
->rela
, & arm_sec
->nrelas
))
8927 arm_sec
->next_rela
= arm_sec
->rela
;
8930 /* If there is no unwind data we can do nothing. */
8931 if (arm_sec
->data
== NULL
)
8934 /* If the offset is invalid then fail. */
8935 if (/* PR 21343 *//* PR 18879 */
8937 || word_offset
> (sec
->sh_size
- 4)
8938 || ((bfd_signed_vma
) word_offset
) < 0)
8941 /* Get the word at the required offset. */
8942 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8944 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8945 if (arm_sec
->rela
== NULL
)
8951 /* Look through the relocs to find the one that applies to the provided offset. */
8953 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8955 bfd_vma prelval
, offset
;
8957 if (rp
->r_offset
> word_offset
&& !wrapped
)
8962 if (rp
->r_offset
> word_offset
)
8965 if (rp
->r_offset
& 3)
8967 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8968 (unsigned long) rp
->r_offset
);
8972 if (rp
->r_offset
< word_offset
)
8975 /* PR 17531: file: 027-161405-0.004 */
8976 if (aux
->symtab
== NULL
)
8979 if (arm_sec
->rel_type
== SHT_REL
)
8981 offset
= word
& 0x7fffffff;
8982 if (offset
& 0x40000000)
8983 offset
|= ~ (bfd_vma
) 0x7fffffff;
8985 else if (arm_sec
->rel_type
== SHT_RELA
)
8986 offset
= rp
->r_addend
;
8989 error (_("Unknown section relocation type %d encountered\n"),
8994 /* PR 17531 file: 027-1241568-0.004. */
8995 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8997 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8998 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
9002 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
9003 offset
+= sym
->st_value
;
9004 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
9006 /* Check that we are processing the expected reloc type. */
9007 if (filedata
->file_header
.e_machine
== EM_ARM
)
9009 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
9010 if (relname
== NULL
)
9012 warn (_("Skipping unknown ARM relocation type: %d\n"),
9013 (int) ELF32_R_TYPE (rp
->r_info
));
9017 if (streq (relname
, "R_ARM_NONE"))
9020 if (! streq (relname
, "R_ARM_PREL31"))
9022 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
9026 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9028 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
9029 if (relname
== NULL
)
9031 warn (_("Skipping unknown C6000 relocation type: %d\n"),
9032 (int) ELF32_R_TYPE (rp
->r_info
));
9036 if (streq (relname
, "R_C6000_NONE"))
9039 if (! streq (relname
, "R_C6000_PREL31"))
9041 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
9049 /* This function currently only supports ARM and TI unwinders. */
9050 warn (_("Only TI and ARM unwinders are currently supported\n"));
9054 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
9055 addr
->section
= sym
->st_shndx
;
9056 addr
->offset
= offset
;
9059 * sym_name
= sym
->st_name
;
9064 arm_sec
->next_rela
= rp
;
9069 static const char *tic6x_unwind_regnames
[16] =
9071 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
9072 "A14", "A13", "A12", "A11", "A10",
9073 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
9077 decode_tic6x_unwind_regmask (unsigned int mask
)
9081 for (i
= 12; mask
; mask
>>= 1, i
--)
9085 fputs (tic6x_unwind_regnames
[i
], stdout
);
9087 fputs (", ", stdout
);
9093 if (remaining == 0 && more_words) \
9096 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
9097 data_offset, & word, & addr, NULL)) \
9103 #define GET_OP(OP) \
9108 (OP) = word >> 24; \
9113 printf (_("[Truncated opcode]\n")); \
9116 printf ("0x%02x ", OP)
9119 decode_arm_unwind_bytecode (Filedata
* filedata
,
9120 struct arm_unw_aux_info
* aux
,
9122 unsigned int remaining
,
9123 unsigned int more_words
,
9124 bfd_vma data_offset
,
9125 Elf_Internal_Shdr
* data_sec
,
9126 struct arm_section
* data_arm_sec
)
9128 struct absaddr addr
;
9131 /* Decode the unwinding instructions. */
9134 unsigned int op
, op2
;
9143 printf (" 0x%02x ", op
);
9145 if ((op
& 0xc0) == 0x00)
9147 int offset
= ((op
& 0x3f) << 2) + 4;
9149 printf (" vsp = vsp + %d", offset
);
9151 else if ((op
& 0xc0) == 0x40)
9153 int offset
= ((op
& 0x3f) << 2) + 4;
9155 printf (" vsp = vsp - %d", offset
);
9157 else if ((op
& 0xf0) == 0x80)
9160 if (op
== 0x80 && op2
== 0)
9161 printf (_("Refuse to unwind"));
9164 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
9169 for (i
= 0; i
< 12; i
++)
9170 if (mask
& (1 << i
))
9176 printf ("r%d", 4 + i
);
9181 else if ((op
& 0xf0) == 0x90)
9183 if (op
== 0x9d || op
== 0x9f)
9184 printf (_(" [Reserved]"));
9186 printf (" vsp = r%d", op
& 0x0f);
9188 else if ((op
& 0xf0) == 0xa0)
9190 int end
= 4 + (op
& 0x07);
9195 for (i
= 4; i
<= end
; i
++)
9211 else if (op
== 0xb0)
9212 printf (_(" finish"));
9213 else if (op
== 0xb1)
9216 if (op2
== 0 || (op2
& 0xf0) != 0)
9217 printf (_("[Spare]"));
9220 unsigned int mask
= op2
& 0x0f;
9225 for (i
= 0; i
< 12; i
++)
9226 if (mask
& (1 << i
))
9237 else if (op
== 0xb2)
9239 unsigned char buf
[9];
9240 unsigned int i
, len
;
9241 unsigned long offset
;
9243 for (i
= 0; i
< sizeof (buf
); i
++)
9246 if ((buf
[i
] & 0x80) == 0)
9249 if (i
== sizeof (buf
))
9251 error (_("corrupt change to vsp\n"));
9256 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
9257 assert (len
== i
+ 1);
9258 offset
= offset
* 4 + 0x204;
9259 printf ("vsp = vsp + %ld", offset
);
9262 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
9264 unsigned int first
, last
;
9271 printf ("pop {D%d", first
);
9273 printf ("-D%d", first
+ last
);
9276 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
9278 unsigned int count
= op
& 0x07;
9282 printf ("-D%d", 8 + count
);
9285 else if (op
>= 0xc0 && op
<= 0xc5)
9287 unsigned int count
= op
& 0x07;
9289 printf (" pop {wR10");
9291 printf ("-wR%d", 10 + count
);
9294 else if (op
== 0xc6)
9296 unsigned int first
, last
;
9301 printf ("pop {wR%d", first
);
9303 printf ("-wR%d", first
+ last
);
9306 else if (op
== 0xc7)
9309 if (op2
== 0 || (op2
& 0xf0) != 0)
9310 printf (_("[Spare]"));
9313 unsigned int mask
= op2
& 0x0f;
9318 for (i
= 0; i
< 4; i
++)
9319 if (mask
& (1 << i
))
9325 printf ("wCGR%d", i
);
9332 printf (_(" [unsupported opcode]"));
9343 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
9344 struct arm_unw_aux_info
* aux
,
9346 unsigned int remaining
,
9347 unsigned int more_words
,
9348 bfd_vma data_offset
,
9349 Elf_Internal_Shdr
* data_sec
,
9350 struct arm_section
* data_arm_sec
)
9352 struct absaddr addr
;
9354 /* Decode the unwinding instructions. */
9357 unsigned int op
, op2
;
9366 printf (" 0x%02x ", op
);
9368 if ((op
& 0xc0) == 0x00)
9370 int offset
= ((op
& 0x3f) << 3) + 8;
9371 printf (" sp = sp + %d", offset
);
9373 else if ((op
& 0xc0) == 0x80)
9376 if (op
== 0x80 && op2
== 0)
9377 printf (_("Refuse to unwind"));
9380 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
9382 printf ("pop compact {");
9386 decode_tic6x_unwind_regmask (mask
);
9390 else if ((op
& 0xf0) == 0xc0)
9398 unsigned int offset
;
9402 /* Scan entire instruction first so that GET_OP output is not
9403 interleaved with disassembly. */
9405 for (i
= 0; nregs
< (op
& 0xf); i
++)
9411 regpos
[nregs
].offset
= i
* 2;
9412 regpos
[nregs
].reg
= reg
;
9419 regpos
[nregs
].offset
= i
* 2 + 1;
9420 regpos
[nregs
].reg
= reg
;
9425 printf (_("pop frame {"));
9428 printf (_("*corrupt* - no registers specified"));
9433 for (i
= i
* 2; i
> 0; i
--)
9435 if (regpos
[reg
].offset
== i
- 1)
9437 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
9444 fputs (name
, stdout
);
9452 else if (op
== 0xd0)
9453 printf (" MOV FP, SP");
9454 else if (op
== 0xd1)
9455 printf (" __c6xabi_pop_rts");
9456 else if (op
== 0xd2)
9458 unsigned char buf
[9];
9459 unsigned int i
, len
;
9460 unsigned long offset
;
9462 for (i
= 0; i
< sizeof (buf
); i
++)
9465 if ((buf
[i
] & 0x80) == 0)
9468 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9469 if (i
== sizeof (buf
))
9471 warn (_("Corrupt stack pointer adjustment detected\n"));
9475 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
9476 assert (len
== i
+ 1);
9477 offset
= offset
* 8 + 0x408;
9478 printf (_("sp = sp + %ld"), offset
);
9480 else if ((op
& 0xf0) == 0xe0)
9482 if ((op
& 0x0f) == 7)
9485 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9489 printf (_(" [unsupported opcode]"));
9498 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9502 offset
= word
& 0x7fffffff;
9503 if (offset
& 0x40000000)
9504 offset
|= ~ (bfd_vma
) 0x7fffffff;
9506 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9509 return offset
+ where
;
9513 decode_arm_unwind (Filedata
* filedata
,
9514 struct arm_unw_aux_info
* aux
,
9516 unsigned int remaining
,
9517 bfd_vma data_offset
,
9518 Elf_Internal_Shdr
* data_sec
,
9519 struct arm_section
* data_arm_sec
)
9522 unsigned int more_words
= 0;
9523 struct absaddr addr
;
9524 bfd_vma sym_name
= (bfd_vma
) -1;
9529 /* Fetch the first word.
9530 Note - when decoding an object file the address extracted
9531 here will always be 0. So we also pass in the sym_name
9532 parameter so that we can find the symbol associated with
9533 the personality routine. */
9534 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9535 & word
, & addr
, & sym_name
))
9542 addr
.section
= SHN_UNDEF
;
9546 if ((word
& 0x80000000) == 0)
9548 /* Expand prel31 for personality routine. */
9550 const char *procname
;
9552 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9553 printf (_(" Personality routine: "));
9555 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9556 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9558 procname
= aux
->strtab
+ sym_name
;
9559 print_vma (fn
, PREFIX_HEX
);
9562 fputs (" <", stdout
);
9563 fputs (procname
, stdout
);
9564 fputc ('>', stdout
);
9568 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9569 fputc ('\n', stdout
);
9571 /* The GCC personality routines use the standard compact
9572 encoding, starting with one byte giving the number of
9574 if (procname
!= NULL
9575 && (startswith (procname
, "__gcc_personality_v0")
9576 || startswith (procname
, "__gxx_personality_v0")
9577 || startswith (procname
, "__gcj_personality_v0")
9578 || startswith (procname
, "__gnu_objc_personality_v0")))
9585 printf (_(" [Truncated data]\n"));
9588 more_words
= word
>> 24;
9598 /* ARM EHABI Section 6.3:
9600 An exception-handling table entry for the compact model looks like:
9604 1 0 index Data for personalityRoutine[index] */
9606 if (filedata
->file_header
.e_machine
== EM_ARM
9607 && (word
& 0x70000000))
9609 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9613 per_index
= (word
>> 24) & 0x7f;
9614 printf (_(" Compact model index: %d\n"), per_index
);
9621 else if (per_index
< 3)
9623 more_words
= (word
>> 16) & 0xff;
9629 switch (filedata
->file_header
.e_machine
)
9634 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9635 data_offset
, data_sec
, data_arm_sec
))
9640 warn (_("Unknown ARM compact model index encountered\n"));
9641 printf (_(" [reserved]\n"));
9649 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9650 data_offset
, data_sec
, data_arm_sec
))
9653 else if (per_index
< 5)
9655 if (((word
>> 17) & 0x7f) == 0x7f)
9656 printf (_(" Restore stack from frame pointer\n"));
9658 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9659 printf (_(" Registers restored: "));
9661 printf (" (compact) ");
9662 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9664 printf (_(" Return register: %s\n"),
9665 tic6x_unwind_regnames
[word
& 0xf]);
9668 printf (_(" [reserved (%d)]\n"), per_index
);
9672 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9673 filedata
->file_header
.e_machine
);
9677 /* Decode the descriptors. Not implemented. */
9683 dump_arm_unwind (Filedata
* filedata
,
9684 struct arm_unw_aux_info
* aux
,
9685 Elf_Internal_Shdr
* exidx_sec
)
9687 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9688 unsigned int i
, exidx_len
;
9689 unsigned long j
, nfuns
;
9692 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9693 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9694 exidx_len
= exidx_sec
->sh_size
/ 8;
9696 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9697 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9698 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9699 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9701 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9703 for (i
= 0; i
< exidx_len
; i
++)
9705 unsigned int exidx_fn
, exidx_entry
;
9706 struct absaddr fn_addr
, entry_addr
;
9709 fputc ('\n', stdout
);
9711 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9712 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9713 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9714 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9717 arm_free_section (& exidx_arm_sec
);
9718 arm_free_section (& extab_arm_sec
);
9722 /* ARM EHABI, Section 5:
9723 An index table entry consists of 2 words.
9724 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9725 if (exidx_fn
& 0x80000000)
9727 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9731 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9733 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9734 fputs (": ", stdout
);
9736 if (exidx_entry
== 1)
9738 print_vma (exidx_entry
, PREFIX_HEX
);
9739 fputs (" [cantunwind]\n", stdout
);
9741 else if (exidx_entry
& 0x80000000)
9743 print_vma (exidx_entry
, PREFIX_HEX
);
9744 fputc ('\n', stdout
);
9745 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9749 bfd_vma table
, table_offset
= 0;
9750 Elf_Internal_Shdr
*table_sec
;
9752 fputs ("@", stdout
);
9753 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9754 print_vma (table
, PREFIX_HEX
);
9757 /* Locate the matching .ARM.extab. */
9758 if (entry_addr
.section
!= SHN_UNDEF
9759 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9761 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9762 table_offset
= entry_addr
.offset
;
9764 if (table_offset
> table_sec
->sh_size
9765 || ((bfd_signed_vma
) table_offset
) < 0)
9767 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9768 (unsigned long) table_offset
,
9769 printable_section_name (filedata
, table_sec
));
9776 table_sec
= find_section_by_address (filedata
, table
);
9777 if (table_sec
!= NULL
)
9778 table_offset
= table
- table_sec
->sh_addr
;
9781 if (table_sec
== NULL
)
9783 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9784 (unsigned long) table
);
9789 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9798 arm_free_section (&exidx_arm_sec
);
9799 arm_free_section (&extab_arm_sec
);
9804 /* Used for both ARM and C6X unwinding tables. */
9807 arm_process_unwind (Filedata
* filedata
)
9809 struct arm_unw_aux_info aux
;
9810 Elf_Internal_Shdr
*unwsec
= NULL
;
9811 Elf_Internal_Shdr
*sec
;
9813 unsigned int sec_type
;
9816 switch (filedata
->file_header
.e_machine
)
9819 sec_type
= SHT_ARM_EXIDX
;
9823 sec_type
= SHT_C6000_UNWIND
;
9827 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9828 filedata
->file_header
.e_machine
);
9832 if (filedata
->string_table
== NULL
)
9835 memset (& aux
, 0, sizeof (aux
));
9836 aux
.filedata
= filedata
;
9838 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9840 if (sec
->sh_type
== SHT_SYMTAB
)
9844 error (_("Multiple symbol tables encountered\n"));
9850 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9851 &aux
.strtab
, &aux
.strtab_size
))
9854 else if (sec
->sh_type
== sec_type
)
9859 printf (_("\nThere are no unwind sections in this file.\n"));
9861 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9863 if (sec
->sh_type
== sec_type
)
9865 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9866 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9867 "contains %lu entry:\n",
9868 "\nUnwind section '%s' at offset 0x%lx "
9869 "contains %lu entries:\n",
9871 printable_section_name (filedata
, sec
),
9872 (unsigned long) sec
->sh_offset
,
9875 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9881 free ((char *) aux
.strtab
);
9887 no_processor_specific_unwind (Filedata
* filedata ATTRIBUTE_UNUSED
)
9889 printf (_("No processor specific unwind information to decode\n"));
9894 process_unwind (Filedata
* filedata
)
9896 struct unwind_handler
9898 unsigned int machtype
;
9899 bool (* handler
)(Filedata
*);
9902 { EM_ARM
, arm_process_unwind
},
9903 { EM_IA_64
, ia64_process_unwind
},
9904 { EM_PARISC
, hppa_process_unwind
},
9905 { EM_TI_C6000
, arm_process_unwind
},
9906 { EM_386
, no_processor_specific_unwind
},
9907 { EM_X86_64
, no_processor_specific_unwind
},
9915 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9916 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9917 return handlers
[i
].handler (filedata
);
9919 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9920 get_machine_name (filedata
->file_header
.e_machine
));
9925 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9927 switch (entry
->d_tag
)
9929 case DT_AARCH64_BTI_PLT
:
9930 case DT_AARCH64_PAC_PLT
:
9933 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9940 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
9942 switch (entry
->d_tag
)
9945 if (entry
->d_un
.d_val
== 0)
9949 static const char * opts
[] =
9951 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9952 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9953 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9954 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9960 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9961 if (entry
->d_un
.d_val
& (1 << cnt
))
9963 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9969 case DT_MIPS_IVERSION
:
9970 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
9971 printf (_("Interface Version: %s"),
9972 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
9976 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9977 /* Note: coded this way so that there is a single string for translation. */
9978 printf (_("<corrupt: %s>"), buf
);
9982 case DT_MIPS_TIME_STAMP
:
9986 time_t atime
= entry
->d_un
.d_val
;
9988 tmp
= gmtime (&atime
);
9989 /* PR 17531: file: 6accc532. */
9991 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9993 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9994 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9995 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9996 printf (_("Time Stamp: %s"), timebuf
);
10000 case DT_MIPS_RLD_VERSION
:
10001 case DT_MIPS_LOCAL_GOTNO
:
10002 case DT_MIPS_CONFLICTNO
:
10003 case DT_MIPS_LIBLISTNO
:
10004 case DT_MIPS_SYMTABNO
:
10005 case DT_MIPS_UNREFEXTNO
:
10006 case DT_MIPS_HIPAGENO
:
10007 case DT_MIPS_DELTA_CLASS_NO
:
10008 case DT_MIPS_DELTA_INSTANCE_NO
:
10009 case DT_MIPS_DELTA_RELOC_NO
:
10010 case DT_MIPS_DELTA_SYM_NO
:
10011 case DT_MIPS_DELTA_CLASSSYM_NO
:
10012 case DT_MIPS_COMPACT_SIZE
:
10013 print_vma (entry
->d_un
.d_val
, DEC
);
10016 case DT_MIPS_XHASH
:
10017 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10018 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10019 /* Falls through. */
10022 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10028 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
10030 switch (entry
->d_tag
)
10032 case DT_HP_DLD_FLAGS
:
10041 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
10042 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
10043 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
10044 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
10045 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
10046 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
10047 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
10048 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
10049 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
10050 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
10051 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
10052 { DT_HP_GST
, "HP_GST" },
10053 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
10054 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
10055 { DT_HP_NODELETE
, "HP_NODELETE" },
10056 { DT_HP_GROUP
, "HP_GROUP" },
10057 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
10061 bfd_vma val
= entry
->d_un
.d_val
;
10063 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
10064 if (val
& flags
[cnt
].bit
)
10068 fputs (flags
[cnt
].str
, stdout
);
10070 val
^= flags
[cnt
].bit
;
10073 if (val
!= 0 || first
)
10077 print_vma (val
, HEX
);
10083 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10091 /* VMS vs Unix time offset and factor. */
10093 #define VMS_EPOCH_OFFSET 35067168000000000LL
10094 #define VMS_GRANULARITY_FACTOR 10000000
10096 #define INT64_MIN (-9223372036854775807LL - 1)
10099 /* Display a VMS time in a human readable format. */
10102 print_vms_time (bfd_int64_t vmstime
)
10104 struct tm
*tm
= NULL
;
10107 if (vmstime
>= INT64_MIN
+ VMS_EPOCH_OFFSET
)
10109 vmstime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
10111 if (unxtime
== vmstime
)
10112 tm
= gmtime (&unxtime
);
10115 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
10116 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
10117 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
10122 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
10124 switch (entry
->d_tag
)
10126 case DT_IA_64_PLT_RESERVE
:
10127 /* First 3 slots reserved. */
10128 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10130 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
10133 case DT_IA_64_VMS_LINKTIME
:
10135 print_vms_time (entry
->d_un
.d_val
);
10139 case DT_IA_64_VMS_LNKFLAGS
:
10140 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10141 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
10142 printf (" CALL_DEBUG");
10143 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
10144 printf (" NOP0BUFS");
10145 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
10146 printf (" P0IMAGE");
10147 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
10148 printf (" MKTHREADS");
10149 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
10150 printf (" UPCALLS");
10151 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
10152 printf (" IMGSTA");
10153 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
10154 printf (" INITIALIZE");
10155 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
10157 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
10158 printf (" EXE_INIT");
10159 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
10160 printf (" TBK_IN_IMG");
10161 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
10162 printf (" DBG_IN_IMG");
10163 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
10164 printf (" TBK_IN_DSF");
10165 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
10166 printf (" DBG_IN_DSF");
10167 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
10168 printf (" SIGNATURES");
10169 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
10170 printf (" REL_SEG_OFF");
10174 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10181 get_32bit_dynamic_section (Filedata
* filedata
)
10183 Elf32_External_Dyn
* edyn
;
10184 Elf32_External_Dyn
* ext
;
10185 Elf_Internal_Dyn
* entry
;
10187 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
10188 filedata
->dynamic_addr
, 1,
10189 filedata
->dynamic_size
,
10190 _("dynamic section"));
10194 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
10195 might not have the luxury of section headers. Look for the DT_NULL
10196 terminator to determine the number of entries. */
10197 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
10198 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
10201 filedata
->dynamic_nent
++;
10202 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
10206 filedata
->dynamic_section
10207 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
10208 if (filedata
->dynamic_section
== NULL
)
10210 error (_("Out of memory allocating space for %lu dynamic entries\n"),
10211 (unsigned long) filedata
->dynamic_nent
);
10216 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10217 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10220 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10221 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10230 get_64bit_dynamic_section (Filedata
* filedata
)
10232 Elf64_External_Dyn
* edyn
;
10233 Elf64_External_Dyn
* ext
;
10234 Elf_Internal_Dyn
* entry
;
10236 /* Read in the data. */
10237 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
10238 filedata
->dynamic_addr
, 1,
10239 filedata
->dynamic_size
,
10240 _("dynamic section"));
10244 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
10245 might not have the luxury of section headers. Look for the DT_NULL
10246 terminator to determine the number of entries. */
10247 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
10248 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
10249 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
10252 filedata
->dynamic_nent
++;
10253 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
10257 filedata
->dynamic_section
10258 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
10259 if (filedata
->dynamic_section
== NULL
)
10261 error (_("Out of memory allocating space for %lu dynamic entries\n"),
10262 (unsigned long) filedata
->dynamic_nent
);
10267 /* Convert from external to internal formats. */
10268 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10269 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10272 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10273 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10282 print_dynamic_flags (bfd_vma flags
)
10290 flag
= flags
& - flags
;
10296 putc (' ', stdout
);
10300 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
10301 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
10302 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
10303 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
10304 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
10305 default: fputs (_("unknown"), stdout
); break;
10312 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
10314 unsigned char * e_data
;
10317 /* If the size_t type is smaller than the bfd_size_type, eg because
10318 you are building a 32-bit tool on a 64-bit host, then make sure
10319 that when (number) is cast to (size_t) no information is lost. */
10320 if (sizeof (size_t) < sizeof (bfd_size_type
)
10321 && (bfd_size_type
) ((size_t) number
) != number
)
10323 error (_("Size truncation prevents reading %s elements of size %u\n"),
10324 bfd_vmatoa ("u", number
), ent_size
);
10328 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
10329 attempting to allocate memory when the read is bound to fail. */
10330 if (ent_size
* number
> filedata
->file_size
)
10332 error (_("Invalid number of dynamic entries: %s\n"),
10333 bfd_vmatoa ("u", number
));
10337 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10338 if (e_data
== NULL
)
10340 error (_("Out of memory reading %s dynamic entries\n"),
10341 bfd_vmatoa ("u", number
));
10345 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
10347 error (_("Unable to read in %s bytes of dynamic data\n"),
10348 bfd_vmatoa ("u", number
* ent_size
));
10353 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10354 if (i_data
== NULL
)
10356 error (_("Out of memory allocating space for %s dynamic entries\n"),
10357 bfd_vmatoa ("u", number
));
10363 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10370 static unsigned long
10371 get_num_dynamic_syms (Filedata
* filedata
)
10373 unsigned long num_of_syms
= 0;
10375 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
10376 return num_of_syms
;
10378 if (filedata
->dynamic_info
[DT_HASH
])
10380 unsigned char nb
[8];
10381 unsigned char nc
[8];
10382 unsigned int hash_ent_size
= 4;
10384 if ((filedata
->file_header
.e_machine
== EM_ALPHA
10385 || filedata
->file_header
.e_machine
== EM_S390
10386 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
10387 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10390 if (fseek (filedata
->handle
,
10391 (filedata
->archive_file_offset
10392 + offset_from_vma (filedata
, filedata
->dynamic_info
[DT_HASH
],
10393 sizeof nb
+ sizeof nc
)),
10396 error (_("Unable to seek to start of dynamic information\n"));
10400 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
10402 error (_("Failed to read in number of buckets\n"));
10406 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
10408 error (_("Failed to read in number of chains\n"));
10412 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
10413 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
10415 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
10417 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
10419 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
10422 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
10423 num_of_syms
= filedata
->nchains
;
10426 if (num_of_syms
== 0)
10428 free (filedata
->buckets
);
10429 filedata
->buckets
= NULL
;
10430 free (filedata
->chains
);
10431 filedata
->chains
= NULL
;
10432 filedata
->nbuckets
= 0;
10436 if (filedata
->dynamic_info_DT_GNU_HASH
)
10438 unsigned char nb
[16];
10439 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10440 bfd_vma buckets_vma
;
10443 if (fseek (filedata
->handle
,
10444 (filedata
->archive_file_offset
10445 + offset_from_vma (filedata
,
10446 filedata
->dynamic_info_DT_GNU_HASH
,
10450 error (_("Unable to seek to start of dynamic information\n"));
10454 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
10456 error (_("Failed to read in number of buckets\n"));
10460 filedata
->ngnubuckets
= byte_get (nb
, 4);
10461 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
10462 bitmaskwords
= byte_get (nb
+ 8, 4);
10463 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
10465 buckets_vma
+= bitmaskwords
* 4;
10467 buckets_vma
+= bitmaskwords
* 8;
10469 if (fseek (filedata
->handle
,
10470 (filedata
->archive_file_offset
10471 + offset_from_vma (filedata
, buckets_vma
, 4)),
10474 error (_("Unable to seek to start of dynamic information\n"));
10478 filedata
->gnubuckets
10479 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
10481 if (filedata
->gnubuckets
== NULL
)
10484 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
10485 if (filedata
->gnubuckets
[i
] != 0)
10487 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
10490 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
10491 maxchain
= filedata
->gnubuckets
[i
];
10494 if (maxchain
== 0xffffffff)
10497 maxchain
-= filedata
->gnusymidx
;
10499 if (fseek (filedata
->handle
,
10500 (filedata
->archive_file_offset
10501 + offset_from_vma (filedata
,
10502 buckets_vma
+ 4 * (filedata
->ngnubuckets
10507 error (_("Unable to seek to start of dynamic information\n"));
10513 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
10515 error (_("Failed to determine last chain length\n"));
10519 if (maxchain
+ 1 == 0)
10524 while ((byte_get (nb
, 4) & 1) == 0);
10526 if (fseek (filedata
->handle
,
10527 (filedata
->archive_file_offset
10528 + offset_from_vma (filedata
, (buckets_vma
10529 + 4 * filedata
->ngnubuckets
),
10533 error (_("Unable to seek to start of dynamic information\n"));
10537 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
10538 filedata
->ngnuchains
= maxchain
;
10540 if (filedata
->gnuchains
== NULL
)
10543 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10545 if (fseek (filedata
->handle
,
10546 (filedata
->archive_file_offset
10547 + offset_from_vma (filedata
, (buckets_vma
10548 + 4 * (filedata
->ngnubuckets
10552 error (_("Unable to seek to start of dynamic information\n"));
10556 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
10557 if (filedata
->mipsxlat
== NULL
)
10561 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
10562 if (filedata
->gnubuckets
[hn
] != 0)
10564 bfd_vma si
= filedata
->gnubuckets
[hn
];
10565 bfd_vma off
= si
- filedata
->gnusymidx
;
10569 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10571 if (off
< filedata
->ngnuchains
10572 && filedata
->mipsxlat
[off
] >= num_of_syms
)
10573 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
10577 if (si
>= num_of_syms
)
10578 num_of_syms
= si
+ 1;
10582 while (off
< filedata
->ngnuchains
10583 && (filedata
->gnuchains
[off
++] & 1) == 0);
10586 if (num_of_syms
== 0)
10589 free (filedata
->mipsxlat
);
10590 filedata
->mipsxlat
= NULL
;
10591 free (filedata
->gnuchains
);
10592 filedata
->gnuchains
= NULL
;
10593 free (filedata
->gnubuckets
);
10594 filedata
->gnubuckets
= NULL
;
10595 filedata
->ngnubuckets
= 0;
10596 filedata
->ngnuchains
= 0;
10600 return num_of_syms
;
10603 /* Parse and display the contents of the dynamic section. */
10606 process_dynamic_section (Filedata
* filedata
)
10608 Elf_Internal_Dyn
* entry
;
10610 if (filedata
->dynamic_size
== 0)
10614 if (filedata
->is_separate
)
10615 printf (_("\nThere is no dynamic section in linked file '%s'.\n"),
10616 filedata
->file_name
);
10618 printf (_("\nThere is no dynamic section in this file.\n"));
10626 if (! get_32bit_dynamic_section (filedata
))
10631 if (! get_64bit_dynamic_section (filedata
))
10635 /* Find the appropriate symbol table. */
10636 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
10638 unsigned long num_of_syms
;
10640 for (entry
= filedata
->dynamic_section
;
10641 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10643 if (entry
->d_tag
== DT_SYMTAB
)
10644 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
10645 else if (entry
->d_tag
== DT_SYMENT
)
10646 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
10647 else if (entry
->d_tag
== DT_HASH
)
10648 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
10649 else if (entry
->d_tag
== DT_GNU_HASH
)
10650 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10651 else if ((filedata
->file_header
.e_machine
== EM_MIPS
10652 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
10653 && entry
->d_tag
== DT_MIPS_XHASH
)
10655 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10656 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10659 num_of_syms
= get_num_dynamic_syms (filedata
);
10661 if (num_of_syms
!= 0
10662 && filedata
->dynamic_symbols
== NULL
10663 && filedata
->dynamic_info
[DT_SYMTAB
]
10664 && filedata
->dynamic_info
[DT_SYMENT
])
10666 Elf_Internal_Phdr
*seg
;
10667 bfd_vma vma
= filedata
->dynamic_info
[DT_SYMTAB
];
10669 if (! get_program_headers (filedata
))
10671 error (_("Cannot interpret virtual addresses "
10672 "without program headers.\n"));
10676 for (seg
= filedata
->program_headers
;
10677 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
10680 if (seg
->p_type
!= PT_LOAD
)
10683 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
10685 /* See PR 21379 for a reproducer. */
10686 error (_("Invalid PT_LOAD entry\n"));
10690 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
10691 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
10693 /* Since we do not know how big the symbol table is,
10694 we default to reading in up to the end of PT_LOAD
10695 segment and processing that. This is overkill, I
10696 know, but it should work. */
10697 Elf_Internal_Shdr section
;
10698 section
.sh_offset
= (vma
- seg
->p_vaddr
10700 section
.sh_size
= (num_of_syms
10701 * filedata
->dynamic_info
[DT_SYMENT
]);
10702 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
10705 && filedata
->dynamic_symtab_section
!= NULL
10706 && ((filedata
->dynamic_symtab_section
->sh_offset
10707 != section
.sh_offset
)
10708 || (filedata
->dynamic_symtab_section
->sh_size
10709 != section
.sh_size
)
10710 || (filedata
->dynamic_symtab_section
->sh_entsize
10711 != section
.sh_entsize
)))
10713 the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
10715 section
.sh_name
= filedata
->string_table_length
;
10716 filedata
->dynamic_symbols
10717 = GET_ELF_SYMBOLS (filedata
, §ion
,
10718 &filedata
->num_dynamic_syms
);
10719 if (filedata
->dynamic_symbols
== NULL
10720 || filedata
->num_dynamic_syms
!= num_of_syms
)
10722 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
10731 /* Similarly find a string table. */
10732 if (filedata
->dynamic_strings
== NULL
)
10733 for (entry
= filedata
->dynamic_section
;
10734 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10737 if (entry
->d_tag
== DT_STRTAB
)
10738 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
10740 if (entry
->d_tag
== DT_STRSZ
)
10741 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
10743 if (filedata
->dynamic_info
[DT_STRTAB
]
10744 && filedata
->dynamic_info
[DT_STRSZ
])
10746 unsigned long offset
;
10747 bfd_size_type str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
10749 offset
= offset_from_vma (filedata
,
10750 filedata
->dynamic_info
[DT_STRTAB
],
10753 && filedata
->dynamic_strtab_section
10754 && ((filedata
->dynamic_strtab_section
->sh_offset
10755 != (file_ptr
) offset
)
10756 || (filedata
->dynamic_strtab_section
->sh_size
10759 the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
10761 filedata
->dynamic_strings
10762 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
10763 _("dynamic string table"));
10764 if (filedata
->dynamic_strings
== NULL
)
10766 error (_("Corrupt DT_STRTAB dynamic entry\n"));
10770 filedata
->dynamic_strings_length
= str_tab_len
;
10775 /* And find the syminfo section if available. */
10776 if (filedata
->dynamic_syminfo
== NULL
)
10778 unsigned long syminsz
= 0;
10780 for (entry
= filedata
->dynamic_section
;
10781 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10784 if (entry
->d_tag
== DT_SYMINENT
)
10786 /* Note: these braces are necessary to avoid a syntax
10787 error from the SunOS4 C compiler. */
10788 /* PR binutils/17531: A corrupt file can trigger this test.
10789 So do not use an assert, instead generate an error message. */
10790 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
10791 error (_("Bad value (%d) for SYMINENT entry\n"),
10792 (int) entry
->d_un
.d_val
);
10794 else if (entry
->d_tag
== DT_SYMINSZ
)
10795 syminsz
= entry
->d_un
.d_val
;
10796 else if (entry
->d_tag
== DT_SYMINFO
)
10797 filedata
->dynamic_syminfo_offset
10798 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
10801 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
10803 Elf_External_Syminfo
* extsyminfo
;
10804 Elf_External_Syminfo
* extsym
;
10805 Elf_Internal_Syminfo
* syminfo
;
10807 /* There is a syminfo section. Read the data. */
10808 extsyminfo
= (Elf_External_Syminfo
*)
10809 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
10810 1, syminsz
, _("symbol information"));
10814 if (filedata
->dynamic_syminfo
!= NULL
)
10816 error (_("Multiple dynamic symbol information sections found\n"));
10817 free (filedata
->dynamic_syminfo
);
10819 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10820 if (filedata
->dynamic_syminfo
== NULL
)
10822 error (_("Out of memory allocating %lu bytes "
10823 "for dynamic symbol info\n"),
10824 (unsigned long) syminsz
);
10828 filedata
->dynamic_syminfo_nent
10829 = syminsz
/ sizeof (Elf_External_Syminfo
);
10830 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
10831 syminfo
< (filedata
->dynamic_syminfo
10832 + filedata
->dynamic_syminfo_nent
);
10833 ++syminfo
, ++extsym
)
10835 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10836 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10843 if (do_dynamic
&& filedata
->dynamic_addr
)
10845 if (filedata
->dynamic_nent
== 1)
10847 if (filedata
->is_separate
)
10848 printf (_("\nIn linked file '%s' the dynamic section at offset 0x%lx contains 1 entry:\n"),
10849 filedata
->file_name
,
10850 filedata
->dynamic_addr
);
10852 printf (_("\nDynamic section at offset 0x%lx contains 1 entry:\n"),
10853 filedata
->dynamic_addr
);
10857 if (filedata
->is_separate
)
10858 printf (_("\nIn linked file '%s' the dynamic section at offset 0x%lx contains %lu entries:\n"),
10859 filedata
->file_name
,
10860 filedata
->dynamic_addr
,
10861 (unsigned long) filedata
->dynamic_nent
);
10863 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
10864 filedata
->dynamic_addr
,
10865 (unsigned long) filedata
->dynamic_nent
);
10869 printf (_(" Tag Type Name/Value\n"));
10871 for (entry
= filedata
->dynamic_section
;
10872 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10877 const char * dtype
;
10880 print_vma (entry
->d_tag
, FULL_HEX
);
10881 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10882 printf (" (%s)%*s", dtype
,
10883 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10886 switch (entry
->d_tag
)
10890 print_dynamic_flags (entry
->d_un
.d_val
);
10900 switch (entry
->d_tag
)
10903 printf (_("Auxiliary library"));
10907 printf (_("Filter library"));
10911 printf (_("Configuration file"));
10915 printf (_("Dependency audit library"));
10919 printf (_("Audit library"));
10923 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10924 printf (": [%s]\n",
10925 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
10929 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10938 printf (_("Flags:"));
10940 if (entry
->d_un
.d_val
== 0)
10941 printf (_(" None\n"));
10944 unsigned long int val
= entry
->d_un
.d_val
;
10946 if (val
& DTF_1_PARINIT
)
10948 printf (" PARINIT");
10949 val
^= DTF_1_PARINIT
;
10951 if (val
& DTF_1_CONFEXP
)
10953 printf (" CONFEXP");
10954 val
^= DTF_1_CONFEXP
;
10957 printf (" %lx", val
);
10966 printf (_("Flags:"));
10968 if (entry
->d_un
.d_val
== 0)
10969 printf (_(" None\n"));
10972 unsigned long int val
= entry
->d_un
.d_val
;
10974 if (val
& DF_P1_LAZYLOAD
)
10976 printf (" LAZYLOAD");
10977 val
^= DF_P1_LAZYLOAD
;
10979 if (val
& DF_P1_GROUPPERM
)
10981 printf (" GROUPPERM");
10982 val
^= DF_P1_GROUPPERM
;
10985 printf (" %lx", val
);
10994 printf (_("Flags:"));
10995 if (entry
->d_un
.d_val
== 0)
10996 printf (_(" None\n"));
10999 unsigned long int val
= entry
->d_un
.d_val
;
11001 if (val
& DF_1_NOW
)
11006 if (val
& DF_1_GLOBAL
)
11008 printf (" GLOBAL");
11009 val
^= DF_1_GLOBAL
;
11011 if (val
& DF_1_GROUP
)
11016 if (val
& DF_1_NODELETE
)
11018 printf (" NODELETE");
11019 val
^= DF_1_NODELETE
;
11021 if (val
& DF_1_LOADFLTR
)
11023 printf (" LOADFLTR");
11024 val
^= DF_1_LOADFLTR
;
11026 if (val
& DF_1_INITFIRST
)
11028 printf (" INITFIRST");
11029 val
^= DF_1_INITFIRST
;
11031 if (val
& DF_1_NOOPEN
)
11033 printf (" NOOPEN");
11034 val
^= DF_1_NOOPEN
;
11036 if (val
& DF_1_ORIGIN
)
11038 printf (" ORIGIN");
11039 val
^= DF_1_ORIGIN
;
11041 if (val
& DF_1_DIRECT
)
11043 printf (" DIRECT");
11044 val
^= DF_1_DIRECT
;
11046 if (val
& DF_1_TRANS
)
11051 if (val
& DF_1_INTERPOSE
)
11053 printf (" INTERPOSE");
11054 val
^= DF_1_INTERPOSE
;
11056 if (val
& DF_1_NODEFLIB
)
11058 printf (" NODEFLIB");
11059 val
^= DF_1_NODEFLIB
;
11061 if (val
& DF_1_NODUMP
)
11063 printf (" NODUMP");
11064 val
^= DF_1_NODUMP
;
11066 if (val
& DF_1_CONFALT
)
11068 printf (" CONFALT");
11069 val
^= DF_1_CONFALT
;
11071 if (val
& DF_1_ENDFILTEE
)
11073 printf (" ENDFILTEE");
11074 val
^= DF_1_ENDFILTEE
;
11076 if (val
& DF_1_DISPRELDNE
)
11078 printf (" DISPRELDNE");
11079 val
^= DF_1_DISPRELDNE
;
11081 if (val
& DF_1_DISPRELPND
)
11083 printf (" DISPRELPND");
11084 val
^= DF_1_DISPRELPND
;
11086 if (val
& DF_1_NODIRECT
)
11088 printf (" NODIRECT");
11089 val
^= DF_1_NODIRECT
;
11091 if (val
& DF_1_IGNMULDEF
)
11093 printf (" IGNMULDEF");
11094 val
^= DF_1_IGNMULDEF
;
11096 if (val
& DF_1_NOKSYMS
)
11098 printf (" NOKSYMS");
11099 val
^= DF_1_NOKSYMS
;
11101 if (val
& DF_1_NOHDR
)
11106 if (val
& DF_1_EDITED
)
11108 printf (" EDITED");
11109 val
^= DF_1_EDITED
;
11111 if (val
& DF_1_NORELOC
)
11113 printf (" NORELOC");
11114 val
^= DF_1_NORELOC
;
11116 if (val
& DF_1_SYMINTPOSE
)
11118 printf (" SYMINTPOSE");
11119 val
^= DF_1_SYMINTPOSE
;
11121 if (val
& DF_1_GLOBAUDIT
)
11123 printf (" GLOBAUDIT");
11124 val
^= DF_1_GLOBAUDIT
;
11126 if (val
& DF_1_SINGLETON
)
11128 printf (" SINGLETON");
11129 val
^= DF_1_SINGLETON
;
11131 if (val
& DF_1_STUB
)
11136 if (val
& DF_1_PIE
)
11141 if (val
& DF_1_KMOD
)
11146 if (val
& DF_1_WEAKFILTER
)
11148 printf (" WEAKFILTER");
11149 val
^= DF_1_WEAKFILTER
;
11151 if (val
& DF_1_NOCOMMON
)
11153 printf (" NOCOMMON");
11154 val
^= DF_1_NOCOMMON
;
11157 printf (" %lx", val
);
11164 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11166 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
11186 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11192 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
11193 name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
11199 switch (entry
->d_tag
)
11202 printf (_("Shared library: [%s]"), name
);
11204 if (filedata
->program_interpreter
11205 && streq (name
, filedata
->program_interpreter
))
11206 printf (_(" program interpreter"));
11210 printf (_("Library soname: [%s]"), name
);
11214 printf (_("Library rpath: [%s]"), name
);
11218 printf (_("Library runpath: [%s]"), name
);
11222 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11227 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11240 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11241 /* Fall through. */
11245 case DT_INIT_ARRAYSZ
:
11246 case DT_FINI_ARRAYSZ
:
11247 case DT_GNU_CONFLICTSZ
:
11248 case DT_GNU_LIBLISTSZ
:
11251 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11252 printf (_(" (bytes)\n"));
11257 case DT_VERNEEDNUM
:
11262 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11271 case DT_INIT_ARRAY
:
11272 case DT_FINI_ARRAY
:
11275 if (entry
->d_tag
== DT_USED
11276 && VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
11278 char * name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
11282 printf (_("Not needed object: [%s]\n"), name
);
11287 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11293 /* The value of this entry is ignored. */
11298 case DT_GNU_PRELINKED
:
11302 time_t atime
= entry
->d_un
.d_val
;
11304 tmp
= gmtime (&atime
);
11305 /* PR 17533 file: 041-1244816-0.004. */
11307 printf (_("<corrupt time val: %lx"),
11308 (unsigned long) atime
);
11310 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
11311 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11312 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11318 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11321 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11326 case DT_GNU_FLAGS_1
:
11329 printf (_("Flags:"));
11330 if (entry
->d_un
.d_val
== 0)
11331 printf (_(" None\n"));
11334 unsigned long int val
= entry
->d_un
.d_val
;
11336 if (val
& DF_GNU_1_UNIQUE
)
11338 printf (" UNIQUE");
11339 val
^= DF_GNU_1_UNIQUE
;
11342 printf (" %lx", val
);
11349 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
11350 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
11351 = entry
->d_un
.d_val
;
11355 switch (filedata
->file_header
.e_machine
)
11358 dynamic_section_aarch64_val (entry
);
11361 case EM_MIPS_RS3_LE
:
11362 dynamic_section_mips_val (filedata
, entry
);
11365 dynamic_section_parisc_val (entry
);
11368 dynamic_section_ia64_val (entry
);
11371 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11383 get_ver_flags (unsigned int flags
)
11385 static char buff
[128];
11392 if (flags
& VER_FLG_BASE
)
11393 strcat (buff
, "BASE");
11395 if (flags
& VER_FLG_WEAK
)
11397 if (flags
& VER_FLG_BASE
)
11398 strcat (buff
, " | ");
11400 strcat (buff
, "WEAK");
11403 if (flags
& VER_FLG_INFO
)
11405 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
11406 strcat (buff
, " | ");
11408 strcat (buff
, "INFO");
11411 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11413 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11414 strcat (buff
, " | ");
11416 strcat (buff
, _("<unknown>"));
11422 /* Display the contents of the version sections. */
11425 process_version_sections (Filedata
* filedata
)
11427 Elf_Internal_Shdr
* section
;
11429 bool found
= false;
11434 for (i
= 0, section
= filedata
->section_headers
;
11435 i
< filedata
->file_header
.e_shnum
;
11438 switch (section
->sh_type
)
11440 case SHT_GNU_verdef
:
11442 Elf_External_Verdef
* edefs
;
11449 if (filedata
->is_separate
)
11450 printf (ngettext ("\nIn linked file '%s' the version definition section '%s' contains %u entry:\n",
11451 "\nIn linked file '%s' the version definition section '%s' contains %u entries:\n",
11453 filedata
->file_name
,
11454 printable_section_name (filedata
, section
),
11457 printf (ngettext ("\nVersion definition section '%s' "
11458 "contains %u entry:\n",
11459 "\nVersion definition section '%s' "
11460 "contains %u entries:\n",
11462 printable_section_name (filedata
, section
),
11465 printf (_(" Addr: 0x"));
11466 printf_vma (section
->sh_addr
);
11467 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11468 (unsigned long) section
->sh_offset
, section
->sh_link
,
11469 printable_section_name_from_index (filedata
, section
->sh_link
));
11471 edefs
= (Elf_External_Verdef
*)
11472 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
11473 _("version definition section"));
11476 endbuf
= (char *) edefs
+ section
->sh_size
;
11478 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11481 Elf_External_Verdef
* edef
;
11482 Elf_Internal_Verdef ent
;
11483 Elf_External_Verdaux
* eaux
;
11484 Elf_Internal_Verdaux aux
;
11485 unsigned long isum
;
11488 vstart
= ((char *) edefs
) + idx
;
11489 if (vstart
+ sizeof (*edef
) > endbuf
)
11492 edef
= (Elf_External_Verdef
*) vstart
;
11494 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
11495 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
11496 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
11497 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
11498 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
11499 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
11500 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
11502 printf (_(" %#06lx: Rev: %d Flags: %s"),
11503 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
11505 printf (_(" Index: %d Cnt: %d "),
11506 ent
.vd_ndx
, ent
.vd_cnt
);
11508 /* Check for overflow. */
11509 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
11512 vstart
+= ent
.vd_aux
;
11514 if (vstart
+ sizeof (*eaux
) > endbuf
)
11516 eaux
= (Elf_External_Verdaux
*) vstart
;
11518 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11519 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11521 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11522 printf (_("Name: %s\n"),
11523 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11525 printf (_("Name index: %ld\n"), aux
.vda_name
);
11527 isum
= idx
+ ent
.vd_aux
;
11529 for (j
= 1; j
< ent
.vd_cnt
; j
++)
11531 if (aux
.vda_next
< sizeof (*eaux
)
11532 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
11534 warn (_("Invalid vda_next field of %lx\n"),
11539 /* Check for overflow. */
11540 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
11543 isum
+= aux
.vda_next
;
11544 vstart
+= aux
.vda_next
;
11546 if (vstart
+ sizeof (*eaux
) > endbuf
)
11548 eaux
= (Elf_External_Verdaux
*) vstart
;
11550 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11551 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11553 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11554 printf (_(" %#06lx: Parent %d: %s\n"),
11556 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11558 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
11559 isum
, j
, aux
.vda_name
);
11562 if (j
< ent
.vd_cnt
)
11563 printf (_(" Version def aux past end of section\n"));
11566 file: id:000001,src:000172+005151,op:splice,rep:2. */
11567 if (ent
.vd_next
< sizeof (*edef
)
11568 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
11570 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
11571 cnt
= section
->sh_info
;
11574 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
11577 idx
+= ent
.vd_next
;
11580 if (cnt
< section
->sh_info
)
11581 printf (_(" Version definition past end of section\n"));
11587 case SHT_GNU_verneed
:
11589 Elf_External_Verneed
* eneed
;
11596 if (filedata
->is_separate
)
11597 printf (ngettext ("\nIn linked file '%s' the version needs section '%s' contains %u entry:\n",
11598 "\nIn linked file '%s' the version needs section '%s' contains %u entries:\n",
11600 filedata
->file_name
,
11601 printable_section_name (filedata
, section
),
11604 printf (ngettext ("\nVersion needs section '%s' "
11605 "contains %u entry:\n",
11606 "\nVersion needs section '%s' "
11607 "contains %u entries:\n",
11609 printable_section_name (filedata
, section
),
11612 printf (_(" Addr: 0x"));
11613 printf_vma (section
->sh_addr
);
11614 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11615 (unsigned long) section
->sh_offset
, section
->sh_link
,
11616 printable_section_name_from_index (filedata
, section
->sh_link
));
11618 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
11619 section
->sh_offset
, 1,
11621 _("Version Needs section"));
11624 endbuf
= (char *) eneed
+ section
->sh_size
;
11626 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11628 Elf_External_Verneed
* entry
;
11629 Elf_Internal_Verneed ent
;
11630 unsigned long isum
;
11634 vstart
= ((char *) eneed
) + idx
;
11635 if (vstart
+ sizeof (*entry
) > endbuf
)
11638 entry
= (Elf_External_Verneed
*) vstart
;
11640 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
11641 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
11642 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
11643 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
11644 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
11646 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
11648 if (VALID_DYNAMIC_NAME (filedata
, ent
.vn_file
))
11649 printf (_(" File: %s"),
11650 GET_DYNAMIC_NAME (filedata
, ent
.vn_file
));
11652 printf (_(" File: %lx"), ent
.vn_file
);
11654 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
11656 /* Check for overflow. */
11657 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
11659 vstart
+= ent
.vn_aux
;
11661 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
11663 Elf_External_Vernaux
* eaux
;
11664 Elf_Internal_Vernaux aux
;
11666 if (vstart
+ sizeof (*eaux
) > endbuf
)
11668 eaux
= (Elf_External_Vernaux
*) vstart
;
11670 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
11671 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
11672 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
11673 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
11674 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
11676 if (VALID_DYNAMIC_NAME (filedata
, aux
.vna_name
))
11677 printf (_(" %#06lx: Name: %s"),
11678 isum
, GET_DYNAMIC_NAME (filedata
, aux
.vna_name
));
11680 printf (_(" %#06lx: Name index: %lx"),
11681 isum
, aux
.vna_name
);
11683 printf (_(" Flags: %s Version: %d\n"),
11684 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
11686 if (aux
.vna_next
< sizeof (*eaux
)
11687 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
11689 warn (_("Invalid vna_next field of %lx\n"),
11694 /* Check for overflow. */
11695 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
11697 isum
+= aux
.vna_next
;
11698 vstart
+= aux
.vna_next
;
11701 if (j
< ent
.vn_cnt
)
11702 warn (_("Missing Version Needs auxiliary information\n"));
11704 if (ent
.vn_next
< sizeof (*entry
)
11705 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
11707 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
11708 cnt
= section
->sh_info
;
11711 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
11713 idx
+= ent
.vn_next
;
11716 if (cnt
< section
->sh_info
)
11717 warn (_("Missing Version Needs information\n"));
11723 case SHT_GNU_versym
:
11725 Elf_Internal_Shdr
* link_section
;
11728 unsigned char * edata
;
11729 unsigned short * data
;
11731 Elf_Internal_Sym
* symbols
;
11732 Elf_Internal_Shdr
* string_sec
;
11733 unsigned long num_syms
;
11736 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
11739 link_section
= filedata
->section_headers
+ section
->sh_link
;
11740 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
11742 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
11747 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
11748 if (symbols
== NULL
)
11751 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
11753 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
11754 string_sec
->sh_size
,
11755 _("version string table"));
11762 if (filedata
->is_separate
)
11763 printf (ngettext ("\nIn linked file '%s' the version symbols section '%s' contains %lu entry:\n",
11764 "\nIn linked file '%s' the version symbols section '%s' contains %lu entries:\n",
11766 filedata
->file_name
,
11767 printable_section_name (filedata
, section
),
11768 (unsigned long) total
);
11770 printf (ngettext ("\nVersion symbols section '%s' "
11771 "contains %lu entry:\n",
11772 "\nVersion symbols section '%s' "
11773 "contains %lu entries:\n",
11775 printable_section_name (filedata
, section
),
11776 (unsigned long) total
);
11778 printf (_(" Addr: 0x"));
11779 printf_vma (section
->sh_addr
);
11780 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11781 (unsigned long) section
->sh_offset
, section
->sh_link
,
11782 printable_section_name (filedata
, link_section
));
11784 off
= offset_from_vma (filedata
,
11785 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11786 total
* sizeof (short));
11787 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
11788 sizeof (short), total
,
11789 _("version symbol data"));
11797 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
11799 for (cnt
= total
; cnt
--;)
11800 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
11805 for (cnt
= 0; cnt
< total
; cnt
+= 4)
11809 char *invalid
= _("*invalid*");
11811 printf (" %03x:", cnt
);
11813 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
11814 switch (data
[cnt
+ j
])
11817 fputs (_(" 0 (*local*) "), stdout
);
11821 fputs (_(" 1 (*global*) "), stdout
);
11825 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
11826 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
11828 /* If this index value is greater than the size of the symbols
11829 array, break to avoid an out-of-bounds read. */
11830 if ((unsigned long)(cnt
+ j
) >= num_syms
)
11832 warn (_("invalid index into symbol array\n"));
11837 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11839 Elf_Internal_Verneed ivn
;
11840 unsigned long offset
;
11842 offset
= offset_from_vma
11844 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11845 sizeof (Elf_External_Verneed
));
11849 Elf_Internal_Vernaux ivna
;
11850 Elf_External_Verneed evn
;
11851 Elf_External_Vernaux evna
;
11852 unsigned long a_off
;
11854 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11855 _("version need")) == NULL
)
11858 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11859 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11861 a_off
= offset
+ ivn
.vn_aux
;
11865 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
11866 1, _("version need aux (2)")) == NULL
)
11869 ivna
.vna_other
= 0;
11873 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11874 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11877 a_off
+= ivna
.vna_next
;
11879 while (ivna
.vna_other
!= data
[cnt
+ j
]
11880 && ivna
.vna_next
!= 0);
11882 if (ivna
.vna_other
== data
[cnt
+ j
])
11884 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11886 if (ivna
.vna_name
>= string_sec
->sh_size
)
11889 name
= strtab
+ ivna
.vna_name
;
11893 offset
+= ivn
.vn_next
;
11895 while (ivn
.vn_next
);
11898 if (data
[cnt
+ j
] != 0x8001
11899 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11901 Elf_Internal_Verdef ivd
;
11902 Elf_External_Verdef evd
;
11903 unsigned long offset
;
11905 offset
= offset_from_vma
11907 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11912 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11913 _("version def")) == NULL
)
11916 /* PR 17531: file: 046-1082287-0.004. */
11917 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11922 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11923 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11926 offset
+= ivd
.vd_next
;
11928 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11929 && ivd
.vd_next
!= 0);
11931 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11933 Elf_External_Verdaux evda
;
11934 Elf_Internal_Verdaux ivda
;
11936 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11938 if (get_data (&evda
, filedata
,
11939 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11941 _("version def aux")) == NULL
)
11944 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11946 if (ivda
.vda_name
>= string_sec
->sh_size
)
11948 else if (name
!= NULL
&& name
!= invalid
)
11949 name
= _("*both*");
11951 name
= strtab
+ ivda
.vda_name
;
11955 nn
+= printf ("(%s%-*s",
11957 12 - (int) strlen (name
),
11961 printf ("%*c", 18 - nn
, ' ');
11980 if (filedata
->is_separate
)
11981 printf (_("\nNo version information found in linked file '%s'.\n"),
11982 filedata
->file_name
);
11984 printf (_("\nNo version information found in this file.\n"));
11990 static const char *
11991 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11993 static char buff
[64];
11997 case STB_LOCAL
: return "LOCAL";
11998 case STB_GLOBAL
: return "GLOBAL";
11999 case STB_WEAK
: return "WEAK";
12001 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
12002 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
12004 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
12006 if (binding
== STB_GNU_UNIQUE
12007 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
12009 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
12012 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
12017 static const char *
12018 get_symbol_type (Filedata
* filedata
, unsigned int type
)
12020 static char buff
[64];
12024 case STT_NOTYPE
: return "NOTYPE";
12025 case STT_OBJECT
: return "OBJECT";
12026 case STT_FUNC
: return "FUNC";
12027 case STT_SECTION
: return "SECTION";
12028 case STT_FILE
: return "FILE";
12029 case STT_COMMON
: return "COMMON";
12030 case STT_TLS
: return "TLS";
12031 case STT_RELC
: return "RELC";
12032 case STT_SRELC
: return "SRELC";
12034 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
12036 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
12037 return "THUMB_FUNC";
12039 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
12042 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
12043 return "PARISC_MILLI";
12045 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
12047 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
12049 if (filedata
->file_header
.e_machine
== EM_PARISC
)
12051 if (type
== STT_HP_OPAQUE
)
12052 return "HP_OPAQUE";
12053 if (type
== STT_HP_STUB
)
12057 if (type
== STT_GNU_IFUNC
12058 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
12059 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
12062 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
12065 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
12070 static const char *
12071 get_symbol_visibility (unsigned int visibility
)
12073 switch (visibility
)
12075 case STV_DEFAULT
: return "DEFAULT";
12076 case STV_INTERNAL
: return "INTERNAL";
12077 case STV_HIDDEN
: return "HIDDEN";
12078 case STV_PROTECTED
: return "PROTECTED";
12080 error (_("Unrecognized visibility value: %u\n"), visibility
);
12081 return _("<unknown>");
12085 static const char *
12086 get_alpha_symbol_other (unsigned int other
)
12090 case STO_ALPHA_NOPV
: return "NOPV";
12091 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
12093 error (_("Unrecognized alpha specific other value: %u\n"), other
);
12094 return _("<unknown>");
12098 static const char *
12099 get_solaris_symbol_visibility (unsigned int visibility
)
12101 switch (visibility
)
12103 case 4: return "EXPORTED";
12104 case 5: return "SINGLETON";
12105 case 6: return "ELIMINATE";
12106 default: return get_symbol_visibility (visibility
);
12110 static const char *
12111 get_aarch64_symbol_other (unsigned int other
)
12113 static char buf
[32];
12115 if (other
& STO_AARCH64_VARIANT_PCS
)
12117 other
&= ~STO_AARCH64_VARIANT_PCS
;
12119 return "VARIANT_PCS";
12120 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
12126 static const char *
12127 get_mips_symbol_other (unsigned int other
)
12131 case STO_OPTIONAL
: return "OPTIONAL";
12132 case STO_MIPS_PLT
: return "MIPS PLT";
12133 case STO_MIPS_PIC
: return "MIPS PIC";
12134 case STO_MICROMIPS
: return "MICROMIPS";
12135 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
12136 case STO_MIPS16
: return "MIPS16";
12137 default: return NULL
;
12141 static const char *
12142 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
12144 if (is_ia64_vms (filedata
))
12146 static char res
[32];
12150 /* Function types is for images and .STB files only. */
12151 switch (filedata
->file_header
.e_type
)
12155 switch (VMS_ST_FUNC_TYPE (other
))
12157 case VMS_SFT_CODE_ADDR
:
12158 strcat (res
, " CA");
12160 case VMS_SFT_SYMV_IDX
:
12161 strcat (res
, " VEC");
12164 strcat (res
, " FD");
12166 case VMS_SFT_RESERVE
:
12167 strcat (res
, " RSV");
12170 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
12171 VMS_ST_FUNC_TYPE (other
));
12172 strcat (res
, " <unknown>");
12179 switch (VMS_ST_LINKAGE (other
))
12181 case VMS_STL_IGNORE
:
12182 strcat (res
, " IGN");
12184 case VMS_STL_RESERVE
:
12185 strcat (res
, " RSV");
12188 strcat (res
, " STD");
12191 strcat (res
, " LNK");
12194 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
12195 VMS_ST_LINKAGE (other
));
12196 strcat (res
, " <unknown>");
12208 static const char *
12209 get_ppc64_symbol_other (unsigned int other
)
12211 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
12214 other
>>= STO_PPC64_LOCAL_BIT
;
12217 static char buf
[64];
12219 other
= ppc64_decode_local_entry (other
);
12220 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
12226 static const char *
12227 get_symbol_other (Filedata
* filedata
, unsigned int other
)
12229 const char * result
= NULL
;
12230 static char buff
[64];
12235 switch (filedata
->file_header
.e_machine
)
12238 result
= get_alpha_symbol_other (other
);
12241 result
= get_aarch64_symbol_other (other
);
12244 result
= get_mips_symbol_other (other
);
12247 result
= get_ia64_symbol_other (filedata
, other
);
12250 result
= get_ppc64_symbol_other (other
);
12260 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
12264 static const char *
12265 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
12267 static char buff
[32];
12271 case SHN_UNDEF
: return "UND";
12272 case SHN_ABS
: return "ABS";
12273 case SHN_COMMON
: return "COM";
12275 if (type
== SHN_IA_64_ANSI_COMMON
12276 && filedata
->file_header
.e_machine
== EM_IA_64
12277 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
12279 else if ((filedata
->file_header
.e_machine
== EM_X86_64
12280 || filedata
->file_header
.e_machine
== EM_L1OM
12281 || filedata
->file_header
.e_machine
== EM_K1OM
)
12282 && type
== SHN_X86_64_LCOMMON
)
12283 return "LARGE_COM";
12284 else if ((type
== SHN_MIPS_SCOMMON
12285 && filedata
->file_header
.e_machine
== EM_MIPS
)
12286 || (type
== SHN_TIC6X_SCOMMON
12287 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
12289 else if (type
== SHN_MIPS_SUNDEFINED
12290 && filedata
->file_header
.e_machine
== EM_MIPS
)
12292 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
12293 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
12294 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
12295 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
12296 else if (type
>= SHN_LORESERVE
)
12297 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
12298 else if (filedata
->file_header
.e_shnum
!= 0
12299 && type
>= filedata
->file_header
.e_shnum
)
12300 sprintf (buff
, _("bad section index[%3d]"), type
);
12302 sprintf (buff
, "%3d", type
);
12309 static const char *
12310 get_symbol_version_string (Filedata
* filedata
,
12312 const char * strtab
,
12313 unsigned long int strtab_size
,
12315 Elf_Internal_Sym
* psym
,
12316 enum versioned_symbol_info
* sym_info
,
12317 unsigned short * vna_other
)
12319 unsigned char data
[2];
12320 unsigned short vers_data
;
12321 unsigned long offset
;
12322 unsigned short max_vd_ndx
;
12325 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
12328 offset
= offset_from_vma (filedata
,
12329 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
12330 sizeof data
+ si
* sizeof (vers_data
));
12332 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
12333 sizeof (data
), 1, _("version data")) == NULL
)
12336 vers_data
= byte_get (data
, 2);
12338 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
12341 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
12344 /* Usually we'd only see verdef for defined symbols, and verneed for
12345 undefined symbols. However, symbols defined by the linker in
12346 .dynbss for variables copied from a shared library in order to
12347 avoid text relocations are defined yet have verneed. We could
12348 use a heuristic to detect the special case, for example, check
12349 for verneed first on symbols defined in SHT_NOBITS sections, but
12350 it is simpler and more reliable to just look for both verdef and
12351 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
12353 if (psym
->st_shndx
!= SHN_UNDEF
12354 && vers_data
!= 0x8001
12355 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
12357 Elf_Internal_Verdef ivd
;
12358 Elf_Internal_Verdaux ivda
;
12359 Elf_External_Verdaux evda
;
12362 off
= offset_from_vma (filedata
,
12363 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
12364 sizeof (Elf_External_Verdef
));
12368 Elf_External_Verdef evd
;
12370 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
12371 _("version def")) == NULL
)
12380 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
12381 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
12382 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
12383 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
12386 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
12387 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
12389 off
+= ivd
.vd_next
;
12391 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
12393 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
12395 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
12398 off
-= ivd
.vd_next
;
12401 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
12402 _("version def aux")) != NULL
)
12404 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
12406 if (psym
->st_name
!= ivda
.vda_name
)
12407 return (ivda
.vda_name
< strtab_size
12408 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
12413 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
12415 Elf_External_Verneed evn
;
12416 Elf_Internal_Verneed ivn
;
12417 Elf_Internal_Vernaux ivna
;
12419 offset
= offset_from_vma (filedata
,
12420 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
12424 unsigned long vna_off
;
12426 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
12427 _("version need")) == NULL
)
12430 ivna
.vna_other
= 0;
12435 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
12436 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
12438 vna_off
= offset
+ ivn
.vn_aux
;
12442 Elf_External_Vernaux evna
;
12444 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
12445 _("version need aux (3)")) == NULL
)
12448 ivna
.vna_other
= 0;
12453 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
12454 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
12455 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
12458 vna_off
+= ivna
.vna_next
;
12460 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
12462 if (ivna
.vna_other
== vers_data
)
12465 offset
+= ivn
.vn_next
;
12467 while (ivn
.vn_next
!= 0);
12469 if (ivna
.vna_other
== vers_data
)
12471 *sym_info
= symbol_undefined
;
12472 *vna_other
= ivna
.vna_other
;
12473 return (ivna
.vna_name
< strtab_size
12474 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
12476 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
12477 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
12478 return _("<corrupt>");
12483 /* Display a symbol size on stdout. Format is based on --sym-base setting. */
12485 static unsigned int
12486 print_dynamic_symbol_size (bfd_vma vma
, int base
)
12491 return print_vma (vma
, OCTAL_5
);
12494 return print_vma (vma
, UNSIGNED_5
);
12497 return print_vma (vma
, PREFIX_HEX_5
);
12501 return print_vma (vma
, DEC_5
);
12506 print_dynamic_symbol (Filedata
*filedata
, unsigned long si
,
12507 Elf_Internal_Sym
*symtab
,
12508 Elf_Internal_Shdr
*section
,
12509 char *strtab
, size_t strtab_size
)
12511 const char *version_string
;
12512 enum versioned_symbol_info sym_info
;
12513 unsigned short vna_other
;
12516 Elf_Internal_Sym
*psym
= symtab
+ si
;
12518 printf ("%6ld: ", si
);
12519 print_vma (psym
->st_value
, LONG_HEX
);
12521 print_dynamic_symbol_size (psym
->st_size
, sym_base
);
12522 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12523 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12524 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12525 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12528 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12530 printf (" %-7s", get_symbol_visibility (vis
));
12531 /* Check to see if any other bits in the st_other field are set.
12532 Note - displaying this information disrupts the layout of the
12533 table being generated, but for the moment this case is very rare. */
12534 if (psym
->st_other
^ vis
)
12535 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12537 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12539 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
12540 && psym
->st_shndx
< filedata
->file_header
.e_shnum
12541 && psym
->st_name
== 0)
12543 is_valid
= SECTION_NAME_VALID (filedata
->section_headers
+ psym
->st_shndx
);
12545 SECTION_NAME_PRINT (filedata
->section_headers
+ psym
->st_shndx
)
12550 is_valid
= VALID_SYMBOL_NAME (strtab
, strtab_size
, psym
->st_name
);
12551 sstr
= is_valid
? strtab
+ psym
->st_name
: _("<corrupt>");
12555 = get_symbol_version_string (filedata
,
12557 || section
->sh_type
== SHT_DYNSYM
),
12558 strtab
, strtab_size
, si
,
12559 psym
, &sym_info
, &vna_other
);
12561 int len_avail
= 21;
12562 if (! do_wide
&& version_string
!= NULL
)
12566 len_avail
-= 1 + strlen (version_string
);
12568 if (sym_info
== symbol_undefined
)
12569 len_avail
-= sprintf (buffer
," (%d)", vna_other
);
12570 else if (sym_info
!= symbol_hidden
)
12574 print_symbol (len_avail
, sstr
);
12576 if (version_string
)
12578 if (sym_info
== symbol_undefined
)
12579 printf ("@%s (%d)", version_string
, vna_other
);
12581 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12587 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12589 && si
>= section
->sh_info
12590 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12591 && filedata
->file_header
.e_machine
!= EM_MIPS
12592 /* Solaris binaries have been found to violate this requirement as
12593 well. Not sure if this is a bug or an ABI requirement. */
12594 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12595 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12596 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12599 static const char *
12600 get_lto_kind (unsigned int kind
)
12604 case 0: return "DEF";
12605 case 1: return "WEAKDEF";
12606 case 2: return "UNDEF";
12607 case 3: return "WEAKUNDEF";
12608 case 4: return "COMMON";
12613 static char buffer
[30];
12614 error (_("Unknown LTO symbol definition encountered: %u\n"), kind
);
12615 sprintf (buffer
, "<unknown: %u>", kind
);
12619 static const char *
12620 get_lto_visibility (unsigned int visibility
)
12622 switch (visibility
)
12624 case 0: return "DEFAULT";
12625 case 1: return "PROTECTED";
12626 case 2: return "INTERNAL";
12627 case 3: return "HIDDEN";
12632 static char buffer
[30];
12633 error (_("Unknown LTO symbol visibility encountered: %u\n"), visibility
);
12634 sprintf (buffer
, "<unknown: %u>", visibility
);
12638 static const char *
12639 get_lto_sym_type (unsigned int sym_type
)
12643 case 0: return "UNKNOWN";
12644 case 1: return "FUNCTION";
12645 case 2: return "VARIABLE";
12650 static char buffer
[30];
12651 error (_("Unknown LTO symbol type encountered: %u\n"), sym_type
);
12652 sprintf (buffer
, "<unknown: %u>", sym_type
);
12656 /* Display an LTO format symbol table.
12657 FIXME: The format of LTO symbol tables is not formalized.
12658 So this code could need changing in the future. */
12661 display_lto_symtab (Filedata
* filedata
,
12662 Elf_Internal_Shdr
* section
)
12664 if (section
->sh_size
== 0)
12666 if (filedata
->is_separate
)
12667 printf (_("\nThe LTO Symbol table section '%s' in linked file '%s' is empty!\n"),
12668 printable_section_name (filedata
, section
),
12669 filedata
->file_name
);
12671 printf (_("\nLTO Symbol table '%s' is empty!\n"),
12672 printable_section_name (filedata
, section
));
12677 if (section
->sh_size
> filedata
->file_size
)
12679 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
12680 printable_section_name (filedata
, section
),
12681 (unsigned long) section
->sh_size
);
12685 void * alloced_data
= get_data (NULL
, filedata
, section
->sh_offset
,
12686 section
->sh_size
, 1, _("LTO symbols"));
12687 if (alloced_data
== NULL
)
12690 /* Look for extended data for the symbol table. */
12691 Elf_Internal_Shdr
* ext
;
12692 void * ext_data_orig
= NULL
;
12693 char * ext_data
= NULL
;
12694 char * ext_data_end
= NULL
;
12695 char * ext_name
= NULL
;
12697 if (asprintf (& ext_name
, ".gnu.lto_.ext_symtab.%s",
12698 SECTION_NAME (section
) + sizeof (".gnu.lto_.symtab.") - 1) > 0
12699 && ext_name
!= NULL
/* Paranoia. */
12700 && (ext
= find_section (filedata
, ext_name
)) != NULL
)
12702 if (ext
->sh_size
< 3)
12703 error (_("LTO Symbol extension table '%s' is empty!\n"),
12704 printable_section_name (filedata
, ext
));
12707 ext_data_orig
= ext_data
= get_data (NULL
, filedata
, ext
->sh_offset
,
12709 _("LTO ext symbol data"));
12710 if (ext_data
!= NULL
)
12712 ext_data_end
= ext_data
+ ext
->sh_size
;
12713 if (* ext_data
++ != 1)
12714 error (_("Unexpected version number in symbol extension table\n"));
12719 const unsigned char * data
= (const unsigned char *) alloced_data
;
12720 const unsigned char * end
= data
+ section
->sh_size
;
12722 if (filedata
->is_separate
)
12723 printf (_("\nIn linked file '%s': "), filedata
->file_name
);
12727 if (ext_data_orig
!= NULL
)
12730 printf (_("LTO Symbol table '%s' and extension table '%s' contain:\n"),
12731 printable_section_name (filedata
, section
),
12732 printable_section_name (filedata
, ext
));
12735 printf (_("LTO Symbol table '%s'\n"),
12736 printable_section_name (filedata
, section
));
12737 printf (_(" and extension table '%s' contain:\n"),
12738 printable_section_name (filedata
, ext
));
12742 printf (_("LTO Symbol table '%s' contains:\n"),
12743 printable_section_name (filedata
, section
));
12745 /* FIXME: Add a wide version. */
12746 if (ext_data_orig
!= NULL
)
12747 printf (_(" Comdat_Key Kind Visibility Size Slot Type Section Name\n"));
12749 printf (_(" Comdat_Key Kind Visibility Size Slot Name\n"));
12751 /* FIXME: We do not handle style prefixes. */
12755 const unsigned char * sym_name
= data
;
12756 data
+= strnlen ((const char *) sym_name
, end
- data
) + 1;
12760 const unsigned char * comdat_key
= data
;
12761 data
+= strnlen ((const char *) comdat_key
, end
- data
) + 1;
12765 if (data
+ 2 + 8 + 4 > end
)
12768 unsigned int kind
= *data
++;
12769 unsigned int visibility
= *data
++;
12771 elf_vma size
= byte_get (data
, 8);
12774 elf_vma slot
= byte_get (data
, 4);
12777 if (ext_data
!= NULL
)
12779 if (ext_data
< (ext_data_end
- 1))
12781 unsigned int sym_type
= * ext_data
++;
12782 unsigned int sec_kind
= * ext_data
++;
12784 printf (" %10s %10s %11s %08lx %08lx %9s %08lx _",
12785 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
12786 get_lto_kind (kind
),
12787 get_lto_visibility (visibility
),
12790 get_lto_sym_type (sym_type
),
12792 print_symbol (6, (const char *) sym_name
);
12796 error (_("Ran out of LTO symbol extension data\n"));
12798 /* FIXME: return FAIL result ? */
12803 printf (" %10s %10s %11s %08lx %08lx _",
12804 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
12805 get_lto_kind (kind
),
12806 get_lto_visibility (visibility
),
12809 print_symbol (21, (const char *) sym_name
);
12814 if (ext_data
!= NULL
&& ext_data
< ext_data_end
)
12816 error (_("Data remains in the LTO symbol extension table\n"));
12820 free (alloced_data
);
12821 free (ext_data_orig
);
12826 error (_("Buffer overrun encountered whilst decoding LTO symbol table\n"));
12827 free (alloced_data
);
12828 free (ext_data_orig
);
12833 /* Display LTO symbol tables. */
12836 process_lto_symbol_tables (Filedata
* filedata
)
12838 Elf_Internal_Shdr
* section
;
12845 if (filedata
->section_headers
== NULL
)
12848 for (i
= 0, section
= filedata
->section_headers
;
12849 i
< filedata
->file_header
.e_shnum
;
12851 if (SECTION_NAME_VALID (section
)
12852 && startswith (SECTION_NAME (section
), ".gnu.lto_.symtab."))
12853 res
&= display_lto_symtab (filedata
, section
);
12858 /* Dump the symbol table. */
12861 process_symbol_table (Filedata
* filedata
)
12863 Elf_Internal_Shdr
* section
;
12865 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
12868 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
12870 && do_using_dynamic
12871 && filedata
->dynamic_strings
!= NULL
12872 && filedata
->dynamic_symbols
!= NULL
)
12876 if (filedata
->is_separate
)
12878 printf (ngettext ("\nIn linked file '%s' the dynamic symbol table contains %lu entry:\n",
12879 "\nIn linked file '%s' the dynamic symbol table contains %lu entries:\n",
12880 filedata
->num_dynamic_syms
),
12881 filedata
->file_name
,
12882 filedata
->num_dynamic_syms
);
12886 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
12887 "\nSymbol table for image contains %lu entries:\n",
12888 filedata
->num_dynamic_syms
),
12889 filedata
->num_dynamic_syms
);
12892 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12894 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12896 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
12897 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
12898 filedata
->dynamic_strings
,
12899 filedata
->dynamic_strings_length
);
12901 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
12902 && filedata
->section_headers
!= NULL
)
12906 for (i
= 0, section
= filedata
->section_headers
;
12907 i
< filedata
->file_header
.e_shnum
;
12910 char * strtab
= NULL
;
12911 unsigned long int strtab_size
= 0;
12912 Elf_Internal_Sym
* symtab
;
12913 unsigned long si
, num_syms
;
12915 if ((section
->sh_type
!= SHT_SYMTAB
12916 && section
->sh_type
!= SHT_DYNSYM
)
12918 && section
->sh_type
== SHT_SYMTAB
))
12921 if (section
->sh_entsize
== 0)
12923 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12924 printable_section_name (filedata
, section
));
12928 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12930 if (filedata
->is_separate
)
12931 printf (ngettext ("\nIn linked file '%s' symbol section '%s' contains %lu entry:\n",
12932 "\nIn linked file '%s' symbol section '%s' contains %lu entries:\n",
12934 filedata
->file_name
,
12935 printable_section_name (filedata
, section
),
12938 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12939 "\nSymbol table '%s' contains %lu entries:\n",
12941 printable_section_name (filedata
, section
),
12945 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12947 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12949 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
12950 if (symtab
== NULL
)
12953 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12955 strtab
= filedata
->string_table
;
12956 strtab_size
= filedata
->string_table_length
;
12958 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12960 Elf_Internal_Shdr
* string_sec
;
12962 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12964 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12965 1, string_sec
->sh_size
,
12966 _("string table"));
12967 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12970 for (si
= 0; si
< num_syms
; si
++)
12971 print_dynamic_symbol (filedata
, si
, symtab
, section
,
12972 strtab
, strtab_size
);
12975 if (strtab
!= filedata
->string_table
)
12981 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12983 if (do_histogram
&& filedata
->buckets
!= NULL
)
12985 unsigned long * lengths
;
12986 unsigned long * counts
;
12989 unsigned long maxlength
= 0;
12990 unsigned long nzero_counts
= 0;
12991 unsigned long nsyms
= 0;
12994 printf (ngettext ("\nHistogram for bucket list length "
12995 "(total of %lu bucket):\n",
12996 "\nHistogram for bucket list length "
12997 "(total of %lu buckets):\n",
12998 (unsigned long) filedata
->nbuckets
),
12999 (unsigned long) filedata
->nbuckets
);
13001 lengths
= (unsigned long *) calloc (filedata
->nbuckets
,
13002 sizeof (*lengths
));
13003 if (lengths
== NULL
)
13005 error (_("Out of memory allocating space for histogram buckets\n"));
13008 visited
= xcmalloc (filedata
->nchains
, 1);
13009 memset (visited
, 0, filedata
->nchains
);
13011 printf (_(" Length Number %% of total Coverage\n"));
13012 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
13014 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
13017 if (maxlength
< ++lengths
[hn
])
13019 if (si
>= filedata
->nchains
|| visited
[si
])
13021 error (_("histogram chain is corrupt\n"));
13029 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
13030 if (counts
== NULL
)
13033 error (_("Out of memory allocating space for histogram counts\n"));
13037 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
13038 ++counts
[lengths
[hn
]];
13040 if (filedata
->nbuckets
> 0)
13043 printf (" 0 %-10lu (%5.1f%%)\n",
13044 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
13045 for (i
= 1; i
<= maxlength
; ++i
)
13047 nzero_counts
+= counts
[i
] * i
;
13048 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
13049 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
13050 (nzero_counts
* 100.0) / nsyms
);
13058 free (filedata
->buckets
);
13059 filedata
->buckets
= NULL
;
13060 filedata
->nbuckets
= 0;
13061 free (filedata
->chains
);
13062 filedata
->chains
= NULL
;
13064 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
13066 unsigned long * lengths
;
13067 unsigned long * counts
;
13069 unsigned long maxlength
= 0;
13070 unsigned long nzero_counts
= 0;
13071 unsigned long nsyms
= 0;
13073 printf (ngettext ("\nHistogram for `%s' bucket list length "
13074 "(total of %lu bucket):\n",
13075 "\nHistogram for `%s' bucket list length "
13076 "(total of %lu buckets):\n",
13077 (unsigned long) filedata
->ngnubuckets
),
13078 GNU_HASH_SECTION_NAME (filedata
),
13079 (unsigned long) filedata
->ngnubuckets
);
13081 lengths
= (unsigned long *) calloc (filedata
->ngnubuckets
,
13082 sizeof (*lengths
));
13083 if (lengths
== NULL
)
13085 error (_("Out of memory allocating space for gnu histogram buckets\n"));
13089 printf (_(" Length Number %% of total Coverage\n"));
13091 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
13092 if (filedata
->gnubuckets
[hn
] != 0)
13094 bfd_vma off
, length
= 1;
13096 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
13097 /* PR 17531 file: 010-77222-0.004. */
13098 off
< filedata
->ngnuchains
13099 && (filedata
->gnuchains
[off
] & 1) == 0;
13102 lengths
[hn
] = length
;
13103 if (length
> maxlength
)
13104 maxlength
= length
;
13108 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
13109 if (counts
== NULL
)
13112 error (_("Out of memory allocating space for gnu histogram counts\n"));
13116 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
13117 ++counts
[lengths
[hn
]];
13119 if (filedata
->ngnubuckets
> 0)
13122 printf (" 0 %-10lu (%5.1f%%)\n",
13123 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
13124 for (j
= 1; j
<= maxlength
; ++j
)
13126 nzero_counts
+= counts
[j
] * j
;
13127 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
13128 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
13129 (nzero_counts
* 100.0) / nsyms
);
13136 free (filedata
->gnubuckets
);
13137 filedata
->gnubuckets
= NULL
;
13138 filedata
->ngnubuckets
= 0;
13139 free (filedata
->gnuchains
);
13140 filedata
->gnuchains
= NULL
;
13141 filedata
->ngnuchains
= 0;
13142 free (filedata
->mipsxlat
);
13143 filedata
->mipsxlat
= NULL
;
13147 free (filedata
->gnubuckets
);
13148 filedata
->gnubuckets
= NULL
;
13149 filedata
->ngnubuckets
= 0;
13150 free (filedata
->gnuchains
);
13151 filedata
->gnuchains
= NULL
;
13152 filedata
->ngnuchains
= 0;
13153 free (filedata
->mipsxlat
);
13154 filedata
->mipsxlat
= NULL
;
13155 free (filedata
->buckets
);
13156 filedata
->buckets
= NULL
;
13157 filedata
->nbuckets
= 0;
13158 free (filedata
->chains
);
13159 filedata
->chains
= NULL
;
13164 process_syminfo (Filedata
* filedata
)
13168 if (filedata
->dynamic_syminfo
== NULL
13170 /* No syminfo, this is ok. */
13173 /* There better should be a dynamic symbol section. */
13174 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
13177 if (filedata
->is_separate
)
13178 printf (ngettext ("\nIn linked file '%s: the dynamic info segment at offset 0x%lx contains %d entry:\n",
13179 "\nIn linked file '%s: the dynamic info segment at offset 0x%lx contains %d entries:\n",
13180 filedata
->dynamic_syminfo_nent
),
13181 filedata
->file_name
,
13182 filedata
->dynamic_syminfo_offset
,
13183 filedata
->dynamic_syminfo_nent
);
13185 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
13186 "contains %d entry:\n",
13187 "\nDynamic info segment at offset 0x%lx "
13188 "contains %d entries:\n",
13189 filedata
->dynamic_syminfo_nent
),
13190 filedata
->dynamic_syminfo_offset
,
13191 filedata
->dynamic_syminfo_nent
);
13193 printf (_(" Num: Name BoundTo Flags\n"));
13194 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
13196 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
13198 printf ("%4d: ", i
);
13199 if (i
>= filedata
->num_dynamic_syms
)
13200 printf (_("<corrupt index>"));
13201 else if (VALID_DYNAMIC_NAME (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
13202 print_symbol (30, GET_DYNAMIC_NAME (filedata
,
13203 filedata
->dynamic_symbols
[i
].st_name
));
13205 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
13208 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
13210 case SYMINFO_BT_SELF
:
13211 fputs ("SELF ", stdout
);
13213 case SYMINFO_BT_PARENT
:
13214 fputs ("PARENT ", stdout
);
13217 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
13218 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
13219 && VALID_DYNAMIC_NAME (filedata
,
13220 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
13222 print_symbol (10, GET_DYNAMIC_NAME (filedata
,
13223 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
13227 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
13231 if (flags
& SYMINFO_FLG_DIRECT
)
13232 printf (" DIRECT");
13233 if (flags
& SYMINFO_FLG_PASSTHRU
)
13234 printf (" PASSTHRU");
13235 if (flags
& SYMINFO_FLG_COPY
)
13237 if (flags
& SYMINFO_FLG_LAZYLOAD
)
13238 printf (" LAZYLOAD");
13246 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
13247 is contained by the region START .. END. The types of ADDR, START
13248 and END should all be the same. Note both ADDR + NELEM and END
13249 point to just beyond the end of the regions that are being tested. */
13250 #define IN_RANGE(START,END,ADDR,NELEM) \
13251 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
13253 /* Check to see if the given reloc needs to be handled in a target specific
13254 manner. If so then process the reloc and return TRUE otherwise return
13257 If called with reloc == NULL, then this is a signal that reloc processing
13258 for the current section has finished, and any saved state should be
13262 target_specific_reloc_handling (Filedata
* filedata
,
13263 Elf_Internal_Rela
* reloc
,
13264 unsigned char * start
,
13265 unsigned char * end
,
13266 Elf_Internal_Sym
* symtab
,
13267 unsigned long num_syms
)
13269 unsigned int reloc_type
= 0;
13270 unsigned long sym_index
= 0;
13274 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
13275 sym_index
= get_reloc_symindex (reloc
->r_info
);
13278 switch (filedata
->file_header
.e_machine
)
13281 case EM_MSP430_OLD
:
13283 static Elf_Internal_Sym
* saved_sym
= NULL
;
13291 switch (reloc_type
)
13293 case 10: /* R_MSP430_SYM_DIFF */
13294 case 12: /* R_MSP430_GNU_SUB_ULEB128 */
13295 if (uses_msp430x_relocs (filedata
))
13297 /* Fall through. */
13298 case 21: /* R_MSP430X_SYM_DIFF */
13299 case 23: /* R_MSP430X_GNU_SUB_ULEB128 */
13301 if (sym_index
>= num_syms
)
13302 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
13305 saved_sym
= symtab
+ sym_index
;
13308 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
13309 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
13310 goto handle_sym_diff
;
13312 case 5: /* R_MSP430_16_BYTE */
13313 case 9: /* R_MSP430_8 */
13314 case 11: /* R_MSP430_GNU_SET_ULEB128 */
13315 if (uses_msp430x_relocs (filedata
))
13317 goto handle_sym_diff
;
13319 case 2: /* R_MSP430_ABS16 */
13320 case 15: /* R_MSP430X_ABS16 */
13321 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
13322 if (! uses_msp430x_relocs (filedata
))
13324 goto handle_sym_diff
;
13327 if (saved_sym
!= NULL
)
13330 unsigned int reloc_size
= 0;
13332 switch (reloc_type
)
13334 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
13337 case 11: /* R_MSP430_GNU_SET_ULEB128 */
13338 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
13339 if (reloc
->r_offset
< (size_t) (end
- start
))
13340 read_leb128 (start
+ reloc
->r_offset
, end
, false,
13341 &reloc_size
, &leb_ret
);
13348 if (leb_ret
!= 0 || reloc_size
== 0 || reloc_size
> 8)
13349 error (_("MSP430 ULEB128 field at 0x%lx contains invalid "
13350 "ULEB128 value\n"),
13351 (long) reloc
->r_offset
);
13352 else if (sym_index
>= num_syms
)
13353 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
13357 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
13358 - saved_sym
->st_value
);
13360 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
13361 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
13364 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
13365 (long) reloc
->r_offset
);
13374 if (saved_sym
!= NULL
)
13375 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13382 case EM_CYGNUS_MN10300
:
13384 static Elf_Internal_Sym
* saved_sym
= NULL
;
13392 switch (reloc_type
)
13394 case 34: /* R_MN10300_ALIGN */
13396 case 33: /* R_MN10300_SYM_DIFF */
13397 if (sym_index
>= num_syms
)
13398 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
13401 saved_sym
= symtab
+ sym_index
;
13404 case 1: /* R_MN10300_32 */
13405 case 2: /* R_MN10300_16 */
13406 if (saved_sym
!= NULL
)
13408 int reloc_size
= reloc_type
== 1 ? 4 : 2;
13411 if (sym_index
>= num_syms
)
13412 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
13416 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
13417 - saved_sym
->st_value
);
13419 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
13420 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
13422 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
13423 (long) reloc
->r_offset
);
13431 if (saved_sym
!= NULL
)
13432 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
13440 static bfd_vma saved_sym1
= 0;
13441 static bfd_vma saved_sym2
= 0;
13442 static bfd_vma value
;
13446 saved_sym1
= saved_sym2
= 0;
13450 switch (reloc_type
)
13452 case 0x80: /* R_RL78_SYM. */
13453 saved_sym1
= saved_sym2
;
13454 if (sym_index
>= num_syms
)
13455 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
13459 saved_sym2
= symtab
[sym_index
].st_value
;
13460 saved_sym2
+= reloc
->r_addend
;
13464 case 0x83: /* R_RL78_OPsub. */
13465 value
= saved_sym1
- saved_sym2
;
13466 saved_sym2
= saved_sym1
= 0;
13470 case 0x41: /* R_RL78_ABS32. */
13471 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
13472 byte_put (start
+ reloc
->r_offset
, value
, 4);
13474 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
13475 (long) reloc
->r_offset
);
13479 case 0x43: /* R_RL78_ABS16. */
13480 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
13481 byte_put (start
+ reloc
->r_offset
, value
, 2);
13483 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
13484 (long) reloc
->r_offset
);
13498 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
13499 DWARF debug sections. This is a target specific test. Note - we do not
13500 go through the whole including-target-headers-multiple-times route, (as
13501 we have already done with <elf/h8.h>) because this would become very
13502 messy and even then this function would have to contain target specific
13503 information (the names of the relocs instead of their numeric values).
13504 FIXME: This is not the correct way to solve this problem. The proper way
13505 is to have target specific reloc sizing and typing functions created by
13506 the reloc-macros.h header, in the same way that it already creates the
13507 reloc naming functions. */
13510 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13512 /* Please keep this table alpha-sorted for ease of visual lookup. */
13513 switch (filedata
->file_header
.e_machine
)
13517 return reloc_type
== 1; /* R_386_32. */
13519 return reloc_type
== 1; /* R_68K_32. */
13521 return reloc_type
== 1; /* R_860_32. */
13523 return reloc_type
== 2; /* R_960_32. */
13525 return (reloc_type
== 258
13526 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
13528 return reloc_type
== 11; /* R_BPF_DATA_32 */
13529 case EM_ADAPTEVA_EPIPHANY
:
13530 return reloc_type
== 3;
13532 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
13534 return reloc_type
== 1; /* R_ARC_32. */
13535 case EM_ARC_COMPACT
:
13536 case EM_ARC_COMPACT2
:
13537 return reloc_type
== 4; /* R_ARC_32. */
13539 return reloc_type
== 2; /* R_ARM_ABS32 */
13542 return reloc_type
== 1;
13544 return reloc_type
== 0x12; /* R_byte4_data. */
13546 return reloc_type
== 3; /* R_CRIS_32. */
13548 return reloc_type
== 3; /* R_CR16_NUM32. */
13550 return reloc_type
== 15; /* R_CRX_NUM32. */
13552 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
13553 case EM_CYGNUS_FRV
:
13554 return reloc_type
== 1;
13555 case EM_CYGNUS_D10V
:
13557 return reloc_type
== 6; /* R_D10V_32. */
13558 case EM_CYGNUS_D30V
:
13560 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
13562 return reloc_type
== 3; /* R_DLX_RELOC_32. */
13563 case EM_CYGNUS_FR30
:
13565 return reloc_type
== 3; /* R_FR30_32. */
13567 return reloc_type
== 1; /* R_FT32_32. */
13571 return reloc_type
== 1; /* R_H8_DIR32. */
13573 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
13574 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
13575 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
13576 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
13579 return reloc_type
== 2; /* R_IP2K_32. */
13581 return reloc_type
== 2; /* R_IQ2000_32. */
13582 case EM_LATTICEMICO32
:
13583 return reloc_type
== 3; /* R_LM32_32. */
13586 return reloc_type
== 3; /* R_M32C_32. */
13588 return reloc_type
== 34; /* R_M32R_32_RELA. */
13591 return reloc_type
== 6; /* R_M68HC11_32. */
13593 return reloc_type
== 7 || /* R_S12Z_EXT32 */
13594 reloc_type
== 6; /* R_S12Z_CW32. */
13596 return reloc_type
== 1; /* R_MCORE_ADDR32. */
13597 case EM_CYGNUS_MEP
:
13598 return reloc_type
== 4; /* R_MEP_32. */
13600 return reloc_type
== 2; /* R_METAG_ADDR32. */
13601 case EM_MICROBLAZE
:
13602 return reloc_type
== 1; /* R_MICROBLAZE_32. */
13604 return reloc_type
== 2; /* R_MIPS_32. */
13606 return reloc_type
== 4; /* R_MMIX_32. */
13607 case EM_CYGNUS_MN10200
:
13609 return reloc_type
== 1; /* R_MN10200_32. */
13610 case EM_CYGNUS_MN10300
:
13612 return reloc_type
== 1; /* R_MN10300_32. */
13614 return reloc_type
== 1; /* R_MOXIE_32. */
13615 case EM_MSP430_OLD
:
13617 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
13619 return reloc_type
== 2; /* R_MT_32. */
13621 return reloc_type
== 20; /* R_NDS32_RELA. */
13622 case EM_ALTERA_NIOS2
:
13623 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
13625 return reloc_type
== 1; /* R_NIOS_32. */
13627 return reloc_type
== 1; /* R_OR1K_32. */
13629 return (reloc_type
== 1 /* R_PARISC_DIR32. */
13630 || reloc_type
== 2 /* R_PARISC_DIR21L. */
13631 || reloc_type
== 41); /* R_PARISC_SECREL32. */
13634 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
13636 return reloc_type
== 1; /* R_PPC64_ADDR32. */
13638 return reloc_type
== 1; /* R_PPC_ADDR32. */
13640 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
13642 return reloc_type
== 1; /* R_RISCV_32. */
13644 return reloc_type
== 1; /* R_RL78_DIR32. */
13646 return reloc_type
== 1; /* R_RX_DIR32. */
13648 return reloc_type
== 1; /* R_I370_ADDR31. */
13651 return reloc_type
== 4; /* R_S390_32. */
13653 return reloc_type
== 8; /* R_SCORE_ABS32. */
13655 return reloc_type
== 1; /* R_SH_DIR32. */
13656 case EM_SPARC32PLUS
:
13659 return reloc_type
== 3 /* R_SPARC_32. */
13660 || reloc_type
== 23; /* R_SPARC_UA32. */
13662 return reloc_type
== 6; /* R_SPU_ADDR32 */
13664 return reloc_type
== 1; /* R_C6000_ABS32. */
13666 return reloc_type
== 2; /* R_TILEGX_32. */
13668 return reloc_type
== 1; /* R_TILEPRO_32. */
13669 case EM_CYGNUS_V850
:
13671 return reloc_type
== 6; /* R_V850_ABS32. */
13673 return reloc_type
== 0x33; /* R_V810_WORD. */
13675 return reloc_type
== 1; /* R_VAX_32. */
13677 return reloc_type
== 3; /* R_VISIUM_32. */
13678 case EM_WEBASSEMBLY
:
13679 return reloc_type
== 1; /* R_WASM32_32. */
13683 return reloc_type
== 10; /* R_X86_64_32. */
13686 return reloc_type
== 3; /* R_XC16C_ABS_32. */
13688 return reloc_type
== 4; /* R_XGATE_32. */
13690 return reloc_type
== 1; /* R_XSTROMY16_32. */
13691 case EM_XTENSA_OLD
:
13693 return reloc_type
== 1; /* R_XTENSA_32. */
13695 return reloc_type
== 6; /* R_Z80_32. */
13698 static unsigned int prev_warn
= 0;
13700 /* Avoid repeating the same warning multiple times. */
13701 if (prev_warn
!= filedata
->file_header
.e_machine
)
13702 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
13703 filedata
->file_header
.e_machine
);
13704 prev_warn
= filedata
->file_header
.e_machine
;
13710 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13711 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
13714 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13716 switch (filedata
->file_header
.e_machine
)
13717 /* Please keep this table alpha-sorted for ease of visual lookup. */
13721 return reloc_type
== 2; /* R_386_PC32. */
13723 return reloc_type
== 4; /* R_68K_PC32. */
13725 return reloc_type
== 261; /* R_AARCH64_PREL32 */
13726 case EM_ADAPTEVA_EPIPHANY
:
13727 return reloc_type
== 6;
13729 return reloc_type
== 10; /* R_ALPHA_SREL32. */
13730 case EM_ARC_COMPACT
:
13731 case EM_ARC_COMPACT2
:
13732 return reloc_type
== 49; /* R_ARC_32_PCREL. */
13734 return reloc_type
== 3; /* R_ARM_REL32 */
13737 return reloc_type
== 36; /* R_AVR_32_PCREL. */
13738 case EM_MICROBLAZE
:
13739 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
13741 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
13743 return reloc_type
== 9; /* R_PARISC_PCREL32. */
13745 return reloc_type
== 26; /* R_PPC_REL32. */
13747 return reloc_type
== 26; /* R_PPC64_REL32. */
13749 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
13752 return reloc_type
== 5; /* R_390_PC32. */
13754 return reloc_type
== 2; /* R_SH_REL32. */
13755 case EM_SPARC32PLUS
:
13758 return reloc_type
== 6; /* R_SPARC_DISP32. */
13760 return reloc_type
== 13; /* R_SPU_REL32. */
13762 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
13764 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
13766 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
13770 return reloc_type
== 2; /* R_X86_64_PC32. */
13772 return reloc_type
== 4; /* R_VAX_PCREL32. */
13773 case EM_XTENSA_OLD
:
13775 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
13777 /* Do not abort or issue an error message here. Not all targets use
13778 pc-relative 32-bit relocs in their DWARF debug information and we
13779 have already tested for target coverage in is_32bit_abs_reloc. A
13780 more helpful warning message will be generated by apply_relocations
13781 anyway, so just return. */
13786 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13787 a 64-bit absolute RELA relocation used in DWARF debug sections. */
13790 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13792 switch (filedata
->file_header
.e_machine
)
13795 return reloc_type
== 257; /* R_AARCH64_ABS64. */
13797 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
13799 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
13800 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
13802 return reloc_type
== 80; /* R_PARISC_DIR64. */
13804 return reloc_type
== 38; /* R_PPC64_ADDR64. */
13806 return reloc_type
== 2; /* R_RISCV_64. */
13807 case EM_SPARC32PLUS
:
13810 return reloc_type
== 32 /* R_SPARC_64. */
13811 || reloc_type
== 54; /* R_SPARC_UA64. */
13815 return reloc_type
== 1; /* R_X86_64_64. */
13818 return reloc_type
== 22; /* R_S390_64. */
13820 return reloc_type
== 1; /* R_TILEGX_64. */
13822 return reloc_type
== 18; /* R_MIPS_64. */
13828 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
13829 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
13832 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13834 switch (filedata
->file_header
.e_machine
)
13837 return reloc_type
== 260; /* R_AARCH64_PREL64. */
13839 return reloc_type
== 11; /* R_ALPHA_SREL64. */
13841 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
13842 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
13844 return reloc_type
== 72; /* R_PARISC_PCREL64. */
13846 return reloc_type
== 44; /* R_PPC64_REL64. */
13847 case EM_SPARC32PLUS
:
13850 return reloc_type
== 46; /* R_SPARC_DISP64. */
13854 return reloc_type
== 24; /* R_X86_64_PC64. */
13857 return reloc_type
== 23; /* R_S390_PC64. */
13859 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
13865 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13866 a 24-bit absolute RELA relocation used in DWARF debug sections. */
13869 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13871 switch (filedata
->file_header
.e_machine
)
13873 case EM_CYGNUS_MN10200
:
13875 return reloc_type
== 4; /* R_MN10200_24. */
13877 return reloc_type
== 5; /* R_FT32_20. */
13879 return reloc_type
== 5; /* R_Z80_24. */
13885 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13886 a 16-bit absolute RELA relocation used in DWARF debug sections. */
13889 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13891 /* Please keep this table alpha-sorted for ease of visual lookup. */
13892 switch (filedata
->file_header
.e_machine
)
13895 case EM_ARC_COMPACT
:
13896 case EM_ARC_COMPACT2
:
13897 return reloc_type
== 2; /* R_ARC_16. */
13898 case EM_ADAPTEVA_EPIPHANY
:
13899 return reloc_type
== 5;
13902 return reloc_type
== 4; /* R_AVR_16. */
13903 case EM_CYGNUS_D10V
:
13905 return reloc_type
== 3; /* R_D10V_16. */
13907 return reloc_type
== 2; /* R_FT32_16. */
13911 return reloc_type
== R_H8_DIR16
;
13914 return reloc_type
== 1; /* R_IP2K_16. */
13917 return reloc_type
== 1; /* R_M32C_16 */
13918 case EM_CYGNUS_MN10200
:
13920 return reloc_type
== 2; /* R_MN10200_16. */
13921 case EM_CYGNUS_MN10300
:
13923 return reloc_type
== 2; /* R_MN10300_16. */
13925 if (uses_msp430x_relocs (filedata
))
13926 return reloc_type
== 2; /* R_MSP430_ABS16. */
13927 /* Fall through. */
13928 case EM_MSP430_OLD
:
13929 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13931 return reloc_type
== 19; /* R_NDS32_RELA. */
13932 case EM_ALTERA_NIOS2
:
13933 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13935 return reloc_type
== 9; /* R_NIOS_16. */
13937 return reloc_type
== 2; /* R_OR1K_16. */
13939 return reloc_type
== 55; /* R_RISCV_SET16. */
13941 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13943 return reloc_type
== 2; /* R_C6000_ABS16. */
13945 return reloc_type
== 2; /* R_VISIUM_16. */
13948 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13950 return reloc_type
== 3; /* R_XGATE_16. */
13952 return reloc_type
== 4; /* R_Z80_16. */
13958 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13959 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13962 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13964 switch (filedata
->file_header
.e_machine
)
13967 return reloc_type
== 54; /* R_RISCV_SET8. */
13969 return reloc_type
== 1; /* R_Z80_8. */
13975 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13976 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13979 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13981 switch (filedata
->file_header
.e_machine
)
13984 return reloc_type
== 53; /* R_RISCV_SET6. */
13990 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13991 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13994 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13996 /* Please keep this table alpha-sorted for ease of visual lookup. */
13997 switch (filedata
->file_header
.e_machine
)
14000 return reloc_type
== 35; /* R_RISCV_ADD32. */
14006 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14007 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
14010 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14012 /* Please keep this table alpha-sorted for ease of visual lookup. */
14013 switch (filedata
->file_header
.e_machine
)
14016 return reloc_type
== 39; /* R_RISCV_SUB32. */
14022 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14023 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
14026 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14028 /* Please keep this table alpha-sorted for ease of visual lookup. */
14029 switch (filedata
->file_header
.e_machine
)
14032 return reloc_type
== 36; /* R_RISCV_ADD64. */
14038 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14039 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
14042 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14044 /* Please keep this table alpha-sorted for ease of visual lookup. */
14045 switch (filedata
->file_header
.e_machine
)
14048 return reloc_type
== 40; /* R_RISCV_SUB64. */
14054 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14055 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
14058 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14060 /* Please keep this table alpha-sorted for ease of visual lookup. */
14061 switch (filedata
->file_header
.e_machine
)
14064 return reloc_type
== 34; /* R_RISCV_ADD16. */
14070 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14071 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
14074 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14076 /* Please keep this table alpha-sorted for ease of visual lookup. */
14077 switch (filedata
->file_header
.e_machine
)
14080 return reloc_type
== 38; /* R_RISCV_SUB16. */
14086 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14087 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
14090 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14092 /* Please keep this table alpha-sorted for ease of visual lookup. */
14093 switch (filedata
->file_header
.e_machine
)
14096 return reloc_type
== 33; /* R_RISCV_ADD8. */
14102 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14103 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
14106 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14108 /* Please keep this table alpha-sorted for ease of visual lookup. */
14109 switch (filedata
->file_header
.e_machine
)
14112 return reloc_type
== 37; /* R_RISCV_SUB8. */
14118 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14119 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
14122 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14124 switch (filedata
->file_header
.e_machine
)
14127 return reloc_type
== 52; /* R_RISCV_SUB6. */
14133 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
14134 relocation entries (possibly formerly used for SHT_GROUP sections). */
14137 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14139 switch (filedata
->file_header
.e_machine
)
14141 case EM_386
: /* R_386_NONE. */
14142 case EM_68K
: /* R_68K_NONE. */
14143 case EM_ADAPTEVA_EPIPHANY
:
14144 case EM_ALPHA
: /* R_ALPHA_NONE. */
14145 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
14146 case EM_ARC
: /* R_ARC_NONE. */
14147 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
14148 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
14149 case EM_ARM
: /* R_ARM_NONE. */
14150 case EM_C166
: /* R_XC16X_NONE. */
14151 case EM_CRIS
: /* R_CRIS_NONE. */
14152 case EM_FT32
: /* R_FT32_NONE. */
14153 case EM_IA_64
: /* R_IA64_NONE. */
14154 case EM_K1OM
: /* R_X86_64_NONE. */
14155 case EM_L1OM
: /* R_X86_64_NONE. */
14156 case EM_M32R
: /* R_M32R_NONE. */
14157 case EM_MIPS
: /* R_MIPS_NONE. */
14158 case EM_MN10300
: /* R_MN10300_NONE. */
14159 case EM_MOXIE
: /* R_MOXIE_NONE. */
14160 case EM_NIOS32
: /* R_NIOS_NONE. */
14161 case EM_OR1K
: /* R_OR1K_NONE. */
14162 case EM_PARISC
: /* R_PARISC_NONE. */
14163 case EM_PPC64
: /* R_PPC64_NONE. */
14164 case EM_PPC
: /* R_PPC_NONE. */
14165 case EM_RISCV
: /* R_RISCV_NONE. */
14166 case EM_S390
: /* R_390_NONE. */
14168 case EM_SH
: /* R_SH_NONE. */
14169 case EM_SPARC32PLUS
:
14170 case EM_SPARC
: /* R_SPARC_NONE. */
14172 case EM_TILEGX
: /* R_TILEGX_NONE. */
14173 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
14174 case EM_TI_C6000
:/* R_C6000_NONE. */
14175 case EM_X86_64
: /* R_X86_64_NONE. */
14177 case EM_Z80
: /* R_Z80_NONE. */
14178 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
14179 return reloc_type
== 0;
14182 return reloc_type
== 0 || reloc_type
== 256;
14185 return (reloc_type
== 0 /* R_AVR_NONE. */
14186 || reloc_type
== 30 /* R_AVR_DIFF8. */
14187 || reloc_type
== 31 /* R_AVR_DIFF16. */
14188 || reloc_type
== 32 /* R_AVR_DIFF32. */);
14190 return reloc_type
== 3; /* R_METAG_NONE. */
14192 return (reloc_type
== 0 /* R_XTENSA_NONE. */
14193 || reloc_type
== 204 /* R_NDS32_DIFF8. */
14194 || reloc_type
== 205 /* R_NDS32_DIFF16. */
14195 || reloc_type
== 206 /* R_NDS32_DIFF32. */
14196 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
14198 return (reloc_type
== 0 /* R_PRU_NONE. */
14199 || reloc_type
== 65 /* R_PRU_DIFF8. */
14200 || reloc_type
== 66 /* R_PRU_DIFF16. */
14201 || reloc_type
== 67 /* R_PRU_DIFF32. */);
14202 case EM_XTENSA_OLD
:
14204 return (reloc_type
== 0 /* R_XTENSA_NONE. */
14205 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
14206 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
14207 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
14208 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
14209 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
14210 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
14211 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
14212 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
14213 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
14218 /* Returns TRUE if there is a relocation against
14219 section NAME at OFFSET bytes. */
14222 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
14224 Elf_Internal_Rela
* relocs
;
14225 Elf_Internal_Rela
* rp
;
14227 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
14230 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
14232 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
14233 if (rp
->r_offset
== offset
)
14239 /* Apply relocations to a section.
14240 Returns TRUE upon success, FALSE otherwise.
14241 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
14242 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
14243 will be set to the number of relocs loaded.
14245 Note: So far support has been added only for those relocations
14246 which can be found in debug sections. FIXME: Add support for
14247 more relocations ? */
14250 apply_relocations (Filedata
* filedata
,
14251 const Elf_Internal_Shdr
* section
,
14252 unsigned char * start
,
14253 bfd_size_type size
,
14254 void ** relocs_return
,
14255 unsigned long * num_relocs_return
)
14257 Elf_Internal_Shdr
* relsec
;
14258 unsigned char * end
= start
+ size
;
14260 if (relocs_return
!= NULL
)
14262 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
14263 * num_relocs_return
= 0;
14266 if (filedata
->file_header
.e_type
!= ET_REL
)
14267 /* No relocs to apply. */
14270 /* Find the reloc section associated with the section. */
14271 for (relsec
= filedata
->section_headers
;
14272 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14276 unsigned long num_relocs
;
14277 Elf_Internal_Rela
* relocs
;
14278 Elf_Internal_Rela
* rp
;
14279 Elf_Internal_Shdr
* symsec
;
14280 Elf_Internal_Sym
* symtab
;
14281 unsigned long num_syms
;
14282 Elf_Internal_Sym
* sym
;
14284 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14285 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14286 || filedata
->section_headers
+ relsec
->sh_info
!= section
14287 || relsec
->sh_size
== 0
14288 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14291 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
14292 if (symsec
->sh_type
!= SHT_SYMTAB
14293 && symsec
->sh_type
!= SHT_DYNSYM
)
14296 is_rela
= relsec
->sh_type
== SHT_RELA
;
14300 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
14301 relsec
->sh_size
, & relocs
, & num_relocs
))
14306 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
14307 relsec
->sh_size
, & relocs
, & num_relocs
))
14311 /* SH uses RELA but uses in place value instead of the addend field. */
14312 if (filedata
->file_header
.e_machine
== EM_SH
)
14315 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
14317 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
14320 unsigned int reloc_type
;
14321 unsigned int reloc_size
;
14322 bool reloc_inplace
= false;
14323 bool reloc_subtract
= false;
14324 unsigned char *rloc
;
14325 unsigned long sym_index
;
14327 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
14329 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
14331 else if (is_none_reloc (filedata
, reloc_type
))
14333 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
14334 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
14336 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
14337 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
14339 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
14341 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
14343 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
14344 || is_6bit_abs_reloc (filedata
, reloc_type
))
14346 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
14348 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
14351 reloc_inplace
= true;
14353 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
14355 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
14358 reloc_inplace
= true;
14360 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
14362 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
14365 reloc_inplace
= true;
14367 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
14369 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
14372 reloc_inplace
= true;
14374 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
14378 reloc_inplace
= true;
14382 static unsigned int prev_reloc
= 0;
14384 if (reloc_type
!= prev_reloc
)
14385 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
14386 reloc_type
, printable_section_name (filedata
, section
));
14387 prev_reloc
= reloc_type
;
14391 rloc
= start
+ rp
->r_offset
;
14392 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
14394 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
14395 (unsigned long) rp
->r_offset
,
14396 printable_section_name (filedata
, section
));
14400 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
14401 if (sym_index
>= num_syms
)
14403 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
14404 sym_index
, printable_section_name (filedata
, section
));
14407 sym
= symtab
+ sym_index
;
14409 /* If the reloc has a symbol associated with it,
14410 make sure that it is of an appropriate type.
14412 Relocations against symbols without type can happen.
14413 Gcc -feliminate-dwarf2-dups may generate symbols
14414 without type for debug info.
14416 Icc generates relocations against function symbols
14417 instead of local labels.
14419 Relocations against object symbols can happen, eg when
14420 referencing a global array. For an example of this see
14421 the _clz.o binary in libgcc.a. */
14423 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
14424 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
14426 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
14427 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
14428 printable_section_name (filedata
, relsec
),
14429 (long int)(rp
- relocs
));
14435 addend
+= rp
->r_addend
;
14436 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
14437 partial_inplace. */
14439 || (filedata
->file_header
.e_machine
== EM_XTENSA
14440 && reloc_type
== 1)
14441 || ((filedata
->file_header
.e_machine
== EM_PJ
14442 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
14443 && reloc_type
== 1)
14444 || ((filedata
->file_header
.e_machine
== EM_D30V
14445 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
14446 && reloc_type
== 12)
14449 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
14450 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
14452 addend
+= byte_get (rloc
, reloc_size
);
14455 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
14456 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
14458 /* On HPPA, all pc-relative relocations are biased by 8. */
14459 if (filedata
->file_header
.e_machine
== EM_PARISC
)
14461 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
14464 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
14465 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
14467 if (reloc_subtract
)
14468 addend
-= sym
->st_value
;
14470 addend
+= sym
->st_value
;
14471 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
14472 byte_put (rloc
, addend
, reloc_size
);
14474 else if (reloc_subtract
)
14475 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
14477 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
14481 /* Let the target specific reloc processing code know that
14482 we have finished with these relocs. */
14483 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
14487 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
14488 * num_relocs_return
= num_relocs
;
14499 #ifdef SUPPORT_DISASSEMBLY
14501 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14503 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
14505 /* FIXME: XXX -- to be done --- XXX */
14511 /* Reads in the contents of SECTION from FILE, returning a pointer
14512 to a malloc'ed buffer or NULL if something went wrong. */
14515 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14517 bfd_size_type num_bytes
= section
->sh_size
;
14519 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
14521 printf (_("Section '%s' has no data to dump.\n"),
14522 printable_section_name (filedata
, section
));
14526 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
14527 _("section contents"));
14530 /* Uncompresses a section that was compressed using zlib, in place. */
14533 uncompress_section_contents (unsigned char ** buffer
,
14534 dwarf_size_type uncompressed_size
,
14535 dwarf_size_type
* size
)
14537 dwarf_size_type compressed_size
= *size
;
14538 unsigned char * compressed_buffer
= *buffer
;
14539 unsigned char * uncompressed_buffer
;
14543 /* It is possible the section consists of several compressed
14544 buffers concatenated together, so we uncompress in a loop. */
14545 /* PR 18313: The state field in the z_stream structure is supposed
14546 to be invisible to the user (ie us), but some compilers will
14547 still complain about it being used without initialisation. So
14548 we first zero the entire z_stream structure and then set the fields
14550 memset (& strm
, 0, sizeof strm
);
14551 strm
.avail_in
= compressed_size
;
14552 strm
.next_in
= (Bytef
*) compressed_buffer
;
14553 strm
.avail_out
= uncompressed_size
;
14554 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
14556 rc
= inflateInit (& strm
);
14557 while (strm
.avail_in
> 0)
14561 strm
.next_out
= ((Bytef
*) uncompressed_buffer
14562 + (uncompressed_size
- strm
.avail_out
));
14563 rc
= inflate (&strm
, Z_FINISH
);
14564 if (rc
!= Z_STREAM_END
)
14566 rc
= inflateReset (& strm
);
14568 if (inflateEnd (& strm
) != Z_OK
14570 || strm
.avail_out
!= 0)
14573 *buffer
= uncompressed_buffer
;
14574 *size
= uncompressed_size
;
14578 free (uncompressed_buffer
);
14579 /* Indicate decompression failure. */
14585 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14587 Elf_Internal_Shdr
*relsec
;
14588 bfd_size_type num_bytes
;
14589 unsigned char *data
;
14590 unsigned char *end
;
14591 unsigned char *real_start
;
14592 unsigned char *start
;
14593 bool some_strings_shown
;
14595 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
14597 /* PR 21820: Do not fail if the section was empty. */
14598 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
14600 num_bytes
= section
->sh_size
;
14602 if (filedata
->is_separate
)
14603 printf (_("\nString dump of section '%s' in linked file %s:\n"),
14604 printable_section_name (filedata
, section
),
14605 filedata
->file_name
);
14607 printf (_("\nString dump of section '%s':\n"),
14608 printable_section_name (filedata
, section
));
14610 if (decompress_dumps
)
14612 dwarf_size_type new_size
= num_bytes
;
14613 dwarf_size_type uncompressed_size
= 0;
14615 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14617 Elf_Internal_Chdr chdr
;
14618 unsigned int compression_header_size
14619 = get_compression_header (& chdr
, (unsigned char *) start
,
14621 if (compression_header_size
== 0)
14622 /* An error message will have already been generated
14623 by get_compression_header. */
14626 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14628 warn (_("section '%s' has unsupported compress type: %d\n"),
14629 printable_section_name (filedata
, section
), chdr
.ch_type
);
14632 uncompressed_size
= chdr
.ch_size
;
14633 start
+= compression_header_size
;
14634 new_size
-= compression_header_size
;
14636 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14638 /* Read the zlib header. In this case, it should be "ZLIB"
14639 followed by the uncompressed section size, 8 bytes in
14640 big-endian order. */
14641 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14642 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14643 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14644 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14645 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14646 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14647 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14648 uncompressed_size
+= start
[11];
14653 if (uncompressed_size
)
14655 if (uncompress_section_contents (& start
,
14656 uncompressed_size
, & new_size
))
14657 num_bytes
= new_size
;
14660 error (_("Unable to decompress section %s\n"),
14661 printable_section_name (filedata
, section
));
14666 start
= real_start
;
14669 /* If the section being dumped has relocations against it the user might
14670 be expecting these relocations to have been applied. Check for this
14671 case and issue a warning message in order to avoid confusion.
14672 FIXME: Maybe we ought to have an option that dumps a section with
14673 relocs applied ? */
14674 for (relsec
= filedata
->section_headers
;
14675 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14678 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14679 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14680 || filedata
->section_headers
+ relsec
->sh_info
!= section
14681 || relsec
->sh_size
== 0
14682 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14685 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14690 end
= start
+ num_bytes
;
14691 some_strings_shown
= false;
14693 #ifdef HAVE_MBSTATE_T
14695 /* Initialise the multibyte conversion state. */
14696 memset (& state
, 0, sizeof (state
));
14699 bool continuing
= false;
14703 while (!ISPRINT (* data
))
14704 if (++ data
>= end
)
14709 size_t maxlen
= end
- data
;
14714 continuing
= false;
14718 printf (" [%6lx] ", (unsigned long) (data
- start
));
14732 /* PR 25543: Treat new-lines as string-ending characters. */
14741 /* Do not print control characters directly as they can affect terminal
14742 settings. Such characters usually appear in the names generated
14743 by the assembler for local labels. */
14746 printf ("^%c", c
+ 0x40);
14748 else if (ISPRINT (c
))
14755 #ifdef HAVE_MBSTATE_T
14758 /* Let printf do the hard work of displaying multibyte characters. */
14759 printf ("%.1s", data
- 1);
14760 #ifdef HAVE_MBSTATE_T
14761 /* Try to find out how many bytes made up the character that was
14762 just printed. Advance the symbol pointer past the bytes that
14764 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
14768 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
14778 printf (_("<corrupt>\n"));
14781 some_strings_shown
= true;
14785 if (! some_strings_shown
)
14786 printf (_(" No strings found in this section."));
14799 dump_section_as_bytes (Elf_Internal_Shdr
*section
,
14800 Filedata
*filedata
,
14803 Elf_Internal_Shdr
* relsec
;
14804 bfd_size_type bytes
;
14805 bfd_size_type section_size
;
14807 unsigned char * data
;
14808 unsigned char * real_start
;
14809 unsigned char * start
;
14811 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
14813 /* PR 21820: Do not fail if the section was empty. */
14814 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
14816 section_size
= section
->sh_size
;
14818 if (filedata
->is_separate
)
14819 printf (_("\nHex dump of section '%s' in linked file %s:\n"),
14820 printable_section_name (filedata
, section
),
14821 filedata
->file_name
);
14823 printf (_("\nHex dump of section '%s':\n"),
14824 printable_section_name (filedata
, section
));
14826 if (decompress_dumps
)
14828 dwarf_size_type new_size
= section_size
;
14829 dwarf_size_type uncompressed_size
= 0;
14831 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14833 Elf_Internal_Chdr chdr
;
14834 unsigned int compression_header_size
14835 = get_compression_header (& chdr
, start
, section_size
);
14837 if (compression_header_size
== 0)
14838 /* An error message will have already been generated
14839 by get_compression_header. */
14842 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14844 warn (_("section '%s' has unsupported compress type: %d\n"),
14845 printable_section_name (filedata
, section
), chdr
.ch_type
);
14848 uncompressed_size
= chdr
.ch_size
;
14849 start
+= compression_header_size
;
14850 new_size
-= compression_header_size
;
14852 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14854 /* Read the zlib header. In this case, it should be "ZLIB"
14855 followed by the uncompressed section size, 8 bytes in
14856 big-endian order. */
14857 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14858 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14859 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14860 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14861 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14862 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14863 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14864 uncompressed_size
+= start
[11];
14869 if (uncompressed_size
)
14871 if (uncompress_section_contents (& start
, uncompressed_size
,
14874 section_size
= new_size
;
14878 error (_("Unable to decompress section %s\n"),
14879 printable_section_name (filedata
, section
));
14880 /* FIXME: Print the section anyway ? */
14885 start
= real_start
;
14890 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
14895 /* If the section being dumped has relocations against it the user might
14896 be expecting these relocations to have been applied. Check for this
14897 case and issue a warning message in order to avoid confusion.
14898 FIXME: Maybe we ought to have an option that dumps a section with
14899 relocs applied ? */
14900 for (relsec
= filedata
->section_headers
;
14901 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14904 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14905 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14906 || filedata
->section_headers
+ relsec
->sh_info
!= section
14907 || relsec
->sh_size
== 0
14908 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14911 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14916 addr
= section
->sh_addr
;
14917 bytes
= section_size
;
14926 lbytes
= (bytes
> 16 ? 16 : bytes
);
14928 printf (" 0x%8.8lx ", (unsigned long) addr
);
14930 for (j
= 0; j
< 16; j
++)
14933 printf ("%2.2x", data
[j
]);
14941 for (j
= 0; j
< lbytes
; j
++)
14944 if (k
>= ' ' && k
< 0x7f)
14967 #ifdef ENABLE_LIBCTF
14968 static ctf_sect_t
*
14969 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14971 buf
->cts_name
= SECTION_NAME_PRINT (shdr
);
14972 buf
->cts_size
= shdr
->sh_size
;
14973 buf
->cts_entsize
= shdr
->sh_entsize
;
14978 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14979 it is passed, or a pointer to newly-allocated storage, in which case
14980 dump_ctf() will free it when it no longer needs it. */
14983 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14984 char *s
, void *arg
)
14986 const char *blanks
= arg
;
14989 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14994 /* Dump CTF errors/warnings. */
14996 dump_ctf_errs (ctf_dict_t
*fp
)
14998 ctf_next_t
*it
= NULL
;
15003 /* Dump accumulated errors and warnings. */
15004 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
15006 error (_("%s: %s"), is_warning
? _("warning"): _("error"),
15010 if (err
!= ECTF_NEXT_END
)
15011 error (_("CTF error: cannot get CTF errors: `%s'"), ctf_errmsg (err
));
15014 /* Dump one CTF archive member. */
15017 dump_ctf_archive_member (ctf_dict_t
*ctf
, const char *name
, void *arg
)
15019 ctf_dict_t
*parent
= (ctf_dict_t
*) arg
;
15020 const char *things
[] = {"Header", "Labels", "Data objects",
15021 "Function objects", "Variables", "Types", "Strings",
15023 const char **thing
;
15027 /* Only print out the name of non-default-named archive members.
15028 The name .ctf appears everywhere, even for things that aren't
15029 really archives, so printing it out is liable to be confusing.
15031 The parent, if there is one, is the default-owned archive member:
15032 avoid importing it into itself. (This does no harm, but looks
15035 if (strcmp (name
, ".ctf") != 0)
15037 printf (_("\nCTF archive member: %s:\n"), name
);
15038 ctf_import (ctf
, parent
);
15041 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
15043 ctf_dump_state_t
*s
= NULL
;
15046 printf ("\n %s:\n", *thing
);
15047 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
15048 (void *) " ")) != NULL
)
15050 printf ("%s\n", item
);
15054 if (ctf_errno (ctf
))
15056 error (_("Iteration failed: %s, %s\n"), *thing
,
15057 ctf_errmsg (ctf_errno (ctf
)));
15064 dump_ctf_errs (ctf
);
15069 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15071 Elf_Internal_Shdr
* parent_sec
= NULL
;
15072 Elf_Internal_Shdr
* symtab_sec
= NULL
;
15073 Elf_Internal_Shdr
* strtab_sec
= NULL
;
15074 void * data
= NULL
;
15075 void * symdata
= NULL
;
15076 void * strdata
= NULL
;
15077 void * parentdata
= NULL
;
15078 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
15079 ctf_sect_t
* symsectp
= NULL
;
15080 ctf_sect_t
* strsectp
= NULL
;
15081 ctf_archive_t
* ctfa
= NULL
;
15082 ctf_archive_t
* parenta
= NULL
, *lookparent
;
15083 ctf_dict_t
* parent
= NULL
;
15088 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
15089 data
= get_section_contents (section
, filedata
);
15090 ctfsect
.cts_data
= data
;
15092 if (!dump_ctf_symtab_name
)
15093 dump_ctf_symtab_name
= strdup (".dynsym");
15095 if (!dump_ctf_strtab_name
)
15096 dump_ctf_strtab_name
= strdup (".dynstr");
15098 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
15100 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
15102 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
15105 if ((symdata
= (void *) get_data (NULL
, filedata
,
15106 symtab_sec
->sh_offset
, 1,
15107 symtab_sec
->sh_size
,
15108 _("symbols"))) == NULL
)
15110 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
15111 symsect
.cts_data
= symdata
;
15114 if (dump_ctf_strtab_name
&& dump_ctf_strtab_name
[0] != 0)
15116 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
15118 error (_("No string table section named %s\n"),
15119 dump_ctf_strtab_name
);
15122 if ((strdata
= (void *) get_data (NULL
, filedata
,
15123 strtab_sec
->sh_offset
, 1,
15124 strtab_sec
->sh_size
,
15125 _("strings"))) == NULL
)
15127 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
15128 strsect
.cts_data
= strdata
;
15131 if (dump_ctf_parent_name
)
15133 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
15135 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
15138 if ((parentdata
= (void *) get_data (NULL
, filedata
,
15139 parent_sec
->sh_offset
, 1,
15140 parent_sec
->sh_size
,
15141 _("CTF parent"))) == NULL
)
15143 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
15144 parentsect
.cts_data
= parentdata
;
15147 /* Load the CTF file and dump it. It may be a raw CTF section, or an archive:
15148 libctf papers over the difference, so we can pretend it is always an
15149 archive. Possibly open the parent as well, if one was specified. */
15151 if ((ctfa
= ctf_arc_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
15153 dump_ctf_errs (NULL
);
15154 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15158 ctf_arc_symsect_endianness (ctfa
, filedata
->file_header
.e_ident
[EI_DATA
]
15163 if ((parenta
= ctf_arc_bufopen (&parentsect
, symsectp
, strsectp
,
15166 dump_ctf_errs (NULL
);
15167 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15170 lookparent
= parenta
;
15175 /* Assume that the applicable parent archive member is the default one.
15176 (This is what all known implementations are expected to do, if they
15177 put CTFs and their parents in archives together.) */
15178 if ((parent
= ctf_dict_open (lookparent
, NULL
, &err
)) == NULL
)
15180 dump_ctf_errs (NULL
);
15181 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15187 if (filedata
->is_separate
)
15188 printf (_("\nDump of CTF section '%s' in linked file %s:\n"),
15189 printable_section_name (filedata
, section
),
15190 filedata
->file_name
);
15192 printf (_("\nDump of CTF section '%s':\n"),
15193 printable_section_name (filedata
, section
));
15195 if ((err
= ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
)) != 0)
15197 dump_ctf_errs (NULL
);
15198 error (_("CTF member open failure: %s\n"), ctf_errmsg (err
));
15203 ctf_dict_close (parent
);
15205 ctf_close (parenta
);
15215 load_specific_debug_section (enum dwarf_section_display_enum debug
,
15216 const Elf_Internal_Shdr
* sec
,
15219 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15221 Filedata
* filedata
= (Filedata
*) data
;
15223 if (section
->start
!= NULL
)
15225 /* If it is already loaded, do nothing. */
15226 if (streq (section
->filename
, filedata
->file_name
))
15228 free (section
->start
);
15231 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
15232 section
->address
= sec
->sh_addr
;
15233 section
->filename
= filedata
->file_name
;
15234 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
15236 sec
->sh_size
, buf
);
15237 if (section
->start
== NULL
)
15241 unsigned char *start
= section
->start
;
15242 dwarf_size_type size
= sec
->sh_size
;
15243 dwarf_size_type uncompressed_size
= 0;
15245 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
15247 Elf_Internal_Chdr chdr
;
15248 unsigned int compression_header_size
;
15250 if (size
< (is_32bit_elf
15251 ? sizeof (Elf32_External_Chdr
)
15252 : sizeof (Elf64_External_Chdr
)))
15254 warn (_("compressed section %s is too small to contain a compression header\n"),
15259 compression_header_size
= get_compression_header (&chdr
, start
, size
);
15260 if (compression_header_size
== 0)
15261 /* An error message will have already been generated
15262 by get_compression_header. */
15265 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
15267 warn (_("section '%s' has unsupported compress type: %d\n"),
15268 section
->name
, chdr
.ch_type
);
15271 uncompressed_size
= chdr
.ch_size
;
15272 start
+= compression_header_size
;
15273 size
-= compression_header_size
;
15275 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
15277 /* Read the zlib header. In this case, it should be "ZLIB"
15278 followed by the uncompressed section size, 8 bytes in
15279 big-endian order. */
15280 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
15281 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
15282 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
15283 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
15284 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
15285 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
15286 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
15287 uncompressed_size
+= start
[11];
15292 if (uncompressed_size
)
15294 if (uncompress_section_contents (&start
, uncompressed_size
,
15297 /* Free the compressed buffer, update the section buffer
15298 and the section size if uncompress is successful. */
15299 free (section
->start
);
15300 section
->start
= start
;
15304 error (_("Unable to decompress section %s\n"),
15305 printable_section_name (filedata
, sec
));
15310 section
->size
= size
;
15313 if (section
->start
== NULL
)
15316 if (debug_displays
[debug
].relocate
)
15318 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
15319 & section
->reloc_info
, & section
->num_relocs
))
15324 section
->reloc_info
= NULL
;
15325 section
->num_relocs
= 0;
15331 #if HAVE_LIBDEBUGINFOD
15332 /* Return a hex string representation of the build-id. */
15334 get_build_id (void * data
)
15336 Filedata
* filedata
= (Filedata
*) data
;
15337 Elf_Internal_Shdr
* shdr
;
15340 /* Iterate through notes to find note.gnu.build-id.
15341 FIXME: Only the first note in any note section is examined. */
15342 for (i
= 0, shdr
= filedata
->section_headers
;
15343 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
15346 if (shdr
->sh_type
!= SHT_NOTE
)
15351 size_t data_remaining
;
15353 Elf_External_Note
* enote
;
15354 Elf_Internal_Note inote
;
15356 bfd_vma offset
= shdr
->sh_offset
;
15357 bfd_vma align
= shdr
->sh_addralign
;
15358 bfd_vma length
= shdr
->sh_size
;
15360 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
15366 else if (align
!= 4 && align
!= 8)
15372 end
= (char *) enote
+ length
;
15373 data_remaining
= end
- (char *) enote
;
15375 if (!is_ia64_vms (filedata
))
15377 min_notesz
= offsetof (Elf_External_Note
, name
);
15378 if (data_remaining
< min_notesz
)
15381 malformed note encountered in section %s whilst scanning for build-id note\n"),
15382 printable_section_name (filedata
, shdr
));
15386 data_remaining
-= min_notesz
;
15388 inote
.type
= BYTE_GET (enote
->type
);
15389 inote
.namesz
= BYTE_GET (enote
->namesz
);
15390 inote
.namedata
= enote
->name
;
15391 inote
.descsz
= BYTE_GET (enote
->descsz
);
15392 inote
.descdata
= ((char *) enote
15393 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
15394 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
15395 next
= ((char *) enote
15396 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
15400 Elf64_External_VMS_Note
*vms_enote
;
15402 /* PR binutils/15191
15403 Make sure that there is enough data to read. */
15404 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
15405 if (data_remaining
< min_notesz
)
15408 malformed note encountered in section %s whilst scanning for build-id note\n"),
15409 printable_section_name (filedata
, shdr
));
15413 data_remaining
-= min_notesz
;
15415 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
15416 inote
.type
= BYTE_GET (vms_enote
->type
);
15417 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
15418 inote
.namedata
= vms_enote
->name
;
15419 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
15420 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
15421 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
15422 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
15425 /* Skip malformed notes. */
15426 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
15427 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
15428 || (size_t) (next
- inote
.descdata
) < inote
.descsz
15429 || ((size_t) (next
- inote
.descdata
)
15430 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
15433 malformed note encountered in section %s whilst scanning for build-id note\n"),
15434 printable_section_name (filedata
, shdr
));
15439 /* Check if this is the build-id note. If so then convert the build-id
15440 bytes to a hex string. */
15441 if (inote
.namesz
> 0
15442 && startswith (inote
.namedata
, "GNU")
15443 && inote
.type
== NT_GNU_BUILD_ID
)
15448 build_id
= malloc (inote
.descsz
* 2 + 1);
15449 if (build_id
== NULL
)
15455 for (j
= 0; j
< inote
.descsz
; ++j
)
15456 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
15457 build_id
[inote
.descsz
* 2] = '\0';
15460 return (unsigned char *) build_id
;
15467 #endif /* HAVE_LIBDEBUGINFOD */
15469 /* If this is not NULL, load_debug_section will only look for sections
15470 within the list of sections given here. */
15471 static unsigned int * section_subset
= NULL
;
15474 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
15476 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15477 Elf_Internal_Shdr
* sec
;
15478 Filedata
* filedata
= (Filedata
*) data
;
15480 /* Without section headers we cannot find any sections. */
15481 if (filedata
->section_headers
== NULL
)
15484 if (filedata
->string_table
== NULL
15485 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
15486 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
15488 Elf_Internal_Shdr
* strs
;
15490 /* Read in the string table, so that we have section names to scan. */
15491 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
15493 if (strs
!= NULL
&& strs
->sh_size
!= 0)
15495 filedata
->string_table
15496 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
15497 1, strs
->sh_size
, _("string table"));
15499 filedata
->string_table_length
15500 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
15504 /* Locate the debug section. */
15505 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
15507 section
->name
= section
->uncompressed_name
;
15510 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
15512 section
->name
= section
->compressed_name
;
15517 /* If we're loading from a subset of sections, and we've loaded
15518 a section matching this name before, it's likely that it's a
15520 if (section_subset
!= NULL
)
15521 free_debug_section (debug
);
15523 return load_specific_debug_section (debug
, sec
, data
);
15527 free_debug_section (enum dwarf_section_display_enum debug
)
15529 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15531 if (section
->start
== NULL
)
15534 free ((char *) section
->start
);
15535 section
->start
= NULL
;
15536 section
->address
= 0;
15539 free (section
->reloc_info
);
15540 section
->reloc_info
= NULL
;
15541 section
->num_relocs
= 0;
15545 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15547 char * name
= SECTION_NAME_VALID (section
) ? SECTION_NAME (section
) : "";
15548 const char * print_name
= printable_section_name (filedata
, section
);
15549 bfd_size_type length
;
15550 bool result
= true;
15553 length
= section
->sh_size
;
15556 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
15559 if (section
->sh_type
== SHT_NOBITS
)
15561 /* There is no point in dumping the contents of a debugging section
15562 which has the NOBITS type - the bits in the file will be random.
15563 This can happen when a file containing a .eh_frame section is
15564 stripped with the --only-keep-debug command line option. */
15565 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
15570 if (startswith (name
, ".gnu.linkonce.wi."))
15571 name
= ".debug_info";
15573 /* See if we know how to display the contents of this section. */
15574 for (i
= 0; i
< max
; i
++)
15576 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
15577 struct dwarf_section_display
* display
= debug_displays
+ i
;
15578 struct dwarf_section
* sec
= & display
->section
;
15580 if (streq (sec
->uncompressed_name
, name
)
15581 || (id
== line
&& startswith (name
, ".debug_line."))
15582 || streq (sec
->compressed_name
, name
))
15584 bool secondary
= (section
!= find_section (filedata
, name
));
15587 free_debug_section (id
);
15589 if (i
== line
&& startswith (name
, ".debug_line."))
15591 else if (streq (sec
->uncompressed_name
, name
))
15592 sec
->name
= sec
->uncompressed_name
;
15594 sec
->name
= sec
->compressed_name
;
15596 if (load_specific_debug_section (id
, section
, filedata
))
15598 /* If this debug section is part of a CU/TU set in a .dwp file,
15599 restrict load_debug_section to the sections in that set. */
15600 section_subset
= find_cu_tu_set (filedata
, shndx
);
15602 result
&= display
->display (sec
, filedata
);
15604 section_subset
= NULL
;
15606 if (secondary
|| (id
!= info
&& id
!= abbrev
&& id
!= debug_addr
))
15607 free_debug_section (id
);
15615 printf (_("Unrecognized debug section: %s\n"), print_name
);
15622 /* Set DUMP_SECTS for all sections where dumps were requested
15623 based on section name. */
15626 initialise_dumps_byname (Filedata
* filedata
)
15628 struct dump_list_entry
* cur
;
15630 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
15635 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
15636 if (SECTION_NAME_VALID (filedata
->section_headers
+ i
)
15637 && streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
15639 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
15643 if (!any
&& !filedata
->is_separate
)
15644 warn (_("Section '%s' was not dumped because it does not exist\n"),
15650 process_section_contents (Filedata
* filedata
)
15652 Elf_Internal_Shdr
* section
;
15659 initialise_dumps_byname (filedata
);
15661 for (i
= 0, section
= filedata
->section_headers
;
15662 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
15665 dump_type dump
= filedata
->dump
.dump_sects
[i
];
15667 if (filedata
->is_separate
&& ! process_links
)
15668 dump
&= DEBUG_DUMP
;
15670 #ifdef SUPPORT_DISASSEMBLY
15671 if (dump
& DISASS_DUMP
)
15673 if (! disassemble_section (section
, filedata
))
15677 if (dump
& HEX_DUMP
)
15679 if (! dump_section_as_bytes (section
, filedata
, false))
15683 if (dump
& RELOC_DUMP
)
15685 if (! dump_section_as_bytes (section
, filedata
, true))
15689 if (dump
& STRING_DUMP
)
15691 if (! dump_section_as_strings (section
, filedata
))
15695 if (dump
& DEBUG_DUMP
)
15697 if (! display_debug_section (i
, section
, filedata
))
15701 #ifdef ENABLE_LIBCTF
15702 if (dump
& CTF_DUMP
)
15704 if (! dump_section_as_ctf (section
, filedata
))
15710 if (! filedata
->is_separate
)
15712 /* Check to see if the user requested a
15713 dump of a section that does not exist. */
15714 for (; i
< filedata
->dump
.num_dump_sects
; i
++)
15715 if (filedata
->dump
.dump_sects
[i
])
15717 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
15726 process_mips_fpe_exception (int mask
)
15732 if (mask
& OEX_FPU_INEX
)
15733 fputs ("INEX", stdout
), first
= false;
15734 if (mask
& OEX_FPU_UFLO
)
15735 printf ("%sUFLO", first
? "" : "|"), first
= false;
15736 if (mask
& OEX_FPU_OFLO
)
15737 printf ("%sOFLO", first
? "" : "|"), first
= false;
15738 if (mask
& OEX_FPU_DIV0
)
15739 printf ("%sDIV0", first
? "" : "|"), first
= false;
15740 if (mask
& OEX_FPU_INVAL
)
15741 printf ("%sINVAL", first
? "" : "|");
15744 fputs ("0", stdout
);
15747 /* Display's the value of TAG at location P. If TAG is
15748 greater than 0 it is assumed to be an unknown tag, and
15749 a message is printed to this effect. Otherwise it is
15750 assumed that a message has already been printed.
15752 If the bottom bit of TAG is set it assumed to have a
15753 string value, otherwise it is assumed to have an integer
15756 Returns an updated P pointing to the first unread byte
15757 beyond the end of TAG's value.
15759 Reads at or beyond END will not be made. */
15761 static unsigned char *
15762 display_tag_value (signed int tag
,
15764 const unsigned char * const end
)
15769 printf (" Tag_unknown_%d: ", tag
);
15773 warn (_("<corrupt tag>\n"));
15777 /* PR 17531 file: 027-19978-0.004. */
15778 size_t maxlen
= (end
- p
) - 1;
15783 print_symbol ((int) maxlen
, (const char *) p
);
15784 p
+= strnlen ((char *) p
, maxlen
) + 1;
15788 printf (_("<corrupt string tag>"));
15789 p
= (unsigned char *) end
;
15795 READ_ULEB (val
, p
, end
);
15796 printf ("%ld (0x%lx)\n", val
, val
);
15803 /* ARC ABI attributes section. */
15805 static unsigned char *
15806 display_arc_attribute (unsigned char * p
,
15807 const unsigned char * const end
)
15812 READ_ULEB (tag
, p
, end
);
15816 case Tag_ARC_PCS_config
:
15817 READ_ULEB (val
, p
, end
);
15818 printf (" Tag_ARC_PCS_config: ");
15822 printf (_("Absent/Non standard\n"));
15825 printf (_("Bare metal/mwdt\n"));
15828 printf (_("Bare metal/newlib\n"));
15831 printf (_("Linux/uclibc\n"));
15834 printf (_("Linux/glibc\n"));
15837 printf (_("Unknown\n"));
15842 case Tag_ARC_CPU_base
:
15843 READ_ULEB (val
, p
, end
);
15844 printf (" Tag_ARC_CPU_base: ");
15849 printf (_("Absent\n"));
15851 case TAG_CPU_ARC6xx
:
15852 printf ("ARC6xx\n");
15854 case TAG_CPU_ARC7xx
:
15855 printf ("ARC7xx\n");
15857 case TAG_CPU_ARCEM
:
15858 printf ("ARCEM\n");
15860 case TAG_CPU_ARCHS
:
15861 printf ("ARCHS\n");
15866 case Tag_ARC_CPU_variation
:
15867 READ_ULEB (val
, p
, end
);
15868 printf (" Tag_ARC_CPU_variation: ");
15872 if (val
> 0 && val
< 16)
15873 printf ("Core%d\n", val
);
15875 printf ("Unknown\n");
15879 printf (_("Absent\n"));
15884 case Tag_ARC_CPU_name
:
15885 printf (" Tag_ARC_CPU_name: ");
15886 p
= display_tag_value (-1, p
, end
);
15889 case Tag_ARC_ABI_rf16
:
15890 READ_ULEB (val
, p
, end
);
15891 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
15894 case Tag_ARC_ABI_osver
:
15895 READ_ULEB (val
, p
, end
);
15896 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
15899 case Tag_ARC_ABI_pic
:
15900 case Tag_ARC_ABI_sda
:
15901 READ_ULEB (val
, p
, end
);
15902 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
15903 : " Tag_ARC_ABI_pic: ");
15907 printf (_("Absent\n"));
15916 printf (_("Unknown\n"));
15921 case Tag_ARC_ABI_tls
:
15922 READ_ULEB (val
, p
, end
);
15923 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
15926 case Tag_ARC_ABI_enumsize
:
15927 READ_ULEB (val
, p
, end
);
15928 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
15932 case Tag_ARC_ABI_exceptions
:
15933 READ_ULEB (val
, p
, end
);
15934 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
15938 case Tag_ARC_ABI_double_size
:
15939 READ_ULEB (val
, p
, end
);
15940 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
15943 case Tag_ARC_ISA_config
:
15944 printf (" Tag_ARC_ISA_config: ");
15945 p
= display_tag_value (-1, p
, end
);
15948 case Tag_ARC_ISA_apex
:
15949 printf (" Tag_ARC_ISA_apex: ");
15950 p
= display_tag_value (-1, p
, end
);
15953 case Tag_ARC_ISA_mpy_option
:
15954 READ_ULEB (val
, p
, end
);
15955 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
15958 case Tag_ARC_ATR_version
:
15959 READ_ULEB (val
, p
, end
);
15960 printf (" Tag_ARC_ATR_version: %d\n", val
);
15964 return display_tag_value (tag
& 1, p
, end
);
15970 /* ARM EABI attributes section. */
15975 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
15977 const char *const *table
;
15978 } arm_attr_public_tag
;
15980 static const char *const arm_attr_tag_CPU_arch
[] =
15981 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
15982 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
15983 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
15984 static const char *const arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
15985 static const char *const arm_attr_tag_THUMB_ISA_use
[] =
15986 {"No", "Thumb-1", "Thumb-2", "Yes"};
15987 static const char *const arm_attr_tag_FP_arch
[] =
15988 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
15989 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
15990 static const char *const arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
15991 static const char *const arm_attr_tag_Advanced_SIMD_arch
[] =
15992 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
15993 "NEON for ARMv8.1"};
15994 static const char *const arm_attr_tag_PCS_config
[] =
15995 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
15996 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
15997 static const char *const arm_attr_tag_ABI_PCS_R9_use
[] =
15998 {"V6", "SB", "TLS", "Unused"};
15999 static const char *const arm_attr_tag_ABI_PCS_RW_data
[] =
16000 {"Absolute", "PC-relative", "SB-relative", "None"};
16001 static const char *const arm_attr_tag_ABI_PCS_RO_data
[] =
16002 {"Absolute", "PC-relative", "None"};
16003 static const char *const arm_attr_tag_ABI_PCS_GOT_use
[] =
16004 {"None", "direct", "GOT-indirect"};
16005 static const char *const arm_attr_tag_ABI_PCS_wchar_t
[] =
16006 {"None", "??? 1", "2", "??? 3", "4"};
16007 static const char *const arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
16008 static const char *const arm_attr_tag_ABI_FP_denormal
[] =
16009 {"Unused", "Needed", "Sign only"};
16010 static const char *const arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
16011 static const char *const arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
16012 static const char *const arm_attr_tag_ABI_FP_number_model
[] =
16013 {"Unused", "Finite", "RTABI", "IEEE 754"};
16014 static const char *const arm_attr_tag_ABI_enum_size
[] =
16015 {"Unused", "small", "int", "forced to int"};
16016 static const char *const arm_attr_tag_ABI_HardFP_use
[] =
16017 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
16018 static const char *const arm_attr_tag_ABI_VFP_args
[] =
16019 {"AAPCS", "VFP registers", "custom", "compatible"};
16020 static const char *const arm_attr_tag_ABI_WMMX_args
[] =
16021 {"AAPCS", "WMMX registers", "custom"};
16022 static const char *const arm_attr_tag_ABI_optimization_goals
[] =
16023 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
16024 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
16025 static const char *const arm_attr_tag_ABI_FP_optimization_goals
[] =
16026 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
16027 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
16028 static const char *const arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
16029 static const char *const arm_attr_tag_FP_HP_extension
[] =
16030 {"Not Allowed", "Allowed"};
16031 static const char *const arm_attr_tag_ABI_FP_16bit_format
[] =
16032 {"None", "IEEE 754", "Alternative Format"};
16033 static const char *const arm_attr_tag_DSP_extension
[] =
16034 {"Follow architecture", "Allowed"};
16035 static const char *const arm_attr_tag_MPextension_use
[] =
16036 {"Not Allowed", "Allowed"};
16037 static const char *const arm_attr_tag_DIV_use
[] =
16038 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
16039 "Allowed in v7-A with integer division extension"};
16040 static const char *const arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
16041 static const char *const arm_attr_tag_Virtualization_use
[] =
16042 {"Not Allowed", "TrustZone", "Virtualization Extensions",
16043 "TrustZone and Virtualization Extensions"};
16044 static const char *const arm_attr_tag_MPextension_use_legacy
[] =
16045 {"Not Allowed", "Allowed"};
16047 static const char *const arm_attr_tag_MVE_arch
[] =
16048 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
16050 #define LOOKUP(id, name) \
16051 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
16052 static arm_attr_public_tag arm_attr_public_tags
[] =
16054 {4, "CPU_raw_name", 1, NULL
},
16055 {5, "CPU_name", 1, NULL
},
16056 LOOKUP(6, CPU_arch
),
16057 {7, "CPU_arch_profile", 0, NULL
},
16058 LOOKUP(8, ARM_ISA_use
),
16059 LOOKUP(9, THUMB_ISA_use
),
16060 LOOKUP(10, FP_arch
),
16061 LOOKUP(11, WMMX_arch
),
16062 LOOKUP(12, Advanced_SIMD_arch
),
16063 LOOKUP(13, PCS_config
),
16064 LOOKUP(14, ABI_PCS_R9_use
),
16065 LOOKUP(15, ABI_PCS_RW_data
),
16066 LOOKUP(16, ABI_PCS_RO_data
),
16067 LOOKUP(17, ABI_PCS_GOT_use
),
16068 LOOKUP(18, ABI_PCS_wchar_t
),
16069 LOOKUP(19, ABI_FP_rounding
),
16070 LOOKUP(20, ABI_FP_denormal
),
16071 LOOKUP(21, ABI_FP_exceptions
),
16072 LOOKUP(22, ABI_FP_user_exceptions
),
16073 LOOKUP(23, ABI_FP_number_model
),
16074 {24, "ABI_align_needed", 0, NULL
},
16075 {25, "ABI_align_preserved", 0, NULL
},
16076 LOOKUP(26, ABI_enum_size
),
16077 LOOKUP(27, ABI_HardFP_use
),
16078 LOOKUP(28, ABI_VFP_args
),
16079 LOOKUP(29, ABI_WMMX_args
),
16080 LOOKUP(30, ABI_optimization_goals
),
16081 LOOKUP(31, ABI_FP_optimization_goals
),
16082 {32, "compatibility", 0, NULL
},
16083 LOOKUP(34, CPU_unaligned_access
),
16084 LOOKUP(36, FP_HP_extension
),
16085 LOOKUP(38, ABI_FP_16bit_format
),
16086 LOOKUP(42, MPextension_use
),
16087 LOOKUP(44, DIV_use
),
16088 LOOKUP(46, DSP_extension
),
16089 LOOKUP(48, MVE_arch
),
16090 {64, "nodefaults", 0, NULL
},
16091 {65, "also_compatible_with", 0, NULL
},
16092 LOOKUP(66, T2EE_use
),
16093 {67, "conformance", 1, NULL
},
16094 LOOKUP(68, Virtualization_use
),
16095 LOOKUP(70, MPextension_use_legacy
)
16099 static unsigned char *
16100 display_arm_attribute (unsigned char * p
,
16101 const unsigned char * const end
)
16105 arm_attr_public_tag
* attr
;
16109 READ_ULEB (tag
, p
, end
);
16111 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
16113 if (arm_attr_public_tags
[i
].tag
== tag
)
16115 attr
= &arm_attr_public_tags
[i
];
16122 printf (" Tag_%s: ", attr
->name
);
16123 switch (attr
->type
)
16128 case 7: /* Tag_CPU_arch_profile. */
16129 READ_ULEB (val
, p
, end
);
16132 case 0: printf (_("None\n")); break;
16133 case 'A': printf (_("Application\n")); break;
16134 case 'R': printf (_("Realtime\n")); break;
16135 case 'M': printf (_("Microcontroller\n")); break;
16136 case 'S': printf (_("Application or Realtime\n")); break;
16137 default: printf ("??? (%d)\n", val
); break;
16141 case 24: /* Tag_align_needed. */
16142 READ_ULEB (val
, p
, end
);
16145 case 0: printf (_("None\n")); break;
16146 case 1: printf (_("8-byte\n")); break;
16147 case 2: printf (_("4-byte\n")); break;
16148 case 3: printf ("??? 3\n"); break;
16151 printf (_("8-byte and up to %d-byte extended\n"),
16154 printf ("??? (%d)\n", val
);
16159 case 25: /* Tag_align_preserved. */
16160 READ_ULEB (val
, p
, end
);
16163 case 0: printf (_("None\n")); break;
16164 case 1: printf (_("8-byte, except leaf SP\n")); break;
16165 case 2: printf (_("8-byte\n")); break;
16166 case 3: printf ("??? 3\n"); break;
16169 printf (_("8-byte and up to %d-byte extended\n"),
16172 printf ("??? (%d)\n", val
);
16177 case 32: /* Tag_compatibility. */
16179 READ_ULEB (val
, p
, end
);
16180 printf (_("flag = %d, vendor = "), val
);
16183 size_t maxlen
= (end
- p
) - 1;
16185 print_symbol ((int) maxlen
, (const char *) p
);
16186 p
+= strnlen ((char *) p
, maxlen
) + 1;
16190 printf (_("<corrupt>"));
16191 p
= (unsigned char *) end
;
16197 case 64: /* Tag_nodefaults. */
16198 /* PR 17531: file: 001-505008-0.01. */
16201 printf (_("True\n"));
16204 case 65: /* Tag_also_compatible_with. */
16205 READ_ULEB (val
, p
, end
);
16206 if (val
== 6 /* Tag_CPU_arch. */)
16208 READ_ULEB (val
, p
, end
);
16209 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
16210 printf ("??? (%d)\n", val
);
16212 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
16216 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
16221 printf (_("<unknown: %d>\n"), tag
);
16227 return display_tag_value (-1, p
, end
);
16229 return display_tag_value (0, p
, end
);
16232 assert (attr
->type
& 0x80);
16233 READ_ULEB (val
, p
, end
);
16234 type
= attr
->type
& 0x7f;
16236 printf ("??? (%d)\n", val
);
16238 printf ("%s\n", attr
->table
[val
]);
16243 return display_tag_value (tag
, p
, end
);
16246 static unsigned char *
16247 display_gnu_attribute (unsigned char * p
,
16248 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
16249 const unsigned char * const end
)
16254 READ_ULEB (tag
, p
, end
);
16256 /* Tag_compatibility is the only generic GNU attribute defined at
16260 READ_ULEB (val
, p
, end
);
16262 printf (_("flag = %d, vendor = "), val
);
16265 printf (_("<corrupt>\n"));
16266 warn (_("corrupt vendor attribute\n"));
16272 size_t maxlen
= (end
- p
) - 1;
16274 print_symbol ((int) maxlen
, (const char *) p
);
16275 p
+= strnlen ((char *) p
, maxlen
) + 1;
16279 printf (_("<corrupt>"));
16280 p
= (unsigned char *) end
;
16287 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
16288 return display_proc_gnu_attribute (p
, tag
, end
);
16290 return display_tag_value (tag
, p
, end
);
16293 static unsigned char *
16294 display_m68k_gnu_attribute (unsigned char * p
,
16296 const unsigned char * const end
)
16300 if (tag
== Tag_GNU_M68K_ABI_FP
)
16302 printf (" Tag_GNU_M68K_ABI_FP: ");
16305 printf (_("<corrupt>\n"));
16308 READ_ULEB (val
, p
, end
);
16311 printf ("(%#x), ", val
);
16316 printf (_("unspecified hard/soft float\n"));
16319 printf (_("hard float\n"));
16322 printf (_("soft float\n"));
16328 return display_tag_value (tag
& 1, p
, end
);
16331 static unsigned char *
16332 display_power_gnu_attribute (unsigned char * p
,
16334 const unsigned char * const end
)
16338 if (tag
== Tag_GNU_Power_ABI_FP
)
16340 printf (" Tag_GNU_Power_ABI_FP: ");
16343 printf (_("<corrupt>\n"));
16346 READ_ULEB (val
, p
, end
);
16349 printf ("(%#x), ", val
);
16354 printf (_("unspecified hard/soft float, "));
16357 printf (_("hard float, "));
16360 printf (_("soft float, "));
16363 printf (_("single-precision hard float, "));
16370 printf (_("unspecified long double\n"));
16373 printf (_("128-bit IBM long double\n"));
16376 printf (_("64-bit long double\n"));
16379 printf (_("128-bit IEEE long double\n"));
16385 if (tag
== Tag_GNU_Power_ABI_Vector
)
16387 printf (" Tag_GNU_Power_ABI_Vector: ");
16390 printf (_("<corrupt>\n"));
16393 READ_ULEB (val
, p
, end
);
16396 printf ("(%#x), ", val
);
16401 printf (_("unspecified\n"));
16404 printf (_("generic\n"));
16407 printf ("AltiVec\n");
16416 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
16418 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
16421 printf (_("<corrupt>\n"));
16424 READ_ULEB (val
, p
, end
);
16427 printf ("(%#x), ", val
);
16432 printf (_("unspecified\n"));
16435 printf ("r3/r4\n");
16438 printf (_("memory\n"));
16447 return display_tag_value (tag
& 1, p
, end
);
16450 static unsigned char *
16451 display_s390_gnu_attribute (unsigned char * p
,
16453 const unsigned char * const end
)
16457 if (tag
== Tag_GNU_S390_ABI_Vector
)
16459 printf (" Tag_GNU_S390_ABI_Vector: ");
16460 READ_ULEB (val
, p
, end
);
16465 printf (_("any\n"));
16468 printf (_("software\n"));
16471 printf (_("hardware\n"));
16474 printf ("??? (%d)\n", val
);
16480 return display_tag_value (tag
& 1, p
, end
);
16484 display_sparc_hwcaps (unsigned int mask
)
16490 if (mask
& ELF_SPARC_HWCAP_MUL32
)
16491 fputs ("mul32", stdout
), first
= false;
16492 if (mask
& ELF_SPARC_HWCAP_DIV32
)
16493 printf ("%sdiv32", first
? "" : "|"), first
= false;
16494 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
16495 printf ("%sfsmuld", first
? "" : "|"), first
= false;
16496 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
16497 printf ("%sv8plus", first
? "" : "|"), first
= false;
16498 if (mask
& ELF_SPARC_HWCAP_POPC
)
16499 printf ("%spopc", first
? "" : "|"), first
= false;
16500 if (mask
& ELF_SPARC_HWCAP_VIS
)
16501 printf ("%svis", first
? "" : "|"), first
= false;
16502 if (mask
& ELF_SPARC_HWCAP_VIS2
)
16503 printf ("%svis2", first
? "" : "|"), first
= false;
16504 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
16505 printf ("%sASIBlkInit", first
? "" : "|"), first
= false;
16506 if (mask
& ELF_SPARC_HWCAP_FMAF
)
16507 printf ("%sfmaf", first
? "" : "|"), first
= false;
16508 if (mask
& ELF_SPARC_HWCAP_VIS3
)
16509 printf ("%svis3", first
? "" : "|"), first
= false;
16510 if (mask
& ELF_SPARC_HWCAP_HPC
)
16511 printf ("%shpc", first
? "" : "|"), first
= false;
16512 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
16513 printf ("%srandom", first
? "" : "|"), first
= false;
16514 if (mask
& ELF_SPARC_HWCAP_TRANS
)
16515 printf ("%strans", first
? "" : "|"), first
= false;
16516 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
16517 printf ("%sfjfmau", first
? "" : "|"), first
= false;
16518 if (mask
& ELF_SPARC_HWCAP_IMA
)
16519 printf ("%sima", first
? "" : "|"), first
= false;
16520 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
16521 printf ("%scspare", first
? "" : "|"), first
= false;
16524 fputc ('0', stdout
);
16525 fputc ('\n', stdout
);
16529 display_sparc_hwcaps2 (unsigned int mask
)
16535 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
16536 fputs ("fjathplus", stdout
), first
= false;
16537 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
16538 printf ("%svis3b", first
? "" : "|"), first
= false;
16539 if (mask
& ELF_SPARC_HWCAP2_ADP
)
16540 printf ("%sadp", first
? "" : "|"), first
= false;
16541 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
16542 printf ("%ssparc5", first
? "" : "|"), first
= false;
16543 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
16544 printf ("%smwait", first
? "" : "|"), first
= false;
16545 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
16546 printf ("%sxmpmul", first
? "" : "|"), first
= false;
16547 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
16548 printf ("%sxmont2", first
? "" : "|"), first
= false;
16549 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
16550 printf ("%snsec", first
? "" : "|"), first
= false;
16551 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
16552 printf ("%sfjathhpc", first
? "" : "|"), first
= false;
16553 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
16554 printf ("%sfjdes", first
? "" : "|"), first
= false;
16555 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
16556 printf ("%sfjaes", first
? "" : "|"), first
= false;
16559 fputc ('0', stdout
);
16560 fputc ('\n', stdout
);
16563 static unsigned char *
16564 display_sparc_gnu_attribute (unsigned char * p
,
16566 const unsigned char * const end
)
16570 if (tag
== Tag_GNU_Sparc_HWCAPS
)
16572 READ_ULEB (val
, p
, end
);
16573 printf (" Tag_GNU_Sparc_HWCAPS: ");
16574 display_sparc_hwcaps (val
);
16577 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
16579 READ_ULEB (val
, p
, end
);
16580 printf (" Tag_GNU_Sparc_HWCAPS2: ");
16581 display_sparc_hwcaps2 (val
);
16585 return display_tag_value (tag
, p
, end
);
16589 print_mips_fp_abi_value (unsigned int val
)
16593 case Val_GNU_MIPS_ABI_FP_ANY
:
16594 printf (_("Hard or soft float\n"));
16596 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
16597 printf (_("Hard float (double precision)\n"));
16599 case Val_GNU_MIPS_ABI_FP_SINGLE
:
16600 printf (_("Hard float (single precision)\n"));
16602 case Val_GNU_MIPS_ABI_FP_SOFT
:
16603 printf (_("Soft float\n"));
16605 case Val_GNU_MIPS_ABI_FP_OLD_64
:
16606 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
16608 case Val_GNU_MIPS_ABI_FP_XX
:
16609 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
16611 case Val_GNU_MIPS_ABI_FP_64
:
16612 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
16614 case Val_GNU_MIPS_ABI_FP_64A
:
16615 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
16617 case Val_GNU_MIPS_ABI_FP_NAN2008
:
16618 printf (_("NaN 2008 compatibility\n"));
16621 printf ("??? (%d)\n", val
);
16626 static unsigned char *
16627 display_mips_gnu_attribute (unsigned char * p
,
16629 const unsigned char * const end
)
16631 if (tag
== Tag_GNU_MIPS_ABI_FP
)
16635 printf (" Tag_GNU_MIPS_ABI_FP: ");
16636 READ_ULEB (val
, p
, end
);
16637 print_mips_fp_abi_value (val
);
16641 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
16645 printf (" Tag_GNU_MIPS_ABI_MSA: ");
16646 READ_ULEB (val
, p
, end
);
16650 case Val_GNU_MIPS_ABI_MSA_ANY
:
16651 printf (_("Any MSA or not\n"));
16653 case Val_GNU_MIPS_ABI_MSA_128
:
16654 printf (_("128-bit MSA\n"));
16657 printf ("??? (%d)\n", val
);
16663 return display_tag_value (tag
& 1, p
, end
);
16666 static unsigned char *
16667 display_tic6x_attribute (unsigned char * p
,
16668 const unsigned char * const end
)
16673 READ_ULEB (tag
, p
, end
);
16678 printf (" Tag_ISA: ");
16679 READ_ULEB (val
, p
, end
);
16683 case C6XABI_Tag_ISA_none
:
16684 printf (_("None\n"));
16686 case C6XABI_Tag_ISA_C62X
:
16689 case C6XABI_Tag_ISA_C67X
:
16692 case C6XABI_Tag_ISA_C67XP
:
16693 printf ("C67x+\n");
16695 case C6XABI_Tag_ISA_C64X
:
16698 case C6XABI_Tag_ISA_C64XP
:
16699 printf ("C64x+\n");
16701 case C6XABI_Tag_ISA_C674X
:
16702 printf ("C674x\n");
16705 printf ("??? (%d)\n", val
);
16710 case Tag_ABI_wchar_t
:
16711 printf (" Tag_ABI_wchar_t: ");
16712 READ_ULEB (val
, p
, end
);
16716 printf (_("Not used\n"));
16719 printf (_("2 bytes\n"));
16722 printf (_("4 bytes\n"));
16725 printf ("??? (%d)\n", val
);
16730 case Tag_ABI_stack_align_needed
:
16731 printf (" Tag_ABI_stack_align_needed: ");
16732 READ_ULEB (val
, p
, end
);
16736 printf (_("8-byte\n"));
16739 printf (_("16-byte\n"));
16742 printf ("??? (%d)\n", val
);
16747 case Tag_ABI_stack_align_preserved
:
16748 READ_ULEB (val
, p
, end
);
16749 printf (" Tag_ABI_stack_align_preserved: ");
16753 printf (_("8-byte\n"));
16756 printf (_("16-byte\n"));
16759 printf ("??? (%d)\n", val
);
16765 READ_ULEB (val
, p
, end
);
16766 printf (" Tag_ABI_DSBT: ");
16770 printf (_("DSBT addressing not used\n"));
16773 printf (_("DSBT addressing used\n"));
16776 printf ("??? (%d)\n", val
);
16782 READ_ULEB (val
, p
, end
);
16783 printf (" Tag_ABI_PID: ");
16787 printf (_("Data addressing position-dependent\n"));
16790 printf (_("Data addressing position-independent, GOT near DP\n"));
16793 printf (_("Data addressing position-independent, GOT far from DP\n"));
16796 printf ("??? (%d)\n", val
);
16802 READ_ULEB (val
, p
, end
);
16803 printf (" Tag_ABI_PIC: ");
16807 printf (_("Code addressing position-dependent\n"));
16810 printf (_("Code addressing position-independent\n"));
16813 printf ("??? (%d)\n", val
);
16818 case Tag_ABI_array_object_alignment
:
16819 READ_ULEB (val
, p
, end
);
16820 printf (" Tag_ABI_array_object_alignment: ");
16824 printf (_("8-byte\n"));
16827 printf (_("4-byte\n"));
16830 printf (_("16-byte\n"));
16833 printf ("??? (%d)\n", val
);
16838 case Tag_ABI_array_object_align_expected
:
16839 READ_ULEB (val
, p
, end
);
16840 printf (" Tag_ABI_array_object_align_expected: ");
16844 printf (_("8-byte\n"));
16847 printf (_("4-byte\n"));
16850 printf (_("16-byte\n"));
16853 printf ("??? (%d)\n", val
);
16858 case Tag_ABI_compatibility
:
16860 READ_ULEB (val
, p
, end
);
16861 printf (" Tag_ABI_compatibility: ");
16862 printf (_("flag = %d, vendor = "), val
);
16865 size_t maxlen
= (end
- p
) - 1;
16867 print_symbol ((int) maxlen
, (const char *) p
);
16868 p
+= strnlen ((char *) p
, maxlen
) + 1;
16872 printf (_("<corrupt>"));
16873 p
= (unsigned char *) end
;
16879 case Tag_ABI_conformance
:
16881 printf (" Tag_ABI_conformance: \"");
16884 size_t maxlen
= (end
- p
) - 1;
16886 print_symbol ((int) maxlen
, (const char *) p
);
16887 p
+= strnlen ((char *) p
, maxlen
) + 1;
16891 printf (_("<corrupt>"));
16892 p
= (unsigned char *) end
;
16899 return display_tag_value (tag
, p
, end
);
16903 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
16905 unsigned long addr
= 0;
16906 size_t bytes
= end
- p
;
16913 int lbytes
= (bytes
> 16 ? 16 : bytes
);
16915 printf (" 0x%8.8lx ", addr
);
16917 for (j
= 0; j
< 16; j
++)
16920 printf ("%2.2x", p
[j
]);
16928 for (j
= 0; j
< lbytes
; j
++)
16931 if (k
>= ' ' && k
< 0x7f)
16947 static unsigned char *
16948 display_msp430_attribute (unsigned char * p
,
16949 const unsigned char * const end
)
16954 READ_ULEB (tag
, p
, end
);
16958 case OFBA_MSPABI_Tag_ISA
:
16959 printf (" Tag_ISA: ");
16960 READ_ULEB (val
, p
, end
);
16963 case 0: printf (_("None\n")); break;
16964 case 1: printf (_("MSP430\n")); break;
16965 case 2: printf (_("MSP430X\n")); break;
16966 default: printf ("??? (%d)\n", val
); break;
16970 case OFBA_MSPABI_Tag_Code_Model
:
16971 printf (" Tag_Code_Model: ");
16972 READ_ULEB (val
, p
, end
);
16975 case 0: printf (_("None\n")); break;
16976 case 1: printf (_("Small\n")); break;
16977 case 2: printf (_("Large\n")); break;
16978 default: printf ("??? (%d)\n", val
); break;
16982 case OFBA_MSPABI_Tag_Data_Model
:
16983 printf (" Tag_Data_Model: ");
16984 READ_ULEB (val
, p
, end
);
16987 case 0: printf (_("None\n")); break;
16988 case 1: printf (_("Small\n")); break;
16989 case 2: printf (_("Large\n")); break;
16990 case 3: printf (_("Restricted Large\n")); break;
16991 default: printf ("??? (%d)\n", val
); break;
16996 printf (_(" <unknown tag %d>: "), tag
);
17003 size_t maxlen
= (end
- p
) - 1;
17005 print_symbol ((int) maxlen
, (const char *) p
);
17006 p
+= strnlen ((char *) p
, maxlen
) + 1;
17010 printf (_("<corrupt>"));
17011 p
= (unsigned char *) end
;
17017 READ_ULEB (val
, p
, end
);
17018 printf ("%d (0x%x)\n", val
, val
);
17027 static unsigned char *
17028 display_msp430_gnu_attribute (unsigned char * p
,
17030 const unsigned char * const end
)
17032 if (tag
== Tag_GNU_MSP430_Data_Region
)
17036 printf (" Tag_GNU_MSP430_Data_Region: ");
17037 READ_ULEB (val
, p
, end
);
17041 case Val_GNU_MSP430_Data_Region_Any
:
17042 printf (_("Any Region\n"));
17044 case Val_GNU_MSP430_Data_Region_Lower
:
17045 printf (_("Lower Region Only\n"));
17048 printf ("??? (%u)\n", val
);
17052 return display_tag_value (tag
& 1, p
, end
);
17055 struct riscv_attr_tag_t
{
17060 static struct riscv_attr_tag_t riscv_attr_tag
[] =
17062 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
17065 T(priv_spec_minor
),
17066 T(priv_spec_revision
),
17067 T(unaligned_access
),
17072 static unsigned char *
17073 display_riscv_attribute (unsigned char *p
,
17074 const unsigned char * const end
)
17078 struct riscv_attr_tag_t
*attr
= NULL
;
17081 READ_ULEB (tag
, p
, end
);
17083 /* Find the name of attribute. */
17084 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
17086 if (riscv_attr_tag
[i
].tag
== tag
)
17088 attr
= &riscv_attr_tag
[i
];
17094 printf (" %s: ", attr
->name
);
17096 return display_tag_value (tag
, p
, end
);
17100 case Tag_RISCV_priv_spec
:
17101 case Tag_RISCV_priv_spec_minor
:
17102 case Tag_RISCV_priv_spec_revision
:
17103 READ_ULEB (val
, p
, end
);
17104 printf (_("%u\n"), val
);
17106 case Tag_RISCV_unaligned_access
:
17107 READ_ULEB (val
, p
, end
);
17111 printf (_("No unaligned access\n"));
17114 printf (_("Unaligned access\n"));
17118 case Tag_RISCV_stack_align
:
17119 READ_ULEB (val
, p
, end
);
17120 printf (_("%u-bytes\n"), val
);
17122 case Tag_RISCV_arch
:
17123 p
= display_tag_value (-1, p
, end
);
17126 return display_tag_value (tag
, p
, end
);
17132 static unsigned char *
17133 display_csky_attribute (unsigned char * p
,
17134 const unsigned char * const end
)
17138 READ_ULEB (tag
, p
, end
);
17140 if (tag
>= Tag_CSKY_MAX
)
17142 return display_tag_value (-1, p
, end
);
17147 case Tag_CSKY_ARCH_NAME
:
17148 printf (" Tag_CSKY_ARCH_NAME:\t\t");
17149 return display_tag_value (-1, p
, end
);
17150 case Tag_CSKY_CPU_NAME
:
17151 printf (" Tag_CSKY_CPU_NAME:\t\t");
17152 return display_tag_value (-1, p
, end
);
17154 case Tag_CSKY_ISA_FLAGS
:
17155 printf (" Tag_CSKY_ISA_FLAGS:\t\t");
17156 return display_tag_value (0, p
, end
);
17157 case Tag_CSKY_ISA_EXT_FLAGS
:
17158 printf (" Tag_CSKY_ISA_EXT_FLAGS:\t");
17159 return display_tag_value (0, p
, end
);
17161 case Tag_CSKY_DSP_VERSION
:
17162 printf (" Tag_CSKY_DSP_VERSION:\t\t");
17163 READ_ULEB (val
, p
, end
);
17164 if (val
== VAL_CSKY_DSP_VERSION_EXTENSION
)
17165 printf ("DSP Extension\n");
17166 else if (val
== VAL_CSKY_DSP_VERSION_2
)
17167 printf ("DSP 2.0\n");
17170 case Tag_CSKY_VDSP_VERSION
:
17171 printf (" Tag_CSKY_VDSP_VERSION:\t");
17172 READ_ULEB (val
, p
, end
);
17173 printf ("VDSP Version %d\n", val
);
17176 case Tag_CSKY_FPU_VERSION
:
17177 printf (" Tag_CSKY_FPU_VERSION:\t\t");
17178 READ_ULEB (val
, p
, end
);
17179 if (val
== VAL_CSKY_FPU_VERSION_1
)
17180 printf ("ABIV1 FPU Version 1\n");
17181 else if (val
== VAL_CSKY_FPU_VERSION_2
)
17182 printf ("FPU Version 2\n");
17185 case Tag_CSKY_FPU_ABI
:
17186 printf (" Tag_CSKY_FPU_ABI:\t\t");
17187 READ_ULEB (val
, p
, end
);
17188 if (val
== VAL_CSKY_FPU_ABI_HARD
)
17190 else if (val
== VAL_CSKY_FPU_ABI_SOFTFP
)
17191 printf ("SoftFP\n");
17192 else if (val
== VAL_CSKY_FPU_ABI_SOFT
)
17195 case Tag_CSKY_FPU_ROUNDING
:
17196 READ_ULEB (val
, p
, end
);
17198 printf (" Tag_CSKY_FPU_ROUNDING:\t");
17199 printf ("Needed\n");
17202 case Tag_CSKY_FPU_DENORMAL
:
17203 READ_ULEB (val
, p
, end
);
17205 printf (" Tag_CSKY_FPU_DENORMAL:\t");
17206 printf ("Needed\n");
17209 case Tag_CSKY_FPU_Exception
:
17210 READ_ULEB (val
, p
, end
);
17212 printf (" Tag_CSKY_FPU_Exception:\t");
17213 printf ("Needed\n");
17216 case Tag_CSKY_FPU_NUMBER_MODULE
:
17217 printf (" Tag_CSKY_FPU_NUMBER_MODULE:\t");
17218 return display_tag_value (-1, p
, end
);
17219 case Tag_CSKY_FPU_HARDFP
:
17220 printf (" Tag_CSKY_FPU_HARDFP:\t\t");
17221 READ_ULEB (val
, p
, end
);
17222 if (val
& VAL_CSKY_FPU_HARDFP_HALF
)
17224 if (val
& VAL_CSKY_FPU_HARDFP_SINGLE
)
17225 printf (" Single");
17226 if (val
& VAL_CSKY_FPU_HARDFP_DOUBLE
)
17227 printf (" Double");
17231 return display_tag_value (tag
, p
, end
);
17237 process_attributes (Filedata
* filedata
,
17238 const char * public_name
,
17239 unsigned int proc_type
,
17240 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
17241 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
17243 Elf_Internal_Shdr
* sect
;
17247 /* Find the section header so that we get the size. */
17248 for (i
= 0, sect
= filedata
->section_headers
;
17249 i
< filedata
->file_header
.e_shnum
;
17252 unsigned char * contents
;
17255 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
17258 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17259 sect
->sh_size
, _("attributes"));
17260 if (contents
== NULL
)
17267 /* The first character is the version of the attributes.
17268 Currently only version 1, (aka 'A') is recognised here. */
17271 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
17276 bfd_vma section_len
;
17278 section_len
= sect
->sh_size
- 1;
17281 while (section_len
> 0)
17284 unsigned int namelen
;
17285 bool public_section
;
17288 if (section_len
<= 4)
17290 error (_("Tag section ends prematurely\n"));
17294 attr_len
= byte_get (p
, 4);
17297 if (attr_len
> section_len
)
17299 error (_("Bad attribute length (%u > %u)\n"),
17300 (unsigned) attr_len
, (unsigned) section_len
);
17301 attr_len
= section_len
;
17304 /* PR 17531: file: 001-101425-0.004 */
17305 else if (attr_len
< 5)
17307 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
17312 section_len
-= attr_len
;
17315 namelen
= strnlen ((char *) p
, attr_len
) + 1;
17316 if (namelen
== 0 || namelen
>= attr_len
)
17318 error (_("Corrupt attribute section name\n"));
17323 printf (_("Attribute Section: "));
17324 print_symbol (INT_MAX
, (const char *) p
);
17327 if (public_name
&& streq ((char *) p
, public_name
))
17328 public_section
= true;
17330 public_section
= false;
17332 if (streq ((char *) p
, "gnu"))
17333 gnu_section
= true;
17335 gnu_section
= false;
17338 attr_len
-= namelen
;
17340 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
17345 unsigned char * end
;
17347 /* PR binutils/17531: Safe handling of corrupt files. */
17350 error (_("Unused bytes at end of section\n"));
17357 size
= byte_get (p
, 4);
17358 if (size
> attr_len
)
17360 error (_("Bad subsection length (%u > %u)\n"),
17361 (unsigned) size
, (unsigned) attr_len
);
17365 /* PR binutils/17531: Safe handling of corrupt files. */
17368 error (_("Bad subsection length (%u < 6)\n"),
17376 end
= p
+ size
- 1;
17377 assert (end
<= contents
+ sect
->sh_size
);
17383 printf (_("File Attributes\n"));
17386 printf (_("Section Attributes:"));
17389 printf (_("Symbol Attributes:"));
17390 /* Fall through. */
17394 READ_ULEB (val
, p
, end
);
17397 printf (" %d", val
);
17402 printf (_("Unknown tag: %d\n"), tag
);
17403 public_section
= false;
17407 if (public_section
&& display_pub_attribute
!= NULL
)
17410 p
= display_pub_attribute (p
, end
);
17413 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
17416 p
= display_gnu_attribute (p
,
17417 display_proc_gnu_attribute
,
17423 printf (_(" Unknown attribute:\n"));
17424 display_raw_attribute (p
, end
);
17439 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
17440 Print the Address, Access and Initial fields of an entry at VMA ADDR
17441 and return the VMA of the next entry, or -1 if there was a problem.
17442 Does not read from DATA_END or beyond. */
17445 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
17446 unsigned char * data_end
)
17449 print_vma (addr
, LONG_HEX
);
17451 if (addr
< pltgot
+ 0xfff0)
17452 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
17454 printf ("%10s", "");
17457 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
17461 unsigned char * from
= data
+ addr
- pltgot
;
17463 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
17465 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
17466 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
17467 return (bfd_vma
) -1;
17471 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
17472 print_vma (entry
, LONG_HEX
);
17475 return addr
+ (is_32bit_elf
? 4 : 8);
17478 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
17479 PLTGOT. Print the Address and Initial fields of an entry at VMA
17480 ADDR and return the VMA of the next entry. */
17483 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
17486 print_vma (addr
, LONG_HEX
);
17489 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
17494 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
17495 print_vma (entry
, LONG_HEX
);
17497 return addr
+ (is_32bit_elf
? 4 : 8);
17501 print_mips_ases (unsigned int mask
)
17503 if (mask
& AFL_ASE_DSP
)
17504 fputs ("\n\tDSP ASE", stdout
);
17505 if (mask
& AFL_ASE_DSPR2
)
17506 fputs ("\n\tDSP R2 ASE", stdout
);
17507 if (mask
& AFL_ASE_DSPR3
)
17508 fputs ("\n\tDSP R3 ASE", stdout
);
17509 if (mask
& AFL_ASE_EVA
)
17510 fputs ("\n\tEnhanced VA Scheme", stdout
);
17511 if (mask
& AFL_ASE_MCU
)
17512 fputs ("\n\tMCU (MicroController) ASE", stdout
);
17513 if (mask
& AFL_ASE_MDMX
)
17514 fputs ("\n\tMDMX ASE", stdout
);
17515 if (mask
& AFL_ASE_MIPS3D
)
17516 fputs ("\n\tMIPS-3D ASE", stdout
);
17517 if (mask
& AFL_ASE_MT
)
17518 fputs ("\n\tMT ASE", stdout
);
17519 if (mask
& AFL_ASE_SMARTMIPS
)
17520 fputs ("\n\tSmartMIPS ASE", stdout
);
17521 if (mask
& AFL_ASE_VIRT
)
17522 fputs ("\n\tVZ ASE", stdout
);
17523 if (mask
& AFL_ASE_MSA
)
17524 fputs ("\n\tMSA ASE", stdout
);
17525 if (mask
& AFL_ASE_MIPS16
)
17526 fputs ("\n\tMIPS16 ASE", stdout
);
17527 if (mask
& AFL_ASE_MICROMIPS
)
17528 fputs ("\n\tMICROMIPS ASE", stdout
);
17529 if (mask
& AFL_ASE_XPA
)
17530 fputs ("\n\tXPA ASE", stdout
);
17531 if (mask
& AFL_ASE_MIPS16E2
)
17532 fputs ("\n\tMIPS16e2 ASE", stdout
);
17533 if (mask
& AFL_ASE_CRC
)
17534 fputs ("\n\tCRC ASE", stdout
);
17535 if (mask
& AFL_ASE_GINV
)
17536 fputs ("\n\tGINV ASE", stdout
);
17537 if (mask
& AFL_ASE_LOONGSON_MMI
)
17538 fputs ("\n\tLoongson MMI ASE", stdout
);
17539 if (mask
& AFL_ASE_LOONGSON_CAM
)
17540 fputs ("\n\tLoongson CAM ASE", stdout
);
17541 if (mask
& AFL_ASE_LOONGSON_EXT
)
17542 fputs ("\n\tLoongson EXT ASE", stdout
);
17543 if (mask
& AFL_ASE_LOONGSON_EXT2
)
17544 fputs ("\n\tLoongson EXT2 ASE", stdout
);
17546 fprintf (stdout
, "\n\t%s", _("None"));
17547 else if ((mask
& ~AFL_ASE_MASK
) != 0)
17548 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
17552 print_mips_isa_ext (unsigned int isa_ext
)
17557 fputs (_("None"), stdout
);
17560 fputs ("RMI XLR", stdout
);
17562 case AFL_EXT_OCTEON3
:
17563 fputs ("Cavium Networks Octeon3", stdout
);
17565 case AFL_EXT_OCTEON2
:
17566 fputs ("Cavium Networks Octeon2", stdout
);
17568 case AFL_EXT_OCTEONP
:
17569 fputs ("Cavium Networks OcteonP", stdout
);
17571 case AFL_EXT_OCTEON
:
17572 fputs ("Cavium Networks Octeon", stdout
);
17575 fputs ("Toshiba R5900", stdout
);
17578 fputs ("MIPS R4650", stdout
);
17581 fputs ("LSI R4010", stdout
);
17584 fputs ("NEC VR4100", stdout
);
17587 fputs ("Toshiba R3900", stdout
);
17589 case AFL_EXT_10000
:
17590 fputs ("MIPS R10000", stdout
);
17593 fputs ("Broadcom SB-1", stdout
);
17596 fputs ("NEC VR4111/VR4181", stdout
);
17599 fputs ("NEC VR4120", stdout
);
17602 fputs ("NEC VR5400", stdout
);
17605 fputs ("NEC VR5500", stdout
);
17607 case AFL_EXT_LOONGSON_2E
:
17608 fputs ("ST Microelectronics Loongson 2E", stdout
);
17610 case AFL_EXT_LOONGSON_2F
:
17611 fputs ("ST Microelectronics Loongson 2F", stdout
);
17613 case AFL_EXT_INTERAPTIV_MR2
:
17614 fputs ("Imagination interAptiv MR2", stdout
);
17617 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
17622 get_mips_reg_size (int reg_size
)
17624 return (reg_size
== AFL_REG_NONE
) ? 0
17625 : (reg_size
== AFL_REG_32
) ? 32
17626 : (reg_size
== AFL_REG_64
) ? 64
17627 : (reg_size
== AFL_REG_128
) ? 128
17632 process_mips_specific (Filedata
* filedata
)
17634 Elf_Internal_Dyn
* entry
;
17635 Elf_Internal_Shdr
*sect
= NULL
;
17636 size_t liblist_offset
= 0;
17637 size_t liblistno
= 0;
17638 size_t conflictsno
= 0;
17639 size_t options_offset
= 0;
17640 size_t conflicts_offset
= 0;
17641 size_t pltrelsz
= 0;
17643 bfd_vma pltgot
= 0;
17644 bfd_vma mips_pltgot
= 0;
17645 bfd_vma jmprel
= 0;
17646 bfd_vma local_gotno
= 0;
17647 bfd_vma gotsym
= 0;
17648 bfd_vma symtabno
= 0;
17651 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17652 display_mips_gnu_attribute
))
17655 sect
= find_section (filedata
, ".MIPS.abiflags");
17659 Elf_External_ABIFlags_v0
*abiflags_ext
;
17660 Elf_Internal_ABIFlags_v0 abiflags_in
;
17662 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
17664 error (_("Corrupt MIPS ABI Flags section.\n"));
17669 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17670 sect
->sh_size
, _("MIPS ABI Flags section"));
17673 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
17674 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
17675 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
17676 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
17677 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
17678 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
17679 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
17680 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
17681 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
17682 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
17683 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
17685 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
17686 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
17687 if (abiflags_in
.isa_rev
> 1)
17688 printf ("r%d", abiflags_in
.isa_rev
);
17689 printf ("\nGPR size: %d",
17690 get_mips_reg_size (abiflags_in
.gpr_size
));
17691 printf ("\nCPR1 size: %d",
17692 get_mips_reg_size (abiflags_in
.cpr1_size
));
17693 printf ("\nCPR2 size: %d",
17694 get_mips_reg_size (abiflags_in
.cpr2_size
));
17695 fputs ("\nFP ABI: ", stdout
);
17696 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
17697 fputs ("ISA Extension: ", stdout
);
17698 print_mips_isa_ext (abiflags_in
.isa_ext
);
17699 fputs ("\nASEs:", stdout
);
17700 print_mips_ases (abiflags_in
.ases
);
17701 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
17702 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
17703 fputc ('\n', stdout
);
17704 free (abiflags_ext
);
17709 /* We have a lot of special sections. Thanks SGI! */
17710 if (filedata
->dynamic_section
== NULL
)
17712 /* No dynamic information available. See if there is static GOT. */
17713 sect
= find_section (filedata
, ".got");
17716 unsigned char *data_end
;
17717 unsigned char *data
;
17721 pltgot
= sect
->sh_addr
;
17724 addr_size
= (is_32bit_elf
? 4 : 8);
17725 end
= pltgot
+ sect
->sh_size
;
17727 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
17729 _("Global Offset Table data"));
17730 /* PR 12855: Null data is handled gracefully throughout. */
17731 data_end
= data
+ (end
- pltgot
);
17733 printf (_("\nStatic GOT:\n"));
17734 printf (_(" Canonical gp value: "));
17735 print_vma (ent
+ 0x7ff0, LONG_HEX
);
17738 /* In a dynamic binary GOT[0] is reserved for the dynamic
17739 loader to store the lazy resolver pointer, however in
17740 a static binary it may well have been omitted and GOT
17741 reduced to a table of addresses.
17742 PR 21344: Check for the entry being fully available
17743 before fetching it. */
17745 && data
+ ent
- pltgot
+ addr_size
<= data_end
17746 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
17748 printf (_(" Reserved entries:\n"));
17749 printf (_(" %*s %10s %*s\n"),
17750 addr_size
* 2, _("Address"), _("Access"),
17751 addr_size
* 2, _("Value"));
17752 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17754 if (ent
== (bfd_vma
) -1)
17755 goto sgot_print_fail
;
17757 /* Check for the MSB of GOT[1] being set, identifying a
17758 GNU object. This entry will be used by some runtime
17759 loaders, to store the module pointer. Otherwise this
17760 is an ordinary local entry.
17761 PR 21344: Check for the entry being fully available
17762 before fetching it. */
17764 && data
+ ent
- pltgot
+ addr_size
<= data_end
17765 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17766 >> (addr_size
* 8 - 1)) != 0)
17768 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17770 if (ent
== (bfd_vma
) -1)
17771 goto sgot_print_fail
;
17776 if (data
!= NULL
&& ent
< end
)
17778 printf (_(" Local entries:\n"));
17779 printf (" %*s %10s %*s\n",
17780 addr_size
* 2, _("Address"), _("Access"),
17781 addr_size
* 2, _("Value"));
17784 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17786 if (ent
== (bfd_vma
) -1)
17787 goto sgot_print_fail
;
17798 for (entry
= filedata
->dynamic_section
;
17799 /* PR 17531 file: 012-50589-0.004. */
17800 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
17801 && entry
->d_tag
!= DT_NULL
);
17803 switch (entry
->d_tag
)
17805 case DT_MIPS_LIBLIST
:
17807 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
17808 liblistno
* sizeof (Elf32_External_Lib
));
17810 case DT_MIPS_LIBLISTNO
:
17811 liblistno
= entry
->d_un
.d_val
;
17813 case DT_MIPS_OPTIONS
:
17814 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
17816 case DT_MIPS_CONFLICT
:
17818 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
17819 conflictsno
* sizeof (Elf32_External_Conflict
));
17821 case DT_MIPS_CONFLICTNO
:
17822 conflictsno
= entry
->d_un
.d_val
;
17825 pltgot
= entry
->d_un
.d_ptr
;
17827 case DT_MIPS_LOCAL_GOTNO
:
17828 local_gotno
= entry
->d_un
.d_val
;
17830 case DT_MIPS_GOTSYM
:
17831 gotsym
= entry
->d_un
.d_val
;
17833 case DT_MIPS_SYMTABNO
:
17834 symtabno
= entry
->d_un
.d_val
;
17836 case DT_MIPS_PLTGOT
:
17837 mips_pltgot
= entry
->d_un
.d_ptr
;
17840 pltrel
= entry
->d_un
.d_val
;
17843 pltrelsz
= entry
->d_un
.d_val
;
17846 jmprel
= entry
->d_un
.d_ptr
;
17852 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
17854 Elf32_External_Lib
* elib
;
17857 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
17858 sizeof (Elf32_External_Lib
),
17860 _("liblist section data"));
17863 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
17864 "\nSection '.liblist' contains %lu entries:\n",
17865 (unsigned long) liblistno
),
17866 (unsigned long) liblistno
);
17867 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
17870 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
17877 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17878 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17879 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17880 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17881 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17883 tmp
= gmtime (&atime
);
17884 snprintf (timebuf
, sizeof (timebuf
),
17885 "%04u-%02u-%02uT%02u:%02u:%02u",
17886 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17887 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17889 printf ("%3lu: ", (unsigned long) cnt
);
17890 if (VALID_DYNAMIC_NAME (filedata
, liblist
.l_name
))
17891 print_symbol (20, GET_DYNAMIC_NAME (filedata
, liblist
.l_name
));
17893 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
17894 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
17895 liblist
.l_version
);
17897 if (liblist
.l_flags
== 0)
17901 static const struct
17908 { " EXACT_MATCH", LL_EXACT_MATCH
},
17909 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
17910 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
17911 { " EXPORTS", LL_EXPORTS
},
17912 { " DELAY_LOAD", LL_DELAY_LOAD
},
17913 { " DELTA", LL_DELTA
}
17915 int flags
= liblist
.l_flags
;
17918 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
17919 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
17921 fputs (l_flags_vals
[fcnt
].name
, stdout
);
17922 flags
^= l_flags_vals
[fcnt
].bit
;
17925 printf (" %#x", (unsigned int) flags
);
17937 if (options_offset
!= 0)
17939 Elf_External_Options
* eopt
;
17942 sect
= filedata
->section_headers
;
17944 /* Find the section header so that we get the size. */
17945 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
17946 /* PR 17533 file: 012-277276-0.004. */
17949 error (_("No MIPS_OPTIONS header found\n"));
17953 if (sect
->sh_size
< sizeof (* eopt
))
17955 error (_("The MIPS options section is too small.\n"));
17959 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
17960 sect
->sh_size
, _("options"));
17963 Elf_Internal_Options option
;
17966 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
17968 Elf_External_Options
* eoption
;
17969 unsigned int optsize
;
17971 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
17973 optsize
= BYTE_GET (eoption
->size
);
17975 /* PR 17531: file: ffa0fa3b. */
17976 if (optsize
< sizeof (* eopt
)
17977 || optsize
> sect
->sh_size
- offset
)
17979 error (_("Invalid size (%u) for MIPS option\n"),
17988 printf (ngettext ("\nSection '%s' contains %d entry:\n",
17989 "\nSection '%s' contains %d entries:\n",
17991 printable_section_name (filedata
, sect
), cnt
);
17997 Elf_External_Options
* eoption
;
17999 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
18001 option
.kind
= BYTE_GET (eoption
->kind
);
18002 option
.size
= BYTE_GET (eoption
->size
);
18003 option
.section
= BYTE_GET (eoption
->section
);
18004 option
.info
= BYTE_GET (eoption
->info
);
18006 switch (option
.kind
)
18009 /* This shouldn't happen. */
18010 printf (" NULL %" PRId16
" %" PRIx32
,
18011 option
.section
, option
.info
);
18015 printf (" REGINFO ");
18016 if (filedata
->file_header
.e_machine
== EM_MIPS
)
18018 Elf32_External_RegInfo
* ereg
;
18019 Elf32_RegInfo reginfo
;
18022 if (option
.size
< (sizeof (Elf_External_Options
)
18023 + sizeof (Elf32_External_RegInfo
)))
18025 printf (_("<corrupt>\n"));
18026 error (_("Truncated MIPS REGINFO option\n"));
18031 ereg
= (Elf32_External_RegInfo
*) (eoption
+ 1);
18033 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
18034 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
18035 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
18036 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
18037 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
18038 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
18040 printf ("GPR %08" PRIx32
" GP 0x%" PRIx32
"\n",
18041 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
18043 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
18044 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
18045 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
18046 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
18051 Elf64_External_RegInfo
* ereg
;
18052 Elf64_Internal_RegInfo reginfo
;
18054 if (option
.size
< (sizeof (Elf_External_Options
)
18055 + sizeof (Elf64_External_RegInfo
)))
18057 printf (_("<corrupt>\n"));
18058 error (_("Truncated MIPS REGINFO option\n"));
18063 ereg
= (Elf64_External_RegInfo
*) (eoption
+ 1);
18064 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
18065 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
18066 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
18067 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
18068 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
18069 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
18071 printf ("GPR %08" PRIx32
" GP 0x%" PRIx64
"\n",
18072 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
18074 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
18075 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
18076 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
18077 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
18079 offset
+= option
.size
;
18082 case ODK_EXCEPTIONS
:
18083 fputs (" EXCEPTIONS fpe_min(", stdout
);
18084 process_mips_fpe_exception (option
.info
& OEX_FPU_MIN
);
18085 fputs (") fpe_max(", stdout
);
18086 process_mips_fpe_exception ((option
.info
& OEX_FPU_MAX
) >> 8);
18087 fputs (")", stdout
);
18089 if (option
.info
& OEX_PAGE0
)
18090 fputs (" PAGE0", stdout
);
18091 if (option
.info
& OEX_SMM
)
18092 fputs (" SMM", stdout
);
18093 if (option
.info
& OEX_FPDBUG
)
18094 fputs (" FPDBUG", stdout
);
18095 if (option
.info
& OEX_DISMISS
)
18096 fputs (" DISMISS", stdout
);
18100 fputs (" PAD ", stdout
);
18101 if (option
.info
& OPAD_PREFIX
)
18102 fputs (" PREFIX", stdout
);
18103 if (option
.info
& OPAD_POSTFIX
)
18104 fputs (" POSTFIX", stdout
);
18105 if (option
.info
& OPAD_SYMBOL
)
18106 fputs (" SYMBOL", stdout
);
18110 fputs (" HWPATCH ", stdout
);
18111 if (option
.info
& OHW_R4KEOP
)
18112 fputs (" R4KEOP", stdout
);
18113 if (option
.info
& OHW_R8KPFETCH
)
18114 fputs (" R8KPFETCH", stdout
);
18115 if (option
.info
& OHW_R5KEOP
)
18116 fputs (" R5KEOP", stdout
);
18117 if (option
.info
& OHW_R5KCVTL
)
18118 fputs (" R5KCVTL", stdout
);
18122 fputs (" FILL ", stdout
);
18123 /* XXX Print content of info word? */
18127 fputs (" TAGS ", stdout
);
18128 /* XXX Print content of info word? */
18132 fputs (" HWAND ", stdout
);
18133 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
18134 fputs (" R4KEOP_CHECKED", stdout
);
18135 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
18136 fputs (" R4KEOP_CLEAN", stdout
);
18140 fputs (" HWOR ", stdout
);
18141 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
18142 fputs (" R4KEOP_CHECKED", stdout
);
18143 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
18144 fputs (" R4KEOP_CLEAN", stdout
);
18148 printf (" GP_GROUP %#06x self-contained %#06x",
18149 option
.info
& OGP_GROUP
,
18150 (option
.info
& OGP_SELF
) >> 16);
18154 printf (" IDENT %#06x self-contained %#06x",
18155 option
.info
& OGP_GROUP
,
18156 (option
.info
& OGP_SELF
) >> 16);
18160 /* This shouldn't happen. */
18161 printf (" %3d ??? %" PRId16
" %" PRIx32
,
18162 option
.kind
, option
.section
, option
.info
);
18166 len
= sizeof (* eopt
);
18167 while (len
< option
.size
)
18169 unsigned char datum
= *((unsigned char *) eoption
+ len
);
18171 if (ISPRINT (datum
))
18172 printf ("%c", datum
);
18174 printf ("\\%03o", datum
);
18177 fputs ("\n", stdout
);
18179 offset
+= option
.size
;
18187 if (conflicts_offset
!= 0 && conflictsno
!= 0)
18189 Elf32_Conflict
* iconf
;
18192 if (filedata
->dynamic_symbols
== NULL
)
18194 error (_("conflict list found without a dynamic symbol table\n"));
18198 /* PR 21345 - print a slightly more helpful error message
18199 if we are sure that the cmalloc will fail. */
18200 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
18202 error (_("Overlarge number of conflicts detected: %lx\n"),
18203 (long) conflictsno
);
18207 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
18210 error (_("Out of memory allocating space for dynamic conflicts\n"));
18216 Elf32_External_Conflict
* econf32
;
18218 econf32
= (Elf32_External_Conflict
*)
18219 get_data (NULL
, filedata
, conflicts_offset
,
18220 sizeof (*econf32
), conflictsno
, _("conflict"));
18227 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18228 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
18234 Elf64_External_Conflict
* econf64
;
18236 econf64
= (Elf64_External_Conflict
*)
18237 get_data (NULL
, filedata
, conflicts_offset
,
18238 sizeof (*econf64
), conflictsno
, _("conflict"));
18245 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18246 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
18251 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
18252 "\nSection '.conflict' contains %lu entries:\n",
18253 (unsigned long) conflictsno
),
18254 (unsigned long) conflictsno
);
18255 puts (_(" Num: Index Value Name"));
18257 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18259 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
18261 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
18262 printf (_("<corrupt symbol index>"));
18265 Elf_Internal_Sym
* psym
;
18267 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
18268 print_vma (psym
->st_value
, FULL_HEX
);
18270 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
18271 print_symbol (25, GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
18273 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18281 if (pltgot
!= 0 && local_gotno
!= 0)
18283 bfd_vma ent
, local_end
, global_end
;
18285 unsigned char * data
;
18286 unsigned char * data_end
;
18290 addr_size
= (is_32bit_elf
? 4 : 8);
18291 local_end
= pltgot
+ local_gotno
* addr_size
;
18293 /* PR binutils/17533 file: 012-111227-0.004 */
18294 if (symtabno
< gotsym
)
18296 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
18297 (unsigned long) gotsym
, (unsigned long) symtabno
);
18301 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
18302 /* PR 17531: file: 54c91a34. */
18303 if (global_end
< local_end
)
18305 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
18309 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
18310 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
18311 global_end
- pltgot
, 1,
18312 _("Global Offset Table data"));
18313 /* PR 12855: Null data is handled gracefully throughout. */
18314 data_end
= data
+ (global_end
- pltgot
);
18316 printf (_("\nPrimary GOT:\n"));
18317 printf (_(" Canonical gp value: "));
18318 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
18321 printf (_(" Reserved entries:\n"));
18322 printf (_(" %*s %10s %*s Purpose\n"),
18323 addr_size
* 2, _("Address"), _("Access"),
18324 addr_size
* 2, _("Initial"));
18325 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18326 printf (_(" Lazy resolver\n"));
18327 if (ent
== (bfd_vma
) -1)
18328 goto got_print_fail
;
18330 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
18331 This entry will be used by some runtime loaders, to store the
18332 module pointer. Otherwise this is an ordinary local entry.
18333 PR 21344: Check for the entry being fully available before
18336 && data
+ ent
- pltgot
+ addr_size
<= data_end
18337 && (byte_get (data
+ ent
- pltgot
, addr_size
)
18338 >> (addr_size
* 8 - 1)) != 0)
18340 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18341 printf (_(" Module pointer (GNU extension)\n"));
18342 if (ent
== (bfd_vma
) -1)
18343 goto got_print_fail
;
18347 if (data
!= NULL
&& ent
< local_end
)
18349 printf (_(" Local entries:\n"));
18350 printf (" %*s %10s %*s\n",
18351 addr_size
* 2, _("Address"), _("Access"),
18352 addr_size
* 2, _("Initial"));
18353 while (ent
< local_end
)
18355 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18357 if (ent
== (bfd_vma
) -1)
18358 goto got_print_fail
;
18363 if (data
!= NULL
&& gotsym
< symtabno
)
18367 printf (_(" Global entries:\n"));
18368 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
18369 addr_size
* 2, _("Address"),
18371 addr_size
* 2, _("Initial"),
18372 addr_size
* 2, _("Sym.Val."),
18374 /* Note for translators: "Ndx" = abbreviated form of "Index". */
18375 _("Ndx"), _("Name"));
18377 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
18379 for (i
= gotsym
; i
< symtabno
; i
++)
18381 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18384 if (filedata
->dynamic_symbols
== NULL
)
18385 printf (_("<no dynamic symbols>"));
18386 else if (i
< filedata
->num_dynamic_syms
)
18388 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
18390 print_vma (psym
->st_value
, LONG_HEX
);
18391 printf (" %-7s %3s ",
18392 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
18393 get_symbol_index_type (filedata
, psym
->st_shndx
));
18395 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
18396 print_symbol (sym_width
,
18397 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
18399 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18402 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
18403 (unsigned long) i
);
18406 if (ent
== (bfd_vma
) -1)
18416 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
18419 size_t offset
, rel_offset
;
18420 unsigned long count
, i
;
18421 unsigned char * data
;
18422 int addr_size
, sym_width
;
18423 Elf_Internal_Rela
* rels
;
18425 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
18426 if (pltrel
== DT_RELA
)
18428 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
18433 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
18438 addr_size
= (is_32bit_elf
? 4 : 8);
18439 end
= mips_pltgot
+ (2 + count
) * addr_size
;
18441 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
18442 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
18443 1, _("Procedure Linkage Table data"));
18450 printf ("\nPLT GOT:\n\n");
18451 printf (_(" Reserved entries:\n"));
18452 printf (_(" %*s %*s Purpose\n"),
18453 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
18454 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18455 printf (_(" PLT lazy resolver\n"));
18456 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18457 printf (_(" Module pointer\n"));
18460 printf (_(" Entries:\n"));
18461 printf (" %*s %*s %*s %-7s %3s %s\n",
18462 addr_size
* 2, _("Address"),
18463 addr_size
* 2, _("Initial"),
18464 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
18465 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
18466 for (i
= 0; i
< count
; i
++)
18468 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
18470 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18473 if (idx
>= filedata
->num_dynamic_syms
)
18474 printf (_("<corrupt symbol index: %lu>"), idx
);
18477 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
18479 print_vma (psym
->st_value
, LONG_HEX
);
18480 printf (" %-7s %3s ",
18481 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
18482 get_symbol_index_type (filedata
, psym
->st_shndx
));
18483 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
18484 print_symbol (sym_width
,
18485 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
18487 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18501 process_nds32_specific (Filedata
* filedata
)
18503 Elf_Internal_Shdr
*sect
= NULL
;
18505 sect
= find_section (filedata
, ".nds32_e_flags");
18506 if (sect
!= NULL
&& sect
->sh_size
>= 4)
18508 unsigned char *buf
;
18511 printf ("\nNDS32 elf flags section:\n");
18512 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
18513 _("NDS32 elf flags section"));
18518 flag
= byte_get (buf
, 4);
18520 switch (flag
& 0x3)
18523 printf ("(VEC_SIZE):\tNo entry.\n");
18526 printf ("(VEC_SIZE):\t4 bytes\n");
18529 printf ("(VEC_SIZE):\t16 bytes\n");
18532 printf ("(VEC_SIZE):\treserved\n");
18541 process_gnu_liblist (Filedata
* filedata
)
18543 Elf_Internal_Shdr
* section
;
18544 Elf_Internal_Shdr
* string_sec
;
18545 Elf32_External_Lib
* elib
;
18547 size_t strtab_size
;
18549 unsigned long num_liblist
;
18556 for (i
= 0, section
= filedata
->section_headers
;
18557 i
< filedata
->file_header
.e_shnum
;
18560 switch (section
->sh_type
)
18562 case SHT_GNU_LIBLIST
:
18563 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
18566 elib
= (Elf32_External_Lib
*)
18567 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
18568 _("liblist section data"));
18576 string_sec
= filedata
->section_headers
+ section
->sh_link
;
18577 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
18578 string_sec
->sh_size
,
18579 _("liblist string table"));
18581 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
18588 strtab_size
= string_sec
->sh_size
;
18590 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
18591 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
18592 "\nLibrary list section '%s' contains %lu entries:\n",
18594 printable_section_name (filedata
, section
),
18597 puts (_(" Library Time Stamp Checksum Version Flags"));
18599 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
18607 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
18608 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
18609 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
18610 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
18611 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
18613 tmp
= gmtime (&atime
);
18614 snprintf (timebuf
, sizeof (timebuf
),
18615 "%04u-%02u-%02uT%02u:%02u:%02u",
18616 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
18617 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
18619 printf ("%3lu: ", (unsigned long) cnt
);
18621 printf ("%-20s", liblist
.l_name
< strtab_size
18622 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
18624 printf ("%-20.20s", liblist
.l_name
< strtab_size
18625 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
18626 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
18627 liblist
.l_version
, liblist
.l_flags
);
18638 static const char *
18639 get_note_type (Filedata
* filedata
, unsigned e_type
)
18641 static char buff
[64];
18643 if (filedata
->file_header
.e_type
== ET_CORE
)
18647 return _("NT_AUXV (auxiliary vector)");
18649 return _("NT_PRSTATUS (prstatus structure)");
18651 return _("NT_FPREGSET (floating point registers)");
18653 return _("NT_PRPSINFO (prpsinfo structure)");
18654 case NT_TASKSTRUCT
:
18655 return _("NT_TASKSTRUCT (task structure)");
18657 return _("NT_GDB_TDESC (GDB XML target description)");
18659 return _("NT_PRXFPREG (user_xfpregs structure)");
18661 return _("NT_PPC_VMX (ppc Altivec registers)");
18663 return _("NT_PPC_VSX (ppc VSX registers)");
18665 return _("NT_PPC_TAR (ppc TAR register)");
18667 return _("NT_PPC_PPR (ppc PPR register)");
18669 return _("NT_PPC_DSCR (ppc DSCR register)");
18671 return _("NT_PPC_EBB (ppc EBB registers)");
18673 return _("NT_PPC_PMU (ppc PMU registers)");
18674 case NT_PPC_TM_CGPR
:
18675 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
18676 case NT_PPC_TM_CFPR
:
18677 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
18678 case NT_PPC_TM_CVMX
:
18679 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
18680 case NT_PPC_TM_CVSX
:
18681 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
18682 case NT_PPC_TM_SPR
:
18683 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
18684 case NT_PPC_TM_CTAR
:
18685 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
18686 case NT_PPC_TM_CPPR
:
18687 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
18688 case NT_PPC_TM_CDSCR
:
18689 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
18691 return _("NT_386_TLS (x86 TLS information)");
18692 case NT_386_IOPERM
:
18693 return _("NT_386_IOPERM (x86 I/O permissions)");
18694 case NT_X86_XSTATE
:
18695 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
18697 return _("NT_X86_CET (x86 CET state)");
18698 case NT_S390_HIGH_GPRS
:
18699 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
18700 case NT_S390_TIMER
:
18701 return _("NT_S390_TIMER (s390 timer register)");
18702 case NT_S390_TODCMP
:
18703 return _("NT_S390_TODCMP (s390 TOD comparator register)");
18704 case NT_S390_TODPREG
:
18705 return _("NT_S390_TODPREG (s390 TOD programmable register)");
18707 return _("NT_S390_CTRS (s390 control registers)");
18708 case NT_S390_PREFIX
:
18709 return _("NT_S390_PREFIX (s390 prefix register)");
18710 case NT_S390_LAST_BREAK
:
18711 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
18712 case NT_S390_SYSTEM_CALL
:
18713 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
18715 return _("NT_S390_TDB (s390 transaction diagnostic block)");
18716 case NT_S390_VXRS_LOW
:
18717 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
18718 case NT_S390_VXRS_HIGH
:
18719 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
18720 case NT_S390_GS_CB
:
18721 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
18722 case NT_S390_GS_BC
:
18723 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
18725 return _("NT_ARM_VFP (arm VFP registers)");
18727 return _("NT_ARM_TLS (AArch TLS registers)");
18728 case NT_ARM_HW_BREAK
:
18729 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
18730 case NT_ARM_HW_WATCH
:
18731 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
18733 return _("NT_ARM_SVE (AArch SVE registers)");
18734 case NT_ARM_PAC_MASK
:
18735 return _("NT_ARM_PAC_MASK (AArch pointer authentication code masks)");
18736 case NT_ARM_TAGGED_ADDR_CTRL
:
18737 return _("NT_ARM_TAGGED_ADDR_CTRL (AArch tagged address control)");
18739 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
18741 return _("NT_RISCV_CSR (RISC-V control and status registers)");
18743 return _("NT_PSTATUS (pstatus structure)");
18745 return _("NT_FPREGS (floating point registers)");
18747 return _("NT_PSINFO (psinfo structure)");
18749 return _("NT_LWPSTATUS (lwpstatus_t structure)");
18751 return _("NT_LWPSINFO (lwpsinfo_t structure)");
18752 case NT_WIN32PSTATUS
:
18753 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
18755 return _("NT_SIGINFO (siginfo_t data)");
18757 return _("NT_FILE (mapped files)");
18759 return _("NT_MEMTAG (memory tags)");
18767 return _("NT_VERSION (version)");
18769 return _("NT_ARCH (architecture)");
18770 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
18772 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
18778 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18783 print_core_note (Elf_Internal_Note
*pnote
)
18785 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
18786 bfd_vma count
, page_size
;
18787 unsigned char *descdata
, *filenames
, *descend
;
18789 if (pnote
->type
!= NT_FILE
)
18799 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
18800 /* Still "successful". */
18805 if (pnote
->descsz
< 2 * addr_size
)
18807 error (_(" Malformed note - too short for header\n"));
18811 descdata
= (unsigned char *) pnote
->descdata
;
18812 descend
= descdata
+ pnote
->descsz
;
18814 if (descdata
[pnote
->descsz
- 1] != '\0')
18816 error (_(" Malformed note - does not end with \\0\n"));
18820 count
= byte_get (descdata
, addr_size
);
18821 descdata
+= addr_size
;
18823 page_size
= byte_get (descdata
, addr_size
);
18824 descdata
+= addr_size
;
18826 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
18827 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
18829 error (_(" Malformed note - too short for supplied file count\n"));
18833 printf (_(" Page size: "));
18834 print_vma (page_size
, DEC
);
18837 printf (_(" %*s%*s%*s\n"),
18838 (int) (2 + 2 * addr_size
), _("Start"),
18839 (int) (4 + 2 * addr_size
), _("End"),
18840 (int) (4 + 2 * addr_size
), _("Page Offset"));
18841 filenames
= descdata
+ count
* 3 * addr_size
;
18842 while (count
-- > 0)
18844 bfd_vma start
, end
, file_ofs
;
18846 if (filenames
== descend
)
18848 error (_(" Malformed note - filenames end too early\n"));
18852 start
= byte_get (descdata
, addr_size
);
18853 descdata
+= addr_size
;
18854 end
= byte_get (descdata
, addr_size
);
18855 descdata
+= addr_size
;
18856 file_ofs
= byte_get (descdata
, addr_size
);
18857 descdata
+= addr_size
;
18860 print_vma (start
, FULL_HEX
);
18862 print_vma (end
, FULL_HEX
);
18864 print_vma (file_ofs
, FULL_HEX
);
18865 printf ("\n %s\n", filenames
);
18867 filenames
+= 1 + strlen ((char *) filenames
);
18873 static const char *
18874 get_gnu_elf_note_type (unsigned e_type
)
18876 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
18879 case NT_GNU_ABI_TAG
:
18880 return _("NT_GNU_ABI_TAG (ABI version tag)");
18882 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
18883 case NT_GNU_BUILD_ID
:
18884 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
18885 case NT_GNU_GOLD_VERSION
:
18886 return _("NT_GNU_GOLD_VERSION (gold version)");
18887 case NT_GNU_PROPERTY_TYPE_0
:
18888 return _("NT_GNU_PROPERTY_TYPE_0");
18889 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
18890 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
18891 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
18892 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
18895 static char buff
[64];
18897 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18904 decode_x86_compat_isa (unsigned int bitmask
)
18908 unsigned int bit
= bitmask
& (- bitmask
);
18913 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
18916 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
18919 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
18922 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
18925 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
18928 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
18931 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
18934 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
18937 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
18940 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
18943 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
18946 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
18947 printf ("AVX512F");
18949 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
18950 printf ("AVX512CD");
18952 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
18953 printf ("AVX512ER");
18955 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
18956 printf ("AVX512PF");
18958 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
18959 printf ("AVX512VL");
18961 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
18962 printf ("AVX512DQ");
18964 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
18965 printf ("AVX512BW");
18968 printf (_("<unknown: %x>"), bit
);
18977 decode_x86_compat_2_isa (unsigned int bitmask
)
18981 printf (_("<None>"));
18987 unsigned int bit
= bitmask
& (- bitmask
);
18992 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_CMOV
:
18995 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE
:
18998 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE2
:
19001 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE3
:
19004 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSSE3
:
19007 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_1
:
19010 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_2
:
19013 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX
:
19016 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX2
:
19019 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_FMA
:
19022 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512F
:
19023 printf ("AVX512F");
19025 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512CD
:
19026 printf ("AVX512CD");
19028 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512ER
:
19029 printf ("AVX512ER");
19031 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512PF
:
19032 printf ("AVX512PF");
19034 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512VL
:
19035 printf ("AVX512VL");
19037 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512DQ
:
19038 printf ("AVX512DQ");
19040 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512BW
:
19041 printf ("AVX512BW");
19043 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4FMAPS
:
19044 printf ("AVX512_4FMAPS");
19046 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4VNNIW
:
19047 printf ("AVX512_4VNNIW");
19049 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BITALG
:
19050 printf ("AVX512_BITALG");
19052 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_IFMA
:
19053 printf ("AVX512_IFMA");
19055 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI
:
19056 printf ("AVX512_VBMI");
19058 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI2
:
19059 printf ("AVX512_VBMI2");
19061 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VNNI
:
19062 printf ("AVX512_VNNI");
19064 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BF16
:
19065 printf ("AVX512_BF16");
19068 printf (_("<unknown: %x>"), bit
);
19077 decode_x86_isa (unsigned int bitmask
)
19081 unsigned int bit
= bitmask
& (- bitmask
);
19086 case GNU_PROPERTY_X86_ISA_1_BASELINE
:
19087 printf ("x86-64-baseline");
19089 case GNU_PROPERTY_X86_ISA_1_V2
:
19090 printf ("x86-64-v2");
19092 case GNU_PROPERTY_X86_ISA_1_V3
:
19093 printf ("x86-64-v3");
19095 case GNU_PROPERTY_X86_ISA_1_V4
:
19096 printf ("x86-64-v4");
19099 printf (_("<unknown: %x>"), bit
);
19108 decode_x86_feature_1 (unsigned int bitmask
)
19112 printf (_("<None>"));
19118 unsigned int bit
= bitmask
& (- bitmask
);
19123 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
19126 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
19129 case GNU_PROPERTY_X86_FEATURE_1_LAM_U48
:
19130 printf ("LAM_U48");
19132 case GNU_PROPERTY_X86_FEATURE_1_LAM_U57
:
19133 printf ("LAM_U57");
19136 printf (_("<unknown: %x>"), bit
);
19145 decode_x86_feature_2 (unsigned int bitmask
)
19149 printf (_("<None>"));
19155 unsigned int bit
= bitmask
& (- bitmask
);
19160 case GNU_PROPERTY_X86_FEATURE_2_X86
:
19163 case GNU_PROPERTY_X86_FEATURE_2_X87
:
19166 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
19169 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
19172 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
19175 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
19178 case GNU_PROPERTY_X86_FEATURE_2_TMM
:
19181 case GNU_PROPERTY_X86_FEATURE_2_MASK
:
19184 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
19187 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
19190 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
19191 printf ("XSAVEOPT");
19193 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
19197 printf (_("<unknown: %x>"), bit
);
19206 decode_aarch64_feature_1_and (unsigned int bitmask
)
19210 unsigned int bit
= bitmask
& (- bitmask
);
19215 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
19219 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
19224 printf (_("<unknown: %x>"), bit
);
19233 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
19235 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
19236 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
19237 unsigned int size
= is_32bit_elf
? 4 : 8;
19239 printf (_(" Properties: "));
19241 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
19243 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
19247 while (ptr
< ptr_end
)
19251 unsigned int datasz
;
19253 if ((size_t) (ptr_end
- ptr
) < 8)
19255 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
19259 type
= byte_get (ptr
, 4);
19260 datasz
= byte_get (ptr
+ 4, 4);
19264 if (datasz
> (size_t) (ptr_end
- ptr
))
19266 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
19271 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
19273 if (filedata
->file_header
.e_machine
== EM_X86_64
19274 || filedata
->file_header
.e_machine
== EM_IAMCU
19275 || filedata
->file_header
.e_machine
== EM_386
)
19277 unsigned int bitmask
;
19280 bitmask
= byte_get (ptr
, 4);
19286 case GNU_PROPERTY_X86_ISA_1_USED
:
19288 printf (_("x86 ISA used: <corrupt length: %#x> "),
19292 printf ("x86 ISA used: ");
19293 decode_x86_isa (bitmask
);
19297 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
19299 printf (_("x86 ISA needed: <corrupt length: %#x> "),
19303 printf ("x86 ISA needed: ");
19304 decode_x86_isa (bitmask
);
19308 case GNU_PROPERTY_X86_FEATURE_1_AND
:
19310 printf (_("x86 feature: <corrupt length: %#x> "),
19314 printf ("x86 feature: ");
19315 decode_x86_feature_1 (bitmask
);
19319 case GNU_PROPERTY_X86_FEATURE_2_USED
:
19321 printf (_("x86 feature used: <corrupt length: %#x> "),
19325 printf ("x86 feature used: ");
19326 decode_x86_feature_2 (bitmask
);
19330 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
19332 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
19335 printf ("x86 feature needed: ");
19336 decode_x86_feature_2 (bitmask
);
19340 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
19342 printf (_("x86 ISA used: <corrupt length: %#x> "),
19346 printf ("x86 ISA used: ");
19347 decode_x86_compat_isa (bitmask
);
19351 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
19353 printf (_("x86 ISA needed: <corrupt length: %#x> "),
19357 printf ("x86 ISA needed: ");
19358 decode_x86_compat_isa (bitmask
);
19362 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_USED
:
19364 printf (_("x86 ISA used: <corrupt length: %#x> "),
19368 printf ("x86 ISA used: ");
19369 decode_x86_compat_2_isa (bitmask
);
19373 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_NEEDED
:
19375 printf (_("x86 ISA needed: <corrupt length: %#x> "),
19379 printf ("x86 ISA needed: ");
19380 decode_x86_compat_2_isa (bitmask
);
19388 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
19390 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
19392 printf ("AArch64 feature: ");
19394 printf (_("<corrupt length: %#x> "), datasz
);
19396 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
19405 case GNU_PROPERTY_STACK_SIZE
:
19406 printf (_("stack size: "));
19407 if (datasz
!= size
)
19408 printf (_("<corrupt length: %#x> "), datasz
);
19410 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
19413 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
19414 printf ("no copy on protected ");
19416 printf (_("<corrupt length: %#x> "), datasz
);
19424 if (type
< GNU_PROPERTY_LOPROC
)
19425 printf (_("<unknown type %#x data: "), type
);
19426 else if (type
< GNU_PROPERTY_LOUSER
)
19427 printf (_("<processor-specific type %#x data: "), type
);
19429 printf (_("<application-specific type %#x data: "), type
);
19430 for (j
= 0; j
< datasz
; ++j
)
19431 printf ("%02x ", ptr
[j
] & 0xff);
19435 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
19436 if (ptr
== ptr_end
)
19449 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
19451 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
19452 switch (pnote
->type
)
19454 case NT_GNU_BUILD_ID
:
19458 printf (_(" Build ID: "));
19459 for (i
= 0; i
< pnote
->descsz
; ++i
)
19460 printf ("%02x", pnote
->descdata
[i
] & 0xff);
19465 case NT_GNU_ABI_TAG
:
19467 unsigned long os
, major
, minor
, subminor
;
19468 const char *osname
;
19470 /* PR 17531: file: 030-599401-0.004. */
19471 if (pnote
->descsz
< 16)
19473 printf (_(" <corrupt GNU_ABI_TAG>\n"));
19477 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19478 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19479 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
19480 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
19484 case GNU_ABI_TAG_LINUX
:
19487 case GNU_ABI_TAG_HURD
:
19490 case GNU_ABI_TAG_SOLARIS
:
19491 osname
= "Solaris";
19493 case GNU_ABI_TAG_FREEBSD
:
19494 osname
= "FreeBSD";
19496 case GNU_ABI_TAG_NETBSD
:
19499 case GNU_ABI_TAG_SYLLABLE
:
19500 osname
= "Syllable";
19502 case GNU_ABI_TAG_NACL
:
19506 osname
= "Unknown";
19510 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
19511 major
, minor
, subminor
);
19515 case NT_GNU_GOLD_VERSION
:
19519 printf (_(" Version: "));
19520 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
19521 printf ("%c", pnote
->descdata
[i
]);
19528 unsigned long num_entries
, mask
;
19530 /* Hardware capabilities information. Word 0 is the number of entries.
19531 Word 1 is a bitmask of enabled entries. The rest of the descriptor
19532 is a series of entries, where each entry is a single byte followed
19533 by a nul terminated string. The byte gives the bit number to test
19534 if enabled in the bitmask. */
19535 printf (_(" Hardware Capabilities: "));
19536 if (pnote
->descsz
< 8)
19538 error (_("<corrupt GNU_HWCAP>\n"));
19541 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19542 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19543 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
19544 /* FIXME: Add code to display the entries... */
19548 case NT_GNU_PROPERTY_TYPE_0
:
19549 print_gnu_property_note (filedata
, pnote
);
19553 /* Handle unrecognised types. An error message should have already been
19554 created by get_gnu_elf_note_type(), so all that we need to do is to
19555 display the data. */
19559 printf (_(" Description data: "));
19560 for (i
= 0; i
< pnote
->descsz
; ++i
)
19561 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19570 static const char *
19571 get_v850_elf_note_type (enum v850_notes n_type
)
19573 static char buff
[64];
19577 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
19578 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
19579 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
19580 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
19581 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
19582 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
19584 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
19590 print_v850_note (Elf_Internal_Note
* pnote
)
19594 if (pnote
->descsz
!= 4)
19597 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
19601 printf (_("not set\n"));
19605 switch (pnote
->type
)
19607 case V850_NOTE_ALIGNMENT
:
19610 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return true;
19611 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return true;
19615 case V850_NOTE_DATA_SIZE
:
19618 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return true;
19619 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return true;
19623 case V850_NOTE_FPU_INFO
:
19626 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return true;
19627 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return true;
19631 case V850_NOTE_MMU_INFO
:
19632 case V850_NOTE_CACHE_INFO
:
19633 case V850_NOTE_SIMD_INFO
:
19634 if (val
== EF_RH850_SIMD
)
19636 printf (_("yes\n"));
19642 /* An 'unknown note type' message will already have been displayed. */
19646 printf (_("unknown value: %x\n"), val
);
19651 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
19653 unsigned int version
;
19655 switch (pnote
->type
)
19657 case NT_NETBSD_IDENT
:
19658 if (pnote
->descsz
< 1)
19660 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
19661 if ((version
/ 10000) % 100)
19662 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
19663 version
, version
/ 100000000, (version
/ 1000000) % 100,
19664 (version
/ 10000) % 100 > 26 ? "Z" : "",
19665 'A' + (version
/ 10000) % 26);
19667 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
19668 version
, version
/ 100000000, (version
/ 1000000) % 100,
19669 (version
/ 100) % 100);
19672 case NT_NETBSD_MARCH
:
19673 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
19677 case NT_NETBSD_PAX
:
19678 if (pnote
->descsz
< 1)
19680 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
19681 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
19682 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
19683 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
19684 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
19685 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
19686 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
19687 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
19691 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
19692 pnote
->descsz
, pnote
->type
);
19696 static const char *
19697 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
19701 case NT_FREEBSD_THRMISC
:
19702 return _("NT_THRMISC (thrmisc structure)");
19703 case NT_FREEBSD_PROCSTAT_PROC
:
19704 return _("NT_PROCSTAT_PROC (proc data)");
19705 case NT_FREEBSD_PROCSTAT_FILES
:
19706 return _("NT_PROCSTAT_FILES (files data)");
19707 case NT_FREEBSD_PROCSTAT_VMMAP
:
19708 return _("NT_PROCSTAT_VMMAP (vmmap data)");
19709 case NT_FREEBSD_PROCSTAT_GROUPS
:
19710 return _("NT_PROCSTAT_GROUPS (groups data)");
19711 case NT_FREEBSD_PROCSTAT_UMASK
:
19712 return _("NT_PROCSTAT_UMASK (umask data)");
19713 case NT_FREEBSD_PROCSTAT_RLIMIT
:
19714 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
19715 case NT_FREEBSD_PROCSTAT_OSREL
:
19716 return _("NT_PROCSTAT_OSREL (osreldate data)");
19717 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
19718 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
19719 case NT_FREEBSD_PROCSTAT_AUXV
:
19720 return _("NT_PROCSTAT_AUXV (auxv data)");
19721 case NT_FREEBSD_PTLWPINFO
:
19722 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
19724 return get_note_type (filedata
, e_type
);
19727 static const char *
19728 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
19730 static char buff
[64];
19734 case NT_NETBSDCORE_PROCINFO
:
19735 /* NetBSD core "procinfo" structure. */
19736 return _("NetBSD procinfo structure");
19738 case NT_NETBSDCORE_AUXV
:
19739 return _("NetBSD ELF auxiliary vector data");
19741 case NT_NETBSDCORE_LWPSTATUS
:
19742 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
19745 /* As of Jan 2020 there are no other machine-independent notes
19746 defined for NetBSD core files. If the note type is less
19747 than the start of the machine-dependent note types, we don't
19750 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
19752 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19758 switch (filedata
->file_header
.e_machine
)
19760 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
19761 and PT_GETFPREGS == mach+2. */
19766 case EM_SPARC32PLUS
:
19770 case NT_NETBSDCORE_FIRSTMACH
+ 0:
19771 return _("PT_GETREGS (reg structure)");
19772 case NT_NETBSDCORE_FIRSTMACH
+ 2:
19773 return _("PT_GETFPREGS (fpreg structure)");
19779 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
19780 There's also old PT___GETREGS40 == mach + 1 for old reg
19781 structure which lacks GBR. */
19785 case NT_NETBSDCORE_FIRSTMACH
+ 1:
19786 return _("PT___GETREGS40 (old reg structure)");
19787 case NT_NETBSDCORE_FIRSTMACH
+ 3:
19788 return _("PT_GETREGS (reg structure)");
19789 case NT_NETBSDCORE_FIRSTMACH
+ 5:
19790 return _("PT_GETFPREGS (fpreg structure)");
19796 /* On all other arch's, PT_GETREGS == mach+1 and
19797 PT_GETFPREGS == mach+3. */
19801 case NT_NETBSDCORE_FIRSTMACH
+ 1:
19802 return _("PT_GETREGS (reg structure)");
19803 case NT_NETBSDCORE_FIRSTMACH
+ 3:
19804 return _("PT_GETFPREGS (fpreg structure)");
19810 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
19811 e_type
- NT_NETBSDCORE_FIRSTMACH
);
19815 static const char *
19816 get_stapsdt_note_type (unsigned e_type
)
19818 static char buff
[64];
19823 return _("NT_STAPSDT (SystemTap probe descriptors)");
19829 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19834 print_stapsdt_note (Elf_Internal_Note
*pnote
)
19836 size_t len
, maxlen
;
19837 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
19838 char *data
= pnote
->descdata
;
19839 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
19840 bfd_vma pc
, base_addr
, semaphore
;
19841 char *provider
, *probe
, *arg_fmt
;
19843 if (pnote
->descsz
< (addr_size
* 3))
19844 goto stapdt_note_too_small
;
19846 pc
= byte_get ((unsigned char *) data
, addr_size
);
19849 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
19852 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
19855 if (data
>= data_end
)
19856 goto stapdt_note_too_small
;
19857 maxlen
= data_end
- data
;
19858 len
= strnlen (data
, maxlen
);
19865 goto stapdt_note_too_small
;
19867 if (data
>= data_end
)
19868 goto stapdt_note_too_small
;
19869 maxlen
= data_end
- data
;
19870 len
= strnlen (data
, maxlen
);
19877 goto stapdt_note_too_small
;
19879 if (data
>= data_end
)
19880 goto stapdt_note_too_small
;
19881 maxlen
= data_end
- data
;
19882 len
= strnlen (data
, maxlen
);
19889 goto stapdt_note_too_small
;
19891 printf (_(" Provider: %s\n"), provider
);
19892 printf (_(" Name: %s\n"), probe
);
19893 printf (_(" Location: "));
19894 print_vma (pc
, FULL_HEX
);
19895 printf (_(", Base: "));
19896 print_vma (base_addr
, FULL_HEX
);
19897 printf (_(", Semaphore: "));
19898 print_vma (semaphore
, FULL_HEX
);
19900 printf (_(" Arguments: %s\n"), arg_fmt
);
19902 return data
== data_end
;
19904 stapdt_note_too_small
:
19905 printf (_(" <corrupt - note is too small>\n"));
19906 error (_("corrupt stapdt note - the data size is too small\n"));
19910 static const char *
19911 get_ia64_vms_note_type (unsigned e_type
)
19913 static char buff
[64];
19918 return _("NT_VMS_MHD (module header)");
19920 return _("NT_VMS_LNM (language name)");
19922 return _("NT_VMS_SRC (source files)");
19924 return "NT_VMS_TITLE";
19926 return _("NT_VMS_EIDC (consistency check)");
19927 case NT_VMS_FPMODE
:
19928 return _("NT_VMS_FPMODE (FP mode)");
19929 case NT_VMS_LINKTIME
:
19930 return "NT_VMS_LINKTIME";
19931 case NT_VMS_IMGNAM
:
19932 return _("NT_VMS_IMGNAM (image name)");
19934 return _("NT_VMS_IMGID (image id)");
19935 case NT_VMS_LINKID
:
19936 return _("NT_VMS_LINKID (link id)");
19937 case NT_VMS_IMGBID
:
19938 return _("NT_VMS_IMGBID (build id)");
19939 case NT_VMS_GSTNAM
:
19940 return _("NT_VMS_GSTNAM (sym table name)");
19941 case NT_VMS_ORIG_DYN
:
19942 return "NT_VMS_ORIG_DYN";
19943 case NT_VMS_PATCHTIME
:
19944 return "NT_VMS_PATCHTIME";
19946 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19952 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
19954 int maxlen
= pnote
->descsz
;
19956 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
19957 goto desc_size_fail
;
19959 switch (pnote
->type
)
19963 goto desc_size_fail
;
19965 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
19967 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
19968 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
19969 if (l
+ 34 < maxlen
)
19971 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
19972 if (l
+ 35 < maxlen
)
19973 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
19975 printf (_(" Module version : <missing>\n"));
19979 printf (_(" Module name : <missing>\n"));
19980 printf (_(" Module version : <missing>\n"));
19985 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
19989 case NT_VMS_FPMODE
:
19990 printf (_(" Floating Point mode: "));
19992 goto desc_size_fail
;
19993 /* FIXME: Generate an error if descsz > 8 ? */
19995 printf ("0x%016" BFD_VMA_FMT
"x\n",
19996 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19999 case NT_VMS_LINKTIME
:
20000 printf (_(" Link time: "));
20002 goto desc_size_fail
;
20003 /* FIXME: Generate an error if descsz > 8 ? */
20006 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
20010 case NT_VMS_PATCHTIME
:
20011 printf (_(" Patch time: "));
20013 goto desc_size_fail
;
20014 /* FIXME: Generate an error if descsz > 8 ? */
20017 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
20021 case NT_VMS_ORIG_DYN
:
20023 goto desc_size_fail
;
20025 printf (_(" Major id: %u, minor id: %u\n"),
20026 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
20027 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
20028 printf (_(" Last modified : "));
20030 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
20031 printf (_("\n Link flags : "));
20032 printf ("0x%016" BFD_VMA_FMT
"x\n",
20033 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
20034 printf (_(" Header flags: 0x%08x\n"),
20035 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
20036 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
20040 case NT_VMS_IMGNAM
:
20041 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
20044 case NT_VMS_GSTNAM
:
20045 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
20049 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
20052 case NT_VMS_LINKID
:
20053 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
20063 printf (_(" <corrupt - data size is too small>\n"));
20064 error (_("corrupt IA64 note: data size is too small\n"));
20068 struct build_attr_cache
{
20069 Filedata
*filedata
;
20071 unsigned long strtablen
;
20072 Elf_Internal_Sym
*symtab
;
20073 unsigned long nsyms
;
20076 /* Find the symbol associated with a build attribute that is attached
20077 to address OFFSET. If PNAME is non-NULL then store the name of
20078 the symbol (if found) in the provided pointer, Returns NULL if a
20079 symbol could not be found. */
20081 static Elf_Internal_Sym
*
20082 get_symbol_for_build_attribute (Filedata
*filedata
,
20083 unsigned long offset
,
20085 const char **pname
)
20087 Elf_Internal_Sym
*saved_sym
= NULL
;
20088 Elf_Internal_Sym
*sym
;
20090 if (filedata
->section_headers
!= NULL
20091 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
20093 Elf_Internal_Shdr
* symsec
;
20095 free (ba_cache
.strtab
);
20096 ba_cache
.strtab
= NULL
;
20097 free (ba_cache
.symtab
);
20098 ba_cache
.symtab
= NULL
;
20100 /* Load the symbol and string sections. */
20101 for (symsec
= filedata
->section_headers
;
20102 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
20105 if (symsec
->sh_type
== SHT_SYMTAB
20106 && get_symtab (filedata
, symsec
,
20107 &ba_cache
.symtab
, &ba_cache
.nsyms
,
20108 &ba_cache
.strtab
, &ba_cache
.strtablen
))
20111 ba_cache
.filedata
= filedata
;
20114 if (ba_cache
.symtab
== NULL
)
20117 /* Find a symbol whose value matches offset. */
20118 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
20119 if (sym
->st_value
== offset
)
20121 if (sym
->st_name
>= ba_cache
.strtablen
)
20122 /* Huh ? This should not happen. */
20125 if (ba_cache
.strtab
[sym
->st_name
] == 0)
20128 /* The AArch64 and ARM architectures define mapping symbols
20129 (eg $d, $x, $t) which we want to ignore. */
20130 if (ba_cache
.strtab
[sym
->st_name
] == '$'
20131 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
20132 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
20137 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
20138 and FILE or OBJECT symbols over NOTYPE symbols. We skip
20139 FUNC symbols entirely. */
20140 switch (ELF_ST_TYPE (sym
->st_info
))
20147 /* If the symbol has a size associated
20148 with it then we can stop searching. */
20149 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
20154 /* Ignore function symbols. */
20161 switch (ELF_ST_BIND (sym
->st_info
))
20164 if (saved_sym
== NULL
20165 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
20170 if (saved_sym
== NULL
)
20180 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
20188 if (saved_sym
&& pname
)
20189 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
20194 /* Returns true iff addr1 and addr2 are in the same section. */
20197 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
20199 Elf_Internal_Shdr
* a1
;
20200 Elf_Internal_Shdr
* a2
;
20202 a1
= find_section_by_address (filedata
, addr1
);
20203 a2
= find_section_by_address (filedata
, addr2
);
20205 return a1
== a2
&& a1
!= NULL
;
20209 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
20210 Filedata
* filedata
)
20212 static unsigned long global_offset
= 0;
20213 static unsigned long global_end
= 0;
20214 static unsigned long func_offset
= 0;
20215 static unsigned long func_end
= 0;
20217 Elf_Internal_Sym
*sym
;
20219 unsigned long start
;
20221 bool is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
20223 switch (pnote
->descsz
)
20226 /* A zero-length description means that the range of
20227 the previous note of the same type should be used. */
20230 if (global_end
> global_offset
)
20231 printf (_(" Applies to region from %#lx to %#lx\n"),
20232 global_offset
, global_end
);
20234 printf (_(" Applies to region from %#lx\n"), global_offset
);
20238 if (func_end
> func_offset
)
20239 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
20241 printf (_(" Applies to region from %#lx\n"), func_offset
);
20246 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20251 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20252 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
20256 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
20257 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
20261 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
20262 printf (_(" <invalid descsz>"));
20267 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
20268 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
20269 in order to avoid them being confused with the start address of the
20270 first function in the file... */
20271 if (sym
== NULL
&& is_open_attr
)
20272 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
20275 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
20276 end
= start
+ sym
->st_size
;
20280 /* FIXME: Need to properly allow for section alignment.
20281 16 is just the alignment used on x86_64. */
20283 && start
> BFD_ALIGN (global_end
, 16)
20284 /* Build notes are not guaranteed to be organised in order of
20285 increasing address, but we should find the all of the notes
20286 for one section in the same place. */
20287 && same_section (filedata
, start
, global_end
))
20288 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
20289 global_end
+ 1, start
- 1);
20291 printf (_(" Applies to region from %#lx"), start
);
20292 global_offset
= start
;
20296 printf (_(" to %#lx"), end
);
20302 printf (_(" Applies to region from %#lx"), start
);
20303 func_offset
= start
;
20307 printf (_(" to %#lx"), end
);
20313 printf (_(" (%s)"), name
);
20320 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
20322 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
20323 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
20324 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
20326 char name_attribute
;
20327 const char * expected_types
;
20328 const char * name
= pnote
->namedata
;
20332 if (name
== NULL
|| pnote
->namesz
< 2)
20334 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
20335 print_symbol (-20, _(" <corrupt name>"));
20344 /* Version 2 of the spec adds a "GA" prefix to the name field. */
20345 if (name
[0] == 'G' && name
[1] == 'A')
20347 if (pnote
->namesz
< 4)
20349 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
20350 print_symbol (-20, _(" <corrupt name>"));
20359 switch ((name_type
= * name
))
20361 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
20362 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
20363 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
20364 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
20365 printf ("%c", * name
);
20369 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
20370 print_symbol (-20, _("<unknown name type>"));
20377 switch ((name_attribute
= * name
))
20379 case GNU_BUILD_ATTRIBUTE_VERSION
:
20380 text
= _("<version>");
20381 expected_types
= string_expected
;
20384 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
20385 text
= _("<stack prot>");
20386 expected_types
= "!+*";
20389 case GNU_BUILD_ATTRIBUTE_RELRO
:
20390 text
= _("<relro>");
20391 expected_types
= bool_expected
;
20394 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
20395 text
= _("<stack size>");
20396 expected_types
= number_expected
;
20399 case GNU_BUILD_ATTRIBUTE_TOOL
:
20400 text
= _("<tool>");
20401 expected_types
= string_expected
;
20404 case GNU_BUILD_ATTRIBUTE_ABI
:
20406 expected_types
= "$*";
20409 case GNU_BUILD_ATTRIBUTE_PIC
:
20411 expected_types
= number_expected
;
20414 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
20415 text
= _("<short enum>");
20416 expected_types
= bool_expected
;
20420 if (ISPRINT (* name
))
20422 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
20424 if (len
> left
&& ! do_wide
)
20426 printf ("%.*s:", len
, name
);
20432 static char tmpbuf
[128];
20434 error (_("unrecognised byte in name field: %d\n"), * name
);
20435 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
20439 expected_types
= "*$!+";
20444 left
-= printf ("%s", text
);
20446 if (strchr (expected_types
, name_type
) == NULL
)
20447 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
20449 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
20451 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
20452 (unsigned long) pnote
->namesz
,
20453 (long) (name
- pnote
->namedata
));
20457 if (left
< 1 && ! do_wide
)
20462 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
20464 unsigned int bytes
;
20465 unsigned long long val
= 0;
20466 unsigned int shift
= 0;
20467 char * decoded
= NULL
;
20469 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
20471 /* The -1 is because the name field is always 0 terminated, and we
20472 want to be able to ensure that the shift in the while loop below
20473 will not overflow. */
20476 if (bytes
> sizeof (val
))
20478 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
20480 bytes
= sizeof (val
);
20482 /* We do not bother to warn if bytes == 0 as this can
20483 happen with some early versions of the gcc plugin. */
20487 unsigned long long byte
= *name
++ & 0xff;
20489 val
|= byte
<< shift
;
20493 switch (name_attribute
)
20495 case GNU_BUILD_ATTRIBUTE_PIC
:
20498 case 0: decoded
= "static"; break;
20499 case 1: decoded
= "pic"; break;
20500 case 2: decoded
= "PIC"; break;
20501 case 3: decoded
= "pie"; break;
20502 case 4: decoded
= "PIE"; break;
20506 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
20509 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
20510 case 0: decoded
= "off"; break;
20511 case 1: decoded
= "on"; break;
20512 case 2: decoded
= "all"; break;
20513 case 3: decoded
= "strong"; break;
20514 case 4: decoded
= "explicit"; break;
20522 if (decoded
!= NULL
)
20524 print_symbol (-left
, decoded
);
20535 left
-= printf ("0x%llx", val
);
20537 left
-= printf ("0x%-.*llx", left
, val
);
20541 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
20542 left
-= print_symbol (- left
, name
);
20544 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
20545 left
-= print_symbol (- left
, "true");
20547 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
20548 left
-= print_symbol (- left
, "false");
20552 if (do_wide
&& left
> 0)
20553 printf ("%-*s", left
, " ");
20558 /* Note that by the ELF standard, the name field is already null byte
20559 terminated, and namesz includes the terminating null byte.
20560 I.E. the value of namesz for the name "FSF" is 4.
20562 If the value of namesz is zero, there is no name present. */
20565 process_note (Elf_Internal_Note
* pnote
,
20566 Filedata
* filedata
)
20568 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
20571 if (pnote
->namesz
== 0)
20572 /* If there is no note name, then use the default set of
20573 note type strings. */
20574 nt
= get_note_type (filedata
, pnote
->type
);
20576 else if (startswith (pnote
->namedata
, "GNU"))
20577 /* GNU-specific object file notes. */
20578 nt
= get_gnu_elf_note_type (pnote
->type
);
20580 else if (startswith (pnote
->namedata
, "FreeBSD"))
20581 /* FreeBSD-specific core file notes. */
20582 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
20584 else if (startswith (pnote
->namedata
, "NetBSD-CORE"))
20585 /* NetBSD-specific core file notes. */
20586 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
20588 else if (startswith (pnote
->namedata
, "NetBSD"))
20589 /* NetBSD-specific core file notes. */
20590 return process_netbsd_elf_note (pnote
);
20592 else if (startswith (pnote
->namedata
, "PaX"))
20593 /* NetBSD-specific core file notes. */
20594 return process_netbsd_elf_note (pnote
);
20596 else if (startswith (pnote
->namedata
, "SPU/"))
20598 /* SPU-specific core file notes. */
20599 nt
= pnote
->namedata
+ 4;
20603 else if (startswith (pnote
->namedata
, "IPF/VMS"))
20604 /* VMS/ia64-specific file notes. */
20605 nt
= get_ia64_vms_note_type (pnote
->type
);
20607 else if (startswith (pnote
->namedata
, "stapsdt"))
20608 nt
= get_stapsdt_note_type (pnote
->type
);
20611 /* Don't recognize this note name; just use the default set of
20612 note type strings. */
20613 nt
= get_note_type (filedata
, pnote
->type
);
20617 if (((startswith (pnote
->namedata
, "GA")
20618 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
20619 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
20620 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
20621 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
20622 print_gnu_build_attribute_name (pnote
);
20624 print_symbol (-20, name
);
20627 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
20629 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
20631 if (startswith (pnote
->namedata
, "IPF/VMS"))
20632 return print_ia64_vms_note (pnote
);
20633 else if (startswith (pnote
->namedata
, "GNU"))
20634 return print_gnu_note (filedata
, pnote
);
20635 else if (startswith (pnote
->namedata
, "stapsdt"))
20636 return print_stapsdt_note (pnote
);
20637 else if (startswith (pnote
->namedata
, "CORE"))
20638 return print_core_note (pnote
);
20639 else if (((startswith (pnote
->namedata
, "GA")
20640 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
20641 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
20642 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
20643 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
20644 return print_gnu_build_attribute_description (pnote
, filedata
);
20650 printf (_(" description data: "));
20651 for (i
= 0; i
< pnote
->descsz
; i
++)
20652 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
20664 process_notes_at (Filedata
* filedata
,
20665 Elf_Internal_Shdr
* section
,
20670 Elf_External_Note
*pnotes
;
20671 Elf_External_Note
*external
;
20680 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
20683 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
20691 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
20694 if (pnotes
== NULL
)
20699 if (filedata
->is_separate
)
20700 printf (_("In linked file '%s': "), filedata
->file_name
);
20704 printf (_("Displaying notes found in: %s\n"), printable_section_name (filedata
, section
));
20706 printf (_("Displaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
20707 (unsigned long) offset
, (unsigned long) length
);
20709 /* NB: Some note sections may have alignment value of 0 or 1. gABI
20710 specifies that notes should be aligned to 4 bytes in 32-bit
20711 objects and to 8 bytes in 64-bit objects. As a Linux extension,
20712 we also support 4 byte alignment in 64-bit objects. If section
20713 alignment is less than 4, we treate alignment as 4 bytes. */
20716 else if (align
!= 4 && align
!= 8)
20718 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
20724 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
20726 end
= (char *) pnotes
+ length
;
20727 while ((char *) external
< end
)
20729 Elf_Internal_Note inote
;
20732 char * temp
= NULL
;
20733 size_t data_remaining
= end
- (char *) external
;
20735 if (!is_ia64_vms (filedata
))
20737 /* PR binutils/15191
20738 Make sure that there is enough data to read. */
20739 min_notesz
= offsetof (Elf_External_Note
, name
);
20740 if (data_remaining
< min_notesz
)
20742 warn (ngettext ("Corrupt note: only %ld byte remains, "
20743 "not enough for a full note\n",
20744 "Corrupt note: only %ld bytes remain, "
20745 "not enough for a full note\n",
20747 (long) data_remaining
);
20750 data_remaining
-= min_notesz
;
20752 inote
.type
= BYTE_GET (external
->type
);
20753 inote
.namesz
= BYTE_GET (external
->namesz
);
20754 inote
.namedata
= external
->name
;
20755 inote
.descsz
= BYTE_GET (external
->descsz
);
20756 inote
.descdata
= ((char *) external
20757 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
20758 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20759 next
= ((char *) external
20760 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
20764 Elf64_External_VMS_Note
*vms_external
;
20766 /* PR binutils/15191
20767 Make sure that there is enough data to read. */
20768 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
20769 if (data_remaining
< min_notesz
)
20771 warn (ngettext ("Corrupt note: only %ld byte remains, "
20772 "not enough for a full note\n",
20773 "Corrupt note: only %ld bytes remain, "
20774 "not enough for a full note\n",
20776 (long) data_remaining
);
20779 data_remaining
-= min_notesz
;
20781 vms_external
= (Elf64_External_VMS_Note
*) external
;
20782 inote
.type
= BYTE_GET (vms_external
->type
);
20783 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
20784 inote
.namedata
= vms_external
->name
;
20785 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
20786 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
20787 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20788 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
20791 /* PR 17531: file: 3443835e. */
20792 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
20793 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
20794 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
20795 || (size_t) (next
- inote
.descdata
) < inote
.descsz
20796 || ((size_t) (next
- inote
.descdata
)
20797 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
20799 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
20800 (unsigned long) ((char *) external
- (char *) pnotes
));
20801 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
20802 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
20806 external
= (Elf_External_Note
*) next
;
20808 /* Verify that name is null terminated. It appears that at least
20809 one version of Linux (RedHat 6.0) generates corefiles that don't
20810 comply with the ELF spec by failing to include the null byte in
20812 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
20814 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
20816 temp
= (char *) malloc (inote
.namesz
+ 1);
20819 error (_("Out of memory allocating space for inote name\n"));
20824 memcpy (temp
, inote
.namedata
, inote
.namesz
);
20825 inote
.namedata
= temp
;
20827 inote
.namedata
[inote
.namesz
] = 0;
20830 if (! process_note (& inote
, filedata
))
20843 process_corefile_note_segments (Filedata
* filedata
)
20845 Elf_Internal_Phdr
*segment
;
20849 if (! get_program_headers (filedata
))
20852 for (i
= 0, segment
= filedata
->program_headers
;
20853 i
< filedata
->file_header
.e_phnum
;
20856 if (segment
->p_type
== PT_NOTE
)
20857 if (! process_notes_at (filedata
, NULL
,
20858 (bfd_vma
) segment
->p_offset
,
20859 (bfd_vma
) segment
->p_filesz
,
20860 (bfd_vma
) segment
->p_align
))
20868 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
20870 Elf_External_Note
* pnotes
;
20871 Elf_External_Note
* external
;
20878 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
20880 if (pnotes
== NULL
)
20884 end
= (char*) pnotes
+ length
;
20886 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
20887 (unsigned long) offset
, (unsigned long) length
);
20889 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
20891 Elf_External_Note
* next
;
20892 Elf_Internal_Note inote
;
20894 inote
.type
= BYTE_GET (external
->type
);
20895 inote
.namesz
= BYTE_GET (external
->namesz
);
20896 inote
.namedata
= external
->name
;
20897 inote
.descsz
= BYTE_GET (external
->descsz
);
20898 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
20899 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20901 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
20903 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
20904 inote
.descdata
= inote
.namedata
;
20908 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
20910 if ( ((char *) next
> end
)
20911 || ((char *) next
< (char *) pnotes
))
20913 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
20914 (unsigned long) ((char *) external
- (char *) pnotes
));
20915 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
20916 inote
.type
, inote
.namesz
, inote
.descsz
);
20922 /* Prevent out-of-bounds indexing. */
20923 if ( inote
.namedata
+ inote
.namesz
> end
20924 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
20926 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
20927 (unsigned long) ((char *) external
- (char *) pnotes
));
20928 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
20929 inote
.type
, inote
.namesz
, inote
.descsz
);
20933 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
20935 if (! print_v850_note (& inote
))
20938 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
20939 inote
.namesz
, inote
.descsz
);
20949 process_note_sections (Filedata
* filedata
)
20951 Elf_Internal_Shdr
*section
;
20953 unsigned int n
= 0;
20956 for (i
= 0, section
= filedata
->section_headers
;
20957 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
20960 if (section
->sh_type
== SHT_NOTE
)
20962 if (! process_notes_at (filedata
, section
,
20963 (bfd_vma
) section
->sh_offset
,
20964 (bfd_vma
) section
->sh_size
,
20965 (bfd_vma
) section
->sh_addralign
))
20970 if (( filedata
->file_header
.e_machine
== EM_V800
20971 || filedata
->file_header
.e_machine
== EM_V850
20972 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
20973 && section
->sh_type
== SHT_RENESAS_INFO
)
20975 if (! process_v850_notes (filedata
,
20976 (bfd_vma
) section
->sh_offset
,
20977 (bfd_vma
) section
->sh_size
))
20984 /* Try processing NOTE segments instead. */
20985 return process_corefile_note_segments (filedata
);
20991 process_notes (Filedata
* filedata
)
20993 /* If we have not been asked to display the notes then do nothing. */
20997 if (filedata
->file_header
.e_type
!= ET_CORE
)
20998 return process_note_sections (filedata
);
21000 /* No program headers means no NOTE segment. */
21001 if (filedata
->file_header
.e_phnum
> 0)
21002 return process_corefile_note_segments (filedata
);
21004 if (filedata
->is_separate
)
21005 printf (_("No notes found in linked file '%s'.\n"),
21006 filedata
->file_name
);
21008 printf (_("No notes found file.\n"));
21013 static unsigned char *
21014 display_public_gnu_attributes (unsigned char * start
,
21015 const unsigned char * const end
)
21017 printf (_(" Unknown GNU attribute: %s\n"), start
);
21019 start
+= strnlen ((char *) start
, end
- start
);
21020 display_raw_attribute (start
, end
);
21022 return (unsigned char *) end
;
21025 static unsigned char *
21026 display_generic_attribute (unsigned char * start
,
21028 const unsigned char * const end
)
21031 return (unsigned char *) end
;
21033 return display_tag_value (tag
, start
, end
);
21037 process_arch_specific (Filedata
* filedata
)
21042 switch (filedata
->file_header
.e_machine
)
21045 case EM_ARC_COMPACT
:
21046 case EM_ARC_COMPACT2
:
21047 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
21048 display_arc_attribute
,
21049 display_generic_attribute
);
21051 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
21052 display_arm_attribute
,
21053 display_generic_attribute
);
21056 case EM_MIPS_RS3_LE
:
21057 return process_mips_specific (filedata
);
21060 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
21061 display_msp430_attribute
,
21062 display_msp430_gnu_attribute
);
21065 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
21066 display_riscv_attribute
,
21067 display_generic_attribute
);
21070 return process_nds32_specific (filedata
);
21073 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21074 display_m68k_gnu_attribute
);
21078 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21079 display_power_gnu_attribute
);
21083 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21084 display_s390_gnu_attribute
);
21087 case EM_SPARC32PLUS
:
21089 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21090 display_sparc_gnu_attribute
);
21093 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
21094 display_tic6x_attribute
,
21095 display_generic_attribute
);
21098 return process_attributes (filedata
, "csky", SHT_CSKY_ATTRIBUTES
,
21099 display_csky_attribute
, NULL
);
21102 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
21103 display_public_gnu_attributes
,
21104 display_generic_attribute
);
21109 get_file_header (Filedata
* filedata
)
21111 /* Read in the identity array. */
21112 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
21115 /* Determine how to read the rest of the header. */
21116 switch (filedata
->file_header
.e_ident
[EI_DATA
])
21121 byte_get
= byte_get_little_endian
;
21122 byte_put
= byte_put_little_endian
;
21125 byte_get
= byte_get_big_endian
;
21126 byte_put
= byte_put_big_endian
;
21130 /* For now we only support 32 bit and 64 bit ELF files. */
21131 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
21133 /* Read in the rest of the header. */
21136 Elf32_External_Ehdr ehdr32
;
21138 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
21141 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
21142 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
21143 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
21144 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
21145 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
21146 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
21147 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
21148 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
21149 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
21150 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
21151 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
21152 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
21153 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
21157 Elf64_External_Ehdr ehdr64
;
21159 /* If we have been compiled with sizeof (bfd_vma) == 4, then
21160 we will not be able to cope with the 64bit data found in
21161 64 ELF files. Detect this now and abort before we start
21162 overwriting things. */
21163 if (sizeof (bfd_vma
) < 8)
21165 error (_("This instance of readelf has been built without support for a\n\
21166 64 bit data type and so it cannot read 64 bit ELF files.\n"));
21170 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
21173 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
21174 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
21175 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
21176 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
21177 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
21178 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
21179 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
21180 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
21181 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
21182 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
21183 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
21184 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
21185 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
21188 if (filedata
->file_header
.e_shoff
)
21190 /* There may be some extensions in the first section header. Don't
21191 bomb if we can't read it. */
21193 get_32bit_section_headers (filedata
, true);
21195 get_64bit_section_headers (filedata
, true);
21202 free_filedata (Filedata
*filedata
)
21204 free (filedata
->program_interpreter
);
21205 filedata
->program_interpreter
= NULL
;
21207 free (filedata
->program_headers
);
21208 filedata
->program_headers
= NULL
;
21210 free (filedata
->section_headers
);
21211 filedata
->section_headers
= NULL
;
21213 free (filedata
->string_table
);
21214 filedata
->string_table
= NULL
;
21215 filedata
->string_table_length
= 0;
21217 free (filedata
->dump
.dump_sects
);
21218 filedata
->dump
.dump_sects
= NULL
;
21219 filedata
->dump
.num_dump_sects
= 0;
21221 free (filedata
->dynamic_strings
);
21222 filedata
->dynamic_strings
= NULL
;
21223 filedata
->dynamic_strings_length
= 0;
21225 free (filedata
->dynamic_symbols
);
21226 filedata
->dynamic_symbols
= NULL
;
21227 filedata
->num_dynamic_syms
= 0;
21229 free (filedata
->dynamic_syminfo
);
21230 filedata
->dynamic_syminfo
= NULL
;
21232 free (filedata
->dynamic_section
);
21233 filedata
->dynamic_section
= NULL
;
21235 while (filedata
->symtab_shndx_list
!= NULL
)
21237 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
21238 free (filedata
->symtab_shndx_list
);
21239 filedata
->symtab_shndx_list
= next
;
21242 free (filedata
->section_headers_groups
);
21243 filedata
->section_headers_groups
= NULL
;
21245 if (filedata
->section_groups
)
21248 struct group_list
* g
;
21249 struct group_list
* next
;
21251 for (i
= 0; i
< filedata
->group_count
; i
++)
21253 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
21260 free (filedata
->section_groups
);
21261 filedata
->section_groups
= NULL
;
21266 close_file (Filedata
* filedata
)
21270 if (filedata
->handle
)
21271 fclose (filedata
->handle
);
21277 close_debug_file (void * data
)
21279 free_filedata ((Filedata
*) data
);
21280 close_file ((Filedata
*) data
);
21284 open_file (const char * pathname
, bool is_separate
)
21286 struct stat statbuf
;
21287 Filedata
* filedata
= NULL
;
21289 if (stat (pathname
, & statbuf
) < 0
21290 || ! S_ISREG (statbuf
.st_mode
))
21293 filedata
= calloc (1, sizeof * filedata
);
21294 if (filedata
== NULL
)
21297 filedata
->handle
= fopen (pathname
, "rb");
21298 if (filedata
->handle
== NULL
)
21301 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
21302 filedata
->file_name
= pathname
;
21303 filedata
->is_separate
= is_separate
;
21305 if (! get_file_header (filedata
))
21308 if (filedata
->file_header
.e_shoff
)
21312 /* Read the section headers again, this time for real. */
21314 res
= get_32bit_section_headers (filedata
, false);
21316 res
= get_64bit_section_headers (filedata
, false);
21327 if (filedata
->handle
)
21328 fclose (filedata
->handle
);
21335 open_debug_file (const char * pathname
)
21337 return open_file (pathname
, true);
21341 initialise_dump_sects (Filedata
* filedata
)
21343 /* Initialise the dump_sects array from the cmdline_dump_sects array.
21344 Note we do this even if cmdline_dump_sects is empty because we
21345 must make sure that the dump_sets array is zeroed out before each
21346 object file is processed. */
21347 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
21348 memset (filedata
->dump
.dump_sects
, 0,
21349 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
21351 if (cmdline
.num_dump_sects
> 0)
21353 if (filedata
->dump
.num_dump_sects
== 0)
21354 /* A sneaky way of allocating the dump_sects array. */
21355 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
21357 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
21358 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
21359 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
21363 /* Process one ELF object file according to the command line options.
21364 This file may actually be stored in an archive. The file is
21365 positioned at the start of the ELF object. Returns TRUE if no
21366 problems were encountered, FALSE otherwise. */
21369 process_object (Filedata
* filedata
)
21371 bool have_separate_files
;
21375 if (! get_file_header (filedata
))
21377 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
21381 /* Initialise per file variables. */
21382 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
21383 filedata
->version_info
[i
] = 0;
21385 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
21386 filedata
->dynamic_info
[i
] = 0;
21387 filedata
->dynamic_info_DT_GNU_HASH
= 0;
21388 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
21390 /* Process the file. */
21392 printf (_("\nFile: %s\n"), filedata
->file_name
);
21394 initialise_dump_sects (filedata
);
21396 if (! process_file_header (filedata
))
21399 if (! process_section_headers (filedata
))
21401 /* Without loaded section headers we cannot process lots of things. */
21402 do_unwind
= do_version
= do_dump
= do_arch
= false;
21404 if (! do_using_dynamic
)
21405 do_syms
= do_dyn_syms
= do_reloc
= false;
21408 if (! process_section_groups (filedata
))
21409 /* Without loaded section groups we cannot process unwind. */
21412 res
= process_program_headers (filedata
);
21414 res
= process_dynamic_section (filedata
);
21416 if (! process_relocs (filedata
))
21419 if (! process_unwind (filedata
))
21422 if (! process_symbol_table (filedata
))
21425 if (! process_lto_symbol_tables (filedata
))
21428 if (! process_syminfo (filedata
))
21431 if (! process_version_sections (filedata
))
21434 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
21435 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
21437 have_separate_files
= false;
21439 if (! process_section_contents (filedata
))
21442 if (have_separate_files
)
21446 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
21448 initialise_dump_sects (d
->handle
);
21450 if (process_links
&& ! process_file_header (d
->handle
))
21452 else if (! process_section_headers (d
->handle
))
21454 else if (! process_section_contents (d
->handle
))
21456 else if (process_links
)
21458 if (! process_section_groups (d
->handle
))
21460 if (! process_program_headers (d
->handle
))
21462 if (! process_dynamic_section (d
->handle
))
21464 if (! process_relocs (d
->handle
))
21466 if (! process_unwind (d
->handle
))
21468 if (! process_symbol_table (d
->handle
))
21470 if (! process_lto_symbol_tables (d
->handle
))
21472 if (! process_syminfo (d
->handle
))
21474 if (! process_version_sections (d
->handle
))
21476 if (! process_notes (d
->handle
))
21481 /* The file handles are closed by the call to free_debug_memory() below. */
21484 if (! process_notes (filedata
))
21487 if (! process_gnu_liblist (filedata
))
21490 if (! process_arch_specific (filedata
))
21493 free_filedata (filedata
);
21495 free_debug_memory ();
21500 /* Process an ELF archive.
21501 On entry the file is positioned just after the ARMAG string.
21502 Returns TRUE upon success, FALSE otherwise. */
21505 process_archive (Filedata
* filedata
, bool is_thin_archive
)
21507 struct archive_info arch
;
21508 struct archive_info nested_arch
;
21514 /* The ARCH structure is used to hold information about this archive. */
21515 arch
.file_name
= NULL
;
21517 arch
.index_array
= NULL
;
21518 arch
.sym_table
= NULL
;
21519 arch
.longnames
= NULL
;
21521 /* The NESTED_ARCH structure is used as a single-item cache of information
21522 about a nested archive (when members of a thin archive reside within
21523 another regular archive file). */
21524 nested_arch
.file_name
= NULL
;
21525 nested_arch
.file
= NULL
;
21526 nested_arch
.index_array
= NULL
;
21527 nested_arch
.sym_table
= NULL
;
21528 nested_arch
.longnames
= NULL
;
21530 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
21531 filedata
->file_size
, is_thin_archive
,
21532 do_archive_index
) != 0)
21538 if (do_archive_index
)
21540 if (arch
.sym_table
== NULL
)
21541 error (_("%s: unable to dump the index as none was found\n"),
21542 filedata
->file_name
);
21545 unsigned long i
, l
;
21546 unsigned long current_pos
;
21548 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
21549 "in the symbol table)\n"),
21550 filedata
->file_name
, (unsigned long) arch
.index_num
,
21553 current_pos
= ftell (filedata
->handle
);
21555 for (i
= l
= 0; i
< arch
.index_num
; i
++)
21558 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
21561 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
21564 if (member_name
!= NULL
)
21566 char * qualified_name
21567 = make_qualified_name (&arch
, &nested_arch
,
21570 if (qualified_name
!= NULL
)
21572 printf (_("Contents of binary %s at offset "),
21574 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
21576 free (qualified_name
);
21578 free (member_name
);
21582 if (l
>= arch
.sym_size
)
21584 error (_("%s: end of the symbol table reached "
21585 "before the end of the index\n"),
21586 filedata
->file_name
);
21590 /* PR 17531: file: 0b6630b2. */
21591 printf ("\t%.*s\n",
21592 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
21593 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
21596 if (arch
.uses_64bit_indices
)
21601 if (l
< arch
.sym_size
)
21603 error (ngettext ("%s: %ld byte remains in the symbol table, "
21604 "but without corresponding entries in "
21605 "the index table\n",
21606 "%s: %ld bytes remain in the symbol table, "
21607 "but without corresponding entries in "
21608 "the index table\n",
21609 arch
.sym_size
- l
),
21610 filedata
->file_name
, arch
.sym_size
- l
);
21614 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
21616 error (_("%s: failed to seek back to start of object files "
21617 "in the archive\n"),
21618 filedata
->file_name
);
21624 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
21625 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
21626 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
21627 && !do_section_groups
&& !do_dyn_syms
)
21629 ret
= true; /* Archive index only. */
21638 char * qualified_name
;
21640 /* Read the next archive header. */
21641 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
21643 error (_("%s: failed to seek to next archive header\n"),
21648 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
21649 if (got
!= sizeof arch
.arhdr
)
21653 /* PR 24049 - we cannot use filedata->file_name as this will
21654 have already been freed. */
21655 error (_("%s: failed to read archive header\n"), arch
.file_name
);
21660 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
21662 error (_("%s: did not find a valid archive header\n"),
21668 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
21670 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
21671 if (filedata
->archive_file_size
& 01)
21672 ++filedata
->archive_file_size
;
21674 name
= get_archive_member_name (&arch
, &nested_arch
);
21677 error (_("%s: bad archive file name\n"), arch
.file_name
);
21681 namelen
= strlen (name
);
21683 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
21684 if (qualified_name
== NULL
)
21686 error (_("%s: bad archive file name\n"), arch
.file_name
);
21692 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
21694 /* This is a proxy for an external member of a thin archive. */
21695 Filedata
* member_filedata
;
21696 char * member_file_name
= adjust_relative_path
21697 (filedata
->file_name
, name
, namelen
);
21700 if (member_file_name
== NULL
)
21702 free (qualified_name
);
21707 member_filedata
= open_file (member_file_name
, false);
21708 if (member_filedata
== NULL
)
21710 error (_("Input file '%s' is not readable.\n"), member_file_name
);
21711 free (member_file_name
);
21712 free (qualified_name
);
21717 filedata
->archive_file_offset
= arch
.nested_member_origin
;
21718 member_filedata
->file_name
= qualified_name
;
21720 if (! process_object (member_filedata
))
21723 close_file (member_filedata
);
21724 free (member_file_name
);
21726 else if (is_thin_archive
)
21728 Filedata thin_filedata
;
21730 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
21732 /* PR 15140: Allow for corrupt thin archives. */
21733 if (nested_arch
.file
== NULL
)
21735 error (_("%s: contains corrupt thin archive: %s\n"),
21736 qualified_name
, name
);
21737 free (qualified_name
);
21744 /* This is a proxy for a member of a nested archive. */
21745 filedata
->archive_file_offset
21746 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
21748 /* The nested archive file will have been opened and setup by
21749 get_archive_member_name. */
21750 if (fseek (nested_arch
.file
, filedata
->archive_file_offset
,
21753 error (_("%s: failed to seek to archive member.\n"),
21754 nested_arch
.file_name
);
21755 free (qualified_name
);
21760 thin_filedata
.handle
= nested_arch
.file
;
21761 thin_filedata
.file_name
= qualified_name
;
21763 if (! process_object (& thin_filedata
))
21769 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
21770 filedata
->file_name
= qualified_name
;
21771 if (! process_object (filedata
))
21773 arch
.next_arhdr_offset
+= filedata
->archive_file_size
;
21774 /* Stop looping with "negative" archive_file_size. */
21775 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
21776 arch
.next_arhdr_offset
= -1ul;
21779 free (qualified_name
);
21783 if (nested_arch
.file
!= NULL
)
21784 fclose (nested_arch
.file
);
21785 release_archive (&nested_arch
);
21786 release_archive (&arch
);
21792 process_file (char * file_name
)
21794 Filedata
* filedata
= NULL
;
21795 struct stat statbuf
;
21796 char armag
[SARMAG
];
21799 if (stat (file_name
, &statbuf
) < 0)
21801 if (errno
== ENOENT
)
21802 error (_("'%s': No such file\n"), file_name
);
21804 error (_("Could not locate '%s'. System error message: %s\n"),
21805 file_name
, strerror (errno
));
21809 if (! S_ISREG (statbuf
.st_mode
))
21811 error (_("'%s' is not an ordinary file\n"), file_name
);
21815 filedata
= calloc (1, sizeof * filedata
);
21816 if (filedata
== NULL
)
21818 error (_("Out of memory allocating file data structure\n"));
21822 filedata
->file_name
= file_name
;
21823 filedata
->handle
= fopen (file_name
, "rb");
21824 if (filedata
->handle
== NULL
)
21826 error (_("Input file '%s' is not readable.\n"), file_name
);
21831 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
21833 error (_("%s: Failed to read file's magic number\n"), file_name
);
21834 fclose (filedata
->handle
);
21839 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
21840 filedata
->is_separate
= false;
21842 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
21844 if (! process_archive (filedata
, false))
21847 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
21849 if ( ! process_archive (filedata
, true))
21854 if (do_archive_index
&& !check_all
)
21855 error (_("File %s is not an archive so its index cannot be displayed.\n"),
21858 rewind (filedata
->handle
);
21859 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
21861 if (! process_object (filedata
))
21865 fclose (filedata
->handle
);
21866 free (filedata
->section_headers
);
21867 free (filedata
->program_headers
);
21868 free (filedata
->string_table
);
21869 free (filedata
->dump
.dump_sects
);
21872 free (ba_cache
.strtab
);
21873 ba_cache
.strtab
= NULL
;
21874 free (ba_cache
.symtab
);
21875 ba_cache
.symtab
= NULL
;
21876 ba_cache
.filedata
= NULL
;
21881 #ifdef SUPPORT_DISASSEMBLY
21882 /* Needed by the i386 disassembler. For extra credit, someone could
21883 fix this so that we insert symbolic addresses here, esp for GOT/PLT
21887 print_address (unsigned int addr
, FILE * outfile
)
21889 fprintf (outfile
,"0x%8.8x", addr
);
21892 /* Needed by the i386 disassembler. */
21895 db_task_printsym (unsigned int addr
)
21897 print_address (addr
, stderr
);
21902 main (int argc
, char ** argv
)
21906 #ifdef HAVE_LC_MESSAGES
21907 setlocale (LC_MESSAGES
, "");
21909 setlocale (LC_CTYPE
, "");
21910 bindtextdomain (PACKAGE
, LOCALEDIR
);
21911 textdomain (PACKAGE
);
21913 expandargv (&argc
, &argv
);
21915 parse_args (& cmdline
, argc
, argv
);
21917 if (optind
< (argc
- 1))
21918 /* When displaying information for more than one file,
21919 prefix the information with the file name. */
21921 else if (optind
>= argc
)
21923 /* Ensure that the warning is always displayed. */
21926 warn (_("Nothing to do.\n"));
21931 while (optind
< argc
)
21932 if (! process_file (argv
[optind
++]))
21935 free (cmdline
.dump_sects
);
21937 free (dump_ctf_symtab_name
);
21938 free (dump_ctf_strtab_name
);
21939 free (dump_ctf_parent_name
);
21941 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;