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 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4618 -h --file-header Display the ELF file header\n\
4619 -l --program-headers Display the program headers\n\
4620 --segments An alias for --program-headers\n\
4621 -S --section-headers Display the sections' header\n\
4622 --sections An alias for --section-headers\n\
4623 -g --section-groups Display the section groups\n\
4624 -t --section-details Display the section details\n\
4625 -e --headers Equivalent to: -h -l -S\n\
4626 -s --syms Display the symbol table\n\
4627 --symbols An alias for --syms\n\
4628 --dyn-syms Display the dynamic symbol table\n\
4629 --lto-syms Display LTO symbol tables\n\
4630 --sym-base=[0|8|10|16] \n\
4631 Force base for symbol sizes. The options are \n\
4632 mixed (the default), octal, decimal, hexadecimal.\n\
4633 -C --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
4634 The STYLE, if specified, can be `auto' (the default),\n\
4635 `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
4637 --no-demangle Do not demangle low-level symbol names. (This is the default)\n\
4638 --recurse-limit Enable a demangling recursion limit. (This is the default)\n\
4639 --no-recurse-limit Disable a demangling recursion limit\n\
4640 -n --notes Display the core notes (if present)\n\
4641 -r --relocs Display the relocations (if present)\n\
4642 -u --unwind Display the unwind info (if present)\n\
4643 -d --dynamic Display the dynamic section (if present)\n\
4644 -V --version-info Display the version sections (if present)\n\
4645 -A --arch-specific Display architecture specific information (if any)\n\
4646 -c --archive-index Display the symbol/file index in an archive\n\
4647 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4648 -L --lint|--enable-checks Display warning messages for possible problems\n\
4649 -x --hex-dump=<number|name>\n\
4650 Dump the contents of section <number|name> as bytes\n\
4651 -p --string-dump=<number|name>\n\
4652 Dump the contents of section <number|name> as strings\n\
4653 -R --relocated-dump=<number|name>\n\
4654 Dump the contents of section <number|name> as relocated bytes\n\
4655 -z --decompress Decompress section before dumping it\n\
4656 -w[lLiaprmfFsoORtUuTgAc] or\n\
4657 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4658 =frames-interp,=str,=str-offsets,=loc,=Ranges,=pubtypes,\n\
4659 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4661 Display the contents of DWARF debug sections\n\
4662 -wk,--debug-dump=links Display the contents of sections that link to separate debuginfo files\n\
4663 -P,--process-links Display the contents of non-debug sections in separate debuginfo files. (Implies -wK)\n"));
4664 #if DEFAULT_FOR_FOLLOW_LINKS
4665 fprintf (stream
, _("\
4666 -wK,--debug-dump=follow-links Follow links to separate debug info files (default)\n\
4667 -wN,--debug-dump=no-follow-links Do not follow links to separate debug info files\n\
4670 fprintf (stream
, _("\
4671 -wK,--debug-dump=follow-links Follow links to separate debug info files\n\
4672 -wN,--debug-dump=no-follow-links Do not follow links to separate debug info files (default)\n\
4675 fprintf (stream
, _("\
4676 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4677 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4679 #ifdef ENABLE_LIBCTF
4680 fprintf (stream
, _("\
4681 --ctf=<number|name> Display CTF info from section <number|name>\n\
4682 --ctf-parent=<number|name>\n\
4683 Use section <number|name> as the CTF parent\n\n\
4684 --ctf-symbols=<number|name>\n\
4685 Use section <number|name> as the CTF external symtab\n\n\
4686 --ctf-strings=<number|name>\n\
4687 Use section <number|name> as the CTF external strtab\n\n"));
4690 #ifdef SUPPORT_DISASSEMBLY
4691 fprintf (stream
, _("\
4692 -i --instruction-dump=<number|name>\n\
4693 Disassemble the contents of section <number|name>\n"));
4695 fprintf (stream
, _("\
4696 -I --histogram Display histogram of bucket list lengths\n\
4697 -W --wide Allow output width to exceed 80 characters\n\
4698 -T --silent-truncation If a symbol name is truncated, do not add a suffix [...]\n\
4699 @<file> Read options from <file>\n\
4700 -H --help Display this information\n\
4701 -v --version Display the version number of readelf\n"));
4703 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4704 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4706 exit (stream
== stdout
? 0 : 1);
4709 /* Record the fact that the user wants the contents of section number
4710 SECTION to be displayed using the method(s) encoded as flags bits
4711 in TYPE. Note, TYPE can be zero if we are creating the array for
4715 request_dump_bynumber (struct dump_data
*dumpdata
,
4716 unsigned int section
, dump_type type
)
4718 if (section
>= dumpdata
->num_dump_sects
)
4720 dump_type
* new_dump_sects
;
4722 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4723 sizeof (* new_dump_sects
));
4725 if (new_dump_sects
== NULL
)
4726 error (_("Out of memory allocating dump request table.\n"));
4729 if (dumpdata
->dump_sects
)
4731 /* Copy current flag settings. */
4732 memcpy (new_dump_sects
, dumpdata
->dump_sects
,
4733 dumpdata
->num_dump_sects
* sizeof (* new_dump_sects
));
4735 free (dumpdata
->dump_sects
);
4738 dumpdata
->dump_sects
= new_dump_sects
;
4739 dumpdata
->num_dump_sects
= section
+ 1;
4743 if (dumpdata
->dump_sects
)
4744 dumpdata
->dump_sects
[section
] |= type
;
4747 /* Request a dump by section name. */
4750 request_dump_byname (const char * section
, dump_type type
)
4752 struct dump_list_entry
* new_request
;
4754 new_request
= (struct dump_list_entry
*)
4755 malloc (sizeof (struct dump_list_entry
));
4757 error (_("Out of memory allocating dump request table.\n"));
4759 new_request
->name
= strdup (section
);
4760 if (!new_request
->name
)
4761 error (_("Out of memory allocating dump request table.\n"));
4763 new_request
->type
= type
;
4765 new_request
->next
= dump_sects_byname
;
4766 dump_sects_byname
= new_request
;
4770 request_dump (struct dump_data
*dumpdata
, dump_type type
)
4776 section
= strtoul (optarg
, & cp
, 0);
4778 if (! *cp
&& section
>= 0)
4779 request_dump_bynumber (dumpdata
, section
, type
);
4781 request_dump_byname (optarg
, type
);
4785 parse_args (struct dump_data
*dumpdata
, int argc
, char ** argv
)
4792 while ((c
= getopt_long
4793 (argc
, argv
, "ACDHILNPR:STVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4811 do_section_groups
= true;
4814 do_histogram
= true;
4820 do_section_groups
= true;
4825 do_section_details
= true;
4836 do_using_dynamic
= true;
4860 do_histogram
= true;
4866 do_archive_index
= true;
4872 process_links
= true;
4873 do_follow_links
= true;
4876 request_dump (dumpdata
, HEX_DUMP
);
4879 request_dump (dumpdata
, STRING_DUMP
);
4882 request_dump (dumpdata
, RELOC_DUMP
);
4885 decompress_dumps
= true;
4891 do_debugging
= true;
4892 dwarf_select_sections_all ();
4896 do_debugging
= false;
4897 dwarf_select_sections_by_letters (optarg
);
4900 case OPTION_DEBUG_DUMP
:
4903 do_debugging
= true;
4906 do_debugging
= false;
4907 dwarf_select_sections_by_names (optarg
);
4910 case OPTION_DWARF_DEPTH
:
4914 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4917 case OPTION_DWARF_START
:
4921 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4924 case OPTION_DWARF_CHECK
:
4927 case OPTION_CTF_DUMP
:
4929 request_dump (dumpdata
, CTF_DUMP
);
4931 case OPTION_CTF_SYMBOLS
:
4932 free (dump_ctf_symtab_name
);
4933 dump_ctf_symtab_name
= strdup (optarg
);
4935 case OPTION_CTF_STRINGS
:
4936 free (dump_ctf_strtab_name
);
4937 dump_ctf_strtab_name
= strdup (optarg
);
4939 case OPTION_CTF_PARENT
:
4940 free (dump_ctf_parent_name
);
4941 dump_ctf_parent_name
= strdup (optarg
);
4943 case OPTION_DYN_SYMS
:
4946 case OPTION_LTO_SYMS
:
4949 #ifdef SUPPORT_DISASSEMBLY
4951 request_dump (dumpdata
, DISASS_DUMP
);
4955 print_version (program_name
);
4964 do_not_show_symbol_truncation
= true;
4970 enum demangling_styles style
;
4972 style
= cplus_demangle_name_to_style (optarg
);
4973 if (style
== unknown_demangling
)
4974 error (_("unknown demangling style `%s'"), optarg
);
4976 cplus_demangle_set_style (style
);
4979 case OPTION_NO_DEMANGLING
:
4980 do_demangle
= false;
4982 case OPTION_RECURSE_LIMIT
:
4983 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
4985 case OPTION_NO_RECURSE_LIMIT
:
4986 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
4988 case OPTION_WITH_SYMBOL_VERSIONS
:
4989 /* Ignored for backward compatibility. */
4992 case OPTION_SYM_BASE
:
4996 sym_base
= strtoul (optarg
, NULL
, 0);
5013 /* xgettext:c-format */
5014 error (_("Invalid option '-%c'\n"), c
);
5021 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
5022 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
5023 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
5024 && !do_section_groups
&& !do_archive_index
5025 && !do_dyn_syms
&& !do_lto_syms
)
5030 do_dynamic
= do_syms
= do_reloc
= do_unwind
= do_sections
= true;
5031 do_segments
= do_header
= do_dump
= do_version
= true;
5032 do_histogram
= do_debugging
= do_arch
= do_notes
= true;
5033 do_section_groups
= do_archive_index
= do_dyn_syms
= true;
5042 get_elf_class (unsigned int elf_class
)
5044 static char buff
[32];
5048 case ELFCLASSNONE
: return _("none");
5049 case ELFCLASS32
: return "ELF32";
5050 case ELFCLASS64
: return "ELF64";
5052 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
5058 get_data_encoding (unsigned int encoding
)
5060 static char buff
[32];
5064 case ELFDATANONE
: return _("none");
5065 case ELFDATA2LSB
: return _("2's complement, little endian");
5066 case ELFDATA2MSB
: return _("2's complement, big endian");
5068 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
5073 /* Decode the data held in 'filedata->file_header'. */
5076 process_file_header (Filedata
* filedata
)
5078 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
5080 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
5081 || header
->e_ident
[EI_MAG1
] != ELFMAG1
5082 || header
->e_ident
[EI_MAG2
] != ELFMAG2
5083 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
5086 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
5090 if (! filedata
->is_separate
)
5091 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
5097 if (filedata
->is_separate
)
5098 printf (_("ELF Header in linked file '%s':\n"), filedata
->file_name
);
5100 printf (_("ELF Header:\n"));
5101 printf (_(" Magic: "));
5102 for (i
= 0; i
< EI_NIDENT
; i
++)
5103 printf ("%2.2x ", header
->e_ident
[i
]);
5105 printf (_(" Class: %s\n"),
5106 get_elf_class (header
->e_ident
[EI_CLASS
]));
5107 printf (_(" Data: %s\n"),
5108 get_data_encoding (header
->e_ident
[EI_DATA
]));
5109 printf (_(" Version: %d%s\n"),
5110 header
->e_ident
[EI_VERSION
],
5111 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
5113 : (header
->e_ident
[EI_VERSION
] != EV_NONE
5116 printf (_(" OS/ABI: %s\n"),
5117 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
5118 printf (_(" ABI Version: %d\n"),
5119 header
->e_ident
[EI_ABIVERSION
]);
5120 printf (_(" Type: %s\n"),
5121 get_file_type (header
->e_type
));
5122 printf (_(" Machine: %s\n"),
5123 get_machine_name (header
->e_machine
));
5124 printf (_(" Version: 0x%lx\n"),
5127 printf (_(" Entry point address: "));
5128 print_vma (header
->e_entry
, PREFIX_HEX
);
5129 printf (_("\n Start of program headers: "));
5130 print_vma (header
->e_phoff
, DEC
);
5131 printf (_(" (bytes into file)\n Start of section headers: "));
5132 print_vma (header
->e_shoff
, DEC
);
5133 printf (_(" (bytes into file)\n"));
5135 printf (_(" Flags: 0x%lx%s\n"),
5137 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
5138 printf (_(" Size of this header: %u (bytes)\n"),
5140 printf (_(" Size of program headers: %u (bytes)\n"),
5141 header
->e_phentsize
);
5142 printf (_(" Number of program headers: %u"),
5144 if (filedata
->section_headers
!= NULL
5145 && header
->e_phnum
== PN_XNUM
5146 && filedata
->section_headers
[0].sh_info
!= 0)
5148 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
5149 printf (" (%u)", header
->e_phnum
);
5151 putc ('\n', stdout
);
5152 printf (_(" Size of section headers: %u (bytes)\n"),
5153 header
->e_shentsize
);
5154 printf (_(" Number of section headers: %u"),
5156 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
5158 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5159 printf (" (%u)", header
->e_shnum
);
5161 putc ('\n', stdout
);
5162 printf (_(" Section header string table index: %u"),
5163 header
->e_shstrndx
);
5164 if (filedata
->section_headers
!= NULL
5165 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5167 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5168 printf (" (%u)", header
->e_shstrndx
);
5170 if (header
->e_shstrndx
!= SHN_UNDEF
5171 && header
->e_shstrndx
>= header
->e_shnum
)
5173 header
->e_shstrndx
= SHN_UNDEF
;
5174 printf (_(" <corrupt: out of range>"));
5176 putc ('\n', stdout
);
5179 if (filedata
->section_headers
!= NULL
)
5181 if (header
->e_phnum
== PN_XNUM
5182 && filedata
->section_headers
[0].sh_info
!= 0)
5183 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
5184 if (header
->e_shnum
== SHN_UNDEF
)
5185 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5186 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5187 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5188 if (header
->e_shstrndx
>= header
->e_shnum
)
5189 header
->e_shstrndx
= SHN_UNDEF
;
5190 free (filedata
->section_headers
);
5191 filedata
->section_headers
= NULL
;
5197 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5198 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
5201 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5203 Elf32_External_Phdr
* phdrs
;
5204 Elf32_External_Phdr
* external
;
5205 Elf_Internal_Phdr
* internal
;
5207 unsigned int size
= filedata
->file_header
.e_phentsize
;
5208 unsigned int num
= filedata
->file_header
.e_phnum
;
5210 /* PR binutils/17531: Cope with unexpected section header sizes. */
5211 if (size
== 0 || num
== 0)
5213 if (size
< sizeof * phdrs
)
5215 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5218 if (size
> sizeof * phdrs
)
5219 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5221 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5222 size
, num
, _("program headers"));
5226 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5227 i
< filedata
->file_header
.e_phnum
;
5228 i
++, internal
++, external
++)
5230 internal
->p_type
= BYTE_GET (external
->p_type
);
5231 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5232 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5233 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5234 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5235 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5236 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5237 internal
->p_align
= BYTE_GET (external
->p_align
);
5244 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5245 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5248 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5250 Elf64_External_Phdr
* phdrs
;
5251 Elf64_External_Phdr
* external
;
5252 Elf_Internal_Phdr
* internal
;
5254 unsigned int size
= filedata
->file_header
.e_phentsize
;
5255 unsigned int num
= filedata
->file_header
.e_phnum
;
5257 /* PR binutils/17531: Cope with unexpected section header sizes. */
5258 if (size
== 0 || num
== 0)
5260 if (size
< sizeof * phdrs
)
5262 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5265 if (size
> sizeof * phdrs
)
5266 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5268 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5269 size
, num
, _("program headers"));
5273 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5274 i
< filedata
->file_header
.e_phnum
;
5275 i
++, internal
++, external
++)
5277 internal
->p_type
= BYTE_GET (external
->p_type
);
5278 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5279 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5280 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5281 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5282 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5283 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5284 internal
->p_align
= BYTE_GET (external
->p_align
);
5291 /* Returns TRUE if the program headers were read into `program_headers'. */
5294 get_program_headers (Filedata
* filedata
)
5296 Elf_Internal_Phdr
* phdrs
;
5298 /* Check cache of prior read. */
5299 if (filedata
->program_headers
!= NULL
)
5302 /* Be kind to memory checkers by looking for
5303 e_phnum values which we know must be invalid. */
5304 if (filedata
->file_header
.e_phnum
5305 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5306 >= filedata
->file_size
)
5308 error (_("Too many program headers - %#x - the file is not that big\n"),
5309 filedata
->file_header
.e_phnum
);
5313 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5314 sizeof (Elf_Internal_Phdr
));
5317 error (_("Out of memory reading %u program headers\n"),
5318 filedata
->file_header
.e_phnum
);
5323 ? get_32bit_program_headers (filedata
, phdrs
)
5324 : get_64bit_program_headers (filedata
, phdrs
))
5326 filedata
->program_headers
= phdrs
;
5334 /* Returns TRUE if the program headers were loaded. */
5337 process_program_headers (Filedata
* filedata
)
5339 Elf_Internal_Phdr
* segment
;
5341 Elf_Internal_Phdr
* previous_load
= NULL
;
5343 filedata
->dynamic_addr
= 0;
5344 filedata
->dynamic_size
= 0;
5346 if (filedata
->file_header
.e_phnum
== 0)
5348 /* PR binutils/12467. */
5349 if (filedata
->file_header
.e_phoff
!= 0)
5351 warn (_("possibly corrupt ELF header - it has a non-zero program"
5352 " header offset, but no program headers\n"));
5355 else if (do_segments
)
5357 if (filedata
->is_separate
)
5358 printf (_("\nThere are no program headers in linked file '%s'.\n"),
5359 filedata
->file_name
);
5361 printf (_("\nThere are no program headers in this file.\n"));
5366 if (do_segments
&& !do_header
)
5368 if (filedata
->is_separate
)
5369 printf ("\nIn linked file '%s' the ELF file type is %s\n",
5370 filedata
->file_name
,
5371 get_file_type (filedata
->file_header
.e_type
));
5373 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5374 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5375 printf (ngettext ("There is %d program header, starting at offset %s\n",
5376 "There are %d program headers, starting at offset %s\n",
5377 filedata
->file_header
.e_phnum
),
5378 filedata
->file_header
.e_phnum
,
5379 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5382 if (! get_program_headers (filedata
))
5387 if (filedata
->file_header
.e_phnum
> 1)
5388 printf (_("\nProgram Headers:\n"));
5390 printf (_("\nProgram Headers:\n"));
5394 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5397 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5401 (_(" Type Offset VirtAddr PhysAddr\n"));
5403 (_(" FileSiz MemSiz Flags Align\n"));
5407 for (i
= 0, segment
= filedata
->program_headers
;
5408 i
< filedata
->file_header
.e_phnum
;
5413 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5417 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5418 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5419 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5420 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5421 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5423 (segment
->p_flags
& PF_R
? 'R' : ' '),
5424 (segment
->p_flags
& PF_W
? 'W' : ' '),
5425 (segment
->p_flags
& PF_X
? 'E' : ' '));
5426 printf ("%#lx", (unsigned long) segment
->p_align
);
5430 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5431 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5434 print_vma (segment
->p_offset
, FULL_HEX
);
5438 print_vma (segment
->p_vaddr
, FULL_HEX
);
5440 print_vma (segment
->p_paddr
, FULL_HEX
);
5443 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5444 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5447 print_vma (segment
->p_filesz
, FULL_HEX
);
5451 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5452 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5455 print_vma (segment
->p_memsz
, FULL_HEX
);
5459 (segment
->p_flags
& PF_R
? 'R' : ' '),
5460 (segment
->p_flags
& PF_W
? 'W' : ' '),
5461 (segment
->p_flags
& PF_X
? 'E' : ' '));
5463 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5464 printf ("%#lx", (unsigned long) segment
->p_align
);
5467 print_vma (segment
->p_align
, PREFIX_HEX
);
5472 print_vma (segment
->p_offset
, FULL_HEX
);
5474 print_vma (segment
->p_vaddr
, FULL_HEX
);
5476 print_vma (segment
->p_paddr
, FULL_HEX
);
5478 print_vma (segment
->p_filesz
, FULL_HEX
);
5480 print_vma (segment
->p_memsz
, FULL_HEX
);
5482 (segment
->p_flags
& PF_R
? 'R' : ' '),
5483 (segment
->p_flags
& PF_W
? 'W' : ' '),
5484 (segment
->p_flags
& PF_X
? 'E' : ' '));
5485 print_vma (segment
->p_align
, PREFIX_HEX
);
5488 putc ('\n', stdout
);
5491 switch (segment
->p_type
)
5494 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5495 required by the ELF standard, several programs, including the Linux
5496 kernel, make use of non-ordered segments. */
5498 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5499 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5501 if (segment
->p_memsz
< segment
->p_filesz
)
5502 error (_("the segment's file size is larger than its memory size\n"));
5503 previous_load
= segment
;
5507 /* PR 20815 - Verify that the program header is loaded into memory. */
5508 if (i
> 0 && previous_load
!= NULL
)
5509 error (_("the PHDR segment must occur before any LOAD segment\n"));
5510 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5514 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5516 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
5517 if (load
->p_type
== PT_LOAD
5518 && load
->p_offset
<= segment
->p_offset
5519 && (load
->p_offset
+ load
->p_filesz
5520 >= segment
->p_offset
+ segment
->p_filesz
)
5521 && load
->p_vaddr
<= segment
->p_vaddr
5522 && (load
->p_vaddr
+ load
->p_filesz
5523 >= segment
->p_vaddr
+ segment
->p_filesz
))
5526 if (j
== filedata
->file_header
.e_phnum
)
5527 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5532 if (filedata
->dynamic_addr
)
5533 error (_("more than one dynamic segment\n"));
5535 /* By default, assume that the .dynamic section is the first
5536 section in the DYNAMIC segment. */
5537 filedata
->dynamic_addr
= segment
->p_offset
;
5538 filedata
->dynamic_size
= segment
->p_filesz
;
5540 /* Try to locate the .dynamic section. If there is
5541 a section header table, we can easily locate it. */
5542 if (filedata
->section_headers
!= NULL
)
5544 Elf_Internal_Shdr
* sec
;
5546 sec
= find_section (filedata
, ".dynamic");
5547 if (sec
== NULL
|| sec
->sh_size
== 0)
5549 /* A corresponding .dynamic section is expected, but on
5550 IA-64/OpenVMS it is OK for it to be missing. */
5551 if (!is_ia64_vms (filedata
))
5552 error (_("no .dynamic section in the dynamic segment\n"));
5556 if (sec
->sh_type
== SHT_NOBITS
)
5558 filedata
->dynamic_size
= 0;
5562 filedata
->dynamic_addr
= sec
->sh_offset
;
5563 filedata
->dynamic_size
= sec
->sh_size
;
5565 /* The PT_DYNAMIC segment, which is used by the run-time
5566 loader, should exactly match the .dynamic section. */
5568 && (filedata
->dynamic_addr
!= segment
->p_offset
5569 || filedata
->dynamic_size
!= segment
->p_filesz
))
5571 the .dynamic section is not the same as the dynamic segment\n"));
5574 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5575 segment. Check this after matching against the section headers
5576 so we don't warn on debuginfo file (which have NOBITS .dynamic
5578 if (filedata
->dynamic_addr
> filedata
->file_size
5579 || (filedata
->dynamic_size
5580 > filedata
->file_size
- filedata
->dynamic_addr
))
5582 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5583 filedata
->dynamic_addr
= filedata
->dynamic_size
= 0;
5588 if (segment
->p_offset
>= filedata
->file_size
5589 || segment
->p_filesz
> filedata
->file_size
- segment
->p_offset
5590 || segment
->p_filesz
- 1 >= (size_t) -2
5591 || fseek (filedata
->handle
,
5592 filedata
->archive_file_offset
+ (long) segment
->p_offset
,
5594 error (_("Unable to find program interpreter name\n"));
5597 size_t len
= segment
->p_filesz
;
5598 free (filedata
->program_interpreter
);
5599 filedata
->program_interpreter
= xmalloc (len
+ 1);
5600 len
= fread (filedata
->program_interpreter
, 1, len
,
5602 filedata
->program_interpreter
[len
] = 0;
5605 printf (_(" [Requesting program interpreter: %s]\n"),
5606 filedata
->program_interpreter
);
5613 && filedata
->section_headers
!= NULL
5614 && filedata
->string_table
!= NULL
)
5616 printf (_("\n Section to Segment mapping:\n"));
5617 printf (_(" Segment Sections...\n"));
5619 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5622 Elf_Internal_Shdr
* section
;
5624 segment
= filedata
->program_headers
+ i
;
5625 section
= filedata
->section_headers
+ 1;
5627 printf (" %2.2d ", i
);
5629 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5631 if (!ELF_TBSS_SPECIAL (section
, segment
)
5632 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5633 printf ("%s ", printable_section_name (filedata
, section
));
5644 /* Find the file offset corresponding to VMA by using the program headers. */
5647 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5649 Elf_Internal_Phdr
* seg
;
5651 if (! get_program_headers (filedata
))
5653 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5657 for (seg
= filedata
->program_headers
;
5658 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5661 if (seg
->p_type
!= PT_LOAD
)
5664 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5665 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5666 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5669 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5670 (unsigned long) vma
);
5675 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5676 If PROBE is true, this is just a probe and we do not generate any error
5677 messages if the load fails. */
5680 get_32bit_section_headers (Filedata
* filedata
, bool probe
)
5682 Elf32_External_Shdr
* shdrs
;
5683 Elf_Internal_Shdr
* internal
;
5685 unsigned int size
= filedata
->file_header
.e_shentsize
;
5686 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5688 /* PR binutils/17531: Cope with unexpected section header sizes. */
5689 if (size
== 0 || num
== 0)
5691 if (size
< sizeof * shdrs
)
5694 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5697 if (!probe
&& size
> sizeof * shdrs
)
5698 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5700 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5702 probe
? NULL
: _("section headers"));
5706 free (filedata
->section_headers
);
5707 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5708 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5709 if (filedata
->section_headers
== NULL
)
5712 error (_("Out of memory reading %u section headers\n"), num
);
5717 for (i
= 0, internal
= filedata
->section_headers
;
5721 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5722 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5723 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5724 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5725 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5726 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5727 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5728 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5729 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5730 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5731 if (!probe
&& internal
->sh_link
> num
)
5732 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5733 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5734 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5741 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5744 get_64bit_section_headers (Filedata
* filedata
, bool probe
)
5746 Elf64_External_Shdr
* shdrs
;
5747 Elf_Internal_Shdr
* internal
;
5749 unsigned int size
= filedata
->file_header
.e_shentsize
;
5750 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5752 /* PR binutils/17531: Cope with unexpected section header sizes. */
5753 if (size
== 0 || num
== 0)
5756 if (size
< sizeof * shdrs
)
5759 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5763 if (! probe
&& size
> sizeof * shdrs
)
5764 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5766 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5767 filedata
->file_header
.e_shoff
,
5769 probe
? NULL
: _("section headers"));
5773 free (filedata
->section_headers
);
5774 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5775 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5776 if (filedata
->section_headers
== NULL
)
5779 error (_("Out of memory reading %u section headers\n"), num
);
5784 for (i
= 0, internal
= filedata
->section_headers
;
5788 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5789 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5790 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5791 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5792 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5793 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5794 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5795 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5796 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5797 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5798 if (!probe
&& internal
->sh_link
> num
)
5799 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5800 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5801 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5808 static Elf_Internal_Sym
*
5809 get_32bit_elf_symbols (Filedata
* filedata
,
5810 Elf_Internal_Shdr
* section
,
5811 unsigned long * num_syms_return
)
5813 unsigned long number
= 0;
5814 Elf32_External_Sym
* esyms
= NULL
;
5815 Elf_External_Sym_Shndx
* shndx
= NULL
;
5816 Elf_Internal_Sym
* isyms
= NULL
;
5817 Elf_Internal_Sym
* psym
;
5819 elf_section_list
* entry
;
5821 if (section
->sh_size
== 0)
5823 if (num_syms_return
!= NULL
)
5824 * num_syms_return
= 0;
5828 /* Run some sanity checks first. */
5829 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5831 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5832 printable_section_name (filedata
, section
),
5833 (unsigned long) section
->sh_entsize
);
5837 if (section
->sh_size
> filedata
->file_size
)
5839 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5840 printable_section_name (filedata
, section
),
5841 (unsigned long) section
->sh_size
);
5845 number
= section
->sh_size
/ section
->sh_entsize
;
5847 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5849 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5850 (unsigned long) section
->sh_size
,
5851 printable_section_name (filedata
, section
),
5852 (unsigned long) section
->sh_entsize
);
5856 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5857 section
->sh_size
, _("symbols"));
5862 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5864 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5869 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5873 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5874 entry
->hdr
->sh_offset
,
5875 1, entry
->hdr
->sh_size
,
5876 _("symbol table section indices"));
5880 /* PR17531: file: heap-buffer-overflow */
5881 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5883 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5884 printable_section_name (filedata
, entry
->hdr
),
5885 (unsigned long) entry
->hdr
->sh_size
,
5886 (unsigned long) section
->sh_size
);
5891 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5895 error (_("Out of memory reading %lu symbols\n"),
5896 (unsigned long) number
);
5900 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5902 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5903 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5904 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5905 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5906 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5908 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5909 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5910 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5911 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5912 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5919 if (num_syms_return
!= NULL
)
5920 * num_syms_return
= isyms
== NULL
? 0 : number
;
5925 static Elf_Internal_Sym
*
5926 get_64bit_elf_symbols (Filedata
* filedata
,
5927 Elf_Internal_Shdr
* section
,
5928 unsigned long * num_syms_return
)
5930 unsigned long number
= 0;
5931 Elf64_External_Sym
* esyms
= NULL
;
5932 Elf_External_Sym_Shndx
* shndx
= NULL
;
5933 Elf_Internal_Sym
* isyms
= NULL
;
5934 Elf_Internal_Sym
* psym
;
5936 elf_section_list
* entry
;
5938 if (section
->sh_size
== 0)
5940 if (num_syms_return
!= NULL
)
5941 * num_syms_return
= 0;
5945 /* Run some sanity checks first. */
5946 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5948 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5949 printable_section_name (filedata
, section
),
5950 (unsigned long) section
->sh_entsize
);
5954 if (section
->sh_size
> filedata
->file_size
)
5956 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5957 printable_section_name (filedata
, section
),
5958 (unsigned long) section
->sh_size
);
5962 number
= section
->sh_size
/ section
->sh_entsize
;
5964 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5966 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5967 (unsigned long) section
->sh_size
,
5968 printable_section_name (filedata
, section
),
5969 (unsigned long) section
->sh_entsize
);
5973 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5974 section
->sh_size
, _("symbols"));
5979 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5981 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5986 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5990 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5991 entry
->hdr
->sh_offset
,
5992 1, entry
->hdr
->sh_size
,
5993 _("symbol table section indices"));
5997 /* PR17531: file: heap-buffer-overflow */
5998 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
6000 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
6001 printable_section_name (filedata
, entry
->hdr
),
6002 (unsigned long) entry
->hdr
->sh_size
,
6003 (unsigned long) section
->sh_size
);
6008 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
6012 error (_("Out of memory reading %lu symbols\n"),
6013 (unsigned long) number
);
6017 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
6019 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
6020 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
6021 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
6022 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
6024 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
6026 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
6027 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
6028 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
6030 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
6031 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
6038 if (num_syms_return
!= NULL
)
6039 * num_syms_return
= isyms
== NULL
? 0 : number
;
6045 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
6047 static char buff
[1024];
6049 unsigned int field_size
= is_32bit_elf
? 8 : 16;
6051 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
6052 bfd_vma os_flags
= 0;
6053 bfd_vma proc_flags
= 0;
6054 bfd_vma unknown_flags
= 0;
6062 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
6063 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
6064 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
6065 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
6066 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
6067 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
6068 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
6069 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
6070 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
6071 /* 9 */ { STRING_COMMA_LEN ("TLS") },
6072 /* IA-64 specific. */
6073 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
6074 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
6075 /* IA-64 OpenVMS specific. */
6076 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
6077 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
6078 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
6079 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
6080 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
6081 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
6083 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
6084 /* SPARC specific. */
6085 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
6086 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
6088 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
6089 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
6090 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
6092 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
6094 /* 25 */ { STRING_COMMA_LEN ("VLE") },
6096 /* 26 */ { STRING_COMMA_LEN ("GNU_RETAIN") },
6099 if (do_section_details
)
6101 sprintf (buff
, "[%*.*lx]: ",
6102 field_size
, field_size
, (unsigned long) sh_flags
);
6103 p
+= field_size
+ 4;
6110 flag
= sh_flags
& - sh_flags
;
6113 if (do_section_details
)
6117 case SHF_WRITE
: sindex
= 0; break;
6118 case SHF_ALLOC
: sindex
= 1; break;
6119 case SHF_EXECINSTR
: sindex
= 2; break;
6120 case SHF_MERGE
: sindex
= 3; break;
6121 case SHF_STRINGS
: sindex
= 4; break;
6122 case SHF_INFO_LINK
: sindex
= 5; break;
6123 case SHF_LINK_ORDER
: sindex
= 6; break;
6124 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
6125 case SHF_GROUP
: sindex
= 8; break;
6126 case SHF_TLS
: sindex
= 9; break;
6127 case SHF_EXCLUDE
: sindex
= 18; break;
6128 case SHF_COMPRESSED
: sindex
= 20; break;
6132 switch (filedata
->file_header
.e_machine
)
6135 if (flag
== SHF_IA_64_SHORT
)
6137 else if (flag
== SHF_IA_64_NORECOV
)
6140 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
6143 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
6144 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
6145 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
6146 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
6147 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
6148 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
6159 case EM_OLD_SPARCV9
:
6160 case EM_SPARC32PLUS
:
6163 if (flag
== SHF_ORDERED
)
6170 case SHF_ENTRYSECT
: sindex
= 21; break;
6171 case SHF_ARM_PURECODE
: sindex
= 22; break;
6172 case SHF_COMDEF
: sindex
= 23; break;
6177 if (flag
== SHF_PPC_VLE
)
6184 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
6187 case ELFOSABI_FREEBSD
:
6188 if (flag
== SHF_GNU_RETAIN
)
6192 if (flag
== SHF_GNU_MBIND
)
6193 /* We should not recognize SHF_GNU_MBIND for
6194 ELFOSABI_NONE, but binutils as of 2019-07-23 did
6195 not set the EI_OSABI header byte. */
6206 if (p
!= buff
+ field_size
+ 4)
6208 if (size
< (10 + 2))
6210 warn (_("Internal error: not enough buffer room for section flag info"));
6211 return _("<unknown>");
6218 size
-= flags
[sindex
].len
;
6219 p
= stpcpy (p
, flags
[sindex
].str
);
6221 else if (flag
& SHF_MASKOS
)
6223 else if (flag
& SHF_MASKPROC
)
6226 unknown_flags
|= flag
;
6232 case SHF_WRITE
: *p
= 'W'; break;
6233 case SHF_ALLOC
: *p
= 'A'; break;
6234 case SHF_EXECINSTR
: *p
= 'X'; break;
6235 case SHF_MERGE
: *p
= 'M'; break;
6236 case SHF_STRINGS
: *p
= 'S'; break;
6237 case SHF_INFO_LINK
: *p
= 'I'; break;
6238 case SHF_LINK_ORDER
: *p
= 'L'; break;
6239 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
6240 case SHF_GROUP
: *p
= 'G'; break;
6241 case SHF_TLS
: *p
= 'T'; break;
6242 case SHF_EXCLUDE
: *p
= 'E'; break;
6243 case SHF_COMPRESSED
: *p
= 'C'; break;
6246 if ((filedata
->file_header
.e_machine
== EM_X86_64
6247 || filedata
->file_header
.e_machine
== EM_L1OM
6248 || filedata
->file_header
.e_machine
== EM_K1OM
)
6249 && flag
== SHF_X86_64_LARGE
)
6251 else if (filedata
->file_header
.e_machine
== EM_ARM
6252 && flag
== SHF_ARM_PURECODE
)
6254 else if (filedata
->file_header
.e_machine
== EM_PPC
6255 && flag
== SHF_PPC_VLE
)
6257 else if (flag
& SHF_MASKOS
)
6259 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
6262 case ELFOSABI_FREEBSD
:
6263 if (flag
== SHF_GNU_RETAIN
)
6270 if (flag
== SHF_GNU_MBIND
)
6272 /* We should not recognize SHF_GNU_MBIND for
6273 ELFOSABI_NONE, but binutils as of 2019-07-23 did
6274 not set the EI_OSABI header byte. */
6281 sh_flags
&= ~SHF_MASKOS
;
6285 else if (flag
& SHF_MASKPROC
)
6288 sh_flags
&= ~ SHF_MASKPROC
;
6298 if (do_section_details
)
6302 size
-= 5 + field_size
;
6303 if (p
!= buff
+ field_size
+ 4)
6307 warn (_("Internal error: not enough buffer room for section flag info"));
6308 return _("<unknown>");
6314 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6315 (unsigned long) os_flags
);
6316 p
+= 5 + field_size
;
6320 size
-= 7 + field_size
;
6321 if (p
!= buff
+ field_size
+ 4)
6325 warn (_("Internal error: not enough buffer room for section flag info"));
6326 return _("<unknown>");
6332 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6333 (unsigned long) proc_flags
);
6334 p
+= 7 + field_size
;
6338 size
-= 10 + field_size
;
6339 if (p
!= buff
+ field_size
+ 4)
6343 warn (_("Internal error: not enough buffer room for section flag info"));
6344 return _("<unknown>");
6350 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6351 (unsigned long) unknown_flags
);
6352 p
+= 10 + field_size
;
6360 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
6361 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6365 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6367 if (size
< sizeof (* echdr
))
6369 error (_("Compressed section is too small even for a compression header\n"));
6373 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6374 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6375 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6376 return sizeof (*echdr
);
6380 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6382 if (size
< sizeof (* echdr
))
6384 error (_("Compressed section is too small even for a compression header\n"));
6388 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6389 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6390 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6391 return sizeof (*echdr
);
6396 process_section_headers (Filedata
* filedata
)
6398 Elf_Internal_Shdr
* section
;
6401 free (filedata
->section_headers
);
6402 filedata
->section_headers
= NULL
;
6403 free (filedata
->dynamic_symbols
);
6404 filedata
->dynamic_symbols
= NULL
;
6405 filedata
->num_dynamic_syms
= 0;
6406 free (filedata
->dynamic_strings
);
6407 filedata
->dynamic_strings
= NULL
;
6408 filedata
->dynamic_strings_length
= 0;
6409 free (filedata
->dynamic_syminfo
);
6410 filedata
->dynamic_syminfo
= NULL
;
6411 while (filedata
->symtab_shndx_list
!= NULL
)
6413 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
6414 free (filedata
->symtab_shndx_list
);
6415 filedata
->symtab_shndx_list
= next
;
6418 if (filedata
->file_header
.e_shnum
== 0)
6420 /* PR binutils/12467. */
6421 if (filedata
->file_header
.e_shoff
!= 0)
6423 warn (_("possibly corrupt ELF file header - it has a non-zero"
6424 " section header offset, but no section headers\n"));
6427 else if (do_sections
)
6428 printf (_("\nThere are no sections in this file.\n"));
6433 if (do_sections
&& !do_header
)
6435 if (filedata
->is_separate
&& process_links
)
6436 printf (_("In linked file '%s': "), filedata
->file_name
);
6437 if (! filedata
->is_separate
|| process_links
)
6438 printf (ngettext ("There is %d section header, "
6439 "starting at offset 0x%lx:\n",
6440 "There are %d section headers, "
6441 "starting at offset 0x%lx:\n",
6442 filedata
->file_header
.e_shnum
),
6443 filedata
->file_header
.e_shnum
,
6444 (unsigned long) filedata
->file_header
.e_shoff
);
6449 if (! get_32bit_section_headers (filedata
, false))
6454 if (! get_64bit_section_headers (filedata
, false))
6458 /* Read in the string table, so that we have names to display. */
6459 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6460 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6462 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6464 if (section
->sh_size
!= 0)
6466 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6467 1, section
->sh_size
,
6470 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6474 /* Scan the sections for the dynamic symbol table
6475 and dynamic string table and debug sections. */
6476 eh_addr_size
= is_32bit_elf
? 4 : 8;
6477 switch (filedata
->file_header
.e_machine
)
6480 case EM_MIPS_RS3_LE
:
6481 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6482 FDE addresses. However, the ABI also has a semi-official ILP32
6483 variant for which the normal FDE address size rules apply.
6485 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6486 section, where XX is the size of longs in bits. Unfortunately,
6487 earlier compilers provided no way of distinguishing ILP32 objects
6488 from LP64 objects, so if there's any doubt, we should assume that
6489 the official LP64 form is being used. */
6490 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6491 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6497 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6499 case E_H8_MACH_H8300
:
6500 case E_H8_MACH_H8300HN
:
6501 case E_H8_MACH_H8300SN
:
6502 case E_H8_MACH_H8300SXN
:
6505 case E_H8_MACH_H8300H
:
6506 case E_H8_MACH_H8300S
:
6507 case E_H8_MACH_H8300SX
:
6515 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6517 case EF_M32C_CPU_M16C
:
6524 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6527 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6528 if (section->sh_entsize != expected_entsize) \
6531 sprintf_vma (buf, section->sh_entsize); \
6532 /* Note: coded this way so that there is a single string for \
6534 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6535 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6536 (unsigned) expected_entsize); \
6537 section->sh_entsize = expected_entsize; \
6542 #define CHECK_ENTSIZE(section, i, type) \
6543 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6544 sizeof (Elf64_External_##type))
6546 for (i
= 0, section
= filedata
->section_headers
;
6547 i
< filedata
->file_header
.e_shnum
;
6550 char * name
= SECTION_NAME_PRINT (section
);
6552 /* Run some sanity checks on the headers and
6553 possibly fill in some file data as well. */
6554 switch (section
->sh_type
)
6557 if (filedata
->dynamic_symbols
!= NULL
)
6559 error (_("File contains multiple dynamic symbol tables\n"));
6563 CHECK_ENTSIZE (section
, i
, Sym
);
6564 filedata
->dynamic_symbols
6565 = GET_ELF_SYMBOLS (filedata
, section
, &filedata
->num_dynamic_syms
);
6566 filedata
->dynamic_symtab_section
= section
;
6570 if (streq (name
, ".dynstr"))
6572 if (filedata
->dynamic_strings
!= NULL
)
6574 error (_("File contains multiple dynamic string tables\n"));
6578 filedata
->dynamic_strings
6579 = (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6580 1, section
->sh_size
, _("dynamic strings"));
6581 filedata
->dynamic_strings_length
6582 = filedata
->dynamic_strings
== NULL
? 0 : section
->sh_size
;
6583 filedata
->dynamic_strtab_section
= section
;
6587 case SHT_SYMTAB_SHNDX
:
6589 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6591 entry
->hdr
= section
;
6592 entry
->next
= filedata
->symtab_shndx_list
;
6593 filedata
->symtab_shndx_list
= entry
;
6598 CHECK_ENTSIZE (section
, i
, Sym
);
6602 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6606 CHECK_ENTSIZE (section
, i
, Rel
);
6607 if (do_checks
&& section
->sh_size
== 0)
6608 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6612 CHECK_ENTSIZE (section
, i
, Rela
);
6613 if (do_checks
&& section
->sh_size
== 0)
6614 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6619 /* Having a zero sized section is not illegal according to the
6620 ELF standard, but it might be an indication that something
6621 is wrong. So issue a warning if we are running in lint mode. */
6622 if (do_checks
&& section
->sh_size
== 0)
6623 warn (_("Section '%s': has a size of zero - is this intended ?\n"), name
);
6630 if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6631 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6632 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6633 || do_debug_str
|| do_debug_str_offsets
|| do_debug_loc
6635 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6636 && (startswith (name
, ".debug_")
6637 || startswith (name
, ".zdebug_")))
6640 name
+= sizeof (".zdebug_") - 1;
6642 name
+= sizeof (".debug_") - 1;
6645 || (do_debug_info
&& startswith (name
, "info"))
6646 || (do_debug_info
&& startswith (name
, "types"))
6647 || (do_debug_abbrevs
&& startswith (name
, "abbrev"))
6648 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6649 || (do_debug_lines
&& startswith (name
, "line."))
6650 || (do_debug_pubnames
&& startswith (name
, "pubnames"))
6651 || (do_debug_pubtypes
&& startswith (name
, "pubtypes"))
6652 || (do_debug_pubnames
&& startswith (name
, "gnu_pubnames"))
6653 || (do_debug_pubtypes
&& startswith (name
, "gnu_pubtypes"))
6654 || (do_debug_aranges
&& startswith (name
, "aranges"))
6655 || (do_debug_ranges
&& startswith (name
, "ranges"))
6656 || (do_debug_ranges
&& startswith (name
, "rnglists"))
6657 || (do_debug_frames
&& startswith (name
, "frame"))
6658 || (do_debug_macinfo
&& startswith (name
, "macinfo"))
6659 || (do_debug_macinfo
&& startswith (name
, "macro"))
6660 || (do_debug_str
&& startswith (name
, "str"))
6661 || (do_debug_links
&& startswith (name
, "sup"))
6662 || (do_debug_str_offsets
&& startswith (name
, "str_offsets"))
6663 || (do_debug_loc
&& startswith (name
, "loc"))
6664 || (do_debug_loc
&& startswith (name
, "loclists"))
6665 || (do_debug_addr
&& startswith (name
, "addr"))
6666 || (do_debug_cu_index
&& startswith (name
, "cu_index"))
6667 || (do_debug_cu_index
&& startswith (name
, "tu_index"))
6669 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6671 /* Linkonce section to be combined with .debug_info at link time. */
6672 else if ((do_debugging
|| do_debug_info
)
6673 && startswith (name
, ".gnu.linkonce.wi."))
6674 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6675 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6676 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6677 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6678 || streq (name
, ".debug_names")))
6679 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6680 /* Trace sections for Itanium VMS. */
6681 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6682 || do_trace_aranges
)
6683 && startswith (name
, ".trace_"))
6685 name
+= sizeof (".trace_") - 1;
6688 || (do_trace_info
&& streq (name
, "info"))
6689 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6690 || (do_trace_aranges
&& streq (name
, "aranges"))
6692 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6694 else if ((do_debugging
|| do_debug_links
)
6695 && (startswith (name
, ".gnu_debuglink")
6696 || startswith (name
, ".gnu_debugaltlink")))
6697 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6703 if (filedata
->is_separate
&& ! process_links
)
6706 if (filedata
->is_separate
)
6707 printf (_("\nSection Headers in linked file '%s':\n"), filedata
->file_name
);
6708 else if (filedata
->file_header
.e_shnum
> 1)
6709 printf (_("\nSection Headers:\n"));
6711 printf (_("\nSection Header:\n"));
6715 if (do_section_details
)
6717 printf (_(" [Nr] Name\n"));
6718 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6722 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6726 if (do_section_details
)
6728 printf (_(" [Nr] Name\n"));
6729 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6733 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6737 if (do_section_details
)
6739 printf (_(" [Nr] Name\n"));
6740 printf (_(" Type Address Offset Link\n"));
6741 printf (_(" Size EntSize Info Align\n"));
6745 printf (_(" [Nr] Name Type Address Offset\n"));
6746 printf (_(" Size EntSize Flags Link Info Align\n"));
6750 if (do_section_details
)
6751 printf (_(" Flags\n"));
6753 for (i
= 0, section
= filedata
->section_headers
;
6754 i
< filedata
->file_header
.e_shnum
;
6757 /* Run some sanity checks on the section header. */
6759 /* Check the sh_link field. */
6760 switch (section
->sh_type
)
6764 if (section
->sh_link
== 0
6765 && (filedata
->file_header
.e_type
== ET_EXEC
6766 || filedata
->file_header
.e_type
== ET_DYN
))
6767 /* A dynamic relocation section where all entries use a
6768 zero symbol index need not specify a symtab section. */
6771 case SHT_SYMTAB_SHNDX
:
6775 case SHT_GNU_versym
:
6776 if (section
->sh_link
== 0
6777 || section
->sh_link
>= filedata
->file_header
.e_shnum
6778 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6779 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6780 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6781 i
, section
->sh_link
);
6787 case SHT_GNU_verneed
:
6788 case SHT_GNU_verdef
:
6789 case SHT_GNU_LIBLIST
:
6790 if (section
->sh_link
== 0
6791 || section
->sh_link
>= filedata
->file_header
.e_shnum
6792 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6793 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6794 i
, section
->sh_link
);
6797 case SHT_INIT_ARRAY
:
6798 case SHT_FINI_ARRAY
:
6799 case SHT_PREINIT_ARRAY
:
6800 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6801 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6802 i
, section
->sh_link
);
6806 /* FIXME: Add support for target specific section types. */
6807 #if 0 /* Currently we do not check other section types as there are too
6808 many special cases. Stab sections for example have a type
6809 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6811 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6812 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6813 i
, section
->sh_link
);
6818 /* Check the sh_info field. */
6819 switch (section
->sh_type
)
6823 if (section
->sh_info
== 0
6824 && (filedata
->file_header
.e_type
== ET_EXEC
6825 || filedata
->file_header
.e_type
== ET_DYN
))
6826 /* Dynamic relocations apply to segments, so they do not
6827 need to specify the section they relocate. */
6829 if (section
->sh_info
== 0
6830 || section
->sh_info
>= filedata
->file_header
.e_shnum
6831 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6832 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6833 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6834 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6835 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6836 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6837 /* FIXME: Are other section types valid ? */
6838 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6839 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6840 i
, section
->sh_info
);
6845 case SHT_SYMTAB_SHNDX
:
6846 case SHT_INIT_ARRAY
:
6847 case SHT_FINI_ARRAY
:
6848 case SHT_PREINIT_ARRAY
:
6849 if (section
->sh_info
!= 0)
6850 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6851 i
, section
->sh_info
);
6857 /* A symbol index - we assume that it is valid. */
6861 /* FIXME: Add support for target specific section types. */
6862 if (section
->sh_type
== SHT_NOBITS
)
6863 /* NOBITS section headers with non-zero sh_info fields can be
6864 created when a binary is stripped of everything but its debug
6865 information. The stripped sections have their headers
6866 preserved but their types set to SHT_NOBITS. So do not check
6867 this type of section. */
6869 else if (section
->sh_flags
& SHF_INFO_LINK
)
6871 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6872 warn (_("[%2u]: Expected link to another section in info field"), i
);
6874 else if (section
->sh_type
< SHT_LOOS
6875 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6876 && section
->sh_info
!= 0)
6877 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6878 i
, section
->sh_info
);
6882 /* Check the sh_size field. */
6883 if (section
->sh_size
> filedata
->file_size
6884 && section
->sh_type
!= SHT_NOBITS
6885 && section
->sh_type
!= SHT_NULL
6886 && section
->sh_type
< SHT_LOOS
)
6887 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6889 printf (" [%2u] ", i
);
6890 if (do_section_details
)
6891 printf ("%s\n ", printable_section_name (filedata
, section
));
6893 print_symbol (-17, SECTION_NAME_PRINT (section
));
6895 printf (do_wide
? " %-15s " : " %-15.15s ",
6896 get_section_type_name (filedata
, section
->sh_type
));
6900 const char * link_too_big
= NULL
;
6902 print_vma (section
->sh_addr
, LONG_HEX
);
6904 printf ( " %6.6lx %6.6lx %2.2lx",
6905 (unsigned long) section
->sh_offset
,
6906 (unsigned long) section
->sh_size
,
6907 (unsigned long) section
->sh_entsize
);
6909 if (do_section_details
)
6910 fputs (" ", stdout
);
6912 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6914 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6917 /* The sh_link value is out of range. Normally this indicates
6918 an error but it can have special values in Solaris binaries. */
6919 switch (filedata
->file_header
.e_machine
)
6926 case EM_OLD_SPARCV9
:
6927 case EM_SPARC32PLUS
:
6930 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6931 link_too_big
= "BEFORE";
6932 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6933 link_too_big
= "AFTER";
6940 if (do_section_details
)
6942 if (link_too_big
!= NULL
&& * link_too_big
)
6943 printf ("<%s> ", link_too_big
);
6945 printf ("%2u ", section
->sh_link
);
6946 printf ("%3u %2lu\n", section
->sh_info
,
6947 (unsigned long) section
->sh_addralign
);
6950 printf ("%2u %3u %2lu\n",
6953 (unsigned long) section
->sh_addralign
);
6955 if (link_too_big
&& ! * link_too_big
)
6956 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6957 i
, section
->sh_link
);
6961 print_vma (section
->sh_addr
, LONG_HEX
);
6963 if ((long) section
->sh_offset
== section
->sh_offset
)
6964 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6968 print_vma (section
->sh_offset
, LONG_HEX
);
6971 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6972 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6976 print_vma (section
->sh_size
, LONG_HEX
);
6979 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6980 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6984 print_vma (section
->sh_entsize
, LONG_HEX
);
6987 if (do_section_details
)
6988 fputs (" ", stdout
);
6990 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6992 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6994 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6995 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6998 print_vma (section
->sh_addralign
, DEC
);
7002 else if (do_section_details
)
7005 print_vma (section
->sh_addr
, LONG_HEX
);
7006 if ((long) section
->sh_offset
== section
->sh_offset
)
7007 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
7011 print_vma (section
->sh_offset
, LONG_HEX
);
7013 printf (" %u\n ", section
->sh_link
);
7014 print_vma (section
->sh_size
, LONG_HEX
);
7016 print_vma (section
->sh_entsize
, LONG_HEX
);
7018 printf (" %-16u %lu\n",
7020 (unsigned long) section
->sh_addralign
);
7025 print_vma (section
->sh_addr
, LONG_HEX
);
7026 if ((long) section
->sh_offset
== section
->sh_offset
)
7027 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
7031 print_vma (section
->sh_offset
, LONG_HEX
);
7034 print_vma (section
->sh_size
, LONG_HEX
);
7036 print_vma (section
->sh_entsize
, LONG_HEX
);
7038 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
7040 printf (" %2u %3u %lu\n",
7043 (unsigned long) section
->sh_addralign
);
7046 if (do_section_details
)
7048 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
7049 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
7051 /* Minimum section size is 12 bytes for 32-bit compression
7052 header + 12 bytes for compressed data header. */
7053 unsigned char buf
[24];
7055 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
7056 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
7057 sizeof (buf
), _("compression header")))
7059 Elf_Internal_Chdr chdr
;
7061 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
7062 printf (_(" [<corrupt>]\n"));
7065 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
7068 printf (_(" [<unknown>: 0x%x], "),
7070 print_vma (chdr
.ch_size
, LONG_HEX
);
7071 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
7078 if (!do_section_details
)
7080 /* The ordering of the letters shown here matches the ordering of the
7081 corresponding SHF_xxx values, and hence the order in which these
7082 letters will be displayed to the user. */
7083 printf (_("Key to Flags:\n\
7084 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
7085 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
7086 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
7087 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
7090 case ELFOSABI_FREEBSD
:
7091 printf (_("R (retain), "));
7094 printf (_("D (mbind), "));
7099 if (filedata
->file_header
.e_machine
== EM_X86_64
7100 || filedata
->file_header
.e_machine
== EM_L1OM
7101 || filedata
->file_header
.e_machine
== EM_K1OM
)
7102 printf (_("l (large), "));
7103 else if (filedata
->file_header
.e_machine
== EM_ARM
)
7104 printf (_("y (purecode), "));
7105 else if (filedata
->file_header
.e_machine
== EM_PPC
)
7106 printf (_("v (VLE), "));
7107 printf ("p (processor specific)\n");
7114 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
7115 Elf_Internal_Sym
**symtab
, unsigned long *nsyms
,
7116 char **strtab
, unsigned long *strtablen
)
7120 *symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, nsyms
);
7122 if (*symtab
== NULL
)
7125 if (symsec
->sh_link
!= 0)
7127 Elf_Internal_Shdr
*strsec
;
7129 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
7131 error (_("Bad sh_link in symbol table section\n"));
7138 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7140 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7141 1, strsec
->sh_size
, _("string table"));
7142 if (*strtab
== NULL
)
7149 *strtablen
= strsec
->sh_size
;
7155 get_group_flags (unsigned int flags
)
7157 static char buff
[128];
7161 else if (flags
== GRP_COMDAT
)
7164 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
7166 flags
& GRP_MASKOS
? _("<OS specific>") : "",
7167 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
7168 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
7169 ? _("<unknown>") : ""));
7175 process_section_groups (Filedata
* filedata
)
7177 Elf_Internal_Shdr
* section
;
7179 struct group
* group
;
7180 Elf_Internal_Shdr
* symtab_sec
;
7181 Elf_Internal_Shdr
* strtab_sec
;
7182 Elf_Internal_Sym
* symtab
;
7183 unsigned long num_syms
;
7187 /* Don't process section groups unless needed. */
7188 if (!do_unwind
&& !do_section_groups
)
7191 if (filedata
->file_header
.e_shnum
== 0)
7193 if (do_section_groups
)
7195 if (filedata
->is_separate
)
7196 printf (_("\nThere are no sections group in linked file '%s'.\n"),
7197 filedata
->file_name
);
7199 printf (_("\nThere are no section groups in this file.\n"));
7204 if (filedata
->section_headers
== NULL
)
7206 error (_("Section headers are not available!\n"));
7207 /* PR 13622: This can happen with a corrupt ELF header. */
7211 filedata
->section_headers_groups
7212 = (struct group
**) calloc (filedata
->file_header
.e_shnum
,
7213 sizeof (struct group
*));
7215 if (filedata
->section_headers_groups
== NULL
)
7217 error (_("Out of memory reading %u section group headers\n"),
7218 filedata
->file_header
.e_shnum
);
7222 /* Scan the sections for the group section. */
7223 filedata
->group_count
= 0;
7224 for (i
= 0, section
= filedata
->section_headers
;
7225 i
< filedata
->file_header
.e_shnum
;
7227 if (section
->sh_type
== SHT_GROUP
)
7228 filedata
->group_count
++;
7230 if (filedata
->group_count
== 0)
7232 if (do_section_groups
)
7234 if (filedata
->is_separate
)
7235 printf (_("\nThere are no section groups in linked file '%s'.\n"),
7236 filedata
->file_name
);
7238 printf (_("\nThere are no section groups in this file.\n"));
7244 filedata
->section_groups
= (struct group
*) calloc (filedata
->group_count
,
7245 sizeof (struct group
));
7247 if (filedata
->section_groups
== NULL
)
7249 error (_("Out of memory reading %lu groups\n"),
7250 (unsigned long) filedata
->group_count
);
7261 if (filedata
->is_separate
)
7262 printf (_("Section groups in linked file '%s'\n"), filedata
->file_name
);
7264 for (i
= 0, section
= filedata
->section_headers
, group
= filedata
->section_groups
;
7265 i
< filedata
->file_header
.e_shnum
;
7268 if (section
->sh_type
== SHT_GROUP
)
7270 const char * name
= printable_section_name (filedata
, section
);
7271 const char * group_name
;
7272 unsigned char * start
;
7273 unsigned char * indices
;
7274 unsigned int entry
, j
, size
;
7275 Elf_Internal_Shdr
* sec
;
7276 Elf_Internal_Sym
* sym
;
7278 /* Get the symbol table. */
7279 if (section
->sh_link
>= filedata
->file_header
.e_shnum
7280 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
7283 error (_("Bad sh_link in group section `%s'\n"), name
);
7287 if (symtab_sec
!= sec
)
7291 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
7296 error (_("Corrupt header in group section `%s'\n"), name
);
7300 if (section
->sh_info
>= num_syms
)
7302 error (_("Bad sh_info in group section `%s'\n"), name
);
7306 sym
= symtab
+ section
->sh_info
;
7308 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
7310 if (sym
->st_shndx
== 0
7311 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
7313 error (_("Bad sh_info in group section `%s'\n"), name
);
7317 group_name
= SECTION_NAME_PRINT (filedata
->section_headers
7326 /* Get the string table. */
7327 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
7335 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
7340 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
7341 1, strtab_sec
->sh_size
,
7343 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
7345 group_name
= sym
->st_name
< strtab_size
7346 ? strtab
+ sym
->st_name
: _("<corrupt>");
7349 /* PR 17531: file: loop. */
7350 if (section
->sh_entsize
> section
->sh_size
)
7352 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7353 printable_section_name (filedata
, section
),
7354 (unsigned long) section
->sh_entsize
,
7355 (unsigned long) section
->sh_size
);
7359 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
7360 1, section
->sh_size
,
7366 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
7367 entry
= byte_get (indices
, 4);
7370 if (do_section_groups
)
7372 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7373 get_group_flags (entry
), i
, name
, group_name
, size
);
7375 printf (_(" [Index] Name\n"));
7378 group
->group_index
= i
;
7380 for (j
= 0; j
< size
; j
++)
7382 struct group_list
* g
;
7384 entry
= byte_get (indices
, 4);
7387 if (entry
>= filedata
->file_header
.e_shnum
)
7389 static unsigned num_group_errors
= 0;
7391 if (num_group_errors
++ < 10)
7393 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7394 entry
, i
, filedata
->file_header
.e_shnum
- 1);
7395 if (num_group_errors
== 10)
7396 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7401 if (filedata
->section_headers_groups
[entry
] != NULL
)
7405 static unsigned num_errs
= 0;
7407 if (num_errs
++ < 10)
7409 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7411 filedata
->section_headers_groups
[entry
]->group_index
);
7413 warn (_("Further error messages about already contained group sections suppressed\n"));
7419 /* Intel C/C++ compiler may put section 0 in a
7420 section group. We just warn it the first time
7421 and ignore it afterwards. */
7422 static bool warned
= false;
7425 error (_("section 0 in group section [%5u]\n"),
7426 filedata
->section_headers_groups
[entry
]->group_index
);
7432 filedata
->section_headers_groups
[entry
] = group
;
7434 if (do_section_groups
)
7436 sec
= filedata
->section_headers
+ entry
;
7437 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7440 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7441 g
->section_index
= entry
;
7442 g
->next
= group
->root
;
7457 /* Data used to display dynamic fixups. */
7459 struct ia64_vms_dynfixup
7461 bfd_vma needed_ident
; /* Library ident number. */
7462 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7463 bfd_vma fixup_needed
; /* Index of the library. */
7464 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7465 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7468 /* Data used to display dynamic relocations. */
7470 struct ia64_vms_dynimgrela
7472 bfd_vma img_rela_cnt
; /* Number of relocations. */
7473 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7476 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7480 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7481 struct ia64_vms_dynfixup
* fixup
,
7482 const char * strtab
,
7483 unsigned int strtab_sz
)
7485 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7487 const char * lib_name
;
7489 imfs
= get_data (NULL
, filedata
,
7490 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
7491 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
7492 _("dynamic section image fixups"));
7496 if (fixup
->needed
< strtab_sz
)
7497 lib_name
= strtab
+ fixup
->needed
;
7500 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7501 (unsigned long) fixup
->needed
);
7505 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7506 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7508 (_("Seg Offset Type SymVec DataType\n"));
7510 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7515 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7516 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7517 type
= BYTE_GET (imfs
[i
].type
);
7518 rtype
= elf_ia64_reloc_type (type
);
7520 printf (" 0x%08x ", type
);
7522 printf (" %-32s ", rtype
);
7523 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7524 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7531 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7534 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7536 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7539 imrs
= get_data (NULL
, filedata
,
7540 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
7541 sizeof (*imrs
), imgrela
->img_rela_cnt
,
7542 _("dynamic section image relocations"));
7546 printf (_("\nImage relocs\n"));
7548 (_("Seg Offset Type Addend Seg Sym Off\n"));
7550 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7555 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7556 printf ("%08" BFD_VMA_FMT
"x ",
7557 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7558 type
= BYTE_GET (imrs
[i
].type
);
7559 rtype
= elf_ia64_reloc_type (type
);
7561 printf ("0x%08x ", type
);
7563 printf ("%-31s ", rtype
);
7564 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7565 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7566 printf ("%08" BFD_VMA_FMT
"x\n",
7567 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7574 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7577 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7579 struct ia64_vms_dynfixup fixup
;
7580 struct ia64_vms_dynimgrela imgrela
;
7581 Elf_Internal_Dyn
*entry
;
7582 bfd_vma strtab_off
= 0;
7583 bfd_vma strtab_sz
= 0;
7584 char *strtab
= NULL
;
7587 memset (&fixup
, 0, sizeof (fixup
));
7588 memset (&imgrela
, 0, sizeof (imgrela
));
7590 /* Note: the order of the entries is specified by the OpenVMS specs. */
7591 for (entry
= filedata
->dynamic_section
;
7592 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
7595 switch (entry
->d_tag
)
7597 case DT_IA_64_VMS_STRTAB_OFFSET
:
7598 strtab_off
= entry
->d_un
.d_val
;
7601 strtab_sz
= entry
->d_un
.d_val
;
7603 strtab
= get_data (NULL
, filedata
,
7604 filedata
->dynamic_addr
+ strtab_off
,
7605 1, strtab_sz
, _("dynamic string section"));
7610 case DT_IA_64_VMS_NEEDED_IDENT
:
7611 fixup
.needed_ident
= entry
->d_un
.d_val
;
7614 fixup
.needed
= entry
->d_un
.d_val
;
7616 case DT_IA_64_VMS_FIXUP_NEEDED
:
7617 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7619 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7620 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7622 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7623 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7624 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7627 case DT_IA_64_VMS_IMG_RELA_CNT
:
7628 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7630 case DT_IA_64_VMS_IMG_RELA_OFF
:
7631 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7632 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7653 dynamic_relocations
[] =
7655 { "REL", DT_REL
, DT_RELSZ
, false },
7656 { "RELA", DT_RELA
, DT_RELASZ
, true },
7657 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7660 /* Process the reloc section. */
7663 process_relocs (Filedata
* filedata
)
7665 unsigned long rel_size
;
7666 unsigned long rel_offset
;
7671 if (do_using_dynamic
)
7675 bool has_dynamic_reloc
;
7678 has_dynamic_reloc
= false;
7680 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7682 is_rela
= dynamic_relocations
[i
].rela
;
7683 name
= dynamic_relocations
[i
].name
;
7684 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
7685 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
7688 has_dynamic_reloc
= true;
7690 if (is_rela
== UNKNOWN
)
7692 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7693 switch (filedata
->dynamic_info
[DT_PLTREL
])
7706 if (filedata
->is_separate
)
7708 (_("\nIn linked file '%s' section '%s' at offset 0x%lx contains %ld bytes:\n"),
7709 filedata
->file_name
, name
, rel_offset
, rel_size
);
7712 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7713 name
, rel_offset
, rel_size
);
7715 dump_relocations (filedata
,
7716 offset_from_vma (filedata
, rel_offset
, rel_size
),
7718 filedata
->dynamic_symbols
,
7719 filedata
->num_dynamic_syms
,
7720 filedata
->dynamic_strings
,
7721 filedata
->dynamic_strings_length
,
7722 is_rela
, true /* is_dynamic */);
7726 if (is_ia64_vms (filedata
))
7727 if (process_ia64_vms_dynamic_relocs (filedata
))
7728 has_dynamic_reloc
= true;
7730 if (! has_dynamic_reloc
)
7732 if (filedata
->is_separate
)
7733 printf (_("\nThere are no dynamic relocations in linked file '%s'.\n"),
7734 filedata
->file_name
);
7736 printf (_("\nThere are no dynamic relocations in this file.\n"));
7741 Elf_Internal_Shdr
* section
;
7745 for (i
= 0, section
= filedata
->section_headers
;
7746 i
< filedata
->file_header
.e_shnum
;
7749 if ( section
->sh_type
!= SHT_RELA
7750 && section
->sh_type
!= SHT_REL
)
7753 rel_offset
= section
->sh_offset
;
7754 rel_size
= section
->sh_size
;
7759 unsigned long num_rela
;
7761 if (filedata
->is_separate
)
7762 printf (_("\nIn linked file '%s' relocation section "),
7763 filedata
->file_name
);
7765 printf (_("\nRelocation section "));
7767 if (filedata
->string_table
== NULL
)
7768 printf ("%d", section
->sh_name
);
7770 printf ("'%s'", printable_section_name (filedata
, section
));
7772 num_rela
= rel_size
/ section
->sh_entsize
;
7773 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7774 " at offset 0x%lx contains %lu entries:\n",
7776 rel_offset
, num_rela
);
7778 is_rela
= section
->sh_type
== SHT_RELA
;
7780 if (section
->sh_link
!= 0
7781 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7783 Elf_Internal_Shdr
* symsec
;
7784 Elf_Internal_Sym
* symtab
;
7785 unsigned long nsyms
;
7786 unsigned long strtablen
= 0;
7787 char * strtab
= NULL
;
7789 symsec
= filedata
->section_headers
+ section
->sh_link
;
7790 if (symsec
->sh_type
!= SHT_SYMTAB
7791 && symsec
->sh_type
!= SHT_DYNSYM
)
7794 if (!get_symtab (filedata
, symsec
,
7795 &symtab
, &nsyms
, &strtab
, &strtablen
))
7798 dump_relocations (filedata
, rel_offset
, rel_size
,
7799 symtab
, nsyms
, strtab
, strtablen
,
7801 symsec
->sh_type
== SHT_DYNSYM
);
7806 dump_relocations (filedata
, rel_offset
, rel_size
,
7807 NULL
, 0, NULL
, 0, is_rela
,
7808 false /* is_dynamic */);
7816 /* Users sometimes forget the -D option, so try to be helpful. */
7817 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7819 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
7821 if (filedata
->is_separate
)
7822 printf (_("\nThere are no static relocations in linked file '%s'."),
7823 filedata
->file_name
);
7825 printf (_("\nThere are no static relocations in this file."));
7826 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7831 if (i
== ARRAY_SIZE (dynamic_relocations
))
7833 if (filedata
->is_separate
)
7834 printf (_("\nThere are no relocations in linked file '%s'.\n"),
7835 filedata
->file_name
);
7837 printf (_("\nThere are no relocations in this file.\n"));
7845 /* An absolute address consists of a section and an offset. If the
7846 section is NULL, the offset itself is the address, otherwise, the
7847 address equals to LOAD_ADDRESS(section) + offset. */
7851 unsigned short section
;
7855 /* Find the nearest symbol at or below ADDR. Returns the symbol
7856 name, if found, and the offset from the symbol to ADDR. */
7859 find_symbol_for_address (Filedata
* filedata
,
7860 Elf_Internal_Sym
* symtab
,
7861 unsigned long nsyms
,
7862 const char * strtab
,
7863 unsigned long strtab_size
,
7864 struct absaddr addr
,
7865 const char ** symname
,
7868 bfd_vma dist
= 0x100000;
7869 Elf_Internal_Sym
* sym
;
7870 Elf_Internal_Sym
* beg
;
7871 Elf_Internal_Sym
* end
;
7872 Elf_Internal_Sym
* best
= NULL
;
7874 REMOVE_ARCH_BITS (addr
.offset
);
7876 end
= symtab
+ nsyms
;
7882 sym
= beg
+ (end
- beg
) / 2;
7884 value
= sym
->st_value
;
7885 REMOVE_ARCH_BITS (value
);
7887 if (sym
->st_name
!= 0
7888 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7889 && addr
.offset
>= value
7890 && addr
.offset
- value
< dist
)
7893 dist
= addr
.offset
- value
;
7898 if (addr
.offset
< value
)
7906 *symname
= (best
->st_name
>= strtab_size
7907 ? _("<corrupt>") : strtab
+ best
->st_name
);
7913 *offset
= addr
.offset
;
7916 static /* signed */ int
7917 symcmp (const void *p
, const void *q
)
7919 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7920 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7922 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7925 /* Process the unwind section. */
7927 #include "unwind-ia64.h"
7929 struct ia64_unw_table_entry
7931 struct absaddr start
;
7933 struct absaddr info
;
7936 struct ia64_unw_aux_info
7938 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7939 unsigned long table_len
; /* Length of unwind table. */
7940 unsigned char * info
; /* Unwind info. */
7941 unsigned long info_size
; /* Size of unwind info. */
7942 bfd_vma info_addr
; /* Starting address of unwind info. */
7943 bfd_vma seg_base
; /* Starting address of segment. */
7944 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7945 unsigned long nsyms
; /* Number of symbols. */
7946 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7947 unsigned long nfuns
; /* Number of entries in funtab. */
7948 char * strtab
; /* The string table. */
7949 unsigned long strtab_size
; /* Size of string table. */
7953 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7955 struct ia64_unw_table_entry
* tp
;
7956 unsigned long j
, nfuns
;
7960 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7961 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7962 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7963 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7965 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7967 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7971 const unsigned char * dp
;
7972 const unsigned char * head
;
7973 const unsigned char * end
;
7974 const char * procname
;
7976 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7977 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7979 fputs ("\n<", stdout
);
7983 fputs (procname
, stdout
);
7986 printf ("+%lx", (unsigned long) offset
);
7989 fputs (">: [", stdout
);
7990 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7991 fputc ('-', stdout
);
7992 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7993 printf ("], info at +0x%lx\n",
7994 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7996 /* PR 17531: file: 86232b32. */
7997 if (aux
->info
== NULL
)
8000 offset
= tp
->info
.offset
;
8001 if (tp
->info
.section
)
8003 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
8005 warn (_("Invalid section %u in table entry %ld\n"),
8006 tp
->info
.section
, (long) (tp
- aux
->table
));
8010 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
8012 offset
-= aux
->info_addr
;
8013 /* PR 17531: file: 0997b4d1. */
8014 if (offset
>= aux
->info_size
8015 || aux
->info_size
- offset
< 8)
8017 warn (_("Invalid offset %lx in table entry %ld\n"),
8018 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
8023 head
= aux
->info
+ offset
;
8024 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
8026 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
8027 (unsigned) UNW_VER (stamp
),
8028 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
8029 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
8030 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
8031 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
8033 if (UNW_VER (stamp
) != 1)
8035 printf (_("\tUnknown version.\n"));
8040 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
8041 /* PR 17531: file: 16ceda89. */
8042 if (end
> aux
->info
+ aux
->info_size
)
8043 end
= aux
->info
+ aux
->info_size
;
8044 for (dp
= head
+ 8; dp
< end
;)
8045 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
8054 slurp_ia64_unwind_table (Filedata
* filedata
,
8055 struct ia64_unw_aux_info
* aux
,
8056 Elf_Internal_Shdr
* sec
)
8058 unsigned long size
, nrelas
, i
;
8059 Elf_Internal_Phdr
* seg
;
8060 struct ia64_unw_table_entry
* tep
;
8061 Elf_Internal_Shdr
* relsec
;
8062 Elf_Internal_Rela
* rela
;
8063 Elf_Internal_Rela
* rp
;
8064 unsigned char * table
;
8066 Elf_Internal_Sym
* sym
;
8067 const char * relname
;
8071 /* First, find the starting address of the segment that includes
8074 if (filedata
->file_header
.e_phnum
)
8076 if (! get_program_headers (filedata
))
8079 for (seg
= filedata
->program_headers
;
8080 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8083 if (seg
->p_type
!= PT_LOAD
)
8086 if (sec
->sh_addr
>= seg
->p_vaddr
8087 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8089 aux
->seg_base
= seg
->p_vaddr
;
8095 /* Second, build the unwind table from the contents of the unwind section: */
8096 size
= sec
->sh_size
;
8097 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8102 aux
->table_len
= size
/ (3 * eh_addr_size
);
8103 aux
->table
= (struct ia64_unw_table_entry
*)
8104 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
8107 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
8109 tep
->start
.section
= SHN_UNDEF
;
8110 tep
->end
.section
= SHN_UNDEF
;
8111 tep
->info
.section
= SHN_UNDEF
;
8112 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8113 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8114 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8115 tep
->start
.offset
+= aux
->seg_base
;
8116 tep
->end
.offset
+= aux
->seg_base
;
8117 tep
->info
.offset
+= aux
->seg_base
;
8121 /* Third, apply any relocations to the unwind table: */
8122 for (relsec
= filedata
->section_headers
;
8123 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8126 if (relsec
->sh_type
!= SHT_RELA
8127 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8128 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8131 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8140 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8142 unsigned int sym_ndx
;
8143 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8144 relname
= elf_ia64_reloc_type (r_type
);
8146 /* PR 17531: file: 9fa67536. */
8147 if (relname
== NULL
)
8149 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8153 if (! startswith (relname
, "R_IA64_SEGREL"))
8155 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8159 i
= rp
->r_offset
/ (3 * eh_addr_size
);
8161 /* PR 17531: file: 5bc8d9bf. */
8162 if (i
>= aux
->table_len
)
8164 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8168 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8169 if (sym_ndx
>= aux
->nsyms
)
8171 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8175 sym
= aux
->symtab
+ sym_ndx
;
8177 switch (rp
->r_offset
/ eh_addr_size
% 3)
8180 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8181 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
8184 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8185 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
8188 aux
->table
[i
].info
.section
= sym
->st_shndx
;
8189 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
8203 ia64_process_unwind (Filedata
* filedata
)
8205 Elf_Internal_Shdr
* sec
;
8206 Elf_Internal_Shdr
* unwsec
= NULL
;
8207 unsigned long i
, unwcount
= 0, unwstart
= 0;
8208 struct ia64_unw_aux_info aux
;
8211 memset (& aux
, 0, sizeof (aux
));
8213 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8215 if (sec
->sh_type
== SHT_SYMTAB
)
8219 error (_("Multiple symbol tables encountered\n"));
8225 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8226 &aux
.strtab
, &aux
.strtab_size
))
8229 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8234 printf (_("\nThere are no unwind sections in this file.\n"));
8236 while (unwcount
-- > 0)
8241 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
8242 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8243 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8248 /* We have already counted the number of SHT_IA64_UNWIND
8249 sections so the loop above should never fail. */
8250 assert (unwsec
!= NULL
);
8253 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
8255 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
8257 /* We need to find which section group it is in. */
8258 struct group_list
* g
;
8260 if (filedata
->section_headers_groups
== NULL
8261 || filedata
->section_headers_groups
[i
] == NULL
)
8262 i
= filedata
->file_header
.e_shnum
;
8265 g
= filedata
->section_headers_groups
[i
]->root
;
8267 for (; g
!= NULL
; g
= g
->next
)
8269 sec
= filedata
->section_headers
+ g
->section_index
;
8271 if (SECTION_NAME_VALID (sec
)
8272 && streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
8277 i
= filedata
->file_header
.e_shnum
;
8280 else if (SECTION_NAME_VALID (unwsec
)
8281 && startswith (SECTION_NAME (unwsec
),
8282 ELF_STRING_ia64_unwind_once
))
8284 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
8285 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
8286 suffix
= SECTION_NAME (unwsec
) + len
;
8287 for (i
= 0, sec
= filedata
->section_headers
;
8288 i
< filedata
->file_header
.e_shnum
;
8290 if (SECTION_NAME_VALID (sec
)
8291 && startswith (SECTION_NAME (sec
),
8292 ELF_STRING_ia64_unwind_info_once
)
8293 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8298 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
8299 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
8300 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
8301 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
8303 if (SECTION_NAME_VALID (unwsec
)
8304 && startswith (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
))
8305 suffix
= SECTION_NAME (unwsec
) + len
;
8306 for (i
= 0, sec
= filedata
->section_headers
;
8307 i
< filedata
->file_header
.e_shnum
;
8309 if (SECTION_NAME_VALID (sec
)
8310 && startswith (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
)
8311 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8315 if (i
== filedata
->file_header
.e_shnum
)
8317 printf (_("\nCould not find unwind info section for "));
8319 if (filedata
->string_table
== NULL
)
8320 printf ("%d", unwsec
->sh_name
);
8322 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8326 aux
.info_addr
= sec
->sh_addr
;
8327 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
8330 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
8332 printf (_("\nUnwind section "));
8334 if (filedata
->string_table
== NULL
)
8335 printf ("%d", unwsec
->sh_name
);
8337 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8339 printf (_(" at offset 0x%lx contains %lu entries:\n"),
8340 (unsigned long) unwsec
->sh_offset
,
8341 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
8343 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
8344 && aux
.table_len
> 0)
8345 dump_ia64_unwind (filedata
, & aux
);
8347 free ((char *) aux
.table
);
8348 free ((char *) aux
.info
);
8355 free ((char *) aux
.strtab
);
8360 struct hppa_unw_table_entry
8362 struct absaddr start
;
8364 unsigned int Cannot_unwind
:1; /* 0 */
8365 unsigned int Millicode
:1; /* 1 */
8366 unsigned int Millicode_save_sr0
:1; /* 2 */
8367 unsigned int Region_description
:2; /* 3..4 */
8368 unsigned int reserved1
:1; /* 5 */
8369 unsigned int Entry_SR
:1; /* 6 */
8370 unsigned int Entry_FR
:4; /* Number saved 7..10 */
8371 unsigned int Entry_GR
:5; /* Number saved 11..15 */
8372 unsigned int Args_stored
:1; /* 16 */
8373 unsigned int Variable_Frame
:1; /* 17 */
8374 unsigned int Separate_Package_Body
:1; /* 18 */
8375 unsigned int Frame_Extension_Millicode
:1; /* 19 */
8376 unsigned int Stack_Overflow_Check
:1; /* 20 */
8377 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
8378 unsigned int Ada_Region
:1; /* 22 */
8379 unsigned int cxx_info
:1; /* 23 */
8380 unsigned int cxx_try_catch
:1; /* 24 */
8381 unsigned int sched_entry_seq
:1; /* 25 */
8382 unsigned int reserved2
:1; /* 26 */
8383 unsigned int Save_SP
:1; /* 27 */
8384 unsigned int Save_RP
:1; /* 28 */
8385 unsigned int Save_MRP_in_frame
:1; /* 29 */
8386 unsigned int extn_ptr_defined
:1; /* 30 */
8387 unsigned int Cleanup_defined
:1; /* 31 */
8389 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
8390 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
8391 unsigned int Large_frame
:1; /* 2 */
8392 unsigned int Pseudo_SP_Set
:1; /* 3 */
8393 unsigned int reserved4
:1; /* 4 */
8394 unsigned int Total_frame_size
:27; /* 5..31 */
8397 struct hppa_unw_aux_info
8399 struct hppa_unw_table_entry
* table
; /* Unwind table. */
8400 unsigned long table_len
; /* Length of unwind table. */
8401 bfd_vma seg_base
; /* Starting address of segment. */
8402 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8403 unsigned long nsyms
; /* Number of symbols. */
8404 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8405 unsigned long nfuns
; /* Number of entries in funtab. */
8406 char * strtab
; /* The string table. */
8407 unsigned long strtab_size
; /* Size of string table. */
8411 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8413 struct hppa_unw_table_entry
* tp
;
8414 unsigned long j
, nfuns
;
8417 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8418 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8419 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8420 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8422 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8424 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8427 const char * procname
;
8429 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8430 aux
->strtab_size
, tp
->start
, &procname
,
8433 fputs ("\n<", stdout
);
8437 fputs (procname
, stdout
);
8440 printf ("+%lx", (unsigned long) offset
);
8443 fputs (">: [", stdout
);
8444 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8445 fputc ('-', stdout
);
8446 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8449 #define PF(_m) if (tp->_m) printf (#_m " ");
8450 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8453 PF(Millicode_save_sr0
);
8454 /* PV(Region_description); */
8460 PF(Separate_Package_Body
);
8461 PF(Frame_Extension_Millicode
);
8462 PF(Stack_Overflow_Check
);
8463 PF(Two_Instruction_SP_Increment
);
8467 PF(sched_entry_seq
);
8470 PF(Save_MRP_in_frame
);
8471 PF(extn_ptr_defined
);
8472 PF(Cleanup_defined
);
8473 PF(MPE_XL_interrupt_marker
);
8474 PF(HP_UX_interrupt_marker
);
8477 PV(Total_frame_size
);
8490 slurp_hppa_unwind_table (Filedata
* filedata
,
8491 struct hppa_unw_aux_info
* aux
,
8492 Elf_Internal_Shdr
* sec
)
8494 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8495 Elf_Internal_Phdr
* seg
;
8496 struct hppa_unw_table_entry
* tep
;
8497 Elf_Internal_Shdr
* relsec
;
8498 Elf_Internal_Rela
* rela
;
8499 Elf_Internal_Rela
* rp
;
8500 unsigned char * table
;
8502 Elf_Internal_Sym
* sym
;
8503 const char * relname
;
8505 /* First, find the starting address of the segment that includes
8507 if (filedata
->file_header
.e_phnum
)
8509 if (! get_program_headers (filedata
))
8512 for (seg
= filedata
->program_headers
;
8513 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8516 if (seg
->p_type
!= PT_LOAD
)
8519 if (sec
->sh_addr
>= seg
->p_vaddr
8520 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8522 aux
->seg_base
= seg
->p_vaddr
;
8528 /* Second, build the unwind table from the contents of the unwind
8530 size
= sec
->sh_size
;
8531 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8537 nentries
= size
/ unw_ent_size
;
8538 size
= unw_ent_size
* nentries
;
8540 aux
->table_len
= nentries
;
8541 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8542 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8544 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8546 unsigned int tmp1
, tmp2
;
8548 tep
->start
.section
= SHN_UNDEF
;
8549 tep
->end
.section
= SHN_UNDEF
;
8551 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8552 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8553 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8554 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8556 tep
->start
.offset
+= aux
->seg_base
;
8557 tep
->end
.offset
+= aux
->seg_base
;
8559 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8560 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8561 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8562 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8563 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8564 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8565 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8566 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8567 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8568 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8569 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8570 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8571 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8572 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8573 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8574 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8575 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8576 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8577 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8578 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8579 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8580 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8581 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8582 tep
->Cleanup_defined
= tmp1
& 0x1;
8584 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8585 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8586 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8587 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8588 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8589 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8593 /* Third, apply any relocations to the unwind table. */
8594 for (relsec
= filedata
->section_headers
;
8595 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8598 if (relsec
->sh_type
!= SHT_RELA
8599 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8600 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8603 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8607 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8609 unsigned int sym_ndx
;
8610 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8611 relname
= elf_hppa_reloc_type (r_type
);
8613 if (relname
== NULL
)
8615 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8619 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8620 if (! startswith (relname
, "R_PARISC_SEGREL"))
8622 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8626 i
= rp
->r_offset
/ unw_ent_size
;
8627 if (i
>= aux
->table_len
)
8629 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8633 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8634 if (sym_ndx
>= aux
->nsyms
)
8636 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8640 sym
= aux
->symtab
+ sym_ndx
;
8642 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8645 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8646 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8649 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8650 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8664 hppa_process_unwind (Filedata
* filedata
)
8666 struct hppa_unw_aux_info aux
;
8667 Elf_Internal_Shdr
* unwsec
= NULL
;
8668 Elf_Internal_Shdr
* sec
;
8672 if (filedata
->string_table
== NULL
)
8675 memset (& aux
, 0, sizeof (aux
));
8677 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8679 if (sec
->sh_type
== SHT_SYMTAB
)
8683 error (_("Multiple symbol tables encountered\n"));
8689 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8690 &aux
.strtab
, &aux
.strtab_size
))
8693 else if (SECTION_NAME_VALID (sec
)
8694 && streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8699 printf (_("\nThere are no unwind sections in this file.\n"));
8701 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8703 if (SECTION_NAME_VALID (sec
)
8704 && streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8706 unsigned long num_unwind
= sec
->sh_size
/ 16;
8708 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8709 "contains %lu entry:\n",
8710 "\nUnwind section '%s' at offset 0x%lx "
8711 "contains %lu entries:\n",
8713 printable_section_name (filedata
, sec
),
8714 (unsigned long) sec
->sh_offset
,
8717 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8720 if (res
&& aux
.table_len
> 0)
8722 if (! dump_hppa_unwind (filedata
, &aux
))
8726 free ((char *) aux
.table
);
8732 free ((char *) aux
.strtab
);
8739 unsigned char * data
; /* The unwind data. */
8740 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8741 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8742 unsigned long nrelas
; /* The number of relocations. */
8743 unsigned int rel_type
; /* REL or RELA ? */
8744 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8747 struct arm_unw_aux_info
8749 Filedata
* filedata
; /* The file containing the unwind sections. */
8750 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8751 unsigned long nsyms
; /* Number of symbols. */
8752 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8753 unsigned long nfuns
; /* Number of these symbols. */
8754 char * strtab
; /* The file's string table. */
8755 unsigned long strtab_size
; /* Size of string table. */
8759 arm_print_vma_and_name (Filedata
* filedata
,
8760 struct arm_unw_aux_info
* aux
,
8762 struct absaddr addr
)
8764 const char *procname
;
8767 if (addr
.section
== SHN_UNDEF
)
8770 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8771 aux
->strtab_size
, addr
, &procname
,
8774 print_vma (fn
, PREFIX_HEX
);
8778 fputs (" <", stdout
);
8779 fputs (procname
, stdout
);
8782 printf ("+0x%lx", (unsigned long) sym_offset
);
8783 fputc ('>', stdout
);
8790 arm_free_section (struct arm_section
*arm_sec
)
8792 free (arm_sec
->data
);
8793 free (arm_sec
->rela
);
8796 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8797 cached section and install SEC instead.
8798 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8799 and return its valued in * WORDP, relocating if necessary.
8800 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8801 relocation's offset in ADDR.
8802 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8803 into the string table of the symbol associated with the reloc. If no
8804 reloc was applied store -1 there.
8805 5) Return TRUE upon success, FALSE otherwise. */
8808 get_unwind_section_word (Filedata
* filedata
,
8809 struct arm_unw_aux_info
* aux
,
8810 struct arm_section
* arm_sec
,
8811 Elf_Internal_Shdr
* sec
,
8812 bfd_vma word_offset
,
8813 unsigned int * wordp
,
8814 struct absaddr
* addr
,
8817 Elf_Internal_Rela
*rp
;
8818 Elf_Internal_Sym
*sym
;
8819 const char * relname
;
8823 if (sec
== NULL
|| arm_sec
== NULL
)
8826 addr
->section
= SHN_UNDEF
;
8829 if (sym_name
!= NULL
)
8830 *sym_name
= (bfd_vma
) -1;
8832 /* If necessary, update the section cache. */
8833 if (sec
!= arm_sec
->sec
)
8835 Elf_Internal_Shdr
*relsec
;
8837 arm_free_section (arm_sec
);
8840 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8841 sec
->sh_size
, _("unwind data"));
8842 arm_sec
->rela
= NULL
;
8843 arm_sec
->nrelas
= 0;
8845 for (relsec
= filedata
->section_headers
;
8846 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8849 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8850 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8851 /* PR 15745: Check the section type as well. */
8852 || (relsec
->sh_type
!= SHT_REL
8853 && relsec
->sh_type
!= SHT_RELA
))
8856 arm_sec
->rel_type
= relsec
->sh_type
;
8857 if (relsec
->sh_type
== SHT_REL
)
8859 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8861 & arm_sec
->rela
, & arm_sec
->nrelas
))
8864 else /* relsec->sh_type == SHT_RELA */
8866 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8868 & arm_sec
->rela
, & arm_sec
->nrelas
))
8874 arm_sec
->next_rela
= arm_sec
->rela
;
8877 /* If there is no unwind data we can do nothing. */
8878 if (arm_sec
->data
== NULL
)
8881 /* If the offset is invalid then fail. */
8882 if (/* PR 21343 *//* PR 18879 */
8884 || word_offset
> (sec
->sh_size
- 4)
8885 || ((bfd_signed_vma
) word_offset
) < 0)
8888 /* Get the word at the required offset. */
8889 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8891 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8892 if (arm_sec
->rela
== NULL
)
8898 /* Look through the relocs to find the one that applies to the provided offset. */
8900 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8902 bfd_vma prelval
, offset
;
8904 if (rp
->r_offset
> word_offset
&& !wrapped
)
8909 if (rp
->r_offset
> word_offset
)
8912 if (rp
->r_offset
& 3)
8914 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8915 (unsigned long) rp
->r_offset
);
8919 if (rp
->r_offset
< word_offset
)
8922 /* PR 17531: file: 027-161405-0.004 */
8923 if (aux
->symtab
== NULL
)
8926 if (arm_sec
->rel_type
== SHT_REL
)
8928 offset
= word
& 0x7fffffff;
8929 if (offset
& 0x40000000)
8930 offset
|= ~ (bfd_vma
) 0x7fffffff;
8932 else if (arm_sec
->rel_type
== SHT_RELA
)
8933 offset
= rp
->r_addend
;
8936 error (_("Unknown section relocation type %d encountered\n"),
8941 /* PR 17531 file: 027-1241568-0.004. */
8942 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8944 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8945 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8949 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8950 offset
+= sym
->st_value
;
8951 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8953 /* Check that we are processing the expected reloc type. */
8954 if (filedata
->file_header
.e_machine
== EM_ARM
)
8956 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8957 if (relname
== NULL
)
8959 warn (_("Skipping unknown ARM relocation type: %d\n"),
8960 (int) ELF32_R_TYPE (rp
->r_info
));
8964 if (streq (relname
, "R_ARM_NONE"))
8967 if (! streq (relname
, "R_ARM_PREL31"))
8969 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8973 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8975 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8976 if (relname
== NULL
)
8978 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8979 (int) ELF32_R_TYPE (rp
->r_info
));
8983 if (streq (relname
, "R_C6000_NONE"))
8986 if (! streq (relname
, "R_C6000_PREL31"))
8988 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8996 /* This function currently only supports ARM and TI unwinders. */
8997 warn (_("Only TI and ARM unwinders are currently supported\n"));
9001 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
9002 addr
->section
= sym
->st_shndx
;
9003 addr
->offset
= offset
;
9006 * sym_name
= sym
->st_name
;
9011 arm_sec
->next_rela
= rp
;
9016 static const char *tic6x_unwind_regnames
[16] =
9018 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
9019 "A14", "A13", "A12", "A11", "A10",
9020 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
9024 decode_tic6x_unwind_regmask (unsigned int mask
)
9028 for (i
= 12; mask
; mask
>>= 1, i
--)
9032 fputs (tic6x_unwind_regnames
[i
], stdout
);
9034 fputs (", ", stdout
);
9040 if (remaining == 0 && more_words) \
9043 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
9044 data_offset, & word, & addr, NULL)) \
9050 #define GET_OP(OP) \
9055 (OP) = word >> 24; \
9060 printf (_("[Truncated opcode]\n")); \
9063 printf ("0x%02x ", OP)
9066 decode_arm_unwind_bytecode (Filedata
* filedata
,
9067 struct arm_unw_aux_info
* aux
,
9069 unsigned int remaining
,
9070 unsigned int more_words
,
9071 bfd_vma data_offset
,
9072 Elf_Internal_Shdr
* data_sec
,
9073 struct arm_section
* data_arm_sec
)
9075 struct absaddr addr
;
9078 /* Decode the unwinding instructions. */
9081 unsigned int op
, op2
;
9090 printf (" 0x%02x ", op
);
9092 if ((op
& 0xc0) == 0x00)
9094 int offset
= ((op
& 0x3f) << 2) + 4;
9096 printf (" vsp = vsp + %d", offset
);
9098 else if ((op
& 0xc0) == 0x40)
9100 int offset
= ((op
& 0x3f) << 2) + 4;
9102 printf (" vsp = vsp - %d", offset
);
9104 else if ((op
& 0xf0) == 0x80)
9107 if (op
== 0x80 && op2
== 0)
9108 printf (_("Refuse to unwind"));
9111 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
9116 for (i
= 0; i
< 12; i
++)
9117 if (mask
& (1 << i
))
9123 printf ("r%d", 4 + i
);
9128 else if ((op
& 0xf0) == 0x90)
9130 if (op
== 0x9d || op
== 0x9f)
9131 printf (_(" [Reserved]"));
9133 printf (" vsp = r%d", op
& 0x0f);
9135 else if ((op
& 0xf0) == 0xa0)
9137 int end
= 4 + (op
& 0x07);
9142 for (i
= 4; i
<= end
; i
++)
9158 else if (op
== 0xb0)
9159 printf (_(" finish"));
9160 else if (op
== 0xb1)
9163 if (op2
== 0 || (op2
& 0xf0) != 0)
9164 printf (_("[Spare]"));
9167 unsigned int mask
= op2
& 0x0f;
9172 for (i
= 0; i
< 12; i
++)
9173 if (mask
& (1 << i
))
9184 else if (op
== 0xb2)
9186 unsigned char buf
[9];
9187 unsigned int i
, len
;
9188 unsigned long offset
;
9190 for (i
= 0; i
< sizeof (buf
); i
++)
9193 if ((buf
[i
] & 0x80) == 0)
9196 if (i
== sizeof (buf
))
9198 error (_("corrupt change to vsp\n"));
9203 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
9204 assert (len
== i
+ 1);
9205 offset
= offset
* 4 + 0x204;
9206 printf ("vsp = vsp + %ld", offset
);
9209 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
9211 unsigned int first
, last
;
9218 printf ("pop {D%d", first
);
9220 printf ("-D%d", first
+ last
);
9223 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
9225 unsigned int count
= op
& 0x07;
9229 printf ("-D%d", 8 + count
);
9232 else if (op
>= 0xc0 && op
<= 0xc5)
9234 unsigned int count
= op
& 0x07;
9236 printf (" pop {wR10");
9238 printf ("-wR%d", 10 + count
);
9241 else if (op
== 0xc6)
9243 unsigned int first
, last
;
9248 printf ("pop {wR%d", first
);
9250 printf ("-wR%d", first
+ last
);
9253 else if (op
== 0xc7)
9256 if (op2
== 0 || (op2
& 0xf0) != 0)
9257 printf (_("[Spare]"));
9260 unsigned int mask
= op2
& 0x0f;
9265 for (i
= 0; i
< 4; i
++)
9266 if (mask
& (1 << i
))
9272 printf ("wCGR%d", i
);
9279 printf (_(" [unsupported opcode]"));
9290 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
9291 struct arm_unw_aux_info
* aux
,
9293 unsigned int remaining
,
9294 unsigned int more_words
,
9295 bfd_vma data_offset
,
9296 Elf_Internal_Shdr
* data_sec
,
9297 struct arm_section
* data_arm_sec
)
9299 struct absaddr addr
;
9301 /* Decode the unwinding instructions. */
9304 unsigned int op
, op2
;
9313 printf (" 0x%02x ", op
);
9315 if ((op
& 0xc0) == 0x00)
9317 int offset
= ((op
& 0x3f) << 3) + 8;
9318 printf (" sp = sp + %d", offset
);
9320 else if ((op
& 0xc0) == 0x80)
9323 if (op
== 0x80 && op2
== 0)
9324 printf (_("Refuse to unwind"));
9327 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
9329 printf ("pop compact {");
9333 decode_tic6x_unwind_regmask (mask
);
9337 else if ((op
& 0xf0) == 0xc0)
9345 unsigned int offset
;
9349 /* Scan entire instruction first so that GET_OP output is not
9350 interleaved with disassembly. */
9352 for (i
= 0; nregs
< (op
& 0xf); i
++)
9358 regpos
[nregs
].offset
= i
* 2;
9359 regpos
[nregs
].reg
= reg
;
9366 regpos
[nregs
].offset
= i
* 2 + 1;
9367 regpos
[nregs
].reg
= reg
;
9372 printf (_("pop frame {"));
9375 printf (_("*corrupt* - no registers specified"));
9380 for (i
= i
* 2; i
> 0; i
--)
9382 if (regpos
[reg
].offset
== i
- 1)
9384 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
9391 fputs (name
, stdout
);
9399 else if (op
== 0xd0)
9400 printf (" MOV FP, SP");
9401 else if (op
== 0xd1)
9402 printf (" __c6xabi_pop_rts");
9403 else if (op
== 0xd2)
9405 unsigned char buf
[9];
9406 unsigned int i
, len
;
9407 unsigned long offset
;
9409 for (i
= 0; i
< sizeof (buf
); i
++)
9412 if ((buf
[i
] & 0x80) == 0)
9415 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9416 if (i
== sizeof (buf
))
9418 warn (_("Corrupt stack pointer adjustment detected\n"));
9422 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
9423 assert (len
== i
+ 1);
9424 offset
= offset
* 8 + 0x408;
9425 printf (_("sp = sp + %ld"), offset
);
9427 else if ((op
& 0xf0) == 0xe0)
9429 if ((op
& 0x0f) == 7)
9432 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9436 printf (_(" [unsupported opcode]"));
9445 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9449 offset
= word
& 0x7fffffff;
9450 if (offset
& 0x40000000)
9451 offset
|= ~ (bfd_vma
) 0x7fffffff;
9453 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9456 return offset
+ where
;
9460 decode_arm_unwind (Filedata
* filedata
,
9461 struct arm_unw_aux_info
* aux
,
9463 unsigned int remaining
,
9464 bfd_vma data_offset
,
9465 Elf_Internal_Shdr
* data_sec
,
9466 struct arm_section
* data_arm_sec
)
9469 unsigned int more_words
= 0;
9470 struct absaddr addr
;
9471 bfd_vma sym_name
= (bfd_vma
) -1;
9476 /* Fetch the first word.
9477 Note - when decoding an object file the address extracted
9478 here will always be 0. So we also pass in the sym_name
9479 parameter so that we can find the symbol associated with
9480 the personality routine. */
9481 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9482 & word
, & addr
, & sym_name
))
9489 addr
.section
= SHN_UNDEF
;
9493 if ((word
& 0x80000000) == 0)
9495 /* Expand prel31 for personality routine. */
9497 const char *procname
;
9499 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9500 printf (_(" Personality routine: "));
9502 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9503 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9505 procname
= aux
->strtab
+ sym_name
;
9506 print_vma (fn
, PREFIX_HEX
);
9509 fputs (" <", stdout
);
9510 fputs (procname
, stdout
);
9511 fputc ('>', stdout
);
9515 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9516 fputc ('\n', stdout
);
9518 /* The GCC personality routines use the standard compact
9519 encoding, starting with one byte giving the number of
9521 if (procname
!= NULL
9522 && (startswith (procname
, "__gcc_personality_v0")
9523 || startswith (procname
, "__gxx_personality_v0")
9524 || startswith (procname
, "__gcj_personality_v0")
9525 || startswith (procname
, "__gnu_objc_personality_v0")))
9532 printf (_(" [Truncated data]\n"));
9535 more_words
= word
>> 24;
9545 /* ARM EHABI Section 6.3:
9547 An exception-handling table entry for the compact model looks like:
9551 1 0 index Data for personalityRoutine[index] */
9553 if (filedata
->file_header
.e_machine
== EM_ARM
9554 && (word
& 0x70000000))
9556 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9560 per_index
= (word
>> 24) & 0x7f;
9561 printf (_(" Compact model index: %d\n"), per_index
);
9568 else if (per_index
< 3)
9570 more_words
= (word
>> 16) & 0xff;
9576 switch (filedata
->file_header
.e_machine
)
9581 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9582 data_offset
, data_sec
, data_arm_sec
))
9587 warn (_("Unknown ARM compact model index encountered\n"));
9588 printf (_(" [reserved]\n"));
9596 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9597 data_offset
, data_sec
, data_arm_sec
))
9600 else if (per_index
< 5)
9602 if (((word
>> 17) & 0x7f) == 0x7f)
9603 printf (_(" Restore stack from frame pointer\n"));
9605 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9606 printf (_(" Registers restored: "));
9608 printf (" (compact) ");
9609 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9611 printf (_(" Return register: %s\n"),
9612 tic6x_unwind_regnames
[word
& 0xf]);
9615 printf (_(" [reserved (%d)]\n"), per_index
);
9619 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9620 filedata
->file_header
.e_machine
);
9624 /* Decode the descriptors. Not implemented. */
9630 dump_arm_unwind (Filedata
* filedata
,
9631 struct arm_unw_aux_info
* aux
,
9632 Elf_Internal_Shdr
* exidx_sec
)
9634 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9635 unsigned int i
, exidx_len
;
9636 unsigned long j
, nfuns
;
9639 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9640 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9641 exidx_len
= exidx_sec
->sh_size
/ 8;
9643 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9644 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9645 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9646 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9648 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9650 for (i
= 0; i
< exidx_len
; i
++)
9652 unsigned int exidx_fn
, exidx_entry
;
9653 struct absaddr fn_addr
, entry_addr
;
9656 fputc ('\n', stdout
);
9658 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9659 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9660 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9661 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9664 arm_free_section (& exidx_arm_sec
);
9665 arm_free_section (& extab_arm_sec
);
9669 /* ARM EHABI, Section 5:
9670 An index table entry consists of 2 words.
9671 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9672 if (exidx_fn
& 0x80000000)
9674 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9678 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9680 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9681 fputs (": ", stdout
);
9683 if (exidx_entry
== 1)
9685 print_vma (exidx_entry
, PREFIX_HEX
);
9686 fputs (" [cantunwind]\n", stdout
);
9688 else if (exidx_entry
& 0x80000000)
9690 print_vma (exidx_entry
, PREFIX_HEX
);
9691 fputc ('\n', stdout
);
9692 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9696 bfd_vma table
, table_offset
= 0;
9697 Elf_Internal_Shdr
*table_sec
;
9699 fputs ("@", stdout
);
9700 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9701 print_vma (table
, PREFIX_HEX
);
9704 /* Locate the matching .ARM.extab. */
9705 if (entry_addr
.section
!= SHN_UNDEF
9706 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9708 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9709 table_offset
= entry_addr
.offset
;
9711 if (table_offset
> table_sec
->sh_size
9712 || ((bfd_signed_vma
) table_offset
) < 0)
9714 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9715 (unsigned long) table_offset
,
9716 printable_section_name (filedata
, table_sec
));
9723 table_sec
= find_section_by_address (filedata
, table
);
9724 if (table_sec
!= NULL
)
9725 table_offset
= table
- table_sec
->sh_addr
;
9728 if (table_sec
== NULL
)
9730 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9731 (unsigned long) table
);
9736 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9745 arm_free_section (&exidx_arm_sec
);
9746 arm_free_section (&extab_arm_sec
);
9751 /* Used for both ARM and C6X unwinding tables. */
9754 arm_process_unwind (Filedata
* filedata
)
9756 struct arm_unw_aux_info aux
;
9757 Elf_Internal_Shdr
*unwsec
= NULL
;
9758 Elf_Internal_Shdr
*sec
;
9760 unsigned int sec_type
;
9763 switch (filedata
->file_header
.e_machine
)
9766 sec_type
= SHT_ARM_EXIDX
;
9770 sec_type
= SHT_C6000_UNWIND
;
9774 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9775 filedata
->file_header
.e_machine
);
9779 if (filedata
->string_table
== NULL
)
9782 memset (& aux
, 0, sizeof (aux
));
9783 aux
.filedata
= filedata
;
9785 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9787 if (sec
->sh_type
== SHT_SYMTAB
)
9791 error (_("Multiple symbol tables encountered\n"));
9797 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9798 &aux
.strtab
, &aux
.strtab_size
))
9801 else if (sec
->sh_type
== sec_type
)
9806 printf (_("\nThere are no unwind sections in this file.\n"));
9808 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9810 if (sec
->sh_type
== sec_type
)
9812 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9813 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9814 "contains %lu entry:\n",
9815 "\nUnwind section '%s' at offset 0x%lx "
9816 "contains %lu entries:\n",
9818 printable_section_name (filedata
, sec
),
9819 (unsigned long) sec
->sh_offset
,
9822 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9828 free ((char *) aux
.strtab
);
9834 no_processor_specific_unwind (Filedata
* filedata ATTRIBUTE_UNUSED
)
9836 printf (_("No processor specific unwind information to decode\n"));
9841 process_unwind (Filedata
* filedata
)
9843 struct unwind_handler
9845 unsigned int machtype
;
9846 bool (* handler
)(Filedata
*);
9849 { EM_ARM
, arm_process_unwind
},
9850 { EM_IA_64
, ia64_process_unwind
},
9851 { EM_PARISC
, hppa_process_unwind
},
9852 { EM_TI_C6000
, arm_process_unwind
},
9853 { EM_386
, no_processor_specific_unwind
},
9854 { EM_X86_64
, no_processor_specific_unwind
},
9862 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9863 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9864 return handlers
[i
].handler (filedata
);
9866 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9867 get_machine_name (filedata
->file_header
.e_machine
));
9872 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9874 switch (entry
->d_tag
)
9876 case DT_AARCH64_BTI_PLT
:
9877 case DT_AARCH64_PAC_PLT
:
9880 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9887 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
9889 switch (entry
->d_tag
)
9892 if (entry
->d_un
.d_val
== 0)
9896 static const char * opts
[] =
9898 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9899 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9900 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9901 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9907 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9908 if (entry
->d_un
.d_val
& (1 << cnt
))
9910 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9916 case DT_MIPS_IVERSION
:
9917 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
9918 printf (_("Interface Version: %s"),
9919 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
9923 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9924 /* Note: coded this way so that there is a single string for translation. */
9925 printf (_("<corrupt: %s>"), buf
);
9929 case DT_MIPS_TIME_STAMP
:
9933 time_t atime
= entry
->d_un
.d_val
;
9935 tmp
= gmtime (&atime
);
9936 /* PR 17531: file: 6accc532. */
9938 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9940 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9941 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9942 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9943 printf (_("Time Stamp: %s"), timebuf
);
9947 case DT_MIPS_RLD_VERSION
:
9948 case DT_MIPS_LOCAL_GOTNO
:
9949 case DT_MIPS_CONFLICTNO
:
9950 case DT_MIPS_LIBLISTNO
:
9951 case DT_MIPS_SYMTABNO
:
9952 case DT_MIPS_UNREFEXTNO
:
9953 case DT_MIPS_HIPAGENO
:
9954 case DT_MIPS_DELTA_CLASS_NO
:
9955 case DT_MIPS_DELTA_INSTANCE_NO
:
9956 case DT_MIPS_DELTA_RELOC_NO
:
9957 case DT_MIPS_DELTA_SYM_NO
:
9958 case DT_MIPS_DELTA_CLASSSYM_NO
:
9959 case DT_MIPS_COMPACT_SIZE
:
9960 print_vma (entry
->d_un
.d_val
, DEC
);
9964 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
9965 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9966 /* Falls through. */
9969 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9975 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9977 switch (entry
->d_tag
)
9979 case DT_HP_DLD_FLAGS
:
9988 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9989 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9990 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9991 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9992 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9993 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9994 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9995 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9996 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9997 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9998 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9999 { DT_HP_GST
, "HP_GST" },
10000 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
10001 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
10002 { DT_HP_NODELETE
, "HP_NODELETE" },
10003 { DT_HP_GROUP
, "HP_GROUP" },
10004 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
10008 bfd_vma val
= entry
->d_un
.d_val
;
10010 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
10011 if (val
& flags
[cnt
].bit
)
10015 fputs (flags
[cnt
].str
, stdout
);
10017 val
^= flags
[cnt
].bit
;
10020 if (val
!= 0 || first
)
10024 print_vma (val
, HEX
);
10030 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10038 /* VMS vs Unix time offset and factor. */
10040 #define VMS_EPOCH_OFFSET 35067168000000000LL
10041 #define VMS_GRANULARITY_FACTOR 10000000
10043 #define INT64_MIN (-9223372036854775807LL - 1)
10046 /* Display a VMS time in a human readable format. */
10049 print_vms_time (bfd_int64_t vmstime
)
10051 struct tm
*tm
= NULL
;
10054 if (vmstime
>= INT64_MIN
+ VMS_EPOCH_OFFSET
)
10056 vmstime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
10058 if (unxtime
== vmstime
)
10059 tm
= gmtime (&unxtime
);
10062 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
10063 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
10064 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
10069 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
10071 switch (entry
->d_tag
)
10073 case DT_IA_64_PLT_RESERVE
:
10074 /* First 3 slots reserved. */
10075 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10077 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
10080 case DT_IA_64_VMS_LINKTIME
:
10082 print_vms_time (entry
->d_un
.d_val
);
10086 case DT_IA_64_VMS_LNKFLAGS
:
10087 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10088 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
10089 printf (" CALL_DEBUG");
10090 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
10091 printf (" NOP0BUFS");
10092 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
10093 printf (" P0IMAGE");
10094 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
10095 printf (" MKTHREADS");
10096 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
10097 printf (" UPCALLS");
10098 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
10099 printf (" IMGSTA");
10100 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
10101 printf (" INITIALIZE");
10102 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
10104 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
10105 printf (" EXE_INIT");
10106 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
10107 printf (" TBK_IN_IMG");
10108 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
10109 printf (" DBG_IN_IMG");
10110 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
10111 printf (" TBK_IN_DSF");
10112 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
10113 printf (" DBG_IN_DSF");
10114 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
10115 printf (" SIGNATURES");
10116 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
10117 printf (" REL_SEG_OFF");
10121 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10128 get_32bit_dynamic_section (Filedata
* filedata
)
10130 Elf32_External_Dyn
* edyn
;
10131 Elf32_External_Dyn
* ext
;
10132 Elf_Internal_Dyn
* entry
;
10134 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
10135 filedata
->dynamic_addr
, 1,
10136 filedata
->dynamic_size
,
10137 _("dynamic section"));
10141 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
10142 might not have the luxury of section headers. Look for the DT_NULL
10143 terminator to determine the number of entries. */
10144 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
10145 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
10148 filedata
->dynamic_nent
++;
10149 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
10153 filedata
->dynamic_section
10154 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
10155 if (filedata
->dynamic_section
== NULL
)
10157 error (_("Out of memory allocating space for %lu dynamic entries\n"),
10158 (unsigned long) filedata
->dynamic_nent
);
10163 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10164 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10167 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10168 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10177 get_64bit_dynamic_section (Filedata
* filedata
)
10179 Elf64_External_Dyn
* edyn
;
10180 Elf64_External_Dyn
* ext
;
10181 Elf_Internal_Dyn
* entry
;
10183 /* Read in the data. */
10184 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
10185 filedata
->dynamic_addr
, 1,
10186 filedata
->dynamic_size
,
10187 _("dynamic section"));
10191 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
10192 might not have the luxury of section headers. Look for the DT_NULL
10193 terminator to determine the number of entries. */
10194 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
10195 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
10196 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
10199 filedata
->dynamic_nent
++;
10200 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
10204 filedata
->dynamic_section
10205 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
10206 if (filedata
->dynamic_section
== NULL
)
10208 error (_("Out of memory allocating space for %lu dynamic entries\n"),
10209 (unsigned long) filedata
->dynamic_nent
);
10214 /* Convert from external to internal formats. */
10215 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10216 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10219 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10220 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10229 print_dynamic_flags (bfd_vma flags
)
10237 flag
= flags
& - flags
;
10243 putc (' ', stdout
);
10247 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
10248 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
10249 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
10250 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
10251 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
10252 default: fputs (_("unknown"), stdout
); break;
10259 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
10261 unsigned char * e_data
;
10264 /* If the size_t type is smaller than the bfd_size_type, eg because
10265 you are building a 32-bit tool on a 64-bit host, then make sure
10266 that when (number) is cast to (size_t) no information is lost. */
10267 if (sizeof (size_t) < sizeof (bfd_size_type
)
10268 && (bfd_size_type
) ((size_t) number
) != number
)
10270 error (_("Size truncation prevents reading %s elements of size %u\n"),
10271 bfd_vmatoa ("u", number
), ent_size
);
10275 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
10276 attempting to allocate memory when the read is bound to fail. */
10277 if (ent_size
* number
> filedata
->file_size
)
10279 error (_("Invalid number of dynamic entries: %s\n"),
10280 bfd_vmatoa ("u", number
));
10284 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10285 if (e_data
== NULL
)
10287 error (_("Out of memory reading %s dynamic entries\n"),
10288 bfd_vmatoa ("u", number
));
10292 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
10294 error (_("Unable to read in %s bytes of dynamic data\n"),
10295 bfd_vmatoa ("u", number
* ent_size
));
10300 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10301 if (i_data
== NULL
)
10303 error (_("Out of memory allocating space for %s dynamic entries\n"),
10304 bfd_vmatoa ("u", number
));
10310 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10317 static unsigned long
10318 get_num_dynamic_syms (Filedata
* filedata
)
10320 unsigned long num_of_syms
= 0;
10322 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
10323 return num_of_syms
;
10325 if (filedata
->dynamic_info
[DT_HASH
])
10327 unsigned char nb
[8];
10328 unsigned char nc
[8];
10329 unsigned int hash_ent_size
= 4;
10331 if ((filedata
->file_header
.e_machine
== EM_ALPHA
10332 || filedata
->file_header
.e_machine
== EM_S390
10333 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
10334 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10337 if (fseek (filedata
->handle
,
10338 (filedata
->archive_file_offset
10339 + offset_from_vma (filedata
, filedata
->dynamic_info
[DT_HASH
],
10340 sizeof nb
+ sizeof nc
)),
10343 error (_("Unable to seek to start of dynamic information\n"));
10347 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
10349 error (_("Failed to read in number of buckets\n"));
10353 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
10355 error (_("Failed to read in number of chains\n"));
10359 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
10360 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
10362 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
10364 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
10366 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
10369 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
10370 num_of_syms
= filedata
->nchains
;
10373 if (num_of_syms
== 0)
10375 free (filedata
->buckets
);
10376 filedata
->buckets
= NULL
;
10377 free (filedata
->chains
);
10378 filedata
->chains
= NULL
;
10379 filedata
->nbuckets
= 0;
10383 if (filedata
->dynamic_info_DT_GNU_HASH
)
10385 unsigned char nb
[16];
10386 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10387 bfd_vma buckets_vma
;
10390 if (fseek (filedata
->handle
,
10391 (filedata
->archive_file_offset
10392 + offset_from_vma (filedata
,
10393 filedata
->dynamic_info_DT_GNU_HASH
,
10397 error (_("Unable to seek to start of dynamic information\n"));
10401 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
10403 error (_("Failed to read in number of buckets\n"));
10407 filedata
->ngnubuckets
= byte_get (nb
, 4);
10408 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
10409 bitmaskwords
= byte_get (nb
+ 8, 4);
10410 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
10412 buckets_vma
+= bitmaskwords
* 4;
10414 buckets_vma
+= bitmaskwords
* 8;
10416 if (fseek (filedata
->handle
,
10417 (filedata
->archive_file_offset
10418 + offset_from_vma (filedata
, buckets_vma
, 4)),
10421 error (_("Unable to seek to start of dynamic information\n"));
10425 filedata
->gnubuckets
10426 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
10428 if (filedata
->gnubuckets
== NULL
)
10431 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
10432 if (filedata
->gnubuckets
[i
] != 0)
10434 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
10437 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
10438 maxchain
= filedata
->gnubuckets
[i
];
10441 if (maxchain
== 0xffffffff)
10444 maxchain
-= filedata
->gnusymidx
;
10446 if (fseek (filedata
->handle
,
10447 (filedata
->archive_file_offset
10448 + offset_from_vma (filedata
,
10449 buckets_vma
+ 4 * (filedata
->ngnubuckets
10454 error (_("Unable to seek to start of dynamic information\n"));
10460 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
10462 error (_("Failed to determine last chain length\n"));
10466 if (maxchain
+ 1 == 0)
10471 while ((byte_get (nb
, 4) & 1) == 0);
10473 if (fseek (filedata
->handle
,
10474 (filedata
->archive_file_offset
10475 + offset_from_vma (filedata
, (buckets_vma
10476 + 4 * filedata
->ngnubuckets
),
10480 error (_("Unable to seek to start of dynamic information\n"));
10484 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
10485 filedata
->ngnuchains
= maxchain
;
10487 if (filedata
->gnuchains
== NULL
)
10490 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10492 if (fseek (filedata
->handle
,
10493 (filedata
->archive_file_offset
10494 + offset_from_vma (filedata
, (buckets_vma
10495 + 4 * (filedata
->ngnubuckets
10499 error (_("Unable to seek to start of dynamic information\n"));
10503 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
10504 if (filedata
->mipsxlat
== NULL
)
10508 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
10509 if (filedata
->gnubuckets
[hn
] != 0)
10511 bfd_vma si
= filedata
->gnubuckets
[hn
];
10512 bfd_vma off
= si
- filedata
->gnusymidx
;
10516 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10518 if (off
< filedata
->ngnuchains
10519 && filedata
->mipsxlat
[off
] >= num_of_syms
)
10520 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
10524 if (si
>= num_of_syms
)
10525 num_of_syms
= si
+ 1;
10529 while (off
< filedata
->ngnuchains
10530 && (filedata
->gnuchains
[off
++] & 1) == 0);
10533 if (num_of_syms
== 0)
10536 free (filedata
->mipsxlat
);
10537 filedata
->mipsxlat
= NULL
;
10538 free (filedata
->gnuchains
);
10539 filedata
->gnuchains
= NULL
;
10540 free (filedata
->gnubuckets
);
10541 filedata
->gnubuckets
= NULL
;
10542 filedata
->ngnubuckets
= 0;
10543 filedata
->ngnuchains
= 0;
10547 return num_of_syms
;
10550 /* Parse and display the contents of the dynamic section. */
10553 process_dynamic_section (Filedata
* filedata
)
10555 Elf_Internal_Dyn
* entry
;
10557 if (filedata
->dynamic_size
== 0)
10561 if (filedata
->is_separate
)
10562 printf (_("\nThere is no dynamic section in linked file '%s'.\n"),
10563 filedata
->file_name
);
10565 printf (_("\nThere is no dynamic section in this file.\n"));
10573 if (! get_32bit_dynamic_section (filedata
))
10578 if (! get_64bit_dynamic_section (filedata
))
10582 /* Find the appropriate symbol table. */
10583 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
10585 unsigned long num_of_syms
;
10587 for (entry
= filedata
->dynamic_section
;
10588 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10590 if (entry
->d_tag
== DT_SYMTAB
)
10591 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
10592 else if (entry
->d_tag
== DT_SYMENT
)
10593 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
10594 else if (entry
->d_tag
== DT_HASH
)
10595 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
10596 else if (entry
->d_tag
== DT_GNU_HASH
)
10597 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10598 else if ((filedata
->file_header
.e_machine
== EM_MIPS
10599 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
10600 && entry
->d_tag
== DT_MIPS_XHASH
)
10602 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10603 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10606 num_of_syms
= get_num_dynamic_syms (filedata
);
10608 if (num_of_syms
!= 0
10609 && filedata
->dynamic_symbols
== NULL
10610 && filedata
->dynamic_info
[DT_SYMTAB
]
10611 && filedata
->dynamic_info
[DT_SYMENT
])
10613 Elf_Internal_Phdr
*seg
;
10614 bfd_vma vma
= filedata
->dynamic_info
[DT_SYMTAB
];
10616 if (! get_program_headers (filedata
))
10618 error (_("Cannot interpret virtual addresses "
10619 "without program headers.\n"));
10623 for (seg
= filedata
->program_headers
;
10624 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
10627 if (seg
->p_type
!= PT_LOAD
)
10630 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
10632 /* See PR 21379 for a reproducer. */
10633 error (_("Invalid PT_LOAD entry\n"));
10637 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
10638 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
10640 /* Since we do not know how big the symbol table is,
10641 we default to reading in up to the end of PT_LOAD
10642 segment and processing that. This is overkill, I
10643 know, but it should work. */
10644 Elf_Internal_Shdr section
;
10645 section
.sh_offset
= (vma
- seg
->p_vaddr
10647 section
.sh_size
= (num_of_syms
10648 * filedata
->dynamic_info
[DT_SYMENT
]);
10649 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
10652 && filedata
->dynamic_symtab_section
!= NULL
10653 && ((filedata
->dynamic_symtab_section
->sh_offset
10654 != section
.sh_offset
)
10655 || (filedata
->dynamic_symtab_section
->sh_size
10656 != section
.sh_size
)
10657 || (filedata
->dynamic_symtab_section
->sh_entsize
10658 != section
.sh_entsize
)))
10660 the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
10662 section
.sh_name
= filedata
->string_table_length
;
10663 filedata
->dynamic_symbols
10664 = GET_ELF_SYMBOLS (filedata
, §ion
,
10665 &filedata
->num_dynamic_syms
);
10666 if (filedata
->dynamic_symbols
== NULL
10667 || filedata
->num_dynamic_syms
!= num_of_syms
)
10669 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
10678 /* Similarly find a string table. */
10679 if (filedata
->dynamic_strings
== NULL
)
10680 for (entry
= filedata
->dynamic_section
;
10681 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10684 if (entry
->d_tag
== DT_STRTAB
)
10685 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
10687 if (entry
->d_tag
== DT_STRSZ
)
10688 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
10690 if (filedata
->dynamic_info
[DT_STRTAB
]
10691 && filedata
->dynamic_info
[DT_STRSZ
])
10693 unsigned long offset
;
10694 bfd_size_type str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
10696 offset
= offset_from_vma (filedata
,
10697 filedata
->dynamic_info
[DT_STRTAB
],
10700 && filedata
->dynamic_strtab_section
10701 && ((filedata
->dynamic_strtab_section
->sh_offset
10702 != (file_ptr
) offset
)
10703 || (filedata
->dynamic_strtab_section
->sh_size
10706 the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
10708 filedata
->dynamic_strings
10709 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
10710 _("dynamic string table"));
10711 if (filedata
->dynamic_strings
== NULL
)
10713 error (_("Corrupt DT_STRTAB dynamic entry\n"));
10717 filedata
->dynamic_strings_length
= str_tab_len
;
10722 /* And find the syminfo section if available. */
10723 if (filedata
->dynamic_syminfo
== NULL
)
10725 unsigned long syminsz
= 0;
10727 for (entry
= filedata
->dynamic_section
;
10728 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10731 if (entry
->d_tag
== DT_SYMINENT
)
10733 /* Note: these braces are necessary to avoid a syntax
10734 error from the SunOS4 C compiler. */
10735 /* PR binutils/17531: A corrupt file can trigger this test.
10736 So do not use an assert, instead generate an error message. */
10737 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
10738 error (_("Bad value (%d) for SYMINENT entry\n"),
10739 (int) entry
->d_un
.d_val
);
10741 else if (entry
->d_tag
== DT_SYMINSZ
)
10742 syminsz
= entry
->d_un
.d_val
;
10743 else if (entry
->d_tag
== DT_SYMINFO
)
10744 filedata
->dynamic_syminfo_offset
10745 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
10748 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
10750 Elf_External_Syminfo
* extsyminfo
;
10751 Elf_External_Syminfo
* extsym
;
10752 Elf_Internal_Syminfo
* syminfo
;
10754 /* There is a syminfo section. Read the data. */
10755 extsyminfo
= (Elf_External_Syminfo
*)
10756 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
10757 1, syminsz
, _("symbol information"));
10761 if (filedata
->dynamic_syminfo
!= NULL
)
10763 error (_("Multiple dynamic symbol information sections found\n"));
10764 free (filedata
->dynamic_syminfo
);
10766 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10767 if (filedata
->dynamic_syminfo
== NULL
)
10769 error (_("Out of memory allocating %lu bytes "
10770 "for dynamic symbol info\n"),
10771 (unsigned long) syminsz
);
10775 filedata
->dynamic_syminfo_nent
10776 = syminsz
/ sizeof (Elf_External_Syminfo
);
10777 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
10778 syminfo
< (filedata
->dynamic_syminfo
10779 + filedata
->dynamic_syminfo_nent
);
10780 ++syminfo
, ++extsym
)
10782 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10783 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10790 if (do_dynamic
&& filedata
->dynamic_addr
)
10792 if (filedata
->dynamic_nent
== 1)
10794 if (filedata
->is_separate
)
10795 printf (_("\nIn linked file '%s' the dynamic section at offset 0x%lx contains 1 entry:\n"),
10796 filedata
->file_name
,
10797 filedata
->dynamic_addr
);
10799 printf (_("\nDynamic section at offset 0x%lx contains 1 entry:\n"),
10800 filedata
->dynamic_addr
);
10804 if (filedata
->is_separate
)
10805 printf (_("\nIn linked file '%s' the dynamic section at offset 0x%lx contains %lu entries:\n"),
10806 filedata
->file_name
,
10807 filedata
->dynamic_addr
,
10808 (unsigned long) filedata
->dynamic_nent
);
10810 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
10811 filedata
->dynamic_addr
,
10812 (unsigned long) filedata
->dynamic_nent
);
10816 printf (_(" Tag Type Name/Value\n"));
10818 for (entry
= filedata
->dynamic_section
;
10819 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10824 const char * dtype
;
10827 print_vma (entry
->d_tag
, FULL_HEX
);
10828 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10829 printf (" (%s)%*s", dtype
,
10830 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10833 switch (entry
->d_tag
)
10837 print_dynamic_flags (entry
->d_un
.d_val
);
10847 switch (entry
->d_tag
)
10850 printf (_("Auxiliary library"));
10854 printf (_("Filter library"));
10858 printf (_("Configuration file"));
10862 printf (_("Dependency audit library"));
10866 printf (_("Audit library"));
10870 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10871 printf (": [%s]\n",
10872 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
10876 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10885 printf (_("Flags:"));
10887 if (entry
->d_un
.d_val
== 0)
10888 printf (_(" None\n"));
10891 unsigned long int val
= entry
->d_un
.d_val
;
10893 if (val
& DTF_1_PARINIT
)
10895 printf (" PARINIT");
10896 val
^= DTF_1_PARINIT
;
10898 if (val
& DTF_1_CONFEXP
)
10900 printf (" CONFEXP");
10901 val
^= DTF_1_CONFEXP
;
10904 printf (" %lx", val
);
10913 printf (_("Flags:"));
10915 if (entry
->d_un
.d_val
== 0)
10916 printf (_(" None\n"));
10919 unsigned long int val
= entry
->d_un
.d_val
;
10921 if (val
& DF_P1_LAZYLOAD
)
10923 printf (" LAZYLOAD");
10924 val
^= DF_P1_LAZYLOAD
;
10926 if (val
& DF_P1_GROUPPERM
)
10928 printf (" GROUPPERM");
10929 val
^= DF_P1_GROUPPERM
;
10932 printf (" %lx", val
);
10941 printf (_("Flags:"));
10942 if (entry
->d_un
.d_val
== 0)
10943 printf (_(" None\n"));
10946 unsigned long int val
= entry
->d_un
.d_val
;
10948 if (val
& DF_1_NOW
)
10953 if (val
& DF_1_GLOBAL
)
10955 printf (" GLOBAL");
10956 val
^= DF_1_GLOBAL
;
10958 if (val
& DF_1_GROUP
)
10963 if (val
& DF_1_NODELETE
)
10965 printf (" NODELETE");
10966 val
^= DF_1_NODELETE
;
10968 if (val
& DF_1_LOADFLTR
)
10970 printf (" LOADFLTR");
10971 val
^= DF_1_LOADFLTR
;
10973 if (val
& DF_1_INITFIRST
)
10975 printf (" INITFIRST");
10976 val
^= DF_1_INITFIRST
;
10978 if (val
& DF_1_NOOPEN
)
10980 printf (" NOOPEN");
10981 val
^= DF_1_NOOPEN
;
10983 if (val
& DF_1_ORIGIN
)
10985 printf (" ORIGIN");
10986 val
^= DF_1_ORIGIN
;
10988 if (val
& DF_1_DIRECT
)
10990 printf (" DIRECT");
10991 val
^= DF_1_DIRECT
;
10993 if (val
& DF_1_TRANS
)
10998 if (val
& DF_1_INTERPOSE
)
11000 printf (" INTERPOSE");
11001 val
^= DF_1_INTERPOSE
;
11003 if (val
& DF_1_NODEFLIB
)
11005 printf (" NODEFLIB");
11006 val
^= DF_1_NODEFLIB
;
11008 if (val
& DF_1_NODUMP
)
11010 printf (" NODUMP");
11011 val
^= DF_1_NODUMP
;
11013 if (val
& DF_1_CONFALT
)
11015 printf (" CONFALT");
11016 val
^= DF_1_CONFALT
;
11018 if (val
& DF_1_ENDFILTEE
)
11020 printf (" ENDFILTEE");
11021 val
^= DF_1_ENDFILTEE
;
11023 if (val
& DF_1_DISPRELDNE
)
11025 printf (" DISPRELDNE");
11026 val
^= DF_1_DISPRELDNE
;
11028 if (val
& DF_1_DISPRELPND
)
11030 printf (" DISPRELPND");
11031 val
^= DF_1_DISPRELPND
;
11033 if (val
& DF_1_NODIRECT
)
11035 printf (" NODIRECT");
11036 val
^= DF_1_NODIRECT
;
11038 if (val
& DF_1_IGNMULDEF
)
11040 printf (" IGNMULDEF");
11041 val
^= DF_1_IGNMULDEF
;
11043 if (val
& DF_1_NOKSYMS
)
11045 printf (" NOKSYMS");
11046 val
^= DF_1_NOKSYMS
;
11048 if (val
& DF_1_NOHDR
)
11053 if (val
& DF_1_EDITED
)
11055 printf (" EDITED");
11056 val
^= DF_1_EDITED
;
11058 if (val
& DF_1_NORELOC
)
11060 printf (" NORELOC");
11061 val
^= DF_1_NORELOC
;
11063 if (val
& DF_1_SYMINTPOSE
)
11065 printf (" SYMINTPOSE");
11066 val
^= DF_1_SYMINTPOSE
;
11068 if (val
& DF_1_GLOBAUDIT
)
11070 printf (" GLOBAUDIT");
11071 val
^= DF_1_GLOBAUDIT
;
11073 if (val
& DF_1_SINGLETON
)
11075 printf (" SINGLETON");
11076 val
^= DF_1_SINGLETON
;
11078 if (val
& DF_1_STUB
)
11083 if (val
& DF_1_PIE
)
11088 if (val
& DF_1_KMOD
)
11093 if (val
& DF_1_WEAKFILTER
)
11095 printf (" WEAKFILTER");
11096 val
^= DF_1_WEAKFILTER
;
11098 if (val
& DF_1_NOCOMMON
)
11100 printf (" NOCOMMON");
11101 val
^= DF_1_NOCOMMON
;
11104 printf (" %lx", val
);
11111 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11113 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
11133 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11139 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
11140 name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
11146 switch (entry
->d_tag
)
11149 printf (_("Shared library: [%s]"), name
);
11151 if (filedata
->program_interpreter
11152 && streq (name
, filedata
->program_interpreter
))
11153 printf (_(" program interpreter"));
11157 printf (_("Library soname: [%s]"), name
);
11161 printf (_("Library rpath: [%s]"), name
);
11165 printf (_("Library runpath: [%s]"), name
);
11169 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11174 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11187 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11188 /* Fall through. */
11192 case DT_INIT_ARRAYSZ
:
11193 case DT_FINI_ARRAYSZ
:
11194 case DT_GNU_CONFLICTSZ
:
11195 case DT_GNU_LIBLISTSZ
:
11198 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11199 printf (_(" (bytes)\n"));
11204 case DT_VERNEEDNUM
:
11209 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11218 case DT_INIT_ARRAY
:
11219 case DT_FINI_ARRAY
:
11222 if (entry
->d_tag
== DT_USED
11223 && VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
11225 char * name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
11229 printf (_("Not needed object: [%s]\n"), name
);
11234 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11240 /* The value of this entry is ignored. */
11245 case DT_GNU_PRELINKED
:
11249 time_t atime
= entry
->d_un
.d_val
;
11251 tmp
= gmtime (&atime
);
11252 /* PR 17533 file: 041-1244816-0.004. */
11254 printf (_("<corrupt time val: %lx"),
11255 (unsigned long) atime
);
11257 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
11258 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11259 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11265 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11268 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11273 case DT_GNU_FLAGS_1
:
11276 printf (_("Flags:"));
11277 if (entry
->d_un
.d_val
== 0)
11278 printf (_(" None\n"));
11281 unsigned long int val
= entry
->d_un
.d_val
;
11283 if (val
& DF_GNU_1_UNIQUE
)
11285 printf (" UNIQUE");
11286 val
^= DF_GNU_1_UNIQUE
;
11289 printf (" %lx", val
);
11296 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
11297 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
11298 = entry
->d_un
.d_val
;
11302 switch (filedata
->file_header
.e_machine
)
11305 dynamic_section_aarch64_val (entry
);
11308 case EM_MIPS_RS3_LE
:
11309 dynamic_section_mips_val (filedata
, entry
);
11312 dynamic_section_parisc_val (entry
);
11315 dynamic_section_ia64_val (entry
);
11318 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11330 get_ver_flags (unsigned int flags
)
11332 static char buff
[128];
11339 if (flags
& VER_FLG_BASE
)
11340 strcat (buff
, "BASE");
11342 if (flags
& VER_FLG_WEAK
)
11344 if (flags
& VER_FLG_BASE
)
11345 strcat (buff
, " | ");
11347 strcat (buff
, "WEAK");
11350 if (flags
& VER_FLG_INFO
)
11352 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
11353 strcat (buff
, " | ");
11355 strcat (buff
, "INFO");
11358 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11360 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11361 strcat (buff
, " | ");
11363 strcat (buff
, _("<unknown>"));
11369 /* Display the contents of the version sections. */
11372 process_version_sections (Filedata
* filedata
)
11374 Elf_Internal_Shdr
* section
;
11376 bool found
= false;
11381 for (i
= 0, section
= filedata
->section_headers
;
11382 i
< filedata
->file_header
.e_shnum
;
11385 switch (section
->sh_type
)
11387 case SHT_GNU_verdef
:
11389 Elf_External_Verdef
* edefs
;
11396 if (filedata
->is_separate
)
11397 printf (ngettext ("\nIn linked file '%s' the version definition section '%s' contains %u entry:\n",
11398 "\nIn linked file '%s' the version definition section '%s' contains %u entries:\n",
11400 filedata
->file_name
,
11401 printable_section_name (filedata
, section
),
11404 printf (ngettext ("\nVersion definition section '%s' "
11405 "contains %u entry:\n",
11406 "\nVersion definition section '%s' "
11407 "contains %u entries:\n",
11409 printable_section_name (filedata
, section
),
11412 printf (_(" Addr: 0x"));
11413 printf_vma (section
->sh_addr
);
11414 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11415 (unsigned long) section
->sh_offset
, section
->sh_link
,
11416 printable_section_name_from_index (filedata
, section
->sh_link
));
11418 edefs
= (Elf_External_Verdef
*)
11419 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
11420 _("version definition section"));
11423 endbuf
= (char *) edefs
+ section
->sh_size
;
11425 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11428 Elf_External_Verdef
* edef
;
11429 Elf_Internal_Verdef ent
;
11430 Elf_External_Verdaux
* eaux
;
11431 Elf_Internal_Verdaux aux
;
11432 unsigned long isum
;
11435 vstart
= ((char *) edefs
) + idx
;
11436 if (vstart
+ sizeof (*edef
) > endbuf
)
11439 edef
= (Elf_External_Verdef
*) vstart
;
11441 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
11442 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
11443 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
11444 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
11445 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
11446 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
11447 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
11449 printf (_(" %#06lx: Rev: %d Flags: %s"),
11450 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
11452 printf (_(" Index: %d Cnt: %d "),
11453 ent
.vd_ndx
, ent
.vd_cnt
);
11455 /* Check for overflow. */
11456 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
11459 vstart
+= ent
.vd_aux
;
11461 if (vstart
+ sizeof (*eaux
) > endbuf
)
11463 eaux
= (Elf_External_Verdaux
*) vstart
;
11465 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11466 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11468 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11469 printf (_("Name: %s\n"),
11470 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11472 printf (_("Name index: %ld\n"), aux
.vda_name
);
11474 isum
= idx
+ ent
.vd_aux
;
11476 for (j
= 1; j
< ent
.vd_cnt
; j
++)
11478 if (aux
.vda_next
< sizeof (*eaux
)
11479 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
11481 warn (_("Invalid vda_next field of %lx\n"),
11486 /* Check for overflow. */
11487 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
11490 isum
+= aux
.vda_next
;
11491 vstart
+= aux
.vda_next
;
11493 if (vstart
+ sizeof (*eaux
) > endbuf
)
11495 eaux
= (Elf_External_Verdaux
*) vstart
;
11497 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11498 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11500 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11501 printf (_(" %#06lx: Parent %d: %s\n"),
11503 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11505 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
11506 isum
, j
, aux
.vda_name
);
11509 if (j
< ent
.vd_cnt
)
11510 printf (_(" Version def aux past end of section\n"));
11513 file: id:000001,src:000172+005151,op:splice,rep:2. */
11514 if (ent
.vd_next
< sizeof (*edef
)
11515 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
11517 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
11518 cnt
= section
->sh_info
;
11521 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
11524 idx
+= ent
.vd_next
;
11527 if (cnt
< section
->sh_info
)
11528 printf (_(" Version definition past end of section\n"));
11534 case SHT_GNU_verneed
:
11536 Elf_External_Verneed
* eneed
;
11543 if (filedata
->is_separate
)
11544 printf (ngettext ("\nIn linked file '%s' the version needs section '%s' contains %u entry:\n",
11545 "\nIn linked file '%s' the version needs section '%s' contains %u entries:\n",
11547 filedata
->file_name
,
11548 printable_section_name (filedata
, section
),
11551 printf (ngettext ("\nVersion needs section '%s' "
11552 "contains %u entry:\n",
11553 "\nVersion needs section '%s' "
11554 "contains %u entries:\n",
11556 printable_section_name (filedata
, section
),
11559 printf (_(" Addr: 0x"));
11560 printf_vma (section
->sh_addr
);
11561 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11562 (unsigned long) section
->sh_offset
, section
->sh_link
,
11563 printable_section_name_from_index (filedata
, section
->sh_link
));
11565 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
11566 section
->sh_offset
, 1,
11568 _("Version Needs section"));
11571 endbuf
= (char *) eneed
+ section
->sh_size
;
11573 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11575 Elf_External_Verneed
* entry
;
11576 Elf_Internal_Verneed ent
;
11577 unsigned long isum
;
11581 vstart
= ((char *) eneed
) + idx
;
11582 if (vstart
+ sizeof (*entry
) > endbuf
)
11585 entry
= (Elf_External_Verneed
*) vstart
;
11587 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
11588 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
11589 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
11590 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
11591 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
11593 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
11595 if (VALID_DYNAMIC_NAME (filedata
, ent
.vn_file
))
11596 printf (_(" File: %s"),
11597 GET_DYNAMIC_NAME (filedata
, ent
.vn_file
));
11599 printf (_(" File: %lx"), ent
.vn_file
);
11601 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
11603 /* Check for overflow. */
11604 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
11606 vstart
+= ent
.vn_aux
;
11608 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
11610 Elf_External_Vernaux
* eaux
;
11611 Elf_Internal_Vernaux aux
;
11613 if (vstart
+ sizeof (*eaux
) > endbuf
)
11615 eaux
= (Elf_External_Vernaux
*) vstart
;
11617 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
11618 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
11619 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
11620 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
11621 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
11623 if (VALID_DYNAMIC_NAME (filedata
, aux
.vna_name
))
11624 printf (_(" %#06lx: Name: %s"),
11625 isum
, GET_DYNAMIC_NAME (filedata
, aux
.vna_name
));
11627 printf (_(" %#06lx: Name index: %lx"),
11628 isum
, aux
.vna_name
);
11630 printf (_(" Flags: %s Version: %d\n"),
11631 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
11633 if (aux
.vna_next
< sizeof (*eaux
)
11634 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
11636 warn (_("Invalid vna_next field of %lx\n"),
11641 /* Check for overflow. */
11642 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
11644 isum
+= aux
.vna_next
;
11645 vstart
+= aux
.vna_next
;
11648 if (j
< ent
.vn_cnt
)
11649 warn (_("Missing Version Needs auxiliary information\n"));
11651 if (ent
.vn_next
< sizeof (*entry
)
11652 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
11654 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
11655 cnt
= section
->sh_info
;
11658 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
11660 idx
+= ent
.vn_next
;
11663 if (cnt
< section
->sh_info
)
11664 warn (_("Missing Version Needs information\n"));
11670 case SHT_GNU_versym
:
11672 Elf_Internal_Shdr
* link_section
;
11675 unsigned char * edata
;
11676 unsigned short * data
;
11678 Elf_Internal_Sym
* symbols
;
11679 Elf_Internal_Shdr
* string_sec
;
11680 unsigned long num_syms
;
11683 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
11686 link_section
= filedata
->section_headers
+ section
->sh_link
;
11687 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
11689 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
11694 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
11695 if (symbols
== NULL
)
11698 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
11700 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
11701 string_sec
->sh_size
,
11702 _("version string table"));
11709 if (filedata
->is_separate
)
11710 printf (ngettext ("\nIn linked file '%s' the version symbols section '%s' contains %lu entry:\n",
11711 "\nIn linked file '%s' the version symbols section '%s' contains %lu entries:\n",
11713 filedata
->file_name
,
11714 printable_section_name (filedata
, section
),
11715 (unsigned long) total
);
11717 printf (ngettext ("\nVersion symbols section '%s' "
11718 "contains %lu entry:\n",
11719 "\nVersion symbols section '%s' "
11720 "contains %lu entries:\n",
11722 printable_section_name (filedata
, section
),
11723 (unsigned long) total
);
11725 printf (_(" Addr: 0x"));
11726 printf_vma (section
->sh_addr
);
11727 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11728 (unsigned long) section
->sh_offset
, section
->sh_link
,
11729 printable_section_name (filedata
, link_section
));
11731 off
= offset_from_vma (filedata
,
11732 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11733 total
* sizeof (short));
11734 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
11735 sizeof (short), total
,
11736 _("version symbol data"));
11744 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
11746 for (cnt
= total
; cnt
--;)
11747 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
11752 for (cnt
= 0; cnt
< total
; cnt
+= 4)
11756 char *invalid
= _("*invalid*");
11758 printf (" %03x:", cnt
);
11760 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
11761 switch (data
[cnt
+ j
])
11764 fputs (_(" 0 (*local*) "), stdout
);
11768 fputs (_(" 1 (*global*) "), stdout
);
11772 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
11773 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
11775 /* If this index value is greater than the size of the symbols
11776 array, break to avoid an out-of-bounds read. */
11777 if ((unsigned long)(cnt
+ j
) >= num_syms
)
11779 warn (_("invalid index into symbol array\n"));
11784 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11786 Elf_Internal_Verneed ivn
;
11787 unsigned long offset
;
11789 offset
= offset_from_vma
11791 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11792 sizeof (Elf_External_Verneed
));
11796 Elf_Internal_Vernaux ivna
;
11797 Elf_External_Verneed evn
;
11798 Elf_External_Vernaux evna
;
11799 unsigned long a_off
;
11801 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11802 _("version need")) == NULL
)
11805 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11806 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11808 a_off
= offset
+ ivn
.vn_aux
;
11812 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
11813 1, _("version need aux (2)")) == NULL
)
11816 ivna
.vna_other
= 0;
11820 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11821 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11824 a_off
+= ivna
.vna_next
;
11826 while (ivna
.vna_other
!= data
[cnt
+ j
]
11827 && ivna
.vna_next
!= 0);
11829 if (ivna
.vna_other
== data
[cnt
+ j
])
11831 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11833 if (ivna
.vna_name
>= string_sec
->sh_size
)
11836 name
= strtab
+ ivna
.vna_name
;
11840 offset
+= ivn
.vn_next
;
11842 while (ivn
.vn_next
);
11845 if (data
[cnt
+ j
] != 0x8001
11846 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11848 Elf_Internal_Verdef ivd
;
11849 Elf_External_Verdef evd
;
11850 unsigned long offset
;
11852 offset
= offset_from_vma
11854 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11859 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11860 _("version def")) == NULL
)
11863 /* PR 17531: file: 046-1082287-0.004. */
11864 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11869 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11870 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11873 offset
+= ivd
.vd_next
;
11875 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11876 && ivd
.vd_next
!= 0);
11878 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11880 Elf_External_Verdaux evda
;
11881 Elf_Internal_Verdaux ivda
;
11883 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11885 if (get_data (&evda
, filedata
,
11886 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11888 _("version def aux")) == NULL
)
11891 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11893 if (ivda
.vda_name
>= string_sec
->sh_size
)
11895 else if (name
!= NULL
&& name
!= invalid
)
11896 name
= _("*both*");
11898 name
= strtab
+ ivda
.vda_name
;
11902 nn
+= printf ("(%s%-*s",
11904 12 - (int) strlen (name
),
11908 printf ("%*c", 18 - nn
, ' ');
11927 if (filedata
->is_separate
)
11928 printf (_("\nNo version information found in linked file '%s'.\n"),
11929 filedata
->file_name
);
11931 printf (_("\nNo version information found in this file.\n"));
11937 static const char *
11938 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11940 static char buff
[64];
11944 case STB_LOCAL
: return "LOCAL";
11945 case STB_GLOBAL
: return "GLOBAL";
11946 case STB_WEAK
: return "WEAK";
11948 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11949 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11951 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11953 if (binding
== STB_GNU_UNIQUE
11954 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11956 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11959 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11964 static const char *
11965 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11967 static char buff
[64];
11971 case STT_NOTYPE
: return "NOTYPE";
11972 case STT_OBJECT
: return "OBJECT";
11973 case STT_FUNC
: return "FUNC";
11974 case STT_SECTION
: return "SECTION";
11975 case STT_FILE
: return "FILE";
11976 case STT_COMMON
: return "COMMON";
11977 case STT_TLS
: return "TLS";
11978 case STT_RELC
: return "RELC";
11979 case STT_SRELC
: return "SRELC";
11981 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11983 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11984 return "THUMB_FUNC";
11986 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11989 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11990 return "PARISC_MILLI";
11992 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11994 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11996 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11998 if (type
== STT_HP_OPAQUE
)
11999 return "HP_OPAQUE";
12000 if (type
== STT_HP_STUB
)
12004 if (type
== STT_GNU_IFUNC
12005 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
12006 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
12009 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
12012 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
12017 static const char *
12018 get_symbol_visibility (unsigned int visibility
)
12020 switch (visibility
)
12022 case STV_DEFAULT
: return "DEFAULT";
12023 case STV_INTERNAL
: return "INTERNAL";
12024 case STV_HIDDEN
: return "HIDDEN";
12025 case STV_PROTECTED
: return "PROTECTED";
12027 error (_("Unrecognized visibility value: %u\n"), visibility
);
12028 return _("<unknown>");
12032 static const char *
12033 get_alpha_symbol_other (unsigned int other
)
12037 case STO_ALPHA_NOPV
: return "NOPV";
12038 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
12040 error (_("Unrecognized alpha specific other value: %u\n"), other
);
12041 return _("<unknown>");
12045 static const char *
12046 get_solaris_symbol_visibility (unsigned int visibility
)
12048 switch (visibility
)
12050 case 4: return "EXPORTED";
12051 case 5: return "SINGLETON";
12052 case 6: return "ELIMINATE";
12053 default: return get_symbol_visibility (visibility
);
12057 static const char *
12058 get_aarch64_symbol_other (unsigned int other
)
12060 static char buf
[32];
12062 if (other
& STO_AARCH64_VARIANT_PCS
)
12064 other
&= ~STO_AARCH64_VARIANT_PCS
;
12066 return "VARIANT_PCS";
12067 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
12073 static const char *
12074 get_mips_symbol_other (unsigned int other
)
12078 case STO_OPTIONAL
: return "OPTIONAL";
12079 case STO_MIPS_PLT
: return "MIPS PLT";
12080 case STO_MIPS_PIC
: return "MIPS PIC";
12081 case STO_MICROMIPS
: return "MICROMIPS";
12082 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
12083 case STO_MIPS16
: return "MIPS16";
12084 default: return NULL
;
12088 static const char *
12089 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
12091 if (is_ia64_vms (filedata
))
12093 static char res
[32];
12097 /* Function types is for images and .STB files only. */
12098 switch (filedata
->file_header
.e_type
)
12102 switch (VMS_ST_FUNC_TYPE (other
))
12104 case VMS_SFT_CODE_ADDR
:
12105 strcat (res
, " CA");
12107 case VMS_SFT_SYMV_IDX
:
12108 strcat (res
, " VEC");
12111 strcat (res
, " FD");
12113 case VMS_SFT_RESERVE
:
12114 strcat (res
, " RSV");
12117 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
12118 VMS_ST_FUNC_TYPE (other
));
12119 strcat (res
, " <unknown>");
12126 switch (VMS_ST_LINKAGE (other
))
12128 case VMS_STL_IGNORE
:
12129 strcat (res
, " IGN");
12131 case VMS_STL_RESERVE
:
12132 strcat (res
, " RSV");
12135 strcat (res
, " STD");
12138 strcat (res
, " LNK");
12141 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
12142 VMS_ST_LINKAGE (other
));
12143 strcat (res
, " <unknown>");
12155 static const char *
12156 get_ppc64_symbol_other (unsigned int other
)
12158 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
12161 other
>>= STO_PPC64_LOCAL_BIT
;
12164 static char buf
[64];
12166 other
= ppc64_decode_local_entry (other
);
12167 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
12173 static const char *
12174 get_symbol_other (Filedata
* filedata
, unsigned int other
)
12176 const char * result
= NULL
;
12177 static char buff
[64];
12182 switch (filedata
->file_header
.e_machine
)
12185 result
= get_alpha_symbol_other (other
);
12188 result
= get_aarch64_symbol_other (other
);
12191 result
= get_mips_symbol_other (other
);
12194 result
= get_ia64_symbol_other (filedata
, other
);
12197 result
= get_ppc64_symbol_other (other
);
12207 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
12211 static const char *
12212 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
12214 static char buff
[32];
12218 case SHN_UNDEF
: return "UND";
12219 case SHN_ABS
: return "ABS";
12220 case SHN_COMMON
: return "COM";
12222 if (type
== SHN_IA_64_ANSI_COMMON
12223 && filedata
->file_header
.e_machine
== EM_IA_64
12224 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
12226 else if ((filedata
->file_header
.e_machine
== EM_X86_64
12227 || filedata
->file_header
.e_machine
== EM_L1OM
12228 || filedata
->file_header
.e_machine
== EM_K1OM
)
12229 && type
== SHN_X86_64_LCOMMON
)
12230 return "LARGE_COM";
12231 else if ((type
== SHN_MIPS_SCOMMON
12232 && filedata
->file_header
.e_machine
== EM_MIPS
)
12233 || (type
== SHN_TIC6X_SCOMMON
12234 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
12236 else if (type
== SHN_MIPS_SUNDEFINED
12237 && filedata
->file_header
.e_machine
== EM_MIPS
)
12239 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
12240 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
12241 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
12242 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
12243 else if (type
>= SHN_LORESERVE
)
12244 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
12245 else if (filedata
->file_header
.e_shnum
!= 0
12246 && type
>= filedata
->file_header
.e_shnum
)
12247 sprintf (buff
, _("bad section index[%3d]"), type
);
12249 sprintf (buff
, "%3d", type
);
12256 static const char *
12257 get_symbol_version_string (Filedata
* filedata
,
12259 const char * strtab
,
12260 unsigned long int strtab_size
,
12262 Elf_Internal_Sym
* psym
,
12263 enum versioned_symbol_info
* sym_info
,
12264 unsigned short * vna_other
)
12266 unsigned char data
[2];
12267 unsigned short vers_data
;
12268 unsigned long offset
;
12269 unsigned short max_vd_ndx
;
12272 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
12275 offset
= offset_from_vma (filedata
,
12276 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
12277 sizeof data
+ si
* sizeof (vers_data
));
12279 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
12280 sizeof (data
), 1, _("version data")) == NULL
)
12283 vers_data
= byte_get (data
, 2);
12285 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
12288 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
12291 /* Usually we'd only see verdef for defined symbols, and verneed for
12292 undefined symbols. However, symbols defined by the linker in
12293 .dynbss for variables copied from a shared library in order to
12294 avoid text relocations are defined yet have verneed. We could
12295 use a heuristic to detect the special case, for example, check
12296 for verneed first on symbols defined in SHT_NOBITS sections, but
12297 it is simpler and more reliable to just look for both verdef and
12298 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
12300 if (psym
->st_shndx
!= SHN_UNDEF
12301 && vers_data
!= 0x8001
12302 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
12304 Elf_Internal_Verdef ivd
;
12305 Elf_Internal_Verdaux ivda
;
12306 Elf_External_Verdaux evda
;
12309 off
= offset_from_vma (filedata
,
12310 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
12311 sizeof (Elf_External_Verdef
));
12315 Elf_External_Verdef evd
;
12317 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
12318 _("version def")) == NULL
)
12327 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
12328 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
12329 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
12330 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
12333 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
12334 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
12336 off
+= ivd
.vd_next
;
12338 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
12340 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
12342 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
12345 off
-= ivd
.vd_next
;
12348 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
12349 _("version def aux")) != NULL
)
12351 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
12353 if (psym
->st_name
!= ivda
.vda_name
)
12354 return (ivda
.vda_name
< strtab_size
12355 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
12360 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
12362 Elf_External_Verneed evn
;
12363 Elf_Internal_Verneed ivn
;
12364 Elf_Internal_Vernaux ivna
;
12366 offset
= offset_from_vma (filedata
,
12367 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
12371 unsigned long vna_off
;
12373 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
12374 _("version need")) == NULL
)
12377 ivna
.vna_other
= 0;
12382 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
12383 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
12385 vna_off
= offset
+ ivn
.vn_aux
;
12389 Elf_External_Vernaux evna
;
12391 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
12392 _("version need aux (3)")) == NULL
)
12395 ivna
.vna_other
= 0;
12400 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
12401 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
12402 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
12405 vna_off
+= ivna
.vna_next
;
12407 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
12409 if (ivna
.vna_other
== vers_data
)
12412 offset
+= ivn
.vn_next
;
12414 while (ivn
.vn_next
!= 0);
12416 if (ivna
.vna_other
== vers_data
)
12418 *sym_info
= symbol_undefined
;
12419 *vna_other
= ivna
.vna_other
;
12420 return (ivna
.vna_name
< strtab_size
12421 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
12423 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
12424 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
12425 return _("<corrupt>");
12430 /* Display a symbol size on stdout. Format is based on --sym-base setting. */
12432 static unsigned int
12433 print_dynamic_symbol_size (bfd_vma vma
, int base
)
12438 return print_vma (vma
, OCTAL_5
);
12441 return print_vma (vma
, UNSIGNED_5
);
12444 return print_vma (vma
, PREFIX_HEX_5
);
12448 return print_vma (vma
, DEC_5
);
12453 print_dynamic_symbol (Filedata
*filedata
, unsigned long si
,
12454 Elf_Internal_Sym
*symtab
,
12455 Elf_Internal_Shdr
*section
,
12456 char *strtab
, size_t strtab_size
)
12458 const char *version_string
;
12459 enum versioned_symbol_info sym_info
;
12460 unsigned short vna_other
;
12463 Elf_Internal_Sym
*psym
= symtab
+ si
;
12465 printf ("%6ld: ", si
);
12466 print_vma (psym
->st_value
, LONG_HEX
);
12468 print_dynamic_symbol_size (psym
->st_size
, sym_base
);
12469 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12470 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12471 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12472 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12475 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12477 printf (" %-7s", get_symbol_visibility (vis
));
12478 /* Check to see if any other bits in the st_other field are set.
12479 Note - displaying this information disrupts the layout of the
12480 table being generated, but for the moment this case is very rare. */
12481 if (psym
->st_other
^ vis
)
12482 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12484 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12486 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
12487 && psym
->st_shndx
< filedata
->file_header
.e_shnum
12488 && psym
->st_name
== 0)
12490 is_valid
= SECTION_NAME_VALID (filedata
->section_headers
+ psym
->st_shndx
);
12492 SECTION_NAME_PRINT (filedata
->section_headers
+ psym
->st_shndx
)
12497 is_valid
= VALID_SYMBOL_NAME (strtab
, strtab_size
, psym
->st_name
);
12498 sstr
= is_valid
? strtab
+ psym
->st_name
: _("<corrupt>");
12502 = get_symbol_version_string (filedata
,
12504 || section
->sh_type
== SHT_DYNSYM
),
12505 strtab
, strtab_size
, si
,
12506 psym
, &sym_info
, &vna_other
);
12508 int len_avail
= 21;
12509 if (! do_wide
&& version_string
!= NULL
)
12513 len_avail
-= 1 + strlen (version_string
);
12515 if (sym_info
== symbol_undefined
)
12516 len_avail
-= sprintf (buffer
," (%d)", vna_other
);
12517 else if (sym_info
!= symbol_hidden
)
12521 print_symbol (len_avail
, sstr
);
12523 if (version_string
)
12525 if (sym_info
== symbol_undefined
)
12526 printf ("@%s (%d)", version_string
, vna_other
);
12528 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12534 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12536 && si
>= section
->sh_info
12537 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12538 && filedata
->file_header
.e_machine
!= EM_MIPS
12539 /* Solaris binaries have been found to violate this requirement as
12540 well. Not sure if this is a bug or an ABI requirement. */
12541 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12542 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12543 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12546 static const char *
12547 get_lto_kind (unsigned int kind
)
12551 case 0: return "DEF";
12552 case 1: return "WEAKDEF";
12553 case 2: return "UNDEF";
12554 case 3: return "WEAKUNDEF";
12555 case 4: return "COMMON";
12560 static char buffer
[30];
12561 error (_("Unknown LTO symbol definition encountered: %u\n"), kind
);
12562 sprintf (buffer
, "<unknown: %u>", kind
);
12566 static const char *
12567 get_lto_visibility (unsigned int visibility
)
12569 switch (visibility
)
12571 case 0: return "DEFAULT";
12572 case 1: return "PROTECTED";
12573 case 2: return "INTERNAL";
12574 case 3: return "HIDDEN";
12579 static char buffer
[30];
12580 error (_("Unknown LTO symbol visibility encountered: %u\n"), visibility
);
12581 sprintf (buffer
, "<unknown: %u>", visibility
);
12585 static const char *
12586 get_lto_sym_type (unsigned int sym_type
)
12590 case 0: return "UNKNOWN";
12591 case 1: return "FUNCTION";
12592 case 2: return "VARIABLE";
12597 static char buffer
[30];
12598 error (_("Unknown LTO symbol type encountered: %u\n"), sym_type
);
12599 sprintf (buffer
, "<unknown: %u>", sym_type
);
12603 /* Display an LTO format symbol table.
12604 FIXME: The format of LTO symbol tables is not formalized.
12605 So this code could need changing in the future. */
12608 display_lto_symtab (Filedata
* filedata
,
12609 Elf_Internal_Shdr
* section
)
12611 if (section
->sh_size
== 0)
12613 if (filedata
->is_separate
)
12614 printf (_("\nThe LTO Symbol table section '%s' in linked file '%s' is empty!\n"),
12615 printable_section_name (filedata
, section
),
12616 filedata
->file_name
);
12618 printf (_("\nLTO Symbol table '%s' is empty!\n"),
12619 printable_section_name (filedata
, section
));
12624 if (section
->sh_size
> filedata
->file_size
)
12626 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
12627 printable_section_name (filedata
, section
),
12628 (unsigned long) section
->sh_size
);
12632 void * alloced_data
= get_data (NULL
, filedata
, section
->sh_offset
,
12633 section
->sh_size
, 1, _("LTO symbols"));
12634 if (alloced_data
== NULL
)
12637 /* Look for extended data for the symbol table. */
12638 Elf_Internal_Shdr
* ext
;
12639 void * ext_data_orig
= NULL
;
12640 char * ext_data
= NULL
;
12641 char * ext_data_end
= NULL
;
12642 char * ext_name
= NULL
;
12644 if (asprintf (& ext_name
, ".gnu.lto_.ext_symtab.%s",
12645 SECTION_NAME (section
) + sizeof (".gnu.lto_.symtab.") - 1) > 0
12646 && ext_name
!= NULL
/* Paranoia. */
12647 && (ext
= find_section (filedata
, ext_name
)) != NULL
)
12649 if (ext
->sh_size
< 3)
12650 error (_("LTO Symbol extension table '%s' is empty!\n"),
12651 printable_section_name (filedata
, ext
));
12654 ext_data_orig
= ext_data
= get_data (NULL
, filedata
, ext
->sh_offset
,
12656 _("LTO ext symbol data"));
12657 if (ext_data
!= NULL
)
12659 ext_data_end
= ext_data
+ ext
->sh_size
;
12660 if (* ext_data
++ != 1)
12661 error (_("Unexpected version number in symbol extension table\n"));
12666 const unsigned char * data
= (const unsigned char *) alloced_data
;
12667 const unsigned char * end
= data
+ section
->sh_size
;
12669 if (filedata
->is_separate
)
12670 printf (_("\nIn linked file '%s': "), filedata
->file_name
);
12674 if (ext_data_orig
!= NULL
)
12677 printf (_("LTO Symbol table '%s' and extension table '%s' contain:\n"),
12678 printable_section_name (filedata
, section
),
12679 printable_section_name (filedata
, ext
));
12682 printf (_("LTO Symbol table '%s'\n"),
12683 printable_section_name (filedata
, section
));
12684 printf (_(" and extension table '%s' contain:\n"),
12685 printable_section_name (filedata
, ext
));
12689 printf (_("LTO Symbol table '%s' contains:\n"),
12690 printable_section_name (filedata
, section
));
12692 /* FIXME: Add a wide version. */
12693 if (ext_data_orig
!= NULL
)
12694 printf (_(" Comdat_Key Kind Visibility Size Slot Type Section Name\n"));
12696 printf (_(" Comdat_Key Kind Visibility Size Slot Name\n"));
12698 /* FIXME: We do not handle style prefixes. */
12702 const unsigned char * sym_name
= data
;
12703 data
+= strnlen ((const char *) sym_name
, end
- data
) + 1;
12707 const unsigned char * comdat_key
= data
;
12708 data
+= strnlen ((const char *) comdat_key
, end
- data
) + 1;
12712 if (data
+ 2 + 8 + 4 > end
)
12715 unsigned int kind
= *data
++;
12716 unsigned int visibility
= *data
++;
12718 elf_vma size
= byte_get (data
, 8);
12721 elf_vma slot
= byte_get (data
, 4);
12724 if (ext_data
!= NULL
)
12726 if (ext_data
< (ext_data_end
- 1))
12728 unsigned int sym_type
= * ext_data
++;
12729 unsigned int sec_kind
= * ext_data
++;
12731 printf (" %10s %10s %11s %08lx %08lx %9s %08lx _",
12732 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
12733 get_lto_kind (kind
),
12734 get_lto_visibility (visibility
),
12737 get_lto_sym_type (sym_type
),
12739 print_symbol (6, (const char *) sym_name
);
12743 error (_("Ran out of LTO symbol extension data\n"));
12745 /* FIXME: return FAIL result ? */
12750 printf (" %10s %10s %11s %08lx %08lx _",
12751 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
12752 get_lto_kind (kind
),
12753 get_lto_visibility (visibility
),
12756 print_symbol (21, (const char *) sym_name
);
12761 if (ext_data
!= NULL
&& ext_data
< ext_data_end
)
12763 error (_("Data remains in the LTO symbol extension table\n"));
12767 free (alloced_data
);
12768 free (ext_data_orig
);
12773 error (_("Buffer overrun encountered whilst decoding LTO symbol table\n"));
12774 free (alloced_data
);
12775 free (ext_data_orig
);
12780 /* Display LTO symbol tables. */
12783 process_lto_symbol_tables (Filedata
* filedata
)
12785 Elf_Internal_Shdr
* section
;
12792 if (filedata
->section_headers
== NULL
)
12795 for (i
= 0, section
= filedata
->section_headers
;
12796 i
< filedata
->file_header
.e_shnum
;
12798 if (SECTION_NAME_VALID (section
)
12799 && startswith (SECTION_NAME (section
), ".gnu.lto_.symtab."))
12800 res
&= display_lto_symtab (filedata
, section
);
12805 /* Dump the symbol table. */
12808 process_symbol_table (Filedata
* filedata
)
12810 Elf_Internal_Shdr
* section
;
12812 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
12815 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
12817 && do_using_dynamic
12818 && filedata
->dynamic_strings
!= NULL
12819 && filedata
->dynamic_symbols
!= NULL
)
12823 if (filedata
->is_separate
)
12825 printf (ngettext ("\nIn linked file '%s' the dynamic symbol table contains %lu entry:\n",
12826 "\nIn linked file '%s' the dynamic symbol table contains %lu entries:\n",
12827 filedata
->num_dynamic_syms
),
12828 filedata
->file_name
,
12829 filedata
->num_dynamic_syms
);
12833 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
12834 "\nSymbol table for image contains %lu entries:\n",
12835 filedata
->num_dynamic_syms
),
12836 filedata
->num_dynamic_syms
);
12839 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12841 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12843 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
12844 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
12845 filedata
->dynamic_strings
,
12846 filedata
->dynamic_strings_length
);
12848 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
12849 && filedata
->section_headers
!= NULL
)
12853 for (i
= 0, section
= filedata
->section_headers
;
12854 i
< filedata
->file_header
.e_shnum
;
12857 char * strtab
= NULL
;
12858 unsigned long int strtab_size
= 0;
12859 Elf_Internal_Sym
* symtab
;
12860 unsigned long si
, num_syms
;
12862 if ((section
->sh_type
!= SHT_SYMTAB
12863 && section
->sh_type
!= SHT_DYNSYM
)
12865 && section
->sh_type
== SHT_SYMTAB
))
12868 if (section
->sh_entsize
== 0)
12870 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12871 printable_section_name (filedata
, section
));
12875 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12877 if (filedata
->is_separate
)
12878 printf (ngettext ("\nIn linked file '%s' symbol section '%s' contains %lu entry:\n",
12879 "\nIn linked file '%s' symbol section '%s' contains %lu entries:\n",
12881 filedata
->file_name
,
12882 printable_section_name (filedata
, section
),
12885 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12886 "\nSymbol table '%s' contains %lu entries:\n",
12888 printable_section_name (filedata
, section
),
12892 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12894 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12896 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
12897 if (symtab
== NULL
)
12900 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12902 strtab
= filedata
->string_table
;
12903 strtab_size
= filedata
->string_table_length
;
12905 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12907 Elf_Internal_Shdr
* string_sec
;
12909 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12911 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12912 1, string_sec
->sh_size
,
12913 _("string table"));
12914 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12917 for (si
= 0; si
< num_syms
; si
++)
12918 print_dynamic_symbol (filedata
, si
, symtab
, section
,
12919 strtab
, strtab_size
);
12922 if (strtab
!= filedata
->string_table
)
12928 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12930 if (do_histogram
&& filedata
->buckets
!= NULL
)
12932 unsigned long * lengths
;
12933 unsigned long * counts
;
12936 unsigned long maxlength
= 0;
12937 unsigned long nzero_counts
= 0;
12938 unsigned long nsyms
= 0;
12941 printf (ngettext ("\nHistogram for bucket list length "
12942 "(total of %lu bucket):\n",
12943 "\nHistogram for bucket list length "
12944 "(total of %lu buckets):\n",
12945 (unsigned long) filedata
->nbuckets
),
12946 (unsigned long) filedata
->nbuckets
);
12948 lengths
= (unsigned long *) calloc (filedata
->nbuckets
,
12949 sizeof (*lengths
));
12950 if (lengths
== NULL
)
12952 error (_("Out of memory allocating space for histogram buckets\n"));
12955 visited
= xcmalloc (filedata
->nchains
, 1);
12956 memset (visited
, 0, filedata
->nchains
);
12958 printf (_(" Length Number %% of total Coverage\n"));
12959 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12961 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
12964 if (maxlength
< ++lengths
[hn
])
12966 if (si
>= filedata
->nchains
|| visited
[si
])
12968 error (_("histogram chain is corrupt\n"));
12976 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12977 if (counts
== NULL
)
12980 error (_("Out of memory allocating space for histogram counts\n"));
12984 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12985 ++counts
[lengths
[hn
]];
12987 if (filedata
->nbuckets
> 0)
12990 printf (" 0 %-10lu (%5.1f%%)\n",
12991 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
12992 for (i
= 1; i
<= maxlength
; ++i
)
12994 nzero_counts
+= counts
[i
] * i
;
12995 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12996 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
12997 (nzero_counts
* 100.0) / nsyms
);
13005 free (filedata
->buckets
);
13006 filedata
->buckets
= NULL
;
13007 filedata
->nbuckets
= 0;
13008 free (filedata
->chains
);
13009 filedata
->chains
= NULL
;
13011 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
13013 unsigned long * lengths
;
13014 unsigned long * counts
;
13016 unsigned long maxlength
= 0;
13017 unsigned long nzero_counts
= 0;
13018 unsigned long nsyms
= 0;
13020 printf (ngettext ("\nHistogram for `%s' bucket list length "
13021 "(total of %lu bucket):\n",
13022 "\nHistogram for `%s' bucket list length "
13023 "(total of %lu buckets):\n",
13024 (unsigned long) filedata
->ngnubuckets
),
13025 GNU_HASH_SECTION_NAME (filedata
),
13026 (unsigned long) filedata
->ngnubuckets
);
13028 lengths
= (unsigned long *) calloc (filedata
->ngnubuckets
,
13029 sizeof (*lengths
));
13030 if (lengths
== NULL
)
13032 error (_("Out of memory allocating space for gnu histogram buckets\n"));
13036 printf (_(" Length Number %% of total Coverage\n"));
13038 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
13039 if (filedata
->gnubuckets
[hn
] != 0)
13041 bfd_vma off
, length
= 1;
13043 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
13044 /* PR 17531 file: 010-77222-0.004. */
13045 off
< filedata
->ngnuchains
13046 && (filedata
->gnuchains
[off
] & 1) == 0;
13049 lengths
[hn
] = length
;
13050 if (length
> maxlength
)
13051 maxlength
= length
;
13055 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
13056 if (counts
== NULL
)
13059 error (_("Out of memory allocating space for gnu histogram counts\n"));
13063 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
13064 ++counts
[lengths
[hn
]];
13066 if (filedata
->ngnubuckets
> 0)
13069 printf (" 0 %-10lu (%5.1f%%)\n",
13070 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
13071 for (j
= 1; j
<= maxlength
; ++j
)
13073 nzero_counts
+= counts
[j
] * j
;
13074 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
13075 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
13076 (nzero_counts
* 100.0) / nsyms
);
13083 free (filedata
->gnubuckets
);
13084 filedata
->gnubuckets
= NULL
;
13085 filedata
->ngnubuckets
= 0;
13086 free (filedata
->gnuchains
);
13087 filedata
->gnuchains
= NULL
;
13088 filedata
->ngnuchains
= 0;
13089 free (filedata
->mipsxlat
);
13090 filedata
->mipsxlat
= NULL
;
13094 free (filedata
->gnubuckets
);
13095 filedata
->gnubuckets
= NULL
;
13096 filedata
->ngnubuckets
= 0;
13097 free (filedata
->gnuchains
);
13098 filedata
->gnuchains
= NULL
;
13099 filedata
->ngnuchains
= 0;
13100 free (filedata
->mipsxlat
);
13101 filedata
->mipsxlat
= NULL
;
13102 free (filedata
->buckets
);
13103 filedata
->buckets
= NULL
;
13104 filedata
->nbuckets
= 0;
13105 free (filedata
->chains
);
13106 filedata
->chains
= NULL
;
13111 process_syminfo (Filedata
* filedata
)
13115 if (filedata
->dynamic_syminfo
== NULL
13117 /* No syminfo, this is ok. */
13120 /* There better should be a dynamic symbol section. */
13121 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
13124 if (filedata
->is_separate
)
13125 printf (ngettext ("\nIn linked file '%s: the dynamic info segment at offset 0x%lx contains %d entry:\n",
13126 "\nIn linked file '%s: the dynamic info segment at offset 0x%lx contains %d entries:\n",
13127 filedata
->dynamic_syminfo_nent
),
13128 filedata
->file_name
,
13129 filedata
->dynamic_syminfo_offset
,
13130 filedata
->dynamic_syminfo_nent
);
13132 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
13133 "contains %d entry:\n",
13134 "\nDynamic info segment at offset 0x%lx "
13135 "contains %d entries:\n",
13136 filedata
->dynamic_syminfo_nent
),
13137 filedata
->dynamic_syminfo_offset
,
13138 filedata
->dynamic_syminfo_nent
);
13140 printf (_(" Num: Name BoundTo Flags\n"));
13141 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
13143 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
13145 printf ("%4d: ", i
);
13146 if (i
>= filedata
->num_dynamic_syms
)
13147 printf (_("<corrupt index>"));
13148 else if (VALID_DYNAMIC_NAME (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
13149 print_symbol (30, GET_DYNAMIC_NAME (filedata
,
13150 filedata
->dynamic_symbols
[i
].st_name
));
13152 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
13155 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
13157 case SYMINFO_BT_SELF
:
13158 fputs ("SELF ", stdout
);
13160 case SYMINFO_BT_PARENT
:
13161 fputs ("PARENT ", stdout
);
13164 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
13165 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
13166 && VALID_DYNAMIC_NAME (filedata
,
13167 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
13169 print_symbol (10, GET_DYNAMIC_NAME (filedata
,
13170 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
13174 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
13178 if (flags
& SYMINFO_FLG_DIRECT
)
13179 printf (" DIRECT");
13180 if (flags
& SYMINFO_FLG_PASSTHRU
)
13181 printf (" PASSTHRU");
13182 if (flags
& SYMINFO_FLG_COPY
)
13184 if (flags
& SYMINFO_FLG_LAZYLOAD
)
13185 printf (" LAZYLOAD");
13193 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
13194 is contained by the region START .. END. The types of ADDR, START
13195 and END should all be the same. Note both ADDR + NELEM and END
13196 point to just beyond the end of the regions that are being tested. */
13197 #define IN_RANGE(START,END,ADDR,NELEM) \
13198 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
13200 /* Check to see if the given reloc needs to be handled in a target specific
13201 manner. If so then process the reloc and return TRUE otherwise return
13204 If called with reloc == NULL, then this is a signal that reloc processing
13205 for the current section has finished, and any saved state should be
13209 target_specific_reloc_handling (Filedata
* filedata
,
13210 Elf_Internal_Rela
* reloc
,
13211 unsigned char * start
,
13212 unsigned char * end
,
13213 Elf_Internal_Sym
* symtab
,
13214 unsigned long num_syms
)
13216 unsigned int reloc_type
= 0;
13217 unsigned long sym_index
= 0;
13221 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
13222 sym_index
= get_reloc_symindex (reloc
->r_info
);
13225 switch (filedata
->file_header
.e_machine
)
13228 case EM_MSP430_OLD
:
13230 static Elf_Internal_Sym
* saved_sym
= NULL
;
13238 switch (reloc_type
)
13240 case 10: /* R_MSP430_SYM_DIFF */
13241 case 12: /* R_MSP430_GNU_SUB_ULEB128 */
13242 if (uses_msp430x_relocs (filedata
))
13244 /* Fall through. */
13245 case 21: /* R_MSP430X_SYM_DIFF */
13246 case 23: /* R_MSP430X_GNU_SUB_ULEB128 */
13248 if (sym_index
>= num_syms
)
13249 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
13252 saved_sym
= symtab
+ sym_index
;
13255 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
13256 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
13257 goto handle_sym_diff
;
13259 case 5: /* R_MSP430_16_BYTE */
13260 case 9: /* R_MSP430_8 */
13261 case 11: /* R_MSP430_GNU_SET_ULEB128 */
13262 if (uses_msp430x_relocs (filedata
))
13264 goto handle_sym_diff
;
13266 case 2: /* R_MSP430_ABS16 */
13267 case 15: /* R_MSP430X_ABS16 */
13268 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
13269 if (! uses_msp430x_relocs (filedata
))
13271 goto handle_sym_diff
;
13274 if (saved_sym
!= NULL
)
13277 unsigned int reloc_size
= 0;
13279 switch (reloc_type
)
13281 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
13284 case 11: /* R_MSP430_GNU_SET_ULEB128 */
13285 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
13286 if (reloc
->r_offset
< (size_t) (end
- start
))
13287 read_leb128 (start
+ reloc
->r_offset
, end
, false,
13288 &reloc_size
, &leb_ret
);
13295 if (leb_ret
!= 0 || reloc_size
== 0 || reloc_size
> 8)
13296 error (_("MSP430 ULEB128 field at 0x%lx contains invalid "
13297 "ULEB128 value\n"),
13298 (long) reloc
->r_offset
);
13299 else if (sym_index
>= num_syms
)
13300 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
13304 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
13305 - saved_sym
->st_value
);
13307 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
13308 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
13311 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
13312 (long) reloc
->r_offset
);
13321 if (saved_sym
!= NULL
)
13322 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13329 case EM_CYGNUS_MN10300
:
13331 static Elf_Internal_Sym
* saved_sym
= NULL
;
13339 switch (reloc_type
)
13341 case 34: /* R_MN10300_ALIGN */
13343 case 33: /* R_MN10300_SYM_DIFF */
13344 if (sym_index
>= num_syms
)
13345 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
13348 saved_sym
= symtab
+ sym_index
;
13351 case 1: /* R_MN10300_32 */
13352 case 2: /* R_MN10300_16 */
13353 if (saved_sym
!= NULL
)
13355 int reloc_size
= reloc_type
== 1 ? 4 : 2;
13358 if (sym_index
>= num_syms
)
13359 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
13363 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
13364 - saved_sym
->st_value
);
13366 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
13367 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
13369 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
13370 (long) reloc
->r_offset
);
13378 if (saved_sym
!= NULL
)
13379 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
13387 static bfd_vma saved_sym1
= 0;
13388 static bfd_vma saved_sym2
= 0;
13389 static bfd_vma value
;
13393 saved_sym1
= saved_sym2
= 0;
13397 switch (reloc_type
)
13399 case 0x80: /* R_RL78_SYM. */
13400 saved_sym1
= saved_sym2
;
13401 if (sym_index
>= num_syms
)
13402 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
13406 saved_sym2
= symtab
[sym_index
].st_value
;
13407 saved_sym2
+= reloc
->r_addend
;
13411 case 0x83: /* R_RL78_OPsub. */
13412 value
= saved_sym1
- saved_sym2
;
13413 saved_sym2
= saved_sym1
= 0;
13417 case 0x41: /* R_RL78_ABS32. */
13418 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
13419 byte_put (start
+ reloc
->r_offset
, value
, 4);
13421 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
13422 (long) reloc
->r_offset
);
13426 case 0x43: /* R_RL78_ABS16. */
13427 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
13428 byte_put (start
+ reloc
->r_offset
, value
, 2);
13430 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
13431 (long) reloc
->r_offset
);
13445 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
13446 DWARF debug sections. This is a target specific test. Note - we do not
13447 go through the whole including-target-headers-multiple-times route, (as
13448 we have already done with <elf/h8.h>) because this would become very
13449 messy and even then this function would have to contain target specific
13450 information (the names of the relocs instead of their numeric values).
13451 FIXME: This is not the correct way to solve this problem. The proper way
13452 is to have target specific reloc sizing and typing functions created by
13453 the reloc-macros.h header, in the same way that it already creates the
13454 reloc naming functions. */
13457 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13459 /* Please keep this table alpha-sorted for ease of visual lookup. */
13460 switch (filedata
->file_header
.e_machine
)
13464 return reloc_type
== 1; /* R_386_32. */
13466 return reloc_type
== 1; /* R_68K_32. */
13468 return reloc_type
== 1; /* R_860_32. */
13470 return reloc_type
== 2; /* R_960_32. */
13472 return (reloc_type
== 258
13473 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
13475 return reloc_type
== 11; /* R_BPF_DATA_32 */
13476 case EM_ADAPTEVA_EPIPHANY
:
13477 return reloc_type
== 3;
13479 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
13481 return reloc_type
== 1; /* R_ARC_32. */
13482 case EM_ARC_COMPACT
:
13483 case EM_ARC_COMPACT2
:
13484 return reloc_type
== 4; /* R_ARC_32. */
13486 return reloc_type
== 2; /* R_ARM_ABS32 */
13489 return reloc_type
== 1;
13491 return reloc_type
== 0x12; /* R_byte4_data. */
13493 return reloc_type
== 3; /* R_CRIS_32. */
13495 return reloc_type
== 3; /* R_CR16_NUM32. */
13497 return reloc_type
== 15; /* R_CRX_NUM32. */
13499 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
13500 case EM_CYGNUS_FRV
:
13501 return reloc_type
== 1;
13502 case EM_CYGNUS_D10V
:
13504 return reloc_type
== 6; /* R_D10V_32. */
13505 case EM_CYGNUS_D30V
:
13507 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
13509 return reloc_type
== 3; /* R_DLX_RELOC_32. */
13510 case EM_CYGNUS_FR30
:
13512 return reloc_type
== 3; /* R_FR30_32. */
13514 return reloc_type
== 1; /* R_FT32_32. */
13518 return reloc_type
== 1; /* R_H8_DIR32. */
13520 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
13521 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
13522 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
13523 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
13526 return reloc_type
== 2; /* R_IP2K_32. */
13528 return reloc_type
== 2; /* R_IQ2000_32. */
13529 case EM_LATTICEMICO32
:
13530 return reloc_type
== 3; /* R_LM32_32. */
13533 return reloc_type
== 3; /* R_M32C_32. */
13535 return reloc_type
== 34; /* R_M32R_32_RELA. */
13538 return reloc_type
== 6; /* R_M68HC11_32. */
13540 return reloc_type
== 7 || /* R_S12Z_EXT32 */
13541 reloc_type
== 6; /* R_S12Z_CW32. */
13543 return reloc_type
== 1; /* R_MCORE_ADDR32. */
13544 case EM_CYGNUS_MEP
:
13545 return reloc_type
== 4; /* R_MEP_32. */
13547 return reloc_type
== 2; /* R_METAG_ADDR32. */
13548 case EM_MICROBLAZE
:
13549 return reloc_type
== 1; /* R_MICROBLAZE_32. */
13551 return reloc_type
== 2; /* R_MIPS_32. */
13553 return reloc_type
== 4; /* R_MMIX_32. */
13554 case EM_CYGNUS_MN10200
:
13556 return reloc_type
== 1; /* R_MN10200_32. */
13557 case EM_CYGNUS_MN10300
:
13559 return reloc_type
== 1; /* R_MN10300_32. */
13561 return reloc_type
== 1; /* R_MOXIE_32. */
13562 case EM_MSP430_OLD
:
13564 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
13566 return reloc_type
== 2; /* R_MT_32. */
13568 return reloc_type
== 20; /* R_NDS32_RELA. */
13569 case EM_ALTERA_NIOS2
:
13570 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
13572 return reloc_type
== 1; /* R_NIOS_32. */
13574 return reloc_type
== 1; /* R_OR1K_32. */
13576 return (reloc_type
== 1 /* R_PARISC_DIR32. */
13577 || reloc_type
== 2 /* R_PARISC_DIR21L. */
13578 || reloc_type
== 41); /* R_PARISC_SECREL32. */
13581 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
13583 return reloc_type
== 1; /* R_PPC64_ADDR32. */
13585 return reloc_type
== 1; /* R_PPC_ADDR32. */
13587 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
13589 return reloc_type
== 1; /* R_RISCV_32. */
13591 return reloc_type
== 1; /* R_RL78_DIR32. */
13593 return reloc_type
== 1; /* R_RX_DIR32. */
13595 return reloc_type
== 1; /* R_I370_ADDR31. */
13598 return reloc_type
== 4; /* R_S390_32. */
13600 return reloc_type
== 8; /* R_SCORE_ABS32. */
13602 return reloc_type
== 1; /* R_SH_DIR32. */
13603 case EM_SPARC32PLUS
:
13606 return reloc_type
== 3 /* R_SPARC_32. */
13607 || reloc_type
== 23; /* R_SPARC_UA32. */
13609 return reloc_type
== 6; /* R_SPU_ADDR32 */
13611 return reloc_type
== 1; /* R_C6000_ABS32. */
13613 return reloc_type
== 2; /* R_TILEGX_32. */
13615 return reloc_type
== 1; /* R_TILEPRO_32. */
13616 case EM_CYGNUS_V850
:
13618 return reloc_type
== 6; /* R_V850_ABS32. */
13620 return reloc_type
== 0x33; /* R_V810_WORD. */
13622 return reloc_type
== 1; /* R_VAX_32. */
13624 return reloc_type
== 3; /* R_VISIUM_32. */
13625 case EM_WEBASSEMBLY
:
13626 return reloc_type
== 1; /* R_WASM32_32. */
13630 return reloc_type
== 10; /* R_X86_64_32. */
13633 return reloc_type
== 3; /* R_XC16C_ABS_32. */
13635 return reloc_type
== 4; /* R_XGATE_32. */
13637 return reloc_type
== 1; /* R_XSTROMY16_32. */
13638 case EM_XTENSA_OLD
:
13640 return reloc_type
== 1; /* R_XTENSA_32. */
13642 return reloc_type
== 6; /* R_Z80_32. */
13645 static unsigned int prev_warn
= 0;
13647 /* Avoid repeating the same warning multiple times. */
13648 if (prev_warn
!= filedata
->file_header
.e_machine
)
13649 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
13650 filedata
->file_header
.e_machine
);
13651 prev_warn
= filedata
->file_header
.e_machine
;
13657 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13658 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
13661 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13663 switch (filedata
->file_header
.e_machine
)
13664 /* Please keep this table alpha-sorted for ease of visual lookup. */
13668 return reloc_type
== 2; /* R_386_PC32. */
13670 return reloc_type
== 4; /* R_68K_PC32. */
13672 return reloc_type
== 261; /* R_AARCH64_PREL32 */
13673 case EM_ADAPTEVA_EPIPHANY
:
13674 return reloc_type
== 6;
13676 return reloc_type
== 10; /* R_ALPHA_SREL32. */
13677 case EM_ARC_COMPACT
:
13678 case EM_ARC_COMPACT2
:
13679 return reloc_type
== 49; /* R_ARC_32_PCREL. */
13681 return reloc_type
== 3; /* R_ARM_REL32 */
13684 return reloc_type
== 36; /* R_AVR_32_PCREL. */
13685 case EM_MICROBLAZE
:
13686 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
13688 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
13690 return reloc_type
== 9; /* R_PARISC_PCREL32. */
13692 return reloc_type
== 26; /* R_PPC_REL32. */
13694 return reloc_type
== 26; /* R_PPC64_REL32. */
13696 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
13699 return reloc_type
== 5; /* R_390_PC32. */
13701 return reloc_type
== 2; /* R_SH_REL32. */
13702 case EM_SPARC32PLUS
:
13705 return reloc_type
== 6; /* R_SPARC_DISP32. */
13707 return reloc_type
== 13; /* R_SPU_REL32. */
13709 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
13711 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
13713 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
13717 return reloc_type
== 2; /* R_X86_64_PC32. */
13719 return reloc_type
== 4; /* R_VAX_PCREL32. */
13720 case EM_XTENSA_OLD
:
13722 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
13724 /* Do not abort or issue an error message here. Not all targets use
13725 pc-relative 32-bit relocs in their DWARF debug information and we
13726 have already tested for target coverage in is_32bit_abs_reloc. A
13727 more helpful warning message will be generated by apply_relocations
13728 anyway, so just return. */
13733 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13734 a 64-bit absolute RELA relocation used in DWARF debug sections. */
13737 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13739 switch (filedata
->file_header
.e_machine
)
13742 return reloc_type
== 257; /* R_AARCH64_ABS64. */
13744 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
13746 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
13747 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
13749 return reloc_type
== 80; /* R_PARISC_DIR64. */
13751 return reloc_type
== 38; /* R_PPC64_ADDR64. */
13753 return reloc_type
== 2; /* R_RISCV_64. */
13754 case EM_SPARC32PLUS
:
13757 return reloc_type
== 32 /* R_SPARC_64. */
13758 || reloc_type
== 54; /* R_SPARC_UA64. */
13762 return reloc_type
== 1; /* R_X86_64_64. */
13765 return reloc_type
== 22; /* R_S390_64. */
13767 return reloc_type
== 1; /* R_TILEGX_64. */
13769 return reloc_type
== 18; /* R_MIPS_64. */
13775 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
13776 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
13779 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13781 switch (filedata
->file_header
.e_machine
)
13784 return reloc_type
== 260; /* R_AARCH64_PREL64. */
13786 return reloc_type
== 11; /* R_ALPHA_SREL64. */
13788 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
13789 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
13791 return reloc_type
== 72; /* R_PARISC_PCREL64. */
13793 return reloc_type
== 44; /* R_PPC64_REL64. */
13794 case EM_SPARC32PLUS
:
13797 return reloc_type
== 46; /* R_SPARC_DISP64. */
13801 return reloc_type
== 24; /* R_X86_64_PC64. */
13804 return reloc_type
== 23; /* R_S390_PC64. */
13806 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
13812 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13813 a 24-bit absolute RELA relocation used in DWARF debug sections. */
13816 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13818 switch (filedata
->file_header
.e_machine
)
13820 case EM_CYGNUS_MN10200
:
13822 return reloc_type
== 4; /* R_MN10200_24. */
13824 return reloc_type
== 5; /* R_FT32_20. */
13826 return reloc_type
== 5; /* R_Z80_24. */
13832 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13833 a 16-bit absolute RELA relocation used in DWARF debug sections. */
13836 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13838 /* Please keep this table alpha-sorted for ease of visual lookup. */
13839 switch (filedata
->file_header
.e_machine
)
13842 case EM_ARC_COMPACT
:
13843 case EM_ARC_COMPACT2
:
13844 return reloc_type
== 2; /* R_ARC_16. */
13845 case EM_ADAPTEVA_EPIPHANY
:
13846 return reloc_type
== 5;
13849 return reloc_type
== 4; /* R_AVR_16. */
13850 case EM_CYGNUS_D10V
:
13852 return reloc_type
== 3; /* R_D10V_16. */
13854 return reloc_type
== 2; /* R_FT32_16. */
13858 return reloc_type
== R_H8_DIR16
;
13861 return reloc_type
== 1; /* R_IP2K_16. */
13864 return reloc_type
== 1; /* R_M32C_16 */
13865 case EM_CYGNUS_MN10200
:
13867 return reloc_type
== 2; /* R_MN10200_16. */
13868 case EM_CYGNUS_MN10300
:
13870 return reloc_type
== 2; /* R_MN10300_16. */
13872 if (uses_msp430x_relocs (filedata
))
13873 return reloc_type
== 2; /* R_MSP430_ABS16. */
13874 /* Fall through. */
13875 case EM_MSP430_OLD
:
13876 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13878 return reloc_type
== 19; /* R_NDS32_RELA. */
13879 case EM_ALTERA_NIOS2
:
13880 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13882 return reloc_type
== 9; /* R_NIOS_16. */
13884 return reloc_type
== 2; /* R_OR1K_16. */
13886 return reloc_type
== 55; /* R_RISCV_SET16. */
13888 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13890 return reloc_type
== 2; /* R_C6000_ABS16. */
13892 return reloc_type
== 2; /* R_VISIUM_16. */
13895 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13897 return reloc_type
== 3; /* R_XGATE_16. */
13899 return reloc_type
== 4; /* R_Z80_16. */
13905 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13906 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13909 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13911 switch (filedata
->file_header
.e_machine
)
13914 return reloc_type
== 54; /* R_RISCV_SET8. */
13916 return reloc_type
== 1; /* R_Z80_8. */
13922 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13923 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13926 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13928 switch (filedata
->file_header
.e_machine
)
13931 return reloc_type
== 53; /* R_RISCV_SET6. */
13937 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13938 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13941 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13943 /* Please keep this table alpha-sorted for ease of visual lookup. */
13944 switch (filedata
->file_header
.e_machine
)
13947 return reloc_type
== 35; /* R_RISCV_ADD32. */
13953 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13954 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13957 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13959 /* Please keep this table alpha-sorted for ease of visual lookup. */
13960 switch (filedata
->file_header
.e_machine
)
13963 return reloc_type
== 39; /* R_RISCV_SUB32. */
13969 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13970 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13973 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13975 /* Please keep this table alpha-sorted for ease of visual lookup. */
13976 switch (filedata
->file_header
.e_machine
)
13979 return reloc_type
== 36; /* R_RISCV_ADD64. */
13985 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13986 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13989 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13991 /* Please keep this table alpha-sorted for ease of visual lookup. */
13992 switch (filedata
->file_header
.e_machine
)
13995 return reloc_type
== 40; /* R_RISCV_SUB64. */
14001 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14002 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
14005 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14007 /* Please keep this table alpha-sorted for ease of visual lookup. */
14008 switch (filedata
->file_header
.e_machine
)
14011 return reloc_type
== 34; /* R_RISCV_ADD16. */
14017 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14018 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
14021 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14023 /* Please keep this table alpha-sorted for ease of visual lookup. */
14024 switch (filedata
->file_header
.e_machine
)
14027 return reloc_type
== 38; /* R_RISCV_SUB16. */
14033 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14034 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
14037 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14039 /* Please keep this table alpha-sorted for ease of visual lookup. */
14040 switch (filedata
->file_header
.e_machine
)
14043 return reloc_type
== 33; /* R_RISCV_ADD8. */
14049 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14050 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
14053 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14055 /* Please keep this table alpha-sorted for ease of visual lookup. */
14056 switch (filedata
->file_header
.e_machine
)
14059 return reloc_type
== 37; /* R_RISCV_SUB8. */
14065 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14066 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
14069 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14071 switch (filedata
->file_header
.e_machine
)
14074 return reloc_type
== 52; /* R_RISCV_SUB6. */
14080 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
14081 relocation entries (possibly formerly used for SHT_GROUP sections). */
14084 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14086 switch (filedata
->file_header
.e_machine
)
14088 case EM_386
: /* R_386_NONE. */
14089 case EM_68K
: /* R_68K_NONE. */
14090 case EM_ADAPTEVA_EPIPHANY
:
14091 case EM_ALPHA
: /* R_ALPHA_NONE. */
14092 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
14093 case EM_ARC
: /* R_ARC_NONE. */
14094 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
14095 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
14096 case EM_ARM
: /* R_ARM_NONE. */
14097 case EM_C166
: /* R_XC16X_NONE. */
14098 case EM_CRIS
: /* R_CRIS_NONE. */
14099 case EM_FT32
: /* R_FT32_NONE. */
14100 case EM_IA_64
: /* R_IA64_NONE. */
14101 case EM_K1OM
: /* R_X86_64_NONE. */
14102 case EM_L1OM
: /* R_X86_64_NONE. */
14103 case EM_M32R
: /* R_M32R_NONE. */
14104 case EM_MIPS
: /* R_MIPS_NONE. */
14105 case EM_MN10300
: /* R_MN10300_NONE. */
14106 case EM_MOXIE
: /* R_MOXIE_NONE. */
14107 case EM_NIOS32
: /* R_NIOS_NONE. */
14108 case EM_OR1K
: /* R_OR1K_NONE. */
14109 case EM_PARISC
: /* R_PARISC_NONE. */
14110 case EM_PPC64
: /* R_PPC64_NONE. */
14111 case EM_PPC
: /* R_PPC_NONE. */
14112 case EM_RISCV
: /* R_RISCV_NONE. */
14113 case EM_S390
: /* R_390_NONE. */
14115 case EM_SH
: /* R_SH_NONE. */
14116 case EM_SPARC32PLUS
:
14117 case EM_SPARC
: /* R_SPARC_NONE. */
14119 case EM_TILEGX
: /* R_TILEGX_NONE. */
14120 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
14121 case EM_TI_C6000
:/* R_C6000_NONE. */
14122 case EM_X86_64
: /* R_X86_64_NONE. */
14124 case EM_Z80
: /* R_Z80_NONE. */
14125 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
14126 return reloc_type
== 0;
14129 return reloc_type
== 0 || reloc_type
== 256;
14132 return (reloc_type
== 0 /* R_AVR_NONE. */
14133 || reloc_type
== 30 /* R_AVR_DIFF8. */
14134 || reloc_type
== 31 /* R_AVR_DIFF16. */
14135 || reloc_type
== 32 /* R_AVR_DIFF32. */);
14137 return reloc_type
== 3; /* R_METAG_NONE. */
14139 return (reloc_type
== 0 /* R_XTENSA_NONE. */
14140 || reloc_type
== 204 /* R_NDS32_DIFF8. */
14141 || reloc_type
== 205 /* R_NDS32_DIFF16. */
14142 || reloc_type
== 206 /* R_NDS32_DIFF32. */
14143 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
14145 return (reloc_type
== 0 /* R_PRU_NONE. */
14146 || reloc_type
== 65 /* R_PRU_DIFF8. */
14147 || reloc_type
== 66 /* R_PRU_DIFF16. */
14148 || reloc_type
== 67 /* R_PRU_DIFF32. */);
14149 case EM_XTENSA_OLD
:
14151 return (reloc_type
== 0 /* R_XTENSA_NONE. */
14152 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
14153 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
14154 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
14155 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
14156 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
14157 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
14158 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
14159 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
14160 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
14165 /* Returns TRUE if there is a relocation against
14166 section NAME at OFFSET bytes. */
14169 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
14171 Elf_Internal_Rela
* relocs
;
14172 Elf_Internal_Rela
* rp
;
14174 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
14177 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
14179 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
14180 if (rp
->r_offset
== offset
)
14186 /* Apply relocations to a section.
14187 Returns TRUE upon success, FALSE otherwise.
14188 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
14189 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
14190 will be set to the number of relocs loaded.
14192 Note: So far support has been added only for those relocations
14193 which can be found in debug sections. FIXME: Add support for
14194 more relocations ? */
14197 apply_relocations (Filedata
* filedata
,
14198 const Elf_Internal_Shdr
* section
,
14199 unsigned char * start
,
14200 bfd_size_type size
,
14201 void ** relocs_return
,
14202 unsigned long * num_relocs_return
)
14204 Elf_Internal_Shdr
* relsec
;
14205 unsigned char * end
= start
+ size
;
14207 if (relocs_return
!= NULL
)
14209 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
14210 * num_relocs_return
= 0;
14213 if (filedata
->file_header
.e_type
!= ET_REL
)
14214 /* No relocs to apply. */
14217 /* Find the reloc section associated with the section. */
14218 for (relsec
= filedata
->section_headers
;
14219 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14223 unsigned long num_relocs
;
14224 Elf_Internal_Rela
* relocs
;
14225 Elf_Internal_Rela
* rp
;
14226 Elf_Internal_Shdr
* symsec
;
14227 Elf_Internal_Sym
* symtab
;
14228 unsigned long num_syms
;
14229 Elf_Internal_Sym
* sym
;
14231 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14232 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14233 || filedata
->section_headers
+ relsec
->sh_info
!= section
14234 || relsec
->sh_size
== 0
14235 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14238 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
14239 if (symsec
->sh_type
!= SHT_SYMTAB
14240 && symsec
->sh_type
!= SHT_DYNSYM
)
14243 is_rela
= relsec
->sh_type
== SHT_RELA
;
14247 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
14248 relsec
->sh_size
, & relocs
, & num_relocs
))
14253 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
14254 relsec
->sh_size
, & relocs
, & num_relocs
))
14258 /* SH uses RELA but uses in place value instead of the addend field. */
14259 if (filedata
->file_header
.e_machine
== EM_SH
)
14262 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
14264 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
14267 unsigned int reloc_type
;
14268 unsigned int reloc_size
;
14269 bool reloc_inplace
= false;
14270 bool reloc_subtract
= false;
14271 unsigned char *rloc
;
14272 unsigned long sym_index
;
14274 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
14276 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
14278 else if (is_none_reloc (filedata
, reloc_type
))
14280 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
14281 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
14283 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
14284 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
14286 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
14288 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
14290 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
14291 || is_6bit_abs_reloc (filedata
, reloc_type
))
14293 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
14295 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
14298 reloc_inplace
= true;
14300 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
14302 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
14305 reloc_inplace
= true;
14307 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
14309 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
14312 reloc_inplace
= true;
14314 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
14316 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
14319 reloc_inplace
= true;
14321 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
14325 reloc_inplace
= true;
14329 static unsigned int prev_reloc
= 0;
14331 if (reloc_type
!= prev_reloc
)
14332 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
14333 reloc_type
, printable_section_name (filedata
, section
));
14334 prev_reloc
= reloc_type
;
14338 rloc
= start
+ rp
->r_offset
;
14339 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
14341 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
14342 (unsigned long) rp
->r_offset
,
14343 printable_section_name (filedata
, section
));
14347 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
14348 if (sym_index
>= num_syms
)
14350 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
14351 sym_index
, printable_section_name (filedata
, section
));
14354 sym
= symtab
+ sym_index
;
14356 /* If the reloc has a symbol associated with it,
14357 make sure that it is of an appropriate type.
14359 Relocations against symbols without type can happen.
14360 Gcc -feliminate-dwarf2-dups may generate symbols
14361 without type for debug info.
14363 Icc generates relocations against function symbols
14364 instead of local labels.
14366 Relocations against object symbols can happen, eg when
14367 referencing a global array. For an example of this see
14368 the _clz.o binary in libgcc.a. */
14370 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
14371 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
14373 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
14374 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
14375 printable_section_name (filedata
, relsec
),
14376 (long int)(rp
- relocs
));
14382 addend
+= rp
->r_addend
;
14383 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
14384 partial_inplace. */
14386 || (filedata
->file_header
.e_machine
== EM_XTENSA
14387 && reloc_type
== 1)
14388 || ((filedata
->file_header
.e_machine
== EM_PJ
14389 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
14390 && reloc_type
== 1)
14391 || ((filedata
->file_header
.e_machine
== EM_D30V
14392 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
14393 && reloc_type
== 12)
14396 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
14397 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
14399 addend
+= byte_get (rloc
, reloc_size
);
14402 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
14403 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
14405 /* On HPPA, all pc-relative relocations are biased by 8. */
14406 if (filedata
->file_header
.e_machine
== EM_PARISC
)
14408 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
14411 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
14412 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
14414 if (reloc_subtract
)
14415 addend
-= sym
->st_value
;
14417 addend
+= sym
->st_value
;
14418 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
14419 byte_put (rloc
, addend
, reloc_size
);
14421 else if (reloc_subtract
)
14422 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
14424 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
14428 /* Let the target specific reloc processing code know that
14429 we have finished with these relocs. */
14430 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
14434 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
14435 * num_relocs_return
= num_relocs
;
14446 #ifdef SUPPORT_DISASSEMBLY
14448 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14450 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
14452 /* FIXME: XXX -- to be done --- XXX */
14458 /* Reads in the contents of SECTION from FILE, returning a pointer
14459 to a malloc'ed buffer or NULL if something went wrong. */
14462 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14464 bfd_size_type num_bytes
= section
->sh_size
;
14466 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
14468 printf (_("Section '%s' has no data to dump.\n"),
14469 printable_section_name (filedata
, section
));
14473 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
14474 _("section contents"));
14477 /* Uncompresses a section that was compressed using zlib, in place. */
14480 uncompress_section_contents (unsigned char ** buffer
,
14481 dwarf_size_type uncompressed_size
,
14482 dwarf_size_type
* size
)
14484 dwarf_size_type compressed_size
= *size
;
14485 unsigned char * compressed_buffer
= *buffer
;
14486 unsigned char * uncompressed_buffer
;
14490 /* It is possible the section consists of several compressed
14491 buffers concatenated together, so we uncompress in a loop. */
14492 /* PR 18313: The state field in the z_stream structure is supposed
14493 to be invisible to the user (ie us), but some compilers will
14494 still complain about it being used without initialisation. So
14495 we first zero the entire z_stream structure and then set the fields
14497 memset (& strm
, 0, sizeof strm
);
14498 strm
.avail_in
= compressed_size
;
14499 strm
.next_in
= (Bytef
*) compressed_buffer
;
14500 strm
.avail_out
= uncompressed_size
;
14501 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
14503 rc
= inflateInit (& strm
);
14504 while (strm
.avail_in
> 0)
14508 strm
.next_out
= ((Bytef
*) uncompressed_buffer
14509 + (uncompressed_size
- strm
.avail_out
));
14510 rc
= inflate (&strm
, Z_FINISH
);
14511 if (rc
!= Z_STREAM_END
)
14513 rc
= inflateReset (& strm
);
14515 if (inflateEnd (& strm
) != Z_OK
14517 || strm
.avail_out
!= 0)
14520 *buffer
= uncompressed_buffer
;
14521 *size
= uncompressed_size
;
14525 free (uncompressed_buffer
);
14526 /* Indicate decompression failure. */
14532 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14534 Elf_Internal_Shdr
*relsec
;
14535 bfd_size_type num_bytes
;
14536 unsigned char *data
;
14537 unsigned char *end
;
14538 unsigned char *real_start
;
14539 unsigned char *start
;
14540 bool some_strings_shown
;
14542 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
14544 /* PR 21820: Do not fail if the section was empty. */
14545 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
14547 num_bytes
= section
->sh_size
;
14549 if (filedata
->is_separate
)
14550 printf (_("\nString dump of section '%s' in linked file %s:\n"),
14551 printable_section_name (filedata
, section
),
14552 filedata
->file_name
);
14554 printf (_("\nString dump of section '%s':\n"),
14555 printable_section_name (filedata
, section
));
14557 if (decompress_dumps
)
14559 dwarf_size_type new_size
= num_bytes
;
14560 dwarf_size_type uncompressed_size
= 0;
14562 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14564 Elf_Internal_Chdr chdr
;
14565 unsigned int compression_header_size
14566 = get_compression_header (& chdr
, (unsigned char *) start
,
14568 if (compression_header_size
== 0)
14569 /* An error message will have already been generated
14570 by get_compression_header. */
14573 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14575 warn (_("section '%s' has unsupported compress type: %d\n"),
14576 printable_section_name (filedata
, section
), chdr
.ch_type
);
14579 uncompressed_size
= chdr
.ch_size
;
14580 start
+= compression_header_size
;
14581 new_size
-= compression_header_size
;
14583 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14585 /* Read the zlib header. In this case, it should be "ZLIB"
14586 followed by the uncompressed section size, 8 bytes in
14587 big-endian order. */
14588 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14589 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14590 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14591 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14592 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14593 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14594 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14595 uncompressed_size
+= start
[11];
14600 if (uncompressed_size
)
14602 if (uncompress_section_contents (& start
,
14603 uncompressed_size
, & new_size
))
14604 num_bytes
= new_size
;
14607 error (_("Unable to decompress section %s\n"),
14608 printable_section_name (filedata
, section
));
14613 start
= real_start
;
14616 /* If the section being dumped has relocations against it the user might
14617 be expecting these relocations to have been applied. Check for this
14618 case and issue a warning message in order to avoid confusion.
14619 FIXME: Maybe we ought to have an option that dumps a section with
14620 relocs applied ? */
14621 for (relsec
= filedata
->section_headers
;
14622 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14625 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14626 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14627 || filedata
->section_headers
+ relsec
->sh_info
!= section
14628 || relsec
->sh_size
== 0
14629 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14632 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14637 end
= start
+ num_bytes
;
14638 some_strings_shown
= false;
14640 #ifdef HAVE_MBSTATE_T
14642 /* Initialise the multibyte conversion state. */
14643 memset (& state
, 0, sizeof (state
));
14646 bool continuing
= false;
14650 while (!ISPRINT (* data
))
14651 if (++ data
>= end
)
14656 size_t maxlen
= end
- data
;
14661 continuing
= false;
14665 printf (" [%6lx] ", (unsigned long) (data
- start
));
14679 /* PR 25543: Treat new-lines as string-ending characters. */
14688 /* Do not print control characters directly as they can affect terminal
14689 settings. Such characters usually appear in the names generated
14690 by the assembler for local labels. */
14693 printf ("^%c", c
+ 0x40);
14695 else if (ISPRINT (c
))
14702 #ifdef HAVE_MBSTATE_T
14705 /* Let printf do the hard work of displaying multibyte characters. */
14706 printf ("%.1s", data
- 1);
14707 #ifdef HAVE_MBSTATE_T
14708 /* Try to find out how many bytes made up the character that was
14709 just printed. Advance the symbol pointer past the bytes that
14711 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
14715 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
14725 printf (_("<corrupt>\n"));
14728 some_strings_shown
= true;
14732 if (! some_strings_shown
)
14733 printf (_(" No strings found in this section."));
14746 dump_section_as_bytes (Elf_Internal_Shdr
*section
,
14747 Filedata
*filedata
,
14750 Elf_Internal_Shdr
* relsec
;
14751 bfd_size_type bytes
;
14752 bfd_size_type section_size
;
14754 unsigned char * data
;
14755 unsigned char * real_start
;
14756 unsigned char * start
;
14758 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
14760 /* PR 21820: Do not fail if the section was empty. */
14761 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
14763 section_size
= section
->sh_size
;
14765 if (filedata
->is_separate
)
14766 printf (_("\nHex dump of section '%s' in linked file %s:\n"),
14767 printable_section_name (filedata
, section
),
14768 filedata
->file_name
);
14770 printf (_("\nHex dump of section '%s':\n"),
14771 printable_section_name (filedata
, section
));
14773 if (decompress_dumps
)
14775 dwarf_size_type new_size
= section_size
;
14776 dwarf_size_type uncompressed_size
= 0;
14778 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14780 Elf_Internal_Chdr chdr
;
14781 unsigned int compression_header_size
14782 = get_compression_header (& chdr
, start
, section_size
);
14784 if (compression_header_size
== 0)
14785 /* An error message will have already been generated
14786 by get_compression_header. */
14789 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14791 warn (_("section '%s' has unsupported compress type: %d\n"),
14792 printable_section_name (filedata
, section
), chdr
.ch_type
);
14795 uncompressed_size
= chdr
.ch_size
;
14796 start
+= compression_header_size
;
14797 new_size
-= compression_header_size
;
14799 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14801 /* Read the zlib header. In this case, it should be "ZLIB"
14802 followed by the uncompressed section size, 8 bytes in
14803 big-endian order. */
14804 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14805 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14806 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14807 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14808 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14809 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14810 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14811 uncompressed_size
+= start
[11];
14816 if (uncompressed_size
)
14818 if (uncompress_section_contents (& start
, uncompressed_size
,
14821 section_size
= new_size
;
14825 error (_("Unable to decompress section %s\n"),
14826 printable_section_name (filedata
, section
));
14827 /* FIXME: Print the section anyway ? */
14832 start
= real_start
;
14837 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
14842 /* If the section being dumped has relocations against it the user might
14843 be expecting these relocations to have been applied. Check for this
14844 case and issue a warning message in order to avoid confusion.
14845 FIXME: Maybe we ought to have an option that dumps a section with
14846 relocs applied ? */
14847 for (relsec
= filedata
->section_headers
;
14848 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14851 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14852 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14853 || filedata
->section_headers
+ relsec
->sh_info
!= section
14854 || relsec
->sh_size
== 0
14855 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14858 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14863 addr
= section
->sh_addr
;
14864 bytes
= section_size
;
14873 lbytes
= (bytes
> 16 ? 16 : bytes
);
14875 printf (" 0x%8.8lx ", (unsigned long) addr
);
14877 for (j
= 0; j
< 16; j
++)
14880 printf ("%2.2x", data
[j
]);
14888 for (j
= 0; j
< lbytes
; j
++)
14891 if (k
>= ' ' && k
< 0x7f)
14914 #ifdef ENABLE_LIBCTF
14915 static ctf_sect_t
*
14916 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14918 buf
->cts_name
= SECTION_NAME_PRINT (shdr
);
14919 buf
->cts_size
= shdr
->sh_size
;
14920 buf
->cts_entsize
= shdr
->sh_entsize
;
14925 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14926 it is passed, or a pointer to newly-allocated storage, in which case
14927 dump_ctf() will free it when it no longer needs it. */
14930 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14931 char *s
, void *arg
)
14933 const char *blanks
= arg
;
14936 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14941 /* Dump CTF errors/warnings. */
14943 dump_ctf_errs (ctf_dict_t
*fp
)
14945 ctf_next_t
*it
= NULL
;
14950 /* Dump accumulated errors and warnings. */
14951 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
14953 error (_("%s: %s"), is_warning
? _("warning"): _("error"),
14957 if (err
!= ECTF_NEXT_END
)
14958 error (_("CTF error: cannot get CTF errors: `%s'"), ctf_errmsg (err
));
14961 /* Dump one CTF archive member. */
14964 dump_ctf_archive_member (ctf_dict_t
*ctf
, const char *name
, void *arg
)
14966 ctf_dict_t
*parent
= (ctf_dict_t
*) arg
;
14967 const char *things
[] = {"Header", "Labels", "Data objects",
14968 "Function objects", "Variables", "Types", "Strings",
14970 const char **thing
;
14974 /* Only print out the name of non-default-named archive members.
14975 The name .ctf appears everywhere, even for things that aren't
14976 really archives, so printing it out is liable to be confusing.
14978 The parent, if there is one, is the default-owned archive member:
14979 avoid importing it into itself. (This does no harm, but looks
14982 if (strcmp (name
, ".ctf") != 0)
14984 printf (_("\nCTF archive member: %s:\n"), name
);
14985 ctf_import (ctf
, parent
);
14988 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14990 ctf_dump_state_t
*s
= NULL
;
14993 printf ("\n %s:\n", *thing
);
14994 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14995 (void *) " ")) != NULL
)
14997 printf ("%s\n", item
);
15001 if (ctf_errno (ctf
))
15003 error (_("Iteration failed: %s, %s\n"), *thing
,
15004 ctf_errmsg (ctf_errno (ctf
)));
15011 dump_ctf_errs (ctf
);
15016 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15018 Elf_Internal_Shdr
* parent_sec
= NULL
;
15019 Elf_Internal_Shdr
* symtab_sec
= NULL
;
15020 Elf_Internal_Shdr
* strtab_sec
= NULL
;
15021 void * data
= NULL
;
15022 void * symdata
= NULL
;
15023 void * strdata
= NULL
;
15024 void * parentdata
= NULL
;
15025 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
15026 ctf_sect_t
* symsectp
= NULL
;
15027 ctf_sect_t
* strsectp
= NULL
;
15028 ctf_archive_t
* ctfa
= NULL
;
15029 ctf_archive_t
* parenta
= NULL
, *lookparent
;
15030 ctf_dict_t
* parent
= NULL
;
15035 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
15036 data
= get_section_contents (section
, filedata
);
15037 ctfsect
.cts_data
= data
;
15039 if (!dump_ctf_symtab_name
)
15040 dump_ctf_symtab_name
= strdup (".dynsym");
15042 if (!dump_ctf_strtab_name
)
15043 dump_ctf_strtab_name
= strdup (".dynstr");
15045 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
15047 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
15049 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
15052 if ((symdata
= (void *) get_data (NULL
, filedata
,
15053 symtab_sec
->sh_offset
, 1,
15054 symtab_sec
->sh_size
,
15055 _("symbols"))) == NULL
)
15057 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
15058 symsect
.cts_data
= symdata
;
15061 if (dump_ctf_strtab_name
&& dump_ctf_strtab_name
[0] != 0)
15063 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
15065 error (_("No string table section named %s\n"),
15066 dump_ctf_strtab_name
);
15069 if ((strdata
= (void *) get_data (NULL
, filedata
,
15070 strtab_sec
->sh_offset
, 1,
15071 strtab_sec
->sh_size
,
15072 _("strings"))) == NULL
)
15074 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
15075 strsect
.cts_data
= strdata
;
15078 if (dump_ctf_parent_name
)
15080 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
15082 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
15085 if ((parentdata
= (void *) get_data (NULL
, filedata
,
15086 parent_sec
->sh_offset
, 1,
15087 parent_sec
->sh_size
,
15088 _("CTF parent"))) == NULL
)
15090 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
15091 parentsect
.cts_data
= parentdata
;
15094 /* Load the CTF file and dump it. It may be a raw CTF section, or an archive:
15095 libctf papers over the difference, so we can pretend it is always an
15096 archive. Possibly open the parent as well, if one was specified. */
15098 if ((ctfa
= ctf_arc_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
15100 dump_ctf_errs (NULL
);
15101 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15105 ctf_arc_symsect_endianness (ctfa
, filedata
->file_header
.e_ident
[EI_DATA
]
15110 if ((parenta
= ctf_arc_bufopen (&parentsect
, symsectp
, strsectp
,
15113 dump_ctf_errs (NULL
);
15114 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15117 lookparent
= parenta
;
15122 /* Assume that the applicable parent archive member is the default one.
15123 (This is what all known implementations are expected to do, if they
15124 put CTFs and their parents in archives together.) */
15125 if ((parent
= ctf_dict_open (lookparent
, NULL
, &err
)) == NULL
)
15127 dump_ctf_errs (NULL
);
15128 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15134 if (filedata
->is_separate
)
15135 printf (_("\nDump of CTF section '%s' in linked file %s:\n"),
15136 printable_section_name (filedata
, section
),
15137 filedata
->file_name
);
15139 printf (_("\nDump of CTF section '%s':\n"),
15140 printable_section_name (filedata
, section
));
15142 if ((err
= ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
)) != 0)
15144 dump_ctf_errs (NULL
);
15145 error (_("CTF member open failure: %s\n"), ctf_errmsg (err
));
15150 ctf_dict_close (parent
);
15152 ctf_close (parenta
);
15162 load_specific_debug_section (enum dwarf_section_display_enum debug
,
15163 const Elf_Internal_Shdr
* sec
,
15166 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15168 Filedata
* filedata
= (Filedata
*) data
;
15170 if (section
->start
!= NULL
)
15172 /* If it is already loaded, do nothing. */
15173 if (streq (section
->filename
, filedata
->file_name
))
15175 free (section
->start
);
15178 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
15179 section
->address
= sec
->sh_addr
;
15180 section
->filename
= filedata
->file_name
;
15181 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
15183 sec
->sh_size
, buf
);
15184 if (section
->start
== NULL
)
15188 unsigned char *start
= section
->start
;
15189 dwarf_size_type size
= sec
->sh_size
;
15190 dwarf_size_type uncompressed_size
= 0;
15192 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
15194 Elf_Internal_Chdr chdr
;
15195 unsigned int compression_header_size
;
15197 if (size
< (is_32bit_elf
15198 ? sizeof (Elf32_External_Chdr
)
15199 : sizeof (Elf64_External_Chdr
)))
15201 warn (_("compressed section %s is too small to contain a compression header\n"),
15206 compression_header_size
= get_compression_header (&chdr
, start
, size
);
15207 if (compression_header_size
== 0)
15208 /* An error message will have already been generated
15209 by get_compression_header. */
15212 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
15214 warn (_("section '%s' has unsupported compress type: %d\n"),
15215 section
->name
, chdr
.ch_type
);
15218 uncompressed_size
= chdr
.ch_size
;
15219 start
+= compression_header_size
;
15220 size
-= compression_header_size
;
15222 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
15224 /* Read the zlib header. In this case, it should be "ZLIB"
15225 followed by the uncompressed section size, 8 bytes in
15226 big-endian order. */
15227 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
15228 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
15229 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
15230 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
15231 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
15232 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
15233 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
15234 uncompressed_size
+= start
[11];
15239 if (uncompressed_size
)
15241 if (uncompress_section_contents (&start
, uncompressed_size
,
15244 /* Free the compressed buffer, update the section buffer
15245 and the section size if uncompress is successful. */
15246 free (section
->start
);
15247 section
->start
= start
;
15251 error (_("Unable to decompress section %s\n"),
15252 printable_section_name (filedata
, sec
));
15257 section
->size
= size
;
15260 if (section
->start
== NULL
)
15263 if (debug_displays
[debug
].relocate
)
15265 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
15266 & section
->reloc_info
, & section
->num_relocs
))
15271 section
->reloc_info
= NULL
;
15272 section
->num_relocs
= 0;
15278 #if HAVE_LIBDEBUGINFOD
15279 /* Return a hex string representation of the build-id. */
15281 get_build_id (void * data
)
15283 Filedata
* filedata
= (Filedata
*) data
;
15284 Elf_Internal_Shdr
* shdr
;
15287 /* Iterate through notes to find note.gnu.build-id.
15288 FIXME: Only the first note in any note section is examined. */
15289 for (i
= 0, shdr
= filedata
->section_headers
;
15290 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
15293 if (shdr
->sh_type
!= SHT_NOTE
)
15298 size_t data_remaining
;
15300 Elf_External_Note
* enote
;
15301 Elf_Internal_Note inote
;
15303 bfd_vma offset
= shdr
->sh_offset
;
15304 bfd_vma align
= shdr
->sh_addralign
;
15305 bfd_vma length
= shdr
->sh_size
;
15307 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
15313 else if (align
!= 4 && align
!= 8)
15319 end
= (char *) enote
+ length
;
15320 data_remaining
= end
- (char *) enote
;
15322 if (!is_ia64_vms (filedata
))
15324 min_notesz
= offsetof (Elf_External_Note
, name
);
15325 if (data_remaining
< min_notesz
)
15328 malformed note encountered in section %s whilst scanning for build-id note\n"),
15329 printable_section_name (filedata
, shdr
));
15333 data_remaining
-= min_notesz
;
15335 inote
.type
= BYTE_GET (enote
->type
);
15336 inote
.namesz
= BYTE_GET (enote
->namesz
);
15337 inote
.namedata
= enote
->name
;
15338 inote
.descsz
= BYTE_GET (enote
->descsz
);
15339 inote
.descdata
= ((char *) enote
15340 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
15341 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
15342 next
= ((char *) enote
15343 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
15347 Elf64_External_VMS_Note
*vms_enote
;
15349 /* PR binutils/15191
15350 Make sure that there is enough data to read. */
15351 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
15352 if (data_remaining
< min_notesz
)
15355 malformed note encountered in section %s whilst scanning for build-id note\n"),
15356 printable_section_name (filedata
, shdr
));
15360 data_remaining
-= min_notesz
;
15362 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
15363 inote
.type
= BYTE_GET (vms_enote
->type
);
15364 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
15365 inote
.namedata
= vms_enote
->name
;
15366 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
15367 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
15368 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
15369 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
15372 /* Skip malformed notes. */
15373 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
15374 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
15375 || (size_t) (next
- inote
.descdata
) < inote
.descsz
15376 || ((size_t) (next
- inote
.descdata
)
15377 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
15380 malformed note encountered in section %s whilst scanning for build-id note\n"),
15381 printable_section_name (filedata
, shdr
));
15386 /* Check if this is the build-id note. If so then convert the build-id
15387 bytes to a hex string. */
15388 if (inote
.namesz
> 0
15389 && startswith (inote
.namedata
, "GNU")
15390 && inote
.type
== NT_GNU_BUILD_ID
)
15395 build_id
= malloc (inote
.descsz
* 2 + 1);
15396 if (build_id
== NULL
)
15402 for (j
= 0; j
< inote
.descsz
; ++j
)
15403 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
15404 build_id
[inote
.descsz
* 2] = '\0';
15407 return (unsigned char *) build_id
;
15414 #endif /* HAVE_LIBDEBUGINFOD */
15416 /* If this is not NULL, load_debug_section will only look for sections
15417 within the list of sections given here. */
15418 static unsigned int * section_subset
= NULL
;
15421 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
15423 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15424 Elf_Internal_Shdr
* sec
;
15425 Filedata
* filedata
= (Filedata
*) data
;
15427 /* Without section headers we cannot find any sections. */
15428 if (filedata
->section_headers
== NULL
)
15431 if (filedata
->string_table
== NULL
15432 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
15433 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
15435 Elf_Internal_Shdr
* strs
;
15437 /* Read in the string table, so that we have section names to scan. */
15438 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
15440 if (strs
!= NULL
&& strs
->sh_size
!= 0)
15442 filedata
->string_table
15443 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
15444 1, strs
->sh_size
, _("string table"));
15446 filedata
->string_table_length
15447 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
15451 /* Locate the debug section. */
15452 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
15454 section
->name
= section
->uncompressed_name
;
15457 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
15459 section
->name
= section
->compressed_name
;
15464 /* If we're loading from a subset of sections, and we've loaded
15465 a section matching this name before, it's likely that it's a
15467 if (section_subset
!= NULL
)
15468 free_debug_section (debug
);
15470 return load_specific_debug_section (debug
, sec
, data
);
15474 free_debug_section (enum dwarf_section_display_enum debug
)
15476 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15478 if (section
->start
== NULL
)
15481 free ((char *) section
->start
);
15482 section
->start
= NULL
;
15483 section
->address
= 0;
15486 free (section
->reloc_info
);
15487 section
->reloc_info
= NULL
;
15488 section
->num_relocs
= 0;
15492 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15494 char * name
= SECTION_NAME_VALID (section
) ? SECTION_NAME (section
) : "";
15495 const char * print_name
= printable_section_name (filedata
, section
);
15496 bfd_size_type length
;
15497 bool result
= true;
15500 length
= section
->sh_size
;
15503 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
15506 if (section
->sh_type
== SHT_NOBITS
)
15508 /* There is no point in dumping the contents of a debugging section
15509 which has the NOBITS type - the bits in the file will be random.
15510 This can happen when a file containing a .eh_frame section is
15511 stripped with the --only-keep-debug command line option. */
15512 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
15517 if (startswith (name
, ".gnu.linkonce.wi."))
15518 name
= ".debug_info";
15520 /* See if we know how to display the contents of this section. */
15521 for (i
= 0; i
< max
; i
++)
15523 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
15524 struct dwarf_section_display
* display
= debug_displays
+ i
;
15525 struct dwarf_section
* sec
= & display
->section
;
15527 if (streq (sec
->uncompressed_name
, name
)
15528 || (id
== line
&& startswith (name
, ".debug_line."))
15529 || streq (sec
->compressed_name
, name
))
15531 bool secondary
= (section
!= find_section (filedata
, name
));
15534 free_debug_section (id
);
15536 if (i
== line
&& startswith (name
, ".debug_line."))
15538 else if (streq (sec
->uncompressed_name
, name
))
15539 sec
->name
= sec
->uncompressed_name
;
15541 sec
->name
= sec
->compressed_name
;
15543 if (load_specific_debug_section (id
, section
, filedata
))
15545 /* If this debug section is part of a CU/TU set in a .dwp file,
15546 restrict load_debug_section to the sections in that set. */
15547 section_subset
= find_cu_tu_set (filedata
, shndx
);
15549 result
&= display
->display (sec
, filedata
);
15551 section_subset
= NULL
;
15553 if (secondary
|| (id
!= info
&& id
!= abbrev
&& id
!= debug_addr
))
15554 free_debug_section (id
);
15562 printf (_("Unrecognized debug section: %s\n"), print_name
);
15569 /* Set DUMP_SECTS for all sections where dumps were requested
15570 based on section name. */
15573 initialise_dumps_byname (Filedata
* filedata
)
15575 struct dump_list_entry
* cur
;
15577 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
15582 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
15583 if (SECTION_NAME_VALID (filedata
->section_headers
+ i
)
15584 && streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
15586 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
15590 if (!any
&& !filedata
->is_separate
)
15591 warn (_("Section '%s' was not dumped because it does not exist\n"),
15597 process_section_contents (Filedata
* filedata
)
15599 Elf_Internal_Shdr
* section
;
15606 initialise_dumps_byname (filedata
);
15608 for (i
= 0, section
= filedata
->section_headers
;
15609 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
15612 dump_type dump
= filedata
->dump
.dump_sects
[i
];
15614 if (filedata
->is_separate
&& ! process_links
)
15615 dump
&= DEBUG_DUMP
;
15617 #ifdef SUPPORT_DISASSEMBLY
15618 if (dump
& DISASS_DUMP
)
15620 if (! disassemble_section (section
, filedata
))
15624 if (dump
& HEX_DUMP
)
15626 if (! dump_section_as_bytes (section
, filedata
, false))
15630 if (dump
& RELOC_DUMP
)
15632 if (! dump_section_as_bytes (section
, filedata
, true))
15636 if (dump
& STRING_DUMP
)
15638 if (! dump_section_as_strings (section
, filedata
))
15642 if (dump
& DEBUG_DUMP
)
15644 if (! display_debug_section (i
, section
, filedata
))
15648 #ifdef ENABLE_LIBCTF
15649 if (dump
& CTF_DUMP
)
15651 if (! dump_section_as_ctf (section
, filedata
))
15657 if (! filedata
->is_separate
)
15659 /* Check to see if the user requested a
15660 dump of a section that does not exist. */
15661 for (; i
< filedata
->dump
.num_dump_sects
; i
++)
15662 if (filedata
->dump
.dump_sects
[i
])
15664 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
15673 process_mips_fpe_exception (int mask
)
15679 if (mask
& OEX_FPU_INEX
)
15680 fputs ("INEX", stdout
), first
= false;
15681 if (mask
& OEX_FPU_UFLO
)
15682 printf ("%sUFLO", first
? "" : "|"), first
= false;
15683 if (mask
& OEX_FPU_OFLO
)
15684 printf ("%sOFLO", first
? "" : "|"), first
= false;
15685 if (mask
& OEX_FPU_DIV0
)
15686 printf ("%sDIV0", first
? "" : "|"), first
= false;
15687 if (mask
& OEX_FPU_INVAL
)
15688 printf ("%sINVAL", first
? "" : "|");
15691 fputs ("0", stdout
);
15694 /* Display's the value of TAG at location P. If TAG is
15695 greater than 0 it is assumed to be an unknown tag, and
15696 a message is printed to this effect. Otherwise it is
15697 assumed that a message has already been printed.
15699 If the bottom bit of TAG is set it assumed to have a
15700 string value, otherwise it is assumed to have an integer
15703 Returns an updated P pointing to the first unread byte
15704 beyond the end of TAG's value.
15706 Reads at or beyond END will not be made. */
15708 static unsigned char *
15709 display_tag_value (signed int tag
,
15711 const unsigned char * const end
)
15716 printf (" Tag_unknown_%d: ", tag
);
15720 warn (_("<corrupt tag>\n"));
15724 /* PR 17531 file: 027-19978-0.004. */
15725 size_t maxlen
= (end
- p
) - 1;
15730 print_symbol ((int) maxlen
, (const char *) p
);
15731 p
+= strnlen ((char *) p
, maxlen
) + 1;
15735 printf (_("<corrupt string tag>"));
15736 p
= (unsigned char *) end
;
15742 READ_ULEB (val
, p
, end
);
15743 printf ("%ld (0x%lx)\n", val
, val
);
15750 /* ARC ABI attributes section. */
15752 static unsigned char *
15753 display_arc_attribute (unsigned char * p
,
15754 const unsigned char * const end
)
15759 READ_ULEB (tag
, p
, end
);
15763 case Tag_ARC_PCS_config
:
15764 READ_ULEB (val
, p
, end
);
15765 printf (" Tag_ARC_PCS_config: ");
15769 printf (_("Absent/Non standard\n"));
15772 printf (_("Bare metal/mwdt\n"));
15775 printf (_("Bare metal/newlib\n"));
15778 printf (_("Linux/uclibc\n"));
15781 printf (_("Linux/glibc\n"));
15784 printf (_("Unknown\n"));
15789 case Tag_ARC_CPU_base
:
15790 READ_ULEB (val
, p
, end
);
15791 printf (" Tag_ARC_CPU_base: ");
15796 printf (_("Absent\n"));
15798 case TAG_CPU_ARC6xx
:
15799 printf ("ARC6xx\n");
15801 case TAG_CPU_ARC7xx
:
15802 printf ("ARC7xx\n");
15804 case TAG_CPU_ARCEM
:
15805 printf ("ARCEM\n");
15807 case TAG_CPU_ARCHS
:
15808 printf ("ARCHS\n");
15813 case Tag_ARC_CPU_variation
:
15814 READ_ULEB (val
, p
, end
);
15815 printf (" Tag_ARC_CPU_variation: ");
15819 if (val
> 0 && val
< 16)
15820 printf ("Core%d\n", val
);
15822 printf ("Unknown\n");
15826 printf (_("Absent\n"));
15831 case Tag_ARC_CPU_name
:
15832 printf (" Tag_ARC_CPU_name: ");
15833 p
= display_tag_value (-1, p
, end
);
15836 case Tag_ARC_ABI_rf16
:
15837 READ_ULEB (val
, p
, end
);
15838 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
15841 case Tag_ARC_ABI_osver
:
15842 READ_ULEB (val
, p
, end
);
15843 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
15846 case Tag_ARC_ABI_pic
:
15847 case Tag_ARC_ABI_sda
:
15848 READ_ULEB (val
, p
, end
);
15849 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
15850 : " Tag_ARC_ABI_pic: ");
15854 printf (_("Absent\n"));
15863 printf (_("Unknown\n"));
15868 case Tag_ARC_ABI_tls
:
15869 READ_ULEB (val
, p
, end
);
15870 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
15873 case Tag_ARC_ABI_enumsize
:
15874 READ_ULEB (val
, p
, end
);
15875 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
15879 case Tag_ARC_ABI_exceptions
:
15880 READ_ULEB (val
, p
, end
);
15881 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
15885 case Tag_ARC_ABI_double_size
:
15886 READ_ULEB (val
, p
, end
);
15887 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
15890 case Tag_ARC_ISA_config
:
15891 printf (" Tag_ARC_ISA_config: ");
15892 p
= display_tag_value (-1, p
, end
);
15895 case Tag_ARC_ISA_apex
:
15896 printf (" Tag_ARC_ISA_apex: ");
15897 p
= display_tag_value (-1, p
, end
);
15900 case Tag_ARC_ISA_mpy_option
:
15901 READ_ULEB (val
, p
, end
);
15902 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
15905 case Tag_ARC_ATR_version
:
15906 READ_ULEB (val
, p
, end
);
15907 printf (" Tag_ARC_ATR_version: %d\n", val
);
15911 return display_tag_value (tag
& 1, p
, end
);
15917 /* ARM EABI attributes section. */
15922 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
15924 const char *const *table
;
15925 } arm_attr_public_tag
;
15927 static const char *const arm_attr_tag_CPU_arch
[] =
15928 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
15929 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
15930 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
15931 static const char *const arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
15932 static const char *const arm_attr_tag_THUMB_ISA_use
[] =
15933 {"No", "Thumb-1", "Thumb-2", "Yes"};
15934 static const char *const arm_attr_tag_FP_arch
[] =
15935 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
15936 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
15937 static const char *const arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
15938 static const char *const arm_attr_tag_Advanced_SIMD_arch
[] =
15939 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
15940 "NEON for ARMv8.1"};
15941 static const char *const arm_attr_tag_PCS_config
[] =
15942 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
15943 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
15944 static const char *const arm_attr_tag_ABI_PCS_R9_use
[] =
15945 {"V6", "SB", "TLS", "Unused"};
15946 static const char *const arm_attr_tag_ABI_PCS_RW_data
[] =
15947 {"Absolute", "PC-relative", "SB-relative", "None"};
15948 static const char *const arm_attr_tag_ABI_PCS_RO_data
[] =
15949 {"Absolute", "PC-relative", "None"};
15950 static const char *const arm_attr_tag_ABI_PCS_GOT_use
[] =
15951 {"None", "direct", "GOT-indirect"};
15952 static const char *const arm_attr_tag_ABI_PCS_wchar_t
[] =
15953 {"None", "??? 1", "2", "??? 3", "4"};
15954 static const char *const arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
15955 static const char *const arm_attr_tag_ABI_FP_denormal
[] =
15956 {"Unused", "Needed", "Sign only"};
15957 static const char *const arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
15958 static const char *const arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
15959 static const char *const arm_attr_tag_ABI_FP_number_model
[] =
15960 {"Unused", "Finite", "RTABI", "IEEE 754"};
15961 static const char *const arm_attr_tag_ABI_enum_size
[] =
15962 {"Unused", "small", "int", "forced to int"};
15963 static const char *const arm_attr_tag_ABI_HardFP_use
[] =
15964 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
15965 static const char *const arm_attr_tag_ABI_VFP_args
[] =
15966 {"AAPCS", "VFP registers", "custom", "compatible"};
15967 static const char *const arm_attr_tag_ABI_WMMX_args
[] =
15968 {"AAPCS", "WMMX registers", "custom"};
15969 static const char *const arm_attr_tag_ABI_optimization_goals
[] =
15970 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15971 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
15972 static const char *const arm_attr_tag_ABI_FP_optimization_goals
[] =
15973 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15974 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
15975 static const char *const arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
15976 static const char *const arm_attr_tag_FP_HP_extension
[] =
15977 {"Not Allowed", "Allowed"};
15978 static const char *const arm_attr_tag_ABI_FP_16bit_format
[] =
15979 {"None", "IEEE 754", "Alternative Format"};
15980 static const char *const arm_attr_tag_DSP_extension
[] =
15981 {"Follow architecture", "Allowed"};
15982 static const char *const arm_attr_tag_MPextension_use
[] =
15983 {"Not Allowed", "Allowed"};
15984 static const char *const arm_attr_tag_DIV_use
[] =
15985 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
15986 "Allowed in v7-A with integer division extension"};
15987 static const char *const arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
15988 static const char *const arm_attr_tag_Virtualization_use
[] =
15989 {"Not Allowed", "TrustZone", "Virtualization Extensions",
15990 "TrustZone and Virtualization Extensions"};
15991 static const char *const arm_attr_tag_MPextension_use_legacy
[] =
15992 {"Not Allowed", "Allowed"};
15994 static const char *const arm_attr_tag_MVE_arch
[] =
15995 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
15997 #define LOOKUP(id, name) \
15998 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
15999 static arm_attr_public_tag arm_attr_public_tags
[] =
16001 {4, "CPU_raw_name", 1, NULL
},
16002 {5, "CPU_name", 1, NULL
},
16003 LOOKUP(6, CPU_arch
),
16004 {7, "CPU_arch_profile", 0, NULL
},
16005 LOOKUP(8, ARM_ISA_use
),
16006 LOOKUP(9, THUMB_ISA_use
),
16007 LOOKUP(10, FP_arch
),
16008 LOOKUP(11, WMMX_arch
),
16009 LOOKUP(12, Advanced_SIMD_arch
),
16010 LOOKUP(13, PCS_config
),
16011 LOOKUP(14, ABI_PCS_R9_use
),
16012 LOOKUP(15, ABI_PCS_RW_data
),
16013 LOOKUP(16, ABI_PCS_RO_data
),
16014 LOOKUP(17, ABI_PCS_GOT_use
),
16015 LOOKUP(18, ABI_PCS_wchar_t
),
16016 LOOKUP(19, ABI_FP_rounding
),
16017 LOOKUP(20, ABI_FP_denormal
),
16018 LOOKUP(21, ABI_FP_exceptions
),
16019 LOOKUP(22, ABI_FP_user_exceptions
),
16020 LOOKUP(23, ABI_FP_number_model
),
16021 {24, "ABI_align_needed", 0, NULL
},
16022 {25, "ABI_align_preserved", 0, NULL
},
16023 LOOKUP(26, ABI_enum_size
),
16024 LOOKUP(27, ABI_HardFP_use
),
16025 LOOKUP(28, ABI_VFP_args
),
16026 LOOKUP(29, ABI_WMMX_args
),
16027 LOOKUP(30, ABI_optimization_goals
),
16028 LOOKUP(31, ABI_FP_optimization_goals
),
16029 {32, "compatibility", 0, NULL
},
16030 LOOKUP(34, CPU_unaligned_access
),
16031 LOOKUP(36, FP_HP_extension
),
16032 LOOKUP(38, ABI_FP_16bit_format
),
16033 LOOKUP(42, MPextension_use
),
16034 LOOKUP(44, DIV_use
),
16035 LOOKUP(46, DSP_extension
),
16036 LOOKUP(48, MVE_arch
),
16037 {64, "nodefaults", 0, NULL
},
16038 {65, "also_compatible_with", 0, NULL
},
16039 LOOKUP(66, T2EE_use
),
16040 {67, "conformance", 1, NULL
},
16041 LOOKUP(68, Virtualization_use
),
16042 LOOKUP(70, MPextension_use_legacy
)
16046 static unsigned char *
16047 display_arm_attribute (unsigned char * p
,
16048 const unsigned char * const end
)
16052 arm_attr_public_tag
* attr
;
16056 READ_ULEB (tag
, p
, end
);
16058 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
16060 if (arm_attr_public_tags
[i
].tag
== tag
)
16062 attr
= &arm_attr_public_tags
[i
];
16069 printf (" Tag_%s: ", attr
->name
);
16070 switch (attr
->type
)
16075 case 7: /* Tag_CPU_arch_profile. */
16076 READ_ULEB (val
, p
, end
);
16079 case 0: printf (_("None\n")); break;
16080 case 'A': printf (_("Application\n")); break;
16081 case 'R': printf (_("Realtime\n")); break;
16082 case 'M': printf (_("Microcontroller\n")); break;
16083 case 'S': printf (_("Application or Realtime\n")); break;
16084 default: printf ("??? (%d)\n", val
); break;
16088 case 24: /* Tag_align_needed. */
16089 READ_ULEB (val
, p
, end
);
16092 case 0: printf (_("None\n")); break;
16093 case 1: printf (_("8-byte\n")); break;
16094 case 2: printf (_("4-byte\n")); break;
16095 case 3: printf ("??? 3\n"); break;
16098 printf (_("8-byte and up to %d-byte extended\n"),
16101 printf ("??? (%d)\n", val
);
16106 case 25: /* Tag_align_preserved. */
16107 READ_ULEB (val
, p
, end
);
16110 case 0: printf (_("None\n")); break;
16111 case 1: printf (_("8-byte, except leaf SP\n")); break;
16112 case 2: printf (_("8-byte\n")); break;
16113 case 3: printf ("??? 3\n"); break;
16116 printf (_("8-byte and up to %d-byte extended\n"),
16119 printf ("??? (%d)\n", val
);
16124 case 32: /* Tag_compatibility. */
16126 READ_ULEB (val
, p
, end
);
16127 printf (_("flag = %d, vendor = "), val
);
16130 size_t maxlen
= (end
- p
) - 1;
16132 print_symbol ((int) maxlen
, (const char *) p
);
16133 p
+= strnlen ((char *) p
, maxlen
) + 1;
16137 printf (_("<corrupt>"));
16138 p
= (unsigned char *) end
;
16144 case 64: /* Tag_nodefaults. */
16145 /* PR 17531: file: 001-505008-0.01. */
16148 printf (_("True\n"));
16151 case 65: /* Tag_also_compatible_with. */
16152 READ_ULEB (val
, p
, end
);
16153 if (val
== 6 /* Tag_CPU_arch. */)
16155 READ_ULEB (val
, p
, end
);
16156 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
16157 printf ("??? (%d)\n", val
);
16159 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
16163 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
16168 printf (_("<unknown: %d>\n"), tag
);
16174 return display_tag_value (-1, p
, end
);
16176 return display_tag_value (0, p
, end
);
16179 assert (attr
->type
& 0x80);
16180 READ_ULEB (val
, p
, end
);
16181 type
= attr
->type
& 0x7f;
16183 printf ("??? (%d)\n", val
);
16185 printf ("%s\n", attr
->table
[val
]);
16190 return display_tag_value (tag
, p
, end
);
16193 static unsigned char *
16194 display_gnu_attribute (unsigned char * p
,
16195 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
16196 const unsigned char * const end
)
16201 READ_ULEB (tag
, p
, end
);
16203 /* Tag_compatibility is the only generic GNU attribute defined at
16207 READ_ULEB (val
, p
, end
);
16209 printf (_("flag = %d, vendor = "), val
);
16212 printf (_("<corrupt>\n"));
16213 warn (_("corrupt vendor attribute\n"));
16219 size_t maxlen
= (end
- p
) - 1;
16221 print_symbol ((int) maxlen
, (const char *) p
);
16222 p
+= strnlen ((char *) p
, maxlen
) + 1;
16226 printf (_("<corrupt>"));
16227 p
= (unsigned char *) end
;
16234 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
16235 return display_proc_gnu_attribute (p
, tag
, end
);
16237 return display_tag_value (tag
, p
, end
);
16240 static unsigned char *
16241 display_m68k_gnu_attribute (unsigned char * p
,
16243 const unsigned char * const end
)
16247 if (tag
== Tag_GNU_M68K_ABI_FP
)
16249 printf (" Tag_GNU_M68K_ABI_FP: ");
16252 printf (_("<corrupt>\n"));
16255 READ_ULEB (val
, p
, end
);
16258 printf ("(%#x), ", val
);
16263 printf (_("unspecified hard/soft float\n"));
16266 printf (_("hard float\n"));
16269 printf (_("soft float\n"));
16275 return display_tag_value (tag
& 1, p
, end
);
16278 static unsigned char *
16279 display_power_gnu_attribute (unsigned char * p
,
16281 const unsigned char * const end
)
16285 if (tag
== Tag_GNU_Power_ABI_FP
)
16287 printf (" Tag_GNU_Power_ABI_FP: ");
16290 printf (_("<corrupt>\n"));
16293 READ_ULEB (val
, p
, end
);
16296 printf ("(%#x), ", val
);
16301 printf (_("unspecified hard/soft float, "));
16304 printf (_("hard float, "));
16307 printf (_("soft float, "));
16310 printf (_("single-precision hard float, "));
16317 printf (_("unspecified long double\n"));
16320 printf (_("128-bit IBM long double\n"));
16323 printf (_("64-bit long double\n"));
16326 printf (_("128-bit IEEE long double\n"));
16332 if (tag
== Tag_GNU_Power_ABI_Vector
)
16334 printf (" Tag_GNU_Power_ABI_Vector: ");
16337 printf (_("<corrupt>\n"));
16340 READ_ULEB (val
, p
, end
);
16343 printf ("(%#x), ", val
);
16348 printf (_("unspecified\n"));
16351 printf (_("generic\n"));
16354 printf ("AltiVec\n");
16363 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
16365 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
16368 printf (_("<corrupt>\n"));
16371 READ_ULEB (val
, p
, end
);
16374 printf ("(%#x), ", val
);
16379 printf (_("unspecified\n"));
16382 printf ("r3/r4\n");
16385 printf (_("memory\n"));
16394 return display_tag_value (tag
& 1, p
, end
);
16397 static unsigned char *
16398 display_s390_gnu_attribute (unsigned char * p
,
16400 const unsigned char * const end
)
16404 if (tag
== Tag_GNU_S390_ABI_Vector
)
16406 printf (" Tag_GNU_S390_ABI_Vector: ");
16407 READ_ULEB (val
, p
, end
);
16412 printf (_("any\n"));
16415 printf (_("software\n"));
16418 printf (_("hardware\n"));
16421 printf ("??? (%d)\n", val
);
16427 return display_tag_value (tag
& 1, p
, end
);
16431 display_sparc_hwcaps (unsigned int mask
)
16437 if (mask
& ELF_SPARC_HWCAP_MUL32
)
16438 fputs ("mul32", stdout
), first
= false;
16439 if (mask
& ELF_SPARC_HWCAP_DIV32
)
16440 printf ("%sdiv32", first
? "" : "|"), first
= false;
16441 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
16442 printf ("%sfsmuld", first
? "" : "|"), first
= false;
16443 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
16444 printf ("%sv8plus", first
? "" : "|"), first
= false;
16445 if (mask
& ELF_SPARC_HWCAP_POPC
)
16446 printf ("%spopc", first
? "" : "|"), first
= false;
16447 if (mask
& ELF_SPARC_HWCAP_VIS
)
16448 printf ("%svis", first
? "" : "|"), first
= false;
16449 if (mask
& ELF_SPARC_HWCAP_VIS2
)
16450 printf ("%svis2", first
? "" : "|"), first
= false;
16451 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
16452 printf ("%sASIBlkInit", first
? "" : "|"), first
= false;
16453 if (mask
& ELF_SPARC_HWCAP_FMAF
)
16454 printf ("%sfmaf", first
? "" : "|"), first
= false;
16455 if (mask
& ELF_SPARC_HWCAP_VIS3
)
16456 printf ("%svis3", first
? "" : "|"), first
= false;
16457 if (mask
& ELF_SPARC_HWCAP_HPC
)
16458 printf ("%shpc", first
? "" : "|"), first
= false;
16459 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
16460 printf ("%srandom", first
? "" : "|"), first
= false;
16461 if (mask
& ELF_SPARC_HWCAP_TRANS
)
16462 printf ("%strans", first
? "" : "|"), first
= false;
16463 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
16464 printf ("%sfjfmau", first
? "" : "|"), first
= false;
16465 if (mask
& ELF_SPARC_HWCAP_IMA
)
16466 printf ("%sima", first
? "" : "|"), first
= false;
16467 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
16468 printf ("%scspare", first
? "" : "|"), first
= false;
16471 fputc ('0', stdout
);
16472 fputc ('\n', stdout
);
16476 display_sparc_hwcaps2 (unsigned int mask
)
16482 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
16483 fputs ("fjathplus", stdout
), first
= false;
16484 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
16485 printf ("%svis3b", first
? "" : "|"), first
= false;
16486 if (mask
& ELF_SPARC_HWCAP2_ADP
)
16487 printf ("%sadp", first
? "" : "|"), first
= false;
16488 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
16489 printf ("%ssparc5", first
? "" : "|"), first
= false;
16490 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
16491 printf ("%smwait", first
? "" : "|"), first
= false;
16492 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
16493 printf ("%sxmpmul", first
? "" : "|"), first
= false;
16494 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
16495 printf ("%sxmont2", first
? "" : "|"), first
= false;
16496 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
16497 printf ("%snsec", first
? "" : "|"), first
= false;
16498 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
16499 printf ("%sfjathhpc", first
? "" : "|"), first
= false;
16500 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
16501 printf ("%sfjdes", first
? "" : "|"), first
= false;
16502 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
16503 printf ("%sfjaes", first
? "" : "|"), first
= false;
16506 fputc ('0', stdout
);
16507 fputc ('\n', stdout
);
16510 static unsigned char *
16511 display_sparc_gnu_attribute (unsigned char * p
,
16513 const unsigned char * const end
)
16517 if (tag
== Tag_GNU_Sparc_HWCAPS
)
16519 READ_ULEB (val
, p
, end
);
16520 printf (" Tag_GNU_Sparc_HWCAPS: ");
16521 display_sparc_hwcaps (val
);
16524 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
16526 READ_ULEB (val
, p
, end
);
16527 printf (" Tag_GNU_Sparc_HWCAPS2: ");
16528 display_sparc_hwcaps2 (val
);
16532 return display_tag_value (tag
, p
, end
);
16536 print_mips_fp_abi_value (unsigned int val
)
16540 case Val_GNU_MIPS_ABI_FP_ANY
:
16541 printf (_("Hard or soft float\n"));
16543 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
16544 printf (_("Hard float (double precision)\n"));
16546 case Val_GNU_MIPS_ABI_FP_SINGLE
:
16547 printf (_("Hard float (single precision)\n"));
16549 case Val_GNU_MIPS_ABI_FP_SOFT
:
16550 printf (_("Soft float\n"));
16552 case Val_GNU_MIPS_ABI_FP_OLD_64
:
16553 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
16555 case Val_GNU_MIPS_ABI_FP_XX
:
16556 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
16558 case Val_GNU_MIPS_ABI_FP_64
:
16559 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
16561 case Val_GNU_MIPS_ABI_FP_64A
:
16562 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
16564 case Val_GNU_MIPS_ABI_FP_NAN2008
:
16565 printf (_("NaN 2008 compatibility\n"));
16568 printf ("??? (%d)\n", val
);
16573 static unsigned char *
16574 display_mips_gnu_attribute (unsigned char * p
,
16576 const unsigned char * const end
)
16578 if (tag
== Tag_GNU_MIPS_ABI_FP
)
16582 printf (" Tag_GNU_MIPS_ABI_FP: ");
16583 READ_ULEB (val
, p
, end
);
16584 print_mips_fp_abi_value (val
);
16588 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
16592 printf (" Tag_GNU_MIPS_ABI_MSA: ");
16593 READ_ULEB (val
, p
, end
);
16597 case Val_GNU_MIPS_ABI_MSA_ANY
:
16598 printf (_("Any MSA or not\n"));
16600 case Val_GNU_MIPS_ABI_MSA_128
:
16601 printf (_("128-bit MSA\n"));
16604 printf ("??? (%d)\n", val
);
16610 return display_tag_value (tag
& 1, p
, end
);
16613 static unsigned char *
16614 display_tic6x_attribute (unsigned char * p
,
16615 const unsigned char * const end
)
16620 READ_ULEB (tag
, p
, end
);
16625 printf (" Tag_ISA: ");
16626 READ_ULEB (val
, p
, end
);
16630 case C6XABI_Tag_ISA_none
:
16631 printf (_("None\n"));
16633 case C6XABI_Tag_ISA_C62X
:
16636 case C6XABI_Tag_ISA_C67X
:
16639 case C6XABI_Tag_ISA_C67XP
:
16640 printf ("C67x+\n");
16642 case C6XABI_Tag_ISA_C64X
:
16645 case C6XABI_Tag_ISA_C64XP
:
16646 printf ("C64x+\n");
16648 case C6XABI_Tag_ISA_C674X
:
16649 printf ("C674x\n");
16652 printf ("??? (%d)\n", val
);
16657 case Tag_ABI_wchar_t
:
16658 printf (" Tag_ABI_wchar_t: ");
16659 READ_ULEB (val
, p
, end
);
16663 printf (_("Not used\n"));
16666 printf (_("2 bytes\n"));
16669 printf (_("4 bytes\n"));
16672 printf ("??? (%d)\n", val
);
16677 case Tag_ABI_stack_align_needed
:
16678 printf (" Tag_ABI_stack_align_needed: ");
16679 READ_ULEB (val
, p
, end
);
16683 printf (_("8-byte\n"));
16686 printf (_("16-byte\n"));
16689 printf ("??? (%d)\n", val
);
16694 case Tag_ABI_stack_align_preserved
:
16695 READ_ULEB (val
, p
, end
);
16696 printf (" Tag_ABI_stack_align_preserved: ");
16700 printf (_("8-byte\n"));
16703 printf (_("16-byte\n"));
16706 printf ("??? (%d)\n", val
);
16712 READ_ULEB (val
, p
, end
);
16713 printf (" Tag_ABI_DSBT: ");
16717 printf (_("DSBT addressing not used\n"));
16720 printf (_("DSBT addressing used\n"));
16723 printf ("??? (%d)\n", val
);
16729 READ_ULEB (val
, p
, end
);
16730 printf (" Tag_ABI_PID: ");
16734 printf (_("Data addressing position-dependent\n"));
16737 printf (_("Data addressing position-independent, GOT near DP\n"));
16740 printf (_("Data addressing position-independent, GOT far from DP\n"));
16743 printf ("??? (%d)\n", val
);
16749 READ_ULEB (val
, p
, end
);
16750 printf (" Tag_ABI_PIC: ");
16754 printf (_("Code addressing position-dependent\n"));
16757 printf (_("Code addressing position-independent\n"));
16760 printf ("??? (%d)\n", val
);
16765 case Tag_ABI_array_object_alignment
:
16766 READ_ULEB (val
, p
, end
);
16767 printf (" Tag_ABI_array_object_alignment: ");
16771 printf (_("8-byte\n"));
16774 printf (_("4-byte\n"));
16777 printf (_("16-byte\n"));
16780 printf ("??? (%d)\n", val
);
16785 case Tag_ABI_array_object_align_expected
:
16786 READ_ULEB (val
, p
, end
);
16787 printf (" Tag_ABI_array_object_align_expected: ");
16791 printf (_("8-byte\n"));
16794 printf (_("4-byte\n"));
16797 printf (_("16-byte\n"));
16800 printf ("??? (%d)\n", val
);
16805 case Tag_ABI_compatibility
:
16807 READ_ULEB (val
, p
, end
);
16808 printf (" Tag_ABI_compatibility: ");
16809 printf (_("flag = %d, vendor = "), val
);
16812 size_t maxlen
= (end
- p
) - 1;
16814 print_symbol ((int) maxlen
, (const char *) p
);
16815 p
+= strnlen ((char *) p
, maxlen
) + 1;
16819 printf (_("<corrupt>"));
16820 p
= (unsigned char *) end
;
16826 case Tag_ABI_conformance
:
16828 printf (" Tag_ABI_conformance: \"");
16831 size_t maxlen
= (end
- p
) - 1;
16833 print_symbol ((int) maxlen
, (const char *) p
);
16834 p
+= strnlen ((char *) p
, maxlen
) + 1;
16838 printf (_("<corrupt>"));
16839 p
= (unsigned char *) end
;
16846 return display_tag_value (tag
, p
, end
);
16850 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
16852 unsigned long addr
= 0;
16853 size_t bytes
= end
- p
;
16860 int lbytes
= (bytes
> 16 ? 16 : bytes
);
16862 printf (" 0x%8.8lx ", addr
);
16864 for (j
= 0; j
< 16; j
++)
16867 printf ("%2.2x", p
[j
]);
16875 for (j
= 0; j
< lbytes
; j
++)
16878 if (k
>= ' ' && k
< 0x7f)
16894 static unsigned char *
16895 display_msp430_attribute (unsigned char * p
,
16896 const unsigned char * const end
)
16901 READ_ULEB (tag
, p
, end
);
16905 case OFBA_MSPABI_Tag_ISA
:
16906 printf (" Tag_ISA: ");
16907 READ_ULEB (val
, p
, end
);
16910 case 0: printf (_("None\n")); break;
16911 case 1: printf (_("MSP430\n")); break;
16912 case 2: printf (_("MSP430X\n")); break;
16913 default: printf ("??? (%d)\n", val
); break;
16917 case OFBA_MSPABI_Tag_Code_Model
:
16918 printf (" Tag_Code_Model: ");
16919 READ_ULEB (val
, p
, end
);
16922 case 0: printf (_("None\n")); break;
16923 case 1: printf (_("Small\n")); break;
16924 case 2: printf (_("Large\n")); break;
16925 default: printf ("??? (%d)\n", val
); break;
16929 case OFBA_MSPABI_Tag_Data_Model
:
16930 printf (" Tag_Data_Model: ");
16931 READ_ULEB (val
, p
, end
);
16934 case 0: printf (_("None\n")); break;
16935 case 1: printf (_("Small\n")); break;
16936 case 2: printf (_("Large\n")); break;
16937 case 3: printf (_("Restricted Large\n")); break;
16938 default: printf ("??? (%d)\n", val
); break;
16943 printf (_(" <unknown tag %d>: "), tag
);
16950 size_t maxlen
= (end
- p
) - 1;
16952 print_symbol ((int) maxlen
, (const char *) p
);
16953 p
+= strnlen ((char *) p
, maxlen
) + 1;
16957 printf (_("<corrupt>"));
16958 p
= (unsigned char *) end
;
16964 READ_ULEB (val
, p
, end
);
16965 printf ("%d (0x%x)\n", val
, val
);
16974 static unsigned char *
16975 display_msp430_gnu_attribute (unsigned char * p
,
16977 const unsigned char * const end
)
16979 if (tag
== Tag_GNU_MSP430_Data_Region
)
16983 printf (" Tag_GNU_MSP430_Data_Region: ");
16984 READ_ULEB (val
, p
, end
);
16988 case Val_GNU_MSP430_Data_Region_Any
:
16989 printf (_("Any Region\n"));
16991 case Val_GNU_MSP430_Data_Region_Lower
:
16992 printf (_("Lower Region Only\n"));
16995 printf ("??? (%u)\n", val
);
16999 return display_tag_value (tag
& 1, p
, end
);
17002 struct riscv_attr_tag_t
{
17007 static struct riscv_attr_tag_t riscv_attr_tag
[] =
17009 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
17012 T(priv_spec_minor
),
17013 T(priv_spec_revision
),
17014 T(unaligned_access
),
17019 static unsigned char *
17020 display_riscv_attribute (unsigned char *p
,
17021 const unsigned char * const end
)
17025 struct riscv_attr_tag_t
*attr
= NULL
;
17028 READ_ULEB (tag
, p
, end
);
17030 /* Find the name of attribute. */
17031 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
17033 if (riscv_attr_tag
[i
].tag
== tag
)
17035 attr
= &riscv_attr_tag
[i
];
17041 printf (" %s: ", attr
->name
);
17043 return display_tag_value (tag
, p
, end
);
17047 case Tag_RISCV_priv_spec
:
17048 case Tag_RISCV_priv_spec_minor
:
17049 case Tag_RISCV_priv_spec_revision
:
17050 READ_ULEB (val
, p
, end
);
17051 printf (_("%u\n"), val
);
17053 case Tag_RISCV_unaligned_access
:
17054 READ_ULEB (val
, p
, end
);
17058 printf (_("No unaligned access\n"));
17061 printf (_("Unaligned access\n"));
17065 case Tag_RISCV_stack_align
:
17066 READ_ULEB (val
, p
, end
);
17067 printf (_("%u-bytes\n"), val
);
17069 case Tag_RISCV_arch
:
17070 p
= display_tag_value (-1, p
, end
);
17073 return display_tag_value (tag
, p
, end
);
17079 static unsigned char *
17080 display_csky_attribute (unsigned char * p
,
17081 const unsigned char * const end
)
17085 READ_ULEB (tag
, p
, end
);
17087 if (tag
>= Tag_CSKY_MAX
)
17089 return display_tag_value (-1, p
, end
);
17094 case Tag_CSKY_ARCH_NAME
:
17095 printf (" Tag_CSKY_ARCH_NAME:\t\t");
17096 return display_tag_value (-1, p
, end
);
17097 case Tag_CSKY_CPU_NAME
:
17098 printf (" Tag_CSKY_CPU_NAME:\t\t");
17099 return display_tag_value (-1, p
, end
);
17101 case Tag_CSKY_ISA_FLAGS
:
17102 printf (" Tag_CSKY_ISA_FLAGS:\t\t");
17103 return display_tag_value (0, p
, end
);
17104 case Tag_CSKY_ISA_EXT_FLAGS
:
17105 printf (" Tag_CSKY_ISA_EXT_FLAGS:\t");
17106 return display_tag_value (0, p
, end
);
17108 case Tag_CSKY_DSP_VERSION
:
17109 printf (" Tag_CSKY_DSP_VERSION:\t\t");
17110 READ_ULEB (val
, p
, end
);
17111 if (val
== VAL_CSKY_DSP_VERSION_EXTENSION
)
17112 printf ("DSP Extension\n");
17113 else if (val
== VAL_CSKY_DSP_VERSION_2
)
17114 printf ("DSP 2.0\n");
17117 case Tag_CSKY_VDSP_VERSION
:
17118 printf (" Tag_CSKY_VDSP_VERSION:\t");
17119 READ_ULEB (val
, p
, end
);
17120 printf ("VDSP Version %d\n", val
);
17123 case Tag_CSKY_FPU_VERSION
:
17124 printf (" Tag_CSKY_FPU_VERSION:\t\t");
17125 READ_ULEB (val
, p
, end
);
17126 if (val
== VAL_CSKY_FPU_VERSION_1
)
17127 printf ("ABIV1 FPU Version 1\n");
17128 else if (val
== VAL_CSKY_FPU_VERSION_2
)
17129 printf ("FPU Version 2\n");
17132 case Tag_CSKY_FPU_ABI
:
17133 printf (" Tag_CSKY_FPU_ABI:\t\t");
17134 READ_ULEB (val
, p
, end
);
17135 if (val
== VAL_CSKY_FPU_ABI_HARD
)
17137 else if (val
== VAL_CSKY_FPU_ABI_SOFTFP
)
17138 printf ("SoftFP\n");
17139 else if (val
== VAL_CSKY_FPU_ABI_SOFT
)
17142 case Tag_CSKY_FPU_ROUNDING
:
17143 READ_ULEB (val
, p
, end
);
17145 printf (" Tag_CSKY_FPU_ROUNDING:\t");
17146 printf ("Needed\n");
17149 case Tag_CSKY_FPU_DENORMAL
:
17150 READ_ULEB (val
, p
, end
);
17152 printf (" Tag_CSKY_FPU_DENORMAL:\t");
17153 printf ("Needed\n");
17156 case Tag_CSKY_FPU_Exception
:
17157 READ_ULEB (val
, p
, end
);
17159 printf (" Tag_CSKY_FPU_Exception:\t");
17160 printf ("Needed\n");
17163 case Tag_CSKY_FPU_NUMBER_MODULE
:
17164 printf (" Tag_CSKY_FPU_NUMBER_MODULE:\t");
17165 return display_tag_value (-1, p
, end
);
17166 case Tag_CSKY_FPU_HARDFP
:
17167 printf (" Tag_CSKY_FPU_HARDFP:\t\t");
17168 READ_ULEB (val
, p
, end
);
17169 if (val
& VAL_CSKY_FPU_HARDFP_HALF
)
17171 if (val
& VAL_CSKY_FPU_HARDFP_SINGLE
)
17172 printf (" Single");
17173 if (val
& VAL_CSKY_FPU_HARDFP_DOUBLE
)
17174 printf (" Double");
17178 return display_tag_value (tag
, p
, end
);
17184 process_attributes (Filedata
* filedata
,
17185 const char * public_name
,
17186 unsigned int proc_type
,
17187 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
17188 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
17190 Elf_Internal_Shdr
* sect
;
17194 /* Find the section header so that we get the size. */
17195 for (i
= 0, sect
= filedata
->section_headers
;
17196 i
< filedata
->file_header
.e_shnum
;
17199 unsigned char * contents
;
17202 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
17205 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17206 sect
->sh_size
, _("attributes"));
17207 if (contents
== NULL
)
17214 /* The first character is the version of the attributes.
17215 Currently only version 1, (aka 'A') is recognised here. */
17218 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
17223 bfd_vma section_len
;
17225 section_len
= sect
->sh_size
- 1;
17228 while (section_len
> 0)
17231 unsigned int namelen
;
17232 bool public_section
;
17235 if (section_len
<= 4)
17237 error (_("Tag section ends prematurely\n"));
17241 attr_len
= byte_get (p
, 4);
17244 if (attr_len
> section_len
)
17246 error (_("Bad attribute length (%u > %u)\n"),
17247 (unsigned) attr_len
, (unsigned) section_len
);
17248 attr_len
= section_len
;
17251 /* PR 17531: file: 001-101425-0.004 */
17252 else if (attr_len
< 5)
17254 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
17259 section_len
-= attr_len
;
17262 namelen
= strnlen ((char *) p
, attr_len
) + 1;
17263 if (namelen
== 0 || namelen
>= attr_len
)
17265 error (_("Corrupt attribute section name\n"));
17270 printf (_("Attribute Section: "));
17271 print_symbol (INT_MAX
, (const char *) p
);
17274 if (public_name
&& streq ((char *) p
, public_name
))
17275 public_section
= true;
17277 public_section
= false;
17279 if (streq ((char *) p
, "gnu"))
17280 gnu_section
= true;
17282 gnu_section
= false;
17285 attr_len
-= namelen
;
17287 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
17292 unsigned char * end
;
17294 /* PR binutils/17531: Safe handling of corrupt files. */
17297 error (_("Unused bytes at end of section\n"));
17304 size
= byte_get (p
, 4);
17305 if (size
> attr_len
)
17307 error (_("Bad subsection length (%u > %u)\n"),
17308 (unsigned) size
, (unsigned) attr_len
);
17312 /* PR binutils/17531: Safe handling of corrupt files. */
17315 error (_("Bad subsection length (%u < 6)\n"),
17323 end
= p
+ size
- 1;
17324 assert (end
<= contents
+ sect
->sh_size
);
17330 printf (_("File Attributes\n"));
17333 printf (_("Section Attributes:"));
17336 printf (_("Symbol Attributes:"));
17337 /* Fall through. */
17341 READ_ULEB (val
, p
, end
);
17344 printf (" %d", val
);
17349 printf (_("Unknown tag: %d\n"), tag
);
17350 public_section
= false;
17354 if (public_section
&& display_pub_attribute
!= NULL
)
17357 p
= display_pub_attribute (p
, end
);
17360 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
17363 p
= display_gnu_attribute (p
,
17364 display_proc_gnu_attribute
,
17370 printf (_(" Unknown attribute:\n"));
17371 display_raw_attribute (p
, end
);
17386 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
17387 Print the Address, Access and Initial fields of an entry at VMA ADDR
17388 and return the VMA of the next entry, or -1 if there was a problem.
17389 Does not read from DATA_END or beyond. */
17392 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
17393 unsigned char * data_end
)
17396 print_vma (addr
, LONG_HEX
);
17398 if (addr
< pltgot
+ 0xfff0)
17399 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
17401 printf ("%10s", "");
17404 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
17408 unsigned char * from
= data
+ addr
- pltgot
;
17410 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
17412 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
17413 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
17414 return (bfd_vma
) -1;
17418 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
17419 print_vma (entry
, LONG_HEX
);
17422 return addr
+ (is_32bit_elf
? 4 : 8);
17425 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
17426 PLTGOT. Print the Address and Initial fields of an entry at VMA
17427 ADDR and return the VMA of the next entry. */
17430 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
17433 print_vma (addr
, LONG_HEX
);
17436 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
17441 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
17442 print_vma (entry
, LONG_HEX
);
17444 return addr
+ (is_32bit_elf
? 4 : 8);
17448 print_mips_ases (unsigned int mask
)
17450 if (mask
& AFL_ASE_DSP
)
17451 fputs ("\n\tDSP ASE", stdout
);
17452 if (mask
& AFL_ASE_DSPR2
)
17453 fputs ("\n\tDSP R2 ASE", stdout
);
17454 if (mask
& AFL_ASE_DSPR3
)
17455 fputs ("\n\tDSP R3 ASE", stdout
);
17456 if (mask
& AFL_ASE_EVA
)
17457 fputs ("\n\tEnhanced VA Scheme", stdout
);
17458 if (mask
& AFL_ASE_MCU
)
17459 fputs ("\n\tMCU (MicroController) ASE", stdout
);
17460 if (mask
& AFL_ASE_MDMX
)
17461 fputs ("\n\tMDMX ASE", stdout
);
17462 if (mask
& AFL_ASE_MIPS3D
)
17463 fputs ("\n\tMIPS-3D ASE", stdout
);
17464 if (mask
& AFL_ASE_MT
)
17465 fputs ("\n\tMT ASE", stdout
);
17466 if (mask
& AFL_ASE_SMARTMIPS
)
17467 fputs ("\n\tSmartMIPS ASE", stdout
);
17468 if (mask
& AFL_ASE_VIRT
)
17469 fputs ("\n\tVZ ASE", stdout
);
17470 if (mask
& AFL_ASE_MSA
)
17471 fputs ("\n\tMSA ASE", stdout
);
17472 if (mask
& AFL_ASE_MIPS16
)
17473 fputs ("\n\tMIPS16 ASE", stdout
);
17474 if (mask
& AFL_ASE_MICROMIPS
)
17475 fputs ("\n\tMICROMIPS ASE", stdout
);
17476 if (mask
& AFL_ASE_XPA
)
17477 fputs ("\n\tXPA ASE", stdout
);
17478 if (mask
& AFL_ASE_MIPS16E2
)
17479 fputs ("\n\tMIPS16e2 ASE", stdout
);
17480 if (mask
& AFL_ASE_CRC
)
17481 fputs ("\n\tCRC ASE", stdout
);
17482 if (mask
& AFL_ASE_GINV
)
17483 fputs ("\n\tGINV ASE", stdout
);
17484 if (mask
& AFL_ASE_LOONGSON_MMI
)
17485 fputs ("\n\tLoongson MMI ASE", stdout
);
17486 if (mask
& AFL_ASE_LOONGSON_CAM
)
17487 fputs ("\n\tLoongson CAM ASE", stdout
);
17488 if (mask
& AFL_ASE_LOONGSON_EXT
)
17489 fputs ("\n\tLoongson EXT ASE", stdout
);
17490 if (mask
& AFL_ASE_LOONGSON_EXT2
)
17491 fputs ("\n\tLoongson EXT2 ASE", stdout
);
17493 fprintf (stdout
, "\n\t%s", _("None"));
17494 else if ((mask
& ~AFL_ASE_MASK
) != 0)
17495 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
17499 print_mips_isa_ext (unsigned int isa_ext
)
17504 fputs (_("None"), stdout
);
17507 fputs ("RMI XLR", stdout
);
17509 case AFL_EXT_OCTEON3
:
17510 fputs ("Cavium Networks Octeon3", stdout
);
17512 case AFL_EXT_OCTEON2
:
17513 fputs ("Cavium Networks Octeon2", stdout
);
17515 case AFL_EXT_OCTEONP
:
17516 fputs ("Cavium Networks OcteonP", stdout
);
17518 case AFL_EXT_OCTEON
:
17519 fputs ("Cavium Networks Octeon", stdout
);
17522 fputs ("Toshiba R5900", stdout
);
17525 fputs ("MIPS R4650", stdout
);
17528 fputs ("LSI R4010", stdout
);
17531 fputs ("NEC VR4100", stdout
);
17534 fputs ("Toshiba R3900", stdout
);
17536 case AFL_EXT_10000
:
17537 fputs ("MIPS R10000", stdout
);
17540 fputs ("Broadcom SB-1", stdout
);
17543 fputs ("NEC VR4111/VR4181", stdout
);
17546 fputs ("NEC VR4120", stdout
);
17549 fputs ("NEC VR5400", stdout
);
17552 fputs ("NEC VR5500", stdout
);
17554 case AFL_EXT_LOONGSON_2E
:
17555 fputs ("ST Microelectronics Loongson 2E", stdout
);
17557 case AFL_EXT_LOONGSON_2F
:
17558 fputs ("ST Microelectronics Loongson 2F", stdout
);
17560 case AFL_EXT_INTERAPTIV_MR2
:
17561 fputs ("Imagination interAptiv MR2", stdout
);
17564 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
17569 get_mips_reg_size (int reg_size
)
17571 return (reg_size
== AFL_REG_NONE
) ? 0
17572 : (reg_size
== AFL_REG_32
) ? 32
17573 : (reg_size
== AFL_REG_64
) ? 64
17574 : (reg_size
== AFL_REG_128
) ? 128
17579 process_mips_specific (Filedata
* filedata
)
17581 Elf_Internal_Dyn
* entry
;
17582 Elf_Internal_Shdr
*sect
= NULL
;
17583 size_t liblist_offset
= 0;
17584 size_t liblistno
= 0;
17585 size_t conflictsno
= 0;
17586 size_t options_offset
= 0;
17587 size_t conflicts_offset
= 0;
17588 size_t pltrelsz
= 0;
17590 bfd_vma pltgot
= 0;
17591 bfd_vma mips_pltgot
= 0;
17592 bfd_vma jmprel
= 0;
17593 bfd_vma local_gotno
= 0;
17594 bfd_vma gotsym
= 0;
17595 bfd_vma symtabno
= 0;
17598 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17599 display_mips_gnu_attribute
))
17602 sect
= find_section (filedata
, ".MIPS.abiflags");
17606 Elf_External_ABIFlags_v0
*abiflags_ext
;
17607 Elf_Internal_ABIFlags_v0 abiflags_in
;
17609 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
17611 error (_("Corrupt MIPS ABI Flags section.\n"));
17616 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17617 sect
->sh_size
, _("MIPS ABI Flags section"));
17620 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
17621 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
17622 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
17623 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
17624 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
17625 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
17626 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
17627 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
17628 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
17629 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
17630 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
17632 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
17633 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
17634 if (abiflags_in
.isa_rev
> 1)
17635 printf ("r%d", abiflags_in
.isa_rev
);
17636 printf ("\nGPR size: %d",
17637 get_mips_reg_size (abiflags_in
.gpr_size
));
17638 printf ("\nCPR1 size: %d",
17639 get_mips_reg_size (abiflags_in
.cpr1_size
));
17640 printf ("\nCPR2 size: %d",
17641 get_mips_reg_size (abiflags_in
.cpr2_size
));
17642 fputs ("\nFP ABI: ", stdout
);
17643 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
17644 fputs ("ISA Extension: ", stdout
);
17645 print_mips_isa_ext (abiflags_in
.isa_ext
);
17646 fputs ("\nASEs:", stdout
);
17647 print_mips_ases (abiflags_in
.ases
);
17648 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
17649 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
17650 fputc ('\n', stdout
);
17651 free (abiflags_ext
);
17656 /* We have a lot of special sections. Thanks SGI! */
17657 if (filedata
->dynamic_section
== NULL
)
17659 /* No dynamic information available. See if there is static GOT. */
17660 sect
= find_section (filedata
, ".got");
17663 unsigned char *data_end
;
17664 unsigned char *data
;
17668 pltgot
= sect
->sh_addr
;
17671 addr_size
= (is_32bit_elf
? 4 : 8);
17672 end
= pltgot
+ sect
->sh_size
;
17674 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
17676 _("Global Offset Table data"));
17677 /* PR 12855: Null data is handled gracefully throughout. */
17678 data_end
= data
+ (end
- pltgot
);
17680 printf (_("\nStatic GOT:\n"));
17681 printf (_(" Canonical gp value: "));
17682 print_vma (ent
+ 0x7ff0, LONG_HEX
);
17685 /* In a dynamic binary GOT[0] is reserved for the dynamic
17686 loader to store the lazy resolver pointer, however in
17687 a static binary it may well have been omitted and GOT
17688 reduced to a table of addresses.
17689 PR 21344: Check for the entry being fully available
17690 before fetching it. */
17692 && data
+ ent
- pltgot
+ addr_size
<= data_end
17693 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
17695 printf (_(" Reserved entries:\n"));
17696 printf (_(" %*s %10s %*s\n"),
17697 addr_size
* 2, _("Address"), _("Access"),
17698 addr_size
* 2, _("Value"));
17699 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17701 if (ent
== (bfd_vma
) -1)
17702 goto sgot_print_fail
;
17704 /* Check for the MSB of GOT[1] being set, identifying a
17705 GNU object. This entry will be used by some runtime
17706 loaders, to store the module pointer. Otherwise this
17707 is an ordinary local entry.
17708 PR 21344: Check for the entry being fully available
17709 before fetching it. */
17711 && data
+ ent
- pltgot
+ addr_size
<= data_end
17712 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17713 >> (addr_size
* 8 - 1)) != 0)
17715 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17717 if (ent
== (bfd_vma
) -1)
17718 goto sgot_print_fail
;
17723 if (data
!= NULL
&& ent
< end
)
17725 printf (_(" Local entries:\n"));
17726 printf (" %*s %10s %*s\n",
17727 addr_size
* 2, _("Address"), _("Access"),
17728 addr_size
* 2, _("Value"));
17731 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17733 if (ent
== (bfd_vma
) -1)
17734 goto sgot_print_fail
;
17745 for (entry
= filedata
->dynamic_section
;
17746 /* PR 17531 file: 012-50589-0.004. */
17747 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
17748 && entry
->d_tag
!= DT_NULL
);
17750 switch (entry
->d_tag
)
17752 case DT_MIPS_LIBLIST
:
17754 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
17755 liblistno
* sizeof (Elf32_External_Lib
));
17757 case DT_MIPS_LIBLISTNO
:
17758 liblistno
= entry
->d_un
.d_val
;
17760 case DT_MIPS_OPTIONS
:
17761 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
17763 case DT_MIPS_CONFLICT
:
17765 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
17766 conflictsno
* sizeof (Elf32_External_Conflict
));
17768 case DT_MIPS_CONFLICTNO
:
17769 conflictsno
= entry
->d_un
.d_val
;
17772 pltgot
= entry
->d_un
.d_ptr
;
17774 case DT_MIPS_LOCAL_GOTNO
:
17775 local_gotno
= entry
->d_un
.d_val
;
17777 case DT_MIPS_GOTSYM
:
17778 gotsym
= entry
->d_un
.d_val
;
17780 case DT_MIPS_SYMTABNO
:
17781 symtabno
= entry
->d_un
.d_val
;
17783 case DT_MIPS_PLTGOT
:
17784 mips_pltgot
= entry
->d_un
.d_ptr
;
17787 pltrel
= entry
->d_un
.d_val
;
17790 pltrelsz
= entry
->d_un
.d_val
;
17793 jmprel
= entry
->d_un
.d_ptr
;
17799 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
17801 Elf32_External_Lib
* elib
;
17804 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
17805 sizeof (Elf32_External_Lib
),
17807 _("liblist section data"));
17810 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
17811 "\nSection '.liblist' contains %lu entries:\n",
17812 (unsigned long) liblistno
),
17813 (unsigned long) liblistno
);
17814 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
17817 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
17824 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17825 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17826 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17827 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17828 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17830 tmp
= gmtime (&atime
);
17831 snprintf (timebuf
, sizeof (timebuf
),
17832 "%04u-%02u-%02uT%02u:%02u:%02u",
17833 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17834 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17836 printf ("%3lu: ", (unsigned long) cnt
);
17837 if (VALID_DYNAMIC_NAME (filedata
, liblist
.l_name
))
17838 print_symbol (20, GET_DYNAMIC_NAME (filedata
, liblist
.l_name
));
17840 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
17841 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
17842 liblist
.l_version
);
17844 if (liblist
.l_flags
== 0)
17848 static const struct
17855 { " EXACT_MATCH", LL_EXACT_MATCH
},
17856 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
17857 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
17858 { " EXPORTS", LL_EXPORTS
},
17859 { " DELAY_LOAD", LL_DELAY_LOAD
},
17860 { " DELTA", LL_DELTA
}
17862 int flags
= liblist
.l_flags
;
17865 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
17866 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
17868 fputs (l_flags_vals
[fcnt
].name
, stdout
);
17869 flags
^= l_flags_vals
[fcnt
].bit
;
17872 printf (" %#x", (unsigned int) flags
);
17884 if (options_offset
!= 0)
17886 Elf_External_Options
* eopt
;
17889 sect
= filedata
->section_headers
;
17891 /* Find the section header so that we get the size. */
17892 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
17893 /* PR 17533 file: 012-277276-0.004. */
17896 error (_("No MIPS_OPTIONS header found\n"));
17900 if (sect
->sh_size
< sizeof (* eopt
))
17902 error (_("The MIPS options section is too small.\n"));
17906 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
17907 sect
->sh_size
, _("options"));
17910 Elf_Internal_Options option
;
17913 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
17915 Elf_External_Options
* eoption
;
17916 unsigned int optsize
;
17918 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
17920 optsize
= BYTE_GET (eoption
->size
);
17922 /* PR 17531: file: ffa0fa3b. */
17923 if (optsize
< sizeof (* eopt
)
17924 || optsize
> sect
->sh_size
- offset
)
17926 error (_("Invalid size (%u) for MIPS option\n"),
17935 printf (ngettext ("\nSection '%s' contains %d entry:\n",
17936 "\nSection '%s' contains %d entries:\n",
17938 printable_section_name (filedata
, sect
), cnt
);
17944 Elf_External_Options
* eoption
;
17946 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
17948 option
.kind
= BYTE_GET (eoption
->kind
);
17949 option
.size
= BYTE_GET (eoption
->size
);
17950 option
.section
= BYTE_GET (eoption
->section
);
17951 option
.info
= BYTE_GET (eoption
->info
);
17953 switch (option
.kind
)
17956 /* This shouldn't happen. */
17957 printf (" NULL %" PRId16
" %" PRIx32
,
17958 option
.section
, option
.info
);
17962 printf (" REGINFO ");
17963 if (filedata
->file_header
.e_machine
== EM_MIPS
)
17965 Elf32_External_RegInfo
* ereg
;
17966 Elf32_RegInfo reginfo
;
17969 if (option
.size
< (sizeof (Elf_External_Options
)
17970 + sizeof (Elf32_External_RegInfo
)))
17972 printf (_("<corrupt>\n"));
17973 error (_("Truncated MIPS REGINFO option\n"));
17978 ereg
= (Elf32_External_RegInfo
*) (eoption
+ 1);
17980 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
17981 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
17982 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
17983 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
17984 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
17985 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
17987 printf ("GPR %08" PRIx32
" GP 0x%" PRIx32
"\n",
17988 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
17990 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
17991 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
17992 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17993 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17998 Elf64_External_RegInfo
* ereg
;
17999 Elf64_Internal_RegInfo reginfo
;
18001 if (option
.size
< (sizeof (Elf_External_Options
)
18002 + sizeof (Elf64_External_RegInfo
)))
18004 printf (_("<corrupt>\n"));
18005 error (_("Truncated MIPS REGINFO option\n"));
18010 ereg
= (Elf64_External_RegInfo
*) (eoption
+ 1);
18011 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
18012 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
18013 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
18014 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
18015 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
18016 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
18018 printf ("GPR %08" PRIx32
" GP 0x%" PRIx64
"\n",
18019 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
18021 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
18022 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
18023 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
18024 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
18026 offset
+= option
.size
;
18029 case ODK_EXCEPTIONS
:
18030 fputs (" EXCEPTIONS fpe_min(", stdout
);
18031 process_mips_fpe_exception (option
.info
& OEX_FPU_MIN
);
18032 fputs (") fpe_max(", stdout
);
18033 process_mips_fpe_exception ((option
.info
& OEX_FPU_MAX
) >> 8);
18034 fputs (")", stdout
);
18036 if (option
.info
& OEX_PAGE0
)
18037 fputs (" PAGE0", stdout
);
18038 if (option
.info
& OEX_SMM
)
18039 fputs (" SMM", stdout
);
18040 if (option
.info
& OEX_FPDBUG
)
18041 fputs (" FPDBUG", stdout
);
18042 if (option
.info
& OEX_DISMISS
)
18043 fputs (" DISMISS", stdout
);
18047 fputs (" PAD ", stdout
);
18048 if (option
.info
& OPAD_PREFIX
)
18049 fputs (" PREFIX", stdout
);
18050 if (option
.info
& OPAD_POSTFIX
)
18051 fputs (" POSTFIX", stdout
);
18052 if (option
.info
& OPAD_SYMBOL
)
18053 fputs (" SYMBOL", stdout
);
18057 fputs (" HWPATCH ", stdout
);
18058 if (option
.info
& OHW_R4KEOP
)
18059 fputs (" R4KEOP", stdout
);
18060 if (option
.info
& OHW_R8KPFETCH
)
18061 fputs (" R8KPFETCH", stdout
);
18062 if (option
.info
& OHW_R5KEOP
)
18063 fputs (" R5KEOP", stdout
);
18064 if (option
.info
& OHW_R5KCVTL
)
18065 fputs (" R5KCVTL", stdout
);
18069 fputs (" FILL ", stdout
);
18070 /* XXX Print content of info word? */
18074 fputs (" TAGS ", stdout
);
18075 /* XXX Print content of info word? */
18079 fputs (" HWAND ", stdout
);
18080 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
18081 fputs (" R4KEOP_CHECKED", stdout
);
18082 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
18083 fputs (" R4KEOP_CLEAN", stdout
);
18087 fputs (" HWOR ", stdout
);
18088 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
18089 fputs (" R4KEOP_CHECKED", stdout
);
18090 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
18091 fputs (" R4KEOP_CLEAN", stdout
);
18095 printf (" GP_GROUP %#06x self-contained %#06x",
18096 option
.info
& OGP_GROUP
,
18097 (option
.info
& OGP_SELF
) >> 16);
18101 printf (" IDENT %#06x self-contained %#06x",
18102 option
.info
& OGP_GROUP
,
18103 (option
.info
& OGP_SELF
) >> 16);
18107 /* This shouldn't happen. */
18108 printf (" %3d ??? %" PRId16
" %" PRIx32
,
18109 option
.kind
, option
.section
, option
.info
);
18113 len
= sizeof (* eopt
);
18114 while (len
< option
.size
)
18116 unsigned char datum
= *((unsigned char *) eoption
+ len
);
18118 if (ISPRINT (datum
))
18119 printf ("%c", datum
);
18121 printf ("\\%03o", datum
);
18124 fputs ("\n", stdout
);
18126 offset
+= option
.size
;
18134 if (conflicts_offset
!= 0 && conflictsno
!= 0)
18136 Elf32_Conflict
* iconf
;
18139 if (filedata
->dynamic_symbols
== NULL
)
18141 error (_("conflict list found without a dynamic symbol table\n"));
18145 /* PR 21345 - print a slightly more helpful error message
18146 if we are sure that the cmalloc will fail. */
18147 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
18149 error (_("Overlarge number of conflicts detected: %lx\n"),
18150 (long) conflictsno
);
18154 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
18157 error (_("Out of memory allocating space for dynamic conflicts\n"));
18163 Elf32_External_Conflict
* econf32
;
18165 econf32
= (Elf32_External_Conflict
*)
18166 get_data (NULL
, filedata
, conflicts_offset
,
18167 sizeof (*econf32
), conflictsno
, _("conflict"));
18174 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18175 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
18181 Elf64_External_Conflict
* econf64
;
18183 econf64
= (Elf64_External_Conflict
*)
18184 get_data (NULL
, filedata
, conflicts_offset
,
18185 sizeof (*econf64
), conflictsno
, _("conflict"));
18192 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18193 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
18198 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
18199 "\nSection '.conflict' contains %lu entries:\n",
18200 (unsigned long) conflictsno
),
18201 (unsigned long) conflictsno
);
18202 puts (_(" Num: Index Value Name"));
18204 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18206 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
18208 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
18209 printf (_("<corrupt symbol index>"));
18212 Elf_Internal_Sym
* psym
;
18214 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
18215 print_vma (psym
->st_value
, FULL_HEX
);
18217 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
18218 print_symbol (25, GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
18220 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18228 if (pltgot
!= 0 && local_gotno
!= 0)
18230 bfd_vma ent
, local_end
, global_end
;
18232 unsigned char * data
;
18233 unsigned char * data_end
;
18237 addr_size
= (is_32bit_elf
? 4 : 8);
18238 local_end
= pltgot
+ local_gotno
* addr_size
;
18240 /* PR binutils/17533 file: 012-111227-0.004 */
18241 if (symtabno
< gotsym
)
18243 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
18244 (unsigned long) gotsym
, (unsigned long) symtabno
);
18248 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
18249 /* PR 17531: file: 54c91a34. */
18250 if (global_end
< local_end
)
18252 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
18256 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
18257 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
18258 global_end
- pltgot
, 1,
18259 _("Global Offset Table data"));
18260 /* PR 12855: Null data is handled gracefully throughout. */
18261 data_end
= data
+ (global_end
- pltgot
);
18263 printf (_("\nPrimary GOT:\n"));
18264 printf (_(" Canonical gp value: "));
18265 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
18268 printf (_(" Reserved entries:\n"));
18269 printf (_(" %*s %10s %*s Purpose\n"),
18270 addr_size
* 2, _("Address"), _("Access"),
18271 addr_size
* 2, _("Initial"));
18272 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18273 printf (_(" Lazy resolver\n"));
18274 if (ent
== (bfd_vma
) -1)
18275 goto got_print_fail
;
18277 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
18278 This entry will be used by some runtime loaders, to store the
18279 module pointer. Otherwise this is an ordinary local entry.
18280 PR 21344: Check for the entry being fully available before
18283 && data
+ ent
- pltgot
+ addr_size
<= data_end
18284 && (byte_get (data
+ ent
- pltgot
, addr_size
)
18285 >> (addr_size
* 8 - 1)) != 0)
18287 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18288 printf (_(" Module pointer (GNU extension)\n"));
18289 if (ent
== (bfd_vma
) -1)
18290 goto got_print_fail
;
18294 if (data
!= NULL
&& ent
< local_end
)
18296 printf (_(" Local entries:\n"));
18297 printf (" %*s %10s %*s\n",
18298 addr_size
* 2, _("Address"), _("Access"),
18299 addr_size
* 2, _("Initial"));
18300 while (ent
< local_end
)
18302 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18304 if (ent
== (bfd_vma
) -1)
18305 goto got_print_fail
;
18310 if (data
!= NULL
&& gotsym
< symtabno
)
18314 printf (_(" Global entries:\n"));
18315 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
18316 addr_size
* 2, _("Address"),
18318 addr_size
* 2, _("Initial"),
18319 addr_size
* 2, _("Sym.Val."),
18321 /* Note for translators: "Ndx" = abbreviated form of "Index". */
18322 _("Ndx"), _("Name"));
18324 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
18326 for (i
= gotsym
; i
< symtabno
; i
++)
18328 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18331 if (filedata
->dynamic_symbols
== NULL
)
18332 printf (_("<no dynamic symbols>"));
18333 else if (i
< filedata
->num_dynamic_syms
)
18335 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
18337 print_vma (psym
->st_value
, LONG_HEX
);
18338 printf (" %-7s %3s ",
18339 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
18340 get_symbol_index_type (filedata
, psym
->st_shndx
));
18342 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
18343 print_symbol (sym_width
,
18344 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
18346 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18349 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
18350 (unsigned long) i
);
18353 if (ent
== (bfd_vma
) -1)
18363 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
18366 size_t offset
, rel_offset
;
18367 unsigned long count
, i
;
18368 unsigned char * data
;
18369 int addr_size
, sym_width
;
18370 Elf_Internal_Rela
* rels
;
18372 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
18373 if (pltrel
== DT_RELA
)
18375 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
18380 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
18385 addr_size
= (is_32bit_elf
? 4 : 8);
18386 end
= mips_pltgot
+ (2 + count
) * addr_size
;
18388 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
18389 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
18390 1, _("Procedure Linkage Table data"));
18397 printf ("\nPLT GOT:\n\n");
18398 printf (_(" Reserved entries:\n"));
18399 printf (_(" %*s %*s Purpose\n"),
18400 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
18401 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18402 printf (_(" PLT lazy resolver\n"));
18403 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18404 printf (_(" Module pointer\n"));
18407 printf (_(" Entries:\n"));
18408 printf (" %*s %*s %*s %-7s %3s %s\n",
18409 addr_size
* 2, _("Address"),
18410 addr_size
* 2, _("Initial"),
18411 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
18412 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
18413 for (i
= 0; i
< count
; i
++)
18415 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
18417 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18420 if (idx
>= filedata
->num_dynamic_syms
)
18421 printf (_("<corrupt symbol index: %lu>"), idx
);
18424 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
18426 print_vma (psym
->st_value
, LONG_HEX
);
18427 printf (" %-7s %3s ",
18428 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
18429 get_symbol_index_type (filedata
, psym
->st_shndx
));
18430 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
18431 print_symbol (sym_width
,
18432 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
18434 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18448 process_nds32_specific (Filedata
* filedata
)
18450 Elf_Internal_Shdr
*sect
= NULL
;
18452 sect
= find_section (filedata
, ".nds32_e_flags");
18453 if (sect
!= NULL
&& sect
->sh_size
>= 4)
18455 unsigned char *buf
;
18458 printf ("\nNDS32 elf flags section:\n");
18459 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
18460 _("NDS32 elf flags section"));
18465 flag
= byte_get (buf
, 4);
18467 switch (flag
& 0x3)
18470 printf ("(VEC_SIZE):\tNo entry.\n");
18473 printf ("(VEC_SIZE):\t4 bytes\n");
18476 printf ("(VEC_SIZE):\t16 bytes\n");
18479 printf ("(VEC_SIZE):\treserved\n");
18488 process_gnu_liblist (Filedata
* filedata
)
18490 Elf_Internal_Shdr
* section
;
18491 Elf_Internal_Shdr
* string_sec
;
18492 Elf32_External_Lib
* elib
;
18494 size_t strtab_size
;
18496 unsigned long num_liblist
;
18503 for (i
= 0, section
= filedata
->section_headers
;
18504 i
< filedata
->file_header
.e_shnum
;
18507 switch (section
->sh_type
)
18509 case SHT_GNU_LIBLIST
:
18510 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
18513 elib
= (Elf32_External_Lib
*)
18514 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
18515 _("liblist section data"));
18523 string_sec
= filedata
->section_headers
+ section
->sh_link
;
18524 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
18525 string_sec
->sh_size
,
18526 _("liblist string table"));
18528 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
18535 strtab_size
= string_sec
->sh_size
;
18537 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
18538 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
18539 "\nLibrary list section '%s' contains %lu entries:\n",
18541 printable_section_name (filedata
, section
),
18544 puts (_(" Library Time Stamp Checksum Version Flags"));
18546 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
18554 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
18555 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
18556 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
18557 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
18558 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
18560 tmp
= gmtime (&atime
);
18561 snprintf (timebuf
, sizeof (timebuf
),
18562 "%04u-%02u-%02uT%02u:%02u:%02u",
18563 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
18564 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
18566 printf ("%3lu: ", (unsigned long) cnt
);
18568 printf ("%-20s", liblist
.l_name
< strtab_size
18569 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
18571 printf ("%-20.20s", liblist
.l_name
< strtab_size
18572 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
18573 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
18574 liblist
.l_version
, liblist
.l_flags
);
18585 static const char *
18586 get_note_type (Filedata
* filedata
, unsigned e_type
)
18588 static char buff
[64];
18590 if (filedata
->file_header
.e_type
== ET_CORE
)
18594 return _("NT_AUXV (auxiliary vector)");
18596 return _("NT_PRSTATUS (prstatus structure)");
18598 return _("NT_FPREGSET (floating point registers)");
18600 return _("NT_PRPSINFO (prpsinfo structure)");
18601 case NT_TASKSTRUCT
:
18602 return _("NT_TASKSTRUCT (task structure)");
18604 return _("NT_GDB_TDESC (GDB XML target description)");
18606 return _("NT_PRXFPREG (user_xfpregs structure)");
18608 return _("NT_PPC_VMX (ppc Altivec registers)");
18610 return _("NT_PPC_VSX (ppc VSX registers)");
18612 return _("NT_PPC_TAR (ppc TAR register)");
18614 return _("NT_PPC_PPR (ppc PPR register)");
18616 return _("NT_PPC_DSCR (ppc DSCR register)");
18618 return _("NT_PPC_EBB (ppc EBB registers)");
18620 return _("NT_PPC_PMU (ppc PMU registers)");
18621 case NT_PPC_TM_CGPR
:
18622 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
18623 case NT_PPC_TM_CFPR
:
18624 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
18625 case NT_PPC_TM_CVMX
:
18626 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
18627 case NT_PPC_TM_CVSX
:
18628 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
18629 case NT_PPC_TM_SPR
:
18630 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
18631 case NT_PPC_TM_CTAR
:
18632 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
18633 case NT_PPC_TM_CPPR
:
18634 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
18635 case NT_PPC_TM_CDSCR
:
18636 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
18638 return _("NT_386_TLS (x86 TLS information)");
18639 case NT_386_IOPERM
:
18640 return _("NT_386_IOPERM (x86 I/O permissions)");
18641 case NT_X86_XSTATE
:
18642 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
18644 return _("NT_X86_CET (x86 CET state)");
18645 case NT_S390_HIGH_GPRS
:
18646 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
18647 case NT_S390_TIMER
:
18648 return _("NT_S390_TIMER (s390 timer register)");
18649 case NT_S390_TODCMP
:
18650 return _("NT_S390_TODCMP (s390 TOD comparator register)");
18651 case NT_S390_TODPREG
:
18652 return _("NT_S390_TODPREG (s390 TOD programmable register)");
18654 return _("NT_S390_CTRS (s390 control registers)");
18655 case NT_S390_PREFIX
:
18656 return _("NT_S390_PREFIX (s390 prefix register)");
18657 case NT_S390_LAST_BREAK
:
18658 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
18659 case NT_S390_SYSTEM_CALL
:
18660 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
18662 return _("NT_S390_TDB (s390 transaction diagnostic block)");
18663 case NT_S390_VXRS_LOW
:
18664 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
18665 case NT_S390_VXRS_HIGH
:
18666 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
18667 case NT_S390_GS_CB
:
18668 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
18669 case NT_S390_GS_BC
:
18670 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
18672 return _("NT_ARM_VFP (arm VFP registers)");
18674 return _("NT_ARM_TLS (AArch TLS registers)");
18675 case NT_ARM_HW_BREAK
:
18676 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
18677 case NT_ARM_HW_WATCH
:
18678 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
18680 return _("NT_ARM_SVE (AArch SVE registers)");
18681 case NT_ARM_PAC_MASK
:
18682 return _("NT_ARM_PAC_MASK (AArch pointer authentication code masks)");
18683 case NT_ARM_TAGGED_ADDR_CTRL
:
18684 return _("NT_ARM_TAGGED_ADDR_CTRL (AArch tagged address control)");
18686 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
18688 return _("NT_RISCV_CSR (RISC-V control and status registers)");
18690 return _("NT_PSTATUS (pstatus structure)");
18692 return _("NT_FPREGS (floating point registers)");
18694 return _("NT_PSINFO (psinfo structure)");
18696 return _("NT_LWPSTATUS (lwpstatus_t structure)");
18698 return _("NT_LWPSINFO (lwpsinfo_t structure)");
18699 case NT_WIN32PSTATUS
:
18700 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
18702 return _("NT_SIGINFO (siginfo_t data)");
18704 return _("NT_FILE (mapped files)");
18706 return _("NT_MEMTAG (memory tags)");
18714 return _("NT_VERSION (version)");
18716 return _("NT_ARCH (architecture)");
18717 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
18719 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
18725 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18730 print_core_note (Elf_Internal_Note
*pnote
)
18732 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
18733 bfd_vma count
, page_size
;
18734 unsigned char *descdata
, *filenames
, *descend
;
18736 if (pnote
->type
!= NT_FILE
)
18746 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
18747 /* Still "successful". */
18752 if (pnote
->descsz
< 2 * addr_size
)
18754 error (_(" Malformed note - too short for header\n"));
18758 descdata
= (unsigned char *) pnote
->descdata
;
18759 descend
= descdata
+ pnote
->descsz
;
18761 if (descdata
[pnote
->descsz
- 1] != '\0')
18763 error (_(" Malformed note - does not end with \\0\n"));
18767 count
= byte_get (descdata
, addr_size
);
18768 descdata
+= addr_size
;
18770 page_size
= byte_get (descdata
, addr_size
);
18771 descdata
+= addr_size
;
18773 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
18774 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
18776 error (_(" Malformed note - too short for supplied file count\n"));
18780 printf (_(" Page size: "));
18781 print_vma (page_size
, DEC
);
18784 printf (_(" %*s%*s%*s\n"),
18785 (int) (2 + 2 * addr_size
), _("Start"),
18786 (int) (4 + 2 * addr_size
), _("End"),
18787 (int) (4 + 2 * addr_size
), _("Page Offset"));
18788 filenames
= descdata
+ count
* 3 * addr_size
;
18789 while (count
-- > 0)
18791 bfd_vma start
, end
, file_ofs
;
18793 if (filenames
== descend
)
18795 error (_(" Malformed note - filenames end too early\n"));
18799 start
= byte_get (descdata
, addr_size
);
18800 descdata
+= addr_size
;
18801 end
= byte_get (descdata
, addr_size
);
18802 descdata
+= addr_size
;
18803 file_ofs
= byte_get (descdata
, addr_size
);
18804 descdata
+= addr_size
;
18807 print_vma (start
, FULL_HEX
);
18809 print_vma (end
, FULL_HEX
);
18811 print_vma (file_ofs
, FULL_HEX
);
18812 printf ("\n %s\n", filenames
);
18814 filenames
+= 1 + strlen ((char *) filenames
);
18820 static const char *
18821 get_gnu_elf_note_type (unsigned e_type
)
18823 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
18826 case NT_GNU_ABI_TAG
:
18827 return _("NT_GNU_ABI_TAG (ABI version tag)");
18829 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
18830 case NT_GNU_BUILD_ID
:
18831 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
18832 case NT_GNU_GOLD_VERSION
:
18833 return _("NT_GNU_GOLD_VERSION (gold version)");
18834 case NT_GNU_PROPERTY_TYPE_0
:
18835 return _("NT_GNU_PROPERTY_TYPE_0");
18836 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
18837 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
18838 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
18839 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
18842 static char buff
[64];
18844 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18851 decode_x86_compat_isa (unsigned int bitmask
)
18855 unsigned int bit
= bitmask
& (- bitmask
);
18860 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
18863 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
18866 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
18869 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
18872 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
18875 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
18878 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
18881 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
18884 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
18887 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
18890 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
18893 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
18894 printf ("AVX512F");
18896 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
18897 printf ("AVX512CD");
18899 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
18900 printf ("AVX512ER");
18902 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
18903 printf ("AVX512PF");
18905 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
18906 printf ("AVX512VL");
18908 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
18909 printf ("AVX512DQ");
18911 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
18912 printf ("AVX512BW");
18915 printf (_("<unknown: %x>"), bit
);
18924 decode_x86_compat_2_isa (unsigned int bitmask
)
18928 printf (_("<None>"));
18934 unsigned int bit
= bitmask
& (- bitmask
);
18939 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_CMOV
:
18942 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE
:
18945 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE2
:
18948 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE3
:
18951 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSSE3
:
18954 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_1
:
18957 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_2
:
18960 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX
:
18963 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX2
:
18966 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_FMA
:
18969 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512F
:
18970 printf ("AVX512F");
18972 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512CD
:
18973 printf ("AVX512CD");
18975 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512ER
:
18976 printf ("AVX512ER");
18978 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512PF
:
18979 printf ("AVX512PF");
18981 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512VL
:
18982 printf ("AVX512VL");
18984 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512DQ
:
18985 printf ("AVX512DQ");
18987 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512BW
:
18988 printf ("AVX512BW");
18990 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4FMAPS
:
18991 printf ("AVX512_4FMAPS");
18993 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4VNNIW
:
18994 printf ("AVX512_4VNNIW");
18996 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BITALG
:
18997 printf ("AVX512_BITALG");
18999 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_IFMA
:
19000 printf ("AVX512_IFMA");
19002 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI
:
19003 printf ("AVX512_VBMI");
19005 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI2
:
19006 printf ("AVX512_VBMI2");
19008 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VNNI
:
19009 printf ("AVX512_VNNI");
19011 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BF16
:
19012 printf ("AVX512_BF16");
19015 printf (_("<unknown: %x>"), bit
);
19024 decode_x86_isa (unsigned int bitmask
)
19028 unsigned int bit
= bitmask
& (- bitmask
);
19033 case GNU_PROPERTY_X86_ISA_1_BASELINE
:
19034 printf ("x86-64-baseline");
19036 case GNU_PROPERTY_X86_ISA_1_V2
:
19037 printf ("x86-64-v2");
19039 case GNU_PROPERTY_X86_ISA_1_V3
:
19040 printf ("x86-64-v3");
19042 case GNU_PROPERTY_X86_ISA_1_V4
:
19043 printf ("x86-64-v4");
19046 printf (_("<unknown: %x>"), bit
);
19055 decode_x86_feature_1 (unsigned int bitmask
)
19059 printf (_("<None>"));
19065 unsigned int bit
= bitmask
& (- bitmask
);
19070 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
19073 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
19076 case GNU_PROPERTY_X86_FEATURE_1_LAM_U48
:
19077 printf ("LAM_U48");
19079 case GNU_PROPERTY_X86_FEATURE_1_LAM_U57
:
19080 printf ("LAM_U57");
19083 printf (_("<unknown: %x>"), bit
);
19092 decode_x86_feature_2 (unsigned int bitmask
)
19096 printf (_("<None>"));
19102 unsigned int bit
= bitmask
& (- bitmask
);
19107 case GNU_PROPERTY_X86_FEATURE_2_X86
:
19110 case GNU_PROPERTY_X86_FEATURE_2_X87
:
19113 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
19116 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
19119 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
19122 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
19125 case GNU_PROPERTY_X86_FEATURE_2_TMM
:
19128 case GNU_PROPERTY_X86_FEATURE_2_MASK
:
19131 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
19134 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
19137 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
19138 printf ("XSAVEOPT");
19140 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
19143 case GNU_PROPERTY_X86_FEATURE_2_CODE16
:
19147 printf (_("<unknown: %x>"), bit
);
19156 decode_aarch64_feature_1_and (unsigned int bitmask
)
19160 unsigned int bit
= bitmask
& (- bitmask
);
19165 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
19169 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
19174 printf (_("<unknown: %x>"), bit
);
19183 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
19185 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
19186 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
19187 unsigned int size
= is_32bit_elf
? 4 : 8;
19189 printf (_(" Properties: "));
19191 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
19193 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
19197 while (ptr
< ptr_end
)
19201 unsigned int datasz
;
19203 if ((size_t) (ptr_end
- ptr
) < 8)
19205 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
19209 type
= byte_get (ptr
, 4);
19210 datasz
= byte_get (ptr
+ 4, 4);
19214 if (datasz
> (size_t) (ptr_end
- ptr
))
19216 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
19221 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
19223 if (filedata
->file_header
.e_machine
== EM_X86_64
19224 || filedata
->file_header
.e_machine
== EM_IAMCU
19225 || filedata
->file_header
.e_machine
== EM_386
)
19227 unsigned int bitmask
;
19230 bitmask
= byte_get (ptr
, 4);
19236 case GNU_PROPERTY_X86_ISA_1_USED
:
19238 printf (_("x86 ISA used: <corrupt length: %#x> "),
19242 printf ("x86 ISA used: ");
19243 decode_x86_isa (bitmask
);
19247 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
19249 printf (_("x86 ISA needed: <corrupt length: %#x> "),
19253 printf ("x86 ISA needed: ");
19254 decode_x86_isa (bitmask
);
19258 case GNU_PROPERTY_X86_FEATURE_1_AND
:
19260 printf (_("x86 feature: <corrupt length: %#x> "),
19264 printf ("x86 feature: ");
19265 decode_x86_feature_1 (bitmask
);
19269 case GNU_PROPERTY_X86_FEATURE_2_USED
:
19271 printf (_("x86 feature used: <corrupt length: %#x> "),
19275 printf ("x86 feature used: ");
19276 decode_x86_feature_2 (bitmask
);
19280 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
19282 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
19285 printf ("x86 feature needed: ");
19286 decode_x86_feature_2 (bitmask
);
19290 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
19292 printf (_("x86 ISA used: <corrupt length: %#x> "),
19296 printf ("x86 ISA used: ");
19297 decode_x86_compat_isa (bitmask
);
19301 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
19303 printf (_("x86 ISA needed: <corrupt length: %#x> "),
19307 printf ("x86 ISA needed: ");
19308 decode_x86_compat_isa (bitmask
);
19312 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_USED
:
19314 printf (_("x86 ISA used: <corrupt length: %#x> "),
19318 printf ("x86 ISA used: ");
19319 decode_x86_compat_2_isa (bitmask
);
19323 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_NEEDED
:
19325 printf (_("x86 ISA needed: <corrupt length: %#x> "),
19329 printf ("x86 ISA needed: ");
19330 decode_x86_compat_2_isa (bitmask
);
19338 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
19340 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
19342 printf ("AArch64 feature: ");
19344 printf (_("<corrupt length: %#x> "), datasz
);
19346 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
19355 case GNU_PROPERTY_STACK_SIZE
:
19356 printf (_("stack size: "));
19357 if (datasz
!= size
)
19358 printf (_("<corrupt length: %#x> "), datasz
);
19360 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
19363 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
19364 printf ("no copy on protected ");
19366 printf (_("<corrupt length: %#x> "), datasz
);
19374 if (type
< GNU_PROPERTY_LOPROC
)
19375 printf (_("<unknown type %#x data: "), type
);
19376 else if (type
< GNU_PROPERTY_LOUSER
)
19377 printf (_("<processor-specific type %#x data: "), type
);
19379 printf (_("<application-specific type %#x data: "), type
);
19380 for (j
= 0; j
< datasz
; ++j
)
19381 printf ("%02x ", ptr
[j
] & 0xff);
19385 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
19386 if (ptr
== ptr_end
)
19399 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
19401 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
19402 switch (pnote
->type
)
19404 case NT_GNU_BUILD_ID
:
19408 printf (_(" Build ID: "));
19409 for (i
= 0; i
< pnote
->descsz
; ++i
)
19410 printf ("%02x", pnote
->descdata
[i
] & 0xff);
19415 case NT_GNU_ABI_TAG
:
19417 unsigned long os
, major
, minor
, subminor
;
19418 const char *osname
;
19420 /* PR 17531: file: 030-599401-0.004. */
19421 if (pnote
->descsz
< 16)
19423 printf (_(" <corrupt GNU_ABI_TAG>\n"));
19427 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19428 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19429 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
19430 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
19434 case GNU_ABI_TAG_LINUX
:
19437 case GNU_ABI_TAG_HURD
:
19440 case GNU_ABI_TAG_SOLARIS
:
19441 osname
= "Solaris";
19443 case GNU_ABI_TAG_FREEBSD
:
19444 osname
= "FreeBSD";
19446 case GNU_ABI_TAG_NETBSD
:
19449 case GNU_ABI_TAG_SYLLABLE
:
19450 osname
= "Syllable";
19452 case GNU_ABI_TAG_NACL
:
19456 osname
= "Unknown";
19460 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
19461 major
, minor
, subminor
);
19465 case NT_GNU_GOLD_VERSION
:
19469 printf (_(" Version: "));
19470 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
19471 printf ("%c", pnote
->descdata
[i
]);
19478 unsigned long num_entries
, mask
;
19480 /* Hardware capabilities information. Word 0 is the number of entries.
19481 Word 1 is a bitmask of enabled entries. The rest of the descriptor
19482 is a series of entries, where each entry is a single byte followed
19483 by a nul terminated string. The byte gives the bit number to test
19484 if enabled in the bitmask. */
19485 printf (_(" Hardware Capabilities: "));
19486 if (pnote
->descsz
< 8)
19488 error (_("<corrupt GNU_HWCAP>\n"));
19491 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19492 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19493 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
19494 /* FIXME: Add code to display the entries... */
19498 case NT_GNU_PROPERTY_TYPE_0
:
19499 print_gnu_property_note (filedata
, pnote
);
19503 /* Handle unrecognised types. An error message should have already been
19504 created by get_gnu_elf_note_type(), so all that we need to do is to
19505 display the data. */
19509 printf (_(" Description data: "));
19510 for (i
= 0; i
< pnote
->descsz
; ++i
)
19511 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19520 static const char *
19521 get_v850_elf_note_type (enum v850_notes n_type
)
19523 static char buff
[64];
19527 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
19528 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
19529 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
19530 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
19531 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
19532 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
19534 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
19540 print_v850_note (Elf_Internal_Note
* pnote
)
19544 if (pnote
->descsz
!= 4)
19547 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
19551 printf (_("not set\n"));
19555 switch (pnote
->type
)
19557 case V850_NOTE_ALIGNMENT
:
19560 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return true;
19561 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return true;
19565 case V850_NOTE_DATA_SIZE
:
19568 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return true;
19569 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return true;
19573 case V850_NOTE_FPU_INFO
:
19576 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return true;
19577 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return true;
19581 case V850_NOTE_MMU_INFO
:
19582 case V850_NOTE_CACHE_INFO
:
19583 case V850_NOTE_SIMD_INFO
:
19584 if (val
== EF_RH850_SIMD
)
19586 printf (_("yes\n"));
19592 /* An 'unknown note type' message will already have been displayed. */
19596 printf (_("unknown value: %x\n"), val
);
19601 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
19603 unsigned int version
;
19605 switch (pnote
->type
)
19607 case NT_NETBSD_IDENT
:
19608 if (pnote
->descsz
< 1)
19610 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
19611 if ((version
/ 10000) % 100)
19612 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
19613 version
, version
/ 100000000, (version
/ 1000000) % 100,
19614 (version
/ 10000) % 100 > 26 ? "Z" : "",
19615 'A' + (version
/ 10000) % 26);
19617 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
19618 version
, version
/ 100000000, (version
/ 1000000) % 100,
19619 (version
/ 100) % 100);
19622 case NT_NETBSD_MARCH
:
19623 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
19627 case NT_NETBSD_PAX
:
19628 if (pnote
->descsz
< 1)
19630 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
19631 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
19632 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
19633 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
19634 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
19635 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
19636 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
19637 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
19641 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
19642 pnote
->descsz
, pnote
->type
);
19646 static const char *
19647 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
19651 case NT_FREEBSD_THRMISC
:
19652 return _("NT_THRMISC (thrmisc structure)");
19653 case NT_FREEBSD_PROCSTAT_PROC
:
19654 return _("NT_PROCSTAT_PROC (proc data)");
19655 case NT_FREEBSD_PROCSTAT_FILES
:
19656 return _("NT_PROCSTAT_FILES (files data)");
19657 case NT_FREEBSD_PROCSTAT_VMMAP
:
19658 return _("NT_PROCSTAT_VMMAP (vmmap data)");
19659 case NT_FREEBSD_PROCSTAT_GROUPS
:
19660 return _("NT_PROCSTAT_GROUPS (groups data)");
19661 case NT_FREEBSD_PROCSTAT_UMASK
:
19662 return _("NT_PROCSTAT_UMASK (umask data)");
19663 case NT_FREEBSD_PROCSTAT_RLIMIT
:
19664 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
19665 case NT_FREEBSD_PROCSTAT_OSREL
:
19666 return _("NT_PROCSTAT_OSREL (osreldate data)");
19667 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
19668 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
19669 case NT_FREEBSD_PROCSTAT_AUXV
:
19670 return _("NT_PROCSTAT_AUXV (auxv data)");
19671 case NT_FREEBSD_PTLWPINFO
:
19672 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
19674 return get_note_type (filedata
, e_type
);
19677 static const char *
19678 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
19680 static char buff
[64];
19684 case NT_NETBSDCORE_PROCINFO
:
19685 /* NetBSD core "procinfo" structure. */
19686 return _("NetBSD procinfo structure");
19688 case NT_NETBSDCORE_AUXV
:
19689 return _("NetBSD ELF auxiliary vector data");
19691 case NT_NETBSDCORE_LWPSTATUS
:
19692 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
19695 /* As of Jan 2020 there are no other machine-independent notes
19696 defined for NetBSD core files. If the note type is less
19697 than the start of the machine-dependent note types, we don't
19700 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
19702 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19708 switch (filedata
->file_header
.e_machine
)
19710 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
19711 and PT_GETFPREGS == mach+2. */
19716 case EM_SPARC32PLUS
:
19720 case NT_NETBSDCORE_FIRSTMACH
+ 0:
19721 return _("PT_GETREGS (reg structure)");
19722 case NT_NETBSDCORE_FIRSTMACH
+ 2:
19723 return _("PT_GETFPREGS (fpreg structure)");
19729 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
19730 There's also old PT___GETREGS40 == mach + 1 for old reg
19731 structure which lacks GBR. */
19735 case NT_NETBSDCORE_FIRSTMACH
+ 1:
19736 return _("PT___GETREGS40 (old reg structure)");
19737 case NT_NETBSDCORE_FIRSTMACH
+ 3:
19738 return _("PT_GETREGS (reg structure)");
19739 case NT_NETBSDCORE_FIRSTMACH
+ 5:
19740 return _("PT_GETFPREGS (fpreg structure)");
19746 /* On all other arch's, PT_GETREGS == mach+1 and
19747 PT_GETFPREGS == mach+3. */
19751 case NT_NETBSDCORE_FIRSTMACH
+ 1:
19752 return _("PT_GETREGS (reg structure)");
19753 case NT_NETBSDCORE_FIRSTMACH
+ 3:
19754 return _("PT_GETFPREGS (fpreg structure)");
19760 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
19761 e_type
- NT_NETBSDCORE_FIRSTMACH
);
19765 static const char *
19766 get_stapsdt_note_type (unsigned e_type
)
19768 static char buff
[64];
19773 return _("NT_STAPSDT (SystemTap probe descriptors)");
19779 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19784 print_stapsdt_note (Elf_Internal_Note
*pnote
)
19786 size_t len
, maxlen
;
19787 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
19788 char *data
= pnote
->descdata
;
19789 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
19790 bfd_vma pc
, base_addr
, semaphore
;
19791 char *provider
, *probe
, *arg_fmt
;
19793 if (pnote
->descsz
< (addr_size
* 3))
19794 goto stapdt_note_too_small
;
19796 pc
= byte_get ((unsigned char *) data
, addr_size
);
19799 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
19802 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
19805 if (data
>= data_end
)
19806 goto stapdt_note_too_small
;
19807 maxlen
= data_end
- data
;
19808 len
= strnlen (data
, maxlen
);
19815 goto stapdt_note_too_small
;
19817 if (data
>= data_end
)
19818 goto stapdt_note_too_small
;
19819 maxlen
= data_end
- data
;
19820 len
= strnlen (data
, maxlen
);
19827 goto stapdt_note_too_small
;
19829 if (data
>= data_end
)
19830 goto stapdt_note_too_small
;
19831 maxlen
= data_end
- data
;
19832 len
= strnlen (data
, maxlen
);
19839 goto stapdt_note_too_small
;
19841 printf (_(" Provider: %s\n"), provider
);
19842 printf (_(" Name: %s\n"), probe
);
19843 printf (_(" Location: "));
19844 print_vma (pc
, FULL_HEX
);
19845 printf (_(", Base: "));
19846 print_vma (base_addr
, FULL_HEX
);
19847 printf (_(", Semaphore: "));
19848 print_vma (semaphore
, FULL_HEX
);
19850 printf (_(" Arguments: %s\n"), arg_fmt
);
19852 return data
== data_end
;
19854 stapdt_note_too_small
:
19855 printf (_(" <corrupt - note is too small>\n"));
19856 error (_("corrupt stapdt note - the data size is too small\n"));
19860 static const char *
19861 get_ia64_vms_note_type (unsigned e_type
)
19863 static char buff
[64];
19868 return _("NT_VMS_MHD (module header)");
19870 return _("NT_VMS_LNM (language name)");
19872 return _("NT_VMS_SRC (source files)");
19874 return "NT_VMS_TITLE";
19876 return _("NT_VMS_EIDC (consistency check)");
19877 case NT_VMS_FPMODE
:
19878 return _("NT_VMS_FPMODE (FP mode)");
19879 case NT_VMS_LINKTIME
:
19880 return "NT_VMS_LINKTIME";
19881 case NT_VMS_IMGNAM
:
19882 return _("NT_VMS_IMGNAM (image name)");
19884 return _("NT_VMS_IMGID (image id)");
19885 case NT_VMS_LINKID
:
19886 return _("NT_VMS_LINKID (link id)");
19887 case NT_VMS_IMGBID
:
19888 return _("NT_VMS_IMGBID (build id)");
19889 case NT_VMS_GSTNAM
:
19890 return _("NT_VMS_GSTNAM (sym table name)");
19891 case NT_VMS_ORIG_DYN
:
19892 return "NT_VMS_ORIG_DYN";
19893 case NT_VMS_PATCHTIME
:
19894 return "NT_VMS_PATCHTIME";
19896 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19902 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
19904 int maxlen
= pnote
->descsz
;
19906 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
19907 goto desc_size_fail
;
19909 switch (pnote
->type
)
19913 goto desc_size_fail
;
19915 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
19917 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
19918 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
19919 if (l
+ 34 < maxlen
)
19921 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
19922 if (l
+ 35 < maxlen
)
19923 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
19925 printf (_(" Module version : <missing>\n"));
19929 printf (_(" Module name : <missing>\n"));
19930 printf (_(" Module version : <missing>\n"));
19935 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
19939 case NT_VMS_FPMODE
:
19940 printf (_(" Floating Point mode: "));
19942 goto desc_size_fail
;
19943 /* FIXME: Generate an error if descsz > 8 ? */
19945 printf ("0x%016" BFD_VMA_FMT
"x\n",
19946 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19949 case NT_VMS_LINKTIME
:
19950 printf (_(" Link time: "));
19952 goto desc_size_fail
;
19953 /* FIXME: Generate an error if descsz > 8 ? */
19956 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19960 case NT_VMS_PATCHTIME
:
19961 printf (_(" Patch time: "));
19963 goto desc_size_fail
;
19964 /* FIXME: Generate an error if descsz > 8 ? */
19967 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19971 case NT_VMS_ORIG_DYN
:
19973 goto desc_size_fail
;
19975 printf (_(" Major id: %u, minor id: %u\n"),
19976 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
19977 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
19978 printf (_(" Last modified : "));
19980 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
19981 printf (_("\n Link flags : "));
19982 printf ("0x%016" BFD_VMA_FMT
"x\n",
19983 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
19984 printf (_(" Header flags: 0x%08x\n"),
19985 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
19986 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
19990 case NT_VMS_IMGNAM
:
19991 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
19994 case NT_VMS_GSTNAM
:
19995 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
19999 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
20002 case NT_VMS_LINKID
:
20003 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
20013 printf (_(" <corrupt - data size is too small>\n"));
20014 error (_("corrupt IA64 note: data size is too small\n"));
20018 struct build_attr_cache
{
20019 Filedata
*filedata
;
20021 unsigned long strtablen
;
20022 Elf_Internal_Sym
*symtab
;
20023 unsigned long nsyms
;
20026 /* Find the symbol associated with a build attribute that is attached
20027 to address OFFSET. If PNAME is non-NULL then store the name of
20028 the symbol (if found) in the provided pointer, Returns NULL if a
20029 symbol could not be found. */
20031 static Elf_Internal_Sym
*
20032 get_symbol_for_build_attribute (Filedata
*filedata
,
20033 unsigned long offset
,
20035 const char **pname
)
20037 Elf_Internal_Sym
*saved_sym
= NULL
;
20038 Elf_Internal_Sym
*sym
;
20040 if (filedata
->section_headers
!= NULL
20041 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
20043 Elf_Internal_Shdr
* symsec
;
20045 free (ba_cache
.strtab
);
20046 ba_cache
.strtab
= NULL
;
20047 free (ba_cache
.symtab
);
20048 ba_cache
.symtab
= NULL
;
20050 /* Load the symbol and string sections. */
20051 for (symsec
= filedata
->section_headers
;
20052 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
20055 if (symsec
->sh_type
== SHT_SYMTAB
20056 && get_symtab (filedata
, symsec
,
20057 &ba_cache
.symtab
, &ba_cache
.nsyms
,
20058 &ba_cache
.strtab
, &ba_cache
.strtablen
))
20061 ba_cache
.filedata
= filedata
;
20064 if (ba_cache
.symtab
== NULL
)
20067 /* Find a symbol whose value matches offset. */
20068 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
20069 if (sym
->st_value
== offset
)
20071 if (sym
->st_name
>= ba_cache
.strtablen
)
20072 /* Huh ? This should not happen. */
20075 if (ba_cache
.strtab
[sym
->st_name
] == 0)
20078 /* The AArch64 and ARM architectures define mapping symbols
20079 (eg $d, $x, $t) which we want to ignore. */
20080 if (ba_cache
.strtab
[sym
->st_name
] == '$'
20081 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
20082 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
20087 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
20088 and FILE or OBJECT symbols over NOTYPE symbols. We skip
20089 FUNC symbols entirely. */
20090 switch (ELF_ST_TYPE (sym
->st_info
))
20097 /* If the symbol has a size associated
20098 with it then we can stop searching. */
20099 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
20104 /* Ignore function symbols. */
20111 switch (ELF_ST_BIND (sym
->st_info
))
20114 if (saved_sym
== NULL
20115 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
20120 if (saved_sym
== NULL
)
20130 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
20138 if (saved_sym
&& pname
)
20139 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
20144 /* Returns true iff addr1 and addr2 are in the same section. */
20147 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
20149 Elf_Internal_Shdr
* a1
;
20150 Elf_Internal_Shdr
* a2
;
20152 a1
= find_section_by_address (filedata
, addr1
);
20153 a2
= find_section_by_address (filedata
, addr2
);
20155 return a1
== a2
&& a1
!= NULL
;
20159 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
20160 Filedata
* filedata
)
20162 static unsigned long global_offset
= 0;
20163 static unsigned long global_end
= 0;
20164 static unsigned long func_offset
= 0;
20165 static unsigned long func_end
= 0;
20167 Elf_Internal_Sym
*sym
;
20169 unsigned long start
;
20171 bool is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
20173 switch (pnote
->descsz
)
20176 /* A zero-length description means that the range of
20177 the previous note of the same type should be used. */
20180 if (global_end
> global_offset
)
20181 printf (_(" Applies to region from %#lx to %#lx\n"),
20182 global_offset
, global_end
);
20184 printf (_(" Applies to region from %#lx\n"), global_offset
);
20188 if (func_end
> func_offset
)
20189 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
20191 printf (_(" Applies to region from %#lx\n"), func_offset
);
20196 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20201 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20202 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
20206 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
20207 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
20211 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
20212 printf (_(" <invalid descsz>"));
20217 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
20218 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
20219 in order to avoid them being confused with the start address of the
20220 first function in the file... */
20221 if (sym
== NULL
&& is_open_attr
)
20222 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
20225 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
20226 end
= start
+ sym
->st_size
;
20230 /* FIXME: Need to properly allow for section alignment.
20231 16 is just the alignment used on x86_64. */
20233 && start
> BFD_ALIGN (global_end
, 16)
20234 /* Build notes are not guaranteed to be organised in order of
20235 increasing address, but we should find the all of the notes
20236 for one section in the same place. */
20237 && same_section (filedata
, start
, global_end
))
20238 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
20239 global_end
+ 1, start
- 1);
20241 printf (_(" Applies to region from %#lx"), start
);
20242 global_offset
= start
;
20246 printf (_(" to %#lx"), end
);
20252 printf (_(" Applies to region from %#lx"), start
);
20253 func_offset
= start
;
20257 printf (_(" to %#lx"), end
);
20263 printf (_(" (%s)"), name
);
20270 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
20272 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
20273 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
20274 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
20276 char name_attribute
;
20277 const char * expected_types
;
20278 const char * name
= pnote
->namedata
;
20282 if (name
== NULL
|| pnote
->namesz
< 2)
20284 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
20285 print_symbol (-20, _(" <corrupt name>"));
20294 /* Version 2 of the spec adds a "GA" prefix to the name field. */
20295 if (name
[0] == 'G' && name
[1] == 'A')
20297 if (pnote
->namesz
< 4)
20299 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
20300 print_symbol (-20, _(" <corrupt name>"));
20309 switch ((name_type
= * name
))
20311 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
20312 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
20313 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
20314 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
20315 printf ("%c", * name
);
20319 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
20320 print_symbol (-20, _("<unknown name type>"));
20327 switch ((name_attribute
= * name
))
20329 case GNU_BUILD_ATTRIBUTE_VERSION
:
20330 text
= _("<version>");
20331 expected_types
= string_expected
;
20334 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
20335 text
= _("<stack prot>");
20336 expected_types
= "!+*";
20339 case GNU_BUILD_ATTRIBUTE_RELRO
:
20340 text
= _("<relro>");
20341 expected_types
= bool_expected
;
20344 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
20345 text
= _("<stack size>");
20346 expected_types
= number_expected
;
20349 case GNU_BUILD_ATTRIBUTE_TOOL
:
20350 text
= _("<tool>");
20351 expected_types
= string_expected
;
20354 case GNU_BUILD_ATTRIBUTE_ABI
:
20356 expected_types
= "$*";
20359 case GNU_BUILD_ATTRIBUTE_PIC
:
20361 expected_types
= number_expected
;
20364 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
20365 text
= _("<short enum>");
20366 expected_types
= bool_expected
;
20370 if (ISPRINT (* name
))
20372 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
20374 if (len
> left
&& ! do_wide
)
20376 printf ("%.*s:", len
, name
);
20382 static char tmpbuf
[128];
20384 error (_("unrecognised byte in name field: %d\n"), * name
);
20385 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
20389 expected_types
= "*$!+";
20394 left
-= printf ("%s", text
);
20396 if (strchr (expected_types
, name_type
) == NULL
)
20397 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
20399 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
20401 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
20402 (unsigned long) pnote
->namesz
,
20403 (long) (name
- pnote
->namedata
));
20407 if (left
< 1 && ! do_wide
)
20412 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
20414 unsigned int bytes
;
20415 unsigned long long val
= 0;
20416 unsigned int shift
= 0;
20417 char * decoded
= NULL
;
20419 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
20421 /* The -1 is because the name field is always 0 terminated, and we
20422 want to be able to ensure that the shift in the while loop below
20423 will not overflow. */
20426 if (bytes
> sizeof (val
))
20428 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
20430 bytes
= sizeof (val
);
20432 /* We do not bother to warn if bytes == 0 as this can
20433 happen with some early versions of the gcc plugin. */
20437 unsigned long long byte
= *name
++ & 0xff;
20439 val
|= byte
<< shift
;
20443 switch (name_attribute
)
20445 case GNU_BUILD_ATTRIBUTE_PIC
:
20448 case 0: decoded
= "static"; break;
20449 case 1: decoded
= "pic"; break;
20450 case 2: decoded
= "PIC"; break;
20451 case 3: decoded
= "pie"; break;
20452 case 4: decoded
= "PIE"; break;
20456 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
20459 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
20460 case 0: decoded
= "off"; break;
20461 case 1: decoded
= "on"; break;
20462 case 2: decoded
= "all"; break;
20463 case 3: decoded
= "strong"; break;
20464 case 4: decoded
= "explicit"; break;
20472 if (decoded
!= NULL
)
20474 print_symbol (-left
, decoded
);
20485 left
-= printf ("0x%llx", val
);
20487 left
-= printf ("0x%-.*llx", left
, val
);
20491 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
20492 left
-= print_symbol (- left
, name
);
20494 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
20495 left
-= print_symbol (- left
, "true");
20497 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
20498 left
-= print_symbol (- left
, "false");
20502 if (do_wide
&& left
> 0)
20503 printf ("%-*s", left
, " ");
20508 /* Note that by the ELF standard, the name field is already null byte
20509 terminated, and namesz includes the terminating null byte.
20510 I.E. the value of namesz for the name "FSF" is 4.
20512 If the value of namesz is zero, there is no name present. */
20515 process_note (Elf_Internal_Note
* pnote
,
20516 Filedata
* filedata
)
20518 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
20521 if (pnote
->namesz
== 0)
20522 /* If there is no note name, then use the default set of
20523 note type strings. */
20524 nt
= get_note_type (filedata
, pnote
->type
);
20526 else if (startswith (pnote
->namedata
, "GNU"))
20527 /* GNU-specific object file notes. */
20528 nt
= get_gnu_elf_note_type (pnote
->type
);
20530 else if (startswith (pnote
->namedata
, "FreeBSD"))
20531 /* FreeBSD-specific core file notes. */
20532 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
20534 else if (startswith (pnote
->namedata
, "NetBSD-CORE"))
20535 /* NetBSD-specific core file notes. */
20536 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
20538 else if (startswith (pnote
->namedata
, "NetBSD"))
20539 /* NetBSD-specific core file notes. */
20540 return process_netbsd_elf_note (pnote
);
20542 else if (startswith (pnote
->namedata
, "PaX"))
20543 /* NetBSD-specific core file notes. */
20544 return process_netbsd_elf_note (pnote
);
20546 else if (startswith (pnote
->namedata
, "SPU/"))
20548 /* SPU-specific core file notes. */
20549 nt
= pnote
->namedata
+ 4;
20553 else if (startswith (pnote
->namedata
, "IPF/VMS"))
20554 /* VMS/ia64-specific file notes. */
20555 nt
= get_ia64_vms_note_type (pnote
->type
);
20557 else if (startswith (pnote
->namedata
, "stapsdt"))
20558 nt
= get_stapsdt_note_type (pnote
->type
);
20561 /* Don't recognize this note name; just use the default set of
20562 note type strings. */
20563 nt
= get_note_type (filedata
, pnote
->type
);
20567 if (((startswith (pnote
->namedata
, "GA")
20568 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
20569 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
20570 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
20571 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
20572 print_gnu_build_attribute_name (pnote
);
20574 print_symbol (-20, name
);
20577 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
20579 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
20581 if (startswith (pnote
->namedata
, "IPF/VMS"))
20582 return print_ia64_vms_note (pnote
);
20583 else if (startswith (pnote
->namedata
, "GNU"))
20584 return print_gnu_note (filedata
, pnote
);
20585 else if (startswith (pnote
->namedata
, "stapsdt"))
20586 return print_stapsdt_note (pnote
);
20587 else if (startswith (pnote
->namedata
, "CORE"))
20588 return print_core_note (pnote
);
20589 else if (((startswith (pnote
->namedata
, "GA")
20590 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
20591 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
20592 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
20593 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
20594 return print_gnu_build_attribute_description (pnote
, filedata
);
20600 printf (_(" description data: "));
20601 for (i
= 0; i
< pnote
->descsz
; i
++)
20602 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
20614 process_notes_at (Filedata
* filedata
,
20615 Elf_Internal_Shdr
* section
,
20620 Elf_External_Note
*pnotes
;
20621 Elf_External_Note
*external
;
20630 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
20633 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
20641 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
20644 if (pnotes
== NULL
)
20649 if (filedata
->is_separate
)
20650 printf (_("In linked file '%s': "), filedata
->file_name
);
20654 printf (_("Displaying notes found in: %s\n"), printable_section_name (filedata
, section
));
20656 printf (_("Displaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
20657 (unsigned long) offset
, (unsigned long) length
);
20659 /* NB: Some note sections may have alignment value of 0 or 1. gABI
20660 specifies that notes should be aligned to 4 bytes in 32-bit
20661 objects and to 8 bytes in 64-bit objects. As a Linux extension,
20662 we also support 4 byte alignment in 64-bit objects. If section
20663 alignment is less than 4, we treate alignment as 4 bytes. */
20666 else if (align
!= 4 && align
!= 8)
20668 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
20674 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
20676 end
= (char *) pnotes
+ length
;
20677 while ((char *) external
< end
)
20679 Elf_Internal_Note inote
;
20682 char * temp
= NULL
;
20683 size_t data_remaining
= end
- (char *) external
;
20685 if (!is_ia64_vms (filedata
))
20687 /* PR binutils/15191
20688 Make sure that there is enough data to read. */
20689 min_notesz
= offsetof (Elf_External_Note
, name
);
20690 if (data_remaining
< min_notesz
)
20692 warn (ngettext ("Corrupt note: only %ld byte remains, "
20693 "not enough for a full note\n",
20694 "Corrupt note: only %ld bytes remain, "
20695 "not enough for a full note\n",
20697 (long) data_remaining
);
20700 data_remaining
-= min_notesz
;
20702 inote
.type
= BYTE_GET (external
->type
);
20703 inote
.namesz
= BYTE_GET (external
->namesz
);
20704 inote
.namedata
= external
->name
;
20705 inote
.descsz
= BYTE_GET (external
->descsz
);
20706 inote
.descdata
= ((char *) external
20707 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
20708 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20709 next
= ((char *) external
20710 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
20714 Elf64_External_VMS_Note
*vms_external
;
20716 /* PR binutils/15191
20717 Make sure that there is enough data to read. */
20718 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
20719 if (data_remaining
< min_notesz
)
20721 warn (ngettext ("Corrupt note: only %ld byte remains, "
20722 "not enough for a full note\n",
20723 "Corrupt note: only %ld bytes remain, "
20724 "not enough for a full note\n",
20726 (long) data_remaining
);
20729 data_remaining
-= min_notesz
;
20731 vms_external
= (Elf64_External_VMS_Note
*) external
;
20732 inote
.type
= BYTE_GET (vms_external
->type
);
20733 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
20734 inote
.namedata
= vms_external
->name
;
20735 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
20736 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
20737 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20738 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
20741 /* PR 17531: file: 3443835e. */
20742 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
20743 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
20744 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
20745 || (size_t) (next
- inote
.descdata
) < inote
.descsz
20746 || ((size_t) (next
- inote
.descdata
)
20747 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
20749 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
20750 (unsigned long) ((char *) external
- (char *) pnotes
));
20751 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
20752 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
20756 external
= (Elf_External_Note
*) next
;
20758 /* Verify that name is null terminated. It appears that at least
20759 one version of Linux (RedHat 6.0) generates corefiles that don't
20760 comply with the ELF spec by failing to include the null byte in
20762 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
20764 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
20766 temp
= (char *) malloc (inote
.namesz
+ 1);
20769 error (_("Out of memory allocating space for inote name\n"));
20774 memcpy (temp
, inote
.namedata
, inote
.namesz
);
20775 inote
.namedata
= temp
;
20777 inote
.namedata
[inote
.namesz
] = 0;
20780 if (! process_note (& inote
, filedata
))
20793 process_corefile_note_segments (Filedata
* filedata
)
20795 Elf_Internal_Phdr
*segment
;
20799 if (! get_program_headers (filedata
))
20802 for (i
= 0, segment
= filedata
->program_headers
;
20803 i
< filedata
->file_header
.e_phnum
;
20806 if (segment
->p_type
== PT_NOTE
)
20807 if (! process_notes_at (filedata
, NULL
,
20808 (bfd_vma
) segment
->p_offset
,
20809 (bfd_vma
) segment
->p_filesz
,
20810 (bfd_vma
) segment
->p_align
))
20818 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
20820 Elf_External_Note
* pnotes
;
20821 Elf_External_Note
* external
;
20828 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
20830 if (pnotes
== NULL
)
20834 end
= (char*) pnotes
+ length
;
20836 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
20837 (unsigned long) offset
, (unsigned long) length
);
20839 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
20841 Elf_External_Note
* next
;
20842 Elf_Internal_Note inote
;
20844 inote
.type
= BYTE_GET (external
->type
);
20845 inote
.namesz
= BYTE_GET (external
->namesz
);
20846 inote
.namedata
= external
->name
;
20847 inote
.descsz
= BYTE_GET (external
->descsz
);
20848 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
20849 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20851 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
20853 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
20854 inote
.descdata
= inote
.namedata
;
20858 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
20860 if ( ((char *) next
> end
)
20861 || ((char *) next
< (char *) pnotes
))
20863 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
20864 (unsigned long) ((char *) external
- (char *) pnotes
));
20865 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
20866 inote
.type
, inote
.namesz
, inote
.descsz
);
20872 /* Prevent out-of-bounds indexing. */
20873 if ( inote
.namedata
+ inote
.namesz
> end
20874 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
20876 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
20877 (unsigned long) ((char *) external
- (char *) pnotes
));
20878 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
20879 inote
.type
, inote
.namesz
, inote
.descsz
);
20883 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
20885 if (! print_v850_note (& inote
))
20888 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
20889 inote
.namesz
, inote
.descsz
);
20899 process_note_sections (Filedata
* filedata
)
20901 Elf_Internal_Shdr
*section
;
20903 unsigned int n
= 0;
20906 for (i
= 0, section
= filedata
->section_headers
;
20907 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
20910 if (section
->sh_type
== SHT_NOTE
)
20912 if (! process_notes_at (filedata
, section
,
20913 (bfd_vma
) section
->sh_offset
,
20914 (bfd_vma
) section
->sh_size
,
20915 (bfd_vma
) section
->sh_addralign
))
20920 if (( filedata
->file_header
.e_machine
== EM_V800
20921 || filedata
->file_header
.e_machine
== EM_V850
20922 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
20923 && section
->sh_type
== SHT_RENESAS_INFO
)
20925 if (! process_v850_notes (filedata
,
20926 (bfd_vma
) section
->sh_offset
,
20927 (bfd_vma
) section
->sh_size
))
20934 /* Try processing NOTE segments instead. */
20935 return process_corefile_note_segments (filedata
);
20941 process_notes (Filedata
* filedata
)
20943 /* If we have not been asked to display the notes then do nothing. */
20947 if (filedata
->file_header
.e_type
!= ET_CORE
)
20948 return process_note_sections (filedata
);
20950 /* No program headers means no NOTE segment. */
20951 if (filedata
->file_header
.e_phnum
> 0)
20952 return process_corefile_note_segments (filedata
);
20954 if (filedata
->is_separate
)
20955 printf (_("No notes found in linked file '%s'.\n"),
20956 filedata
->file_name
);
20958 printf (_("No notes found file.\n"));
20963 static unsigned char *
20964 display_public_gnu_attributes (unsigned char * start
,
20965 const unsigned char * const end
)
20967 printf (_(" Unknown GNU attribute: %s\n"), start
);
20969 start
+= strnlen ((char *) start
, end
- start
);
20970 display_raw_attribute (start
, end
);
20972 return (unsigned char *) end
;
20975 static unsigned char *
20976 display_generic_attribute (unsigned char * start
,
20978 const unsigned char * const end
)
20981 return (unsigned char *) end
;
20983 return display_tag_value (tag
, start
, end
);
20987 process_arch_specific (Filedata
* filedata
)
20992 switch (filedata
->file_header
.e_machine
)
20995 case EM_ARC_COMPACT
:
20996 case EM_ARC_COMPACT2
:
20997 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
20998 display_arc_attribute
,
20999 display_generic_attribute
);
21001 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
21002 display_arm_attribute
,
21003 display_generic_attribute
);
21006 case EM_MIPS_RS3_LE
:
21007 return process_mips_specific (filedata
);
21010 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
21011 display_msp430_attribute
,
21012 display_msp430_gnu_attribute
);
21015 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
21016 display_riscv_attribute
,
21017 display_generic_attribute
);
21020 return process_nds32_specific (filedata
);
21023 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21024 display_m68k_gnu_attribute
);
21028 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21029 display_power_gnu_attribute
);
21033 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21034 display_s390_gnu_attribute
);
21037 case EM_SPARC32PLUS
:
21039 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21040 display_sparc_gnu_attribute
);
21043 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
21044 display_tic6x_attribute
,
21045 display_generic_attribute
);
21048 return process_attributes (filedata
, "csky", SHT_CSKY_ATTRIBUTES
,
21049 display_csky_attribute
, NULL
);
21052 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
21053 display_public_gnu_attributes
,
21054 display_generic_attribute
);
21059 get_file_header (Filedata
* filedata
)
21061 /* Read in the identity array. */
21062 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
21065 /* Determine how to read the rest of the header. */
21066 switch (filedata
->file_header
.e_ident
[EI_DATA
])
21071 byte_get
= byte_get_little_endian
;
21072 byte_put
= byte_put_little_endian
;
21075 byte_get
= byte_get_big_endian
;
21076 byte_put
= byte_put_big_endian
;
21080 /* For now we only support 32 bit and 64 bit ELF files. */
21081 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
21083 /* Read in the rest of the header. */
21086 Elf32_External_Ehdr ehdr32
;
21088 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
21091 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
21092 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
21093 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
21094 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
21095 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
21096 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
21097 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
21098 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
21099 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
21100 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
21101 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
21102 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
21103 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
21107 Elf64_External_Ehdr ehdr64
;
21109 /* If we have been compiled with sizeof (bfd_vma) == 4, then
21110 we will not be able to cope with the 64bit data found in
21111 64 ELF files. Detect this now and abort before we start
21112 overwriting things. */
21113 if (sizeof (bfd_vma
) < 8)
21115 error (_("This instance of readelf has been built without support for a\n\
21116 64 bit data type and so it cannot read 64 bit ELF files.\n"));
21120 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
21123 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
21124 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
21125 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
21126 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
21127 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
21128 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
21129 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
21130 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
21131 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
21132 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
21133 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
21134 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
21135 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
21138 if (filedata
->file_header
.e_shoff
)
21140 /* There may be some extensions in the first section header. Don't
21141 bomb if we can't read it. */
21143 get_32bit_section_headers (filedata
, true);
21145 get_64bit_section_headers (filedata
, true);
21152 free_filedata (Filedata
*filedata
)
21154 free (filedata
->program_interpreter
);
21155 filedata
->program_interpreter
= NULL
;
21157 free (filedata
->program_headers
);
21158 filedata
->program_headers
= NULL
;
21160 free (filedata
->section_headers
);
21161 filedata
->section_headers
= NULL
;
21163 free (filedata
->string_table
);
21164 filedata
->string_table
= NULL
;
21165 filedata
->string_table_length
= 0;
21167 free (filedata
->dump
.dump_sects
);
21168 filedata
->dump
.dump_sects
= NULL
;
21169 filedata
->dump
.num_dump_sects
= 0;
21171 free (filedata
->dynamic_strings
);
21172 filedata
->dynamic_strings
= NULL
;
21173 filedata
->dynamic_strings_length
= 0;
21175 free (filedata
->dynamic_symbols
);
21176 filedata
->dynamic_symbols
= NULL
;
21177 filedata
->num_dynamic_syms
= 0;
21179 free (filedata
->dynamic_syminfo
);
21180 filedata
->dynamic_syminfo
= NULL
;
21182 free (filedata
->dynamic_section
);
21183 filedata
->dynamic_section
= NULL
;
21185 while (filedata
->symtab_shndx_list
!= NULL
)
21187 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
21188 free (filedata
->symtab_shndx_list
);
21189 filedata
->symtab_shndx_list
= next
;
21192 free (filedata
->section_headers_groups
);
21193 filedata
->section_headers_groups
= NULL
;
21195 if (filedata
->section_groups
)
21198 struct group_list
* g
;
21199 struct group_list
* next
;
21201 for (i
= 0; i
< filedata
->group_count
; i
++)
21203 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
21210 free (filedata
->section_groups
);
21211 filedata
->section_groups
= NULL
;
21216 close_file (Filedata
* filedata
)
21220 if (filedata
->handle
)
21221 fclose (filedata
->handle
);
21227 close_debug_file (void * data
)
21229 free_filedata ((Filedata
*) data
);
21230 close_file ((Filedata
*) data
);
21234 open_file (const char * pathname
, bool is_separate
)
21236 struct stat statbuf
;
21237 Filedata
* filedata
= NULL
;
21239 if (stat (pathname
, & statbuf
) < 0
21240 || ! S_ISREG (statbuf
.st_mode
))
21243 filedata
= calloc (1, sizeof * filedata
);
21244 if (filedata
== NULL
)
21247 filedata
->handle
= fopen (pathname
, "rb");
21248 if (filedata
->handle
== NULL
)
21251 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
21252 filedata
->file_name
= pathname
;
21253 filedata
->is_separate
= is_separate
;
21255 if (! get_file_header (filedata
))
21258 if (filedata
->file_header
.e_shoff
)
21262 /* Read the section headers again, this time for real. */
21264 res
= get_32bit_section_headers (filedata
, false);
21266 res
= get_64bit_section_headers (filedata
, false);
21277 if (filedata
->handle
)
21278 fclose (filedata
->handle
);
21285 open_debug_file (const char * pathname
)
21287 return open_file (pathname
, true);
21291 initialise_dump_sects (Filedata
* filedata
)
21293 /* Initialise the dump_sects array from the cmdline_dump_sects array.
21294 Note we do this even if cmdline_dump_sects is empty because we
21295 must make sure that the dump_sets array is zeroed out before each
21296 object file is processed. */
21297 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
21298 memset (filedata
->dump
.dump_sects
, 0,
21299 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
21301 if (cmdline
.num_dump_sects
> 0)
21303 if (filedata
->dump
.num_dump_sects
== 0)
21304 /* A sneaky way of allocating the dump_sects array. */
21305 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
21307 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
21308 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
21309 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
21313 /* Process one ELF object file according to the command line options.
21314 This file may actually be stored in an archive. The file is
21315 positioned at the start of the ELF object. Returns TRUE if no
21316 problems were encountered, FALSE otherwise. */
21319 process_object (Filedata
* filedata
)
21321 bool have_separate_files
;
21325 if (! get_file_header (filedata
))
21327 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
21331 /* Initialise per file variables. */
21332 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
21333 filedata
->version_info
[i
] = 0;
21335 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
21336 filedata
->dynamic_info
[i
] = 0;
21337 filedata
->dynamic_info_DT_GNU_HASH
= 0;
21338 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
21340 /* Process the file. */
21342 printf (_("\nFile: %s\n"), filedata
->file_name
);
21344 initialise_dump_sects (filedata
);
21346 if (! process_file_header (filedata
))
21349 if (! process_section_headers (filedata
))
21351 /* Without loaded section headers we cannot process lots of things. */
21352 do_unwind
= do_version
= do_dump
= do_arch
= false;
21354 if (! do_using_dynamic
)
21355 do_syms
= do_dyn_syms
= do_reloc
= false;
21358 if (! process_section_groups (filedata
))
21359 /* Without loaded section groups we cannot process unwind. */
21362 res
= process_program_headers (filedata
);
21364 res
= process_dynamic_section (filedata
);
21366 if (! process_relocs (filedata
))
21369 if (! process_unwind (filedata
))
21372 if (! process_symbol_table (filedata
))
21375 if (! process_lto_symbol_tables (filedata
))
21378 if (! process_syminfo (filedata
))
21381 if (! process_version_sections (filedata
))
21384 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
21385 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
21387 have_separate_files
= false;
21389 if (! process_section_contents (filedata
))
21392 if (have_separate_files
)
21396 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
21398 initialise_dump_sects (d
->handle
);
21400 if (process_links
&& ! process_file_header (d
->handle
))
21402 else if (! process_section_headers (d
->handle
))
21404 else if (! process_section_contents (d
->handle
))
21406 else if (process_links
)
21408 if (! process_section_groups (d
->handle
))
21410 if (! process_program_headers (d
->handle
))
21412 if (! process_dynamic_section (d
->handle
))
21414 if (! process_relocs (d
->handle
))
21416 if (! process_unwind (d
->handle
))
21418 if (! process_symbol_table (d
->handle
))
21420 if (! process_lto_symbol_tables (d
->handle
))
21422 if (! process_syminfo (d
->handle
))
21424 if (! process_version_sections (d
->handle
))
21426 if (! process_notes (d
->handle
))
21431 /* The file handles are closed by the call to free_debug_memory() below. */
21434 if (! process_notes (filedata
))
21437 if (! process_gnu_liblist (filedata
))
21440 if (! process_arch_specific (filedata
))
21443 free_filedata (filedata
);
21445 free_debug_memory ();
21450 /* Process an ELF archive.
21451 On entry the file is positioned just after the ARMAG string.
21452 Returns TRUE upon success, FALSE otherwise. */
21455 process_archive (Filedata
* filedata
, bool is_thin_archive
)
21457 struct archive_info arch
;
21458 struct archive_info nested_arch
;
21464 /* The ARCH structure is used to hold information about this archive. */
21465 arch
.file_name
= NULL
;
21467 arch
.index_array
= NULL
;
21468 arch
.sym_table
= NULL
;
21469 arch
.longnames
= NULL
;
21471 /* The NESTED_ARCH structure is used as a single-item cache of information
21472 about a nested archive (when members of a thin archive reside within
21473 another regular archive file). */
21474 nested_arch
.file_name
= NULL
;
21475 nested_arch
.file
= NULL
;
21476 nested_arch
.index_array
= NULL
;
21477 nested_arch
.sym_table
= NULL
;
21478 nested_arch
.longnames
= NULL
;
21480 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
21481 filedata
->file_size
, is_thin_archive
,
21482 do_archive_index
) != 0)
21488 if (do_archive_index
)
21490 if (arch
.sym_table
== NULL
)
21491 error (_("%s: unable to dump the index as none was found\n"),
21492 filedata
->file_name
);
21495 unsigned long i
, l
;
21496 unsigned long current_pos
;
21498 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
21499 "in the symbol table)\n"),
21500 filedata
->file_name
, (unsigned long) arch
.index_num
,
21503 current_pos
= ftell (filedata
->handle
);
21505 for (i
= l
= 0; i
< arch
.index_num
; i
++)
21508 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
21511 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
21514 if (member_name
!= NULL
)
21516 char * qualified_name
21517 = make_qualified_name (&arch
, &nested_arch
,
21520 if (qualified_name
!= NULL
)
21522 printf (_("Contents of binary %s at offset "),
21524 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
21526 free (qualified_name
);
21528 free (member_name
);
21532 if (l
>= arch
.sym_size
)
21534 error (_("%s: end of the symbol table reached "
21535 "before the end of the index\n"),
21536 filedata
->file_name
);
21540 /* PR 17531: file: 0b6630b2. */
21541 printf ("\t%.*s\n",
21542 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
21543 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
21546 if (arch
.uses_64bit_indices
)
21551 if (l
< arch
.sym_size
)
21553 error (ngettext ("%s: %ld byte remains in the symbol table, "
21554 "but without corresponding entries in "
21555 "the index table\n",
21556 "%s: %ld bytes remain in the symbol table, "
21557 "but without corresponding entries in "
21558 "the index table\n",
21559 arch
.sym_size
- l
),
21560 filedata
->file_name
, arch
.sym_size
- l
);
21564 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
21566 error (_("%s: failed to seek back to start of object files "
21567 "in the archive\n"),
21568 filedata
->file_name
);
21574 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
21575 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
21576 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
21577 && !do_section_groups
&& !do_dyn_syms
)
21579 ret
= true; /* Archive index only. */
21588 char * qualified_name
;
21590 /* Read the next archive header. */
21591 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
21593 error (_("%s: failed to seek to next archive header\n"),
21598 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
21599 if (got
!= sizeof arch
.arhdr
)
21603 /* PR 24049 - we cannot use filedata->file_name as this will
21604 have already been freed. */
21605 error (_("%s: failed to read archive header\n"), arch
.file_name
);
21610 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
21612 error (_("%s: did not find a valid archive header\n"),
21618 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
21620 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
21621 if (filedata
->archive_file_size
& 01)
21622 ++filedata
->archive_file_size
;
21624 name
= get_archive_member_name (&arch
, &nested_arch
);
21627 error (_("%s: bad archive file name\n"), arch
.file_name
);
21631 namelen
= strlen (name
);
21633 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
21634 if (qualified_name
== NULL
)
21636 error (_("%s: bad archive file name\n"), arch
.file_name
);
21642 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
21644 /* This is a proxy for an external member of a thin archive. */
21645 Filedata
* member_filedata
;
21646 char * member_file_name
= adjust_relative_path
21647 (filedata
->file_name
, name
, namelen
);
21650 if (member_file_name
== NULL
)
21652 free (qualified_name
);
21657 member_filedata
= open_file (member_file_name
, false);
21658 if (member_filedata
== NULL
)
21660 error (_("Input file '%s' is not readable.\n"), member_file_name
);
21661 free (member_file_name
);
21662 free (qualified_name
);
21667 filedata
->archive_file_offset
= arch
.nested_member_origin
;
21668 member_filedata
->file_name
= qualified_name
;
21670 if (! process_object (member_filedata
))
21673 close_file (member_filedata
);
21674 free (member_file_name
);
21676 else if (is_thin_archive
)
21678 Filedata thin_filedata
;
21680 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
21682 /* PR 15140: Allow for corrupt thin archives. */
21683 if (nested_arch
.file
== NULL
)
21685 error (_("%s: contains corrupt thin archive: %s\n"),
21686 qualified_name
, name
);
21687 free (qualified_name
);
21694 /* This is a proxy for a member of a nested archive. */
21695 filedata
->archive_file_offset
21696 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
21698 /* The nested archive file will have been opened and setup by
21699 get_archive_member_name. */
21700 if (fseek (nested_arch
.file
, filedata
->archive_file_offset
,
21703 error (_("%s: failed to seek to archive member.\n"),
21704 nested_arch
.file_name
);
21705 free (qualified_name
);
21710 thin_filedata
.handle
= nested_arch
.file
;
21711 thin_filedata
.file_name
= qualified_name
;
21713 if (! process_object (& thin_filedata
))
21719 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
21720 filedata
->file_name
= qualified_name
;
21721 if (! process_object (filedata
))
21723 arch
.next_arhdr_offset
+= filedata
->archive_file_size
;
21724 /* Stop looping with "negative" archive_file_size. */
21725 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
21726 arch
.next_arhdr_offset
= -1ul;
21729 free (qualified_name
);
21733 if (nested_arch
.file
!= NULL
)
21734 fclose (nested_arch
.file
);
21735 release_archive (&nested_arch
);
21736 release_archive (&arch
);
21742 process_file (char * file_name
)
21744 Filedata
* filedata
= NULL
;
21745 struct stat statbuf
;
21746 char armag
[SARMAG
];
21749 if (stat (file_name
, &statbuf
) < 0)
21751 if (errno
== ENOENT
)
21752 error (_("'%s': No such file\n"), file_name
);
21754 error (_("Could not locate '%s'. System error message: %s\n"),
21755 file_name
, strerror (errno
));
21759 if (! S_ISREG (statbuf
.st_mode
))
21761 error (_("'%s' is not an ordinary file\n"), file_name
);
21765 filedata
= calloc (1, sizeof * filedata
);
21766 if (filedata
== NULL
)
21768 error (_("Out of memory allocating file data structure\n"));
21772 filedata
->file_name
= file_name
;
21773 filedata
->handle
= fopen (file_name
, "rb");
21774 if (filedata
->handle
== NULL
)
21776 error (_("Input file '%s' is not readable.\n"), file_name
);
21781 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
21783 error (_("%s: Failed to read file's magic number\n"), file_name
);
21784 fclose (filedata
->handle
);
21789 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
21790 filedata
->is_separate
= false;
21792 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
21794 if (! process_archive (filedata
, false))
21797 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
21799 if ( ! process_archive (filedata
, true))
21804 if (do_archive_index
&& !check_all
)
21805 error (_("File %s is not an archive so its index cannot be displayed.\n"),
21808 rewind (filedata
->handle
);
21809 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
21811 if (! process_object (filedata
))
21815 fclose (filedata
->handle
);
21816 free (filedata
->section_headers
);
21817 free (filedata
->program_headers
);
21818 free (filedata
->string_table
);
21819 free (filedata
->dump
.dump_sects
);
21822 free (ba_cache
.strtab
);
21823 ba_cache
.strtab
= NULL
;
21824 free (ba_cache
.symtab
);
21825 ba_cache
.symtab
= NULL
;
21826 ba_cache
.filedata
= NULL
;
21831 #ifdef SUPPORT_DISASSEMBLY
21832 /* Needed by the i386 disassembler. For extra credit, someone could
21833 fix this so that we insert symbolic addresses here, esp for GOT/PLT
21837 print_address (unsigned int addr
, FILE * outfile
)
21839 fprintf (outfile
,"0x%8.8x", addr
);
21842 /* Needed by the i386 disassembler. */
21845 db_task_printsym (unsigned int addr
)
21847 print_address (addr
, stderr
);
21852 main (int argc
, char ** argv
)
21856 #ifdef HAVE_LC_MESSAGES
21857 setlocale (LC_MESSAGES
, "");
21859 setlocale (LC_CTYPE
, "");
21860 bindtextdomain (PACKAGE
, LOCALEDIR
);
21861 textdomain (PACKAGE
);
21863 expandargv (&argc
, &argv
);
21865 parse_args (& cmdline
, argc
, argv
);
21867 if (optind
< (argc
- 1))
21868 /* When displaying information for more than one file,
21869 prefix the information with the file name. */
21871 else if (optind
>= argc
)
21873 /* Ensure that the warning is always displayed. */
21876 warn (_("Nothing to do.\n"));
21881 while (optind
< argc
)
21882 if (! process_file (argv
[optind
++]))
21885 free (cmdline
.dump_sects
);
21887 free (dump_ctf_symtab_name
);
21888 free (dump_ctf_strtab_name
);
21889 free (dump_ctf_parent_name
);
21891 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;