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[lLiaprmfFsOoRtgUuTAc] or\n\
4657 --debug-dump=[rawline,decodedline,info,abbrev,pubnames,aranges,macro,frames,\n\
4658 frames-interp,str,str-offsets,loc,Ranges,pubtypes,gdb_index,\n\
4659 trace_info,trace_abbrev,trace_aranges,addr,cu_index]\n\
4660 Display the contents of DWARF debug sections\n\
4661 -wk,--debug-dump=links Display the contents of sections that link to separate debuginfo files\n\
4662 -P,--process-links Display the contents of non-debug sections in separate debuginfo files. (Implies -wK)\n"));
4663 #if DEFAULT_FOR_FOLLOW_LINKS
4664 fprintf (stream
, _("\
4665 -wK,--debug-dump=follow-links Follow links to separate debug info files (default)\n\
4666 -wN,--debug-dump=no-follow-links Do not follow links to separate debug info files\n\
4669 fprintf (stream
, _("\
4670 -wK,--debug-dump=follow-links Follow links to separate debug info files\n\
4671 -wN,--debug-dump=no-follow-links Do not follow links to separate debug info files (default)\n\
4674 fprintf (stream
, _("\
4675 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4676 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4678 #ifdef ENABLE_LIBCTF
4679 fprintf (stream
, _("\
4680 --ctf=<number|name> Display CTF info from section <number|name>\n\
4681 --ctf-parent=<number|name>\n\
4682 Use section <number|name> as the CTF parent\n\n\
4683 --ctf-symbols=<number|name>\n\
4684 Use section <number|name> as the CTF external symtab\n\n\
4685 --ctf-strings=<number|name>\n\
4686 Use section <number|name> as the CTF external strtab\n\n"));
4689 #ifdef SUPPORT_DISASSEMBLY
4690 fprintf (stream
, _("\
4691 -i --instruction-dump=<number|name>\n\
4692 Disassemble the contents of section <number|name>\n"));
4694 fprintf (stream
, _("\
4695 -I --histogram Display histogram of bucket list lengths\n\
4696 -W --wide Allow output width to exceed 80 characters\n\
4697 -T --silent-truncation If a symbol name is truncated, do not add a suffix [...]\n\
4698 @<file> Read options from <file>\n\
4699 -H --help Display this information\n\
4700 -v --version Display the version number of readelf\n"));
4702 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4703 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4705 exit (stream
== stdout
? 0 : 1);
4708 /* Record the fact that the user wants the contents of section number
4709 SECTION to be displayed using the method(s) encoded as flags bits
4710 in TYPE. Note, TYPE can be zero if we are creating the array for
4714 request_dump_bynumber (struct dump_data
*dumpdata
,
4715 unsigned int section
, dump_type type
)
4717 if (section
>= dumpdata
->num_dump_sects
)
4719 dump_type
* new_dump_sects
;
4721 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4722 sizeof (* new_dump_sects
));
4724 if (new_dump_sects
== NULL
)
4725 error (_("Out of memory allocating dump request table.\n"));
4728 if (dumpdata
->dump_sects
)
4730 /* Copy current flag settings. */
4731 memcpy (new_dump_sects
, dumpdata
->dump_sects
,
4732 dumpdata
->num_dump_sects
* sizeof (* new_dump_sects
));
4734 free (dumpdata
->dump_sects
);
4737 dumpdata
->dump_sects
= new_dump_sects
;
4738 dumpdata
->num_dump_sects
= section
+ 1;
4742 if (dumpdata
->dump_sects
)
4743 dumpdata
->dump_sects
[section
] |= type
;
4746 /* Request a dump by section name. */
4749 request_dump_byname (const char * section
, dump_type type
)
4751 struct dump_list_entry
* new_request
;
4753 new_request
= (struct dump_list_entry
*)
4754 malloc (sizeof (struct dump_list_entry
));
4756 error (_("Out of memory allocating dump request table.\n"));
4758 new_request
->name
= strdup (section
);
4759 if (!new_request
->name
)
4760 error (_("Out of memory allocating dump request table.\n"));
4762 new_request
->type
= type
;
4764 new_request
->next
= dump_sects_byname
;
4765 dump_sects_byname
= new_request
;
4769 request_dump (struct dump_data
*dumpdata
, dump_type type
)
4775 section
= strtoul (optarg
, & cp
, 0);
4777 if (! *cp
&& section
>= 0)
4778 request_dump_bynumber (dumpdata
, section
, type
);
4780 request_dump_byname (optarg
, type
);
4784 parse_args (struct dump_data
*dumpdata
, int argc
, char ** argv
)
4791 while ((c
= getopt_long
4792 (argc
, argv
, "ACDHILNPR:STVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4810 do_section_groups
= true;
4813 do_histogram
= true;
4819 do_section_groups
= true;
4824 do_section_details
= true;
4835 do_using_dynamic
= true;
4859 do_histogram
= true;
4865 do_archive_index
= true;
4871 process_links
= true;
4872 do_follow_links
= true;
4875 request_dump (dumpdata
, HEX_DUMP
);
4878 request_dump (dumpdata
, STRING_DUMP
);
4881 request_dump (dumpdata
, RELOC_DUMP
);
4884 decompress_dumps
= true;
4890 do_debugging
= true;
4891 dwarf_select_sections_all ();
4895 do_debugging
= false;
4896 dwarf_select_sections_by_letters (optarg
);
4899 case OPTION_DEBUG_DUMP
:
4902 do_debugging
= true;
4905 do_debugging
= false;
4906 dwarf_select_sections_by_names (optarg
);
4909 case OPTION_DWARF_DEPTH
:
4913 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4916 case OPTION_DWARF_START
:
4920 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4923 case OPTION_DWARF_CHECK
:
4926 case OPTION_CTF_DUMP
:
4928 request_dump (dumpdata
, CTF_DUMP
);
4930 case OPTION_CTF_SYMBOLS
:
4931 free (dump_ctf_symtab_name
);
4932 dump_ctf_symtab_name
= strdup (optarg
);
4934 case OPTION_CTF_STRINGS
:
4935 free (dump_ctf_strtab_name
);
4936 dump_ctf_strtab_name
= strdup (optarg
);
4938 case OPTION_CTF_PARENT
:
4939 free (dump_ctf_parent_name
);
4940 dump_ctf_parent_name
= strdup (optarg
);
4942 case OPTION_DYN_SYMS
:
4945 case OPTION_LTO_SYMS
:
4948 #ifdef SUPPORT_DISASSEMBLY
4950 request_dump (dumpdata
, DISASS_DUMP
);
4954 print_version (program_name
);
4963 do_not_show_symbol_truncation
= true;
4969 enum demangling_styles style
;
4971 style
= cplus_demangle_name_to_style (optarg
);
4972 if (style
== unknown_demangling
)
4973 error (_("unknown demangling style `%s'"), optarg
);
4975 cplus_demangle_set_style (style
);
4978 case OPTION_NO_DEMANGLING
:
4979 do_demangle
= false;
4981 case OPTION_RECURSE_LIMIT
:
4982 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
4984 case OPTION_NO_RECURSE_LIMIT
:
4985 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
4987 case OPTION_WITH_SYMBOL_VERSIONS
:
4988 /* Ignored for backward compatibility. */
4991 case OPTION_SYM_BASE
:
4995 sym_base
= strtoul (optarg
, NULL
, 0);
5012 /* xgettext:c-format */
5013 error (_("Invalid option '-%c'\n"), c
);
5020 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
5021 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
5022 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
5023 && !do_section_groups
&& !do_archive_index
5024 && !do_dyn_syms
&& !do_lto_syms
)
5029 do_dynamic
= do_syms
= do_reloc
= do_unwind
= do_sections
= true;
5030 do_segments
= do_header
= do_dump
= do_version
= true;
5031 do_histogram
= do_debugging
= do_arch
= do_notes
= true;
5032 do_section_groups
= do_archive_index
= do_dyn_syms
= true;
5041 get_elf_class (unsigned int elf_class
)
5043 static char buff
[32];
5047 case ELFCLASSNONE
: return _("none");
5048 case ELFCLASS32
: return "ELF32";
5049 case ELFCLASS64
: return "ELF64";
5051 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
5057 get_data_encoding (unsigned int encoding
)
5059 static char buff
[32];
5063 case ELFDATANONE
: return _("none");
5064 case ELFDATA2LSB
: return _("2's complement, little endian");
5065 case ELFDATA2MSB
: return _("2's complement, big endian");
5067 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
5072 /* Decode the data held in 'filedata->file_header'. */
5075 process_file_header (Filedata
* filedata
)
5077 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
5079 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
5080 || header
->e_ident
[EI_MAG1
] != ELFMAG1
5081 || header
->e_ident
[EI_MAG2
] != ELFMAG2
5082 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
5085 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
5089 if (! filedata
->is_separate
)
5090 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
5096 if (filedata
->is_separate
)
5097 printf (_("ELF Header in linked file '%s':\n"), filedata
->file_name
);
5099 printf (_("ELF Header:\n"));
5100 printf (_(" Magic: "));
5101 for (i
= 0; i
< EI_NIDENT
; i
++)
5102 printf ("%2.2x ", header
->e_ident
[i
]);
5104 printf (_(" Class: %s\n"),
5105 get_elf_class (header
->e_ident
[EI_CLASS
]));
5106 printf (_(" Data: %s\n"),
5107 get_data_encoding (header
->e_ident
[EI_DATA
]));
5108 printf (_(" Version: %d%s\n"),
5109 header
->e_ident
[EI_VERSION
],
5110 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
5112 : (header
->e_ident
[EI_VERSION
] != EV_NONE
5115 printf (_(" OS/ABI: %s\n"),
5116 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
5117 printf (_(" ABI Version: %d\n"),
5118 header
->e_ident
[EI_ABIVERSION
]);
5119 printf (_(" Type: %s\n"),
5120 get_file_type (header
->e_type
));
5121 printf (_(" Machine: %s\n"),
5122 get_machine_name (header
->e_machine
));
5123 printf (_(" Version: 0x%lx\n"),
5126 printf (_(" Entry point address: "));
5127 print_vma (header
->e_entry
, PREFIX_HEX
);
5128 printf (_("\n Start of program headers: "));
5129 print_vma (header
->e_phoff
, DEC
);
5130 printf (_(" (bytes into file)\n Start of section headers: "));
5131 print_vma (header
->e_shoff
, DEC
);
5132 printf (_(" (bytes into file)\n"));
5134 printf (_(" Flags: 0x%lx%s\n"),
5136 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
5137 printf (_(" Size of this header: %u (bytes)\n"),
5139 printf (_(" Size of program headers: %u (bytes)\n"),
5140 header
->e_phentsize
);
5141 printf (_(" Number of program headers: %u"),
5143 if (filedata
->section_headers
!= NULL
5144 && header
->e_phnum
== PN_XNUM
5145 && filedata
->section_headers
[0].sh_info
!= 0)
5147 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
5148 printf (" (%u)", header
->e_phnum
);
5150 putc ('\n', stdout
);
5151 printf (_(" Size of section headers: %u (bytes)\n"),
5152 header
->e_shentsize
);
5153 printf (_(" Number of section headers: %u"),
5155 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
5157 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5158 printf (" (%u)", header
->e_shnum
);
5160 putc ('\n', stdout
);
5161 printf (_(" Section header string table index: %u"),
5162 header
->e_shstrndx
);
5163 if (filedata
->section_headers
!= NULL
5164 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5166 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5167 printf (" (%u)", header
->e_shstrndx
);
5169 if (header
->e_shstrndx
!= SHN_UNDEF
5170 && header
->e_shstrndx
>= header
->e_shnum
)
5172 header
->e_shstrndx
= SHN_UNDEF
;
5173 printf (_(" <corrupt: out of range>"));
5175 putc ('\n', stdout
);
5178 if (filedata
->section_headers
!= NULL
)
5180 if (header
->e_phnum
== PN_XNUM
5181 && filedata
->section_headers
[0].sh_info
!= 0)
5182 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
5183 if (header
->e_shnum
== SHN_UNDEF
)
5184 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5185 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5186 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5187 if (header
->e_shstrndx
>= header
->e_shnum
)
5188 header
->e_shstrndx
= SHN_UNDEF
;
5189 free (filedata
->section_headers
);
5190 filedata
->section_headers
= NULL
;
5196 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5197 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
5200 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5202 Elf32_External_Phdr
* phdrs
;
5203 Elf32_External_Phdr
* external
;
5204 Elf_Internal_Phdr
* internal
;
5206 unsigned int size
= filedata
->file_header
.e_phentsize
;
5207 unsigned int num
= filedata
->file_header
.e_phnum
;
5209 /* PR binutils/17531: Cope with unexpected section header sizes. */
5210 if (size
== 0 || num
== 0)
5212 if (size
< sizeof * phdrs
)
5214 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5217 if (size
> sizeof * phdrs
)
5218 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5220 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5221 size
, num
, _("program headers"));
5225 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5226 i
< filedata
->file_header
.e_phnum
;
5227 i
++, internal
++, external
++)
5229 internal
->p_type
= BYTE_GET (external
->p_type
);
5230 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5231 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5232 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5233 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5234 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5235 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5236 internal
->p_align
= BYTE_GET (external
->p_align
);
5243 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5244 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5247 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5249 Elf64_External_Phdr
* phdrs
;
5250 Elf64_External_Phdr
* external
;
5251 Elf_Internal_Phdr
* internal
;
5253 unsigned int size
= filedata
->file_header
.e_phentsize
;
5254 unsigned int num
= filedata
->file_header
.e_phnum
;
5256 /* PR binutils/17531: Cope with unexpected section header sizes. */
5257 if (size
== 0 || num
== 0)
5259 if (size
< sizeof * phdrs
)
5261 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5264 if (size
> sizeof * phdrs
)
5265 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5267 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5268 size
, num
, _("program headers"));
5272 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5273 i
< filedata
->file_header
.e_phnum
;
5274 i
++, internal
++, external
++)
5276 internal
->p_type
= BYTE_GET (external
->p_type
);
5277 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5278 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5279 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5280 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5281 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5282 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5283 internal
->p_align
= BYTE_GET (external
->p_align
);
5290 /* Returns TRUE if the program headers were read into `program_headers'. */
5293 get_program_headers (Filedata
* filedata
)
5295 Elf_Internal_Phdr
* phdrs
;
5297 /* Check cache of prior read. */
5298 if (filedata
->program_headers
!= NULL
)
5301 /* Be kind to memory checkers by looking for
5302 e_phnum values which we know must be invalid. */
5303 if (filedata
->file_header
.e_phnum
5304 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5305 >= filedata
->file_size
)
5307 error (_("Too many program headers - %#x - the file is not that big\n"),
5308 filedata
->file_header
.e_phnum
);
5312 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5313 sizeof (Elf_Internal_Phdr
));
5316 error (_("Out of memory reading %u program headers\n"),
5317 filedata
->file_header
.e_phnum
);
5322 ? get_32bit_program_headers (filedata
, phdrs
)
5323 : get_64bit_program_headers (filedata
, phdrs
))
5325 filedata
->program_headers
= phdrs
;
5333 /* Returns TRUE if the program headers were loaded. */
5336 process_program_headers (Filedata
* filedata
)
5338 Elf_Internal_Phdr
* segment
;
5340 Elf_Internal_Phdr
* previous_load
= NULL
;
5342 filedata
->dynamic_addr
= 0;
5343 filedata
->dynamic_size
= 0;
5345 if (filedata
->file_header
.e_phnum
== 0)
5347 /* PR binutils/12467. */
5348 if (filedata
->file_header
.e_phoff
!= 0)
5350 warn (_("possibly corrupt ELF header - it has a non-zero program"
5351 " header offset, but no program headers\n"));
5354 else if (do_segments
)
5356 if (filedata
->is_separate
)
5357 printf (_("\nThere are no program headers in linked file '%s'.\n"),
5358 filedata
->file_name
);
5360 printf (_("\nThere are no program headers in this file.\n"));
5365 if (do_segments
&& !do_header
)
5367 if (filedata
->is_separate
)
5368 printf ("\nIn linked file '%s' the ELF file type is %s\n",
5369 filedata
->file_name
,
5370 get_file_type (filedata
->file_header
.e_type
));
5372 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5373 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5374 printf (ngettext ("There is %d program header, starting at offset %s\n",
5375 "There are %d program headers, starting at offset %s\n",
5376 filedata
->file_header
.e_phnum
),
5377 filedata
->file_header
.e_phnum
,
5378 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5381 if (! get_program_headers (filedata
))
5386 if (filedata
->file_header
.e_phnum
> 1)
5387 printf (_("\nProgram Headers:\n"));
5389 printf (_("\nProgram Headers:\n"));
5393 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5396 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5400 (_(" Type Offset VirtAddr PhysAddr\n"));
5402 (_(" FileSiz MemSiz Flags Align\n"));
5406 for (i
= 0, segment
= filedata
->program_headers
;
5407 i
< filedata
->file_header
.e_phnum
;
5412 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5416 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5417 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5418 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5419 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5420 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5422 (segment
->p_flags
& PF_R
? 'R' : ' '),
5423 (segment
->p_flags
& PF_W
? 'W' : ' '),
5424 (segment
->p_flags
& PF_X
? 'E' : ' '));
5425 printf ("%#lx", (unsigned long) segment
->p_align
);
5429 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5430 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5433 print_vma (segment
->p_offset
, FULL_HEX
);
5437 print_vma (segment
->p_vaddr
, FULL_HEX
);
5439 print_vma (segment
->p_paddr
, FULL_HEX
);
5442 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5443 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5446 print_vma (segment
->p_filesz
, FULL_HEX
);
5450 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5451 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5454 print_vma (segment
->p_memsz
, FULL_HEX
);
5458 (segment
->p_flags
& PF_R
? 'R' : ' '),
5459 (segment
->p_flags
& PF_W
? 'W' : ' '),
5460 (segment
->p_flags
& PF_X
? 'E' : ' '));
5462 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5463 printf ("%#lx", (unsigned long) segment
->p_align
);
5466 print_vma (segment
->p_align
, PREFIX_HEX
);
5471 print_vma (segment
->p_offset
, FULL_HEX
);
5473 print_vma (segment
->p_vaddr
, FULL_HEX
);
5475 print_vma (segment
->p_paddr
, FULL_HEX
);
5477 print_vma (segment
->p_filesz
, FULL_HEX
);
5479 print_vma (segment
->p_memsz
, FULL_HEX
);
5481 (segment
->p_flags
& PF_R
? 'R' : ' '),
5482 (segment
->p_flags
& PF_W
? 'W' : ' '),
5483 (segment
->p_flags
& PF_X
? 'E' : ' '));
5484 print_vma (segment
->p_align
, PREFIX_HEX
);
5487 putc ('\n', stdout
);
5490 switch (segment
->p_type
)
5493 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5494 required by the ELF standard, several programs, including the Linux
5495 kernel, make use of non-ordered segments. */
5497 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5498 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5500 if (segment
->p_memsz
< segment
->p_filesz
)
5501 error (_("the segment's file size is larger than its memory size\n"));
5502 previous_load
= segment
;
5506 /* PR 20815 - Verify that the program header is loaded into memory. */
5507 if (i
> 0 && previous_load
!= NULL
)
5508 error (_("the PHDR segment must occur before any LOAD segment\n"));
5509 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5513 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5515 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
5516 if (load
->p_type
== PT_LOAD
5517 && load
->p_offset
<= segment
->p_offset
5518 && (load
->p_offset
+ load
->p_filesz
5519 >= segment
->p_offset
+ segment
->p_filesz
)
5520 && load
->p_vaddr
<= segment
->p_vaddr
5521 && (load
->p_vaddr
+ load
->p_filesz
5522 >= segment
->p_vaddr
+ segment
->p_filesz
))
5525 if (j
== filedata
->file_header
.e_phnum
)
5526 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5531 if (filedata
->dynamic_addr
)
5532 error (_("more than one dynamic segment\n"));
5534 /* By default, assume that the .dynamic section is the first
5535 section in the DYNAMIC segment. */
5536 filedata
->dynamic_addr
= segment
->p_offset
;
5537 filedata
->dynamic_size
= segment
->p_filesz
;
5539 /* Try to locate the .dynamic section. If there is
5540 a section header table, we can easily locate it. */
5541 if (filedata
->section_headers
!= NULL
)
5543 Elf_Internal_Shdr
* sec
;
5545 sec
= find_section (filedata
, ".dynamic");
5546 if (sec
== NULL
|| sec
->sh_size
== 0)
5548 /* A corresponding .dynamic section is expected, but on
5549 IA-64/OpenVMS it is OK for it to be missing. */
5550 if (!is_ia64_vms (filedata
))
5551 error (_("no .dynamic section in the dynamic segment\n"));
5555 if (sec
->sh_type
== SHT_NOBITS
)
5557 filedata
->dynamic_size
= 0;
5561 filedata
->dynamic_addr
= sec
->sh_offset
;
5562 filedata
->dynamic_size
= sec
->sh_size
;
5564 /* The PT_DYNAMIC segment, which is used by the run-time
5565 loader, should exactly match the .dynamic section. */
5567 && (filedata
->dynamic_addr
!= segment
->p_offset
5568 || filedata
->dynamic_size
!= segment
->p_filesz
))
5570 the .dynamic section is not the same as the dynamic segment\n"));
5573 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5574 segment. Check this after matching against the section headers
5575 so we don't warn on debuginfo file (which have NOBITS .dynamic
5577 if (filedata
->dynamic_addr
> filedata
->file_size
5578 || (filedata
->dynamic_size
5579 > filedata
->file_size
- filedata
->dynamic_addr
))
5581 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5582 filedata
->dynamic_addr
= filedata
->dynamic_size
= 0;
5587 if (segment
->p_offset
>= filedata
->file_size
5588 || segment
->p_filesz
> filedata
->file_size
- segment
->p_offset
5589 || segment
->p_filesz
- 1 >= (size_t) -2
5590 || fseek (filedata
->handle
,
5591 filedata
->archive_file_offset
+ (long) segment
->p_offset
,
5593 error (_("Unable to find program interpreter name\n"));
5596 size_t len
= segment
->p_filesz
;
5597 free (filedata
->program_interpreter
);
5598 filedata
->program_interpreter
= xmalloc (len
+ 1);
5599 len
= fread (filedata
->program_interpreter
, 1, len
,
5601 filedata
->program_interpreter
[len
] = 0;
5604 printf (_(" [Requesting program interpreter: %s]\n"),
5605 filedata
->program_interpreter
);
5612 && filedata
->section_headers
!= NULL
5613 && filedata
->string_table
!= NULL
)
5615 printf (_("\n Section to Segment mapping:\n"));
5616 printf (_(" Segment Sections...\n"));
5618 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5621 Elf_Internal_Shdr
* section
;
5623 segment
= filedata
->program_headers
+ i
;
5624 section
= filedata
->section_headers
+ 1;
5626 printf (" %2.2d ", i
);
5628 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5630 if (!ELF_TBSS_SPECIAL (section
, segment
)
5631 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5632 printf ("%s ", printable_section_name (filedata
, section
));
5643 /* Find the file offset corresponding to VMA by using the program headers. */
5646 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5648 Elf_Internal_Phdr
* seg
;
5650 if (! get_program_headers (filedata
))
5652 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5656 for (seg
= filedata
->program_headers
;
5657 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5660 if (seg
->p_type
!= PT_LOAD
)
5663 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5664 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5665 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5668 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5669 (unsigned long) vma
);
5674 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5675 If PROBE is true, this is just a probe and we do not generate any error
5676 messages if the load fails. */
5679 get_32bit_section_headers (Filedata
* filedata
, bool probe
)
5681 Elf32_External_Shdr
* shdrs
;
5682 Elf_Internal_Shdr
* internal
;
5684 unsigned int size
= filedata
->file_header
.e_shentsize
;
5685 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5687 /* PR binutils/17531: Cope with unexpected section header sizes. */
5688 if (size
== 0 || num
== 0)
5690 if (size
< sizeof * shdrs
)
5693 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5696 if (!probe
&& size
> sizeof * shdrs
)
5697 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5699 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5701 probe
? NULL
: _("section headers"));
5705 free (filedata
->section_headers
);
5706 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5707 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5708 if (filedata
->section_headers
== NULL
)
5711 error (_("Out of memory reading %u section headers\n"), num
);
5716 for (i
= 0, internal
= filedata
->section_headers
;
5720 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5721 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5722 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5723 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5724 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5725 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5726 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5727 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5728 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5729 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5730 if (!probe
&& internal
->sh_link
> num
)
5731 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5732 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5733 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5740 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5743 get_64bit_section_headers (Filedata
* filedata
, bool probe
)
5745 Elf64_External_Shdr
* shdrs
;
5746 Elf_Internal_Shdr
* internal
;
5748 unsigned int size
= filedata
->file_header
.e_shentsize
;
5749 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5751 /* PR binutils/17531: Cope with unexpected section header sizes. */
5752 if (size
== 0 || num
== 0)
5755 if (size
< sizeof * shdrs
)
5758 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5762 if (! probe
&& size
> sizeof * shdrs
)
5763 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5765 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5766 filedata
->file_header
.e_shoff
,
5768 probe
? NULL
: _("section headers"));
5772 free (filedata
->section_headers
);
5773 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5774 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5775 if (filedata
->section_headers
== NULL
)
5778 error (_("Out of memory reading %u section headers\n"), num
);
5783 for (i
= 0, internal
= filedata
->section_headers
;
5787 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5788 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5789 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5790 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5791 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5792 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5793 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5794 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5795 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5796 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5797 if (!probe
&& internal
->sh_link
> num
)
5798 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5799 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5800 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5807 static Elf_Internal_Sym
*
5808 get_32bit_elf_symbols (Filedata
* filedata
,
5809 Elf_Internal_Shdr
* section
,
5810 unsigned long * num_syms_return
)
5812 unsigned long number
= 0;
5813 Elf32_External_Sym
* esyms
= NULL
;
5814 Elf_External_Sym_Shndx
* shndx
= NULL
;
5815 Elf_Internal_Sym
* isyms
= NULL
;
5816 Elf_Internal_Sym
* psym
;
5818 elf_section_list
* entry
;
5820 if (section
->sh_size
== 0)
5822 if (num_syms_return
!= NULL
)
5823 * num_syms_return
= 0;
5827 /* Run some sanity checks first. */
5828 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5830 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5831 printable_section_name (filedata
, section
),
5832 (unsigned long) section
->sh_entsize
);
5836 if (section
->sh_size
> filedata
->file_size
)
5838 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5839 printable_section_name (filedata
, section
),
5840 (unsigned long) section
->sh_size
);
5844 number
= section
->sh_size
/ section
->sh_entsize
;
5846 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5848 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5849 (unsigned long) section
->sh_size
,
5850 printable_section_name (filedata
, section
),
5851 (unsigned long) section
->sh_entsize
);
5855 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5856 section
->sh_size
, _("symbols"));
5861 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5863 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5868 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5872 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5873 entry
->hdr
->sh_offset
,
5874 1, entry
->hdr
->sh_size
,
5875 _("symbol table section indices"));
5879 /* PR17531: file: heap-buffer-overflow */
5880 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5882 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5883 printable_section_name (filedata
, entry
->hdr
),
5884 (unsigned long) entry
->hdr
->sh_size
,
5885 (unsigned long) section
->sh_size
);
5890 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5894 error (_("Out of memory reading %lu symbols\n"),
5895 (unsigned long) number
);
5899 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5901 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5902 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5903 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5904 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5905 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5907 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5908 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5909 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5910 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5911 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5918 if (num_syms_return
!= NULL
)
5919 * num_syms_return
= isyms
== NULL
? 0 : number
;
5924 static Elf_Internal_Sym
*
5925 get_64bit_elf_symbols (Filedata
* filedata
,
5926 Elf_Internal_Shdr
* section
,
5927 unsigned long * num_syms_return
)
5929 unsigned long number
= 0;
5930 Elf64_External_Sym
* esyms
= NULL
;
5931 Elf_External_Sym_Shndx
* shndx
= NULL
;
5932 Elf_Internal_Sym
* isyms
= NULL
;
5933 Elf_Internal_Sym
* psym
;
5935 elf_section_list
* entry
;
5937 if (section
->sh_size
== 0)
5939 if (num_syms_return
!= NULL
)
5940 * num_syms_return
= 0;
5944 /* Run some sanity checks first. */
5945 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5947 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5948 printable_section_name (filedata
, section
),
5949 (unsigned long) section
->sh_entsize
);
5953 if (section
->sh_size
> filedata
->file_size
)
5955 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5956 printable_section_name (filedata
, section
),
5957 (unsigned long) section
->sh_size
);
5961 number
= section
->sh_size
/ section
->sh_entsize
;
5963 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5965 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5966 (unsigned long) section
->sh_size
,
5967 printable_section_name (filedata
, section
),
5968 (unsigned long) section
->sh_entsize
);
5972 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5973 section
->sh_size
, _("symbols"));
5978 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5980 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5985 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5989 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5990 entry
->hdr
->sh_offset
,
5991 1, entry
->hdr
->sh_size
,
5992 _("symbol table section indices"));
5996 /* PR17531: file: heap-buffer-overflow */
5997 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5999 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
6000 printable_section_name (filedata
, entry
->hdr
),
6001 (unsigned long) entry
->hdr
->sh_size
,
6002 (unsigned long) section
->sh_size
);
6007 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
6011 error (_("Out of memory reading %lu symbols\n"),
6012 (unsigned long) number
);
6016 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
6018 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
6019 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
6020 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
6021 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
6023 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
6025 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
6026 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
6027 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
6029 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
6030 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
6037 if (num_syms_return
!= NULL
)
6038 * num_syms_return
= isyms
== NULL
? 0 : number
;
6044 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
6046 static char buff
[1024];
6048 unsigned int field_size
= is_32bit_elf
? 8 : 16;
6050 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
6051 bfd_vma os_flags
= 0;
6052 bfd_vma proc_flags
= 0;
6053 bfd_vma unknown_flags
= 0;
6061 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
6062 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
6063 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
6064 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
6065 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
6066 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
6067 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
6068 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
6069 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
6070 /* 9 */ { STRING_COMMA_LEN ("TLS") },
6071 /* IA-64 specific. */
6072 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
6073 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
6074 /* IA-64 OpenVMS specific. */
6075 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
6076 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
6077 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
6078 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
6079 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
6080 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
6082 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
6083 /* SPARC specific. */
6084 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
6085 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
6087 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
6088 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
6089 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
6091 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
6093 /* 25 */ { STRING_COMMA_LEN ("VLE") },
6095 /* 26 */ { STRING_COMMA_LEN ("GNU_RETAIN") },
6098 if (do_section_details
)
6100 sprintf (buff
, "[%*.*lx]: ",
6101 field_size
, field_size
, (unsigned long) sh_flags
);
6102 p
+= field_size
+ 4;
6109 flag
= sh_flags
& - sh_flags
;
6112 if (do_section_details
)
6116 case SHF_WRITE
: sindex
= 0; break;
6117 case SHF_ALLOC
: sindex
= 1; break;
6118 case SHF_EXECINSTR
: sindex
= 2; break;
6119 case SHF_MERGE
: sindex
= 3; break;
6120 case SHF_STRINGS
: sindex
= 4; break;
6121 case SHF_INFO_LINK
: sindex
= 5; break;
6122 case SHF_LINK_ORDER
: sindex
= 6; break;
6123 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
6124 case SHF_GROUP
: sindex
= 8; break;
6125 case SHF_TLS
: sindex
= 9; break;
6126 case SHF_EXCLUDE
: sindex
= 18; break;
6127 case SHF_COMPRESSED
: sindex
= 20; break;
6131 switch (filedata
->file_header
.e_machine
)
6134 if (flag
== SHF_IA_64_SHORT
)
6136 else if (flag
== SHF_IA_64_NORECOV
)
6139 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
6142 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
6143 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
6144 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
6145 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
6146 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
6147 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
6158 case EM_OLD_SPARCV9
:
6159 case EM_SPARC32PLUS
:
6162 if (flag
== SHF_ORDERED
)
6169 case SHF_ENTRYSECT
: sindex
= 21; break;
6170 case SHF_ARM_PURECODE
: sindex
= 22; break;
6171 case SHF_COMDEF
: sindex
= 23; break;
6176 if (flag
== SHF_PPC_VLE
)
6183 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
6186 case ELFOSABI_FREEBSD
:
6187 if (flag
== SHF_GNU_RETAIN
)
6191 if (flag
== SHF_GNU_MBIND
)
6192 /* We should not recognize SHF_GNU_MBIND for
6193 ELFOSABI_NONE, but binutils as of 2019-07-23 did
6194 not set the EI_OSABI header byte. */
6205 if (p
!= buff
+ field_size
+ 4)
6207 if (size
< (10 + 2))
6209 warn (_("Internal error: not enough buffer room for section flag info"));
6210 return _("<unknown>");
6217 size
-= flags
[sindex
].len
;
6218 p
= stpcpy (p
, flags
[sindex
].str
);
6220 else if (flag
& SHF_MASKOS
)
6222 else if (flag
& SHF_MASKPROC
)
6225 unknown_flags
|= flag
;
6231 case SHF_WRITE
: *p
= 'W'; break;
6232 case SHF_ALLOC
: *p
= 'A'; break;
6233 case SHF_EXECINSTR
: *p
= 'X'; break;
6234 case SHF_MERGE
: *p
= 'M'; break;
6235 case SHF_STRINGS
: *p
= 'S'; break;
6236 case SHF_INFO_LINK
: *p
= 'I'; break;
6237 case SHF_LINK_ORDER
: *p
= 'L'; break;
6238 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
6239 case SHF_GROUP
: *p
= 'G'; break;
6240 case SHF_TLS
: *p
= 'T'; break;
6241 case SHF_EXCLUDE
: *p
= 'E'; break;
6242 case SHF_COMPRESSED
: *p
= 'C'; break;
6245 if ((filedata
->file_header
.e_machine
== EM_X86_64
6246 || filedata
->file_header
.e_machine
== EM_L1OM
6247 || filedata
->file_header
.e_machine
== EM_K1OM
)
6248 && flag
== SHF_X86_64_LARGE
)
6250 else if (filedata
->file_header
.e_machine
== EM_ARM
6251 && flag
== SHF_ARM_PURECODE
)
6253 else if (filedata
->file_header
.e_machine
== EM_PPC
6254 && flag
== SHF_PPC_VLE
)
6256 else if (flag
& SHF_MASKOS
)
6258 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
6261 case ELFOSABI_FREEBSD
:
6262 if (flag
== SHF_GNU_RETAIN
)
6269 if (flag
== SHF_GNU_MBIND
)
6271 /* We should not recognize SHF_GNU_MBIND for
6272 ELFOSABI_NONE, but binutils as of 2019-07-23 did
6273 not set the EI_OSABI header byte. */
6280 sh_flags
&= ~SHF_MASKOS
;
6284 else if (flag
& SHF_MASKPROC
)
6287 sh_flags
&= ~ SHF_MASKPROC
;
6297 if (do_section_details
)
6301 size
-= 5 + field_size
;
6302 if (p
!= buff
+ field_size
+ 4)
6306 warn (_("Internal error: not enough buffer room for section flag info"));
6307 return _("<unknown>");
6313 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6314 (unsigned long) os_flags
);
6315 p
+= 5 + field_size
;
6319 size
-= 7 + field_size
;
6320 if (p
!= buff
+ field_size
+ 4)
6324 warn (_("Internal error: not enough buffer room for section flag info"));
6325 return _("<unknown>");
6331 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6332 (unsigned long) proc_flags
);
6333 p
+= 7 + field_size
;
6337 size
-= 10 + field_size
;
6338 if (p
!= buff
+ field_size
+ 4)
6342 warn (_("Internal error: not enough buffer room for section flag info"));
6343 return _("<unknown>");
6349 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6350 (unsigned long) unknown_flags
);
6351 p
+= 10 + field_size
;
6359 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
6360 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6364 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6366 if (size
< sizeof (* echdr
))
6368 error (_("Compressed section is too small even for a compression header\n"));
6372 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6373 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6374 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6375 return sizeof (*echdr
);
6379 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6381 if (size
< sizeof (* echdr
))
6383 error (_("Compressed section is too small even for a compression header\n"));
6387 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6388 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6389 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6390 return sizeof (*echdr
);
6395 process_section_headers (Filedata
* filedata
)
6397 Elf_Internal_Shdr
* section
;
6400 free (filedata
->section_headers
);
6401 filedata
->section_headers
= NULL
;
6402 free (filedata
->dynamic_symbols
);
6403 filedata
->dynamic_symbols
= NULL
;
6404 filedata
->num_dynamic_syms
= 0;
6405 free (filedata
->dynamic_strings
);
6406 filedata
->dynamic_strings
= NULL
;
6407 filedata
->dynamic_strings_length
= 0;
6408 free (filedata
->dynamic_syminfo
);
6409 filedata
->dynamic_syminfo
= NULL
;
6410 while (filedata
->symtab_shndx_list
!= NULL
)
6412 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
6413 free (filedata
->symtab_shndx_list
);
6414 filedata
->symtab_shndx_list
= next
;
6417 if (filedata
->file_header
.e_shnum
== 0)
6419 /* PR binutils/12467. */
6420 if (filedata
->file_header
.e_shoff
!= 0)
6422 warn (_("possibly corrupt ELF file header - it has a non-zero"
6423 " section header offset, but no section headers\n"));
6426 else if (do_sections
)
6427 printf (_("\nThere are no sections in this file.\n"));
6432 if (do_sections
&& !do_header
)
6434 if (filedata
->is_separate
&& process_links
)
6435 printf (_("In linked file '%s': "), filedata
->file_name
);
6436 if (! filedata
->is_separate
|| process_links
)
6437 printf (ngettext ("There is %d section header, "
6438 "starting at offset 0x%lx:\n",
6439 "There are %d section headers, "
6440 "starting at offset 0x%lx:\n",
6441 filedata
->file_header
.e_shnum
),
6442 filedata
->file_header
.e_shnum
,
6443 (unsigned long) filedata
->file_header
.e_shoff
);
6448 if (! get_32bit_section_headers (filedata
, false))
6453 if (! get_64bit_section_headers (filedata
, false))
6457 /* Read in the string table, so that we have names to display. */
6458 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6459 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6461 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6463 if (section
->sh_size
!= 0)
6465 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6466 1, section
->sh_size
,
6469 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6473 /* Scan the sections for the dynamic symbol table
6474 and dynamic string table and debug sections. */
6475 eh_addr_size
= is_32bit_elf
? 4 : 8;
6476 switch (filedata
->file_header
.e_machine
)
6479 case EM_MIPS_RS3_LE
:
6480 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6481 FDE addresses. However, the ABI also has a semi-official ILP32
6482 variant for which the normal FDE address size rules apply.
6484 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6485 section, where XX is the size of longs in bits. Unfortunately,
6486 earlier compilers provided no way of distinguishing ILP32 objects
6487 from LP64 objects, so if there's any doubt, we should assume that
6488 the official LP64 form is being used. */
6489 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6490 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6496 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6498 case E_H8_MACH_H8300
:
6499 case E_H8_MACH_H8300HN
:
6500 case E_H8_MACH_H8300SN
:
6501 case E_H8_MACH_H8300SXN
:
6504 case E_H8_MACH_H8300H
:
6505 case E_H8_MACH_H8300S
:
6506 case E_H8_MACH_H8300SX
:
6514 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6516 case EF_M32C_CPU_M16C
:
6523 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6526 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6527 if (section->sh_entsize != expected_entsize) \
6530 sprintf_vma (buf, section->sh_entsize); \
6531 /* Note: coded this way so that there is a single string for \
6533 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6534 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6535 (unsigned) expected_entsize); \
6536 section->sh_entsize = expected_entsize; \
6541 #define CHECK_ENTSIZE(section, i, type) \
6542 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6543 sizeof (Elf64_External_##type))
6545 for (i
= 0, section
= filedata
->section_headers
;
6546 i
< filedata
->file_header
.e_shnum
;
6549 char * name
= SECTION_NAME_PRINT (section
);
6551 /* Run some sanity checks on the headers and
6552 possibly fill in some file data as well. */
6553 switch (section
->sh_type
)
6556 if (filedata
->dynamic_symbols
!= NULL
)
6558 error (_("File contains multiple dynamic symbol tables\n"));
6562 CHECK_ENTSIZE (section
, i
, Sym
);
6563 filedata
->dynamic_symbols
6564 = GET_ELF_SYMBOLS (filedata
, section
, &filedata
->num_dynamic_syms
);
6565 filedata
->dynamic_symtab_section
= section
;
6569 if (streq (name
, ".dynstr"))
6571 if (filedata
->dynamic_strings
!= NULL
)
6573 error (_("File contains multiple dynamic string tables\n"));
6577 filedata
->dynamic_strings
6578 = (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6579 1, section
->sh_size
, _("dynamic strings"));
6580 filedata
->dynamic_strings_length
6581 = filedata
->dynamic_strings
== NULL
? 0 : section
->sh_size
;
6582 filedata
->dynamic_strtab_section
= section
;
6586 case SHT_SYMTAB_SHNDX
:
6588 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6590 entry
->hdr
= section
;
6591 entry
->next
= filedata
->symtab_shndx_list
;
6592 filedata
->symtab_shndx_list
= entry
;
6597 CHECK_ENTSIZE (section
, i
, Sym
);
6601 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6605 CHECK_ENTSIZE (section
, i
, Rel
);
6606 if (do_checks
&& section
->sh_size
== 0)
6607 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6611 CHECK_ENTSIZE (section
, i
, Rela
);
6612 if (do_checks
&& section
->sh_size
== 0)
6613 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6618 /* Having a zero sized section is not illegal according to the
6619 ELF standard, but it might be an indication that something
6620 is wrong. So issue a warning if we are running in lint mode. */
6621 if (do_checks
&& section
->sh_size
== 0)
6622 warn (_("Section '%s': has a size of zero - is this intended ?\n"), name
);
6629 if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6630 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6631 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6632 || do_debug_str
|| do_debug_str_offsets
|| do_debug_loc
6634 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6635 && (startswith (name
, ".debug_")
6636 || startswith (name
, ".zdebug_")))
6639 name
+= sizeof (".zdebug_") - 1;
6641 name
+= sizeof (".debug_") - 1;
6644 || (do_debug_info
&& startswith (name
, "info"))
6645 || (do_debug_info
&& startswith (name
, "types"))
6646 || (do_debug_abbrevs
&& startswith (name
, "abbrev"))
6647 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6648 || (do_debug_lines
&& startswith (name
, "line."))
6649 || (do_debug_pubnames
&& startswith (name
, "pubnames"))
6650 || (do_debug_pubtypes
&& startswith (name
, "pubtypes"))
6651 || (do_debug_pubnames
&& startswith (name
, "gnu_pubnames"))
6652 || (do_debug_pubtypes
&& startswith (name
, "gnu_pubtypes"))
6653 || (do_debug_aranges
&& startswith (name
, "aranges"))
6654 || (do_debug_ranges
&& startswith (name
, "ranges"))
6655 || (do_debug_ranges
&& startswith (name
, "rnglists"))
6656 || (do_debug_frames
&& startswith (name
, "frame"))
6657 || (do_debug_macinfo
&& startswith (name
, "macinfo"))
6658 || (do_debug_macinfo
&& startswith (name
, "macro"))
6659 || (do_debug_str
&& startswith (name
, "str"))
6660 || (do_debug_links
&& startswith (name
, "sup"))
6661 || (do_debug_str_offsets
&& startswith (name
, "str_offsets"))
6662 || (do_debug_loc
&& startswith (name
, "loc"))
6663 || (do_debug_loc
&& startswith (name
, "loclists"))
6664 || (do_debug_addr
&& startswith (name
, "addr"))
6665 || (do_debug_cu_index
&& startswith (name
, "cu_index"))
6666 || (do_debug_cu_index
&& startswith (name
, "tu_index"))
6668 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6670 /* Linkonce section to be combined with .debug_info at link time. */
6671 else if ((do_debugging
|| do_debug_info
)
6672 && startswith (name
, ".gnu.linkonce.wi."))
6673 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6674 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6675 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6676 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6677 || streq (name
, ".debug_names")))
6678 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6679 /* Trace sections for Itanium VMS. */
6680 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6681 || do_trace_aranges
)
6682 && startswith (name
, ".trace_"))
6684 name
+= sizeof (".trace_") - 1;
6687 || (do_trace_info
&& streq (name
, "info"))
6688 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6689 || (do_trace_aranges
&& streq (name
, "aranges"))
6691 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6693 else if ((do_debugging
|| do_debug_links
)
6694 && (startswith (name
, ".gnu_debuglink")
6695 || startswith (name
, ".gnu_debugaltlink")))
6696 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6702 if (filedata
->is_separate
&& ! process_links
)
6705 if (filedata
->is_separate
)
6706 printf (_("\nSection Headers in linked file '%s':\n"), filedata
->file_name
);
6707 else if (filedata
->file_header
.e_shnum
> 1)
6708 printf (_("\nSection Headers:\n"));
6710 printf (_("\nSection Header:\n"));
6714 if (do_section_details
)
6716 printf (_(" [Nr] Name\n"));
6717 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6721 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6725 if (do_section_details
)
6727 printf (_(" [Nr] Name\n"));
6728 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6732 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6736 if (do_section_details
)
6738 printf (_(" [Nr] Name\n"));
6739 printf (_(" Type Address Offset Link\n"));
6740 printf (_(" Size EntSize Info Align\n"));
6744 printf (_(" [Nr] Name Type Address Offset\n"));
6745 printf (_(" Size EntSize Flags Link Info Align\n"));
6749 if (do_section_details
)
6750 printf (_(" Flags\n"));
6752 for (i
= 0, section
= filedata
->section_headers
;
6753 i
< filedata
->file_header
.e_shnum
;
6756 /* Run some sanity checks on the section header. */
6758 /* Check the sh_link field. */
6759 switch (section
->sh_type
)
6763 if (section
->sh_link
== 0
6764 && (filedata
->file_header
.e_type
== ET_EXEC
6765 || filedata
->file_header
.e_type
== ET_DYN
))
6766 /* A dynamic relocation section where all entries use a
6767 zero symbol index need not specify a symtab section. */
6770 case SHT_SYMTAB_SHNDX
:
6774 case SHT_GNU_versym
:
6775 if (section
->sh_link
== 0
6776 || section
->sh_link
>= filedata
->file_header
.e_shnum
6777 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6778 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6779 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6780 i
, section
->sh_link
);
6786 case SHT_GNU_verneed
:
6787 case SHT_GNU_verdef
:
6788 case SHT_GNU_LIBLIST
:
6789 if (section
->sh_link
== 0
6790 || section
->sh_link
>= filedata
->file_header
.e_shnum
6791 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6792 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6793 i
, section
->sh_link
);
6796 case SHT_INIT_ARRAY
:
6797 case SHT_FINI_ARRAY
:
6798 case SHT_PREINIT_ARRAY
:
6799 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6800 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6801 i
, section
->sh_link
);
6805 /* FIXME: Add support for target specific section types. */
6806 #if 0 /* Currently we do not check other section types as there are too
6807 many special cases. Stab sections for example have a type
6808 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6810 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6811 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6812 i
, section
->sh_link
);
6817 /* Check the sh_info field. */
6818 switch (section
->sh_type
)
6822 if (section
->sh_info
== 0
6823 && (filedata
->file_header
.e_type
== ET_EXEC
6824 || filedata
->file_header
.e_type
== ET_DYN
))
6825 /* Dynamic relocations apply to segments, so they do not
6826 need to specify the section they relocate. */
6828 if (section
->sh_info
== 0
6829 || section
->sh_info
>= filedata
->file_header
.e_shnum
6830 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6831 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6832 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6833 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6834 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6835 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6836 /* FIXME: Are other section types valid ? */
6837 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6838 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6839 i
, section
->sh_info
);
6844 case SHT_SYMTAB_SHNDX
:
6845 case SHT_INIT_ARRAY
:
6846 case SHT_FINI_ARRAY
:
6847 case SHT_PREINIT_ARRAY
:
6848 if (section
->sh_info
!= 0)
6849 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6850 i
, section
->sh_info
);
6856 /* A symbol index - we assume that it is valid. */
6860 /* FIXME: Add support for target specific section types. */
6861 if (section
->sh_type
== SHT_NOBITS
)
6862 /* NOBITS section headers with non-zero sh_info fields can be
6863 created when a binary is stripped of everything but its debug
6864 information. The stripped sections have their headers
6865 preserved but their types set to SHT_NOBITS. So do not check
6866 this type of section. */
6868 else if (section
->sh_flags
& SHF_INFO_LINK
)
6870 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6871 warn (_("[%2u]: Expected link to another section in info field"), i
);
6873 else if (section
->sh_type
< SHT_LOOS
6874 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6875 && section
->sh_info
!= 0)
6876 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6877 i
, section
->sh_info
);
6881 /* Check the sh_size field. */
6882 if (section
->sh_size
> filedata
->file_size
6883 && section
->sh_type
!= SHT_NOBITS
6884 && section
->sh_type
!= SHT_NULL
6885 && section
->sh_type
< SHT_LOOS
)
6886 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6888 printf (" [%2u] ", i
);
6889 if (do_section_details
)
6890 printf ("%s\n ", printable_section_name (filedata
, section
));
6892 print_symbol (-17, SECTION_NAME_PRINT (section
));
6894 printf (do_wide
? " %-15s " : " %-15.15s ",
6895 get_section_type_name (filedata
, section
->sh_type
));
6899 const char * link_too_big
= NULL
;
6901 print_vma (section
->sh_addr
, LONG_HEX
);
6903 printf ( " %6.6lx %6.6lx %2.2lx",
6904 (unsigned long) section
->sh_offset
,
6905 (unsigned long) section
->sh_size
,
6906 (unsigned long) section
->sh_entsize
);
6908 if (do_section_details
)
6909 fputs (" ", stdout
);
6911 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6913 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6916 /* The sh_link value is out of range. Normally this indicates
6917 an error but it can have special values in Solaris binaries. */
6918 switch (filedata
->file_header
.e_machine
)
6925 case EM_OLD_SPARCV9
:
6926 case EM_SPARC32PLUS
:
6929 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6930 link_too_big
= "BEFORE";
6931 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6932 link_too_big
= "AFTER";
6939 if (do_section_details
)
6941 if (link_too_big
!= NULL
&& * link_too_big
)
6942 printf ("<%s> ", link_too_big
);
6944 printf ("%2u ", section
->sh_link
);
6945 printf ("%3u %2lu\n", section
->sh_info
,
6946 (unsigned long) section
->sh_addralign
);
6949 printf ("%2u %3u %2lu\n",
6952 (unsigned long) section
->sh_addralign
);
6954 if (link_too_big
&& ! * link_too_big
)
6955 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6956 i
, section
->sh_link
);
6960 print_vma (section
->sh_addr
, LONG_HEX
);
6962 if ((long) section
->sh_offset
== section
->sh_offset
)
6963 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6967 print_vma (section
->sh_offset
, LONG_HEX
);
6970 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6971 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6975 print_vma (section
->sh_size
, LONG_HEX
);
6978 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6979 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6983 print_vma (section
->sh_entsize
, LONG_HEX
);
6986 if (do_section_details
)
6987 fputs (" ", stdout
);
6989 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6991 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6993 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6994 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6997 print_vma (section
->sh_addralign
, DEC
);
7001 else if (do_section_details
)
7004 print_vma (section
->sh_addr
, LONG_HEX
);
7005 if ((long) section
->sh_offset
== section
->sh_offset
)
7006 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
7010 print_vma (section
->sh_offset
, LONG_HEX
);
7012 printf (" %u\n ", section
->sh_link
);
7013 print_vma (section
->sh_size
, LONG_HEX
);
7015 print_vma (section
->sh_entsize
, LONG_HEX
);
7017 printf (" %-16u %lu\n",
7019 (unsigned long) section
->sh_addralign
);
7024 print_vma (section
->sh_addr
, LONG_HEX
);
7025 if ((long) section
->sh_offset
== section
->sh_offset
)
7026 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
7030 print_vma (section
->sh_offset
, LONG_HEX
);
7033 print_vma (section
->sh_size
, LONG_HEX
);
7035 print_vma (section
->sh_entsize
, LONG_HEX
);
7037 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
7039 printf (" %2u %3u %lu\n",
7042 (unsigned long) section
->sh_addralign
);
7045 if (do_section_details
)
7047 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
7048 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
7050 /* Minimum section size is 12 bytes for 32-bit compression
7051 header + 12 bytes for compressed data header. */
7052 unsigned char buf
[24];
7054 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
7055 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
7056 sizeof (buf
), _("compression header")))
7058 Elf_Internal_Chdr chdr
;
7060 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
7061 printf (_(" [<corrupt>]\n"));
7064 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
7067 printf (_(" [<unknown>: 0x%x], "),
7069 print_vma (chdr
.ch_size
, LONG_HEX
);
7070 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
7077 if (!do_section_details
)
7079 /* The ordering of the letters shown here matches the ordering of the
7080 corresponding SHF_xxx values, and hence the order in which these
7081 letters will be displayed to the user. */
7082 printf (_("Key to Flags:\n\
7083 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
7084 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
7085 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
7086 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
7089 case ELFOSABI_FREEBSD
:
7090 printf (_("R (retain), "));
7093 printf (_("D (mbind), "));
7098 if (filedata
->file_header
.e_machine
== EM_X86_64
7099 || filedata
->file_header
.e_machine
== EM_L1OM
7100 || filedata
->file_header
.e_machine
== EM_K1OM
)
7101 printf (_("l (large), "));
7102 else if (filedata
->file_header
.e_machine
== EM_ARM
)
7103 printf (_("y (purecode), "));
7104 else if (filedata
->file_header
.e_machine
== EM_PPC
)
7105 printf (_("v (VLE), "));
7106 printf ("p (processor specific)\n");
7113 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
7114 Elf_Internal_Sym
**symtab
, unsigned long *nsyms
,
7115 char **strtab
, unsigned long *strtablen
)
7119 *symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, nsyms
);
7121 if (*symtab
== NULL
)
7124 if (symsec
->sh_link
!= 0)
7126 Elf_Internal_Shdr
*strsec
;
7128 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
7130 error (_("Bad sh_link in symbol table section\n"));
7137 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7139 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7140 1, strsec
->sh_size
, _("string table"));
7141 if (*strtab
== NULL
)
7148 *strtablen
= strsec
->sh_size
;
7154 get_group_flags (unsigned int flags
)
7156 static char buff
[128];
7160 else if (flags
== GRP_COMDAT
)
7163 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
7165 flags
& GRP_MASKOS
? _("<OS specific>") : "",
7166 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
7167 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
7168 ? _("<unknown>") : ""));
7174 process_section_groups (Filedata
* filedata
)
7176 Elf_Internal_Shdr
* section
;
7178 struct group
* group
;
7179 Elf_Internal_Shdr
* symtab_sec
;
7180 Elf_Internal_Shdr
* strtab_sec
;
7181 Elf_Internal_Sym
* symtab
;
7182 unsigned long num_syms
;
7186 /* Don't process section groups unless needed. */
7187 if (!do_unwind
&& !do_section_groups
)
7190 if (filedata
->file_header
.e_shnum
== 0)
7192 if (do_section_groups
)
7194 if (filedata
->is_separate
)
7195 printf (_("\nThere are no sections group in linked file '%s'.\n"),
7196 filedata
->file_name
);
7198 printf (_("\nThere are no section groups in this file.\n"));
7203 if (filedata
->section_headers
== NULL
)
7205 error (_("Section headers are not available!\n"));
7206 /* PR 13622: This can happen with a corrupt ELF header. */
7210 filedata
->section_headers_groups
7211 = (struct group
**) calloc (filedata
->file_header
.e_shnum
,
7212 sizeof (struct group
*));
7214 if (filedata
->section_headers_groups
== NULL
)
7216 error (_("Out of memory reading %u section group headers\n"),
7217 filedata
->file_header
.e_shnum
);
7221 /* Scan the sections for the group section. */
7222 filedata
->group_count
= 0;
7223 for (i
= 0, section
= filedata
->section_headers
;
7224 i
< filedata
->file_header
.e_shnum
;
7226 if (section
->sh_type
== SHT_GROUP
)
7227 filedata
->group_count
++;
7229 if (filedata
->group_count
== 0)
7231 if (do_section_groups
)
7233 if (filedata
->is_separate
)
7234 printf (_("\nThere are no section groups in linked file '%s'.\n"),
7235 filedata
->file_name
);
7237 printf (_("\nThere are no section groups in this file.\n"));
7243 filedata
->section_groups
= (struct group
*) calloc (filedata
->group_count
,
7244 sizeof (struct group
));
7246 if (filedata
->section_groups
== NULL
)
7248 error (_("Out of memory reading %lu groups\n"),
7249 (unsigned long) filedata
->group_count
);
7260 if (filedata
->is_separate
)
7261 printf (_("Section groups in linked file '%s'\n"), filedata
->file_name
);
7263 for (i
= 0, section
= filedata
->section_headers
, group
= filedata
->section_groups
;
7264 i
< filedata
->file_header
.e_shnum
;
7267 if (section
->sh_type
== SHT_GROUP
)
7269 const char * name
= printable_section_name (filedata
, section
);
7270 const char * group_name
;
7271 unsigned char * start
;
7272 unsigned char * indices
;
7273 unsigned int entry
, j
, size
;
7274 Elf_Internal_Shdr
* sec
;
7275 Elf_Internal_Sym
* sym
;
7277 /* Get the symbol table. */
7278 if (section
->sh_link
>= filedata
->file_header
.e_shnum
7279 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
7282 error (_("Bad sh_link in group section `%s'\n"), name
);
7286 if (symtab_sec
!= sec
)
7290 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
7295 error (_("Corrupt header in group section `%s'\n"), name
);
7299 if (section
->sh_info
>= num_syms
)
7301 error (_("Bad sh_info in group section `%s'\n"), name
);
7305 sym
= symtab
+ section
->sh_info
;
7307 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
7309 if (sym
->st_shndx
== 0
7310 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
7312 error (_("Bad sh_info in group section `%s'\n"), name
);
7316 group_name
= SECTION_NAME_PRINT (filedata
->section_headers
7325 /* Get the string table. */
7326 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
7334 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
7339 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
7340 1, strtab_sec
->sh_size
,
7342 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
7344 group_name
= sym
->st_name
< strtab_size
7345 ? strtab
+ sym
->st_name
: _("<corrupt>");
7348 /* PR 17531: file: loop. */
7349 if (section
->sh_entsize
> section
->sh_size
)
7351 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7352 printable_section_name (filedata
, section
),
7353 (unsigned long) section
->sh_entsize
,
7354 (unsigned long) section
->sh_size
);
7358 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
7359 1, section
->sh_size
,
7365 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
7366 entry
= byte_get (indices
, 4);
7369 if (do_section_groups
)
7371 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7372 get_group_flags (entry
), i
, name
, group_name
, size
);
7374 printf (_(" [Index] Name\n"));
7377 group
->group_index
= i
;
7379 for (j
= 0; j
< size
; j
++)
7381 struct group_list
* g
;
7383 entry
= byte_get (indices
, 4);
7386 if (entry
>= filedata
->file_header
.e_shnum
)
7388 static unsigned num_group_errors
= 0;
7390 if (num_group_errors
++ < 10)
7392 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7393 entry
, i
, filedata
->file_header
.e_shnum
- 1);
7394 if (num_group_errors
== 10)
7395 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7400 if (filedata
->section_headers_groups
[entry
] != NULL
)
7404 static unsigned num_errs
= 0;
7406 if (num_errs
++ < 10)
7408 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7410 filedata
->section_headers_groups
[entry
]->group_index
);
7412 warn (_("Further error messages about already contained group sections suppressed\n"));
7418 /* Intel C/C++ compiler may put section 0 in a
7419 section group. We just warn it the first time
7420 and ignore it afterwards. */
7421 static bool warned
= false;
7424 error (_("section 0 in group section [%5u]\n"),
7425 filedata
->section_headers_groups
[entry
]->group_index
);
7431 filedata
->section_headers_groups
[entry
] = group
;
7433 if (do_section_groups
)
7435 sec
= filedata
->section_headers
+ entry
;
7436 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7439 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7440 g
->section_index
= entry
;
7441 g
->next
= group
->root
;
7456 /* Data used to display dynamic fixups. */
7458 struct ia64_vms_dynfixup
7460 bfd_vma needed_ident
; /* Library ident number. */
7461 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7462 bfd_vma fixup_needed
; /* Index of the library. */
7463 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7464 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7467 /* Data used to display dynamic relocations. */
7469 struct ia64_vms_dynimgrela
7471 bfd_vma img_rela_cnt
; /* Number of relocations. */
7472 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7475 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7479 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7480 struct ia64_vms_dynfixup
* fixup
,
7481 const char * strtab
,
7482 unsigned int strtab_sz
)
7484 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7486 const char * lib_name
;
7488 imfs
= get_data (NULL
, filedata
,
7489 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
7490 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
7491 _("dynamic section image fixups"));
7495 if (fixup
->needed
< strtab_sz
)
7496 lib_name
= strtab
+ fixup
->needed
;
7499 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7500 (unsigned long) fixup
->needed
);
7504 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7505 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7507 (_("Seg Offset Type SymVec DataType\n"));
7509 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7514 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7515 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7516 type
= BYTE_GET (imfs
[i
].type
);
7517 rtype
= elf_ia64_reloc_type (type
);
7519 printf (" 0x%08x ", type
);
7521 printf (" %-32s ", rtype
);
7522 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7523 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7530 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7533 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7535 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7538 imrs
= get_data (NULL
, filedata
,
7539 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
7540 sizeof (*imrs
), imgrela
->img_rela_cnt
,
7541 _("dynamic section image relocations"));
7545 printf (_("\nImage relocs\n"));
7547 (_("Seg Offset Type Addend Seg Sym Off\n"));
7549 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7554 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7555 printf ("%08" BFD_VMA_FMT
"x ",
7556 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7557 type
= BYTE_GET (imrs
[i
].type
);
7558 rtype
= elf_ia64_reloc_type (type
);
7560 printf ("0x%08x ", type
);
7562 printf ("%-31s ", rtype
);
7563 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7564 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7565 printf ("%08" BFD_VMA_FMT
"x\n",
7566 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7573 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7576 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7578 struct ia64_vms_dynfixup fixup
;
7579 struct ia64_vms_dynimgrela imgrela
;
7580 Elf_Internal_Dyn
*entry
;
7581 bfd_vma strtab_off
= 0;
7582 bfd_vma strtab_sz
= 0;
7583 char *strtab
= NULL
;
7586 memset (&fixup
, 0, sizeof (fixup
));
7587 memset (&imgrela
, 0, sizeof (imgrela
));
7589 /* Note: the order of the entries is specified by the OpenVMS specs. */
7590 for (entry
= filedata
->dynamic_section
;
7591 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
7594 switch (entry
->d_tag
)
7596 case DT_IA_64_VMS_STRTAB_OFFSET
:
7597 strtab_off
= entry
->d_un
.d_val
;
7600 strtab_sz
= entry
->d_un
.d_val
;
7602 strtab
= get_data (NULL
, filedata
,
7603 filedata
->dynamic_addr
+ strtab_off
,
7604 1, strtab_sz
, _("dynamic string section"));
7609 case DT_IA_64_VMS_NEEDED_IDENT
:
7610 fixup
.needed_ident
= entry
->d_un
.d_val
;
7613 fixup
.needed
= entry
->d_un
.d_val
;
7615 case DT_IA_64_VMS_FIXUP_NEEDED
:
7616 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7618 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7619 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7621 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7622 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7623 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7626 case DT_IA_64_VMS_IMG_RELA_CNT
:
7627 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7629 case DT_IA_64_VMS_IMG_RELA_OFF
:
7630 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7631 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7652 dynamic_relocations
[] =
7654 { "REL", DT_REL
, DT_RELSZ
, false },
7655 { "RELA", DT_RELA
, DT_RELASZ
, true },
7656 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7659 /* Process the reloc section. */
7662 process_relocs (Filedata
* filedata
)
7664 unsigned long rel_size
;
7665 unsigned long rel_offset
;
7670 if (do_using_dynamic
)
7674 bool has_dynamic_reloc
;
7677 has_dynamic_reloc
= false;
7679 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7681 is_rela
= dynamic_relocations
[i
].rela
;
7682 name
= dynamic_relocations
[i
].name
;
7683 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
7684 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
7687 has_dynamic_reloc
= true;
7689 if (is_rela
== UNKNOWN
)
7691 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7692 switch (filedata
->dynamic_info
[DT_PLTREL
])
7705 if (filedata
->is_separate
)
7707 (_("\nIn linked file '%s' section '%s' at offset 0x%lx contains %ld bytes:\n"),
7708 filedata
->file_name
, name
, rel_offset
, rel_size
);
7711 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7712 name
, rel_offset
, rel_size
);
7714 dump_relocations (filedata
,
7715 offset_from_vma (filedata
, rel_offset
, rel_size
),
7717 filedata
->dynamic_symbols
,
7718 filedata
->num_dynamic_syms
,
7719 filedata
->dynamic_strings
,
7720 filedata
->dynamic_strings_length
,
7721 is_rela
, true /* is_dynamic */);
7725 if (is_ia64_vms (filedata
))
7726 if (process_ia64_vms_dynamic_relocs (filedata
))
7727 has_dynamic_reloc
= true;
7729 if (! has_dynamic_reloc
)
7731 if (filedata
->is_separate
)
7732 printf (_("\nThere are no dynamic relocations in linked file '%s'.\n"),
7733 filedata
->file_name
);
7735 printf (_("\nThere are no dynamic relocations in this file.\n"));
7740 Elf_Internal_Shdr
* section
;
7744 for (i
= 0, section
= filedata
->section_headers
;
7745 i
< filedata
->file_header
.e_shnum
;
7748 if ( section
->sh_type
!= SHT_RELA
7749 && section
->sh_type
!= SHT_REL
)
7752 rel_offset
= section
->sh_offset
;
7753 rel_size
= section
->sh_size
;
7758 unsigned long num_rela
;
7760 if (filedata
->is_separate
)
7761 printf (_("\nIn linked file '%s' relocation section "),
7762 filedata
->file_name
);
7764 printf (_("\nRelocation section "));
7766 if (filedata
->string_table
== NULL
)
7767 printf ("%d", section
->sh_name
);
7769 printf ("'%s'", printable_section_name (filedata
, section
));
7771 num_rela
= rel_size
/ section
->sh_entsize
;
7772 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7773 " at offset 0x%lx contains %lu entries:\n",
7775 rel_offset
, num_rela
);
7777 is_rela
= section
->sh_type
== SHT_RELA
;
7779 if (section
->sh_link
!= 0
7780 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7782 Elf_Internal_Shdr
* symsec
;
7783 Elf_Internal_Sym
* symtab
;
7784 unsigned long nsyms
;
7785 unsigned long strtablen
= 0;
7786 char * strtab
= NULL
;
7788 symsec
= filedata
->section_headers
+ section
->sh_link
;
7789 if (symsec
->sh_type
!= SHT_SYMTAB
7790 && symsec
->sh_type
!= SHT_DYNSYM
)
7793 if (!get_symtab (filedata
, symsec
,
7794 &symtab
, &nsyms
, &strtab
, &strtablen
))
7797 dump_relocations (filedata
, rel_offset
, rel_size
,
7798 symtab
, nsyms
, strtab
, strtablen
,
7800 symsec
->sh_type
== SHT_DYNSYM
);
7805 dump_relocations (filedata
, rel_offset
, rel_size
,
7806 NULL
, 0, NULL
, 0, is_rela
,
7807 false /* is_dynamic */);
7815 /* Users sometimes forget the -D option, so try to be helpful. */
7816 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7818 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
7820 if (filedata
->is_separate
)
7821 printf (_("\nThere are no static relocations in linked file '%s'."),
7822 filedata
->file_name
);
7824 printf (_("\nThere are no static relocations in this file."));
7825 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7830 if (i
== ARRAY_SIZE (dynamic_relocations
))
7832 if (filedata
->is_separate
)
7833 printf (_("\nThere are no relocations in linked file '%s'.\n"),
7834 filedata
->file_name
);
7836 printf (_("\nThere are no relocations in this file.\n"));
7844 /* An absolute address consists of a section and an offset. If the
7845 section is NULL, the offset itself is the address, otherwise, the
7846 address equals to LOAD_ADDRESS(section) + offset. */
7850 unsigned short section
;
7854 /* Find the nearest symbol at or below ADDR. Returns the symbol
7855 name, if found, and the offset from the symbol to ADDR. */
7858 find_symbol_for_address (Filedata
* filedata
,
7859 Elf_Internal_Sym
* symtab
,
7860 unsigned long nsyms
,
7861 const char * strtab
,
7862 unsigned long strtab_size
,
7863 struct absaddr addr
,
7864 const char ** symname
,
7867 bfd_vma dist
= 0x100000;
7868 Elf_Internal_Sym
* sym
;
7869 Elf_Internal_Sym
* beg
;
7870 Elf_Internal_Sym
* end
;
7871 Elf_Internal_Sym
* best
= NULL
;
7873 REMOVE_ARCH_BITS (addr
.offset
);
7875 end
= symtab
+ nsyms
;
7881 sym
= beg
+ (end
- beg
) / 2;
7883 value
= sym
->st_value
;
7884 REMOVE_ARCH_BITS (value
);
7886 if (sym
->st_name
!= 0
7887 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7888 && addr
.offset
>= value
7889 && addr
.offset
- value
< dist
)
7892 dist
= addr
.offset
- value
;
7897 if (addr
.offset
< value
)
7905 *symname
= (best
->st_name
>= strtab_size
7906 ? _("<corrupt>") : strtab
+ best
->st_name
);
7912 *offset
= addr
.offset
;
7915 static /* signed */ int
7916 symcmp (const void *p
, const void *q
)
7918 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7919 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7921 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7924 /* Process the unwind section. */
7926 #include "unwind-ia64.h"
7928 struct ia64_unw_table_entry
7930 struct absaddr start
;
7932 struct absaddr info
;
7935 struct ia64_unw_aux_info
7937 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7938 unsigned long table_len
; /* Length of unwind table. */
7939 unsigned char * info
; /* Unwind info. */
7940 unsigned long info_size
; /* Size of unwind info. */
7941 bfd_vma info_addr
; /* Starting address of unwind info. */
7942 bfd_vma seg_base
; /* Starting address of segment. */
7943 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7944 unsigned long nsyms
; /* Number of symbols. */
7945 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7946 unsigned long nfuns
; /* Number of entries in funtab. */
7947 char * strtab
; /* The string table. */
7948 unsigned long strtab_size
; /* Size of string table. */
7952 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7954 struct ia64_unw_table_entry
* tp
;
7955 unsigned long j
, nfuns
;
7959 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7960 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7961 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7962 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7964 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7966 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7970 const unsigned char * dp
;
7971 const unsigned char * head
;
7972 const unsigned char * end
;
7973 const char * procname
;
7975 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7976 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7978 fputs ("\n<", stdout
);
7982 fputs (procname
, stdout
);
7985 printf ("+%lx", (unsigned long) offset
);
7988 fputs (">: [", stdout
);
7989 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7990 fputc ('-', stdout
);
7991 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7992 printf ("], info at +0x%lx\n",
7993 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7995 /* PR 17531: file: 86232b32. */
7996 if (aux
->info
== NULL
)
7999 offset
= tp
->info
.offset
;
8000 if (tp
->info
.section
)
8002 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
8004 warn (_("Invalid section %u in table entry %ld\n"),
8005 tp
->info
.section
, (long) (tp
- aux
->table
));
8009 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
8011 offset
-= aux
->info_addr
;
8012 /* PR 17531: file: 0997b4d1. */
8013 if (offset
>= aux
->info_size
8014 || aux
->info_size
- offset
< 8)
8016 warn (_("Invalid offset %lx in table entry %ld\n"),
8017 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
8022 head
= aux
->info
+ offset
;
8023 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
8025 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
8026 (unsigned) UNW_VER (stamp
),
8027 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
8028 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
8029 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
8030 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
8032 if (UNW_VER (stamp
) != 1)
8034 printf (_("\tUnknown version.\n"));
8039 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
8040 /* PR 17531: file: 16ceda89. */
8041 if (end
> aux
->info
+ aux
->info_size
)
8042 end
= aux
->info
+ aux
->info_size
;
8043 for (dp
= head
+ 8; dp
< end
;)
8044 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
8053 slurp_ia64_unwind_table (Filedata
* filedata
,
8054 struct ia64_unw_aux_info
* aux
,
8055 Elf_Internal_Shdr
* sec
)
8057 unsigned long size
, nrelas
, i
;
8058 Elf_Internal_Phdr
* seg
;
8059 struct ia64_unw_table_entry
* tep
;
8060 Elf_Internal_Shdr
* relsec
;
8061 Elf_Internal_Rela
* rela
;
8062 Elf_Internal_Rela
* rp
;
8063 unsigned char * table
;
8065 Elf_Internal_Sym
* sym
;
8066 const char * relname
;
8070 /* First, find the starting address of the segment that includes
8073 if (filedata
->file_header
.e_phnum
)
8075 if (! get_program_headers (filedata
))
8078 for (seg
= filedata
->program_headers
;
8079 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8082 if (seg
->p_type
!= PT_LOAD
)
8085 if (sec
->sh_addr
>= seg
->p_vaddr
8086 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8088 aux
->seg_base
= seg
->p_vaddr
;
8094 /* Second, build the unwind table from the contents of the unwind section: */
8095 size
= sec
->sh_size
;
8096 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8101 aux
->table_len
= size
/ (3 * eh_addr_size
);
8102 aux
->table
= (struct ia64_unw_table_entry
*)
8103 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
8106 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
8108 tep
->start
.section
= SHN_UNDEF
;
8109 tep
->end
.section
= SHN_UNDEF
;
8110 tep
->info
.section
= SHN_UNDEF
;
8111 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8112 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8113 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8114 tep
->start
.offset
+= aux
->seg_base
;
8115 tep
->end
.offset
+= aux
->seg_base
;
8116 tep
->info
.offset
+= aux
->seg_base
;
8120 /* Third, apply any relocations to the unwind table: */
8121 for (relsec
= filedata
->section_headers
;
8122 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8125 if (relsec
->sh_type
!= SHT_RELA
8126 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8127 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8130 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8139 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8141 unsigned int sym_ndx
;
8142 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8143 relname
= elf_ia64_reloc_type (r_type
);
8145 /* PR 17531: file: 9fa67536. */
8146 if (relname
== NULL
)
8148 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8152 if (! startswith (relname
, "R_IA64_SEGREL"))
8154 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8158 i
= rp
->r_offset
/ (3 * eh_addr_size
);
8160 /* PR 17531: file: 5bc8d9bf. */
8161 if (i
>= aux
->table_len
)
8163 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8167 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8168 if (sym_ndx
>= aux
->nsyms
)
8170 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8174 sym
= aux
->symtab
+ sym_ndx
;
8176 switch (rp
->r_offset
/ eh_addr_size
% 3)
8179 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8180 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
8183 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8184 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
8187 aux
->table
[i
].info
.section
= sym
->st_shndx
;
8188 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
8202 ia64_process_unwind (Filedata
* filedata
)
8204 Elf_Internal_Shdr
* sec
;
8205 Elf_Internal_Shdr
* unwsec
= NULL
;
8206 unsigned long i
, unwcount
= 0, unwstart
= 0;
8207 struct ia64_unw_aux_info aux
;
8210 memset (& aux
, 0, sizeof (aux
));
8212 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8214 if (sec
->sh_type
== SHT_SYMTAB
)
8218 error (_("Multiple symbol tables encountered\n"));
8224 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8225 &aux
.strtab
, &aux
.strtab_size
))
8228 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8233 printf (_("\nThere are no unwind sections in this file.\n"));
8235 while (unwcount
-- > 0)
8240 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
8241 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8242 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8247 /* We have already counted the number of SHT_IA64_UNWIND
8248 sections so the loop above should never fail. */
8249 assert (unwsec
!= NULL
);
8252 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
8254 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
8256 /* We need to find which section group it is in. */
8257 struct group_list
* g
;
8259 if (filedata
->section_headers_groups
== NULL
8260 || filedata
->section_headers_groups
[i
] == NULL
)
8261 i
= filedata
->file_header
.e_shnum
;
8264 g
= filedata
->section_headers_groups
[i
]->root
;
8266 for (; g
!= NULL
; g
= g
->next
)
8268 sec
= filedata
->section_headers
+ g
->section_index
;
8270 if (SECTION_NAME_VALID (sec
)
8271 && streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
8276 i
= filedata
->file_header
.e_shnum
;
8279 else if (SECTION_NAME_VALID (unwsec
)
8280 && startswith (SECTION_NAME (unwsec
),
8281 ELF_STRING_ia64_unwind_once
))
8283 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
8284 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
8285 suffix
= SECTION_NAME (unwsec
) + len
;
8286 for (i
= 0, sec
= filedata
->section_headers
;
8287 i
< filedata
->file_header
.e_shnum
;
8289 if (SECTION_NAME_VALID (sec
)
8290 && startswith (SECTION_NAME (sec
),
8291 ELF_STRING_ia64_unwind_info_once
)
8292 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8297 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
8298 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
8299 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
8300 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
8302 if (SECTION_NAME_VALID (unwsec
)
8303 && startswith (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
))
8304 suffix
= SECTION_NAME (unwsec
) + len
;
8305 for (i
= 0, sec
= filedata
->section_headers
;
8306 i
< filedata
->file_header
.e_shnum
;
8308 if (SECTION_NAME_VALID (sec
)
8309 && startswith (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
)
8310 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8314 if (i
== filedata
->file_header
.e_shnum
)
8316 printf (_("\nCould not find unwind info section for "));
8318 if (filedata
->string_table
== NULL
)
8319 printf ("%d", unwsec
->sh_name
);
8321 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8325 aux
.info_addr
= sec
->sh_addr
;
8326 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
8329 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
8331 printf (_("\nUnwind section "));
8333 if (filedata
->string_table
== NULL
)
8334 printf ("%d", unwsec
->sh_name
);
8336 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8338 printf (_(" at offset 0x%lx contains %lu entries:\n"),
8339 (unsigned long) unwsec
->sh_offset
,
8340 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
8342 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
8343 && aux
.table_len
> 0)
8344 dump_ia64_unwind (filedata
, & aux
);
8346 free ((char *) aux
.table
);
8347 free ((char *) aux
.info
);
8354 free ((char *) aux
.strtab
);
8359 struct hppa_unw_table_entry
8361 struct absaddr start
;
8363 unsigned int Cannot_unwind
:1; /* 0 */
8364 unsigned int Millicode
:1; /* 1 */
8365 unsigned int Millicode_save_sr0
:1; /* 2 */
8366 unsigned int Region_description
:2; /* 3..4 */
8367 unsigned int reserved1
:1; /* 5 */
8368 unsigned int Entry_SR
:1; /* 6 */
8369 unsigned int Entry_FR
:4; /* Number saved 7..10 */
8370 unsigned int Entry_GR
:5; /* Number saved 11..15 */
8371 unsigned int Args_stored
:1; /* 16 */
8372 unsigned int Variable_Frame
:1; /* 17 */
8373 unsigned int Separate_Package_Body
:1; /* 18 */
8374 unsigned int Frame_Extension_Millicode
:1; /* 19 */
8375 unsigned int Stack_Overflow_Check
:1; /* 20 */
8376 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
8377 unsigned int Ada_Region
:1; /* 22 */
8378 unsigned int cxx_info
:1; /* 23 */
8379 unsigned int cxx_try_catch
:1; /* 24 */
8380 unsigned int sched_entry_seq
:1; /* 25 */
8381 unsigned int reserved2
:1; /* 26 */
8382 unsigned int Save_SP
:1; /* 27 */
8383 unsigned int Save_RP
:1; /* 28 */
8384 unsigned int Save_MRP_in_frame
:1; /* 29 */
8385 unsigned int extn_ptr_defined
:1; /* 30 */
8386 unsigned int Cleanup_defined
:1; /* 31 */
8388 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
8389 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
8390 unsigned int Large_frame
:1; /* 2 */
8391 unsigned int Pseudo_SP_Set
:1; /* 3 */
8392 unsigned int reserved4
:1; /* 4 */
8393 unsigned int Total_frame_size
:27; /* 5..31 */
8396 struct hppa_unw_aux_info
8398 struct hppa_unw_table_entry
* table
; /* Unwind table. */
8399 unsigned long table_len
; /* Length of unwind table. */
8400 bfd_vma seg_base
; /* Starting address of segment. */
8401 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8402 unsigned long nsyms
; /* Number of symbols. */
8403 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8404 unsigned long nfuns
; /* Number of entries in funtab. */
8405 char * strtab
; /* The string table. */
8406 unsigned long strtab_size
; /* Size of string table. */
8410 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8412 struct hppa_unw_table_entry
* tp
;
8413 unsigned long j
, nfuns
;
8416 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8417 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8418 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8419 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8421 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8423 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8426 const char * procname
;
8428 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8429 aux
->strtab_size
, tp
->start
, &procname
,
8432 fputs ("\n<", stdout
);
8436 fputs (procname
, stdout
);
8439 printf ("+%lx", (unsigned long) offset
);
8442 fputs (">: [", stdout
);
8443 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8444 fputc ('-', stdout
);
8445 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8448 #define PF(_m) if (tp->_m) printf (#_m " ");
8449 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8452 PF(Millicode_save_sr0
);
8453 /* PV(Region_description); */
8459 PF(Separate_Package_Body
);
8460 PF(Frame_Extension_Millicode
);
8461 PF(Stack_Overflow_Check
);
8462 PF(Two_Instruction_SP_Increment
);
8466 PF(sched_entry_seq
);
8469 PF(Save_MRP_in_frame
);
8470 PF(extn_ptr_defined
);
8471 PF(Cleanup_defined
);
8472 PF(MPE_XL_interrupt_marker
);
8473 PF(HP_UX_interrupt_marker
);
8476 PV(Total_frame_size
);
8489 slurp_hppa_unwind_table (Filedata
* filedata
,
8490 struct hppa_unw_aux_info
* aux
,
8491 Elf_Internal_Shdr
* sec
)
8493 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8494 Elf_Internal_Phdr
* seg
;
8495 struct hppa_unw_table_entry
* tep
;
8496 Elf_Internal_Shdr
* relsec
;
8497 Elf_Internal_Rela
* rela
;
8498 Elf_Internal_Rela
* rp
;
8499 unsigned char * table
;
8501 Elf_Internal_Sym
* sym
;
8502 const char * relname
;
8504 /* First, find the starting address of the segment that includes
8506 if (filedata
->file_header
.e_phnum
)
8508 if (! get_program_headers (filedata
))
8511 for (seg
= filedata
->program_headers
;
8512 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8515 if (seg
->p_type
!= PT_LOAD
)
8518 if (sec
->sh_addr
>= seg
->p_vaddr
8519 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8521 aux
->seg_base
= seg
->p_vaddr
;
8527 /* Second, build the unwind table from the contents of the unwind
8529 size
= sec
->sh_size
;
8530 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8536 nentries
= size
/ unw_ent_size
;
8537 size
= unw_ent_size
* nentries
;
8539 aux
->table_len
= nentries
;
8540 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8541 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8543 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8545 unsigned int tmp1
, tmp2
;
8547 tep
->start
.section
= SHN_UNDEF
;
8548 tep
->end
.section
= SHN_UNDEF
;
8550 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8551 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8552 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8553 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8555 tep
->start
.offset
+= aux
->seg_base
;
8556 tep
->end
.offset
+= aux
->seg_base
;
8558 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8559 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8560 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8561 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8562 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8563 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8564 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8565 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8566 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8567 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8568 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8569 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8570 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8571 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8572 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8573 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8574 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8575 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8576 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8577 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8578 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8579 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8580 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8581 tep
->Cleanup_defined
= tmp1
& 0x1;
8583 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8584 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8585 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8586 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8587 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8588 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8592 /* Third, apply any relocations to the unwind table. */
8593 for (relsec
= filedata
->section_headers
;
8594 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8597 if (relsec
->sh_type
!= SHT_RELA
8598 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8599 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8602 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8606 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8608 unsigned int sym_ndx
;
8609 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8610 relname
= elf_hppa_reloc_type (r_type
);
8612 if (relname
== NULL
)
8614 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8618 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8619 if (! startswith (relname
, "R_PARISC_SEGREL"))
8621 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8625 i
= rp
->r_offset
/ unw_ent_size
;
8626 if (i
>= aux
->table_len
)
8628 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8632 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8633 if (sym_ndx
>= aux
->nsyms
)
8635 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8639 sym
= aux
->symtab
+ sym_ndx
;
8641 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8644 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8645 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8648 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8649 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8663 hppa_process_unwind (Filedata
* filedata
)
8665 struct hppa_unw_aux_info aux
;
8666 Elf_Internal_Shdr
* unwsec
= NULL
;
8667 Elf_Internal_Shdr
* sec
;
8671 if (filedata
->string_table
== NULL
)
8674 memset (& aux
, 0, sizeof (aux
));
8676 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8678 if (sec
->sh_type
== SHT_SYMTAB
)
8682 error (_("Multiple symbol tables encountered\n"));
8688 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8689 &aux
.strtab
, &aux
.strtab_size
))
8692 else if (SECTION_NAME_VALID (sec
)
8693 && streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8698 printf (_("\nThere are no unwind sections in this file.\n"));
8700 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8702 if (SECTION_NAME_VALID (sec
)
8703 && streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8705 unsigned long num_unwind
= sec
->sh_size
/ 16;
8707 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8708 "contains %lu entry:\n",
8709 "\nUnwind section '%s' at offset 0x%lx "
8710 "contains %lu entries:\n",
8712 printable_section_name (filedata
, sec
),
8713 (unsigned long) sec
->sh_offset
,
8716 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8719 if (res
&& aux
.table_len
> 0)
8721 if (! dump_hppa_unwind (filedata
, &aux
))
8725 free ((char *) aux
.table
);
8731 free ((char *) aux
.strtab
);
8738 unsigned char * data
; /* The unwind data. */
8739 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8740 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8741 unsigned long nrelas
; /* The number of relocations. */
8742 unsigned int rel_type
; /* REL or RELA ? */
8743 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8746 struct arm_unw_aux_info
8748 Filedata
* filedata
; /* The file containing the unwind sections. */
8749 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8750 unsigned long nsyms
; /* Number of symbols. */
8751 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8752 unsigned long nfuns
; /* Number of these symbols. */
8753 char * strtab
; /* The file's string table. */
8754 unsigned long strtab_size
; /* Size of string table. */
8758 arm_print_vma_and_name (Filedata
* filedata
,
8759 struct arm_unw_aux_info
* aux
,
8761 struct absaddr addr
)
8763 const char *procname
;
8766 if (addr
.section
== SHN_UNDEF
)
8769 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8770 aux
->strtab_size
, addr
, &procname
,
8773 print_vma (fn
, PREFIX_HEX
);
8777 fputs (" <", stdout
);
8778 fputs (procname
, stdout
);
8781 printf ("+0x%lx", (unsigned long) sym_offset
);
8782 fputc ('>', stdout
);
8789 arm_free_section (struct arm_section
*arm_sec
)
8791 free (arm_sec
->data
);
8792 free (arm_sec
->rela
);
8795 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8796 cached section and install SEC instead.
8797 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8798 and return its valued in * WORDP, relocating if necessary.
8799 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8800 relocation's offset in ADDR.
8801 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8802 into the string table of the symbol associated with the reloc. If no
8803 reloc was applied store -1 there.
8804 5) Return TRUE upon success, FALSE otherwise. */
8807 get_unwind_section_word (Filedata
* filedata
,
8808 struct arm_unw_aux_info
* aux
,
8809 struct arm_section
* arm_sec
,
8810 Elf_Internal_Shdr
* sec
,
8811 bfd_vma word_offset
,
8812 unsigned int * wordp
,
8813 struct absaddr
* addr
,
8816 Elf_Internal_Rela
*rp
;
8817 Elf_Internal_Sym
*sym
;
8818 const char * relname
;
8822 if (sec
== NULL
|| arm_sec
== NULL
)
8825 addr
->section
= SHN_UNDEF
;
8828 if (sym_name
!= NULL
)
8829 *sym_name
= (bfd_vma
) -1;
8831 /* If necessary, update the section cache. */
8832 if (sec
!= arm_sec
->sec
)
8834 Elf_Internal_Shdr
*relsec
;
8836 arm_free_section (arm_sec
);
8839 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8840 sec
->sh_size
, _("unwind data"));
8841 arm_sec
->rela
= NULL
;
8842 arm_sec
->nrelas
= 0;
8844 for (relsec
= filedata
->section_headers
;
8845 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8848 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8849 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8850 /* PR 15745: Check the section type as well. */
8851 || (relsec
->sh_type
!= SHT_REL
8852 && relsec
->sh_type
!= SHT_RELA
))
8855 arm_sec
->rel_type
= relsec
->sh_type
;
8856 if (relsec
->sh_type
== SHT_REL
)
8858 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8860 & arm_sec
->rela
, & arm_sec
->nrelas
))
8863 else /* relsec->sh_type == SHT_RELA */
8865 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8867 & arm_sec
->rela
, & arm_sec
->nrelas
))
8873 arm_sec
->next_rela
= arm_sec
->rela
;
8876 /* If there is no unwind data we can do nothing. */
8877 if (arm_sec
->data
== NULL
)
8880 /* If the offset is invalid then fail. */
8881 if (/* PR 21343 *//* PR 18879 */
8883 || word_offset
> (sec
->sh_size
- 4)
8884 || ((bfd_signed_vma
) word_offset
) < 0)
8887 /* Get the word at the required offset. */
8888 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8890 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8891 if (arm_sec
->rela
== NULL
)
8897 /* Look through the relocs to find the one that applies to the provided offset. */
8899 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8901 bfd_vma prelval
, offset
;
8903 if (rp
->r_offset
> word_offset
&& !wrapped
)
8908 if (rp
->r_offset
> word_offset
)
8911 if (rp
->r_offset
& 3)
8913 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8914 (unsigned long) rp
->r_offset
);
8918 if (rp
->r_offset
< word_offset
)
8921 /* PR 17531: file: 027-161405-0.004 */
8922 if (aux
->symtab
== NULL
)
8925 if (arm_sec
->rel_type
== SHT_REL
)
8927 offset
= word
& 0x7fffffff;
8928 if (offset
& 0x40000000)
8929 offset
|= ~ (bfd_vma
) 0x7fffffff;
8931 else if (arm_sec
->rel_type
== SHT_RELA
)
8932 offset
= rp
->r_addend
;
8935 error (_("Unknown section relocation type %d encountered\n"),
8940 /* PR 17531 file: 027-1241568-0.004. */
8941 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8943 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8944 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8948 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8949 offset
+= sym
->st_value
;
8950 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8952 /* Check that we are processing the expected reloc type. */
8953 if (filedata
->file_header
.e_machine
== EM_ARM
)
8955 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8956 if (relname
== NULL
)
8958 warn (_("Skipping unknown ARM relocation type: %d\n"),
8959 (int) ELF32_R_TYPE (rp
->r_info
));
8963 if (streq (relname
, "R_ARM_NONE"))
8966 if (! streq (relname
, "R_ARM_PREL31"))
8968 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8972 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8974 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8975 if (relname
== NULL
)
8977 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8978 (int) ELF32_R_TYPE (rp
->r_info
));
8982 if (streq (relname
, "R_C6000_NONE"))
8985 if (! streq (relname
, "R_C6000_PREL31"))
8987 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8995 /* This function currently only supports ARM and TI unwinders. */
8996 warn (_("Only TI and ARM unwinders are currently supported\n"));
9000 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
9001 addr
->section
= sym
->st_shndx
;
9002 addr
->offset
= offset
;
9005 * sym_name
= sym
->st_name
;
9010 arm_sec
->next_rela
= rp
;
9015 static const char *tic6x_unwind_regnames
[16] =
9017 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
9018 "A14", "A13", "A12", "A11", "A10",
9019 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
9023 decode_tic6x_unwind_regmask (unsigned int mask
)
9027 for (i
= 12; mask
; mask
>>= 1, i
--)
9031 fputs (tic6x_unwind_regnames
[i
], stdout
);
9033 fputs (", ", stdout
);
9039 if (remaining == 0 && more_words) \
9042 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
9043 data_offset, & word, & addr, NULL)) \
9049 #define GET_OP(OP) \
9054 (OP) = word >> 24; \
9059 printf (_("[Truncated opcode]\n")); \
9062 printf ("0x%02x ", OP)
9065 decode_arm_unwind_bytecode (Filedata
* filedata
,
9066 struct arm_unw_aux_info
* aux
,
9068 unsigned int remaining
,
9069 unsigned int more_words
,
9070 bfd_vma data_offset
,
9071 Elf_Internal_Shdr
* data_sec
,
9072 struct arm_section
* data_arm_sec
)
9074 struct absaddr addr
;
9077 /* Decode the unwinding instructions. */
9080 unsigned int op
, op2
;
9089 printf (" 0x%02x ", op
);
9091 if ((op
& 0xc0) == 0x00)
9093 int offset
= ((op
& 0x3f) << 2) + 4;
9095 printf (" vsp = vsp + %d", offset
);
9097 else if ((op
& 0xc0) == 0x40)
9099 int offset
= ((op
& 0x3f) << 2) + 4;
9101 printf (" vsp = vsp - %d", offset
);
9103 else if ((op
& 0xf0) == 0x80)
9106 if (op
== 0x80 && op2
== 0)
9107 printf (_("Refuse to unwind"));
9110 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
9115 for (i
= 0; i
< 12; i
++)
9116 if (mask
& (1 << i
))
9122 printf ("r%d", 4 + i
);
9127 else if ((op
& 0xf0) == 0x90)
9129 if (op
== 0x9d || op
== 0x9f)
9130 printf (_(" [Reserved]"));
9132 printf (" vsp = r%d", op
& 0x0f);
9134 else if ((op
& 0xf0) == 0xa0)
9136 int end
= 4 + (op
& 0x07);
9141 for (i
= 4; i
<= end
; i
++)
9157 else if (op
== 0xb0)
9158 printf (_(" finish"));
9159 else if (op
== 0xb1)
9162 if (op2
== 0 || (op2
& 0xf0) != 0)
9163 printf (_("[Spare]"));
9166 unsigned int mask
= op2
& 0x0f;
9171 for (i
= 0; i
< 12; i
++)
9172 if (mask
& (1 << i
))
9183 else if (op
== 0xb2)
9185 unsigned char buf
[9];
9186 unsigned int i
, len
;
9187 unsigned long offset
;
9189 for (i
= 0; i
< sizeof (buf
); i
++)
9192 if ((buf
[i
] & 0x80) == 0)
9195 if (i
== sizeof (buf
))
9197 error (_("corrupt change to vsp\n"));
9202 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
9203 assert (len
== i
+ 1);
9204 offset
= offset
* 4 + 0x204;
9205 printf ("vsp = vsp + %ld", offset
);
9208 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
9210 unsigned int first
, last
;
9217 printf ("pop {D%d", first
);
9219 printf ("-D%d", first
+ last
);
9222 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
9224 unsigned int count
= op
& 0x07;
9228 printf ("-D%d", 8 + count
);
9231 else if (op
>= 0xc0 && op
<= 0xc5)
9233 unsigned int count
= op
& 0x07;
9235 printf (" pop {wR10");
9237 printf ("-wR%d", 10 + count
);
9240 else if (op
== 0xc6)
9242 unsigned int first
, last
;
9247 printf ("pop {wR%d", first
);
9249 printf ("-wR%d", first
+ last
);
9252 else if (op
== 0xc7)
9255 if (op2
== 0 || (op2
& 0xf0) != 0)
9256 printf (_("[Spare]"));
9259 unsigned int mask
= op2
& 0x0f;
9264 for (i
= 0; i
< 4; i
++)
9265 if (mask
& (1 << i
))
9271 printf ("wCGR%d", i
);
9278 printf (_(" [unsupported opcode]"));
9289 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
9290 struct arm_unw_aux_info
* aux
,
9292 unsigned int remaining
,
9293 unsigned int more_words
,
9294 bfd_vma data_offset
,
9295 Elf_Internal_Shdr
* data_sec
,
9296 struct arm_section
* data_arm_sec
)
9298 struct absaddr addr
;
9300 /* Decode the unwinding instructions. */
9303 unsigned int op
, op2
;
9312 printf (" 0x%02x ", op
);
9314 if ((op
& 0xc0) == 0x00)
9316 int offset
= ((op
& 0x3f) << 3) + 8;
9317 printf (" sp = sp + %d", offset
);
9319 else if ((op
& 0xc0) == 0x80)
9322 if (op
== 0x80 && op2
== 0)
9323 printf (_("Refuse to unwind"));
9326 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
9328 printf ("pop compact {");
9332 decode_tic6x_unwind_regmask (mask
);
9336 else if ((op
& 0xf0) == 0xc0)
9344 unsigned int offset
;
9348 /* Scan entire instruction first so that GET_OP output is not
9349 interleaved with disassembly. */
9351 for (i
= 0; nregs
< (op
& 0xf); i
++)
9357 regpos
[nregs
].offset
= i
* 2;
9358 regpos
[nregs
].reg
= reg
;
9365 regpos
[nregs
].offset
= i
* 2 + 1;
9366 regpos
[nregs
].reg
= reg
;
9371 printf (_("pop frame {"));
9374 printf (_("*corrupt* - no registers specified"));
9379 for (i
= i
* 2; i
> 0; i
--)
9381 if (regpos
[reg
].offset
== i
- 1)
9383 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
9390 fputs (name
, stdout
);
9398 else if (op
== 0xd0)
9399 printf (" MOV FP, SP");
9400 else if (op
== 0xd1)
9401 printf (" __c6xabi_pop_rts");
9402 else if (op
== 0xd2)
9404 unsigned char buf
[9];
9405 unsigned int i
, len
;
9406 unsigned long offset
;
9408 for (i
= 0; i
< sizeof (buf
); i
++)
9411 if ((buf
[i
] & 0x80) == 0)
9414 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9415 if (i
== sizeof (buf
))
9417 warn (_("Corrupt stack pointer adjustment detected\n"));
9421 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
9422 assert (len
== i
+ 1);
9423 offset
= offset
* 8 + 0x408;
9424 printf (_("sp = sp + %ld"), offset
);
9426 else if ((op
& 0xf0) == 0xe0)
9428 if ((op
& 0x0f) == 7)
9431 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9435 printf (_(" [unsupported opcode]"));
9444 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9448 offset
= word
& 0x7fffffff;
9449 if (offset
& 0x40000000)
9450 offset
|= ~ (bfd_vma
) 0x7fffffff;
9452 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9455 return offset
+ where
;
9459 decode_arm_unwind (Filedata
* filedata
,
9460 struct arm_unw_aux_info
* aux
,
9462 unsigned int remaining
,
9463 bfd_vma data_offset
,
9464 Elf_Internal_Shdr
* data_sec
,
9465 struct arm_section
* data_arm_sec
)
9468 unsigned int more_words
= 0;
9469 struct absaddr addr
;
9470 bfd_vma sym_name
= (bfd_vma
) -1;
9475 /* Fetch the first word.
9476 Note - when decoding an object file the address extracted
9477 here will always be 0. So we also pass in the sym_name
9478 parameter so that we can find the symbol associated with
9479 the personality routine. */
9480 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9481 & word
, & addr
, & sym_name
))
9488 addr
.section
= SHN_UNDEF
;
9492 if ((word
& 0x80000000) == 0)
9494 /* Expand prel31 for personality routine. */
9496 const char *procname
;
9498 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9499 printf (_(" Personality routine: "));
9501 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9502 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9504 procname
= aux
->strtab
+ sym_name
;
9505 print_vma (fn
, PREFIX_HEX
);
9508 fputs (" <", stdout
);
9509 fputs (procname
, stdout
);
9510 fputc ('>', stdout
);
9514 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9515 fputc ('\n', stdout
);
9517 /* The GCC personality routines use the standard compact
9518 encoding, starting with one byte giving the number of
9520 if (procname
!= NULL
9521 && (startswith (procname
, "__gcc_personality_v0")
9522 || startswith (procname
, "__gxx_personality_v0")
9523 || startswith (procname
, "__gcj_personality_v0")
9524 || startswith (procname
, "__gnu_objc_personality_v0")))
9531 printf (_(" [Truncated data]\n"));
9534 more_words
= word
>> 24;
9544 /* ARM EHABI Section 6.3:
9546 An exception-handling table entry for the compact model looks like:
9550 1 0 index Data for personalityRoutine[index] */
9552 if (filedata
->file_header
.e_machine
== EM_ARM
9553 && (word
& 0x70000000))
9555 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9559 per_index
= (word
>> 24) & 0x7f;
9560 printf (_(" Compact model index: %d\n"), per_index
);
9567 else if (per_index
< 3)
9569 more_words
= (word
>> 16) & 0xff;
9575 switch (filedata
->file_header
.e_machine
)
9580 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9581 data_offset
, data_sec
, data_arm_sec
))
9586 warn (_("Unknown ARM compact model index encountered\n"));
9587 printf (_(" [reserved]\n"));
9595 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9596 data_offset
, data_sec
, data_arm_sec
))
9599 else if (per_index
< 5)
9601 if (((word
>> 17) & 0x7f) == 0x7f)
9602 printf (_(" Restore stack from frame pointer\n"));
9604 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9605 printf (_(" Registers restored: "));
9607 printf (" (compact) ");
9608 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9610 printf (_(" Return register: %s\n"),
9611 tic6x_unwind_regnames
[word
& 0xf]);
9614 printf (_(" [reserved (%d)]\n"), per_index
);
9618 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9619 filedata
->file_header
.e_machine
);
9623 /* Decode the descriptors. Not implemented. */
9629 dump_arm_unwind (Filedata
* filedata
,
9630 struct arm_unw_aux_info
* aux
,
9631 Elf_Internal_Shdr
* exidx_sec
)
9633 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9634 unsigned int i
, exidx_len
;
9635 unsigned long j
, nfuns
;
9638 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9639 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9640 exidx_len
= exidx_sec
->sh_size
/ 8;
9642 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9643 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9644 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9645 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9647 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9649 for (i
= 0; i
< exidx_len
; i
++)
9651 unsigned int exidx_fn
, exidx_entry
;
9652 struct absaddr fn_addr
, entry_addr
;
9655 fputc ('\n', stdout
);
9657 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9658 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9659 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9660 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9663 arm_free_section (& exidx_arm_sec
);
9664 arm_free_section (& extab_arm_sec
);
9668 /* ARM EHABI, Section 5:
9669 An index table entry consists of 2 words.
9670 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9671 if (exidx_fn
& 0x80000000)
9673 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9677 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9679 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9680 fputs (": ", stdout
);
9682 if (exidx_entry
== 1)
9684 print_vma (exidx_entry
, PREFIX_HEX
);
9685 fputs (" [cantunwind]\n", stdout
);
9687 else if (exidx_entry
& 0x80000000)
9689 print_vma (exidx_entry
, PREFIX_HEX
);
9690 fputc ('\n', stdout
);
9691 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9695 bfd_vma table
, table_offset
= 0;
9696 Elf_Internal_Shdr
*table_sec
;
9698 fputs ("@", stdout
);
9699 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9700 print_vma (table
, PREFIX_HEX
);
9703 /* Locate the matching .ARM.extab. */
9704 if (entry_addr
.section
!= SHN_UNDEF
9705 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9707 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9708 table_offset
= entry_addr
.offset
;
9710 if (table_offset
> table_sec
->sh_size
9711 || ((bfd_signed_vma
) table_offset
) < 0)
9713 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9714 (unsigned long) table_offset
,
9715 printable_section_name (filedata
, table_sec
));
9722 table_sec
= find_section_by_address (filedata
, table
);
9723 if (table_sec
!= NULL
)
9724 table_offset
= table
- table_sec
->sh_addr
;
9727 if (table_sec
== NULL
)
9729 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9730 (unsigned long) table
);
9735 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9744 arm_free_section (&exidx_arm_sec
);
9745 arm_free_section (&extab_arm_sec
);
9750 /* Used for both ARM and C6X unwinding tables. */
9753 arm_process_unwind (Filedata
* filedata
)
9755 struct arm_unw_aux_info aux
;
9756 Elf_Internal_Shdr
*unwsec
= NULL
;
9757 Elf_Internal_Shdr
*sec
;
9759 unsigned int sec_type
;
9762 switch (filedata
->file_header
.e_machine
)
9765 sec_type
= SHT_ARM_EXIDX
;
9769 sec_type
= SHT_C6000_UNWIND
;
9773 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9774 filedata
->file_header
.e_machine
);
9778 if (filedata
->string_table
== NULL
)
9781 memset (& aux
, 0, sizeof (aux
));
9782 aux
.filedata
= filedata
;
9784 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9786 if (sec
->sh_type
== SHT_SYMTAB
)
9790 error (_("Multiple symbol tables encountered\n"));
9796 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9797 &aux
.strtab
, &aux
.strtab_size
))
9800 else if (sec
->sh_type
== sec_type
)
9805 printf (_("\nThere are no unwind sections in this file.\n"));
9807 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9809 if (sec
->sh_type
== sec_type
)
9811 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9812 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9813 "contains %lu entry:\n",
9814 "\nUnwind section '%s' at offset 0x%lx "
9815 "contains %lu entries:\n",
9817 printable_section_name (filedata
, sec
),
9818 (unsigned long) sec
->sh_offset
,
9821 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9827 free ((char *) aux
.strtab
);
9833 no_processor_specific_unwind (Filedata
* filedata ATTRIBUTE_UNUSED
)
9835 printf (_("No processor specific unwind information to decode\n"));
9840 process_unwind (Filedata
* filedata
)
9842 struct unwind_handler
9844 unsigned int machtype
;
9845 bool (* handler
)(Filedata
*);
9848 { EM_ARM
, arm_process_unwind
},
9849 { EM_IA_64
, ia64_process_unwind
},
9850 { EM_PARISC
, hppa_process_unwind
},
9851 { EM_TI_C6000
, arm_process_unwind
},
9852 { EM_386
, no_processor_specific_unwind
},
9853 { EM_X86_64
, no_processor_specific_unwind
},
9861 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9862 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9863 return handlers
[i
].handler (filedata
);
9865 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9866 get_machine_name (filedata
->file_header
.e_machine
));
9871 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9873 switch (entry
->d_tag
)
9875 case DT_AARCH64_BTI_PLT
:
9876 case DT_AARCH64_PAC_PLT
:
9879 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9886 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
9888 switch (entry
->d_tag
)
9891 if (entry
->d_un
.d_val
== 0)
9895 static const char * opts
[] =
9897 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9898 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9899 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9900 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9906 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9907 if (entry
->d_un
.d_val
& (1 << cnt
))
9909 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9915 case DT_MIPS_IVERSION
:
9916 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
9917 printf (_("Interface Version: %s"),
9918 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
9922 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9923 /* Note: coded this way so that there is a single string for translation. */
9924 printf (_("<corrupt: %s>"), buf
);
9928 case DT_MIPS_TIME_STAMP
:
9932 time_t atime
= entry
->d_un
.d_val
;
9934 tmp
= gmtime (&atime
);
9935 /* PR 17531: file: 6accc532. */
9937 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9939 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9940 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9941 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9942 printf (_("Time Stamp: %s"), timebuf
);
9946 case DT_MIPS_RLD_VERSION
:
9947 case DT_MIPS_LOCAL_GOTNO
:
9948 case DT_MIPS_CONFLICTNO
:
9949 case DT_MIPS_LIBLISTNO
:
9950 case DT_MIPS_SYMTABNO
:
9951 case DT_MIPS_UNREFEXTNO
:
9952 case DT_MIPS_HIPAGENO
:
9953 case DT_MIPS_DELTA_CLASS_NO
:
9954 case DT_MIPS_DELTA_INSTANCE_NO
:
9955 case DT_MIPS_DELTA_RELOC_NO
:
9956 case DT_MIPS_DELTA_SYM_NO
:
9957 case DT_MIPS_DELTA_CLASSSYM_NO
:
9958 case DT_MIPS_COMPACT_SIZE
:
9959 print_vma (entry
->d_un
.d_val
, DEC
);
9963 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
9964 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9965 /* Falls through. */
9968 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9974 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9976 switch (entry
->d_tag
)
9978 case DT_HP_DLD_FLAGS
:
9987 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9988 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9989 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9990 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9991 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9992 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9993 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9994 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9995 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9996 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9997 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9998 { DT_HP_GST
, "HP_GST" },
9999 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
10000 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
10001 { DT_HP_NODELETE
, "HP_NODELETE" },
10002 { DT_HP_GROUP
, "HP_GROUP" },
10003 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
10007 bfd_vma val
= entry
->d_un
.d_val
;
10009 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
10010 if (val
& flags
[cnt
].bit
)
10014 fputs (flags
[cnt
].str
, stdout
);
10016 val
^= flags
[cnt
].bit
;
10019 if (val
!= 0 || first
)
10023 print_vma (val
, HEX
);
10029 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10037 /* VMS vs Unix time offset and factor. */
10039 #define VMS_EPOCH_OFFSET 35067168000000000LL
10040 #define VMS_GRANULARITY_FACTOR 10000000
10042 #define INT64_MIN (-9223372036854775807LL - 1)
10045 /* Display a VMS time in a human readable format. */
10048 print_vms_time (bfd_int64_t vmstime
)
10050 struct tm
*tm
= NULL
;
10053 if (vmstime
>= INT64_MIN
+ VMS_EPOCH_OFFSET
)
10055 vmstime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
10057 if (unxtime
== vmstime
)
10058 tm
= gmtime (&unxtime
);
10061 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
10062 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
10063 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
10068 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
10070 switch (entry
->d_tag
)
10072 case DT_IA_64_PLT_RESERVE
:
10073 /* First 3 slots reserved. */
10074 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10076 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
10079 case DT_IA_64_VMS_LINKTIME
:
10081 print_vms_time (entry
->d_un
.d_val
);
10085 case DT_IA_64_VMS_LNKFLAGS
:
10086 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10087 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
10088 printf (" CALL_DEBUG");
10089 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
10090 printf (" NOP0BUFS");
10091 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
10092 printf (" P0IMAGE");
10093 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
10094 printf (" MKTHREADS");
10095 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
10096 printf (" UPCALLS");
10097 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
10098 printf (" IMGSTA");
10099 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
10100 printf (" INITIALIZE");
10101 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
10103 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
10104 printf (" EXE_INIT");
10105 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
10106 printf (" TBK_IN_IMG");
10107 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
10108 printf (" DBG_IN_IMG");
10109 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
10110 printf (" TBK_IN_DSF");
10111 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
10112 printf (" DBG_IN_DSF");
10113 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
10114 printf (" SIGNATURES");
10115 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
10116 printf (" REL_SEG_OFF");
10120 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10127 get_32bit_dynamic_section (Filedata
* filedata
)
10129 Elf32_External_Dyn
* edyn
;
10130 Elf32_External_Dyn
* ext
;
10131 Elf_Internal_Dyn
* entry
;
10133 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
10134 filedata
->dynamic_addr
, 1,
10135 filedata
->dynamic_size
,
10136 _("dynamic section"));
10140 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
10141 might not have the luxury of section headers. Look for the DT_NULL
10142 terminator to determine the number of entries. */
10143 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
10144 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
10147 filedata
->dynamic_nent
++;
10148 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
10152 filedata
->dynamic_section
10153 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
10154 if (filedata
->dynamic_section
== NULL
)
10156 error (_("Out of memory allocating space for %lu dynamic entries\n"),
10157 (unsigned long) filedata
->dynamic_nent
);
10162 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10163 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10166 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10167 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10176 get_64bit_dynamic_section (Filedata
* filedata
)
10178 Elf64_External_Dyn
* edyn
;
10179 Elf64_External_Dyn
* ext
;
10180 Elf_Internal_Dyn
* entry
;
10182 /* Read in the data. */
10183 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
10184 filedata
->dynamic_addr
, 1,
10185 filedata
->dynamic_size
,
10186 _("dynamic section"));
10190 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
10191 might not have the luxury of section headers. Look for the DT_NULL
10192 terminator to determine the number of entries. */
10193 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
10194 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
10195 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
10198 filedata
->dynamic_nent
++;
10199 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
10203 filedata
->dynamic_section
10204 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
10205 if (filedata
->dynamic_section
== NULL
)
10207 error (_("Out of memory allocating space for %lu dynamic entries\n"),
10208 (unsigned long) filedata
->dynamic_nent
);
10213 /* Convert from external to internal formats. */
10214 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10215 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10218 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10219 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10228 print_dynamic_flags (bfd_vma flags
)
10236 flag
= flags
& - flags
;
10242 putc (' ', stdout
);
10246 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
10247 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
10248 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
10249 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
10250 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
10251 default: fputs (_("unknown"), stdout
); break;
10258 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
10260 unsigned char * e_data
;
10263 /* If the size_t type is smaller than the bfd_size_type, eg because
10264 you are building a 32-bit tool on a 64-bit host, then make sure
10265 that when (number) is cast to (size_t) no information is lost. */
10266 if (sizeof (size_t) < sizeof (bfd_size_type
)
10267 && (bfd_size_type
) ((size_t) number
) != number
)
10269 error (_("Size truncation prevents reading %s elements of size %u\n"),
10270 bfd_vmatoa ("u", number
), ent_size
);
10274 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
10275 attempting to allocate memory when the read is bound to fail. */
10276 if (ent_size
* number
> filedata
->file_size
)
10278 error (_("Invalid number of dynamic entries: %s\n"),
10279 bfd_vmatoa ("u", number
));
10283 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10284 if (e_data
== NULL
)
10286 error (_("Out of memory reading %s dynamic entries\n"),
10287 bfd_vmatoa ("u", number
));
10291 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
10293 error (_("Unable to read in %s bytes of dynamic data\n"),
10294 bfd_vmatoa ("u", number
* ent_size
));
10299 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10300 if (i_data
== NULL
)
10302 error (_("Out of memory allocating space for %s dynamic entries\n"),
10303 bfd_vmatoa ("u", number
));
10309 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10316 static unsigned long
10317 get_num_dynamic_syms (Filedata
* filedata
)
10319 unsigned long num_of_syms
= 0;
10321 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
10322 return num_of_syms
;
10324 if (filedata
->dynamic_info
[DT_HASH
])
10326 unsigned char nb
[8];
10327 unsigned char nc
[8];
10328 unsigned int hash_ent_size
= 4;
10330 if ((filedata
->file_header
.e_machine
== EM_ALPHA
10331 || filedata
->file_header
.e_machine
== EM_S390
10332 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
10333 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10336 if (fseek (filedata
->handle
,
10337 (filedata
->archive_file_offset
10338 + offset_from_vma (filedata
, filedata
->dynamic_info
[DT_HASH
],
10339 sizeof nb
+ sizeof nc
)),
10342 error (_("Unable to seek to start of dynamic information\n"));
10346 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
10348 error (_("Failed to read in number of buckets\n"));
10352 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
10354 error (_("Failed to read in number of chains\n"));
10358 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
10359 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
10361 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
10363 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
10365 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
10368 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
10369 num_of_syms
= filedata
->nchains
;
10372 if (num_of_syms
== 0)
10374 free (filedata
->buckets
);
10375 filedata
->buckets
= NULL
;
10376 free (filedata
->chains
);
10377 filedata
->chains
= NULL
;
10378 filedata
->nbuckets
= 0;
10382 if (filedata
->dynamic_info_DT_GNU_HASH
)
10384 unsigned char nb
[16];
10385 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10386 bfd_vma buckets_vma
;
10389 if (fseek (filedata
->handle
,
10390 (filedata
->archive_file_offset
10391 + offset_from_vma (filedata
,
10392 filedata
->dynamic_info_DT_GNU_HASH
,
10396 error (_("Unable to seek to start of dynamic information\n"));
10400 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
10402 error (_("Failed to read in number of buckets\n"));
10406 filedata
->ngnubuckets
= byte_get (nb
, 4);
10407 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
10408 bitmaskwords
= byte_get (nb
+ 8, 4);
10409 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
10411 buckets_vma
+= bitmaskwords
* 4;
10413 buckets_vma
+= bitmaskwords
* 8;
10415 if (fseek (filedata
->handle
,
10416 (filedata
->archive_file_offset
10417 + offset_from_vma (filedata
, buckets_vma
, 4)),
10420 error (_("Unable to seek to start of dynamic information\n"));
10424 filedata
->gnubuckets
10425 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
10427 if (filedata
->gnubuckets
== NULL
)
10430 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
10431 if (filedata
->gnubuckets
[i
] != 0)
10433 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
10436 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
10437 maxchain
= filedata
->gnubuckets
[i
];
10440 if (maxchain
== 0xffffffff)
10443 maxchain
-= filedata
->gnusymidx
;
10445 if (fseek (filedata
->handle
,
10446 (filedata
->archive_file_offset
10447 + offset_from_vma (filedata
,
10448 buckets_vma
+ 4 * (filedata
->ngnubuckets
10453 error (_("Unable to seek to start of dynamic information\n"));
10459 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
10461 error (_("Failed to determine last chain length\n"));
10465 if (maxchain
+ 1 == 0)
10470 while ((byte_get (nb
, 4) & 1) == 0);
10472 if (fseek (filedata
->handle
,
10473 (filedata
->archive_file_offset
10474 + offset_from_vma (filedata
, (buckets_vma
10475 + 4 * filedata
->ngnubuckets
),
10479 error (_("Unable to seek to start of dynamic information\n"));
10483 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
10484 filedata
->ngnuchains
= maxchain
;
10486 if (filedata
->gnuchains
== NULL
)
10489 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10491 if (fseek (filedata
->handle
,
10492 (filedata
->archive_file_offset
10493 + offset_from_vma (filedata
, (buckets_vma
10494 + 4 * (filedata
->ngnubuckets
10498 error (_("Unable to seek to start of dynamic information\n"));
10502 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
10503 if (filedata
->mipsxlat
== NULL
)
10507 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
10508 if (filedata
->gnubuckets
[hn
] != 0)
10510 bfd_vma si
= filedata
->gnubuckets
[hn
];
10511 bfd_vma off
= si
- filedata
->gnusymidx
;
10515 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10517 if (off
< filedata
->ngnuchains
10518 && filedata
->mipsxlat
[off
] >= num_of_syms
)
10519 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
10523 if (si
>= num_of_syms
)
10524 num_of_syms
= si
+ 1;
10528 while (off
< filedata
->ngnuchains
10529 && (filedata
->gnuchains
[off
++] & 1) == 0);
10532 if (num_of_syms
== 0)
10535 free (filedata
->mipsxlat
);
10536 filedata
->mipsxlat
= NULL
;
10537 free (filedata
->gnuchains
);
10538 filedata
->gnuchains
= NULL
;
10539 free (filedata
->gnubuckets
);
10540 filedata
->gnubuckets
= NULL
;
10541 filedata
->ngnubuckets
= 0;
10542 filedata
->ngnuchains
= 0;
10546 return num_of_syms
;
10549 /* Parse and display the contents of the dynamic section. */
10552 process_dynamic_section (Filedata
* filedata
)
10554 Elf_Internal_Dyn
* entry
;
10556 if (filedata
->dynamic_size
== 0)
10560 if (filedata
->is_separate
)
10561 printf (_("\nThere is no dynamic section in linked file '%s'.\n"),
10562 filedata
->file_name
);
10564 printf (_("\nThere is no dynamic section in this file.\n"));
10572 if (! get_32bit_dynamic_section (filedata
))
10577 if (! get_64bit_dynamic_section (filedata
))
10581 /* Find the appropriate symbol table. */
10582 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
10584 unsigned long num_of_syms
;
10586 for (entry
= filedata
->dynamic_section
;
10587 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10589 if (entry
->d_tag
== DT_SYMTAB
)
10590 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
10591 else if (entry
->d_tag
== DT_SYMENT
)
10592 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
10593 else if (entry
->d_tag
== DT_HASH
)
10594 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
10595 else if (entry
->d_tag
== DT_GNU_HASH
)
10596 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10597 else if ((filedata
->file_header
.e_machine
== EM_MIPS
10598 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
10599 && entry
->d_tag
== DT_MIPS_XHASH
)
10601 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10602 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10605 num_of_syms
= get_num_dynamic_syms (filedata
);
10607 if (num_of_syms
!= 0
10608 && filedata
->dynamic_symbols
== NULL
10609 && filedata
->dynamic_info
[DT_SYMTAB
]
10610 && filedata
->dynamic_info
[DT_SYMENT
])
10612 Elf_Internal_Phdr
*seg
;
10613 bfd_vma vma
= filedata
->dynamic_info
[DT_SYMTAB
];
10615 if (! get_program_headers (filedata
))
10617 error (_("Cannot interpret virtual addresses "
10618 "without program headers.\n"));
10622 for (seg
= filedata
->program_headers
;
10623 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
10626 if (seg
->p_type
!= PT_LOAD
)
10629 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
10631 /* See PR 21379 for a reproducer. */
10632 error (_("Invalid PT_LOAD entry\n"));
10636 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
10637 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
10639 /* Since we do not know how big the symbol table is,
10640 we default to reading in up to the end of PT_LOAD
10641 segment and processing that. This is overkill, I
10642 know, but it should work. */
10643 Elf_Internal_Shdr section
;
10644 section
.sh_offset
= (vma
- seg
->p_vaddr
10646 section
.sh_size
= (num_of_syms
10647 * filedata
->dynamic_info
[DT_SYMENT
]);
10648 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
10651 && filedata
->dynamic_symtab_section
!= NULL
10652 && ((filedata
->dynamic_symtab_section
->sh_offset
10653 != section
.sh_offset
)
10654 || (filedata
->dynamic_symtab_section
->sh_size
10655 != section
.sh_size
)
10656 || (filedata
->dynamic_symtab_section
->sh_entsize
10657 != section
.sh_entsize
)))
10659 the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
10661 section
.sh_name
= filedata
->string_table_length
;
10662 filedata
->dynamic_symbols
10663 = GET_ELF_SYMBOLS (filedata
, §ion
,
10664 &filedata
->num_dynamic_syms
);
10665 if (filedata
->dynamic_symbols
== NULL
10666 || filedata
->num_dynamic_syms
!= num_of_syms
)
10668 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
10677 /* Similarly find a string table. */
10678 if (filedata
->dynamic_strings
== NULL
)
10679 for (entry
= filedata
->dynamic_section
;
10680 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10683 if (entry
->d_tag
== DT_STRTAB
)
10684 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
10686 if (entry
->d_tag
== DT_STRSZ
)
10687 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
10689 if (filedata
->dynamic_info
[DT_STRTAB
]
10690 && filedata
->dynamic_info
[DT_STRSZ
])
10692 unsigned long offset
;
10693 bfd_size_type str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
10695 offset
= offset_from_vma (filedata
,
10696 filedata
->dynamic_info
[DT_STRTAB
],
10699 && filedata
->dynamic_strtab_section
10700 && ((filedata
->dynamic_strtab_section
->sh_offset
10701 != (file_ptr
) offset
)
10702 || (filedata
->dynamic_strtab_section
->sh_size
10705 the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
10707 filedata
->dynamic_strings
10708 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
10709 _("dynamic string table"));
10710 if (filedata
->dynamic_strings
== NULL
)
10712 error (_("Corrupt DT_STRTAB dynamic entry\n"));
10716 filedata
->dynamic_strings_length
= str_tab_len
;
10721 /* And find the syminfo section if available. */
10722 if (filedata
->dynamic_syminfo
== NULL
)
10724 unsigned long syminsz
= 0;
10726 for (entry
= filedata
->dynamic_section
;
10727 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10730 if (entry
->d_tag
== DT_SYMINENT
)
10732 /* Note: these braces are necessary to avoid a syntax
10733 error from the SunOS4 C compiler. */
10734 /* PR binutils/17531: A corrupt file can trigger this test.
10735 So do not use an assert, instead generate an error message. */
10736 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
10737 error (_("Bad value (%d) for SYMINENT entry\n"),
10738 (int) entry
->d_un
.d_val
);
10740 else if (entry
->d_tag
== DT_SYMINSZ
)
10741 syminsz
= entry
->d_un
.d_val
;
10742 else if (entry
->d_tag
== DT_SYMINFO
)
10743 filedata
->dynamic_syminfo_offset
10744 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
10747 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
10749 Elf_External_Syminfo
* extsyminfo
;
10750 Elf_External_Syminfo
* extsym
;
10751 Elf_Internal_Syminfo
* syminfo
;
10753 /* There is a syminfo section. Read the data. */
10754 extsyminfo
= (Elf_External_Syminfo
*)
10755 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
10756 1, syminsz
, _("symbol information"));
10760 if (filedata
->dynamic_syminfo
!= NULL
)
10762 error (_("Multiple dynamic symbol information sections found\n"));
10763 free (filedata
->dynamic_syminfo
);
10765 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10766 if (filedata
->dynamic_syminfo
== NULL
)
10768 error (_("Out of memory allocating %lu bytes "
10769 "for dynamic symbol info\n"),
10770 (unsigned long) syminsz
);
10774 filedata
->dynamic_syminfo_nent
10775 = syminsz
/ sizeof (Elf_External_Syminfo
);
10776 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
10777 syminfo
< (filedata
->dynamic_syminfo
10778 + filedata
->dynamic_syminfo_nent
);
10779 ++syminfo
, ++extsym
)
10781 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10782 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10789 if (do_dynamic
&& filedata
->dynamic_addr
)
10791 if (filedata
->dynamic_nent
== 1)
10793 if (filedata
->is_separate
)
10794 printf (_("\nIn linked file '%s' the dynamic section at offset 0x%lx contains 1 entry:\n"),
10795 filedata
->file_name
,
10796 filedata
->dynamic_addr
);
10798 printf (_("\nDynamic section at offset 0x%lx contains 1 entry:\n"),
10799 filedata
->dynamic_addr
);
10803 if (filedata
->is_separate
)
10804 printf (_("\nIn linked file '%s' the dynamic section at offset 0x%lx contains %lu entries:\n"),
10805 filedata
->file_name
,
10806 filedata
->dynamic_addr
,
10807 (unsigned long) filedata
->dynamic_nent
);
10809 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
10810 filedata
->dynamic_addr
,
10811 (unsigned long) filedata
->dynamic_nent
);
10815 printf (_(" Tag Type Name/Value\n"));
10817 for (entry
= filedata
->dynamic_section
;
10818 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10823 const char * dtype
;
10826 print_vma (entry
->d_tag
, FULL_HEX
);
10827 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10828 printf (" (%s)%*s", dtype
,
10829 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10832 switch (entry
->d_tag
)
10836 print_dynamic_flags (entry
->d_un
.d_val
);
10846 switch (entry
->d_tag
)
10849 printf (_("Auxiliary library"));
10853 printf (_("Filter library"));
10857 printf (_("Configuration file"));
10861 printf (_("Dependency audit library"));
10865 printf (_("Audit library"));
10869 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10870 printf (": [%s]\n",
10871 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
10875 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10884 printf (_("Flags:"));
10886 if (entry
->d_un
.d_val
== 0)
10887 printf (_(" None\n"));
10890 unsigned long int val
= entry
->d_un
.d_val
;
10892 if (val
& DTF_1_PARINIT
)
10894 printf (" PARINIT");
10895 val
^= DTF_1_PARINIT
;
10897 if (val
& DTF_1_CONFEXP
)
10899 printf (" CONFEXP");
10900 val
^= DTF_1_CONFEXP
;
10903 printf (" %lx", val
);
10912 printf (_("Flags:"));
10914 if (entry
->d_un
.d_val
== 0)
10915 printf (_(" None\n"));
10918 unsigned long int val
= entry
->d_un
.d_val
;
10920 if (val
& DF_P1_LAZYLOAD
)
10922 printf (" LAZYLOAD");
10923 val
^= DF_P1_LAZYLOAD
;
10925 if (val
& DF_P1_GROUPPERM
)
10927 printf (" GROUPPERM");
10928 val
^= DF_P1_GROUPPERM
;
10931 printf (" %lx", val
);
10940 printf (_("Flags:"));
10941 if (entry
->d_un
.d_val
== 0)
10942 printf (_(" None\n"));
10945 unsigned long int val
= entry
->d_un
.d_val
;
10947 if (val
& DF_1_NOW
)
10952 if (val
& DF_1_GLOBAL
)
10954 printf (" GLOBAL");
10955 val
^= DF_1_GLOBAL
;
10957 if (val
& DF_1_GROUP
)
10962 if (val
& DF_1_NODELETE
)
10964 printf (" NODELETE");
10965 val
^= DF_1_NODELETE
;
10967 if (val
& DF_1_LOADFLTR
)
10969 printf (" LOADFLTR");
10970 val
^= DF_1_LOADFLTR
;
10972 if (val
& DF_1_INITFIRST
)
10974 printf (" INITFIRST");
10975 val
^= DF_1_INITFIRST
;
10977 if (val
& DF_1_NOOPEN
)
10979 printf (" NOOPEN");
10980 val
^= DF_1_NOOPEN
;
10982 if (val
& DF_1_ORIGIN
)
10984 printf (" ORIGIN");
10985 val
^= DF_1_ORIGIN
;
10987 if (val
& DF_1_DIRECT
)
10989 printf (" DIRECT");
10990 val
^= DF_1_DIRECT
;
10992 if (val
& DF_1_TRANS
)
10997 if (val
& DF_1_INTERPOSE
)
10999 printf (" INTERPOSE");
11000 val
^= DF_1_INTERPOSE
;
11002 if (val
& DF_1_NODEFLIB
)
11004 printf (" NODEFLIB");
11005 val
^= DF_1_NODEFLIB
;
11007 if (val
& DF_1_NODUMP
)
11009 printf (" NODUMP");
11010 val
^= DF_1_NODUMP
;
11012 if (val
& DF_1_CONFALT
)
11014 printf (" CONFALT");
11015 val
^= DF_1_CONFALT
;
11017 if (val
& DF_1_ENDFILTEE
)
11019 printf (" ENDFILTEE");
11020 val
^= DF_1_ENDFILTEE
;
11022 if (val
& DF_1_DISPRELDNE
)
11024 printf (" DISPRELDNE");
11025 val
^= DF_1_DISPRELDNE
;
11027 if (val
& DF_1_DISPRELPND
)
11029 printf (" DISPRELPND");
11030 val
^= DF_1_DISPRELPND
;
11032 if (val
& DF_1_NODIRECT
)
11034 printf (" NODIRECT");
11035 val
^= DF_1_NODIRECT
;
11037 if (val
& DF_1_IGNMULDEF
)
11039 printf (" IGNMULDEF");
11040 val
^= DF_1_IGNMULDEF
;
11042 if (val
& DF_1_NOKSYMS
)
11044 printf (" NOKSYMS");
11045 val
^= DF_1_NOKSYMS
;
11047 if (val
& DF_1_NOHDR
)
11052 if (val
& DF_1_EDITED
)
11054 printf (" EDITED");
11055 val
^= DF_1_EDITED
;
11057 if (val
& DF_1_NORELOC
)
11059 printf (" NORELOC");
11060 val
^= DF_1_NORELOC
;
11062 if (val
& DF_1_SYMINTPOSE
)
11064 printf (" SYMINTPOSE");
11065 val
^= DF_1_SYMINTPOSE
;
11067 if (val
& DF_1_GLOBAUDIT
)
11069 printf (" GLOBAUDIT");
11070 val
^= DF_1_GLOBAUDIT
;
11072 if (val
& DF_1_SINGLETON
)
11074 printf (" SINGLETON");
11075 val
^= DF_1_SINGLETON
;
11077 if (val
& DF_1_STUB
)
11082 if (val
& DF_1_PIE
)
11087 if (val
& DF_1_KMOD
)
11092 if (val
& DF_1_WEAKFILTER
)
11094 printf (" WEAKFILTER");
11095 val
^= DF_1_WEAKFILTER
;
11097 if (val
& DF_1_NOCOMMON
)
11099 printf (" NOCOMMON");
11100 val
^= DF_1_NOCOMMON
;
11103 printf (" %lx", val
);
11110 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11112 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
11132 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11138 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
11139 name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
11145 switch (entry
->d_tag
)
11148 printf (_("Shared library: [%s]"), name
);
11150 if (filedata
->program_interpreter
11151 && streq (name
, filedata
->program_interpreter
))
11152 printf (_(" program interpreter"));
11156 printf (_("Library soname: [%s]"), name
);
11160 printf (_("Library rpath: [%s]"), name
);
11164 printf (_("Library runpath: [%s]"), name
);
11168 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11173 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11186 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11187 /* Fall through. */
11191 case DT_INIT_ARRAYSZ
:
11192 case DT_FINI_ARRAYSZ
:
11193 case DT_GNU_CONFLICTSZ
:
11194 case DT_GNU_LIBLISTSZ
:
11197 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11198 printf (_(" (bytes)\n"));
11203 case DT_VERNEEDNUM
:
11208 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11217 case DT_INIT_ARRAY
:
11218 case DT_FINI_ARRAY
:
11221 if (entry
->d_tag
== DT_USED
11222 && VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
11224 char * name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
11228 printf (_("Not needed object: [%s]\n"), name
);
11233 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11239 /* The value of this entry is ignored. */
11244 case DT_GNU_PRELINKED
:
11248 time_t atime
= entry
->d_un
.d_val
;
11250 tmp
= gmtime (&atime
);
11251 /* PR 17533 file: 041-1244816-0.004. */
11253 printf (_("<corrupt time val: %lx"),
11254 (unsigned long) atime
);
11256 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
11257 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11258 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11264 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11267 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11272 case DT_GNU_FLAGS_1
:
11275 printf (_("Flags:"));
11276 if (entry
->d_un
.d_val
== 0)
11277 printf (_(" None\n"));
11280 unsigned long int val
= entry
->d_un
.d_val
;
11282 if (val
& DF_GNU_1_UNIQUE
)
11284 printf (" UNIQUE");
11285 val
^= DF_GNU_1_UNIQUE
;
11288 printf (" %lx", val
);
11295 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
11296 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
11297 = entry
->d_un
.d_val
;
11301 switch (filedata
->file_header
.e_machine
)
11304 dynamic_section_aarch64_val (entry
);
11307 case EM_MIPS_RS3_LE
:
11308 dynamic_section_mips_val (filedata
, entry
);
11311 dynamic_section_parisc_val (entry
);
11314 dynamic_section_ia64_val (entry
);
11317 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11329 get_ver_flags (unsigned int flags
)
11331 static char buff
[128];
11338 if (flags
& VER_FLG_BASE
)
11339 strcat (buff
, "BASE");
11341 if (flags
& VER_FLG_WEAK
)
11343 if (flags
& VER_FLG_BASE
)
11344 strcat (buff
, " | ");
11346 strcat (buff
, "WEAK");
11349 if (flags
& VER_FLG_INFO
)
11351 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
11352 strcat (buff
, " | ");
11354 strcat (buff
, "INFO");
11357 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11359 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11360 strcat (buff
, " | ");
11362 strcat (buff
, _("<unknown>"));
11368 /* Display the contents of the version sections. */
11371 process_version_sections (Filedata
* filedata
)
11373 Elf_Internal_Shdr
* section
;
11375 bool found
= false;
11380 for (i
= 0, section
= filedata
->section_headers
;
11381 i
< filedata
->file_header
.e_shnum
;
11384 switch (section
->sh_type
)
11386 case SHT_GNU_verdef
:
11388 Elf_External_Verdef
* edefs
;
11395 if (filedata
->is_separate
)
11396 printf (ngettext ("\nIn linked file '%s' the version definition section '%s' contains %u entry:\n",
11397 "\nIn linked file '%s' the version definition section '%s' contains %u entries:\n",
11399 filedata
->file_name
,
11400 printable_section_name (filedata
, section
),
11403 printf (ngettext ("\nVersion definition section '%s' "
11404 "contains %u entry:\n",
11405 "\nVersion definition section '%s' "
11406 "contains %u entries:\n",
11408 printable_section_name (filedata
, section
),
11411 printf (_(" Addr: 0x"));
11412 printf_vma (section
->sh_addr
);
11413 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11414 (unsigned long) section
->sh_offset
, section
->sh_link
,
11415 printable_section_name_from_index (filedata
, section
->sh_link
));
11417 edefs
= (Elf_External_Verdef
*)
11418 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
11419 _("version definition section"));
11422 endbuf
= (char *) edefs
+ section
->sh_size
;
11424 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11427 Elf_External_Verdef
* edef
;
11428 Elf_Internal_Verdef ent
;
11429 Elf_External_Verdaux
* eaux
;
11430 Elf_Internal_Verdaux aux
;
11431 unsigned long isum
;
11434 vstart
= ((char *) edefs
) + idx
;
11435 if (vstart
+ sizeof (*edef
) > endbuf
)
11438 edef
= (Elf_External_Verdef
*) vstart
;
11440 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
11441 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
11442 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
11443 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
11444 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
11445 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
11446 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
11448 printf (_(" %#06lx: Rev: %d Flags: %s"),
11449 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
11451 printf (_(" Index: %d Cnt: %d "),
11452 ent
.vd_ndx
, ent
.vd_cnt
);
11454 /* Check for overflow. */
11455 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
11458 vstart
+= ent
.vd_aux
;
11460 if (vstart
+ sizeof (*eaux
) > endbuf
)
11462 eaux
= (Elf_External_Verdaux
*) vstart
;
11464 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11465 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11467 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11468 printf (_("Name: %s\n"),
11469 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11471 printf (_("Name index: %ld\n"), aux
.vda_name
);
11473 isum
= idx
+ ent
.vd_aux
;
11475 for (j
= 1; j
< ent
.vd_cnt
; j
++)
11477 if (aux
.vda_next
< sizeof (*eaux
)
11478 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
11480 warn (_("Invalid vda_next field of %lx\n"),
11485 /* Check for overflow. */
11486 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
11489 isum
+= aux
.vda_next
;
11490 vstart
+= aux
.vda_next
;
11492 if (vstart
+ sizeof (*eaux
) > endbuf
)
11494 eaux
= (Elf_External_Verdaux
*) vstart
;
11496 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11497 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11499 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11500 printf (_(" %#06lx: Parent %d: %s\n"),
11502 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11504 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
11505 isum
, j
, aux
.vda_name
);
11508 if (j
< ent
.vd_cnt
)
11509 printf (_(" Version def aux past end of section\n"));
11512 file: id:000001,src:000172+005151,op:splice,rep:2. */
11513 if (ent
.vd_next
< sizeof (*edef
)
11514 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
11516 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
11517 cnt
= section
->sh_info
;
11520 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
11523 idx
+= ent
.vd_next
;
11526 if (cnt
< section
->sh_info
)
11527 printf (_(" Version definition past end of section\n"));
11533 case SHT_GNU_verneed
:
11535 Elf_External_Verneed
* eneed
;
11542 if (filedata
->is_separate
)
11543 printf (ngettext ("\nIn linked file '%s' the version needs section '%s' contains %u entry:\n",
11544 "\nIn linked file '%s' the version needs section '%s' contains %u entries:\n",
11546 filedata
->file_name
,
11547 printable_section_name (filedata
, section
),
11550 printf (ngettext ("\nVersion needs section '%s' "
11551 "contains %u entry:\n",
11552 "\nVersion needs section '%s' "
11553 "contains %u entries:\n",
11555 printable_section_name (filedata
, section
),
11558 printf (_(" Addr: 0x"));
11559 printf_vma (section
->sh_addr
);
11560 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11561 (unsigned long) section
->sh_offset
, section
->sh_link
,
11562 printable_section_name_from_index (filedata
, section
->sh_link
));
11564 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
11565 section
->sh_offset
, 1,
11567 _("Version Needs section"));
11570 endbuf
= (char *) eneed
+ section
->sh_size
;
11572 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11574 Elf_External_Verneed
* entry
;
11575 Elf_Internal_Verneed ent
;
11576 unsigned long isum
;
11580 vstart
= ((char *) eneed
) + idx
;
11581 if (vstart
+ sizeof (*entry
) > endbuf
)
11584 entry
= (Elf_External_Verneed
*) vstart
;
11586 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
11587 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
11588 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
11589 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
11590 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
11592 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
11594 if (VALID_DYNAMIC_NAME (filedata
, ent
.vn_file
))
11595 printf (_(" File: %s"),
11596 GET_DYNAMIC_NAME (filedata
, ent
.vn_file
));
11598 printf (_(" File: %lx"), ent
.vn_file
);
11600 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
11602 /* Check for overflow. */
11603 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
11605 vstart
+= ent
.vn_aux
;
11607 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
11609 Elf_External_Vernaux
* eaux
;
11610 Elf_Internal_Vernaux aux
;
11612 if (vstart
+ sizeof (*eaux
) > endbuf
)
11614 eaux
= (Elf_External_Vernaux
*) vstart
;
11616 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
11617 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
11618 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
11619 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
11620 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
11622 if (VALID_DYNAMIC_NAME (filedata
, aux
.vna_name
))
11623 printf (_(" %#06lx: Name: %s"),
11624 isum
, GET_DYNAMIC_NAME (filedata
, aux
.vna_name
));
11626 printf (_(" %#06lx: Name index: %lx"),
11627 isum
, aux
.vna_name
);
11629 printf (_(" Flags: %s Version: %d\n"),
11630 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
11632 if (aux
.vna_next
< sizeof (*eaux
)
11633 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
11635 warn (_("Invalid vna_next field of %lx\n"),
11640 /* Check for overflow. */
11641 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
11643 isum
+= aux
.vna_next
;
11644 vstart
+= aux
.vna_next
;
11647 if (j
< ent
.vn_cnt
)
11648 warn (_("Missing Version Needs auxiliary information\n"));
11650 if (ent
.vn_next
< sizeof (*entry
)
11651 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
11653 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
11654 cnt
= section
->sh_info
;
11657 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
11659 idx
+= ent
.vn_next
;
11662 if (cnt
< section
->sh_info
)
11663 warn (_("Missing Version Needs information\n"));
11669 case SHT_GNU_versym
:
11671 Elf_Internal_Shdr
* link_section
;
11674 unsigned char * edata
;
11675 unsigned short * data
;
11677 Elf_Internal_Sym
* symbols
;
11678 Elf_Internal_Shdr
* string_sec
;
11679 unsigned long num_syms
;
11682 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
11685 link_section
= filedata
->section_headers
+ section
->sh_link
;
11686 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
11688 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
11693 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
11694 if (symbols
== NULL
)
11697 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
11699 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
11700 string_sec
->sh_size
,
11701 _("version string table"));
11708 if (filedata
->is_separate
)
11709 printf (ngettext ("\nIn linked file '%s' the version symbols section '%s' contains %lu entry:\n",
11710 "\nIn linked file '%s' the version symbols section '%s' contains %lu entries:\n",
11712 filedata
->file_name
,
11713 printable_section_name (filedata
, section
),
11714 (unsigned long) total
);
11716 printf (ngettext ("\nVersion symbols section '%s' "
11717 "contains %lu entry:\n",
11718 "\nVersion symbols section '%s' "
11719 "contains %lu entries:\n",
11721 printable_section_name (filedata
, section
),
11722 (unsigned long) total
);
11724 printf (_(" Addr: 0x"));
11725 printf_vma (section
->sh_addr
);
11726 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11727 (unsigned long) section
->sh_offset
, section
->sh_link
,
11728 printable_section_name (filedata
, link_section
));
11730 off
= offset_from_vma (filedata
,
11731 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11732 total
* sizeof (short));
11733 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
11734 sizeof (short), total
,
11735 _("version symbol data"));
11743 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
11745 for (cnt
= total
; cnt
--;)
11746 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
11751 for (cnt
= 0; cnt
< total
; cnt
+= 4)
11755 char *invalid
= _("*invalid*");
11757 printf (" %03x:", cnt
);
11759 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
11760 switch (data
[cnt
+ j
])
11763 fputs (_(" 0 (*local*) "), stdout
);
11767 fputs (_(" 1 (*global*) "), stdout
);
11771 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
11772 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
11774 /* If this index value is greater than the size of the symbols
11775 array, break to avoid an out-of-bounds read. */
11776 if ((unsigned long)(cnt
+ j
) >= num_syms
)
11778 warn (_("invalid index into symbol array\n"));
11783 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11785 Elf_Internal_Verneed ivn
;
11786 unsigned long offset
;
11788 offset
= offset_from_vma
11790 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11791 sizeof (Elf_External_Verneed
));
11795 Elf_Internal_Vernaux ivna
;
11796 Elf_External_Verneed evn
;
11797 Elf_External_Vernaux evna
;
11798 unsigned long a_off
;
11800 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11801 _("version need")) == NULL
)
11804 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11805 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11807 a_off
= offset
+ ivn
.vn_aux
;
11811 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
11812 1, _("version need aux (2)")) == NULL
)
11815 ivna
.vna_other
= 0;
11819 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11820 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11823 a_off
+= ivna
.vna_next
;
11825 while (ivna
.vna_other
!= data
[cnt
+ j
]
11826 && ivna
.vna_next
!= 0);
11828 if (ivna
.vna_other
== data
[cnt
+ j
])
11830 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11832 if (ivna
.vna_name
>= string_sec
->sh_size
)
11835 name
= strtab
+ ivna
.vna_name
;
11839 offset
+= ivn
.vn_next
;
11841 while (ivn
.vn_next
);
11844 if (data
[cnt
+ j
] != 0x8001
11845 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11847 Elf_Internal_Verdef ivd
;
11848 Elf_External_Verdef evd
;
11849 unsigned long offset
;
11851 offset
= offset_from_vma
11853 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11858 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11859 _("version def")) == NULL
)
11862 /* PR 17531: file: 046-1082287-0.004. */
11863 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11868 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11869 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11872 offset
+= ivd
.vd_next
;
11874 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11875 && ivd
.vd_next
!= 0);
11877 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11879 Elf_External_Verdaux evda
;
11880 Elf_Internal_Verdaux ivda
;
11882 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11884 if (get_data (&evda
, filedata
,
11885 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11887 _("version def aux")) == NULL
)
11890 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11892 if (ivda
.vda_name
>= string_sec
->sh_size
)
11894 else if (name
!= NULL
&& name
!= invalid
)
11895 name
= _("*both*");
11897 name
= strtab
+ ivda
.vda_name
;
11901 nn
+= printf ("(%s%-*s",
11903 12 - (int) strlen (name
),
11907 printf ("%*c", 18 - nn
, ' ');
11926 if (filedata
->is_separate
)
11927 printf (_("\nNo version information found in linked file '%s'.\n"),
11928 filedata
->file_name
);
11930 printf (_("\nNo version information found in this file.\n"));
11936 static const char *
11937 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11939 static char buff
[64];
11943 case STB_LOCAL
: return "LOCAL";
11944 case STB_GLOBAL
: return "GLOBAL";
11945 case STB_WEAK
: return "WEAK";
11947 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11948 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11950 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11952 if (binding
== STB_GNU_UNIQUE
11953 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11955 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11958 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11963 static const char *
11964 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11966 static char buff
[64];
11970 case STT_NOTYPE
: return "NOTYPE";
11971 case STT_OBJECT
: return "OBJECT";
11972 case STT_FUNC
: return "FUNC";
11973 case STT_SECTION
: return "SECTION";
11974 case STT_FILE
: return "FILE";
11975 case STT_COMMON
: return "COMMON";
11976 case STT_TLS
: return "TLS";
11977 case STT_RELC
: return "RELC";
11978 case STT_SRELC
: return "SRELC";
11980 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11982 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11983 return "THUMB_FUNC";
11985 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11988 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11989 return "PARISC_MILLI";
11991 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11993 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11995 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11997 if (type
== STT_HP_OPAQUE
)
11998 return "HP_OPAQUE";
11999 if (type
== STT_HP_STUB
)
12003 if (type
== STT_GNU_IFUNC
12004 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
12005 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
12008 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
12011 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
12016 static const char *
12017 get_symbol_visibility (unsigned int visibility
)
12019 switch (visibility
)
12021 case STV_DEFAULT
: return "DEFAULT";
12022 case STV_INTERNAL
: return "INTERNAL";
12023 case STV_HIDDEN
: return "HIDDEN";
12024 case STV_PROTECTED
: return "PROTECTED";
12026 error (_("Unrecognized visibility value: %u\n"), visibility
);
12027 return _("<unknown>");
12031 static const char *
12032 get_alpha_symbol_other (unsigned int other
)
12036 case STO_ALPHA_NOPV
: return "NOPV";
12037 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
12039 error (_("Unrecognized alpha specific other value: %u\n"), other
);
12040 return _("<unknown>");
12044 static const char *
12045 get_solaris_symbol_visibility (unsigned int visibility
)
12047 switch (visibility
)
12049 case 4: return "EXPORTED";
12050 case 5: return "SINGLETON";
12051 case 6: return "ELIMINATE";
12052 default: return get_symbol_visibility (visibility
);
12056 static const char *
12057 get_aarch64_symbol_other (unsigned int other
)
12059 static char buf
[32];
12061 if (other
& STO_AARCH64_VARIANT_PCS
)
12063 other
&= ~STO_AARCH64_VARIANT_PCS
;
12065 return "VARIANT_PCS";
12066 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
12072 static const char *
12073 get_mips_symbol_other (unsigned int other
)
12077 case STO_OPTIONAL
: return "OPTIONAL";
12078 case STO_MIPS_PLT
: return "MIPS PLT";
12079 case STO_MIPS_PIC
: return "MIPS PIC";
12080 case STO_MICROMIPS
: return "MICROMIPS";
12081 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
12082 case STO_MIPS16
: return "MIPS16";
12083 default: return NULL
;
12087 static const char *
12088 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
12090 if (is_ia64_vms (filedata
))
12092 static char res
[32];
12096 /* Function types is for images and .STB files only. */
12097 switch (filedata
->file_header
.e_type
)
12101 switch (VMS_ST_FUNC_TYPE (other
))
12103 case VMS_SFT_CODE_ADDR
:
12104 strcat (res
, " CA");
12106 case VMS_SFT_SYMV_IDX
:
12107 strcat (res
, " VEC");
12110 strcat (res
, " FD");
12112 case VMS_SFT_RESERVE
:
12113 strcat (res
, " RSV");
12116 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
12117 VMS_ST_FUNC_TYPE (other
));
12118 strcat (res
, " <unknown>");
12125 switch (VMS_ST_LINKAGE (other
))
12127 case VMS_STL_IGNORE
:
12128 strcat (res
, " IGN");
12130 case VMS_STL_RESERVE
:
12131 strcat (res
, " RSV");
12134 strcat (res
, " STD");
12137 strcat (res
, " LNK");
12140 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
12141 VMS_ST_LINKAGE (other
));
12142 strcat (res
, " <unknown>");
12154 static const char *
12155 get_ppc64_symbol_other (unsigned int other
)
12157 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
12160 other
>>= STO_PPC64_LOCAL_BIT
;
12163 static char buf
[64];
12165 other
= ppc64_decode_local_entry (other
);
12166 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
12172 static const char *
12173 get_symbol_other (Filedata
* filedata
, unsigned int other
)
12175 const char * result
= NULL
;
12176 static char buff
[64];
12181 switch (filedata
->file_header
.e_machine
)
12184 result
= get_alpha_symbol_other (other
);
12187 result
= get_aarch64_symbol_other (other
);
12190 result
= get_mips_symbol_other (other
);
12193 result
= get_ia64_symbol_other (filedata
, other
);
12196 result
= get_ppc64_symbol_other (other
);
12206 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
12210 static const char *
12211 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
12213 static char buff
[32];
12217 case SHN_UNDEF
: return "UND";
12218 case SHN_ABS
: return "ABS";
12219 case SHN_COMMON
: return "COM";
12221 if (type
== SHN_IA_64_ANSI_COMMON
12222 && filedata
->file_header
.e_machine
== EM_IA_64
12223 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
12225 else if ((filedata
->file_header
.e_machine
== EM_X86_64
12226 || filedata
->file_header
.e_machine
== EM_L1OM
12227 || filedata
->file_header
.e_machine
== EM_K1OM
)
12228 && type
== SHN_X86_64_LCOMMON
)
12229 return "LARGE_COM";
12230 else if ((type
== SHN_MIPS_SCOMMON
12231 && filedata
->file_header
.e_machine
== EM_MIPS
)
12232 || (type
== SHN_TIC6X_SCOMMON
12233 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
12235 else if (type
== SHN_MIPS_SUNDEFINED
12236 && filedata
->file_header
.e_machine
== EM_MIPS
)
12238 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
12239 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
12240 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
12241 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
12242 else if (type
>= SHN_LORESERVE
)
12243 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
12244 else if (filedata
->file_header
.e_shnum
!= 0
12245 && type
>= filedata
->file_header
.e_shnum
)
12246 sprintf (buff
, _("bad section index[%3d]"), type
);
12248 sprintf (buff
, "%3d", type
);
12255 static const char *
12256 get_symbol_version_string (Filedata
* filedata
,
12258 const char * strtab
,
12259 unsigned long int strtab_size
,
12261 Elf_Internal_Sym
* psym
,
12262 enum versioned_symbol_info
* sym_info
,
12263 unsigned short * vna_other
)
12265 unsigned char data
[2];
12266 unsigned short vers_data
;
12267 unsigned long offset
;
12268 unsigned short max_vd_ndx
;
12271 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
12274 offset
= offset_from_vma (filedata
,
12275 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
12276 sizeof data
+ si
* sizeof (vers_data
));
12278 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
12279 sizeof (data
), 1, _("version data")) == NULL
)
12282 vers_data
= byte_get (data
, 2);
12284 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
12287 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
12290 /* Usually we'd only see verdef for defined symbols, and verneed for
12291 undefined symbols. However, symbols defined by the linker in
12292 .dynbss for variables copied from a shared library in order to
12293 avoid text relocations are defined yet have verneed. We could
12294 use a heuristic to detect the special case, for example, check
12295 for verneed first on symbols defined in SHT_NOBITS sections, but
12296 it is simpler and more reliable to just look for both verdef and
12297 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
12299 if (psym
->st_shndx
!= SHN_UNDEF
12300 && vers_data
!= 0x8001
12301 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
12303 Elf_Internal_Verdef ivd
;
12304 Elf_Internal_Verdaux ivda
;
12305 Elf_External_Verdaux evda
;
12308 off
= offset_from_vma (filedata
,
12309 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
12310 sizeof (Elf_External_Verdef
));
12314 Elf_External_Verdef evd
;
12316 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
12317 _("version def")) == NULL
)
12326 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
12327 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
12328 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
12329 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
12332 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
12333 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
12335 off
+= ivd
.vd_next
;
12337 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
12339 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
12341 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
12344 off
-= ivd
.vd_next
;
12347 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
12348 _("version def aux")) != NULL
)
12350 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
12352 if (psym
->st_name
!= ivda
.vda_name
)
12353 return (ivda
.vda_name
< strtab_size
12354 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
12359 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
12361 Elf_External_Verneed evn
;
12362 Elf_Internal_Verneed ivn
;
12363 Elf_Internal_Vernaux ivna
;
12365 offset
= offset_from_vma (filedata
,
12366 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
12370 unsigned long vna_off
;
12372 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
12373 _("version need")) == NULL
)
12376 ivna
.vna_other
= 0;
12381 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
12382 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
12384 vna_off
= offset
+ ivn
.vn_aux
;
12388 Elf_External_Vernaux evna
;
12390 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
12391 _("version need aux (3)")) == NULL
)
12394 ivna
.vna_other
= 0;
12399 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
12400 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
12401 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
12404 vna_off
+= ivna
.vna_next
;
12406 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
12408 if (ivna
.vna_other
== vers_data
)
12411 offset
+= ivn
.vn_next
;
12413 while (ivn
.vn_next
!= 0);
12415 if (ivna
.vna_other
== vers_data
)
12417 *sym_info
= symbol_undefined
;
12418 *vna_other
= ivna
.vna_other
;
12419 return (ivna
.vna_name
< strtab_size
12420 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
12422 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
12423 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
12424 return _("<corrupt>");
12429 /* Display a symbol size on stdout. Format is based on --sym-base setting. */
12431 static unsigned int
12432 print_dynamic_symbol_size (bfd_vma vma
, int base
)
12437 return print_vma (vma
, OCTAL_5
);
12440 return print_vma (vma
, UNSIGNED_5
);
12443 return print_vma (vma
, PREFIX_HEX_5
);
12447 return print_vma (vma
, DEC_5
);
12452 print_dynamic_symbol (Filedata
*filedata
, unsigned long si
,
12453 Elf_Internal_Sym
*symtab
,
12454 Elf_Internal_Shdr
*section
,
12455 char *strtab
, size_t strtab_size
)
12457 const char *version_string
;
12458 enum versioned_symbol_info sym_info
;
12459 unsigned short vna_other
;
12462 Elf_Internal_Sym
*psym
= symtab
+ si
;
12464 printf ("%6ld: ", si
);
12465 print_vma (psym
->st_value
, LONG_HEX
);
12467 print_dynamic_symbol_size (psym
->st_size
, sym_base
);
12468 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12469 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12470 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12471 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12474 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12476 printf (" %-7s", get_symbol_visibility (vis
));
12477 /* Check to see if any other bits in the st_other field are set.
12478 Note - displaying this information disrupts the layout of the
12479 table being generated, but for the moment this case is very rare. */
12480 if (psym
->st_other
^ vis
)
12481 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12483 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12485 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
12486 && psym
->st_shndx
< filedata
->file_header
.e_shnum
12487 && psym
->st_name
== 0)
12489 is_valid
= SECTION_NAME_VALID (filedata
->section_headers
+ psym
->st_shndx
);
12491 SECTION_NAME_PRINT (filedata
->section_headers
+ psym
->st_shndx
)
12496 is_valid
= VALID_SYMBOL_NAME (strtab
, strtab_size
, psym
->st_name
);
12497 sstr
= is_valid
? strtab
+ psym
->st_name
: _("<corrupt>");
12501 = get_symbol_version_string (filedata
,
12503 || section
->sh_type
== SHT_DYNSYM
),
12504 strtab
, strtab_size
, si
,
12505 psym
, &sym_info
, &vna_other
);
12507 int len_avail
= 21;
12508 if (! do_wide
&& version_string
!= NULL
)
12512 len_avail
-= 1 + strlen (version_string
);
12514 if (sym_info
== symbol_undefined
)
12515 len_avail
-= sprintf (buffer
," (%d)", vna_other
);
12516 else if (sym_info
!= symbol_hidden
)
12520 print_symbol (len_avail
, sstr
);
12522 if (version_string
)
12524 if (sym_info
== symbol_undefined
)
12525 printf ("@%s (%d)", version_string
, vna_other
);
12527 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12533 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12535 && si
>= section
->sh_info
12536 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12537 && filedata
->file_header
.e_machine
!= EM_MIPS
12538 /* Solaris binaries have been found to violate this requirement as
12539 well. Not sure if this is a bug or an ABI requirement. */
12540 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12541 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12542 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12545 static const char *
12546 get_lto_kind (unsigned int kind
)
12550 case 0: return "DEF";
12551 case 1: return "WEAKDEF";
12552 case 2: return "UNDEF";
12553 case 3: return "WEAKUNDEF";
12554 case 4: return "COMMON";
12559 static char buffer
[30];
12560 error (_("Unknown LTO symbol definition encountered: %u\n"), kind
);
12561 sprintf (buffer
, "<unknown: %u>", kind
);
12565 static const char *
12566 get_lto_visibility (unsigned int visibility
)
12568 switch (visibility
)
12570 case 0: return "DEFAULT";
12571 case 1: return "PROTECTED";
12572 case 2: return "INTERNAL";
12573 case 3: return "HIDDEN";
12578 static char buffer
[30];
12579 error (_("Unknown LTO symbol visibility encountered: %u\n"), visibility
);
12580 sprintf (buffer
, "<unknown: %u>", visibility
);
12584 static const char *
12585 get_lto_sym_type (unsigned int sym_type
)
12589 case 0: return "UNKNOWN";
12590 case 1: return "FUNCTION";
12591 case 2: return "VARIABLE";
12596 static char buffer
[30];
12597 error (_("Unknown LTO symbol type encountered: %u\n"), sym_type
);
12598 sprintf (buffer
, "<unknown: %u>", sym_type
);
12602 /* Display an LTO format symbol table.
12603 FIXME: The format of LTO symbol tables is not formalized.
12604 So this code could need changing in the future. */
12607 display_lto_symtab (Filedata
* filedata
,
12608 Elf_Internal_Shdr
* section
)
12610 if (section
->sh_size
== 0)
12612 if (filedata
->is_separate
)
12613 printf (_("\nThe LTO Symbol table section '%s' in linked file '%s' is empty!\n"),
12614 printable_section_name (filedata
, section
),
12615 filedata
->file_name
);
12617 printf (_("\nLTO Symbol table '%s' is empty!\n"),
12618 printable_section_name (filedata
, section
));
12623 if (section
->sh_size
> filedata
->file_size
)
12625 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
12626 printable_section_name (filedata
, section
),
12627 (unsigned long) section
->sh_size
);
12631 void * alloced_data
= get_data (NULL
, filedata
, section
->sh_offset
,
12632 section
->sh_size
, 1, _("LTO symbols"));
12633 if (alloced_data
== NULL
)
12636 /* Look for extended data for the symbol table. */
12637 Elf_Internal_Shdr
* ext
;
12638 void * ext_data_orig
= NULL
;
12639 char * ext_data
= NULL
;
12640 char * ext_data_end
= NULL
;
12641 char * ext_name
= NULL
;
12643 if (asprintf (& ext_name
, ".gnu.lto_.ext_symtab.%s",
12644 SECTION_NAME (section
) + sizeof (".gnu.lto_.symtab.") - 1) > 0
12645 && ext_name
!= NULL
/* Paranoia. */
12646 && (ext
= find_section (filedata
, ext_name
)) != NULL
)
12648 if (ext
->sh_size
< 3)
12649 error (_("LTO Symbol extension table '%s' is empty!\n"),
12650 printable_section_name (filedata
, ext
));
12653 ext_data_orig
= ext_data
= get_data (NULL
, filedata
, ext
->sh_offset
,
12655 _("LTO ext symbol data"));
12656 if (ext_data
!= NULL
)
12658 ext_data_end
= ext_data
+ ext
->sh_size
;
12659 if (* ext_data
++ != 1)
12660 error (_("Unexpected version number in symbol extension table\n"));
12665 const unsigned char * data
= (const unsigned char *) alloced_data
;
12666 const unsigned char * end
= data
+ section
->sh_size
;
12668 if (filedata
->is_separate
)
12669 printf (_("\nIn linked file '%s': "), filedata
->file_name
);
12673 if (ext_data_orig
!= NULL
)
12676 printf (_("LTO Symbol table '%s' and extension table '%s' contain:\n"),
12677 printable_section_name (filedata
, section
),
12678 printable_section_name (filedata
, ext
));
12681 printf (_("LTO Symbol table '%s'\n"),
12682 printable_section_name (filedata
, section
));
12683 printf (_(" and extension table '%s' contain:\n"),
12684 printable_section_name (filedata
, ext
));
12688 printf (_("LTO Symbol table '%s' contains:\n"),
12689 printable_section_name (filedata
, section
));
12691 /* FIXME: Add a wide version. */
12692 if (ext_data_orig
!= NULL
)
12693 printf (_(" Comdat_Key Kind Visibility Size Slot Type Section Name\n"));
12695 printf (_(" Comdat_Key Kind Visibility Size Slot Name\n"));
12697 /* FIXME: We do not handle style prefixes. */
12701 const unsigned char * sym_name
= data
;
12702 data
+= strnlen ((const char *) sym_name
, end
- data
) + 1;
12706 const unsigned char * comdat_key
= data
;
12707 data
+= strnlen ((const char *) comdat_key
, end
- data
) + 1;
12711 if (data
+ 2 + 8 + 4 > end
)
12714 unsigned int kind
= *data
++;
12715 unsigned int visibility
= *data
++;
12717 elf_vma size
= byte_get (data
, 8);
12720 elf_vma slot
= byte_get (data
, 4);
12723 if (ext_data
!= NULL
)
12725 if (ext_data
< (ext_data_end
- 1))
12727 unsigned int sym_type
= * ext_data
++;
12728 unsigned int sec_kind
= * ext_data
++;
12730 printf (" %10s %10s %11s %08lx %08lx %9s %08lx _",
12731 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
12732 get_lto_kind (kind
),
12733 get_lto_visibility (visibility
),
12736 get_lto_sym_type (sym_type
),
12738 print_symbol (6, (const char *) sym_name
);
12742 error (_("Ran out of LTO symbol extension data\n"));
12744 /* FIXME: return FAIL result ? */
12749 printf (" %10s %10s %11s %08lx %08lx _",
12750 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
12751 get_lto_kind (kind
),
12752 get_lto_visibility (visibility
),
12755 print_symbol (21, (const char *) sym_name
);
12760 if (ext_data
!= NULL
&& ext_data
< ext_data_end
)
12762 error (_("Data remains in the LTO symbol extension table\n"));
12766 free (alloced_data
);
12767 free (ext_data_orig
);
12772 error (_("Buffer overrun encountered whilst decoding LTO symbol table\n"));
12773 free (alloced_data
);
12774 free (ext_data_orig
);
12779 /* Display LTO symbol tables. */
12782 process_lto_symbol_tables (Filedata
* filedata
)
12784 Elf_Internal_Shdr
* section
;
12791 if (filedata
->section_headers
== NULL
)
12794 for (i
= 0, section
= filedata
->section_headers
;
12795 i
< filedata
->file_header
.e_shnum
;
12797 if (SECTION_NAME_VALID (section
)
12798 && startswith (SECTION_NAME (section
), ".gnu.lto_.symtab."))
12799 res
&= display_lto_symtab (filedata
, section
);
12804 /* Dump the symbol table. */
12807 process_symbol_table (Filedata
* filedata
)
12809 Elf_Internal_Shdr
* section
;
12811 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
12814 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
12816 && do_using_dynamic
12817 && filedata
->dynamic_strings
!= NULL
12818 && filedata
->dynamic_symbols
!= NULL
)
12822 if (filedata
->is_separate
)
12824 printf (ngettext ("\nIn linked file '%s' the dynamic symbol table contains %lu entry:\n",
12825 "\nIn linked file '%s' the dynamic symbol table contains %lu entries:\n",
12826 filedata
->num_dynamic_syms
),
12827 filedata
->file_name
,
12828 filedata
->num_dynamic_syms
);
12832 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
12833 "\nSymbol table for image contains %lu entries:\n",
12834 filedata
->num_dynamic_syms
),
12835 filedata
->num_dynamic_syms
);
12838 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12840 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12842 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
12843 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
12844 filedata
->dynamic_strings
,
12845 filedata
->dynamic_strings_length
);
12847 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
12848 && filedata
->section_headers
!= NULL
)
12852 for (i
= 0, section
= filedata
->section_headers
;
12853 i
< filedata
->file_header
.e_shnum
;
12856 char * strtab
= NULL
;
12857 unsigned long int strtab_size
= 0;
12858 Elf_Internal_Sym
* symtab
;
12859 unsigned long si
, num_syms
;
12861 if ((section
->sh_type
!= SHT_SYMTAB
12862 && section
->sh_type
!= SHT_DYNSYM
)
12864 && section
->sh_type
== SHT_SYMTAB
))
12867 if (section
->sh_entsize
== 0)
12869 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12870 printable_section_name (filedata
, section
));
12874 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12876 if (filedata
->is_separate
)
12877 printf (ngettext ("\nIn linked file '%s' symbol section '%s' contains %lu entry:\n",
12878 "\nIn linked file '%s' symbol section '%s' contains %lu entries:\n",
12880 filedata
->file_name
,
12881 printable_section_name (filedata
, section
),
12884 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12885 "\nSymbol table '%s' contains %lu entries:\n",
12887 printable_section_name (filedata
, section
),
12891 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12893 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12895 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
12896 if (symtab
== NULL
)
12899 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12901 strtab
= filedata
->string_table
;
12902 strtab_size
= filedata
->string_table_length
;
12904 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12906 Elf_Internal_Shdr
* string_sec
;
12908 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12910 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12911 1, string_sec
->sh_size
,
12912 _("string table"));
12913 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12916 for (si
= 0; si
< num_syms
; si
++)
12917 print_dynamic_symbol (filedata
, si
, symtab
, section
,
12918 strtab
, strtab_size
);
12921 if (strtab
!= filedata
->string_table
)
12927 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12929 if (do_histogram
&& filedata
->buckets
!= NULL
)
12931 unsigned long * lengths
;
12932 unsigned long * counts
;
12935 unsigned long maxlength
= 0;
12936 unsigned long nzero_counts
= 0;
12937 unsigned long nsyms
= 0;
12940 printf (ngettext ("\nHistogram for bucket list length "
12941 "(total of %lu bucket):\n",
12942 "\nHistogram for bucket list length "
12943 "(total of %lu buckets):\n",
12944 (unsigned long) filedata
->nbuckets
),
12945 (unsigned long) filedata
->nbuckets
);
12947 lengths
= (unsigned long *) calloc (filedata
->nbuckets
,
12948 sizeof (*lengths
));
12949 if (lengths
== NULL
)
12951 error (_("Out of memory allocating space for histogram buckets\n"));
12954 visited
= xcmalloc (filedata
->nchains
, 1);
12955 memset (visited
, 0, filedata
->nchains
);
12957 printf (_(" Length Number %% of total Coverage\n"));
12958 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12960 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
12963 if (maxlength
< ++lengths
[hn
])
12965 if (si
>= filedata
->nchains
|| visited
[si
])
12967 error (_("histogram chain is corrupt\n"));
12975 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12976 if (counts
== NULL
)
12979 error (_("Out of memory allocating space for histogram counts\n"));
12983 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12984 ++counts
[lengths
[hn
]];
12986 if (filedata
->nbuckets
> 0)
12989 printf (" 0 %-10lu (%5.1f%%)\n",
12990 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
12991 for (i
= 1; i
<= maxlength
; ++i
)
12993 nzero_counts
+= counts
[i
] * i
;
12994 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12995 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
12996 (nzero_counts
* 100.0) / nsyms
);
13004 free (filedata
->buckets
);
13005 filedata
->buckets
= NULL
;
13006 filedata
->nbuckets
= 0;
13007 free (filedata
->chains
);
13008 filedata
->chains
= NULL
;
13010 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
13012 unsigned long * lengths
;
13013 unsigned long * counts
;
13015 unsigned long maxlength
= 0;
13016 unsigned long nzero_counts
= 0;
13017 unsigned long nsyms
= 0;
13019 printf (ngettext ("\nHistogram for `%s' bucket list length "
13020 "(total of %lu bucket):\n",
13021 "\nHistogram for `%s' bucket list length "
13022 "(total of %lu buckets):\n",
13023 (unsigned long) filedata
->ngnubuckets
),
13024 GNU_HASH_SECTION_NAME (filedata
),
13025 (unsigned long) filedata
->ngnubuckets
);
13027 lengths
= (unsigned long *) calloc (filedata
->ngnubuckets
,
13028 sizeof (*lengths
));
13029 if (lengths
== NULL
)
13031 error (_("Out of memory allocating space for gnu histogram buckets\n"));
13035 printf (_(" Length Number %% of total Coverage\n"));
13037 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
13038 if (filedata
->gnubuckets
[hn
] != 0)
13040 bfd_vma off
, length
= 1;
13042 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
13043 /* PR 17531 file: 010-77222-0.004. */
13044 off
< filedata
->ngnuchains
13045 && (filedata
->gnuchains
[off
] & 1) == 0;
13048 lengths
[hn
] = length
;
13049 if (length
> maxlength
)
13050 maxlength
= length
;
13054 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
13055 if (counts
== NULL
)
13058 error (_("Out of memory allocating space for gnu histogram counts\n"));
13062 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
13063 ++counts
[lengths
[hn
]];
13065 if (filedata
->ngnubuckets
> 0)
13068 printf (" 0 %-10lu (%5.1f%%)\n",
13069 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
13070 for (j
= 1; j
<= maxlength
; ++j
)
13072 nzero_counts
+= counts
[j
] * j
;
13073 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
13074 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
13075 (nzero_counts
* 100.0) / nsyms
);
13082 free (filedata
->gnubuckets
);
13083 filedata
->gnubuckets
= NULL
;
13084 filedata
->ngnubuckets
= 0;
13085 free (filedata
->gnuchains
);
13086 filedata
->gnuchains
= NULL
;
13087 filedata
->ngnuchains
= 0;
13088 free (filedata
->mipsxlat
);
13089 filedata
->mipsxlat
= NULL
;
13093 free (filedata
->gnubuckets
);
13094 filedata
->gnubuckets
= NULL
;
13095 filedata
->ngnubuckets
= 0;
13096 free (filedata
->gnuchains
);
13097 filedata
->gnuchains
= NULL
;
13098 filedata
->ngnuchains
= 0;
13099 free (filedata
->mipsxlat
);
13100 filedata
->mipsxlat
= NULL
;
13101 free (filedata
->buckets
);
13102 filedata
->buckets
= NULL
;
13103 filedata
->nbuckets
= 0;
13104 free (filedata
->chains
);
13105 filedata
->chains
= NULL
;
13110 process_syminfo (Filedata
* filedata
)
13114 if (filedata
->dynamic_syminfo
== NULL
13116 /* No syminfo, this is ok. */
13119 /* There better should be a dynamic symbol section. */
13120 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
13123 if (filedata
->is_separate
)
13124 printf (ngettext ("\nIn linked file '%s: the dynamic info segment at offset 0x%lx contains %d entry:\n",
13125 "\nIn linked file '%s: the dynamic info segment at offset 0x%lx contains %d entries:\n",
13126 filedata
->dynamic_syminfo_nent
),
13127 filedata
->file_name
,
13128 filedata
->dynamic_syminfo_offset
,
13129 filedata
->dynamic_syminfo_nent
);
13131 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
13132 "contains %d entry:\n",
13133 "\nDynamic info segment at offset 0x%lx "
13134 "contains %d entries:\n",
13135 filedata
->dynamic_syminfo_nent
),
13136 filedata
->dynamic_syminfo_offset
,
13137 filedata
->dynamic_syminfo_nent
);
13139 printf (_(" Num: Name BoundTo Flags\n"));
13140 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
13142 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
13144 printf ("%4d: ", i
);
13145 if (i
>= filedata
->num_dynamic_syms
)
13146 printf (_("<corrupt index>"));
13147 else if (VALID_DYNAMIC_NAME (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
13148 print_symbol (30, GET_DYNAMIC_NAME (filedata
,
13149 filedata
->dynamic_symbols
[i
].st_name
));
13151 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
13154 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
13156 case SYMINFO_BT_SELF
:
13157 fputs ("SELF ", stdout
);
13159 case SYMINFO_BT_PARENT
:
13160 fputs ("PARENT ", stdout
);
13163 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
13164 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
13165 && VALID_DYNAMIC_NAME (filedata
,
13166 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
13168 print_symbol (10, GET_DYNAMIC_NAME (filedata
,
13169 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
13173 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
13177 if (flags
& SYMINFO_FLG_DIRECT
)
13178 printf (" DIRECT");
13179 if (flags
& SYMINFO_FLG_PASSTHRU
)
13180 printf (" PASSTHRU");
13181 if (flags
& SYMINFO_FLG_COPY
)
13183 if (flags
& SYMINFO_FLG_LAZYLOAD
)
13184 printf (" LAZYLOAD");
13192 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
13193 is contained by the region START .. END. The types of ADDR, START
13194 and END should all be the same. Note both ADDR + NELEM and END
13195 point to just beyond the end of the regions that are being tested. */
13196 #define IN_RANGE(START,END,ADDR,NELEM) \
13197 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
13199 /* Check to see if the given reloc needs to be handled in a target specific
13200 manner. If so then process the reloc and return TRUE otherwise return
13203 If called with reloc == NULL, then this is a signal that reloc processing
13204 for the current section has finished, and any saved state should be
13208 target_specific_reloc_handling (Filedata
* filedata
,
13209 Elf_Internal_Rela
* reloc
,
13210 unsigned char * start
,
13211 unsigned char * end
,
13212 Elf_Internal_Sym
* symtab
,
13213 unsigned long num_syms
)
13215 unsigned int reloc_type
= 0;
13216 unsigned long sym_index
= 0;
13220 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
13221 sym_index
= get_reloc_symindex (reloc
->r_info
);
13224 switch (filedata
->file_header
.e_machine
)
13227 case EM_MSP430_OLD
:
13229 static Elf_Internal_Sym
* saved_sym
= NULL
;
13237 switch (reloc_type
)
13239 case 10: /* R_MSP430_SYM_DIFF */
13240 case 12: /* R_MSP430_GNU_SUB_ULEB128 */
13241 if (uses_msp430x_relocs (filedata
))
13243 /* Fall through. */
13244 case 21: /* R_MSP430X_SYM_DIFF */
13245 case 23: /* R_MSP430X_GNU_SUB_ULEB128 */
13247 if (sym_index
>= num_syms
)
13248 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
13251 saved_sym
= symtab
+ sym_index
;
13254 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
13255 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
13256 goto handle_sym_diff
;
13258 case 5: /* R_MSP430_16_BYTE */
13259 case 9: /* R_MSP430_8 */
13260 case 11: /* R_MSP430_GNU_SET_ULEB128 */
13261 if (uses_msp430x_relocs (filedata
))
13263 goto handle_sym_diff
;
13265 case 2: /* R_MSP430_ABS16 */
13266 case 15: /* R_MSP430X_ABS16 */
13267 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
13268 if (! uses_msp430x_relocs (filedata
))
13270 goto handle_sym_diff
;
13273 if (saved_sym
!= NULL
)
13276 unsigned int reloc_size
= 0;
13278 switch (reloc_type
)
13280 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
13283 case 11: /* R_MSP430_GNU_SET_ULEB128 */
13284 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
13285 if (reloc
->r_offset
< (size_t) (end
- start
))
13286 read_leb128 (start
+ reloc
->r_offset
, end
, false,
13287 &reloc_size
, &leb_ret
);
13294 if (leb_ret
!= 0 || reloc_size
== 0 || reloc_size
> 8)
13295 error (_("MSP430 ULEB128 field at 0x%lx contains invalid "
13296 "ULEB128 value\n"),
13297 (long) reloc
->r_offset
);
13298 else if (sym_index
>= num_syms
)
13299 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
13303 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
13304 - saved_sym
->st_value
);
13306 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
13307 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
13310 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
13311 (long) reloc
->r_offset
);
13320 if (saved_sym
!= NULL
)
13321 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13328 case EM_CYGNUS_MN10300
:
13330 static Elf_Internal_Sym
* saved_sym
= NULL
;
13338 switch (reloc_type
)
13340 case 34: /* R_MN10300_ALIGN */
13342 case 33: /* R_MN10300_SYM_DIFF */
13343 if (sym_index
>= num_syms
)
13344 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
13347 saved_sym
= symtab
+ sym_index
;
13350 case 1: /* R_MN10300_32 */
13351 case 2: /* R_MN10300_16 */
13352 if (saved_sym
!= NULL
)
13354 int reloc_size
= reloc_type
== 1 ? 4 : 2;
13357 if (sym_index
>= num_syms
)
13358 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
13362 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
13363 - saved_sym
->st_value
);
13365 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
13366 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
13368 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
13369 (long) reloc
->r_offset
);
13377 if (saved_sym
!= NULL
)
13378 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
13386 static bfd_vma saved_sym1
= 0;
13387 static bfd_vma saved_sym2
= 0;
13388 static bfd_vma value
;
13392 saved_sym1
= saved_sym2
= 0;
13396 switch (reloc_type
)
13398 case 0x80: /* R_RL78_SYM. */
13399 saved_sym1
= saved_sym2
;
13400 if (sym_index
>= num_syms
)
13401 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
13405 saved_sym2
= symtab
[sym_index
].st_value
;
13406 saved_sym2
+= reloc
->r_addend
;
13410 case 0x83: /* R_RL78_OPsub. */
13411 value
= saved_sym1
- saved_sym2
;
13412 saved_sym2
= saved_sym1
= 0;
13416 case 0x41: /* R_RL78_ABS32. */
13417 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
13418 byte_put (start
+ reloc
->r_offset
, value
, 4);
13420 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
13421 (long) reloc
->r_offset
);
13425 case 0x43: /* R_RL78_ABS16. */
13426 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
13427 byte_put (start
+ reloc
->r_offset
, value
, 2);
13429 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
13430 (long) reloc
->r_offset
);
13444 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
13445 DWARF debug sections. This is a target specific test. Note - we do not
13446 go through the whole including-target-headers-multiple-times route, (as
13447 we have already done with <elf/h8.h>) because this would become very
13448 messy and even then this function would have to contain target specific
13449 information (the names of the relocs instead of their numeric values).
13450 FIXME: This is not the correct way to solve this problem. The proper way
13451 is to have target specific reloc sizing and typing functions created by
13452 the reloc-macros.h header, in the same way that it already creates the
13453 reloc naming functions. */
13456 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13458 /* Please keep this table alpha-sorted for ease of visual lookup. */
13459 switch (filedata
->file_header
.e_machine
)
13463 return reloc_type
== 1; /* R_386_32. */
13465 return reloc_type
== 1; /* R_68K_32. */
13467 return reloc_type
== 1; /* R_860_32. */
13469 return reloc_type
== 2; /* R_960_32. */
13471 return (reloc_type
== 258
13472 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
13474 return reloc_type
== 11; /* R_BPF_DATA_32 */
13475 case EM_ADAPTEVA_EPIPHANY
:
13476 return reloc_type
== 3;
13478 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
13480 return reloc_type
== 1; /* R_ARC_32. */
13481 case EM_ARC_COMPACT
:
13482 case EM_ARC_COMPACT2
:
13483 return reloc_type
== 4; /* R_ARC_32. */
13485 return reloc_type
== 2; /* R_ARM_ABS32 */
13488 return reloc_type
== 1;
13490 return reloc_type
== 0x12; /* R_byte4_data. */
13492 return reloc_type
== 3; /* R_CRIS_32. */
13494 return reloc_type
== 3; /* R_CR16_NUM32. */
13496 return reloc_type
== 15; /* R_CRX_NUM32. */
13498 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
13499 case EM_CYGNUS_FRV
:
13500 return reloc_type
== 1;
13501 case EM_CYGNUS_D10V
:
13503 return reloc_type
== 6; /* R_D10V_32. */
13504 case EM_CYGNUS_D30V
:
13506 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
13508 return reloc_type
== 3; /* R_DLX_RELOC_32. */
13509 case EM_CYGNUS_FR30
:
13511 return reloc_type
== 3; /* R_FR30_32. */
13513 return reloc_type
== 1; /* R_FT32_32. */
13517 return reloc_type
== 1; /* R_H8_DIR32. */
13519 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
13520 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
13521 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
13522 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
13525 return reloc_type
== 2; /* R_IP2K_32. */
13527 return reloc_type
== 2; /* R_IQ2000_32. */
13528 case EM_LATTICEMICO32
:
13529 return reloc_type
== 3; /* R_LM32_32. */
13532 return reloc_type
== 3; /* R_M32C_32. */
13534 return reloc_type
== 34; /* R_M32R_32_RELA. */
13537 return reloc_type
== 6; /* R_M68HC11_32. */
13539 return reloc_type
== 7 || /* R_S12Z_EXT32 */
13540 reloc_type
== 6; /* R_S12Z_CW32. */
13542 return reloc_type
== 1; /* R_MCORE_ADDR32. */
13543 case EM_CYGNUS_MEP
:
13544 return reloc_type
== 4; /* R_MEP_32. */
13546 return reloc_type
== 2; /* R_METAG_ADDR32. */
13547 case EM_MICROBLAZE
:
13548 return reloc_type
== 1; /* R_MICROBLAZE_32. */
13550 return reloc_type
== 2; /* R_MIPS_32. */
13552 return reloc_type
== 4; /* R_MMIX_32. */
13553 case EM_CYGNUS_MN10200
:
13555 return reloc_type
== 1; /* R_MN10200_32. */
13556 case EM_CYGNUS_MN10300
:
13558 return reloc_type
== 1; /* R_MN10300_32. */
13560 return reloc_type
== 1; /* R_MOXIE_32. */
13561 case EM_MSP430_OLD
:
13563 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
13565 return reloc_type
== 2; /* R_MT_32. */
13567 return reloc_type
== 20; /* R_NDS32_RELA. */
13568 case EM_ALTERA_NIOS2
:
13569 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
13571 return reloc_type
== 1; /* R_NIOS_32. */
13573 return reloc_type
== 1; /* R_OR1K_32. */
13575 return (reloc_type
== 1 /* R_PARISC_DIR32. */
13576 || reloc_type
== 2 /* R_PARISC_DIR21L. */
13577 || reloc_type
== 41); /* R_PARISC_SECREL32. */
13580 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
13582 return reloc_type
== 1; /* R_PPC64_ADDR32. */
13584 return reloc_type
== 1; /* R_PPC_ADDR32. */
13586 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
13588 return reloc_type
== 1; /* R_RISCV_32. */
13590 return reloc_type
== 1; /* R_RL78_DIR32. */
13592 return reloc_type
== 1; /* R_RX_DIR32. */
13594 return reloc_type
== 1; /* R_I370_ADDR31. */
13597 return reloc_type
== 4; /* R_S390_32. */
13599 return reloc_type
== 8; /* R_SCORE_ABS32. */
13601 return reloc_type
== 1; /* R_SH_DIR32. */
13602 case EM_SPARC32PLUS
:
13605 return reloc_type
== 3 /* R_SPARC_32. */
13606 || reloc_type
== 23; /* R_SPARC_UA32. */
13608 return reloc_type
== 6; /* R_SPU_ADDR32 */
13610 return reloc_type
== 1; /* R_C6000_ABS32. */
13612 return reloc_type
== 2; /* R_TILEGX_32. */
13614 return reloc_type
== 1; /* R_TILEPRO_32. */
13615 case EM_CYGNUS_V850
:
13617 return reloc_type
== 6; /* R_V850_ABS32. */
13619 return reloc_type
== 0x33; /* R_V810_WORD. */
13621 return reloc_type
== 1; /* R_VAX_32. */
13623 return reloc_type
== 3; /* R_VISIUM_32. */
13624 case EM_WEBASSEMBLY
:
13625 return reloc_type
== 1; /* R_WASM32_32. */
13629 return reloc_type
== 10; /* R_X86_64_32. */
13632 return reloc_type
== 3; /* R_XC16C_ABS_32. */
13634 return reloc_type
== 4; /* R_XGATE_32. */
13636 return reloc_type
== 1; /* R_XSTROMY16_32. */
13637 case EM_XTENSA_OLD
:
13639 return reloc_type
== 1; /* R_XTENSA_32. */
13641 return reloc_type
== 6; /* R_Z80_32. */
13644 static unsigned int prev_warn
= 0;
13646 /* Avoid repeating the same warning multiple times. */
13647 if (prev_warn
!= filedata
->file_header
.e_machine
)
13648 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
13649 filedata
->file_header
.e_machine
);
13650 prev_warn
= filedata
->file_header
.e_machine
;
13656 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13657 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
13660 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13662 switch (filedata
->file_header
.e_machine
)
13663 /* Please keep this table alpha-sorted for ease of visual lookup. */
13667 return reloc_type
== 2; /* R_386_PC32. */
13669 return reloc_type
== 4; /* R_68K_PC32. */
13671 return reloc_type
== 261; /* R_AARCH64_PREL32 */
13672 case EM_ADAPTEVA_EPIPHANY
:
13673 return reloc_type
== 6;
13675 return reloc_type
== 10; /* R_ALPHA_SREL32. */
13676 case EM_ARC_COMPACT
:
13677 case EM_ARC_COMPACT2
:
13678 return reloc_type
== 49; /* R_ARC_32_PCREL. */
13680 return reloc_type
== 3; /* R_ARM_REL32 */
13683 return reloc_type
== 36; /* R_AVR_32_PCREL. */
13684 case EM_MICROBLAZE
:
13685 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
13687 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
13689 return reloc_type
== 9; /* R_PARISC_PCREL32. */
13691 return reloc_type
== 26; /* R_PPC_REL32. */
13693 return reloc_type
== 26; /* R_PPC64_REL32. */
13695 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
13698 return reloc_type
== 5; /* R_390_PC32. */
13700 return reloc_type
== 2; /* R_SH_REL32. */
13701 case EM_SPARC32PLUS
:
13704 return reloc_type
== 6; /* R_SPARC_DISP32. */
13706 return reloc_type
== 13; /* R_SPU_REL32. */
13708 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
13710 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
13712 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
13716 return reloc_type
== 2; /* R_X86_64_PC32. */
13718 return reloc_type
== 4; /* R_VAX_PCREL32. */
13719 case EM_XTENSA_OLD
:
13721 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
13723 /* Do not abort or issue an error message here. Not all targets use
13724 pc-relative 32-bit relocs in their DWARF debug information and we
13725 have already tested for target coverage in is_32bit_abs_reloc. A
13726 more helpful warning message will be generated by apply_relocations
13727 anyway, so just return. */
13732 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13733 a 64-bit absolute RELA relocation used in DWARF debug sections. */
13736 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13738 switch (filedata
->file_header
.e_machine
)
13741 return reloc_type
== 257; /* R_AARCH64_ABS64. */
13743 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
13745 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
13746 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
13748 return reloc_type
== 80; /* R_PARISC_DIR64. */
13750 return reloc_type
== 38; /* R_PPC64_ADDR64. */
13752 return reloc_type
== 2; /* R_RISCV_64. */
13753 case EM_SPARC32PLUS
:
13756 return reloc_type
== 32 /* R_SPARC_64. */
13757 || reloc_type
== 54; /* R_SPARC_UA64. */
13761 return reloc_type
== 1; /* R_X86_64_64. */
13764 return reloc_type
== 22; /* R_S390_64. */
13766 return reloc_type
== 1; /* R_TILEGX_64. */
13768 return reloc_type
== 18; /* R_MIPS_64. */
13774 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
13775 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
13778 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13780 switch (filedata
->file_header
.e_machine
)
13783 return reloc_type
== 260; /* R_AARCH64_PREL64. */
13785 return reloc_type
== 11; /* R_ALPHA_SREL64. */
13787 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
13788 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
13790 return reloc_type
== 72; /* R_PARISC_PCREL64. */
13792 return reloc_type
== 44; /* R_PPC64_REL64. */
13793 case EM_SPARC32PLUS
:
13796 return reloc_type
== 46; /* R_SPARC_DISP64. */
13800 return reloc_type
== 24; /* R_X86_64_PC64. */
13803 return reloc_type
== 23; /* R_S390_PC64. */
13805 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
13811 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13812 a 24-bit absolute RELA relocation used in DWARF debug sections. */
13815 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13817 switch (filedata
->file_header
.e_machine
)
13819 case EM_CYGNUS_MN10200
:
13821 return reloc_type
== 4; /* R_MN10200_24. */
13823 return reloc_type
== 5; /* R_FT32_20. */
13825 return reloc_type
== 5; /* R_Z80_24. */
13831 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13832 a 16-bit absolute RELA relocation used in DWARF debug sections. */
13835 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13837 /* Please keep this table alpha-sorted for ease of visual lookup. */
13838 switch (filedata
->file_header
.e_machine
)
13841 case EM_ARC_COMPACT
:
13842 case EM_ARC_COMPACT2
:
13843 return reloc_type
== 2; /* R_ARC_16. */
13844 case EM_ADAPTEVA_EPIPHANY
:
13845 return reloc_type
== 5;
13848 return reloc_type
== 4; /* R_AVR_16. */
13849 case EM_CYGNUS_D10V
:
13851 return reloc_type
== 3; /* R_D10V_16. */
13853 return reloc_type
== 2; /* R_FT32_16. */
13857 return reloc_type
== R_H8_DIR16
;
13860 return reloc_type
== 1; /* R_IP2K_16. */
13863 return reloc_type
== 1; /* R_M32C_16 */
13864 case EM_CYGNUS_MN10200
:
13866 return reloc_type
== 2; /* R_MN10200_16. */
13867 case EM_CYGNUS_MN10300
:
13869 return reloc_type
== 2; /* R_MN10300_16. */
13871 if (uses_msp430x_relocs (filedata
))
13872 return reloc_type
== 2; /* R_MSP430_ABS16. */
13873 /* Fall through. */
13874 case EM_MSP430_OLD
:
13875 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13877 return reloc_type
== 19; /* R_NDS32_RELA. */
13878 case EM_ALTERA_NIOS2
:
13879 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13881 return reloc_type
== 9; /* R_NIOS_16. */
13883 return reloc_type
== 2; /* R_OR1K_16. */
13885 return reloc_type
== 55; /* R_RISCV_SET16. */
13887 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13889 return reloc_type
== 2; /* R_C6000_ABS16. */
13891 return reloc_type
== 2; /* R_VISIUM_16. */
13894 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13896 return reloc_type
== 3; /* R_XGATE_16. */
13898 return reloc_type
== 4; /* R_Z80_16. */
13904 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13905 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13908 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13910 switch (filedata
->file_header
.e_machine
)
13913 return reloc_type
== 54; /* R_RISCV_SET8. */
13915 return reloc_type
== 1; /* R_Z80_8. */
13921 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13922 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13925 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13927 switch (filedata
->file_header
.e_machine
)
13930 return reloc_type
== 53; /* R_RISCV_SET6. */
13936 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13937 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13940 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13942 /* Please keep this table alpha-sorted for ease of visual lookup. */
13943 switch (filedata
->file_header
.e_machine
)
13946 return reloc_type
== 35; /* R_RISCV_ADD32. */
13952 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13953 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13956 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13958 /* Please keep this table alpha-sorted for ease of visual lookup. */
13959 switch (filedata
->file_header
.e_machine
)
13962 return reloc_type
== 39; /* R_RISCV_SUB32. */
13968 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13969 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13972 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13974 /* Please keep this table alpha-sorted for ease of visual lookup. */
13975 switch (filedata
->file_header
.e_machine
)
13978 return reloc_type
== 36; /* R_RISCV_ADD64. */
13984 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13985 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13988 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13990 /* Please keep this table alpha-sorted for ease of visual lookup. */
13991 switch (filedata
->file_header
.e_machine
)
13994 return reloc_type
== 40; /* R_RISCV_SUB64. */
14000 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14001 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
14004 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14006 /* Please keep this table alpha-sorted for ease of visual lookup. */
14007 switch (filedata
->file_header
.e_machine
)
14010 return reloc_type
== 34; /* R_RISCV_ADD16. */
14016 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14017 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
14020 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14022 /* Please keep this table alpha-sorted for ease of visual lookup. */
14023 switch (filedata
->file_header
.e_machine
)
14026 return reloc_type
== 38; /* R_RISCV_SUB16. */
14032 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14033 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
14036 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14038 /* Please keep this table alpha-sorted for ease of visual lookup. */
14039 switch (filedata
->file_header
.e_machine
)
14042 return reloc_type
== 33; /* R_RISCV_ADD8. */
14048 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14049 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
14052 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14054 /* Please keep this table alpha-sorted for ease of visual lookup. */
14055 switch (filedata
->file_header
.e_machine
)
14058 return reloc_type
== 37; /* R_RISCV_SUB8. */
14064 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14065 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
14068 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14070 switch (filedata
->file_header
.e_machine
)
14073 return reloc_type
== 52; /* R_RISCV_SUB6. */
14079 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
14080 relocation entries (possibly formerly used for SHT_GROUP sections). */
14083 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14085 switch (filedata
->file_header
.e_machine
)
14087 case EM_386
: /* R_386_NONE. */
14088 case EM_68K
: /* R_68K_NONE. */
14089 case EM_ADAPTEVA_EPIPHANY
:
14090 case EM_ALPHA
: /* R_ALPHA_NONE. */
14091 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
14092 case EM_ARC
: /* R_ARC_NONE. */
14093 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
14094 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
14095 case EM_ARM
: /* R_ARM_NONE. */
14096 case EM_C166
: /* R_XC16X_NONE. */
14097 case EM_CRIS
: /* R_CRIS_NONE. */
14098 case EM_FT32
: /* R_FT32_NONE. */
14099 case EM_IA_64
: /* R_IA64_NONE. */
14100 case EM_K1OM
: /* R_X86_64_NONE. */
14101 case EM_L1OM
: /* R_X86_64_NONE. */
14102 case EM_M32R
: /* R_M32R_NONE. */
14103 case EM_MIPS
: /* R_MIPS_NONE. */
14104 case EM_MN10300
: /* R_MN10300_NONE. */
14105 case EM_MOXIE
: /* R_MOXIE_NONE. */
14106 case EM_NIOS32
: /* R_NIOS_NONE. */
14107 case EM_OR1K
: /* R_OR1K_NONE. */
14108 case EM_PARISC
: /* R_PARISC_NONE. */
14109 case EM_PPC64
: /* R_PPC64_NONE. */
14110 case EM_PPC
: /* R_PPC_NONE. */
14111 case EM_RISCV
: /* R_RISCV_NONE. */
14112 case EM_S390
: /* R_390_NONE. */
14114 case EM_SH
: /* R_SH_NONE. */
14115 case EM_SPARC32PLUS
:
14116 case EM_SPARC
: /* R_SPARC_NONE. */
14118 case EM_TILEGX
: /* R_TILEGX_NONE. */
14119 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
14120 case EM_TI_C6000
:/* R_C6000_NONE. */
14121 case EM_X86_64
: /* R_X86_64_NONE. */
14123 case EM_Z80
: /* R_Z80_NONE. */
14124 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
14125 return reloc_type
== 0;
14128 return reloc_type
== 0 || reloc_type
== 256;
14131 return (reloc_type
== 0 /* R_AVR_NONE. */
14132 || reloc_type
== 30 /* R_AVR_DIFF8. */
14133 || reloc_type
== 31 /* R_AVR_DIFF16. */
14134 || reloc_type
== 32 /* R_AVR_DIFF32. */);
14136 return reloc_type
== 3; /* R_METAG_NONE. */
14138 return (reloc_type
== 0 /* R_XTENSA_NONE. */
14139 || reloc_type
== 204 /* R_NDS32_DIFF8. */
14140 || reloc_type
== 205 /* R_NDS32_DIFF16. */
14141 || reloc_type
== 206 /* R_NDS32_DIFF32. */
14142 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
14144 return (reloc_type
== 0 /* R_PRU_NONE. */
14145 || reloc_type
== 65 /* R_PRU_DIFF8. */
14146 || reloc_type
== 66 /* R_PRU_DIFF16. */
14147 || reloc_type
== 67 /* R_PRU_DIFF32. */);
14148 case EM_XTENSA_OLD
:
14150 return (reloc_type
== 0 /* R_XTENSA_NONE. */
14151 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
14152 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
14153 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
14154 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
14155 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
14156 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
14157 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
14158 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
14159 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
14164 /* Returns TRUE if there is a relocation against
14165 section NAME at OFFSET bytes. */
14168 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
14170 Elf_Internal_Rela
* relocs
;
14171 Elf_Internal_Rela
* rp
;
14173 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
14176 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
14178 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
14179 if (rp
->r_offset
== offset
)
14185 /* Apply relocations to a section.
14186 Returns TRUE upon success, FALSE otherwise.
14187 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
14188 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
14189 will be set to the number of relocs loaded.
14191 Note: So far support has been added only for those relocations
14192 which can be found in debug sections. FIXME: Add support for
14193 more relocations ? */
14196 apply_relocations (Filedata
* filedata
,
14197 const Elf_Internal_Shdr
* section
,
14198 unsigned char * start
,
14199 bfd_size_type size
,
14200 void ** relocs_return
,
14201 unsigned long * num_relocs_return
)
14203 Elf_Internal_Shdr
* relsec
;
14204 unsigned char * end
= start
+ size
;
14206 if (relocs_return
!= NULL
)
14208 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
14209 * num_relocs_return
= 0;
14212 if (filedata
->file_header
.e_type
!= ET_REL
)
14213 /* No relocs to apply. */
14216 /* Find the reloc section associated with the section. */
14217 for (relsec
= filedata
->section_headers
;
14218 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14222 unsigned long num_relocs
;
14223 Elf_Internal_Rela
* relocs
;
14224 Elf_Internal_Rela
* rp
;
14225 Elf_Internal_Shdr
* symsec
;
14226 Elf_Internal_Sym
* symtab
;
14227 unsigned long num_syms
;
14228 Elf_Internal_Sym
* sym
;
14230 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14231 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14232 || filedata
->section_headers
+ relsec
->sh_info
!= section
14233 || relsec
->sh_size
== 0
14234 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14237 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
14238 if (symsec
->sh_type
!= SHT_SYMTAB
14239 && symsec
->sh_type
!= SHT_DYNSYM
)
14242 is_rela
= relsec
->sh_type
== SHT_RELA
;
14246 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
14247 relsec
->sh_size
, & relocs
, & num_relocs
))
14252 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
14253 relsec
->sh_size
, & relocs
, & num_relocs
))
14257 /* SH uses RELA but uses in place value instead of the addend field. */
14258 if (filedata
->file_header
.e_machine
== EM_SH
)
14261 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
14263 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
14266 unsigned int reloc_type
;
14267 unsigned int reloc_size
;
14268 bool reloc_inplace
= false;
14269 bool reloc_subtract
= false;
14270 unsigned char *rloc
;
14271 unsigned long sym_index
;
14273 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
14275 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
14277 else if (is_none_reloc (filedata
, reloc_type
))
14279 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
14280 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
14282 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
14283 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
14285 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
14287 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
14289 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
14290 || is_6bit_abs_reloc (filedata
, reloc_type
))
14292 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
14294 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
14297 reloc_inplace
= true;
14299 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
14301 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
14304 reloc_inplace
= true;
14306 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
14308 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
14311 reloc_inplace
= true;
14313 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
14315 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
14318 reloc_inplace
= true;
14320 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
14324 reloc_inplace
= true;
14328 static unsigned int prev_reloc
= 0;
14330 if (reloc_type
!= prev_reloc
)
14331 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
14332 reloc_type
, printable_section_name (filedata
, section
));
14333 prev_reloc
= reloc_type
;
14337 rloc
= start
+ rp
->r_offset
;
14338 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
14340 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
14341 (unsigned long) rp
->r_offset
,
14342 printable_section_name (filedata
, section
));
14346 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
14347 if (sym_index
>= num_syms
)
14349 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
14350 sym_index
, printable_section_name (filedata
, section
));
14353 sym
= symtab
+ sym_index
;
14355 /* If the reloc has a symbol associated with it,
14356 make sure that it is of an appropriate type.
14358 Relocations against symbols without type can happen.
14359 Gcc -feliminate-dwarf2-dups may generate symbols
14360 without type for debug info.
14362 Icc generates relocations against function symbols
14363 instead of local labels.
14365 Relocations against object symbols can happen, eg when
14366 referencing a global array. For an example of this see
14367 the _clz.o binary in libgcc.a. */
14369 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
14370 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
14372 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
14373 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
14374 printable_section_name (filedata
, relsec
),
14375 (long int)(rp
- relocs
));
14381 addend
+= rp
->r_addend
;
14382 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
14383 partial_inplace. */
14385 || (filedata
->file_header
.e_machine
== EM_XTENSA
14386 && reloc_type
== 1)
14387 || ((filedata
->file_header
.e_machine
== EM_PJ
14388 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
14389 && reloc_type
== 1)
14390 || ((filedata
->file_header
.e_machine
== EM_D30V
14391 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
14392 && reloc_type
== 12)
14395 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
14396 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
14398 addend
+= byte_get (rloc
, reloc_size
);
14401 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
14402 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
14404 /* On HPPA, all pc-relative relocations are biased by 8. */
14405 if (filedata
->file_header
.e_machine
== EM_PARISC
)
14407 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
14410 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
14411 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
14413 if (reloc_subtract
)
14414 addend
-= sym
->st_value
;
14416 addend
+= sym
->st_value
;
14417 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
14418 byte_put (rloc
, addend
, reloc_size
);
14420 else if (reloc_subtract
)
14421 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
14423 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
14427 /* Let the target specific reloc processing code know that
14428 we have finished with these relocs. */
14429 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
14433 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
14434 * num_relocs_return
= num_relocs
;
14445 #ifdef SUPPORT_DISASSEMBLY
14447 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14449 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
14451 /* FIXME: XXX -- to be done --- XXX */
14457 /* Reads in the contents of SECTION from FILE, returning a pointer
14458 to a malloc'ed buffer or NULL if something went wrong. */
14461 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14463 bfd_size_type num_bytes
= section
->sh_size
;
14465 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
14467 printf (_("Section '%s' has no data to dump.\n"),
14468 printable_section_name (filedata
, section
));
14472 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
14473 _("section contents"));
14476 /* Uncompresses a section that was compressed using zlib, in place. */
14479 uncompress_section_contents (unsigned char ** buffer
,
14480 dwarf_size_type uncompressed_size
,
14481 dwarf_size_type
* size
)
14483 dwarf_size_type compressed_size
= *size
;
14484 unsigned char * compressed_buffer
= *buffer
;
14485 unsigned char * uncompressed_buffer
;
14489 /* It is possible the section consists of several compressed
14490 buffers concatenated together, so we uncompress in a loop. */
14491 /* PR 18313: The state field in the z_stream structure is supposed
14492 to be invisible to the user (ie us), but some compilers will
14493 still complain about it being used without initialisation. So
14494 we first zero the entire z_stream structure and then set the fields
14496 memset (& strm
, 0, sizeof strm
);
14497 strm
.avail_in
= compressed_size
;
14498 strm
.next_in
= (Bytef
*) compressed_buffer
;
14499 strm
.avail_out
= uncompressed_size
;
14500 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
14502 rc
= inflateInit (& strm
);
14503 while (strm
.avail_in
> 0)
14507 strm
.next_out
= ((Bytef
*) uncompressed_buffer
14508 + (uncompressed_size
- strm
.avail_out
));
14509 rc
= inflate (&strm
, Z_FINISH
);
14510 if (rc
!= Z_STREAM_END
)
14512 rc
= inflateReset (& strm
);
14514 if (inflateEnd (& strm
) != Z_OK
14516 || strm
.avail_out
!= 0)
14519 *buffer
= uncompressed_buffer
;
14520 *size
= uncompressed_size
;
14524 free (uncompressed_buffer
);
14525 /* Indicate decompression failure. */
14531 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14533 Elf_Internal_Shdr
*relsec
;
14534 bfd_size_type num_bytes
;
14535 unsigned char *data
;
14536 unsigned char *end
;
14537 unsigned char *real_start
;
14538 unsigned char *start
;
14539 bool some_strings_shown
;
14541 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
14543 /* PR 21820: Do not fail if the section was empty. */
14544 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
14546 num_bytes
= section
->sh_size
;
14548 if (filedata
->is_separate
)
14549 printf (_("\nString dump of section '%s' in linked file %s:\n"),
14550 printable_section_name (filedata
, section
),
14551 filedata
->file_name
);
14553 printf (_("\nString dump of section '%s':\n"),
14554 printable_section_name (filedata
, section
));
14556 if (decompress_dumps
)
14558 dwarf_size_type new_size
= num_bytes
;
14559 dwarf_size_type uncompressed_size
= 0;
14561 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14563 Elf_Internal_Chdr chdr
;
14564 unsigned int compression_header_size
14565 = get_compression_header (& chdr
, (unsigned char *) start
,
14567 if (compression_header_size
== 0)
14568 /* An error message will have already been generated
14569 by get_compression_header. */
14572 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14574 warn (_("section '%s' has unsupported compress type: %d\n"),
14575 printable_section_name (filedata
, section
), chdr
.ch_type
);
14578 uncompressed_size
= chdr
.ch_size
;
14579 start
+= compression_header_size
;
14580 new_size
-= compression_header_size
;
14582 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14584 /* Read the zlib header. In this case, it should be "ZLIB"
14585 followed by the uncompressed section size, 8 bytes in
14586 big-endian order. */
14587 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14588 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14589 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14590 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14591 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14592 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14593 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14594 uncompressed_size
+= start
[11];
14599 if (uncompressed_size
)
14601 if (uncompress_section_contents (& start
,
14602 uncompressed_size
, & new_size
))
14603 num_bytes
= new_size
;
14606 error (_("Unable to decompress section %s\n"),
14607 printable_section_name (filedata
, section
));
14612 start
= real_start
;
14615 /* If the section being dumped has relocations against it the user might
14616 be expecting these relocations to have been applied. Check for this
14617 case and issue a warning message in order to avoid confusion.
14618 FIXME: Maybe we ought to have an option that dumps a section with
14619 relocs applied ? */
14620 for (relsec
= filedata
->section_headers
;
14621 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14624 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14625 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14626 || filedata
->section_headers
+ relsec
->sh_info
!= section
14627 || relsec
->sh_size
== 0
14628 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14631 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14636 end
= start
+ num_bytes
;
14637 some_strings_shown
= false;
14639 #ifdef HAVE_MBSTATE_T
14641 /* Initialise the multibyte conversion state. */
14642 memset (& state
, 0, sizeof (state
));
14645 bool continuing
= false;
14649 while (!ISPRINT (* data
))
14650 if (++ data
>= end
)
14655 size_t maxlen
= end
- data
;
14660 continuing
= false;
14664 printf (" [%6lx] ", (unsigned long) (data
- start
));
14678 /* PR 25543: Treat new-lines as string-ending characters. */
14687 /* Do not print control characters directly as they can affect terminal
14688 settings. Such characters usually appear in the names generated
14689 by the assembler for local labels. */
14692 printf ("^%c", c
+ 0x40);
14694 else if (ISPRINT (c
))
14701 #ifdef HAVE_MBSTATE_T
14704 /* Let printf do the hard work of displaying multibyte characters. */
14705 printf ("%.1s", data
- 1);
14706 #ifdef HAVE_MBSTATE_T
14707 /* Try to find out how many bytes made up the character that was
14708 just printed. Advance the symbol pointer past the bytes that
14710 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
14714 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
14724 printf (_("<corrupt>\n"));
14727 some_strings_shown
= true;
14731 if (! some_strings_shown
)
14732 printf (_(" No strings found in this section."));
14745 dump_section_as_bytes (Elf_Internal_Shdr
*section
,
14746 Filedata
*filedata
,
14749 Elf_Internal_Shdr
* relsec
;
14750 bfd_size_type bytes
;
14751 bfd_size_type section_size
;
14753 unsigned char * data
;
14754 unsigned char * real_start
;
14755 unsigned char * start
;
14757 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
14759 /* PR 21820: Do not fail if the section was empty. */
14760 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
14762 section_size
= section
->sh_size
;
14764 if (filedata
->is_separate
)
14765 printf (_("\nHex dump of section '%s' in linked file %s:\n"),
14766 printable_section_name (filedata
, section
),
14767 filedata
->file_name
);
14769 printf (_("\nHex dump of section '%s':\n"),
14770 printable_section_name (filedata
, section
));
14772 if (decompress_dumps
)
14774 dwarf_size_type new_size
= section_size
;
14775 dwarf_size_type uncompressed_size
= 0;
14777 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14779 Elf_Internal_Chdr chdr
;
14780 unsigned int compression_header_size
14781 = get_compression_header (& chdr
, start
, section_size
);
14783 if (compression_header_size
== 0)
14784 /* An error message will have already been generated
14785 by get_compression_header. */
14788 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14790 warn (_("section '%s' has unsupported compress type: %d\n"),
14791 printable_section_name (filedata
, section
), chdr
.ch_type
);
14794 uncompressed_size
= chdr
.ch_size
;
14795 start
+= compression_header_size
;
14796 new_size
-= compression_header_size
;
14798 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14800 /* Read the zlib header. In this case, it should be "ZLIB"
14801 followed by the uncompressed section size, 8 bytes in
14802 big-endian order. */
14803 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14804 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14805 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14806 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14807 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14808 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14809 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14810 uncompressed_size
+= start
[11];
14815 if (uncompressed_size
)
14817 if (uncompress_section_contents (& start
, uncompressed_size
,
14820 section_size
= new_size
;
14824 error (_("Unable to decompress section %s\n"),
14825 printable_section_name (filedata
, section
));
14826 /* FIXME: Print the section anyway ? */
14831 start
= real_start
;
14836 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
14841 /* If the section being dumped has relocations against it the user might
14842 be expecting these relocations to have been applied. Check for this
14843 case and issue a warning message in order to avoid confusion.
14844 FIXME: Maybe we ought to have an option that dumps a section with
14845 relocs applied ? */
14846 for (relsec
= filedata
->section_headers
;
14847 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14850 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14851 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14852 || filedata
->section_headers
+ relsec
->sh_info
!= section
14853 || relsec
->sh_size
== 0
14854 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14857 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14862 addr
= section
->sh_addr
;
14863 bytes
= section_size
;
14872 lbytes
= (bytes
> 16 ? 16 : bytes
);
14874 printf (" 0x%8.8lx ", (unsigned long) addr
);
14876 for (j
= 0; j
< 16; j
++)
14879 printf ("%2.2x", data
[j
]);
14887 for (j
= 0; j
< lbytes
; j
++)
14890 if (k
>= ' ' && k
< 0x7f)
14913 #ifdef ENABLE_LIBCTF
14914 static ctf_sect_t
*
14915 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14917 buf
->cts_name
= SECTION_NAME_PRINT (shdr
);
14918 buf
->cts_size
= shdr
->sh_size
;
14919 buf
->cts_entsize
= shdr
->sh_entsize
;
14924 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14925 it is passed, or a pointer to newly-allocated storage, in which case
14926 dump_ctf() will free it when it no longer needs it. */
14929 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14930 char *s
, void *arg
)
14932 const char *blanks
= arg
;
14935 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14940 /* Dump CTF errors/warnings. */
14942 dump_ctf_errs (ctf_dict_t
*fp
)
14944 ctf_next_t
*it
= NULL
;
14949 /* Dump accumulated errors and warnings. */
14950 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
14952 error (_("%s: %s"), is_warning
? _("warning"): _("error"),
14956 if (err
!= ECTF_NEXT_END
)
14957 error (_("CTF error: cannot get CTF errors: `%s'"), ctf_errmsg (err
));
14960 /* Dump one CTF archive member. */
14963 dump_ctf_archive_member (ctf_dict_t
*ctf
, const char *name
, void *arg
)
14965 ctf_dict_t
*parent
= (ctf_dict_t
*) arg
;
14966 const char *things
[] = {"Header", "Labels", "Data objects",
14967 "Function objects", "Variables", "Types", "Strings",
14969 const char **thing
;
14973 /* Only print out the name of non-default-named archive members.
14974 The name .ctf appears everywhere, even for things that aren't
14975 really archives, so printing it out is liable to be confusing.
14977 The parent, if there is one, is the default-owned archive member:
14978 avoid importing it into itself. (This does no harm, but looks
14981 if (strcmp (name
, ".ctf") != 0)
14983 printf (_("\nCTF archive member: %s:\n"), name
);
14984 ctf_import (ctf
, parent
);
14987 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14989 ctf_dump_state_t
*s
= NULL
;
14992 printf ("\n %s:\n", *thing
);
14993 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14994 (void *) " ")) != NULL
)
14996 printf ("%s\n", item
);
15000 if (ctf_errno (ctf
))
15002 error (_("Iteration failed: %s, %s\n"), *thing
,
15003 ctf_errmsg (ctf_errno (ctf
)));
15010 dump_ctf_errs (ctf
);
15015 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15017 Elf_Internal_Shdr
* parent_sec
= NULL
;
15018 Elf_Internal_Shdr
* symtab_sec
= NULL
;
15019 Elf_Internal_Shdr
* strtab_sec
= NULL
;
15020 void * data
= NULL
;
15021 void * symdata
= NULL
;
15022 void * strdata
= NULL
;
15023 void * parentdata
= NULL
;
15024 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
15025 ctf_sect_t
* symsectp
= NULL
;
15026 ctf_sect_t
* strsectp
= NULL
;
15027 ctf_archive_t
* ctfa
= NULL
;
15028 ctf_archive_t
* parenta
= NULL
, *lookparent
;
15029 ctf_dict_t
* parent
= NULL
;
15034 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
15035 data
= get_section_contents (section
, filedata
);
15036 ctfsect
.cts_data
= data
;
15038 if (!dump_ctf_symtab_name
)
15039 dump_ctf_symtab_name
= strdup (".dynsym");
15041 if (!dump_ctf_strtab_name
)
15042 dump_ctf_strtab_name
= strdup (".dynstr");
15044 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
15046 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
15048 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
15051 if ((symdata
= (void *) get_data (NULL
, filedata
,
15052 symtab_sec
->sh_offset
, 1,
15053 symtab_sec
->sh_size
,
15054 _("symbols"))) == NULL
)
15056 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
15057 symsect
.cts_data
= symdata
;
15060 if (dump_ctf_strtab_name
&& dump_ctf_strtab_name
[0] != 0)
15062 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
15064 error (_("No string table section named %s\n"),
15065 dump_ctf_strtab_name
);
15068 if ((strdata
= (void *) get_data (NULL
, filedata
,
15069 strtab_sec
->sh_offset
, 1,
15070 strtab_sec
->sh_size
,
15071 _("strings"))) == NULL
)
15073 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
15074 strsect
.cts_data
= strdata
;
15077 if (dump_ctf_parent_name
)
15079 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
15081 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
15084 if ((parentdata
= (void *) get_data (NULL
, filedata
,
15085 parent_sec
->sh_offset
, 1,
15086 parent_sec
->sh_size
,
15087 _("CTF parent"))) == NULL
)
15089 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
15090 parentsect
.cts_data
= parentdata
;
15093 /* Load the CTF file and dump it. It may be a raw CTF section, or an archive:
15094 libctf papers over the difference, so we can pretend it is always an
15095 archive. Possibly open the parent as well, if one was specified. */
15097 if ((ctfa
= ctf_arc_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
15099 dump_ctf_errs (NULL
);
15100 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15104 ctf_arc_symsect_endianness (ctfa
, filedata
->file_header
.e_ident
[EI_DATA
]
15109 if ((parenta
= ctf_arc_bufopen (&parentsect
, symsectp
, strsectp
,
15112 dump_ctf_errs (NULL
);
15113 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15116 lookparent
= parenta
;
15121 /* Assume that the applicable parent archive member is the default one.
15122 (This is what all known implementations are expected to do, if they
15123 put CTFs and their parents in archives together.) */
15124 if ((parent
= ctf_dict_open (lookparent
, NULL
, &err
)) == NULL
)
15126 dump_ctf_errs (NULL
);
15127 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15133 if (filedata
->is_separate
)
15134 printf (_("\nDump of CTF section '%s' in linked file %s:\n"),
15135 printable_section_name (filedata
, section
),
15136 filedata
->file_name
);
15138 printf (_("\nDump of CTF section '%s':\n"),
15139 printable_section_name (filedata
, section
));
15141 if ((err
= ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
)) != 0)
15143 dump_ctf_errs (NULL
);
15144 error (_("CTF member open failure: %s\n"), ctf_errmsg (err
));
15149 ctf_dict_close (parent
);
15151 ctf_close (parenta
);
15161 load_specific_debug_section (enum dwarf_section_display_enum debug
,
15162 const Elf_Internal_Shdr
* sec
,
15165 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15167 Filedata
* filedata
= (Filedata
*) data
;
15169 if (section
->start
!= NULL
)
15171 /* If it is already loaded, do nothing. */
15172 if (streq (section
->filename
, filedata
->file_name
))
15174 free (section
->start
);
15177 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
15178 section
->address
= sec
->sh_addr
;
15179 section
->filename
= filedata
->file_name
;
15180 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
15182 sec
->sh_size
, buf
);
15183 if (section
->start
== NULL
)
15187 unsigned char *start
= section
->start
;
15188 dwarf_size_type size
= sec
->sh_size
;
15189 dwarf_size_type uncompressed_size
= 0;
15191 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
15193 Elf_Internal_Chdr chdr
;
15194 unsigned int compression_header_size
;
15196 if (size
< (is_32bit_elf
15197 ? sizeof (Elf32_External_Chdr
)
15198 : sizeof (Elf64_External_Chdr
)))
15200 warn (_("compressed section %s is too small to contain a compression header\n"),
15205 compression_header_size
= get_compression_header (&chdr
, start
, size
);
15206 if (compression_header_size
== 0)
15207 /* An error message will have already been generated
15208 by get_compression_header. */
15211 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
15213 warn (_("section '%s' has unsupported compress type: %d\n"),
15214 section
->name
, chdr
.ch_type
);
15217 uncompressed_size
= chdr
.ch_size
;
15218 start
+= compression_header_size
;
15219 size
-= compression_header_size
;
15221 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
15223 /* Read the zlib header. In this case, it should be "ZLIB"
15224 followed by the uncompressed section size, 8 bytes in
15225 big-endian order. */
15226 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
15227 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
15228 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
15229 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
15230 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
15231 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
15232 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
15233 uncompressed_size
+= start
[11];
15238 if (uncompressed_size
)
15240 if (uncompress_section_contents (&start
, uncompressed_size
,
15243 /* Free the compressed buffer, update the section buffer
15244 and the section size if uncompress is successful. */
15245 free (section
->start
);
15246 section
->start
= start
;
15250 error (_("Unable to decompress section %s\n"),
15251 printable_section_name (filedata
, sec
));
15256 section
->size
= size
;
15259 if (section
->start
== NULL
)
15262 if (debug_displays
[debug
].relocate
)
15264 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
15265 & section
->reloc_info
, & section
->num_relocs
))
15270 section
->reloc_info
= NULL
;
15271 section
->num_relocs
= 0;
15277 #if HAVE_LIBDEBUGINFOD
15278 /* Return a hex string representation of the build-id. */
15280 get_build_id (void * data
)
15282 Filedata
* filedata
= (Filedata
*) data
;
15283 Elf_Internal_Shdr
* shdr
;
15286 /* Iterate through notes to find note.gnu.build-id.
15287 FIXME: Only the first note in any note section is examined. */
15288 for (i
= 0, shdr
= filedata
->section_headers
;
15289 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
15292 if (shdr
->sh_type
!= SHT_NOTE
)
15297 size_t data_remaining
;
15299 Elf_External_Note
* enote
;
15300 Elf_Internal_Note inote
;
15302 bfd_vma offset
= shdr
->sh_offset
;
15303 bfd_vma align
= shdr
->sh_addralign
;
15304 bfd_vma length
= shdr
->sh_size
;
15306 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
15312 else if (align
!= 4 && align
!= 8)
15318 end
= (char *) enote
+ length
;
15319 data_remaining
= end
- (char *) enote
;
15321 if (!is_ia64_vms (filedata
))
15323 min_notesz
= offsetof (Elf_External_Note
, name
);
15324 if (data_remaining
< min_notesz
)
15327 malformed note encountered in section %s whilst scanning for build-id note\n"),
15328 printable_section_name (filedata
, shdr
));
15332 data_remaining
-= min_notesz
;
15334 inote
.type
= BYTE_GET (enote
->type
);
15335 inote
.namesz
= BYTE_GET (enote
->namesz
);
15336 inote
.namedata
= enote
->name
;
15337 inote
.descsz
= BYTE_GET (enote
->descsz
);
15338 inote
.descdata
= ((char *) enote
15339 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
15340 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
15341 next
= ((char *) enote
15342 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
15346 Elf64_External_VMS_Note
*vms_enote
;
15348 /* PR binutils/15191
15349 Make sure that there is enough data to read. */
15350 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
15351 if (data_remaining
< min_notesz
)
15354 malformed note encountered in section %s whilst scanning for build-id note\n"),
15355 printable_section_name (filedata
, shdr
));
15359 data_remaining
-= min_notesz
;
15361 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
15362 inote
.type
= BYTE_GET (vms_enote
->type
);
15363 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
15364 inote
.namedata
= vms_enote
->name
;
15365 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
15366 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
15367 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
15368 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
15371 /* Skip malformed notes. */
15372 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
15373 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
15374 || (size_t) (next
- inote
.descdata
) < inote
.descsz
15375 || ((size_t) (next
- inote
.descdata
)
15376 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
15379 malformed note encountered in section %s whilst scanning for build-id note\n"),
15380 printable_section_name (filedata
, shdr
));
15385 /* Check if this is the build-id note. If so then convert the build-id
15386 bytes to a hex string. */
15387 if (inote
.namesz
> 0
15388 && startswith (inote
.namedata
, "GNU")
15389 && inote
.type
== NT_GNU_BUILD_ID
)
15394 build_id
= malloc (inote
.descsz
* 2 + 1);
15395 if (build_id
== NULL
)
15401 for (j
= 0; j
< inote
.descsz
; ++j
)
15402 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
15403 build_id
[inote
.descsz
* 2] = '\0';
15406 return (unsigned char *) build_id
;
15413 #endif /* HAVE_LIBDEBUGINFOD */
15415 /* If this is not NULL, load_debug_section will only look for sections
15416 within the list of sections given here. */
15417 static unsigned int * section_subset
= NULL
;
15420 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
15422 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15423 Elf_Internal_Shdr
* sec
;
15424 Filedata
* filedata
= (Filedata
*) data
;
15426 /* Without section headers we cannot find any sections. */
15427 if (filedata
->section_headers
== NULL
)
15430 if (filedata
->string_table
== NULL
15431 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
15432 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
15434 Elf_Internal_Shdr
* strs
;
15436 /* Read in the string table, so that we have section names to scan. */
15437 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
15439 if (strs
!= NULL
&& strs
->sh_size
!= 0)
15441 filedata
->string_table
15442 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
15443 1, strs
->sh_size
, _("string table"));
15445 filedata
->string_table_length
15446 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
15450 /* Locate the debug section. */
15451 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
15453 section
->name
= section
->uncompressed_name
;
15456 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
15458 section
->name
= section
->compressed_name
;
15463 /* If we're loading from a subset of sections, and we've loaded
15464 a section matching this name before, it's likely that it's a
15466 if (section_subset
!= NULL
)
15467 free_debug_section (debug
);
15469 return load_specific_debug_section (debug
, sec
, data
);
15473 free_debug_section (enum dwarf_section_display_enum debug
)
15475 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15477 if (section
->start
== NULL
)
15480 free ((char *) section
->start
);
15481 section
->start
= NULL
;
15482 section
->address
= 0;
15485 free (section
->reloc_info
);
15486 section
->reloc_info
= NULL
;
15487 section
->num_relocs
= 0;
15491 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15493 char * name
= SECTION_NAME_VALID (section
) ? SECTION_NAME (section
) : "";
15494 const char * print_name
= printable_section_name (filedata
, section
);
15495 bfd_size_type length
;
15496 bool result
= true;
15499 length
= section
->sh_size
;
15502 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
15505 if (section
->sh_type
== SHT_NOBITS
)
15507 /* There is no point in dumping the contents of a debugging section
15508 which has the NOBITS type - the bits in the file will be random.
15509 This can happen when a file containing a .eh_frame section is
15510 stripped with the --only-keep-debug command line option. */
15511 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
15516 if (startswith (name
, ".gnu.linkonce.wi."))
15517 name
= ".debug_info";
15519 /* See if we know how to display the contents of this section. */
15520 for (i
= 0; i
< max
; i
++)
15522 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
15523 struct dwarf_section_display
* display
= debug_displays
+ i
;
15524 struct dwarf_section
* sec
= & display
->section
;
15526 if (streq (sec
->uncompressed_name
, name
)
15527 || (id
== line
&& startswith (name
, ".debug_line."))
15528 || streq (sec
->compressed_name
, name
))
15530 bool secondary
= (section
!= find_section (filedata
, name
));
15533 free_debug_section (id
);
15535 if (i
== line
&& startswith (name
, ".debug_line."))
15537 else if (streq (sec
->uncompressed_name
, name
))
15538 sec
->name
= sec
->uncompressed_name
;
15540 sec
->name
= sec
->compressed_name
;
15542 if (load_specific_debug_section (id
, section
, filedata
))
15544 /* If this debug section is part of a CU/TU set in a .dwp file,
15545 restrict load_debug_section to the sections in that set. */
15546 section_subset
= find_cu_tu_set (filedata
, shndx
);
15548 result
&= display
->display (sec
, filedata
);
15550 section_subset
= NULL
;
15552 if (secondary
|| (id
!= info
&& id
!= abbrev
&& id
!= debug_addr
))
15553 free_debug_section (id
);
15561 printf (_("Unrecognized debug section: %s\n"), print_name
);
15568 /* Set DUMP_SECTS for all sections where dumps were requested
15569 based on section name. */
15572 initialise_dumps_byname (Filedata
* filedata
)
15574 struct dump_list_entry
* cur
;
15576 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
15581 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
15582 if (SECTION_NAME_VALID (filedata
->section_headers
+ i
)
15583 && streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
15585 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
15589 if (!any
&& !filedata
->is_separate
)
15590 warn (_("Section '%s' was not dumped because it does not exist\n"),
15596 process_section_contents (Filedata
* filedata
)
15598 Elf_Internal_Shdr
* section
;
15605 initialise_dumps_byname (filedata
);
15607 for (i
= 0, section
= filedata
->section_headers
;
15608 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
15611 dump_type dump
= filedata
->dump
.dump_sects
[i
];
15613 if (filedata
->is_separate
&& ! process_links
)
15614 dump
&= DEBUG_DUMP
;
15616 #ifdef SUPPORT_DISASSEMBLY
15617 if (dump
& DISASS_DUMP
)
15619 if (! disassemble_section (section
, filedata
))
15623 if (dump
& HEX_DUMP
)
15625 if (! dump_section_as_bytes (section
, filedata
, false))
15629 if (dump
& RELOC_DUMP
)
15631 if (! dump_section_as_bytes (section
, filedata
, true))
15635 if (dump
& STRING_DUMP
)
15637 if (! dump_section_as_strings (section
, filedata
))
15641 if (dump
& DEBUG_DUMP
)
15643 if (! display_debug_section (i
, section
, filedata
))
15647 #ifdef ENABLE_LIBCTF
15648 if (dump
& CTF_DUMP
)
15650 if (! dump_section_as_ctf (section
, filedata
))
15656 if (! filedata
->is_separate
)
15658 /* Check to see if the user requested a
15659 dump of a section that does not exist. */
15660 for (; i
< filedata
->dump
.num_dump_sects
; i
++)
15661 if (filedata
->dump
.dump_sects
[i
])
15663 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
15672 process_mips_fpe_exception (int mask
)
15678 if (mask
& OEX_FPU_INEX
)
15679 fputs ("INEX", stdout
), first
= false;
15680 if (mask
& OEX_FPU_UFLO
)
15681 printf ("%sUFLO", first
? "" : "|"), first
= false;
15682 if (mask
& OEX_FPU_OFLO
)
15683 printf ("%sOFLO", first
? "" : "|"), first
= false;
15684 if (mask
& OEX_FPU_DIV0
)
15685 printf ("%sDIV0", first
? "" : "|"), first
= false;
15686 if (mask
& OEX_FPU_INVAL
)
15687 printf ("%sINVAL", first
? "" : "|");
15690 fputs ("0", stdout
);
15693 /* Display's the value of TAG at location P. If TAG is
15694 greater than 0 it is assumed to be an unknown tag, and
15695 a message is printed to this effect. Otherwise it is
15696 assumed that a message has already been printed.
15698 If the bottom bit of TAG is set it assumed to have a
15699 string value, otherwise it is assumed to have an integer
15702 Returns an updated P pointing to the first unread byte
15703 beyond the end of TAG's value.
15705 Reads at or beyond END will not be made. */
15707 static unsigned char *
15708 display_tag_value (signed int tag
,
15710 const unsigned char * const end
)
15715 printf (" Tag_unknown_%d: ", tag
);
15719 warn (_("<corrupt tag>\n"));
15723 /* PR 17531 file: 027-19978-0.004. */
15724 size_t maxlen
= (end
- p
) - 1;
15729 print_symbol ((int) maxlen
, (const char *) p
);
15730 p
+= strnlen ((char *) p
, maxlen
) + 1;
15734 printf (_("<corrupt string tag>"));
15735 p
= (unsigned char *) end
;
15741 READ_ULEB (val
, p
, end
);
15742 printf ("%ld (0x%lx)\n", val
, val
);
15749 /* ARC ABI attributes section. */
15751 static unsigned char *
15752 display_arc_attribute (unsigned char * p
,
15753 const unsigned char * const end
)
15758 READ_ULEB (tag
, p
, end
);
15762 case Tag_ARC_PCS_config
:
15763 READ_ULEB (val
, p
, end
);
15764 printf (" Tag_ARC_PCS_config: ");
15768 printf (_("Absent/Non standard\n"));
15771 printf (_("Bare metal/mwdt\n"));
15774 printf (_("Bare metal/newlib\n"));
15777 printf (_("Linux/uclibc\n"));
15780 printf (_("Linux/glibc\n"));
15783 printf (_("Unknown\n"));
15788 case Tag_ARC_CPU_base
:
15789 READ_ULEB (val
, p
, end
);
15790 printf (" Tag_ARC_CPU_base: ");
15795 printf (_("Absent\n"));
15797 case TAG_CPU_ARC6xx
:
15798 printf ("ARC6xx\n");
15800 case TAG_CPU_ARC7xx
:
15801 printf ("ARC7xx\n");
15803 case TAG_CPU_ARCEM
:
15804 printf ("ARCEM\n");
15806 case TAG_CPU_ARCHS
:
15807 printf ("ARCHS\n");
15812 case Tag_ARC_CPU_variation
:
15813 READ_ULEB (val
, p
, end
);
15814 printf (" Tag_ARC_CPU_variation: ");
15818 if (val
> 0 && val
< 16)
15819 printf ("Core%d\n", val
);
15821 printf ("Unknown\n");
15825 printf (_("Absent\n"));
15830 case Tag_ARC_CPU_name
:
15831 printf (" Tag_ARC_CPU_name: ");
15832 p
= display_tag_value (-1, p
, end
);
15835 case Tag_ARC_ABI_rf16
:
15836 READ_ULEB (val
, p
, end
);
15837 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
15840 case Tag_ARC_ABI_osver
:
15841 READ_ULEB (val
, p
, end
);
15842 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
15845 case Tag_ARC_ABI_pic
:
15846 case Tag_ARC_ABI_sda
:
15847 READ_ULEB (val
, p
, end
);
15848 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
15849 : " Tag_ARC_ABI_pic: ");
15853 printf (_("Absent\n"));
15862 printf (_("Unknown\n"));
15867 case Tag_ARC_ABI_tls
:
15868 READ_ULEB (val
, p
, end
);
15869 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
15872 case Tag_ARC_ABI_enumsize
:
15873 READ_ULEB (val
, p
, end
);
15874 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
15878 case Tag_ARC_ABI_exceptions
:
15879 READ_ULEB (val
, p
, end
);
15880 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
15884 case Tag_ARC_ABI_double_size
:
15885 READ_ULEB (val
, p
, end
);
15886 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
15889 case Tag_ARC_ISA_config
:
15890 printf (" Tag_ARC_ISA_config: ");
15891 p
= display_tag_value (-1, p
, end
);
15894 case Tag_ARC_ISA_apex
:
15895 printf (" Tag_ARC_ISA_apex: ");
15896 p
= display_tag_value (-1, p
, end
);
15899 case Tag_ARC_ISA_mpy_option
:
15900 READ_ULEB (val
, p
, end
);
15901 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
15904 case Tag_ARC_ATR_version
:
15905 READ_ULEB (val
, p
, end
);
15906 printf (" Tag_ARC_ATR_version: %d\n", val
);
15910 return display_tag_value (tag
& 1, p
, end
);
15916 /* ARM EABI attributes section. */
15921 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
15923 const char *const *table
;
15924 } arm_attr_public_tag
;
15926 static const char *const arm_attr_tag_CPU_arch
[] =
15927 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
15928 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
15929 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
15930 static const char *const arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
15931 static const char *const arm_attr_tag_THUMB_ISA_use
[] =
15932 {"No", "Thumb-1", "Thumb-2", "Yes"};
15933 static const char *const arm_attr_tag_FP_arch
[] =
15934 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
15935 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
15936 static const char *const arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
15937 static const char *const arm_attr_tag_Advanced_SIMD_arch
[] =
15938 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
15939 "NEON for ARMv8.1"};
15940 static const char *const arm_attr_tag_PCS_config
[] =
15941 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
15942 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
15943 static const char *const arm_attr_tag_ABI_PCS_R9_use
[] =
15944 {"V6", "SB", "TLS", "Unused"};
15945 static const char *const arm_attr_tag_ABI_PCS_RW_data
[] =
15946 {"Absolute", "PC-relative", "SB-relative", "None"};
15947 static const char *const arm_attr_tag_ABI_PCS_RO_data
[] =
15948 {"Absolute", "PC-relative", "None"};
15949 static const char *const arm_attr_tag_ABI_PCS_GOT_use
[] =
15950 {"None", "direct", "GOT-indirect"};
15951 static const char *const arm_attr_tag_ABI_PCS_wchar_t
[] =
15952 {"None", "??? 1", "2", "??? 3", "4"};
15953 static const char *const arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
15954 static const char *const arm_attr_tag_ABI_FP_denormal
[] =
15955 {"Unused", "Needed", "Sign only"};
15956 static const char *const arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
15957 static const char *const arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
15958 static const char *const arm_attr_tag_ABI_FP_number_model
[] =
15959 {"Unused", "Finite", "RTABI", "IEEE 754"};
15960 static const char *const arm_attr_tag_ABI_enum_size
[] =
15961 {"Unused", "small", "int", "forced to int"};
15962 static const char *const arm_attr_tag_ABI_HardFP_use
[] =
15963 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
15964 static const char *const arm_attr_tag_ABI_VFP_args
[] =
15965 {"AAPCS", "VFP registers", "custom", "compatible"};
15966 static const char *const arm_attr_tag_ABI_WMMX_args
[] =
15967 {"AAPCS", "WMMX registers", "custom"};
15968 static const char *const arm_attr_tag_ABI_optimization_goals
[] =
15969 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15970 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
15971 static const char *const arm_attr_tag_ABI_FP_optimization_goals
[] =
15972 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15973 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
15974 static const char *const arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
15975 static const char *const arm_attr_tag_FP_HP_extension
[] =
15976 {"Not Allowed", "Allowed"};
15977 static const char *const arm_attr_tag_ABI_FP_16bit_format
[] =
15978 {"None", "IEEE 754", "Alternative Format"};
15979 static const char *const arm_attr_tag_DSP_extension
[] =
15980 {"Follow architecture", "Allowed"};
15981 static const char *const arm_attr_tag_MPextension_use
[] =
15982 {"Not Allowed", "Allowed"};
15983 static const char *const arm_attr_tag_DIV_use
[] =
15984 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
15985 "Allowed in v7-A with integer division extension"};
15986 static const char *const arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
15987 static const char *const arm_attr_tag_Virtualization_use
[] =
15988 {"Not Allowed", "TrustZone", "Virtualization Extensions",
15989 "TrustZone and Virtualization Extensions"};
15990 static const char *const arm_attr_tag_MPextension_use_legacy
[] =
15991 {"Not Allowed", "Allowed"};
15993 static const char *const arm_attr_tag_MVE_arch
[] =
15994 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
15996 #define LOOKUP(id, name) \
15997 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
15998 static arm_attr_public_tag arm_attr_public_tags
[] =
16000 {4, "CPU_raw_name", 1, NULL
},
16001 {5, "CPU_name", 1, NULL
},
16002 LOOKUP(6, CPU_arch
),
16003 {7, "CPU_arch_profile", 0, NULL
},
16004 LOOKUP(8, ARM_ISA_use
),
16005 LOOKUP(9, THUMB_ISA_use
),
16006 LOOKUP(10, FP_arch
),
16007 LOOKUP(11, WMMX_arch
),
16008 LOOKUP(12, Advanced_SIMD_arch
),
16009 LOOKUP(13, PCS_config
),
16010 LOOKUP(14, ABI_PCS_R9_use
),
16011 LOOKUP(15, ABI_PCS_RW_data
),
16012 LOOKUP(16, ABI_PCS_RO_data
),
16013 LOOKUP(17, ABI_PCS_GOT_use
),
16014 LOOKUP(18, ABI_PCS_wchar_t
),
16015 LOOKUP(19, ABI_FP_rounding
),
16016 LOOKUP(20, ABI_FP_denormal
),
16017 LOOKUP(21, ABI_FP_exceptions
),
16018 LOOKUP(22, ABI_FP_user_exceptions
),
16019 LOOKUP(23, ABI_FP_number_model
),
16020 {24, "ABI_align_needed", 0, NULL
},
16021 {25, "ABI_align_preserved", 0, NULL
},
16022 LOOKUP(26, ABI_enum_size
),
16023 LOOKUP(27, ABI_HardFP_use
),
16024 LOOKUP(28, ABI_VFP_args
),
16025 LOOKUP(29, ABI_WMMX_args
),
16026 LOOKUP(30, ABI_optimization_goals
),
16027 LOOKUP(31, ABI_FP_optimization_goals
),
16028 {32, "compatibility", 0, NULL
},
16029 LOOKUP(34, CPU_unaligned_access
),
16030 LOOKUP(36, FP_HP_extension
),
16031 LOOKUP(38, ABI_FP_16bit_format
),
16032 LOOKUP(42, MPextension_use
),
16033 LOOKUP(44, DIV_use
),
16034 LOOKUP(46, DSP_extension
),
16035 LOOKUP(48, MVE_arch
),
16036 {64, "nodefaults", 0, NULL
},
16037 {65, "also_compatible_with", 0, NULL
},
16038 LOOKUP(66, T2EE_use
),
16039 {67, "conformance", 1, NULL
},
16040 LOOKUP(68, Virtualization_use
),
16041 LOOKUP(70, MPextension_use_legacy
)
16045 static unsigned char *
16046 display_arm_attribute (unsigned char * p
,
16047 const unsigned char * const end
)
16051 arm_attr_public_tag
* attr
;
16055 READ_ULEB (tag
, p
, end
);
16057 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
16059 if (arm_attr_public_tags
[i
].tag
== tag
)
16061 attr
= &arm_attr_public_tags
[i
];
16068 printf (" Tag_%s: ", attr
->name
);
16069 switch (attr
->type
)
16074 case 7: /* Tag_CPU_arch_profile. */
16075 READ_ULEB (val
, p
, end
);
16078 case 0: printf (_("None\n")); break;
16079 case 'A': printf (_("Application\n")); break;
16080 case 'R': printf (_("Realtime\n")); break;
16081 case 'M': printf (_("Microcontroller\n")); break;
16082 case 'S': printf (_("Application or Realtime\n")); break;
16083 default: printf ("??? (%d)\n", val
); break;
16087 case 24: /* Tag_align_needed. */
16088 READ_ULEB (val
, p
, end
);
16091 case 0: printf (_("None\n")); break;
16092 case 1: printf (_("8-byte\n")); break;
16093 case 2: printf (_("4-byte\n")); break;
16094 case 3: printf ("??? 3\n"); break;
16097 printf (_("8-byte and up to %d-byte extended\n"),
16100 printf ("??? (%d)\n", val
);
16105 case 25: /* Tag_align_preserved. */
16106 READ_ULEB (val
, p
, end
);
16109 case 0: printf (_("None\n")); break;
16110 case 1: printf (_("8-byte, except leaf SP\n")); break;
16111 case 2: printf (_("8-byte\n")); break;
16112 case 3: printf ("??? 3\n"); break;
16115 printf (_("8-byte and up to %d-byte extended\n"),
16118 printf ("??? (%d)\n", val
);
16123 case 32: /* Tag_compatibility. */
16125 READ_ULEB (val
, p
, end
);
16126 printf (_("flag = %d, vendor = "), val
);
16129 size_t maxlen
= (end
- p
) - 1;
16131 print_symbol ((int) maxlen
, (const char *) p
);
16132 p
+= strnlen ((char *) p
, maxlen
) + 1;
16136 printf (_("<corrupt>"));
16137 p
= (unsigned char *) end
;
16143 case 64: /* Tag_nodefaults. */
16144 /* PR 17531: file: 001-505008-0.01. */
16147 printf (_("True\n"));
16150 case 65: /* Tag_also_compatible_with. */
16151 READ_ULEB (val
, p
, end
);
16152 if (val
== 6 /* Tag_CPU_arch. */)
16154 READ_ULEB (val
, p
, end
);
16155 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
16156 printf ("??? (%d)\n", val
);
16158 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
16162 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
16167 printf (_("<unknown: %d>\n"), tag
);
16173 return display_tag_value (-1, p
, end
);
16175 return display_tag_value (0, p
, end
);
16178 assert (attr
->type
& 0x80);
16179 READ_ULEB (val
, p
, end
);
16180 type
= attr
->type
& 0x7f;
16182 printf ("??? (%d)\n", val
);
16184 printf ("%s\n", attr
->table
[val
]);
16189 return display_tag_value (tag
, p
, end
);
16192 static unsigned char *
16193 display_gnu_attribute (unsigned char * p
,
16194 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
16195 const unsigned char * const end
)
16200 READ_ULEB (tag
, p
, end
);
16202 /* Tag_compatibility is the only generic GNU attribute defined at
16206 READ_ULEB (val
, p
, end
);
16208 printf (_("flag = %d, vendor = "), val
);
16211 printf (_("<corrupt>\n"));
16212 warn (_("corrupt vendor attribute\n"));
16218 size_t maxlen
= (end
- p
) - 1;
16220 print_symbol ((int) maxlen
, (const char *) p
);
16221 p
+= strnlen ((char *) p
, maxlen
) + 1;
16225 printf (_("<corrupt>"));
16226 p
= (unsigned char *) end
;
16233 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
16234 return display_proc_gnu_attribute (p
, tag
, end
);
16236 return display_tag_value (tag
, p
, end
);
16239 static unsigned char *
16240 display_m68k_gnu_attribute (unsigned char * p
,
16242 const unsigned char * const end
)
16246 if (tag
== Tag_GNU_M68K_ABI_FP
)
16248 printf (" Tag_GNU_M68K_ABI_FP: ");
16251 printf (_("<corrupt>\n"));
16254 READ_ULEB (val
, p
, end
);
16257 printf ("(%#x), ", val
);
16262 printf (_("unspecified hard/soft float\n"));
16265 printf (_("hard float\n"));
16268 printf (_("soft float\n"));
16274 return display_tag_value (tag
& 1, p
, end
);
16277 static unsigned char *
16278 display_power_gnu_attribute (unsigned char * p
,
16280 const unsigned char * const end
)
16284 if (tag
== Tag_GNU_Power_ABI_FP
)
16286 printf (" Tag_GNU_Power_ABI_FP: ");
16289 printf (_("<corrupt>\n"));
16292 READ_ULEB (val
, p
, end
);
16295 printf ("(%#x), ", val
);
16300 printf (_("unspecified hard/soft float, "));
16303 printf (_("hard float, "));
16306 printf (_("soft float, "));
16309 printf (_("single-precision hard float, "));
16316 printf (_("unspecified long double\n"));
16319 printf (_("128-bit IBM long double\n"));
16322 printf (_("64-bit long double\n"));
16325 printf (_("128-bit IEEE long double\n"));
16331 if (tag
== Tag_GNU_Power_ABI_Vector
)
16333 printf (" Tag_GNU_Power_ABI_Vector: ");
16336 printf (_("<corrupt>\n"));
16339 READ_ULEB (val
, p
, end
);
16342 printf ("(%#x), ", val
);
16347 printf (_("unspecified\n"));
16350 printf (_("generic\n"));
16353 printf ("AltiVec\n");
16362 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
16364 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
16367 printf (_("<corrupt>\n"));
16370 READ_ULEB (val
, p
, end
);
16373 printf ("(%#x), ", val
);
16378 printf (_("unspecified\n"));
16381 printf ("r3/r4\n");
16384 printf (_("memory\n"));
16393 return display_tag_value (tag
& 1, p
, end
);
16396 static unsigned char *
16397 display_s390_gnu_attribute (unsigned char * p
,
16399 const unsigned char * const end
)
16403 if (tag
== Tag_GNU_S390_ABI_Vector
)
16405 printf (" Tag_GNU_S390_ABI_Vector: ");
16406 READ_ULEB (val
, p
, end
);
16411 printf (_("any\n"));
16414 printf (_("software\n"));
16417 printf (_("hardware\n"));
16420 printf ("??? (%d)\n", val
);
16426 return display_tag_value (tag
& 1, p
, end
);
16430 display_sparc_hwcaps (unsigned int mask
)
16436 if (mask
& ELF_SPARC_HWCAP_MUL32
)
16437 fputs ("mul32", stdout
), first
= false;
16438 if (mask
& ELF_SPARC_HWCAP_DIV32
)
16439 printf ("%sdiv32", first
? "" : "|"), first
= false;
16440 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
16441 printf ("%sfsmuld", first
? "" : "|"), first
= false;
16442 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
16443 printf ("%sv8plus", first
? "" : "|"), first
= false;
16444 if (mask
& ELF_SPARC_HWCAP_POPC
)
16445 printf ("%spopc", first
? "" : "|"), first
= false;
16446 if (mask
& ELF_SPARC_HWCAP_VIS
)
16447 printf ("%svis", first
? "" : "|"), first
= false;
16448 if (mask
& ELF_SPARC_HWCAP_VIS2
)
16449 printf ("%svis2", first
? "" : "|"), first
= false;
16450 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
16451 printf ("%sASIBlkInit", first
? "" : "|"), first
= false;
16452 if (mask
& ELF_SPARC_HWCAP_FMAF
)
16453 printf ("%sfmaf", first
? "" : "|"), first
= false;
16454 if (mask
& ELF_SPARC_HWCAP_VIS3
)
16455 printf ("%svis3", first
? "" : "|"), first
= false;
16456 if (mask
& ELF_SPARC_HWCAP_HPC
)
16457 printf ("%shpc", first
? "" : "|"), first
= false;
16458 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
16459 printf ("%srandom", first
? "" : "|"), first
= false;
16460 if (mask
& ELF_SPARC_HWCAP_TRANS
)
16461 printf ("%strans", first
? "" : "|"), first
= false;
16462 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
16463 printf ("%sfjfmau", first
? "" : "|"), first
= false;
16464 if (mask
& ELF_SPARC_HWCAP_IMA
)
16465 printf ("%sima", first
? "" : "|"), first
= false;
16466 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
16467 printf ("%scspare", first
? "" : "|"), first
= false;
16470 fputc ('0', stdout
);
16471 fputc ('\n', stdout
);
16475 display_sparc_hwcaps2 (unsigned int mask
)
16481 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
16482 fputs ("fjathplus", stdout
), first
= false;
16483 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
16484 printf ("%svis3b", first
? "" : "|"), first
= false;
16485 if (mask
& ELF_SPARC_HWCAP2_ADP
)
16486 printf ("%sadp", first
? "" : "|"), first
= false;
16487 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
16488 printf ("%ssparc5", first
? "" : "|"), first
= false;
16489 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
16490 printf ("%smwait", first
? "" : "|"), first
= false;
16491 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
16492 printf ("%sxmpmul", first
? "" : "|"), first
= false;
16493 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
16494 printf ("%sxmont2", first
? "" : "|"), first
= false;
16495 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
16496 printf ("%snsec", first
? "" : "|"), first
= false;
16497 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
16498 printf ("%sfjathhpc", first
? "" : "|"), first
= false;
16499 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
16500 printf ("%sfjdes", first
? "" : "|"), first
= false;
16501 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
16502 printf ("%sfjaes", first
? "" : "|"), first
= false;
16505 fputc ('0', stdout
);
16506 fputc ('\n', stdout
);
16509 static unsigned char *
16510 display_sparc_gnu_attribute (unsigned char * p
,
16512 const unsigned char * const end
)
16516 if (tag
== Tag_GNU_Sparc_HWCAPS
)
16518 READ_ULEB (val
, p
, end
);
16519 printf (" Tag_GNU_Sparc_HWCAPS: ");
16520 display_sparc_hwcaps (val
);
16523 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
16525 READ_ULEB (val
, p
, end
);
16526 printf (" Tag_GNU_Sparc_HWCAPS2: ");
16527 display_sparc_hwcaps2 (val
);
16531 return display_tag_value (tag
, p
, end
);
16535 print_mips_fp_abi_value (unsigned int val
)
16539 case Val_GNU_MIPS_ABI_FP_ANY
:
16540 printf (_("Hard or soft float\n"));
16542 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
16543 printf (_("Hard float (double precision)\n"));
16545 case Val_GNU_MIPS_ABI_FP_SINGLE
:
16546 printf (_("Hard float (single precision)\n"));
16548 case Val_GNU_MIPS_ABI_FP_SOFT
:
16549 printf (_("Soft float\n"));
16551 case Val_GNU_MIPS_ABI_FP_OLD_64
:
16552 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
16554 case Val_GNU_MIPS_ABI_FP_XX
:
16555 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
16557 case Val_GNU_MIPS_ABI_FP_64
:
16558 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
16560 case Val_GNU_MIPS_ABI_FP_64A
:
16561 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
16563 case Val_GNU_MIPS_ABI_FP_NAN2008
:
16564 printf (_("NaN 2008 compatibility\n"));
16567 printf ("??? (%d)\n", val
);
16572 static unsigned char *
16573 display_mips_gnu_attribute (unsigned char * p
,
16575 const unsigned char * const end
)
16577 if (tag
== Tag_GNU_MIPS_ABI_FP
)
16581 printf (" Tag_GNU_MIPS_ABI_FP: ");
16582 READ_ULEB (val
, p
, end
);
16583 print_mips_fp_abi_value (val
);
16587 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
16591 printf (" Tag_GNU_MIPS_ABI_MSA: ");
16592 READ_ULEB (val
, p
, end
);
16596 case Val_GNU_MIPS_ABI_MSA_ANY
:
16597 printf (_("Any MSA or not\n"));
16599 case Val_GNU_MIPS_ABI_MSA_128
:
16600 printf (_("128-bit MSA\n"));
16603 printf ("??? (%d)\n", val
);
16609 return display_tag_value (tag
& 1, p
, end
);
16612 static unsigned char *
16613 display_tic6x_attribute (unsigned char * p
,
16614 const unsigned char * const end
)
16619 READ_ULEB (tag
, p
, end
);
16624 printf (" Tag_ISA: ");
16625 READ_ULEB (val
, p
, end
);
16629 case C6XABI_Tag_ISA_none
:
16630 printf (_("None\n"));
16632 case C6XABI_Tag_ISA_C62X
:
16635 case C6XABI_Tag_ISA_C67X
:
16638 case C6XABI_Tag_ISA_C67XP
:
16639 printf ("C67x+\n");
16641 case C6XABI_Tag_ISA_C64X
:
16644 case C6XABI_Tag_ISA_C64XP
:
16645 printf ("C64x+\n");
16647 case C6XABI_Tag_ISA_C674X
:
16648 printf ("C674x\n");
16651 printf ("??? (%d)\n", val
);
16656 case Tag_ABI_wchar_t
:
16657 printf (" Tag_ABI_wchar_t: ");
16658 READ_ULEB (val
, p
, end
);
16662 printf (_("Not used\n"));
16665 printf (_("2 bytes\n"));
16668 printf (_("4 bytes\n"));
16671 printf ("??? (%d)\n", val
);
16676 case Tag_ABI_stack_align_needed
:
16677 printf (" Tag_ABI_stack_align_needed: ");
16678 READ_ULEB (val
, p
, end
);
16682 printf (_("8-byte\n"));
16685 printf (_("16-byte\n"));
16688 printf ("??? (%d)\n", val
);
16693 case Tag_ABI_stack_align_preserved
:
16694 READ_ULEB (val
, p
, end
);
16695 printf (" Tag_ABI_stack_align_preserved: ");
16699 printf (_("8-byte\n"));
16702 printf (_("16-byte\n"));
16705 printf ("??? (%d)\n", val
);
16711 READ_ULEB (val
, p
, end
);
16712 printf (" Tag_ABI_DSBT: ");
16716 printf (_("DSBT addressing not used\n"));
16719 printf (_("DSBT addressing used\n"));
16722 printf ("??? (%d)\n", val
);
16728 READ_ULEB (val
, p
, end
);
16729 printf (" Tag_ABI_PID: ");
16733 printf (_("Data addressing position-dependent\n"));
16736 printf (_("Data addressing position-independent, GOT near DP\n"));
16739 printf (_("Data addressing position-independent, GOT far from DP\n"));
16742 printf ("??? (%d)\n", val
);
16748 READ_ULEB (val
, p
, end
);
16749 printf (" Tag_ABI_PIC: ");
16753 printf (_("Code addressing position-dependent\n"));
16756 printf (_("Code addressing position-independent\n"));
16759 printf ("??? (%d)\n", val
);
16764 case Tag_ABI_array_object_alignment
:
16765 READ_ULEB (val
, p
, end
);
16766 printf (" Tag_ABI_array_object_alignment: ");
16770 printf (_("8-byte\n"));
16773 printf (_("4-byte\n"));
16776 printf (_("16-byte\n"));
16779 printf ("??? (%d)\n", val
);
16784 case Tag_ABI_array_object_align_expected
:
16785 READ_ULEB (val
, p
, end
);
16786 printf (" Tag_ABI_array_object_align_expected: ");
16790 printf (_("8-byte\n"));
16793 printf (_("4-byte\n"));
16796 printf (_("16-byte\n"));
16799 printf ("??? (%d)\n", val
);
16804 case Tag_ABI_compatibility
:
16806 READ_ULEB (val
, p
, end
);
16807 printf (" Tag_ABI_compatibility: ");
16808 printf (_("flag = %d, vendor = "), val
);
16811 size_t maxlen
= (end
- p
) - 1;
16813 print_symbol ((int) maxlen
, (const char *) p
);
16814 p
+= strnlen ((char *) p
, maxlen
) + 1;
16818 printf (_("<corrupt>"));
16819 p
= (unsigned char *) end
;
16825 case Tag_ABI_conformance
:
16827 printf (" Tag_ABI_conformance: \"");
16830 size_t maxlen
= (end
- p
) - 1;
16832 print_symbol ((int) maxlen
, (const char *) p
);
16833 p
+= strnlen ((char *) p
, maxlen
) + 1;
16837 printf (_("<corrupt>"));
16838 p
= (unsigned char *) end
;
16845 return display_tag_value (tag
, p
, end
);
16849 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
16851 unsigned long addr
= 0;
16852 size_t bytes
= end
- p
;
16859 int lbytes
= (bytes
> 16 ? 16 : bytes
);
16861 printf (" 0x%8.8lx ", addr
);
16863 for (j
= 0; j
< 16; j
++)
16866 printf ("%2.2x", p
[j
]);
16874 for (j
= 0; j
< lbytes
; j
++)
16877 if (k
>= ' ' && k
< 0x7f)
16893 static unsigned char *
16894 display_msp430_attribute (unsigned char * p
,
16895 const unsigned char * const end
)
16900 READ_ULEB (tag
, p
, end
);
16904 case OFBA_MSPABI_Tag_ISA
:
16905 printf (" Tag_ISA: ");
16906 READ_ULEB (val
, p
, end
);
16909 case 0: printf (_("None\n")); break;
16910 case 1: printf (_("MSP430\n")); break;
16911 case 2: printf (_("MSP430X\n")); break;
16912 default: printf ("??? (%d)\n", val
); break;
16916 case OFBA_MSPABI_Tag_Code_Model
:
16917 printf (" Tag_Code_Model: ");
16918 READ_ULEB (val
, p
, end
);
16921 case 0: printf (_("None\n")); break;
16922 case 1: printf (_("Small\n")); break;
16923 case 2: printf (_("Large\n")); break;
16924 default: printf ("??? (%d)\n", val
); break;
16928 case OFBA_MSPABI_Tag_Data_Model
:
16929 printf (" Tag_Data_Model: ");
16930 READ_ULEB (val
, p
, end
);
16933 case 0: printf (_("None\n")); break;
16934 case 1: printf (_("Small\n")); break;
16935 case 2: printf (_("Large\n")); break;
16936 case 3: printf (_("Restricted Large\n")); break;
16937 default: printf ("??? (%d)\n", val
); break;
16942 printf (_(" <unknown tag %d>: "), tag
);
16949 size_t maxlen
= (end
- p
) - 1;
16951 print_symbol ((int) maxlen
, (const char *) p
);
16952 p
+= strnlen ((char *) p
, maxlen
) + 1;
16956 printf (_("<corrupt>"));
16957 p
= (unsigned char *) end
;
16963 READ_ULEB (val
, p
, end
);
16964 printf ("%d (0x%x)\n", val
, val
);
16973 static unsigned char *
16974 display_msp430_gnu_attribute (unsigned char * p
,
16976 const unsigned char * const end
)
16978 if (tag
== Tag_GNU_MSP430_Data_Region
)
16982 printf (" Tag_GNU_MSP430_Data_Region: ");
16983 READ_ULEB (val
, p
, end
);
16987 case Val_GNU_MSP430_Data_Region_Any
:
16988 printf (_("Any Region\n"));
16990 case Val_GNU_MSP430_Data_Region_Lower
:
16991 printf (_("Lower Region Only\n"));
16994 printf ("??? (%u)\n", val
);
16998 return display_tag_value (tag
& 1, p
, end
);
17001 struct riscv_attr_tag_t
{
17006 static struct riscv_attr_tag_t riscv_attr_tag
[] =
17008 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
17011 T(priv_spec_minor
),
17012 T(priv_spec_revision
),
17013 T(unaligned_access
),
17018 static unsigned char *
17019 display_riscv_attribute (unsigned char *p
,
17020 const unsigned char * const end
)
17024 struct riscv_attr_tag_t
*attr
= NULL
;
17027 READ_ULEB (tag
, p
, end
);
17029 /* Find the name of attribute. */
17030 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
17032 if (riscv_attr_tag
[i
].tag
== tag
)
17034 attr
= &riscv_attr_tag
[i
];
17040 printf (" %s: ", attr
->name
);
17042 return display_tag_value (tag
, p
, end
);
17046 case Tag_RISCV_priv_spec
:
17047 case Tag_RISCV_priv_spec_minor
:
17048 case Tag_RISCV_priv_spec_revision
:
17049 READ_ULEB (val
, p
, end
);
17050 printf (_("%u\n"), val
);
17052 case Tag_RISCV_unaligned_access
:
17053 READ_ULEB (val
, p
, end
);
17057 printf (_("No unaligned access\n"));
17060 printf (_("Unaligned access\n"));
17064 case Tag_RISCV_stack_align
:
17065 READ_ULEB (val
, p
, end
);
17066 printf (_("%u-bytes\n"), val
);
17068 case Tag_RISCV_arch
:
17069 p
= display_tag_value (-1, p
, end
);
17072 return display_tag_value (tag
, p
, end
);
17078 static unsigned char *
17079 display_csky_attribute (unsigned char * p
,
17080 const unsigned char * const end
)
17084 READ_ULEB (tag
, p
, end
);
17086 if (tag
>= Tag_CSKY_MAX
)
17088 return display_tag_value (-1, p
, end
);
17093 case Tag_CSKY_ARCH_NAME
:
17094 printf (" Tag_CSKY_ARCH_NAME:\t\t");
17095 return display_tag_value (-1, p
, end
);
17096 case Tag_CSKY_CPU_NAME
:
17097 printf (" Tag_CSKY_CPU_NAME:\t\t");
17098 return display_tag_value (-1, p
, end
);
17100 case Tag_CSKY_ISA_FLAGS
:
17101 printf (" Tag_CSKY_ISA_FLAGS:\t\t");
17102 return display_tag_value (0, p
, end
);
17103 case Tag_CSKY_ISA_EXT_FLAGS
:
17104 printf (" Tag_CSKY_ISA_EXT_FLAGS:\t");
17105 return display_tag_value (0, p
, end
);
17107 case Tag_CSKY_DSP_VERSION
:
17108 printf (" Tag_CSKY_DSP_VERSION:\t\t");
17109 READ_ULEB (val
, p
, end
);
17110 if (val
== VAL_CSKY_DSP_VERSION_EXTENSION
)
17111 printf ("DSP Extension\n");
17112 else if (val
== VAL_CSKY_DSP_VERSION_2
)
17113 printf ("DSP 2.0\n");
17116 case Tag_CSKY_VDSP_VERSION
:
17117 printf (" Tag_CSKY_VDSP_VERSION:\t");
17118 READ_ULEB (val
, p
, end
);
17119 printf ("VDSP Version %d\n", val
);
17122 case Tag_CSKY_FPU_VERSION
:
17123 printf (" Tag_CSKY_FPU_VERSION:\t\t");
17124 READ_ULEB (val
, p
, end
);
17125 if (val
== VAL_CSKY_FPU_VERSION_1
)
17126 printf ("ABIV1 FPU Version 1\n");
17127 else if (val
== VAL_CSKY_FPU_VERSION_2
)
17128 printf ("FPU Version 2\n");
17131 case Tag_CSKY_FPU_ABI
:
17132 printf (" Tag_CSKY_FPU_ABI:\t\t");
17133 READ_ULEB (val
, p
, end
);
17134 if (val
== VAL_CSKY_FPU_ABI_HARD
)
17136 else if (val
== VAL_CSKY_FPU_ABI_SOFTFP
)
17137 printf ("SoftFP\n");
17138 else if (val
== VAL_CSKY_FPU_ABI_SOFT
)
17141 case Tag_CSKY_FPU_ROUNDING
:
17142 READ_ULEB (val
, p
, end
);
17144 printf (" Tag_CSKY_FPU_ROUNDING:\t");
17145 printf ("Needed\n");
17148 case Tag_CSKY_FPU_DENORMAL
:
17149 READ_ULEB (val
, p
, end
);
17151 printf (" Tag_CSKY_FPU_DENORMAL:\t");
17152 printf ("Needed\n");
17155 case Tag_CSKY_FPU_Exception
:
17156 READ_ULEB (val
, p
, end
);
17158 printf (" Tag_CSKY_FPU_Exception:\t");
17159 printf ("Needed\n");
17162 case Tag_CSKY_FPU_NUMBER_MODULE
:
17163 printf (" Tag_CSKY_FPU_NUMBER_MODULE:\t");
17164 return display_tag_value (-1, p
, end
);
17165 case Tag_CSKY_FPU_HARDFP
:
17166 printf (" Tag_CSKY_FPU_HARDFP:\t\t");
17167 READ_ULEB (val
, p
, end
);
17168 if (val
& VAL_CSKY_FPU_HARDFP_HALF
)
17170 if (val
& VAL_CSKY_FPU_HARDFP_SINGLE
)
17171 printf (" Single");
17172 if (val
& VAL_CSKY_FPU_HARDFP_DOUBLE
)
17173 printf (" Double");
17177 return display_tag_value (tag
, p
, end
);
17183 process_attributes (Filedata
* filedata
,
17184 const char * public_name
,
17185 unsigned int proc_type
,
17186 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
17187 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
17189 Elf_Internal_Shdr
* sect
;
17193 /* Find the section header so that we get the size. */
17194 for (i
= 0, sect
= filedata
->section_headers
;
17195 i
< filedata
->file_header
.e_shnum
;
17198 unsigned char * contents
;
17201 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
17204 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17205 sect
->sh_size
, _("attributes"));
17206 if (contents
== NULL
)
17213 /* The first character is the version of the attributes.
17214 Currently only version 1, (aka 'A') is recognised here. */
17217 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
17222 bfd_vma section_len
;
17224 section_len
= sect
->sh_size
- 1;
17227 while (section_len
> 0)
17230 unsigned int namelen
;
17231 bool public_section
;
17234 if (section_len
<= 4)
17236 error (_("Tag section ends prematurely\n"));
17240 attr_len
= byte_get (p
, 4);
17243 if (attr_len
> section_len
)
17245 error (_("Bad attribute length (%u > %u)\n"),
17246 (unsigned) attr_len
, (unsigned) section_len
);
17247 attr_len
= section_len
;
17250 /* PR 17531: file: 001-101425-0.004 */
17251 else if (attr_len
< 5)
17253 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
17258 section_len
-= attr_len
;
17261 namelen
= strnlen ((char *) p
, attr_len
) + 1;
17262 if (namelen
== 0 || namelen
>= attr_len
)
17264 error (_("Corrupt attribute section name\n"));
17269 printf (_("Attribute Section: "));
17270 print_symbol (INT_MAX
, (const char *) p
);
17273 if (public_name
&& streq ((char *) p
, public_name
))
17274 public_section
= true;
17276 public_section
= false;
17278 if (streq ((char *) p
, "gnu"))
17279 gnu_section
= true;
17281 gnu_section
= false;
17284 attr_len
-= namelen
;
17286 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
17291 unsigned char * end
;
17293 /* PR binutils/17531: Safe handling of corrupt files. */
17296 error (_("Unused bytes at end of section\n"));
17303 size
= byte_get (p
, 4);
17304 if (size
> attr_len
)
17306 error (_("Bad subsection length (%u > %u)\n"),
17307 (unsigned) size
, (unsigned) attr_len
);
17311 /* PR binutils/17531: Safe handling of corrupt files. */
17314 error (_("Bad subsection length (%u < 6)\n"),
17322 end
= p
+ size
- 1;
17323 assert (end
<= contents
+ sect
->sh_size
);
17329 printf (_("File Attributes\n"));
17332 printf (_("Section Attributes:"));
17335 printf (_("Symbol Attributes:"));
17336 /* Fall through. */
17340 READ_ULEB (val
, p
, end
);
17343 printf (" %d", val
);
17348 printf (_("Unknown tag: %d\n"), tag
);
17349 public_section
= false;
17353 if (public_section
&& display_pub_attribute
!= NULL
)
17356 p
= display_pub_attribute (p
, end
);
17359 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
17362 p
= display_gnu_attribute (p
,
17363 display_proc_gnu_attribute
,
17369 printf (_(" Unknown attribute:\n"));
17370 display_raw_attribute (p
, end
);
17385 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
17386 Print the Address, Access and Initial fields of an entry at VMA ADDR
17387 and return the VMA of the next entry, or -1 if there was a problem.
17388 Does not read from DATA_END or beyond. */
17391 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
17392 unsigned char * data_end
)
17395 print_vma (addr
, LONG_HEX
);
17397 if (addr
< pltgot
+ 0xfff0)
17398 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
17400 printf ("%10s", "");
17403 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
17407 unsigned char * from
= data
+ addr
- pltgot
;
17409 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
17411 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
17412 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
17413 return (bfd_vma
) -1;
17417 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
17418 print_vma (entry
, LONG_HEX
);
17421 return addr
+ (is_32bit_elf
? 4 : 8);
17424 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
17425 PLTGOT. Print the Address and Initial fields of an entry at VMA
17426 ADDR and return the VMA of the next entry. */
17429 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
17432 print_vma (addr
, LONG_HEX
);
17435 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
17440 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
17441 print_vma (entry
, LONG_HEX
);
17443 return addr
+ (is_32bit_elf
? 4 : 8);
17447 print_mips_ases (unsigned int mask
)
17449 if (mask
& AFL_ASE_DSP
)
17450 fputs ("\n\tDSP ASE", stdout
);
17451 if (mask
& AFL_ASE_DSPR2
)
17452 fputs ("\n\tDSP R2 ASE", stdout
);
17453 if (mask
& AFL_ASE_DSPR3
)
17454 fputs ("\n\tDSP R3 ASE", stdout
);
17455 if (mask
& AFL_ASE_EVA
)
17456 fputs ("\n\tEnhanced VA Scheme", stdout
);
17457 if (mask
& AFL_ASE_MCU
)
17458 fputs ("\n\tMCU (MicroController) ASE", stdout
);
17459 if (mask
& AFL_ASE_MDMX
)
17460 fputs ("\n\tMDMX ASE", stdout
);
17461 if (mask
& AFL_ASE_MIPS3D
)
17462 fputs ("\n\tMIPS-3D ASE", stdout
);
17463 if (mask
& AFL_ASE_MT
)
17464 fputs ("\n\tMT ASE", stdout
);
17465 if (mask
& AFL_ASE_SMARTMIPS
)
17466 fputs ("\n\tSmartMIPS ASE", stdout
);
17467 if (mask
& AFL_ASE_VIRT
)
17468 fputs ("\n\tVZ ASE", stdout
);
17469 if (mask
& AFL_ASE_MSA
)
17470 fputs ("\n\tMSA ASE", stdout
);
17471 if (mask
& AFL_ASE_MIPS16
)
17472 fputs ("\n\tMIPS16 ASE", stdout
);
17473 if (mask
& AFL_ASE_MICROMIPS
)
17474 fputs ("\n\tMICROMIPS ASE", stdout
);
17475 if (mask
& AFL_ASE_XPA
)
17476 fputs ("\n\tXPA ASE", stdout
);
17477 if (mask
& AFL_ASE_MIPS16E2
)
17478 fputs ("\n\tMIPS16e2 ASE", stdout
);
17479 if (mask
& AFL_ASE_CRC
)
17480 fputs ("\n\tCRC ASE", stdout
);
17481 if (mask
& AFL_ASE_GINV
)
17482 fputs ("\n\tGINV ASE", stdout
);
17483 if (mask
& AFL_ASE_LOONGSON_MMI
)
17484 fputs ("\n\tLoongson MMI ASE", stdout
);
17485 if (mask
& AFL_ASE_LOONGSON_CAM
)
17486 fputs ("\n\tLoongson CAM ASE", stdout
);
17487 if (mask
& AFL_ASE_LOONGSON_EXT
)
17488 fputs ("\n\tLoongson EXT ASE", stdout
);
17489 if (mask
& AFL_ASE_LOONGSON_EXT2
)
17490 fputs ("\n\tLoongson EXT2 ASE", stdout
);
17492 fprintf (stdout
, "\n\t%s", _("None"));
17493 else if ((mask
& ~AFL_ASE_MASK
) != 0)
17494 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
17498 print_mips_isa_ext (unsigned int isa_ext
)
17503 fputs (_("None"), stdout
);
17506 fputs ("RMI XLR", stdout
);
17508 case AFL_EXT_OCTEON3
:
17509 fputs ("Cavium Networks Octeon3", stdout
);
17511 case AFL_EXT_OCTEON2
:
17512 fputs ("Cavium Networks Octeon2", stdout
);
17514 case AFL_EXT_OCTEONP
:
17515 fputs ("Cavium Networks OcteonP", stdout
);
17517 case AFL_EXT_OCTEON
:
17518 fputs ("Cavium Networks Octeon", stdout
);
17521 fputs ("Toshiba R5900", stdout
);
17524 fputs ("MIPS R4650", stdout
);
17527 fputs ("LSI R4010", stdout
);
17530 fputs ("NEC VR4100", stdout
);
17533 fputs ("Toshiba R3900", stdout
);
17535 case AFL_EXT_10000
:
17536 fputs ("MIPS R10000", stdout
);
17539 fputs ("Broadcom SB-1", stdout
);
17542 fputs ("NEC VR4111/VR4181", stdout
);
17545 fputs ("NEC VR4120", stdout
);
17548 fputs ("NEC VR5400", stdout
);
17551 fputs ("NEC VR5500", stdout
);
17553 case AFL_EXT_LOONGSON_2E
:
17554 fputs ("ST Microelectronics Loongson 2E", stdout
);
17556 case AFL_EXT_LOONGSON_2F
:
17557 fputs ("ST Microelectronics Loongson 2F", stdout
);
17559 case AFL_EXT_INTERAPTIV_MR2
:
17560 fputs ("Imagination interAptiv MR2", stdout
);
17563 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
17568 get_mips_reg_size (int reg_size
)
17570 return (reg_size
== AFL_REG_NONE
) ? 0
17571 : (reg_size
== AFL_REG_32
) ? 32
17572 : (reg_size
== AFL_REG_64
) ? 64
17573 : (reg_size
== AFL_REG_128
) ? 128
17578 process_mips_specific (Filedata
* filedata
)
17580 Elf_Internal_Dyn
* entry
;
17581 Elf_Internal_Shdr
*sect
= NULL
;
17582 size_t liblist_offset
= 0;
17583 size_t liblistno
= 0;
17584 size_t conflictsno
= 0;
17585 size_t options_offset
= 0;
17586 size_t conflicts_offset
= 0;
17587 size_t pltrelsz
= 0;
17589 bfd_vma pltgot
= 0;
17590 bfd_vma mips_pltgot
= 0;
17591 bfd_vma jmprel
= 0;
17592 bfd_vma local_gotno
= 0;
17593 bfd_vma gotsym
= 0;
17594 bfd_vma symtabno
= 0;
17597 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17598 display_mips_gnu_attribute
))
17601 sect
= find_section (filedata
, ".MIPS.abiflags");
17605 Elf_External_ABIFlags_v0
*abiflags_ext
;
17606 Elf_Internal_ABIFlags_v0 abiflags_in
;
17608 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
17610 error (_("Corrupt MIPS ABI Flags section.\n"));
17615 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17616 sect
->sh_size
, _("MIPS ABI Flags section"));
17619 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
17620 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
17621 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
17622 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
17623 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
17624 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
17625 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
17626 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
17627 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
17628 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
17629 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
17631 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
17632 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
17633 if (abiflags_in
.isa_rev
> 1)
17634 printf ("r%d", abiflags_in
.isa_rev
);
17635 printf ("\nGPR size: %d",
17636 get_mips_reg_size (abiflags_in
.gpr_size
));
17637 printf ("\nCPR1 size: %d",
17638 get_mips_reg_size (abiflags_in
.cpr1_size
));
17639 printf ("\nCPR2 size: %d",
17640 get_mips_reg_size (abiflags_in
.cpr2_size
));
17641 fputs ("\nFP ABI: ", stdout
);
17642 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
17643 fputs ("ISA Extension: ", stdout
);
17644 print_mips_isa_ext (abiflags_in
.isa_ext
);
17645 fputs ("\nASEs:", stdout
);
17646 print_mips_ases (abiflags_in
.ases
);
17647 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
17648 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
17649 fputc ('\n', stdout
);
17650 free (abiflags_ext
);
17655 /* We have a lot of special sections. Thanks SGI! */
17656 if (filedata
->dynamic_section
== NULL
)
17658 /* No dynamic information available. See if there is static GOT. */
17659 sect
= find_section (filedata
, ".got");
17662 unsigned char *data_end
;
17663 unsigned char *data
;
17667 pltgot
= sect
->sh_addr
;
17670 addr_size
= (is_32bit_elf
? 4 : 8);
17671 end
= pltgot
+ sect
->sh_size
;
17673 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
17675 _("Global Offset Table data"));
17676 /* PR 12855: Null data is handled gracefully throughout. */
17677 data_end
= data
+ (end
- pltgot
);
17679 printf (_("\nStatic GOT:\n"));
17680 printf (_(" Canonical gp value: "));
17681 print_vma (ent
+ 0x7ff0, LONG_HEX
);
17684 /* In a dynamic binary GOT[0] is reserved for the dynamic
17685 loader to store the lazy resolver pointer, however in
17686 a static binary it may well have been omitted and GOT
17687 reduced to a table of addresses.
17688 PR 21344: Check for the entry being fully available
17689 before fetching it. */
17691 && data
+ ent
- pltgot
+ addr_size
<= data_end
17692 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
17694 printf (_(" Reserved entries:\n"));
17695 printf (_(" %*s %10s %*s\n"),
17696 addr_size
* 2, _("Address"), _("Access"),
17697 addr_size
* 2, _("Value"));
17698 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17700 if (ent
== (bfd_vma
) -1)
17701 goto sgot_print_fail
;
17703 /* Check for the MSB of GOT[1] being set, identifying a
17704 GNU object. This entry will be used by some runtime
17705 loaders, to store the module pointer. Otherwise this
17706 is an ordinary local entry.
17707 PR 21344: Check for the entry being fully available
17708 before fetching it. */
17710 && data
+ ent
- pltgot
+ addr_size
<= data_end
17711 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17712 >> (addr_size
* 8 - 1)) != 0)
17714 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17716 if (ent
== (bfd_vma
) -1)
17717 goto sgot_print_fail
;
17722 if (data
!= NULL
&& ent
< end
)
17724 printf (_(" Local entries:\n"));
17725 printf (" %*s %10s %*s\n",
17726 addr_size
* 2, _("Address"), _("Access"),
17727 addr_size
* 2, _("Value"));
17730 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17732 if (ent
== (bfd_vma
) -1)
17733 goto sgot_print_fail
;
17744 for (entry
= filedata
->dynamic_section
;
17745 /* PR 17531 file: 012-50589-0.004. */
17746 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
17747 && entry
->d_tag
!= DT_NULL
);
17749 switch (entry
->d_tag
)
17751 case DT_MIPS_LIBLIST
:
17753 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
17754 liblistno
* sizeof (Elf32_External_Lib
));
17756 case DT_MIPS_LIBLISTNO
:
17757 liblistno
= entry
->d_un
.d_val
;
17759 case DT_MIPS_OPTIONS
:
17760 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
17762 case DT_MIPS_CONFLICT
:
17764 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
17765 conflictsno
* sizeof (Elf32_External_Conflict
));
17767 case DT_MIPS_CONFLICTNO
:
17768 conflictsno
= entry
->d_un
.d_val
;
17771 pltgot
= entry
->d_un
.d_ptr
;
17773 case DT_MIPS_LOCAL_GOTNO
:
17774 local_gotno
= entry
->d_un
.d_val
;
17776 case DT_MIPS_GOTSYM
:
17777 gotsym
= entry
->d_un
.d_val
;
17779 case DT_MIPS_SYMTABNO
:
17780 symtabno
= entry
->d_un
.d_val
;
17782 case DT_MIPS_PLTGOT
:
17783 mips_pltgot
= entry
->d_un
.d_ptr
;
17786 pltrel
= entry
->d_un
.d_val
;
17789 pltrelsz
= entry
->d_un
.d_val
;
17792 jmprel
= entry
->d_un
.d_ptr
;
17798 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
17800 Elf32_External_Lib
* elib
;
17803 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
17804 sizeof (Elf32_External_Lib
),
17806 _("liblist section data"));
17809 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
17810 "\nSection '.liblist' contains %lu entries:\n",
17811 (unsigned long) liblistno
),
17812 (unsigned long) liblistno
);
17813 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
17816 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
17823 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17824 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17825 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17826 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17827 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17829 tmp
= gmtime (&atime
);
17830 snprintf (timebuf
, sizeof (timebuf
),
17831 "%04u-%02u-%02uT%02u:%02u:%02u",
17832 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17833 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17835 printf ("%3lu: ", (unsigned long) cnt
);
17836 if (VALID_DYNAMIC_NAME (filedata
, liblist
.l_name
))
17837 print_symbol (20, GET_DYNAMIC_NAME (filedata
, liblist
.l_name
));
17839 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
17840 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
17841 liblist
.l_version
);
17843 if (liblist
.l_flags
== 0)
17847 static const struct
17854 { " EXACT_MATCH", LL_EXACT_MATCH
},
17855 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
17856 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
17857 { " EXPORTS", LL_EXPORTS
},
17858 { " DELAY_LOAD", LL_DELAY_LOAD
},
17859 { " DELTA", LL_DELTA
}
17861 int flags
= liblist
.l_flags
;
17864 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
17865 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
17867 fputs (l_flags_vals
[fcnt
].name
, stdout
);
17868 flags
^= l_flags_vals
[fcnt
].bit
;
17871 printf (" %#x", (unsigned int) flags
);
17883 if (options_offset
!= 0)
17885 Elf_External_Options
* eopt
;
17888 sect
= filedata
->section_headers
;
17890 /* Find the section header so that we get the size. */
17891 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
17892 /* PR 17533 file: 012-277276-0.004. */
17895 error (_("No MIPS_OPTIONS header found\n"));
17899 if (sect
->sh_size
< sizeof (* eopt
))
17901 error (_("The MIPS options section is too small.\n"));
17905 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
17906 sect
->sh_size
, _("options"));
17909 Elf_Internal_Options option
;
17912 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
17914 Elf_External_Options
* eoption
;
17915 unsigned int optsize
;
17917 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
17919 optsize
= BYTE_GET (eoption
->size
);
17921 /* PR 17531: file: ffa0fa3b. */
17922 if (optsize
< sizeof (* eopt
)
17923 || optsize
> sect
->sh_size
- offset
)
17925 error (_("Invalid size (%u) for MIPS option\n"),
17934 printf (ngettext ("\nSection '%s' contains %d entry:\n",
17935 "\nSection '%s' contains %d entries:\n",
17937 printable_section_name (filedata
, sect
), cnt
);
17943 Elf_External_Options
* eoption
;
17945 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
17947 option
.kind
= BYTE_GET (eoption
->kind
);
17948 option
.size
= BYTE_GET (eoption
->size
);
17949 option
.section
= BYTE_GET (eoption
->section
);
17950 option
.info
= BYTE_GET (eoption
->info
);
17952 switch (option
.kind
)
17955 /* This shouldn't happen. */
17956 printf (" NULL %" PRId16
" %" PRIx32
,
17957 option
.section
, option
.info
);
17961 printf (" REGINFO ");
17962 if (filedata
->file_header
.e_machine
== EM_MIPS
)
17964 Elf32_External_RegInfo
* ereg
;
17965 Elf32_RegInfo reginfo
;
17968 if (option
.size
< (sizeof (Elf_External_Options
)
17969 + sizeof (Elf32_External_RegInfo
)))
17971 printf (_("<corrupt>\n"));
17972 error (_("Truncated MIPS REGINFO option\n"));
17977 ereg
= (Elf32_External_RegInfo
*) (eoption
+ 1);
17979 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
17980 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
17981 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
17982 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
17983 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
17984 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
17986 printf ("GPR %08" PRIx32
" GP 0x%" PRIx32
"\n",
17987 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
17989 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
17990 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
17991 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17992 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17997 Elf64_External_RegInfo
* ereg
;
17998 Elf64_Internal_RegInfo reginfo
;
18000 if (option
.size
< (sizeof (Elf_External_Options
)
18001 + sizeof (Elf64_External_RegInfo
)))
18003 printf (_("<corrupt>\n"));
18004 error (_("Truncated MIPS REGINFO option\n"));
18009 ereg
= (Elf64_External_RegInfo
*) (eoption
+ 1);
18010 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
18011 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
18012 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
18013 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
18014 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
18015 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
18017 printf ("GPR %08" PRIx32
" GP 0x%" PRIx64
"\n",
18018 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
18020 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
18021 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
18022 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
18023 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
18025 offset
+= option
.size
;
18028 case ODK_EXCEPTIONS
:
18029 fputs (" EXCEPTIONS fpe_min(", stdout
);
18030 process_mips_fpe_exception (option
.info
& OEX_FPU_MIN
);
18031 fputs (") fpe_max(", stdout
);
18032 process_mips_fpe_exception ((option
.info
& OEX_FPU_MAX
) >> 8);
18033 fputs (")", stdout
);
18035 if (option
.info
& OEX_PAGE0
)
18036 fputs (" PAGE0", stdout
);
18037 if (option
.info
& OEX_SMM
)
18038 fputs (" SMM", stdout
);
18039 if (option
.info
& OEX_FPDBUG
)
18040 fputs (" FPDBUG", stdout
);
18041 if (option
.info
& OEX_DISMISS
)
18042 fputs (" DISMISS", stdout
);
18046 fputs (" PAD ", stdout
);
18047 if (option
.info
& OPAD_PREFIX
)
18048 fputs (" PREFIX", stdout
);
18049 if (option
.info
& OPAD_POSTFIX
)
18050 fputs (" POSTFIX", stdout
);
18051 if (option
.info
& OPAD_SYMBOL
)
18052 fputs (" SYMBOL", stdout
);
18056 fputs (" HWPATCH ", stdout
);
18057 if (option
.info
& OHW_R4KEOP
)
18058 fputs (" R4KEOP", stdout
);
18059 if (option
.info
& OHW_R8KPFETCH
)
18060 fputs (" R8KPFETCH", stdout
);
18061 if (option
.info
& OHW_R5KEOP
)
18062 fputs (" R5KEOP", stdout
);
18063 if (option
.info
& OHW_R5KCVTL
)
18064 fputs (" R5KCVTL", stdout
);
18068 fputs (" FILL ", stdout
);
18069 /* XXX Print content of info word? */
18073 fputs (" TAGS ", stdout
);
18074 /* XXX Print content of info word? */
18078 fputs (" HWAND ", stdout
);
18079 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
18080 fputs (" R4KEOP_CHECKED", stdout
);
18081 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
18082 fputs (" R4KEOP_CLEAN", stdout
);
18086 fputs (" HWOR ", stdout
);
18087 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
18088 fputs (" R4KEOP_CHECKED", stdout
);
18089 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
18090 fputs (" R4KEOP_CLEAN", stdout
);
18094 printf (" GP_GROUP %#06x self-contained %#06x",
18095 option
.info
& OGP_GROUP
,
18096 (option
.info
& OGP_SELF
) >> 16);
18100 printf (" IDENT %#06x self-contained %#06x",
18101 option
.info
& OGP_GROUP
,
18102 (option
.info
& OGP_SELF
) >> 16);
18106 /* This shouldn't happen. */
18107 printf (" %3d ??? %" PRId16
" %" PRIx32
,
18108 option
.kind
, option
.section
, option
.info
);
18112 len
= sizeof (* eopt
);
18113 while (len
< option
.size
)
18115 unsigned char datum
= *((unsigned char *) eoption
+ len
);
18117 if (ISPRINT (datum
))
18118 printf ("%c", datum
);
18120 printf ("\\%03o", datum
);
18123 fputs ("\n", stdout
);
18125 offset
+= option
.size
;
18133 if (conflicts_offset
!= 0 && conflictsno
!= 0)
18135 Elf32_Conflict
* iconf
;
18138 if (filedata
->dynamic_symbols
== NULL
)
18140 error (_("conflict list found without a dynamic symbol table\n"));
18144 /* PR 21345 - print a slightly more helpful error message
18145 if we are sure that the cmalloc will fail. */
18146 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
18148 error (_("Overlarge number of conflicts detected: %lx\n"),
18149 (long) conflictsno
);
18153 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
18156 error (_("Out of memory allocating space for dynamic conflicts\n"));
18162 Elf32_External_Conflict
* econf32
;
18164 econf32
= (Elf32_External_Conflict
*)
18165 get_data (NULL
, filedata
, conflicts_offset
,
18166 sizeof (*econf32
), conflictsno
, _("conflict"));
18173 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18174 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
18180 Elf64_External_Conflict
* econf64
;
18182 econf64
= (Elf64_External_Conflict
*)
18183 get_data (NULL
, filedata
, conflicts_offset
,
18184 sizeof (*econf64
), conflictsno
, _("conflict"));
18191 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18192 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
18197 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
18198 "\nSection '.conflict' contains %lu entries:\n",
18199 (unsigned long) conflictsno
),
18200 (unsigned long) conflictsno
);
18201 puts (_(" Num: Index Value Name"));
18203 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18205 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
18207 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
18208 printf (_("<corrupt symbol index>"));
18211 Elf_Internal_Sym
* psym
;
18213 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
18214 print_vma (psym
->st_value
, FULL_HEX
);
18216 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
18217 print_symbol (25, GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
18219 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18227 if (pltgot
!= 0 && local_gotno
!= 0)
18229 bfd_vma ent
, local_end
, global_end
;
18231 unsigned char * data
;
18232 unsigned char * data_end
;
18236 addr_size
= (is_32bit_elf
? 4 : 8);
18237 local_end
= pltgot
+ local_gotno
* addr_size
;
18239 /* PR binutils/17533 file: 012-111227-0.004 */
18240 if (symtabno
< gotsym
)
18242 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
18243 (unsigned long) gotsym
, (unsigned long) symtabno
);
18247 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
18248 /* PR 17531: file: 54c91a34. */
18249 if (global_end
< local_end
)
18251 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
18255 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
18256 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
18257 global_end
- pltgot
, 1,
18258 _("Global Offset Table data"));
18259 /* PR 12855: Null data is handled gracefully throughout. */
18260 data_end
= data
+ (global_end
- pltgot
);
18262 printf (_("\nPrimary GOT:\n"));
18263 printf (_(" Canonical gp value: "));
18264 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
18267 printf (_(" Reserved entries:\n"));
18268 printf (_(" %*s %10s %*s Purpose\n"),
18269 addr_size
* 2, _("Address"), _("Access"),
18270 addr_size
* 2, _("Initial"));
18271 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18272 printf (_(" Lazy resolver\n"));
18273 if (ent
== (bfd_vma
) -1)
18274 goto got_print_fail
;
18276 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
18277 This entry will be used by some runtime loaders, to store the
18278 module pointer. Otherwise this is an ordinary local entry.
18279 PR 21344: Check for the entry being fully available before
18282 && data
+ ent
- pltgot
+ addr_size
<= data_end
18283 && (byte_get (data
+ ent
- pltgot
, addr_size
)
18284 >> (addr_size
* 8 - 1)) != 0)
18286 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18287 printf (_(" Module pointer (GNU extension)\n"));
18288 if (ent
== (bfd_vma
) -1)
18289 goto got_print_fail
;
18293 if (data
!= NULL
&& ent
< local_end
)
18295 printf (_(" Local entries:\n"));
18296 printf (" %*s %10s %*s\n",
18297 addr_size
* 2, _("Address"), _("Access"),
18298 addr_size
* 2, _("Initial"));
18299 while (ent
< local_end
)
18301 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18303 if (ent
== (bfd_vma
) -1)
18304 goto got_print_fail
;
18309 if (data
!= NULL
&& gotsym
< symtabno
)
18313 printf (_(" Global entries:\n"));
18314 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
18315 addr_size
* 2, _("Address"),
18317 addr_size
* 2, _("Initial"),
18318 addr_size
* 2, _("Sym.Val."),
18320 /* Note for translators: "Ndx" = abbreviated form of "Index". */
18321 _("Ndx"), _("Name"));
18323 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
18325 for (i
= gotsym
; i
< symtabno
; i
++)
18327 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18330 if (filedata
->dynamic_symbols
== NULL
)
18331 printf (_("<no dynamic symbols>"));
18332 else if (i
< filedata
->num_dynamic_syms
)
18334 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
18336 print_vma (psym
->st_value
, LONG_HEX
);
18337 printf (" %-7s %3s ",
18338 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
18339 get_symbol_index_type (filedata
, psym
->st_shndx
));
18341 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
18342 print_symbol (sym_width
,
18343 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
18345 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18348 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
18349 (unsigned long) i
);
18352 if (ent
== (bfd_vma
) -1)
18362 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
18365 size_t offset
, rel_offset
;
18366 unsigned long count
, i
;
18367 unsigned char * data
;
18368 int addr_size
, sym_width
;
18369 Elf_Internal_Rela
* rels
;
18371 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
18372 if (pltrel
== DT_RELA
)
18374 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
18379 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
18384 addr_size
= (is_32bit_elf
? 4 : 8);
18385 end
= mips_pltgot
+ (2 + count
) * addr_size
;
18387 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
18388 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
18389 1, _("Procedure Linkage Table data"));
18396 printf ("\nPLT GOT:\n\n");
18397 printf (_(" Reserved entries:\n"));
18398 printf (_(" %*s %*s Purpose\n"),
18399 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
18400 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18401 printf (_(" PLT lazy resolver\n"));
18402 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18403 printf (_(" Module pointer\n"));
18406 printf (_(" Entries:\n"));
18407 printf (" %*s %*s %*s %-7s %3s %s\n",
18408 addr_size
* 2, _("Address"),
18409 addr_size
* 2, _("Initial"),
18410 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
18411 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
18412 for (i
= 0; i
< count
; i
++)
18414 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
18416 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18419 if (idx
>= filedata
->num_dynamic_syms
)
18420 printf (_("<corrupt symbol index: %lu>"), idx
);
18423 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
18425 print_vma (psym
->st_value
, LONG_HEX
);
18426 printf (" %-7s %3s ",
18427 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
18428 get_symbol_index_type (filedata
, psym
->st_shndx
));
18429 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
18430 print_symbol (sym_width
,
18431 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
18433 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18447 process_nds32_specific (Filedata
* filedata
)
18449 Elf_Internal_Shdr
*sect
= NULL
;
18451 sect
= find_section (filedata
, ".nds32_e_flags");
18452 if (sect
!= NULL
&& sect
->sh_size
>= 4)
18454 unsigned char *buf
;
18457 printf ("\nNDS32 elf flags section:\n");
18458 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
18459 _("NDS32 elf flags section"));
18464 flag
= byte_get (buf
, 4);
18466 switch (flag
& 0x3)
18469 printf ("(VEC_SIZE):\tNo entry.\n");
18472 printf ("(VEC_SIZE):\t4 bytes\n");
18475 printf ("(VEC_SIZE):\t16 bytes\n");
18478 printf ("(VEC_SIZE):\treserved\n");
18487 process_gnu_liblist (Filedata
* filedata
)
18489 Elf_Internal_Shdr
* section
;
18490 Elf_Internal_Shdr
* string_sec
;
18491 Elf32_External_Lib
* elib
;
18493 size_t strtab_size
;
18495 unsigned long num_liblist
;
18502 for (i
= 0, section
= filedata
->section_headers
;
18503 i
< filedata
->file_header
.e_shnum
;
18506 switch (section
->sh_type
)
18508 case SHT_GNU_LIBLIST
:
18509 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
18512 elib
= (Elf32_External_Lib
*)
18513 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
18514 _("liblist section data"));
18522 string_sec
= filedata
->section_headers
+ section
->sh_link
;
18523 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
18524 string_sec
->sh_size
,
18525 _("liblist string table"));
18527 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
18534 strtab_size
= string_sec
->sh_size
;
18536 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
18537 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
18538 "\nLibrary list section '%s' contains %lu entries:\n",
18540 printable_section_name (filedata
, section
),
18543 puts (_(" Library Time Stamp Checksum Version Flags"));
18545 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
18553 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
18554 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
18555 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
18556 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
18557 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
18559 tmp
= gmtime (&atime
);
18560 snprintf (timebuf
, sizeof (timebuf
),
18561 "%04u-%02u-%02uT%02u:%02u:%02u",
18562 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
18563 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
18565 printf ("%3lu: ", (unsigned long) cnt
);
18567 printf ("%-20s", liblist
.l_name
< strtab_size
18568 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
18570 printf ("%-20.20s", liblist
.l_name
< strtab_size
18571 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
18572 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
18573 liblist
.l_version
, liblist
.l_flags
);
18584 static const char *
18585 get_note_type (Filedata
* filedata
, unsigned e_type
)
18587 static char buff
[64];
18589 if (filedata
->file_header
.e_type
== ET_CORE
)
18593 return _("NT_AUXV (auxiliary vector)");
18595 return _("NT_PRSTATUS (prstatus structure)");
18597 return _("NT_FPREGSET (floating point registers)");
18599 return _("NT_PRPSINFO (prpsinfo structure)");
18600 case NT_TASKSTRUCT
:
18601 return _("NT_TASKSTRUCT (task structure)");
18603 return _("NT_GDB_TDESC (GDB XML target description)");
18605 return _("NT_PRXFPREG (user_xfpregs structure)");
18607 return _("NT_PPC_VMX (ppc Altivec registers)");
18609 return _("NT_PPC_VSX (ppc VSX registers)");
18611 return _("NT_PPC_TAR (ppc TAR register)");
18613 return _("NT_PPC_PPR (ppc PPR register)");
18615 return _("NT_PPC_DSCR (ppc DSCR register)");
18617 return _("NT_PPC_EBB (ppc EBB registers)");
18619 return _("NT_PPC_PMU (ppc PMU registers)");
18620 case NT_PPC_TM_CGPR
:
18621 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
18622 case NT_PPC_TM_CFPR
:
18623 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
18624 case NT_PPC_TM_CVMX
:
18625 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
18626 case NT_PPC_TM_CVSX
:
18627 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
18628 case NT_PPC_TM_SPR
:
18629 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
18630 case NT_PPC_TM_CTAR
:
18631 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
18632 case NT_PPC_TM_CPPR
:
18633 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
18634 case NT_PPC_TM_CDSCR
:
18635 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
18637 return _("NT_386_TLS (x86 TLS information)");
18638 case NT_386_IOPERM
:
18639 return _("NT_386_IOPERM (x86 I/O permissions)");
18640 case NT_X86_XSTATE
:
18641 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
18643 return _("NT_X86_CET (x86 CET state)");
18644 case NT_S390_HIGH_GPRS
:
18645 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
18646 case NT_S390_TIMER
:
18647 return _("NT_S390_TIMER (s390 timer register)");
18648 case NT_S390_TODCMP
:
18649 return _("NT_S390_TODCMP (s390 TOD comparator register)");
18650 case NT_S390_TODPREG
:
18651 return _("NT_S390_TODPREG (s390 TOD programmable register)");
18653 return _("NT_S390_CTRS (s390 control registers)");
18654 case NT_S390_PREFIX
:
18655 return _("NT_S390_PREFIX (s390 prefix register)");
18656 case NT_S390_LAST_BREAK
:
18657 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
18658 case NT_S390_SYSTEM_CALL
:
18659 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
18661 return _("NT_S390_TDB (s390 transaction diagnostic block)");
18662 case NT_S390_VXRS_LOW
:
18663 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
18664 case NT_S390_VXRS_HIGH
:
18665 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
18666 case NT_S390_GS_CB
:
18667 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
18668 case NT_S390_GS_BC
:
18669 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
18671 return _("NT_ARM_VFP (arm VFP registers)");
18673 return _("NT_ARM_TLS (AArch TLS registers)");
18674 case NT_ARM_HW_BREAK
:
18675 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
18676 case NT_ARM_HW_WATCH
:
18677 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
18679 return _("NT_ARM_SVE (AArch SVE registers)");
18680 case NT_ARM_PAC_MASK
:
18681 return _("NT_ARM_PAC_MASK (AArch pointer authentication code masks)");
18682 case NT_ARM_TAGGED_ADDR_CTRL
:
18683 return _("NT_ARM_TAGGED_ADDR_CTRL (AArch tagged address control)");
18685 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
18687 return _("NT_RISCV_CSR (RISC-V control and status registers)");
18689 return _("NT_PSTATUS (pstatus structure)");
18691 return _("NT_FPREGS (floating point registers)");
18693 return _("NT_PSINFO (psinfo structure)");
18695 return _("NT_LWPSTATUS (lwpstatus_t structure)");
18697 return _("NT_LWPSINFO (lwpsinfo_t structure)");
18698 case NT_WIN32PSTATUS
:
18699 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
18701 return _("NT_SIGINFO (siginfo_t data)");
18703 return _("NT_FILE (mapped files)");
18705 return _("NT_MEMTAG (memory tags)");
18713 return _("NT_VERSION (version)");
18715 return _("NT_ARCH (architecture)");
18716 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
18718 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
18724 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18729 print_core_note (Elf_Internal_Note
*pnote
)
18731 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
18732 bfd_vma count
, page_size
;
18733 unsigned char *descdata
, *filenames
, *descend
;
18735 if (pnote
->type
!= NT_FILE
)
18745 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
18746 /* Still "successful". */
18751 if (pnote
->descsz
< 2 * addr_size
)
18753 error (_(" Malformed note - too short for header\n"));
18757 descdata
= (unsigned char *) pnote
->descdata
;
18758 descend
= descdata
+ pnote
->descsz
;
18760 if (descdata
[pnote
->descsz
- 1] != '\0')
18762 error (_(" Malformed note - does not end with \\0\n"));
18766 count
= byte_get (descdata
, addr_size
);
18767 descdata
+= addr_size
;
18769 page_size
= byte_get (descdata
, addr_size
);
18770 descdata
+= addr_size
;
18772 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
18773 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
18775 error (_(" Malformed note - too short for supplied file count\n"));
18779 printf (_(" Page size: "));
18780 print_vma (page_size
, DEC
);
18783 printf (_(" %*s%*s%*s\n"),
18784 (int) (2 + 2 * addr_size
), _("Start"),
18785 (int) (4 + 2 * addr_size
), _("End"),
18786 (int) (4 + 2 * addr_size
), _("Page Offset"));
18787 filenames
= descdata
+ count
* 3 * addr_size
;
18788 while (count
-- > 0)
18790 bfd_vma start
, end
, file_ofs
;
18792 if (filenames
== descend
)
18794 error (_(" Malformed note - filenames end too early\n"));
18798 start
= byte_get (descdata
, addr_size
);
18799 descdata
+= addr_size
;
18800 end
= byte_get (descdata
, addr_size
);
18801 descdata
+= addr_size
;
18802 file_ofs
= byte_get (descdata
, addr_size
);
18803 descdata
+= addr_size
;
18806 print_vma (start
, FULL_HEX
);
18808 print_vma (end
, FULL_HEX
);
18810 print_vma (file_ofs
, FULL_HEX
);
18811 printf ("\n %s\n", filenames
);
18813 filenames
+= 1 + strlen ((char *) filenames
);
18819 static const char *
18820 get_gnu_elf_note_type (unsigned e_type
)
18822 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
18825 case NT_GNU_ABI_TAG
:
18826 return _("NT_GNU_ABI_TAG (ABI version tag)");
18828 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
18829 case NT_GNU_BUILD_ID
:
18830 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
18831 case NT_GNU_GOLD_VERSION
:
18832 return _("NT_GNU_GOLD_VERSION (gold version)");
18833 case NT_GNU_PROPERTY_TYPE_0
:
18834 return _("NT_GNU_PROPERTY_TYPE_0");
18835 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
18836 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
18837 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
18838 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
18841 static char buff
[64];
18843 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18850 decode_x86_compat_isa (unsigned int bitmask
)
18854 unsigned int bit
= bitmask
& (- bitmask
);
18859 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
18862 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
18865 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
18868 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
18871 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
18874 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
18877 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
18880 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
18883 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
18886 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
18889 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
18892 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
18893 printf ("AVX512F");
18895 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
18896 printf ("AVX512CD");
18898 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
18899 printf ("AVX512ER");
18901 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
18902 printf ("AVX512PF");
18904 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
18905 printf ("AVX512VL");
18907 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
18908 printf ("AVX512DQ");
18910 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
18911 printf ("AVX512BW");
18914 printf (_("<unknown: %x>"), bit
);
18923 decode_x86_compat_2_isa (unsigned int bitmask
)
18927 printf (_("<None>"));
18933 unsigned int bit
= bitmask
& (- bitmask
);
18938 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_CMOV
:
18941 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE
:
18944 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE2
:
18947 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE3
:
18950 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSSE3
:
18953 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_1
:
18956 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_2
:
18959 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX
:
18962 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX2
:
18965 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_FMA
:
18968 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512F
:
18969 printf ("AVX512F");
18971 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512CD
:
18972 printf ("AVX512CD");
18974 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512ER
:
18975 printf ("AVX512ER");
18977 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512PF
:
18978 printf ("AVX512PF");
18980 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512VL
:
18981 printf ("AVX512VL");
18983 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512DQ
:
18984 printf ("AVX512DQ");
18986 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512BW
:
18987 printf ("AVX512BW");
18989 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4FMAPS
:
18990 printf ("AVX512_4FMAPS");
18992 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4VNNIW
:
18993 printf ("AVX512_4VNNIW");
18995 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BITALG
:
18996 printf ("AVX512_BITALG");
18998 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_IFMA
:
18999 printf ("AVX512_IFMA");
19001 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI
:
19002 printf ("AVX512_VBMI");
19004 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI2
:
19005 printf ("AVX512_VBMI2");
19007 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VNNI
:
19008 printf ("AVX512_VNNI");
19010 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BF16
:
19011 printf ("AVX512_BF16");
19014 printf (_("<unknown: %x>"), bit
);
19023 decode_x86_isa (unsigned int bitmask
)
19027 unsigned int bit
= bitmask
& (- bitmask
);
19032 case GNU_PROPERTY_X86_ISA_1_BASELINE
:
19033 printf ("x86-64-baseline");
19035 case GNU_PROPERTY_X86_ISA_1_V2
:
19036 printf ("x86-64-v2");
19038 case GNU_PROPERTY_X86_ISA_1_V3
:
19039 printf ("x86-64-v3");
19041 case GNU_PROPERTY_X86_ISA_1_V4
:
19042 printf ("x86-64-v4");
19045 printf (_("<unknown: %x>"), bit
);
19054 decode_x86_feature_1 (unsigned int bitmask
)
19058 printf (_("<None>"));
19064 unsigned int bit
= bitmask
& (- bitmask
);
19069 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
19072 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
19075 case GNU_PROPERTY_X86_FEATURE_1_LAM_U48
:
19076 printf ("LAM_U48");
19078 case GNU_PROPERTY_X86_FEATURE_1_LAM_U57
:
19079 printf ("LAM_U57");
19082 printf (_("<unknown: %x>"), bit
);
19091 decode_x86_feature_2 (unsigned int bitmask
)
19095 printf (_("<None>"));
19101 unsigned int bit
= bitmask
& (- bitmask
);
19106 case GNU_PROPERTY_X86_FEATURE_2_X86
:
19109 case GNU_PROPERTY_X86_FEATURE_2_X87
:
19112 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
19115 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
19118 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
19121 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
19124 case GNU_PROPERTY_X86_FEATURE_2_TMM
:
19127 case GNU_PROPERTY_X86_FEATURE_2_MASK
:
19130 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
19133 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
19136 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
19137 printf ("XSAVEOPT");
19139 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
19143 printf (_("<unknown: %x>"), bit
);
19152 decode_aarch64_feature_1_and (unsigned int bitmask
)
19156 unsigned int bit
= bitmask
& (- bitmask
);
19161 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
19165 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
19170 printf (_("<unknown: %x>"), bit
);
19179 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
19181 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
19182 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
19183 unsigned int size
= is_32bit_elf
? 4 : 8;
19185 printf (_(" Properties: "));
19187 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
19189 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
19193 while (ptr
< ptr_end
)
19197 unsigned int datasz
;
19199 if ((size_t) (ptr_end
- ptr
) < 8)
19201 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
19205 type
= byte_get (ptr
, 4);
19206 datasz
= byte_get (ptr
+ 4, 4);
19210 if (datasz
> (size_t) (ptr_end
- ptr
))
19212 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
19217 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
19219 if (filedata
->file_header
.e_machine
== EM_X86_64
19220 || filedata
->file_header
.e_machine
== EM_IAMCU
19221 || filedata
->file_header
.e_machine
== EM_386
)
19223 unsigned int bitmask
;
19226 bitmask
= byte_get (ptr
, 4);
19232 case GNU_PROPERTY_X86_ISA_1_USED
:
19234 printf (_("x86 ISA used: <corrupt length: %#x> "),
19238 printf ("x86 ISA used: ");
19239 decode_x86_isa (bitmask
);
19243 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
19245 printf (_("x86 ISA needed: <corrupt length: %#x> "),
19249 printf ("x86 ISA needed: ");
19250 decode_x86_isa (bitmask
);
19254 case GNU_PROPERTY_X86_FEATURE_1_AND
:
19256 printf (_("x86 feature: <corrupt length: %#x> "),
19260 printf ("x86 feature: ");
19261 decode_x86_feature_1 (bitmask
);
19265 case GNU_PROPERTY_X86_FEATURE_2_USED
:
19267 printf (_("x86 feature used: <corrupt length: %#x> "),
19271 printf ("x86 feature used: ");
19272 decode_x86_feature_2 (bitmask
);
19276 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
19278 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
19281 printf ("x86 feature needed: ");
19282 decode_x86_feature_2 (bitmask
);
19286 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
19288 printf (_("x86 ISA used: <corrupt length: %#x> "),
19292 printf ("x86 ISA used: ");
19293 decode_x86_compat_isa (bitmask
);
19297 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
19299 printf (_("x86 ISA needed: <corrupt length: %#x> "),
19303 printf ("x86 ISA needed: ");
19304 decode_x86_compat_isa (bitmask
);
19308 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_USED
:
19310 printf (_("x86 ISA used: <corrupt length: %#x> "),
19314 printf ("x86 ISA used: ");
19315 decode_x86_compat_2_isa (bitmask
);
19319 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_NEEDED
:
19321 printf (_("x86 ISA needed: <corrupt length: %#x> "),
19325 printf ("x86 ISA needed: ");
19326 decode_x86_compat_2_isa (bitmask
);
19334 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
19336 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
19338 printf ("AArch64 feature: ");
19340 printf (_("<corrupt length: %#x> "), datasz
);
19342 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
19351 case GNU_PROPERTY_STACK_SIZE
:
19352 printf (_("stack size: "));
19353 if (datasz
!= size
)
19354 printf (_("<corrupt length: %#x> "), datasz
);
19356 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
19359 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
19360 printf ("no copy on protected ");
19362 printf (_("<corrupt length: %#x> "), datasz
);
19370 if (type
< GNU_PROPERTY_LOPROC
)
19371 printf (_("<unknown type %#x data: "), type
);
19372 else if (type
< GNU_PROPERTY_LOUSER
)
19373 printf (_("<processor-specific type %#x data: "), type
);
19375 printf (_("<application-specific type %#x data: "), type
);
19376 for (j
= 0; j
< datasz
; ++j
)
19377 printf ("%02x ", ptr
[j
] & 0xff);
19381 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
19382 if (ptr
== ptr_end
)
19395 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
19397 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
19398 switch (pnote
->type
)
19400 case NT_GNU_BUILD_ID
:
19404 printf (_(" Build ID: "));
19405 for (i
= 0; i
< pnote
->descsz
; ++i
)
19406 printf ("%02x", pnote
->descdata
[i
] & 0xff);
19411 case NT_GNU_ABI_TAG
:
19413 unsigned long os
, major
, minor
, subminor
;
19414 const char *osname
;
19416 /* PR 17531: file: 030-599401-0.004. */
19417 if (pnote
->descsz
< 16)
19419 printf (_(" <corrupt GNU_ABI_TAG>\n"));
19423 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19424 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19425 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
19426 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
19430 case GNU_ABI_TAG_LINUX
:
19433 case GNU_ABI_TAG_HURD
:
19436 case GNU_ABI_TAG_SOLARIS
:
19437 osname
= "Solaris";
19439 case GNU_ABI_TAG_FREEBSD
:
19440 osname
= "FreeBSD";
19442 case GNU_ABI_TAG_NETBSD
:
19445 case GNU_ABI_TAG_SYLLABLE
:
19446 osname
= "Syllable";
19448 case GNU_ABI_TAG_NACL
:
19452 osname
= "Unknown";
19456 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
19457 major
, minor
, subminor
);
19461 case NT_GNU_GOLD_VERSION
:
19465 printf (_(" Version: "));
19466 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
19467 printf ("%c", pnote
->descdata
[i
]);
19474 unsigned long num_entries
, mask
;
19476 /* Hardware capabilities information. Word 0 is the number of entries.
19477 Word 1 is a bitmask of enabled entries. The rest of the descriptor
19478 is a series of entries, where each entry is a single byte followed
19479 by a nul terminated string. The byte gives the bit number to test
19480 if enabled in the bitmask. */
19481 printf (_(" Hardware Capabilities: "));
19482 if (pnote
->descsz
< 8)
19484 error (_("<corrupt GNU_HWCAP>\n"));
19487 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19488 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19489 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
19490 /* FIXME: Add code to display the entries... */
19494 case NT_GNU_PROPERTY_TYPE_0
:
19495 print_gnu_property_note (filedata
, pnote
);
19499 /* Handle unrecognised types. An error message should have already been
19500 created by get_gnu_elf_note_type(), so all that we need to do is to
19501 display the data. */
19505 printf (_(" Description data: "));
19506 for (i
= 0; i
< pnote
->descsz
; ++i
)
19507 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19516 static const char *
19517 get_v850_elf_note_type (enum v850_notes n_type
)
19519 static char buff
[64];
19523 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
19524 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
19525 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
19526 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
19527 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
19528 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
19530 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
19536 print_v850_note (Elf_Internal_Note
* pnote
)
19540 if (pnote
->descsz
!= 4)
19543 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
19547 printf (_("not set\n"));
19551 switch (pnote
->type
)
19553 case V850_NOTE_ALIGNMENT
:
19556 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return true;
19557 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return true;
19561 case V850_NOTE_DATA_SIZE
:
19564 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return true;
19565 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return true;
19569 case V850_NOTE_FPU_INFO
:
19572 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return true;
19573 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return true;
19577 case V850_NOTE_MMU_INFO
:
19578 case V850_NOTE_CACHE_INFO
:
19579 case V850_NOTE_SIMD_INFO
:
19580 if (val
== EF_RH850_SIMD
)
19582 printf (_("yes\n"));
19588 /* An 'unknown note type' message will already have been displayed. */
19592 printf (_("unknown value: %x\n"), val
);
19597 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
19599 unsigned int version
;
19601 switch (pnote
->type
)
19603 case NT_NETBSD_IDENT
:
19604 if (pnote
->descsz
< 1)
19606 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
19607 if ((version
/ 10000) % 100)
19608 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
19609 version
, version
/ 100000000, (version
/ 1000000) % 100,
19610 (version
/ 10000) % 100 > 26 ? "Z" : "",
19611 'A' + (version
/ 10000) % 26);
19613 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
19614 version
, version
/ 100000000, (version
/ 1000000) % 100,
19615 (version
/ 100) % 100);
19618 case NT_NETBSD_MARCH
:
19619 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
19623 case NT_NETBSD_PAX
:
19624 if (pnote
->descsz
< 1)
19626 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
19627 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
19628 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
19629 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
19630 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
19631 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
19632 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
19633 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
19637 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
19638 pnote
->descsz
, pnote
->type
);
19642 static const char *
19643 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
19647 case NT_FREEBSD_THRMISC
:
19648 return _("NT_THRMISC (thrmisc structure)");
19649 case NT_FREEBSD_PROCSTAT_PROC
:
19650 return _("NT_PROCSTAT_PROC (proc data)");
19651 case NT_FREEBSD_PROCSTAT_FILES
:
19652 return _("NT_PROCSTAT_FILES (files data)");
19653 case NT_FREEBSD_PROCSTAT_VMMAP
:
19654 return _("NT_PROCSTAT_VMMAP (vmmap data)");
19655 case NT_FREEBSD_PROCSTAT_GROUPS
:
19656 return _("NT_PROCSTAT_GROUPS (groups data)");
19657 case NT_FREEBSD_PROCSTAT_UMASK
:
19658 return _("NT_PROCSTAT_UMASK (umask data)");
19659 case NT_FREEBSD_PROCSTAT_RLIMIT
:
19660 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
19661 case NT_FREEBSD_PROCSTAT_OSREL
:
19662 return _("NT_PROCSTAT_OSREL (osreldate data)");
19663 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
19664 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
19665 case NT_FREEBSD_PROCSTAT_AUXV
:
19666 return _("NT_PROCSTAT_AUXV (auxv data)");
19667 case NT_FREEBSD_PTLWPINFO
:
19668 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
19670 return get_note_type (filedata
, e_type
);
19673 static const char *
19674 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
19676 static char buff
[64];
19680 case NT_NETBSDCORE_PROCINFO
:
19681 /* NetBSD core "procinfo" structure. */
19682 return _("NetBSD procinfo structure");
19684 case NT_NETBSDCORE_AUXV
:
19685 return _("NetBSD ELF auxiliary vector data");
19687 case NT_NETBSDCORE_LWPSTATUS
:
19688 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
19691 /* As of Jan 2020 there are no other machine-independent notes
19692 defined for NetBSD core files. If the note type is less
19693 than the start of the machine-dependent note types, we don't
19696 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
19698 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19704 switch (filedata
->file_header
.e_machine
)
19706 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
19707 and PT_GETFPREGS == mach+2. */
19712 case EM_SPARC32PLUS
:
19716 case NT_NETBSDCORE_FIRSTMACH
+ 0:
19717 return _("PT_GETREGS (reg structure)");
19718 case NT_NETBSDCORE_FIRSTMACH
+ 2:
19719 return _("PT_GETFPREGS (fpreg structure)");
19725 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
19726 There's also old PT___GETREGS40 == mach + 1 for old reg
19727 structure which lacks GBR. */
19731 case NT_NETBSDCORE_FIRSTMACH
+ 1:
19732 return _("PT___GETREGS40 (old reg structure)");
19733 case NT_NETBSDCORE_FIRSTMACH
+ 3:
19734 return _("PT_GETREGS (reg structure)");
19735 case NT_NETBSDCORE_FIRSTMACH
+ 5:
19736 return _("PT_GETFPREGS (fpreg structure)");
19742 /* On all other arch's, PT_GETREGS == mach+1 and
19743 PT_GETFPREGS == mach+3. */
19747 case NT_NETBSDCORE_FIRSTMACH
+ 1:
19748 return _("PT_GETREGS (reg structure)");
19749 case NT_NETBSDCORE_FIRSTMACH
+ 3:
19750 return _("PT_GETFPREGS (fpreg structure)");
19756 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
19757 e_type
- NT_NETBSDCORE_FIRSTMACH
);
19761 static const char *
19762 get_stapsdt_note_type (unsigned e_type
)
19764 static char buff
[64];
19769 return _("NT_STAPSDT (SystemTap probe descriptors)");
19775 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19780 print_stapsdt_note (Elf_Internal_Note
*pnote
)
19782 size_t len
, maxlen
;
19783 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
19784 char *data
= pnote
->descdata
;
19785 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
19786 bfd_vma pc
, base_addr
, semaphore
;
19787 char *provider
, *probe
, *arg_fmt
;
19789 if (pnote
->descsz
< (addr_size
* 3))
19790 goto stapdt_note_too_small
;
19792 pc
= byte_get ((unsigned char *) data
, addr_size
);
19795 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
19798 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
19801 if (data
>= data_end
)
19802 goto stapdt_note_too_small
;
19803 maxlen
= data_end
- data
;
19804 len
= strnlen (data
, maxlen
);
19811 goto stapdt_note_too_small
;
19813 if (data
>= data_end
)
19814 goto stapdt_note_too_small
;
19815 maxlen
= data_end
- data
;
19816 len
= strnlen (data
, maxlen
);
19823 goto stapdt_note_too_small
;
19825 if (data
>= data_end
)
19826 goto stapdt_note_too_small
;
19827 maxlen
= data_end
- data
;
19828 len
= strnlen (data
, maxlen
);
19835 goto stapdt_note_too_small
;
19837 printf (_(" Provider: %s\n"), provider
);
19838 printf (_(" Name: %s\n"), probe
);
19839 printf (_(" Location: "));
19840 print_vma (pc
, FULL_HEX
);
19841 printf (_(", Base: "));
19842 print_vma (base_addr
, FULL_HEX
);
19843 printf (_(", Semaphore: "));
19844 print_vma (semaphore
, FULL_HEX
);
19846 printf (_(" Arguments: %s\n"), arg_fmt
);
19848 return data
== data_end
;
19850 stapdt_note_too_small
:
19851 printf (_(" <corrupt - note is too small>\n"));
19852 error (_("corrupt stapdt note - the data size is too small\n"));
19856 static const char *
19857 get_ia64_vms_note_type (unsigned e_type
)
19859 static char buff
[64];
19864 return _("NT_VMS_MHD (module header)");
19866 return _("NT_VMS_LNM (language name)");
19868 return _("NT_VMS_SRC (source files)");
19870 return "NT_VMS_TITLE";
19872 return _("NT_VMS_EIDC (consistency check)");
19873 case NT_VMS_FPMODE
:
19874 return _("NT_VMS_FPMODE (FP mode)");
19875 case NT_VMS_LINKTIME
:
19876 return "NT_VMS_LINKTIME";
19877 case NT_VMS_IMGNAM
:
19878 return _("NT_VMS_IMGNAM (image name)");
19880 return _("NT_VMS_IMGID (image id)");
19881 case NT_VMS_LINKID
:
19882 return _("NT_VMS_LINKID (link id)");
19883 case NT_VMS_IMGBID
:
19884 return _("NT_VMS_IMGBID (build id)");
19885 case NT_VMS_GSTNAM
:
19886 return _("NT_VMS_GSTNAM (sym table name)");
19887 case NT_VMS_ORIG_DYN
:
19888 return "NT_VMS_ORIG_DYN";
19889 case NT_VMS_PATCHTIME
:
19890 return "NT_VMS_PATCHTIME";
19892 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19898 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
19900 int maxlen
= pnote
->descsz
;
19902 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
19903 goto desc_size_fail
;
19905 switch (pnote
->type
)
19909 goto desc_size_fail
;
19911 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
19913 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
19914 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
19915 if (l
+ 34 < maxlen
)
19917 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
19918 if (l
+ 35 < maxlen
)
19919 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
19921 printf (_(" Module version : <missing>\n"));
19925 printf (_(" Module name : <missing>\n"));
19926 printf (_(" Module version : <missing>\n"));
19931 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
19935 case NT_VMS_FPMODE
:
19936 printf (_(" Floating Point mode: "));
19938 goto desc_size_fail
;
19939 /* FIXME: Generate an error if descsz > 8 ? */
19941 printf ("0x%016" BFD_VMA_FMT
"x\n",
19942 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19945 case NT_VMS_LINKTIME
:
19946 printf (_(" Link time: "));
19948 goto desc_size_fail
;
19949 /* FIXME: Generate an error if descsz > 8 ? */
19952 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19956 case NT_VMS_PATCHTIME
:
19957 printf (_(" Patch time: "));
19959 goto desc_size_fail
;
19960 /* FIXME: Generate an error if descsz > 8 ? */
19963 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19967 case NT_VMS_ORIG_DYN
:
19969 goto desc_size_fail
;
19971 printf (_(" Major id: %u, minor id: %u\n"),
19972 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
19973 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
19974 printf (_(" Last modified : "));
19976 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
19977 printf (_("\n Link flags : "));
19978 printf ("0x%016" BFD_VMA_FMT
"x\n",
19979 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
19980 printf (_(" Header flags: 0x%08x\n"),
19981 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
19982 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
19986 case NT_VMS_IMGNAM
:
19987 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
19990 case NT_VMS_GSTNAM
:
19991 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
19995 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
19998 case NT_VMS_LINKID
:
19999 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
20009 printf (_(" <corrupt - data size is too small>\n"));
20010 error (_("corrupt IA64 note: data size is too small\n"));
20014 struct build_attr_cache
{
20015 Filedata
*filedata
;
20017 unsigned long strtablen
;
20018 Elf_Internal_Sym
*symtab
;
20019 unsigned long nsyms
;
20022 /* Find the symbol associated with a build attribute that is attached
20023 to address OFFSET. If PNAME is non-NULL then store the name of
20024 the symbol (if found) in the provided pointer, Returns NULL if a
20025 symbol could not be found. */
20027 static Elf_Internal_Sym
*
20028 get_symbol_for_build_attribute (Filedata
*filedata
,
20029 unsigned long offset
,
20031 const char **pname
)
20033 Elf_Internal_Sym
*saved_sym
= NULL
;
20034 Elf_Internal_Sym
*sym
;
20036 if (filedata
->section_headers
!= NULL
20037 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
20039 Elf_Internal_Shdr
* symsec
;
20041 free (ba_cache
.strtab
);
20042 ba_cache
.strtab
= NULL
;
20043 free (ba_cache
.symtab
);
20044 ba_cache
.symtab
= NULL
;
20046 /* Load the symbol and string sections. */
20047 for (symsec
= filedata
->section_headers
;
20048 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
20051 if (symsec
->sh_type
== SHT_SYMTAB
20052 && get_symtab (filedata
, symsec
,
20053 &ba_cache
.symtab
, &ba_cache
.nsyms
,
20054 &ba_cache
.strtab
, &ba_cache
.strtablen
))
20057 ba_cache
.filedata
= filedata
;
20060 if (ba_cache
.symtab
== NULL
)
20063 /* Find a symbol whose value matches offset. */
20064 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
20065 if (sym
->st_value
== offset
)
20067 if (sym
->st_name
>= ba_cache
.strtablen
)
20068 /* Huh ? This should not happen. */
20071 if (ba_cache
.strtab
[sym
->st_name
] == 0)
20074 /* The AArch64 and ARM architectures define mapping symbols
20075 (eg $d, $x, $t) which we want to ignore. */
20076 if (ba_cache
.strtab
[sym
->st_name
] == '$'
20077 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
20078 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
20083 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
20084 and FILE or OBJECT symbols over NOTYPE symbols. We skip
20085 FUNC symbols entirely. */
20086 switch (ELF_ST_TYPE (sym
->st_info
))
20093 /* If the symbol has a size associated
20094 with it then we can stop searching. */
20095 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
20100 /* Ignore function symbols. */
20107 switch (ELF_ST_BIND (sym
->st_info
))
20110 if (saved_sym
== NULL
20111 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
20116 if (saved_sym
== NULL
)
20126 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
20134 if (saved_sym
&& pname
)
20135 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
20140 /* Returns true iff addr1 and addr2 are in the same section. */
20143 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
20145 Elf_Internal_Shdr
* a1
;
20146 Elf_Internal_Shdr
* a2
;
20148 a1
= find_section_by_address (filedata
, addr1
);
20149 a2
= find_section_by_address (filedata
, addr2
);
20151 return a1
== a2
&& a1
!= NULL
;
20155 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
20156 Filedata
* filedata
)
20158 static unsigned long global_offset
= 0;
20159 static unsigned long global_end
= 0;
20160 static unsigned long func_offset
= 0;
20161 static unsigned long func_end
= 0;
20163 Elf_Internal_Sym
*sym
;
20165 unsigned long start
;
20167 bool is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
20169 switch (pnote
->descsz
)
20172 /* A zero-length description means that the range of
20173 the previous note of the same type should be used. */
20176 if (global_end
> global_offset
)
20177 printf (_(" Applies to region from %#lx to %#lx\n"),
20178 global_offset
, global_end
);
20180 printf (_(" Applies to region from %#lx\n"), global_offset
);
20184 if (func_end
> func_offset
)
20185 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
20187 printf (_(" Applies to region from %#lx\n"), func_offset
);
20192 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20197 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20198 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
20202 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
20203 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
20207 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
20208 printf (_(" <invalid descsz>"));
20213 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
20214 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
20215 in order to avoid them being confused with the start address of the
20216 first function in the file... */
20217 if (sym
== NULL
&& is_open_attr
)
20218 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
20221 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
20222 end
= start
+ sym
->st_size
;
20226 /* FIXME: Need to properly allow for section alignment.
20227 16 is just the alignment used on x86_64. */
20229 && start
> BFD_ALIGN (global_end
, 16)
20230 /* Build notes are not guaranteed to be organised in order of
20231 increasing address, but we should find the all of the notes
20232 for one section in the same place. */
20233 && same_section (filedata
, start
, global_end
))
20234 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
20235 global_end
+ 1, start
- 1);
20237 printf (_(" Applies to region from %#lx"), start
);
20238 global_offset
= start
;
20242 printf (_(" to %#lx"), end
);
20248 printf (_(" Applies to region from %#lx"), start
);
20249 func_offset
= start
;
20253 printf (_(" to %#lx"), end
);
20259 printf (_(" (%s)"), name
);
20266 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
20268 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
20269 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
20270 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
20272 char name_attribute
;
20273 const char * expected_types
;
20274 const char * name
= pnote
->namedata
;
20278 if (name
== NULL
|| pnote
->namesz
< 2)
20280 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
20281 print_symbol (-20, _(" <corrupt name>"));
20290 /* Version 2 of the spec adds a "GA" prefix to the name field. */
20291 if (name
[0] == 'G' && name
[1] == 'A')
20293 if (pnote
->namesz
< 4)
20295 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
20296 print_symbol (-20, _(" <corrupt name>"));
20305 switch ((name_type
= * name
))
20307 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
20308 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
20309 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
20310 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
20311 printf ("%c", * name
);
20315 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
20316 print_symbol (-20, _("<unknown name type>"));
20323 switch ((name_attribute
= * name
))
20325 case GNU_BUILD_ATTRIBUTE_VERSION
:
20326 text
= _("<version>");
20327 expected_types
= string_expected
;
20330 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
20331 text
= _("<stack prot>");
20332 expected_types
= "!+*";
20335 case GNU_BUILD_ATTRIBUTE_RELRO
:
20336 text
= _("<relro>");
20337 expected_types
= bool_expected
;
20340 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
20341 text
= _("<stack size>");
20342 expected_types
= number_expected
;
20345 case GNU_BUILD_ATTRIBUTE_TOOL
:
20346 text
= _("<tool>");
20347 expected_types
= string_expected
;
20350 case GNU_BUILD_ATTRIBUTE_ABI
:
20352 expected_types
= "$*";
20355 case GNU_BUILD_ATTRIBUTE_PIC
:
20357 expected_types
= number_expected
;
20360 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
20361 text
= _("<short enum>");
20362 expected_types
= bool_expected
;
20366 if (ISPRINT (* name
))
20368 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
20370 if (len
> left
&& ! do_wide
)
20372 printf ("%.*s:", len
, name
);
20378 static char tmpbuf
[128];
20380 error (_("unrecognised byte in name field: %d\n"), * name
);
20381 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
20385 expected_types
= "*$!+";
20390 left
-= printf ("%s", text
);
20392 if (strchr (expected_types
, name_type
) == NULL
)
20393 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
20395 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
20397 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
20398 (unsigned long) pnote
->namesz
,
20399 (long) (name
- pnote
->namedata
));
20403 if (left
< 1 && ! do_wide
)
20408 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
20410 unsigned int bytes
;
20411 unsigned long long val
= 0;
20412 unsigned int shift
= 0;
20413 char * decoded
= NULL
;
20415 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
20417 /* The -1 is because the name field is always 0 terminated, and we
20418 want to be able to ensure that the shift in the while loop below
20419 will not overflow. */
20422 if (bytes
> sizeof (val
))
20424 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
20426 bytes
= sizeof (val
);
20428 /* We do not bother to warn if bytes == 0 as this can
20429 happen with some early versions of the gcc plugin. */
20433 unsigned long long byte
= *name
++ & 0xff;
20435 val
|= byte
<< shift
;
20439 switch (name_attribute
)
20441 case GNU_BUILD_ATTRIBUTE_PIC
:
20444 case 0: decoded
= "static"; break;
20445 case 1: decoded
= "pic"; break;
20446 case 2: decoded
= "PIC"; break;
20447 case 3: decoded
= "pie"; break;
20448 case 4: decoded
= "PIE"; break;
20452 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
20455 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
20456 case 0: decoded
= "off"; break;
20457 case 1: decoded
= "on"; break;
20458 case 2: decoded
= "all"; break;
20459 case 3: decoded
= "strong"; break;
20460 case 4: decoded
= "explicit"; break;
20468 if (decoded
!= NULL
)
20470 print_symbol (-left
, decoded
);
20481 left
-= printf ("0x%llx", val
);
20483 left
-= printf ("0x%-.*llx", left
, val
);
20487 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
20488 left
-= print_symbol (- left
, name
);
20490 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
20491 left
-= print_symbol (- left
, "true");
20493 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
20494 left
-= print_symbol (- left
, "false");
20498 if (do_wide
&& left
> 0)
20499 printf ("%-*s", left
, " ");
20504 /* Note that by the ELF standard, the name field is already null byte
20505 terminated, and namesz includes the terminating null byte.
20506 I.E. the value of namesz for the name "FSF" is 4.
20508 If the value of namesz is zero, there is no name present. */
20511 process_note (Elf_Internal_Note
* pnote
,
20512 Filedata
* filedata
)
20514 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
20517 if (pnote
->namesz
== 0)
20518 /* If there is no note name, then use the default set of
20519 note type strings. */
20520 nt
= get_note_type (filedata
, pnote
->type
);
20522 else if (startswith (pnote
->namedata
, "GNU"))
20523 /* GNU-specific object file notes. */
20524 nt
= get_gnu_elf_note_type (pnote
->type
);
20526 else if (startswith (pnote
->namedata
, "FreeBSD"))
20527 /* FreeBSD-specific core file notes. */
20528 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
20530 else if (startswith (pnote
->namedata
, "NetBSD-CORE"))
20531 /* NetBSD-specific core file notes. */
20532 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
20534 else if (startswith (pnote
->namedata
, "NetBSD"))
20535 /* NetBSD-specific core file notes. */
20536 return process_netbsd_elf_note (pnote
);
20538 else if (startswith (pnote
->namedata
, "PaX"))
20539 /* NetBSD-specific core file notes. */
20540 return process_netbsd_elf_note (pnote
);
20542 else if (startswith (pnote
->namedata
, "SPU/"))
20544 /* SPU-specific core file notes. */
20545 nt
= pnote
->namedata
+ 4;
20549 else if (startswith (pnote
->namedata
, "IPF/VMS"))
20550 /* VMS/ia64-specific file notes. */
20551 nt
= get_ia64_vms_note_type (pnote
->type
);
20553 else if (startswith (pnote
->namedata
, "stapsdt"))
20554 nt
= get_stapsdt_note_type (pnote
->type
);
20557 /* Don't recognize this note name; just use the default set of
20558 note type strings. */
20559 nt
= get_note_type (filedata
, pnote
->type
);
20563 if (((startswith (pnote
->namedata
, "GA")
20564 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
20565 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
20566 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
20567 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
20568 print_gnu_build_attribute_name (pnote
);
20570 print_symbol (-20, name
);
20573 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
20575 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
20577 if (startswith (pnote
->namedata
, "IPF/VMS"))
20578 return print_ia64_vms_note (pnote
);
20579 else if (startswith (pnote
->namedata
, "GNU"))
20580 return print_gnu_note (filedata
, pnote
);
20581 else if (startswith (pnote
->namedata
, "stapsdt"))
20582 return print_stapsdt_note (pnote
);
20583 else if (startswith (pnote
->namedata
, "CORE"))
20584 return print_core_note (pnote
);
20585 else if (((startswith (pnote
->namedata
, "GA")
20586 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
20587 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
20588 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
20589 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
20590 return print_gnu_build_attribute_description (pnote
, filedata
);
20596 printf (_(" description data: "));
20597 for (i
= 0; i
< pnote
->descsz
; i
++)
20598 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
20610 process_notes_at (Filedata
* filedata
,
20611 Elf_Internal_Shdr
* section
,
20616 Elf_External_Note
*pnotes
;
20617 Elf_External_Note
*external
;
20626 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
20629 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
20637 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
20640 if (pnotes
== NULL
)
20645 if (filedata
->is_separate
)
20646 printf (_("In linked file '%s': "), filedata
->file_name
);
20650 printf (_("Displaying notes found in: %s\n"), printable_section_name (filedata
, section
));
20652 printf (_("Displaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
20653 (unsigned long) offset
, (unsigned long) length
);
20655 /* NB: Some note sections may have alignment value of 0 or 1. gABI
20656 specifies that notes should be aligned to 4 bytes in 32-bit
20657 objects and to 8 bytes in 64-bit objects. As a Linux extension,
20658 we also support 4 byte alignment in 64-bit objects. If section
20659 alignment is less than 4, we treate alignment as 4 bytes. */
20662 else if (align
!= 4 && align
!= 8)
20664 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
20670 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
20672 end
= (char *) pnotes
+ length
;
20673 while ((char *) external
< end
)
20675 Elf_Internal_Note inote
;
20678 char * temp
= NULL
;
20679 size_t data_remaining
= end
- (char *) external
;
20681 if (!is_ia64_vms (filedata
))
20683 /* PR binutils/15191
20684 Make sure that there is enough data to read. */
20685 min_notesz
= offsetof (Elf_External_Note
, name
);
20686 if (data_remaining
< min_notesz
)
20688 warn (ngettext ("Corrupt note: only %ld byte remains, "
20689 "not enough for a full note\n",
20690 "Corrupt note: only %ld bytes remain, "
20691 "not enough for a full note\n",
20693 (long) data_remaining
);
20696 data_remaining
-= min_notesz
;
20698 inote
.type
= BYTE_GET (external
->type
);
20699 inote
.namesz
= BYTE_GET (external
->namesz
);
20700 inote
.namedata
= external
->name
;
20701 inote
.descsz
= BYTE_GET (external
->descsz
);
20702 inote
.descdata
= ((char *) external
20703 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
20704 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20705 next
= ((char *) external
20706 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
20710 Elf64_External_VMS_Note
*vms_external
;
20712 /* PR binutils/15191
20713 Make sure that there is enough data to read. */
20714 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
20715 if (data_remaining
< min_notesz
)
20717 warn (ngettext ("Corrupt note: only %ld byte remains, "
20718 "not enough for a full note\n",
20719 "Corrupt note: only %ld bytes remain, "
20720 "not enough for a full note\n",
20722 (long) data_remaining
);
20725 data_remaining
-= min_notesz
;
20727 vms_external
= (Elf64_External_VMS_Note
*) external
;
20728 inote
.type
= BYTE_GET (vms_external
->type
);
20729 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
20730 inote
.namedata
= vms_external
->name
;
20731 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
20732 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
20733 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20734 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
20737 /* PR 17531: file: 3443835e. */
20738 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
20739 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
20740 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
20741 || (size_t) (next
- inote
.descdata
) < inote
.descsz
20742 || ((size_t) (next
- inote
.descdata
)
20743 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
20745 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
20746 (unsigned long) ((char *) external
- (char *) pnotes
));
20747 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
20748 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
20752 external
= (Elf_External_Note
*) next
;
20754 /* Verify that name is null terminated. It appears that at least
20755 one version of Linux (RedHat 6.0) generates corefiles that don't
20756 comply with the ELF spec by failing to include the null byte in
20758 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
20760 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
20762 temp
= (char *) malloc (inote
.namesz
+ 1);
20765 error (_("Out of memory allocating space for inote name\n"));
20770 memcpy (temp
, inote
.namedata
, inote
.namesz
);
20771 inote
.namedata
= temp
;
20773 inote
.namedata
[inote
.namesz
] = 0;
20776 if (! process_note (& inote
, filedata
))
20789 process_corefile_note_segments (Filedata
* filedata
)
20791 Elf_Internal_Phdr
*segment
;
20795 if (! get_program_headers (filedata
))
20798 for (i
= 0, segment
= filedata
->program_headers
;
20799 i
< filedata
->file_header
.e_phnum
;
20802 if (segment
->p_type
== PT_NOTE
)
20803 if (! process_notes_at (filedata
, NULL
,
20804 (bfd_vma
) segment
->p_offset
,
20805 (bfd_vma
) segment
->p_filesz
,
20806 (bfd_vma
) segment
->p_align
))
20814 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
20816 Elf_External_Note
* pnotes
;
20817 Elf_External_Note
* external
;
20824 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
20826 if (pnotes
== NULL
)
20830 end
= (char*) pnotes
+ length
;
20832 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
20833 (unsigned long) offset
, (unsigned long) length
);
20835 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
20837 Elf_External_Note
* next
;
20838 Elf_Internal_Note inote
;
20840 inote
.type
= BYTE_GET (external
->type
);
20841 inote
.namesz
= BYTE_GET (external
->namesz
);
20842 inote
.namedata
= external
->name
;
20843 inote
.descsz
= BYTE_GET (external
->descsz
);
20844 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
20845 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20847 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
20849 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
20850 inote
.descdata
= inote
.namedata
;
20854 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
20856 if ( ((char *) next
> end
)
20857 || ((char *) next
< (char *) pnotes
))
20859 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
20860 (unsigned long) ((char *) external
- (char *) pnotes
));
20861 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
20862 inote
.type
, inote
.namesz
, inote
.descsz
);
20868 /* Prevent out-of-bounds indexing. */
20869 if ( inote
.namedata
+ inote
.namesz
> end
20870 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
20872 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
20873 (unsigned long) ((char *) external
- (char *) pnotes
));
20874 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
20875 inote
.type
, inote
.namesz
, inote
.descsz
);
20879 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
20881 if (! print_v850_note (& inote
))
20884 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
20885 inote
.namesz
, inote
.descsz
);
20895 process_note_sections (Filedata
* filedata
)
20897 Elf_Internal_Shdr
*section
;
20899 unsigned int n
= 0;
20902 for (i
= 0, section
= filedata
->section_headers
;
20903 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
20906 if (section
->sh_type
== SHT_NOTE
)
20908 if (! process_notes_at (filedata
, section
,
20909 (bfd_vma
) section
->sh_offset
,
20910 (bfd_vma
) section
->sh_size
,
20911 (bfd_vma
) section
->sh_addralign
))
20916 if (( filedata
->file_header
.e_machine
== EM_V800
20917 || filedata
->file_header
.e_machine
== EM_V850
20918 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
20919 && section
->sh_type
== SHT_RENESAS_INFO
)
20921 if (! process_v850_notes (filedata
,
20922 (bfd_vma
) section
->sh_offset
,
20923 (bfd_vma
) section
->sh_size
))
20930 /* Try processing NOTE segments instead. */
20931 return process_corefile_note_segments (filedata
);
20937 process_notes (Filedata
* filedata
)
20939 /* If we have not been asked to display the notes then do nothing. */
20943 if (filedata
->file_header
.e_type
!= ET_CORE
)
20944 return process_note_sections (filedata
);
20946 /* No program headers means no NOTE segment. */
20947 if (filedata
->file_header
.e_phnum
> 0)
20948 return process_corefile_note_segments (filedata
);
20950 if (filedata
->is_separate
)
20951 printf (_("No notes found in linked file '%s'.\n"),
20952 filedata
->file_name
);
20954 printf (_("No notes found file.\n"));
20959 static unsigned char *
20960 display_public_gnu_attributes (unsigned char * start
,
20961 const unsigned char * const end
)
20963 printf (_(" Unknown GNU attribute: %s\n"), start
);
20965 start
+= strnlen ((char *) start
, end
- start
);
20966 display_raw_attribute (start
, end
);
20968 return (unsigned char *) end
;
20971 static unsigned char *
20972 display_generic_attribute (unsigned char * start
,
20974 const unsigned char * const end
)
20977 return (unsigned char *) end
;
20979 return display_tag_value (tag
, start
, end
);
20983 process_arch_specific (Filedata
* filedata
)
20988 switch (filedata
->file_header
.e_machine
)
20991 case EM_ARC_COMPACT
:
20992 case EM_ARC_COMPACT2
:
20993 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
20994 display_arc_attribute
,
20995 display_generic_attribute
);
20997 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
20998 display_arm_attribute
,
20999 display_generic_attribute
);
21002 case EM_MIPS_RS3_LE
:
21003 return process_mips_specific (filedata
);
21006 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
21007 display_msp430_attribute
,
21008 display_msp430_gnu_attribute
);
21011 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
21012 display_riscv_attribute
,
21013 display_generic_attribute
);
21016 return process_nds32_specific (filedata
);
21019 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21020 display_m68k_gnu_attribute
);
21024 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21025 display_power_gnu_attribute
);
21029 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21030 display_s390_gnu_attribute
);
21033 case EM_SPARC32PLUS
:
21035 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21036 display_sparc_gnu_attribute
);
21039 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
21040 display_tic6x_attribute
,
21041 display_generic_attribute
);
21044 return process_attributes (filedata
, "csky", SHT_CSKY_ATTRIBUTES
,
21045 display_csky_attribute
, NULL
);
21048 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
21049 display_public_gnu_attributes
,
21050 display_generic_attribute
);
21055 get_file_header (Filedata
* filedata
)
21057 /* Read in the identity array. */
21058 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
21061 /* Determine how to read the rest of the header. */
21062 switch (filedata
->file_header
.e_ident
[EI_DATA
])
21067 byte_get
= byte_get_little_endian
;
21068 byte_put
= byte_put_little_endian
;
21071 byte_get
= byte_get_big_endian
;
21072 byte_put
= byte_put_big_endian
;
21076 /* For now we only support 32 bit and 64 bit ELF files. */
21077 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
21079 /* Read in the rest of the header. */
21082 Elf32_External_Ehdr ehdr32
;
21084 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
21087 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
21088 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
21089 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
21090 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
21091 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
21092 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
21093 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
21094 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
21095 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
21096 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
21097 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
21098 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
21099 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
21103 Elf64_External_Ehdr ehdr64
;
21105 /* If we have been compiled with sizeof (bfd_vma) == 4, then
21106 we will not be able to cope with the 64bit data found in
21107 64 ELF files. Detect this now and abort before we start
21108 overwriting things. */
21109 if (sizeof (bfd_vma
) < 8)
21111 error (_("This instance of readelf has been built without support for a\n\
21112 64 bit data type and so it cannot read 64 bit ELF files.\n"));
21116 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
21119 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
21120 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
21121 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
21122 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
21123 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
21124 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
21125 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
21126 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
21127 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
21128 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
21129 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
21130 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
21131 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
21134 if (filedata
->file_header
.e_shoff
)
21136 /* There may be some extensions in the first section header. Don't
21137 bomb if we can't read it. */
21139 get_32bit_section_headers (filedata
, true);
21141 get_64bit_section_headers (filedata
, true);
21148 free_filedata (Filedata
*filedata
)
21150 free (filedata
->program_interpreter
);
21151 filedata
->program_interpreter
= NULL
;
21153 free (filedata
->program_headers
);
21154 filedata
->program_headers
= NULL
;
21156 free (filedata
->section_headers
);
21157 filedata
->section_headers
= NULL
;
21159 free (filedata
->string_table
);
21160 filedata
->string_table
= NULL
;
21161 filedata
->string_table_length
= 0;
21163 free (filedata
->dump
.dump_sects
);
21164 filedata
->dump
.dump_sects
= NULL
;
21165 filedata
->dump
.num_dump_sects
= 0;
21167 free (filedata
->dynamic_strings
);
21168 filedata
->dynamic_strings
= NULL
;
21169 filedata
->dynamic_strings_length
= 0;
21171 free (filedata
->dynamic_symbols
);
21172 filedata
->dynamic_symbols
= NULL
;
21173 filedata
->num_dynamic_syms
= 0;
21175 free (filedata
->dynamic_syminfo
);
21176 filedata
->dynamic_syminfo
= NULL
;
21178 free (filedata
->dynamic_section
);
21179 filedata
->dynamic_section
= NULL
;
21181 while (filedata
->symtab_shndx_list
!= NULL
)
21183 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
21184 free (filedata
->symtab_shndx_list
);
21185 filedata
->symtab_shndx_list
= next
;
21188 free (filedata
->section_headers_groups
);
21189 filedata
->section_headers_groups
= NULL
;
21191 if (filedata
->section_groups
)
21194 struct group_list
* g
;
21195 struct group_list
* next
;
21197 for (i
= 0; i
< filedata
->group_count
; i
++)
21199 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
21206 free (filedata
->section_groups
);
21207 filedata
->section_groups
= NULL
;
21212 close_file (Filedata
* filedata
)
21216 if (filedata
->handle
)
21217 fclose (filedata
->handle
);
21223 close_debug_file (void * data
)
21225 free_filedata ((Filedata
*) data
);
21226 close_file ((Filedata
*) data
);
21230 open_file (const char * pathname
, bool is_separate
)
21232 struct stat statbuf
;
21233 Filedata
* filedata
= NULL
;
21235 if (stat (pathname
, & statbuf
) < 0
21236 || ! S_ISREG (statbuf
.st_mode
))
21239 filedata
= calloc (1, sizeof * filedata
);
21240 if (filedata
== NULL
)
21243 filedata
->handle
= fopen (pathname
, "rb");
21244 if (filedata
->handle
== NULL
)
21247 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
21248 filedata
->file_name
= pathname
;
21249 filedata
->is_separate
= is_separate
;
21251 if (! get_file_header (filedata
))
21254 if (filedata
->file_header
.e_shoff
)
21258 /* Read the section headers again, this time for real. */
21260 res
= get_32bit_section_headers (filedata
, false);
21262 res
= get_64bit_section_headers (filedata
, false);
21273 if (filedata
->handle
)
21274 fclose (filedata
->handle
);
21281 open_debug_file (const char * pathname
)
21283 return open_file (pathname
, true);
21287 initialise_dump_sects (Filedata
* filedata
)
21289 /* Initialise the dump_sects array from the cmdline_dump_sects array.
21290 Note we do this even if cmdline_dump_sects is empty because we
21291 must make sure that the dump_sets array is zeroed out before each
21292 object file is processed. */
21293 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
21294 memset (filedata
->dump
.dump_sects
, 0,
21295 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
21297 if (cmdline
.num_dump_sects
> 0)
21299 if (filedata
->dump
.num_dump_sects
== 0)
21300 /* A sneaky way of allocating the dump_sects array. */
21301 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
21303 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
21304 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
21305 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
21309 /* Process one ELF object file according to the command line options.
21310 This file may actually be stored in an archive. The file is
21311 positioned at the start of the ELF object. Returns TRUE if no
21312 problems were encountered, FALSE otherwise. */
21315 process_object (Filedata
* filedata
)
21317 bool have_separate_files
;
21321 if (! get_file_header (filedata
))
21323 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
21327 /* Initialise per file variables. */
21328 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
21329 filedata
->version_info
[i
] = 0;
21331 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
21332 filedata
->dynamic_info
[i
] = 0;
21333 filedata
->dynamic_info_DT_GNU_HASH
= 0;
21334 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
21336 /* Process the file. */
21338 printf (_("\nFile: %s\n"), filedata
->file_name
);
21340 initialise_dump_sects (filedata
);
21342 if (! process_file_header (filedata
))
21345 if (! process_section_headers (filedata
))
21347 /* Without loaded section headers we cannot process lots of things. */
21348 do_unwind
= do_version
= do_dump
= do_arch
= false;
21350 if (! do_using_dynamic
)
21351 do_syms
= do_dyn_syms
= do_reloc
= false;
21354 if (! process_section_groups (filedata
))
21355 /* Without loaded section groups we cannot process unwind. */
21358 res
= process_program_headers (filedata
);
21360 res
= process_dynamic_section (filedata
);
21362 if (! process_relocs (filedata
))
21365 if (! process_unwind (filedata
))
21368 if (! process_symbol_table (filedata
))
21371 if (! process_lto_symbol_tables (filedata
))
21374 if (! process_syminfo (filedata
))
21377 if (! process_version_sections (filedata
))
21380 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
21381 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
21383 have_separate_files
= false;
21385 if (! process_section_contents (filedata
))
21388 if (have_separate_files
)
21392 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
21394 initialise_dump_sects (d
->handle
);
21396 if (process_links
&& ! process_file_header (d
->handle
))
21398 else if (! process_section_headers (d
->handle
))
21400 else if (! process_section_contents (d
->handle
))
21402 else if (process_links
)
21404 if (! process_section_groups (d
->handle
))
21406 if (! process_program_headers (d
->handle
))
21408 if (! process_dynamic_section (d
->handle
))
21410 if (! process_relocs (d
->handle
))
21412 if (! process_unwind (d
->handle
))
21414 if (! process_symbol_table (d
->handle
))
21416 if (! process_lto_symbol_tables (d
->handle
))
21418 if (! process_syminfo (d
->handle
))
21420 if (! process_version_sections (d
->handle
))
21422 if (! process_notes (d
->handle
))
21427 /* The file handles are closed by the call to free_debug_memory() below. */
21430 if (! process_notes (filedata
))
21433 if (! process_gnu_liblist (filedata
))
21436 if (! process_arch_specific (filedata
))
21439 free_filedata (filedata
);
21441 free_debug_memory ();
21446 /* Process an ELF archive.
21447 On entry the file is positioned just after the ARMAG string.
21448 Returns TRUE upon success, FALSE otherwise. */
21451 process_archive (Filedata
* filedata
, bool is_thin_archive
)
21453 struct archive_info arch
;
21454 struct archive_info nested_arch
;
21460 /* The ARCH structure is used to hold information about this archive. */
21461 arch
.file_name
= NULL
;
21463 arch
.index_array
= NULL
;
21464 arch
.sym_table
= NULL
;
21465 arch
.longnames
= NULL
;
21467 /* The NESTED_ARCH structure is used as a single-item cache of information
21468 about a nested archive (when members of a thin archive reside within
21469 another regular archive file). */
21470 nested_arch
.file_name
= NULL
;
21471 nested_arch
.file
= NULL
;
21472 nested_arch
.index_array
= NULL
;
21473 nested_arch
.sym_table
= NULL
;
21474 nested_arch
.longnames
= NULL
;
21476 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
21477 filedata
->file_size
, is_thin_archive
,
21478 do_archive_index
) != 0)
21484 if (do_archive_index
)
21486 if (arch
.sym_table
== NULL
)
21487 error (_("%s: unable to dump the index as none was found\n"),
21488 filedata
->file_name
);
21491 unsigned long i
, l
;
21492 unsigned long current_pos
;
21494 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
21495 "in the symbol table)\n"),
21496 filedata
->file_name
, (unsigned long) arch
.index_num
,
21499 current_pos
= ftell (filedata
->handle
);
21501 for (i
= l
= 0; i
< arch
.index_num
; i
++)
21504 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
21507 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
21510 if (member_name
!= NULL
)
21512 char * qualified_name
21513 = make_qualified_name (&arch
, &nested_arch
,
21516 if (qualified_name
!= NULL
)
21518 printf (_("Contents of binary %s at offset "),
21520 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
21522 free (qualified_name
);
21524 free (member_name
);
21528 if (l
>= arch
.sym_size
)
21530 error (_("%s: end of the symbol table reached "
21531 "before the end of the index\n"),
21532 filedata
->file_name
);
21536 /* PR 17531: file: 0b6630b2. */
21537 printf ("\t%.*s\n",
21538 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
21539 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
21542 if (arch
.uses_64bit_indices
)
21547 if (l
< arch
.sym_size
)
21549 error (ngettext ("%s: %ld byte remains in the symbol table, "
21550 "but without corresponding entries in "
21551 "the index table\n",
21552 "%s: %ld bytes remain in the symbol table, "
21553 "but without corresponding entries in "
21554 "the index table\n",
21555 arch
.sym_size
- l
),
21556 filedata
->file_name
, arch
.sym_size
- l
);
21560 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
21562 error (_("%s: failed to seek back to start of object files "
21563 "in the archive\n"),
21564 filedata
->file_name
);
21570 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
21571 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
21572 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
21573 && !do_section_groups
&& !do_dyn_syms
)
21575 ret
= true; /* Archive index only. */
21584 char * qualified_name
;
21586 /* Read the next archive header. */
21587 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
21589 error (_("%s: failed to seek to next archive header\n"),
21594 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
21595 if (got
!= sizeof arch
.arhdr
)
21599 /* PR 24049 - we cannot use filedata->file_name as this will
21600 have already been freed. */
21601 error (_("%s: failed to read archive header\n"), arch
.file_name
);
21606 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
21608 error (_("%s: did not find a valid archive header\n"),
21614 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
21616 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
21617 if (filedata
->archive_file_size
& 01)
21618 ++filedata
->archive_file_size
;
21620 name
= get_archive_member_name (&arch
, &nested_arch
);
21623 error (_("%s: bad archive file name\n"), arch
.file_name
);
21627 namelen
= strlen (name
);
21629 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
21630 if (qualified_name
== NULL
)
21632 error (_("%s: bad archive file name\n"), arch
.file_name
);
21638 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
21640 /* This is a proxy for an external member of a thin archive. */
21641 Filedata
* member_filedata
;
21642 char * member_file_name
= adjust_relative_path
21643 (filedata
->file_name
, name
, namelen
);
21646 if (member_file_name
== NULL
)
21648 free (qualified_name
);
21653 member_filedata
= open_file (member_file_name
, false);
21654 if (member_filedata
== NULL
)
21656 error (_("Input file '%s' is not readable.\n"), member_file_name
);
21657 free (member_file_name
);
21658 free (qualified_name
);
21663 filedata
->archive_file_offset
= arch
.nested_member_origin
;
21664 member_filedata
->file_name
= qualified_name
;
21666 if (! process_object (member_filedata
))
21669 close_file (member_filedata
);
21670 free (member_file_name
);
21672 else if (is_thin_archive
)
21674 Filedata thin_filedata
;
21676 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
21678 /* PR 15140: Allow for corrupt thin archives. */
21679 if (nested_arch
.file
== NULL
)
21681 error (_("%s: contains corrupt thin archive: %s\n"),
21682 qualified_name
, name
);
21683 free (qualified_name
);
21690 /* This is a proxy for a member of a nested archive. */
21691 filedata
->archive_file_offset
21692 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
21694 /* The nested archive file will have been opened and setup by
21695 get_archive_member_name. */
21696 if (fseek (nested_arch
.file
, filedata
->archive_file_offset
,
21699 error (_("%s: failed to seek to archive member.\n"),
21700 nested_arch
.file_name
);
21701 free (qualified_name
);
21706 thin_filedata
.handle
= nested_arch
.file
;
21707 thin_filedata
.file_name
= qualified_name
;
21709 if (! process_object (& thin_filedata
))
21715 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
21716 filedata
->file_name
= qualified_name
;
21717 if (! process_object (filedata
))
21719 arch
.next_arhdr_offset
+= filedata
->archive_file_size
;
21720 /* Stop looping with "negative" archive_file_size. */
21721 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
21722 arch
.next_arhdr_offset
= -1ul;
21725 free (qualified_name
);
21729 if (nested_arch
.file
!= NULL
)
21730 fclose (nested_arch
.file
);
21731 release_archive (&nested_arch
);
21732 release_archive (&arch
);
21738 process_file (char * file_name
)
21740 Filedata
* filedata
= NULL
;
21741 struct stat statbuf
;
21742 char armag
[SARMAG
];
21745 if (stat (file_name
, &statbuf
) < 0)
21747 if (errno
== ENOENT
)
21748 error (_("'%s': No such file\n"), file_name
);
21750 error (_("Could not locate '%s'. System error message: %s\n"),
21751 file_name
, strerror (errno
));
21755 if (! S_ISREG (statbuf
.st_mode
))
21757 error (_("'%s' is not an ordinary file\n"), file_name
);
21761 filedata
= calloc (1, sizeof * filedata
);
21762 if (filedata
== NULL
)
21764 error (_("Out of memory allocating file data structure\n"));
21768 filedata
->file_name
= file_name
;
21769 filedata
->handle
= fopen (file_name
, "rb");
21770 if (filedata
->handle
== NULL
)
21772 error (_("Input file '%s' is not readable.\n"), file_name
);
21777 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
21779 error (_("%s: Failed to read file's magic number\n"), file_name
);
21780 fclose (filedata
->handle
);
21785 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
21786 filedata
->is_separate
= false;
21788 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
21790 if (! process_archive (filedata
, false))
21793 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
21795 if ( ! process_archive (filedata
, true))
21800 if (do_archive_index
&& !check_all
)
21801 error (_("File %s is not an archive so its index cannot be displayed.\n"),
21804 rewind (filedata
->handle
);
21805 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
21807 if (! process_object (filedata
))
21811 fclose (filedata
->handle
);
21812 free (filedata
->section_headers
);
21813 free (filedata
->program_headers
);
21814 free (filedata
->string_table
);
21815 free (filedata
->dump
.dump_sects
);
21818 free (ba_cache
.strtab
);
21819 ba_cache
.strtab
= NULL
;
21820 free (ba_cache
.symtab
);
21821 ba_cache
.symtab
= NULL
;
21822 ba_cache
.filedata
= NULL
;
21827 #ifdef SUPPORT_DISASSEMBLY
21828 /* Needed by the i386 disassembler. For extra credit, someone could
21829 fix this so that we insert symbolic addresses here, esp for GOT/PLT
21833 print_address (unsigned int addr
, FILE * outfile
)
21835 fprintf (outfile
,"0x%8.8x", addr
);
21838 /* Needed by the i386 disassembler. */
21841 db_task_printsym (unsigned int addr
)
21843 print_address (addr
, stderr
);
21848 main (int argc
, char ** argv
)
21852 #ifdef HAVE_LC_MESSAGES
21853 setlocale (LC_MESSAGES
, "");
21855 setlocale (LC_CTYPE
, "");
21856 bindtextdomain (PACKAGE
, LOCALEDIR
);
21857 textdomain (PACKAGE
);
21859 expandargv (&argc
, &argv
);
21861 parse_args (& cmdline
, argc
, argv
);
21863 if (optind
< (argc
- 1))
21864 /* When displaying information for more than one file,
21865 prefix the information with the file name. */
21867 else if (optind
>= argc
)
21869 /* Ensure that the warning is always displayed. */
21872 warn (_("Nothing to do.\n"));
21877 while (optind
< argc
)
21878 if (! process_file (argv
[optind
++]))
21881 free (cmdline
.dump_sects
);
21883 free (dump_ctf_symtab_name
);
21884 free (dump_ctf_strtab_name
);
21885 free (dump_ctf_parent_name
);
21887 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;