1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2021 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
50 /* Define BFD64 here, even if our default architecture is 32 bit ELF
51 as this will allow us to read in and parse 64bit and 32bit ELF files.
52 Only do this if we believe that the compiler can support a 64 bit
53 data type. For now we only rely on GCC being able to do this. */
64 #include "elf/common.h"
65 #include "elf/external.h"
66 #include "elf/internal.h"
69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
77 /* Undo the effects of #including reloc-macros.h. */
79 #undef START_RELOC_NUMBERS
83 #undef END_RELOC_NUMBERS
84 #undef _RELOC_MACROS_H
86 /* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
90 #define RELOC_MACROS_GEN_FUNC
92 #include "elf/aarch64.h"
93 #include "elf/alpha.h"
101 #include "elf/csky.h"
102 #include "elf/d10v.h"
103 #include "elf/d30v.h"
106 #include "elf/epiphany.h"
107 #include "elf/fr30.h"
109 #include "elf/ft32.h"
111 #include "elf/hppa.h"
112 #include "elf/i386.h"
113 #include "elf/i370.h"
114 #include "elf/i860.h"
115 #include "elf/i960.h"
116 #include "elf/ia64.h"
117 #include "elf/ip2k.h"
118 #include "elf/lm32.h"
119 #include "elf/iq2000.h"
120 #include "elf/m32c.h"
121 #include "elf/m32r.h"
122 #include "elf/m68k.h"
123 #include "elf/m68hc11.h"
124 #include "elf/s12z.h"
125 #include "elf/mcore.h"
127 #include "elf/metag.h"
128 #include "elf/microblaze.h"
129 #include "elf/mips.h"
130 #include "elf/mmix.h"
131 #include "elf/mn10200.h"
132 #include "elf/mn10300.h"
133 #include "elf/moxie.h"
135 #include "elf/msp430.h"
136 #include "elf/nds32.h"
138 #include "elf/nios2.h"
139 #include "elf/or1k.h"
142 #include "elf/ppc64.h"
144 #include "elf/riscv.h"
145 #include "elf/rl78.h"
147 #include "elf/s390.h"
148 #include "elf/score.h"
150 #include "elf/sparc.h"
152 #include "elf/tic6x.h"
153 #include "elf/tilegx.h"
154 #include "elf/tilepro.h"
155 #include "elf/v850.h"
157 #include "elf/visium.h"
158 #include "elf/wasm32.h"
159 #include "elf/x86-64.h"
160 #include "elf/xc16x.h"
161 #include "elf/xgate.h"
162 #include "elf/xstormy16.h"
163 #include "elf/xtensa.h"
167 #include "libiberty.h"
168 #include "safe-ctype.h"
169 #include "filenames.h"
172 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
175 typedef struct elf_section_list
177 Elf_Internal_Shdr
* hdr
;
178 struct elf_section_list
* next
;
181 /* Flag bits indicating particular types of dump. */
182 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
183 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
184 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
185 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
186 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
187 #define CTF_DUMP (1 << 5) /* The --ctf command line switch. */
189 typedef unsigned char dump_type
;
191 /* A linked list of the section names for which dumps were requested. */
192 struct dump_list_entry
196 struct dump_list_entry
* next
;
199 /* A dynamic array of flags indicating for which sections a dump
200 has been requested via command line switches. */
203 dump_type
* dump_sects
;
204 unsigned int num_dump_sects
;
207 static struct dump_data cmdline
;
209 static struct dump_list_entry
* dump_sects_byname
;
211 char * program_name
= "readelf";
213 static bool show_name
= false;
214 static bool do_dynamic
= false;
215 static bool do_syms
= false;
216 static bool do_dyn_syms
= false;
217 static bool do_lto_syms
= false;
218 static bool do_reloc
= false;
219 static bool do_sections
= false;
220 static bool do_section_groups
= false;
221 static bool do_section_details
= false;
222 static bool do_segments
= false;
223 static bool do_unwind
= false;
224 static bool do_using_dynamic
= false;
225 static bool do_header
= false;
226 static bool do_dump
= false;
227 static bool do_version
= false;
228 static bool do_histogram
= false;
229 static bool do_debugging
= false;
230 static bool do_ctf
= false;
231 static bool do_arch
= false;
232 static bool do_notes
= false;
233 static bool do_archive_index
= false;
234 static bool check_all
= false;
235 static bool is_32bit_elf
= false;
236 static bool decompress_dumps
= false;
237 static bool do_not_show_symbol_truncation
= false;
238 static bool do_demangle
= false; /* Pretty print C++ symbol names. */
239 static bool process_links
= false;
240 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
241 static int sym_base
= 0;
243 static char *dump_ctf_parent_name
;
244 static char *dump_ctf_symtab_name
;
245 static char *dump_ctf_strtab_name
;
249 struct group_list
* next
;
250 unsigned int section_index
;
255 struct group_list
* root
;
256 unsigned int group_index
;
259 typedef struct filedata
261 const char * file_name
;
264 bfd_size_type file_size
;
265 Elf_Internal_Ehdr file_header
;
266 unsigned long archive_file_offset
;
267 unsigned long archive_file_size
;
268 /* Everything below this point is cleared out by free_filedata. */
269 Elf_Internal_Shdr
* section_headers
;
270 Elf_Internal_Phdr
* program_headers
;
272 unsigned long string_table_length
;
273 unsigned long dynamic_addr
;
274 bfd_size_type dynamic_size
;
276 Elf_Internal_Dyn
* dynamic_section
;
277 Elf_Internal_Shdr
* dynamic_strtab_section
;
278 char * dynamic_strings
;
279 unsigned long dynamic_strings_length
;
280 Elf_Internal_Shdr
* dynamic_symtab_section
;
281 unsigned long num_dynamic_syms
;
282 Elf_Internal_Sym
* dynamic_symbols
;
283 bfd_vma version_info
[16];
284 unsigned int dynamic_syminfo_nent
;
285 Elf_Internal_Syminfo
* dynamic_syminfo
;
286 unsigned long dynamic_syminfo_offset
;
287 bfd_size_type nbuckets
;
288 bfd_size_type nchains
;
291 bfd_size_type ngnubuckets
;
292 bfd_size_type ngnuchains
;
293 bfd_vma
* gnubuckets
;
297 char * program_interpreter
;
298 bfd_vma dynamic_info
[DT_ENCODING
];
299 bfd_vma dynamic_info_DT_GNU_HASH
;
300 bfd_vma dynamic_info_DT_MIPS_XHASH
;
301 elf_section_list
* symtab_shndx_list
;
303 struct group
* section_groups
;
304 struct group
** section_headers_groups
;
305 /* A dynamic array of flags indicating for which sections a dump of
306 some kind has been requested. It is reset on a per-object file
307 basis and then initialised from the cmdline_dump_sects array,
308 the results of interpreting the -w switch, and the
309 dump_sects_byname list. */
310 struct dump_data dump
;
313 /* How to print a vma value. */
314 typedef enum print_mode
331 /* Versioned symbol info. */
332 enum versioned_symbol_info
339 static const char * get_symbol_version_string
340 (Filedata
*, bool, const char *, unsigned long, unsigned,
341 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
345 #define SECTION_NAME(X) \
346 (filedata->string_table + (X)->sh_name)
348 #define SECTION_NAME_VALID(X) \
350 && filedata->string_table != NULL \
351 && (X)->sh_name < filedata->string_table_length)
353 #define SECTION_NAME_PRINT(X) \
354 ((X) == NULL ? _("<none>") \
355 : filedata->string_table == NULL ? _("<no-strings>") \
356 : (X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
357 : filedata->string_table + (X)->sh_name)
359 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
361 #define VALID_SYMBOL_NAME(strtab, strtab_size, offset) \
362 (strtab != NULL && offset < strtab_size)
363 #define VALID_DYNAMIC_NAME(filedata, offset) \
364 VALID_SYMBOL_NAME (filedata->dynamic_strings, \
365 filedata->dynamic_strings_length, offset)
366 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
367 already been called and verified that the string exists. */
368 #define GET_DYNAMIC_NAME(filedata, offset) \
369 (filedata->dynamic_strings + offset)
371 #define REMOVE_ARCH_BITS(ADDR) \
374 if (filedata->file_header.e_machine == EM_ARM) \
379 /* Get the correct GNU hash section name. */
380 #define GNU_HASH_SECTION_NAME(filedata) \
381 filedata->dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
383 /* Print a BFD_VMA to an internal buffer, for use in error messages.
384 BFD_FMA_FMT can't be used in translated strings. */
387 bfd_vmatoa (char *fmtch
, bfd_vma value
)
389 /* bfd_vmatoa is used more then once in a printf call for output.
390 Cycle through an array of buffers. */
391 static int buf_pos
= 0;
392 static struct bfd_vmatoa_buf
399 ret
= buf
[buf_pos
++].place
;
400 buf_pos
%= ARRAY_SIZE (buf
);
402 sprintf (fmt
, "%%%s%s", BFD_VMA_FMT
, fmtch
);
403 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
407 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
408 OFFSET + the offset of the current archive member, if we are examining an
409 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
410 allocate a buffer using malloc and fill that. In either case return the
411 pointer to the start of the retrieved data or NULL if something went wrong.
412 If something does go wrong and REASON is not NULL then emit an error
413 message using REASON as part of the context. */
416 get_data (void * var
,
418 unsigned long offset
,
424 bfd_size_type amt
= size
* nmemb
;
426 if (size
== 0 || nmemb
== 0)
429 /* If the size_t type is smaller than the bfd_size_type, eg because
430 you are building a 32-bit tool on a 64-bit host, then make sure
431 that when the sizes are cast to (size_t) no information is lost. */
432 if ((size_t) size
!= size
433 || (size_t) nmemb
!= nmemb
434 || (size_t) amt
!= amt
)
437 error (_("Size truncation prevents reading %s"
438 " elements of size %s for %s\n"),
439 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
443 /* Check for size overflow. */
444 if (amt
/ size
!= nmemb
|| (size_t) amt
+ 1 == 0)
447 error (_("Size overflow prevents reading %s"
448 " elements of size %s for %s\n"),
449 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
453 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
454 attempting to allocate memory when the read is bound to fail. */
455 if (filedata
->archive_file_offset
> filedata
->file_size
456 || offset
> filedata
->file_size
- filedata
->archive_file_offset
457 || amt
> filedata
->file_size
- filedata
->archive_file_offset
- offset
)
460 error (_("Reading %s bytes extends past end of file for %s\n"),
461 bfd_vmatoa ("u", amt
), reason
);
465 if (fseek (filedata
->handle
, filedata
->archive_file_offset
+ offset
,
469 error (_("Unable to seek to 0x%lx for %s\n"),
470 filedata
->archive_file_offset
+ offset
, reason
);
477 /* + 1 so that we can '\0' terminate invalid string table sections. */
478 mvar
= malloc ((size_t) amt
+ 1);
483 error (_("Out of memory allocating %s bytes for %s\n"),
484 bfd_vmatoa ("u", amt
), reason
);
488 ((char *) mvar
)[amt
] = '\0';
491 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
494 error (_("Unable to read in %s bytes of %s\n"),
495 bfd_vmatoa ("u", amt
), reason
);
504 /* Print a VMA value in the MODE specified.
505 Returns the number of characters displayed. */
508 print_vma (bfd_vma vma
, print_mode mode
)
520 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
527 return printf ("%5" BFD_VMA_FMT
"d", vma
);
533 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
539 return nc
+ printf ("%05" BFD_VMA_FMT
"x", vma
);
542 return printf ("%" BFD_VMA_FMT
"d", vma
);
545 return printf ("%" BFD_VMA_FMT
"u", vma
);
548 return printf ("%5" BFD_VMA_FMT
"u", vma
);
551 return printf ("%" BFD_VMA_FMT
"o", vma
);
554 return printf ("%5" BFD_VMA_FMT
"o", vma
);
557 /* FIXME: Report unrecognised mode ? */
563 /* Display a symbol on stdout. Handles the display of control characters and
564 multibye characters (assuming the host environment supports them).
566 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
568 If truncation will happen and do_not_show_symbol_truncation is FALSE then display
569 abs(WIDTH) - 5 characters followed by "[...]".
571 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
572 padding as necessary.
574 Returns the number of emitted characters. */
577 print_symbol (signed int width
, const char * symbol
)
579 bool extra_padding
= false;
580 bool do_dots
= false;
581 signed int num_printed
= 0;
582 #ifdef HAVE_MBSTATE_T
585 unsigned int width_remaining
;
586 const void * alloced_symbol
= NULL
;
590 /* Keep the width positive. This helps the code below. */
592 extra_padding
= true;
598 /* Set the remaining width to a very large value.
599 This simplifies the code below. */
600 width_remaining
= INT_MAX
;
603 width_remaining
= width
;
604 if (! do_not_show_symbol_truncation
605 && (int) strlen (symbol
) > width
)
607 width_remaining
-= 5;
608 if ((int) width_remaining
< 0)
614 #ifdef HAVE_MBSTATE_T
615 /* Initialise the multibyte conversion state. */
616 memset (& state
, 0, sizeof (state
));
619 if (do_demangle
&& *symbol
)
621 const char * res
= cplus_demangle (symbol
, demangle_flags
);
624 alloced_symbol
= symbol
= res
;
627 while (width_remaining
)
630 const char c
= *symbol
++;
635 /* Do not print control characters directly as they can affect terminal
636 settings. Such characters usually appear in the names generated
637 by the assembler for local labels. */
640 if (width_remaining
< 2)
643 printf ("^%c", c
+ 0x40);
644 width_remaining
-= 2;
647 else if (ISPRINT (c
))
655 #ifdef HAVE_MBSTATE_T
658 /* Let printf do the hard work of displaying multibyte characters. */
659 printf ("%.1s", symbol
- 1);
663 #ifdef HAVE_MBSTATE_T
664 /* Try to find out how many bytes made up the character that was
665 just printed. Advance the symbol pointer past the bytes that
667 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
671 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
677 num_printed
+= printf ("[...]");
679 if (extra_padding
&& num_printed
< width
)
681 /* Fill in the remaining spaces. */
682 printf ("%-*s", width
- num_printed
, " ");
686 free ((void *) alloced_symbol
);
690 /* Returns a pointer to a static buffer containing a printable version of
691 the given section's name. Like print_symbol, except that it does not try
692 to print multibyte characters, it just interprets them as hex values. */
695 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
697 #define MAX_PRINT_SEC_NAME_LEN 256
698 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
699 const char * name
= SECTION_NAME_PRINT (sec
);
700 char * buf
= sec_name_buf
;
702 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
704 while ((c
= * name
++) != 0)
715 else if (ISPRINT (c
))
722 static char hex
[17] = "0123456789ABCDEF";
727 * buf
++ = hex
[(c
& 0xf0) >> 4];
728 * buf
++ = hex
[c
& 0x0f];
742 printable_section_name_from_index (Filedata
* filedata
, unsigned long ndx
)
744 if (ndx
>= filedata
->file_header
.e_shnum
)
745 return _("<corrupt>");
747 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
750 /* Return a pointer to section NAME, or NULL if no such section exists. */
752 static Elf_Internal_Shdr
*
753 find_section (Filedata
* filedata
, const char * name
)
757 if (filedata
->section_headers
== NULL
)
760 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
761 if (SECTION_NAME_VALID (filedata
->section_headers
+ i
)
762 && streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
763 return filedata
->section_headers
+ i
;
768 /* Return a pointer to a section containing ADDR, or NULL if no such
771 static Elf_Internal_Shdr
*
772 find_section_by_address (Filedata
* filedata
, bfd_vma addr
)
776 if (filedata
->section_headers
== NULL
)
779 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
781 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
783 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
790 static Elf_Internal_Shdr
*
791 find_section_by_type (Filedata
* filedata
, unsigned int type
)
795 if (filedata
->section_headers
== NULL
)
798 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
800 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
802 if (sec
->sh_type
== type
)
809 /* Return a pointer to section NAME, or NULL if no such section exists,
810 restricted to the list of sections given in SET. */
812 static Elf_Internal_Shdr
*
813 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
817 if (filedata
->section_headers
== NULL
)
822 while ((i
= *set
++) > 0)
824 /* See PR 21156 for a reproducer. */
825 if (i
>= filedata
->file_header
.e_shnum
)
826 continue; /* FIXME: Should we issue an error message ? */
828 if (SECTION_NAME_VALID (filedata
->section_headers
+ i
)
829 && streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
830 return filedata
->section_headers
+ i
;
834 return find_section (filedata
, name
);
837 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
838 This OS has so many departures from the ELF standard that we test it at
842 is_ia64_vms (Filedata
* filedata
)
844 return filedata
->file_header
.e_machine
== EM_IA_64
845 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
848 /* Guess the relocation size commonly used by the specific machines. */
851 guess_is_rela (unsigned int e_machine
)
855 /* Targets that use REL relocations. */
872 /* Targets that use RELA relocations. */
876 case EM_ADAPTEVA_EPIPHANY
:
878 case EM_ALTERA_NIOS2
:
881 case EM_ARC_COMPACT2
:
902 case EM_LATTICEMICO32
:
911 case EM_CYGNUS_MN10200
:
913 case EM_CYGNUS_MN10300
:
949 case EM_MICROBLAZE_OLD
:
971 warn (_("Don't know about relocations on this machine architecture\n"));
976 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
977 Returns TRUE upon success, FALSE otherwise. If successful then a
978 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
979 and the number of relocs loaded is placed in *NRELASP. It is the caller's
980 responsibility to free the allocated buffer. */
983 slurp_rela_relocs (Filedata
* filedata
,
984 unsigned long rel_offset
,
985 unsigned long rel_size
,
986 Elf_Internal_Rela
** relasp
,
987 unsigned long * nrelasp
)
989 Elf_Internal_Rela
* relas
;
995 Elf32_External_Rela
* erelas
;
997 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
998 rel_size
, _("32-bit relocation data"));
1002 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
1004 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
1005 sizeof (Elf_Internal_Rela
));
1010 error (_("out of memory parsing relocs\n"));
1014 for (i
= 0; i
< nrelas
; i
++)
1016 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
1017 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
1018 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
1025 Elf64_External_Rela
* erelas
;
1027 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
1028 rel_size
, _("64-bit relocation data"));
1032 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
1034 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
1035 sizeof (Elf_Internal_Rela
));
1040 error (_("out of memory parsing relocs\n"));
1044 for (i
= 0; i
< nrelas
; i
++)
1046 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
1047 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
1048 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
1050 /* The #ifdef BFD64 below is to prevent a compile time
1051 warning. We know that if we do not have a 64 bit data
1052 type that we will never execute this code anyway. */
1054 if (filedata
->file_header
.e_machine
== EM_MIPS
1055 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1057 /* In little-endian objects, r_info isn't really a
1058 64-bit little-endian value: it has a 32-bit
1059 little-endian symbol index followed by four
1060 individual byte fields. Reorder INFO
1062 bfd_vma inf
= relas
[i
].r_info
;
1063 inf
= (((inf
& 0xffffffff) << 32)
1064 | ((inf
>> 56) & 0xff)
1065 | ((inf
>> 40) & 0xff00)
1066 | ((inf
>> 24) & 0xff0000)
1067 | ((inf
>> 8) & 0xff000000));
1068 relas
[i
].r_info
= inf
;
1081 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1082 Returns TRUE upon success, FALSE otherwise. If successful then a
1083 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1084 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1085 responsibility to free the allocated buffer. */
1088 slurp_rel_relocs (Filedata
* filedata
,
1089 unsigned long rel_offset
,
1090 unsigned long rel_size
,
1091 Elf_Internal_Rela
** relsp
,
1092 unsigned long * nrelsp
)
1094 Elf_Internal_Rela
* rels
;
1100 Elf32_External_Rel
* erels
;
1102 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1103 rel_size
, _("32-bit relocation data"));
1107 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1109 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1114 error (_("out of memory parsing relocs\n"));
1118 for (i
= 0; i
< nrels
; i
++)
1120 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1121 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1122 rels
[i
].r_addend
= 0;
1129 Elf64_External_Rel
* erels
;
1131 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1132 rel_size
, _("64-bit relocation data"));
1136 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1138 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1143 error (_("out of memory parsing relocs\n"));
1147 for (i
= 0; i
< nrels
; i
++)
1149 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1150 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1151 rels
[i
].r_addend
= 0;
1153 /* The #ifdef BFD64 below is to prevent a compile time
1154 warning. We know that if we do not have a 64 bit data
1155 type that we will never execute this code anyway. */
1157 if (filedata
->file_header
.e_machine
== EM_MIPS
1158 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1160 /* In little-endian objects, r_info isn't really a
1161 64-bit little-endian value: it has a 32-bit
1162 little-endian symbol index followed by four
1163 individual byte fields. Reorder INFO
1165 bfd_vma inf
= rels
[i
].r_info
;
1166 inf
= (((inf
& 0xffffffff) << 32)
1167 | ((inf
>> 56) & 0xff)
1168 | ((inf
>> 40) & 0xff00)
1169 | ((inf
>> 24) & 0xff0000)
1170 | ((inf
>> 8) & 0xff000000));
1171 rels
[i
].r_info
= inf
;
1184 /* Returns the reloc type extracted from the reloc info field. */
1187 get_reloc_type (Filedata
* filedata
, bfd_vma reloc_info
)
1190 return ELF32_R_TYPE (reloc_info
);
1192 switch (filedata
->file_header
.e_machine
)
1195 /* Note: We assume that reloc_info has already been adjusted for us. */
1196 return ELF64_MIPS_R_TYPE (reloc_info
);
1199 return ELF64_R_TYPE_ID (reloc_info
);
1202 return ELF64_R_TYPE (reloc_info
);
1206 /* Return the symbol index extracted from the reloc info field. */
1209 get_reloc_symindex (bfd_vma reloc_info
)
1211 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1215 uses_msp430x_relocs (Filedata
* filedata
)
1218 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1219 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1220 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1221 /* TI compiler uses ELFOSABI_NONE. */
1222 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1225 /* Display the contents of the relocation data found at the specified
1229 dump_relocations (Filedata
* filedata
,
1230 unsigned long rel_offset
,
1231 unsigned long rel_size
,
1232 Elf_Internal_Sym
* symtab
,
1233 unsigned long nsyms
,
1235 unsigned long strtablen
,
1240 Elf_Internal_Rela
* rels
;
1243 if (is_rela
== UNKNOWN
)
1244 is_rela
= guess_is_rela (filedata
->file_header
.e_machine
);
1248 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1253 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1262 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1264 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1269 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1271 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1279 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1281 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1286 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1288 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1292 for (i
= 0; i
< rel_size
; i
++)
1297 bfd_vma symtab_index
;
1300 offset
= rels
[i
].r_offset
;
1301 inf
= rels
[i
].r_info
;
1303 type
= get_reloc_type (filedata
, inf
);
1304 symtab_index
= get_reloc_symindex (inf
);
1308 printf ("%8.8lx %8.8lx ",
1309 (unsigned long) offset
& 0xffffffff,
1310 (unsigned long) inf
& 0xffffffff);
1315 ? "%16.16" BFD_VMA_FMT
"x %16.16" BFD_VMA_FMT
"x "
1316 : "%12.12" BFD_VMA_FMT
"x %12.12" BFD_VMA_FMT
"x ",
1320 switch (filedata
->file_header
.e_machine
)
1327 rtype
= elf_aarch64_reloc_type (type
);
1331 case EM_CYGNUS_M32R
:
1332 rtype
= elf_m32r_reloc_type (type
);
1337 rtype
= elf_i386_reloc_type (type
);
1342 rtype
= elf_m68hc11_reloc_type (type
);
1346 rtype
= elf_s12z_reloc_type (type
);
1350 rtype
= elf_m68k_reloc_type (type
);
1354 rtype
= elf_i960_reloc_type (type
);
1359 rtype
= elf_avr_reloc_type (type
);
1362 case EM_OLD_SPARCV9
:
1363 case EM_SPARC32PLUS
:
1366 rtype
= elf_sparc_reloc_type (type
);
1370 rtype
= elf_spu_reloc_type (type
);
1374 rtype
= v800_reloc_type (type
);
1377 case EM_CYGNUS_V850
:
1378 rtype
= v850_reloc_type (type
);
1382 case EM_CYGNUS_D10V
:
1383 rtype
= elf_d10v_reloc_type (type
);
1387 case EM_CYGNUS_D30V
:
1388 rtype
= elf_d30v_reloc_type (type
);
1392 rtype
= elf_dlx_reloc_type (type
);
1396 rtype
= elf_sh_reloc_type (type
);
1400 case EM_CYGNUS_MN10300
:
1401 rtype
= elf_mn10300_reloc_type (type
);
1405 case EM_CYGNUS_MN10200
:
1406 rtype
= elf_mn10200_reloc_type (type
);
1410 case EM_CYGNUS_FR30
:
1411 rtype
= elf_fr30_reloc_type (type
);
1415 rtype
= elf_frv_reloc_type (type
);
1419 rtype
= elf_csky_reloc_type (type
);
1423 rtype
= elf_ft32_reloc_type (type
);
1427 rtype
= elf_mcore_reloc_type (type
);
1431 rtype
= elf_mmix_reloc_type (type
);
1435 rtype
= elf_moxie_reloc_type (type
);
1439 if (uses_msp430x_relocs (filedata
))
1441 rtype
= elf_msp430x_reloc_type (type
);
1446 rtype
= elf_msp430_reloc_type (type
);
1450 rtype
= elf_nds32_reloc_type (type
);
1454 rtype
= elf_ppc_reloc_type (type
);
1458 rtype
= elf_ppc64_reloc_type (type
);
1462 case EM_MIPS_RS3_LE
:
1463 rtype
= elf_mips_reloc_type (type
);
1467 rtype
= elf_riscv_reloc_type (type
);
1471 rtype
= elf_alpha_reloc_type (type
);
1475 rtype
= elf_arm_reloc_type (type
);
1479 case EM_ARC_COMPACT
:
1480 case EM_ARC_COMPACT2
:
1481 rtype
= elf_arc_reloc_type (type
);
1485 rtype
= elf_hppa_reloc_type (type
);
1491 rtype
= elf_h8_reloc_type (type
);
1495 rtype
= elf_or1k_reloc_type (type
);
1500 rtype
= elf_pj_reloc_type (type
);
1503 rtype
= elf_ia64_reloc_type (type
);
1507 rtype
= elf_cris_reloc_type (type
);
1511 rtype
= elf_i860_reloc_type (type
);
1517 rtype
= elf_x86_64_reloc_type (type
);
1521 rtype
= i370_reloc_type (type
);
1526 rtype
= elf_s390_reloc_type (type
);
1530 rtype
= elf_score_reloc_type (type
);
1534 rtype
= elf_xstormy16_reloc_type (type
);
1538 rtype
= elf_crx_reloc_type (type
);
1542 rtype
= elf_vax_reloc_type (type
);
1546 rtype
= elf_visium_reloc_type (type
);
1550 rtype
= elf_bpf_reloc_type (type
);
1553 case EM_ADAPTEVA_EPIPHANY
:
1554 rtype
= elf_epiphany_reloc_type (type
);
1559 rtype
= elf_ip2k_reloc_type (type
);
1563 rtype
= elf_iq2000_reloc_type (type
);
1568 rtype
= elf_xtensa_reloc_type (type
);
1571 case EM_LATTICEMICO32
:
1572 rtype
= elf_lm32_reloc_type (type
);
1577 rtype
= elf_m32c_reloc_type (type
);
1581 rtype
= elf_mt_reloc_type (type
);
1585 rtype
= elf_bfin_reloc_type (type
);
1589 rtype
= elf_mep_reloc_type (type
);
1593 rtype
= elf_cr16_reloc_type (type
);
1597 case EM_MICROBLAZE_OLD
:
1598 rtype
= elf_microblaze_reloc_type (type
);
1602 rtype
= elf_rl78_reloc_type (type
);
1606 rtype
= elf_rx_reloc_type (type
);
1610 rtype
= elf_metag_reloc_type (type
);
1615 rtype
= elf_xc16x_reloc_type (type
);
1619 rtype
= elf_tic6x_reloc_type (type
);
1623 rtype
= elf_tilegx_reloc_type (type
);
1627 rtype
= elf_tilepro_reloc_type (type
);
1630 case EM_WEBASSEMBLY
:
1631 rtype
= elf_wasm32_reloc_type (type
);
1635 rtype
= elf_xgate_reloc_type (type
);
1638 case EM_ALTERA_NIOS2
:
1639 rtype
= elf_nios2_reloc_type (type
);
1643 rtype
= elf_pru_reloc_type (type
);
1647 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
1648 rtype
= elf_nfp3200_reloc_type (type
);
1650 rtype
= elf_nfp_reloc_type (type
);
1654 rtype
= elf_z80_reloc_type (type
);
1659 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1661 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1663 if (filedata
->file_header
.e_machine
== EM_ALPHA
1665 && streq (rtype
, "R_ALPHA_LITUSE")
1668 switch (rels
[i
].r_addend
)
1670 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1671 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1672 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1673 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1674 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1675 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1676 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1677 default: rtype
= NULL
;
1681 printf (" (%s)", rtype
);
1685 printf (_("<unknown addend: %lx>"),
1686 (unsigned long) rels
[i
].r_addend
);
1690 else if (symtab_index
)
1692 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1694 error (_(" bad symbol index: %08lx in reloc\n"),
1695 (unsigned long) symtab_index
);
1700 Elf_Internal_Sym
* psym
;
1701 const char * version_string
;
1702 enum versioned_symbol_info sym_info
;
1703 unsigned short vna_other
;
1705 psym
= symtab
+ symtab_index
;
1708 = get_symbol_version_string (filedata
, is_dynsym
,
1717 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1721 unsigned int width
= is_32bit_elf
? 8 : 14;
1723 /* Relocations against GNU_IFUNC symbols do not use the value
1724 of the symbol as the address to relocate against. Instead
1725 they invoke the function named by the symbol and use its
1726 result as the address for relocation.
1728 To indicate this to the user, do not display the value of
1729 the symbol in the "Symbols's Value" field. Instead show
1730 its name followed by () as a hint that the symbol is
1734 || psym
->st_name
== 0
1735 || psym
->st_name
>= strtablen
)
1738 name
= strtab
+ psym
->st_name
;
1740 len
= print_symbol (width
, name
);
1742 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1744 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1748 print_vma (psym
->st_value
, LONG_HEX
);
1750 printf (is_32bit_elf
? " " : " ");
1753 if (psym
->st_name
== 0)
1755 const char * sec_name
= "<null>";
1758 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1760 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
)
1761 sec_name
= SECTION_NAME_PRINT (filedata
->section_headers
1763 else if (psym
->st_shndx
== SHN_ABS
)
1765 else if (psym
->st_shndx
== SHN_COMMON
)
1766 sec_name
= "COMMON";
1767 else if ((filedata
->file_header
.e_machine
== EM_MIPS
1768 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1769 || (filedata
->file_header
.e_machine
== EM_TI_C6000
1770 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1771 sec_name
= "SCOMMON";
1772 else if (filedata
->file_header
.e_machine
== EM_MIPS
1773 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1774 sec_name
= "SUNDEF";
1775 else if ((filedata
->file_header
.e_machine
== EM_X86_64
1776 || filedata
->file_header
.e_machine
== EM_L1OM
1777 || filedata
->file_header
.e_machine
== EM_K1OM
)
1778 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1779 sec_name
= "LARGE_COMMON";
1780 else if (filedata
->file_header
.e_machine
== EM_IA_64
1781 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1782 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1783 sec_name
= "ANSI_COM";
1784 else if (is_ia64_vms (filedata
)
1785 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1786 sec_name
= "VMS_SYMVEC";
1789 sprintf (name_buf
, "<section 0x%x>",
1790 (unsigned int) psym
->st_shndx
);
1791 sec_name
= name_buf
;
1794 print_symbol (22, sec_name
);
1796 else if (strtab
== NULL
)
1797 printf (_("<string table index: %3ld>"), psym
->st_name
);
1798 else if (psym
->st_name
>= strtablen
)
1800 error (_("<corrupt string table index: %3ld>\n"),
1806 print_symbol (22, strtab
+ psym
->st_name
);
1808 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1814 bfd_vma off
= rels
[i
].r_addend
;
1816 if ((bfd_signed_vma
) off
< 0)
1817 printf (" - %" BFD_VMA_FMT
"x", - off
);
1819 printf (" + %" BFD_VMA_FMT
"x", off
);
1825 bfd_vma off
= rels
[i
].r_addend
;
1827 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1828 if ((bfd_signed_vma
) off
< 0)
1829 printf ("-%" BFD_VMA_FMT
"x", - off
);
1831 printf ("%" BFD_VMA_FMT
"x", off
);
1834 if (filedata
->file_header
.e_machine
== EM_SPARCV9
1836 && streq (rtype
, "R_SPARC_OLO10"))
1837 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1842 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
1844 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1845 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1846 const char * rtype2
= elf_mips_reloc_type (type2
);
1847 const char * rtype3
= elf_mips_reloc_type (type3
);
1849 printf (" Type2: ");
1852 printf (_("unrecognized: %-7lx"),
1853 (unsigned long) type2
& 0xffffffff);
1855 printf ("%-17.17s", rtype2
);
1857 printf ("\n Type3: ");
1860 printf (_("unrecognized: %-7lx"),
1861 (unsigned long) type3
& 0xffffffff);
1863 printf ("%-17.17s", rtype3
);
1876 get_aarch64_dynamic_type (unsigned long type
)
1880 case DT_AARCH64_BTI_PLT
: return "AARCH64_BTI_PLT";
1881 case DT_AARCH64_PAC_PLT
: return "AARCH64_PAC_PLT";
1882 case DT_AARCH64_VARIANT_PCS
: return "AARCH64_VARIANT_PCS";
1889 get_mips_dynamic_type (unsigned long type
)
1893 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1894 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1895 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1896 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1897 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1898 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1899 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1900 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1901 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1902 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1903 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1904 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1905 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1906 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1907 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1908 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1909 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1910 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1911 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1912 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1913 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1914 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1915 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1916 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1917 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1918 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1919 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1920 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1921 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1922 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1923 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1924 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1925 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1926 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1927 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1928 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1929 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1930 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1931 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1932 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1933 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1934 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1935 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1936 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1937 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1938 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1939 case DT_MIPS_XHASH
: return "MIPS_XHASH";
1946 get_sparc64_dynamic_type (unsigned long type
)
1950 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1957 get_ppc_dynamic_type (unsigned long type
)
1961 case DT_PPC_GOT
: return "PPC_GOT";
1962 case DT_PPC_OPT
: return "PPC_OPT";
1969 get_ppc64_dynamic_type (unsigned long type
)
1973 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1974 case DT_PPC64_OPD
: return "PPC64_OPD";
1975 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1976 case DT_PPC64_OPT
: return "PPC64_OPT";
1983 get_parisc_dynamic_type (unsigned long type
)
1987 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1988 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1989 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1990 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1991 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1992 case DT_HP_PREINIT
: return "HP_PREINIT";
1993 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1994 case DT_HP_NEEDED
: return "HP_NEEDED";
1995 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1996 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1997 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1998 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1999 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
2000 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
2001 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
2002 case DT_HP_FILTERED
: return "HP_FILTERED";
2003 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
2004 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
2005 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
2006 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
2007 case DT_PLT
: return "PLT";
2008 case DT_PLT_SIZE
: return "PLT_SIZE";
2009 case DT_DLT
: return "DLT";
2010 case DT_DLT_SIZE
: return "DLT_SIZE";
2017 get_ia64_dynamic_type (unsigned long type
)
2021 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
2022 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
2023 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
2024 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
2025 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
2026 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
2027 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
2028 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
2029 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
2030 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
2031 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
2032 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
2033 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
2034 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
2035 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
2036 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
2037 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
2038 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
2039 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
2040 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
2041 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
2042 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
2043 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
2044 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
2045 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
2046 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
2047 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
2048 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
2049 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
2050 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
2051 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
2058 get_solaris_section_type (unsigned long type
)
2062 case 0x6fffffee: return "SUNW_ancillary";
2063 case 0x6fffffef: return "SUNW_capchain";
2064 case 0x6ffffff0: return "SUNW_capinfo";
2065 case 0x6ffffff1: return "SUNW_symsort";
2066 case 0x6ffffff2: return "SUNW_tlssort";
2067 case 0x6ffffff3: return "SUNW_LDYNSYM";
2068 case 0x6ffffff4: return "SUNW_dof";
2069 case 0x6ffffff5: return "SUNW_cap";
2070 case 0x6ffffff6: return "SUNW_SIGNATURE";
2071 case 0x6ffffff7: return "SUNW_ANNOTATE";
2072 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2073 case 0x6ffffff9: return "SUNW_DEBUG";
2074 case 0x6ffffffa: return "SUNW_move";
2075 case 0x6ffffffb: return "SUNW_COMDAT";
2076 case 0x6ffffffc: return "SUNW_syminfo";
2077 case 0x6ffffffd: return "SUNW_verdef";
2078 case 0x6ffffffe: return "SUNW_verneed";
2079 case 0x6fffffff: return "SUNW_versym";
2080 case 0x70000000: return "SPARC_GOTDATA";
2081 default: return NULL
;
2086 get_alpha_dynamic_type (unsigned long type
)
2090 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2091 default: return NULL
;
2096 get_score_dynamic_type (unsigned long type
)
2100 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2101 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2102 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2103 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2104 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2105 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2106 default: return NULL
;
2111 get_tic6x_dynamic_type (unsigned long type
)
2115 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2116 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2117 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2118 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2119 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2120 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2121 default: return NULL
;
2126 get_nios2_dynamic_type (unsigned long type
)
2130 case DT_NIOS2_GP
: return "NIOS2_GP";
2131 default: return NULL
;
2136 get_solaris_dynamic_type (unsigned long type
)
2140 case 0x6000000d: return "SUNW_AUXILIARY";
2141 case 0x6000000e: return "SUNW_RTLDINF";
2142 case 0x6000000f: return "SUNW_FILTER";
2143 case 0x60000010: return "SUNW_CAP";
2144 case 0x60000011: return "SUNW_SYMTAB";
2145 case 0x60000012: return "SUNW_SYMSZ";
2146 case 0x60000013: return "SUNW_SORTENT";
2147 case 0x60000014: return "SUNW_SYMSORT";
2148 case 0x60000015: return "SUNW_SYMSORTSZ";
2149 case 0x60000016: return "SUNW_TLSSORT";
2150 case 0x60000017: return "SUNW_TLSSORTSZ";
2151 case 0x60000018: return "SUNW_CAPINFO";
2152 case 0x60000019: return "SUNW_STRPAD";
2153 case 0x6000001a: return "SUNW_CAPCHAIN";
2154 case 0x6000001b: return "SUNW_LDMACH";
2155 case 0x6000001d: return "SUNW_CAPCHAINENT";
2156 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2157 case 0x60000021: return "SUNW_PARENT";
2158 case 0x60000023: return "SUNW_ASLR";
2159 case 0x60000025: return "SUNW_RELAX";
2160 case 0x60000029: return "SUNW_NXHEAP";
2161 case 0x6000002b: return "SUNW_NXSTACK";
2163 case 0x70000001: return "SPARC_REGISTER";
2164 case 0x7ffffffd: return "AUXILIARY";
2165 case 0x7ffffffe: return "USED";
2166 case 0x7fffffff: return "FILTER";
2168 default: return NULL
;
2173 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2175 static char buff
[64];
2179 case DT_NULL
: return "NULL";
2180 case DT_NEEDED
: return "NEEDED";
2181 case DT_PLTRELSZ
: return "PLTRELSZ";
2182 case DT_PLTGOT
: return "PLTGOT";
2183 case DT_HASH
: return "HASH";
2184 case DT_STRTAB
: return "STRTAB";
2185 case DT_SYMTAB
: return "SYMTAB";
2186 case DT_RELA
: return "RELA";
2187 case DT_RELASZ
: return "RELASZ";
2188 case DT_RELAENT
: return "RELAENT";
2189 case DT_STRSZ
: return "STRSZ";
2190 case DT_SYMENT
: return "SYMENT";
2191 case DT_INIT
: return "INIT";
2192 case DT_FINI
: return "FINI";
2193 case DT_SONAME
: return "SONAME";
2194 case DT_RPATH
: return "RPATH";
2195 case DT_SYMBOLIC
: return "SYMBOLIC";
2196 case DT_REL
: return "REL";
2197 case DT_RELSZ
: return "RELSZ";
2198 case DT_RELENT
: return "RELENT";
2199 case DT_PLTREL
: return "PLTREL";
2200 case DT_DEBUG
: return "DEBUG";
2201 case DT_TEXTREL
: return "TEXTREL";
2202 case DT_JMPREL
: return "JMPREL";
2203 case DT_BIND_NOW
: return "BIND_NOW";
2204 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2205 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2206 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2207 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2208 case DT_RUNPATH
: return "RUNPATH";
2209 case DT_FLAGS
: return "FLAGS";
2211 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2212 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2213 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2215 case DT_CHECKSUM
: return "CHECKSUM";
2216 case DT_PLTPADSZ
: return "PLTPADSZ";
2217 case DT_MOVEENT
: return "MOVEENT";
2218 case DT_MOVESZ
: return "MOVESZ";
2219 case DT_FEATURE
: return "FEATURE";
2220 case DT_POSFLAG_1
: return "POSFLAG_1";
2221 case DT_SYMINSZ
: return "SYMINSZ";
2222 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2224 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2225 case DT_CONFIG
: return "CONFIG";
2226 case DT_DEPAUDIT
: return "DEPAUDIT";
2227 case DT_AUDIT
: return "AUDIT";
2228 case DT_PLTPAD
: return "PLTPAD";
2229 case DT_MOVETAB
: return "MOVETAB";
2230 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2232 case DT_VERSYM
: return "VERSYM";
2234 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2235 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2236 case DT_RELACOUNT
: return "RELACOUNT";
2237 case DT_RELCOUNT
: return "RELCOUNT";
2238 case DT_FLAGS_1
: return "FLAGS_1";
2239 case DT_VERDEF
: return "VERDEF";
2240 case DT_VERDEFNUM
: return "VERDEFNUM";
2241 case DT_VERNEED
: return "VERNEED";
2242 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2244 case DT_AUXILIARY
: return "AUXILIARY";
2245 case DT_USED
: return "USED";
2246 case DT_FILTER
: return "FILTER";
2248 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2249 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2250 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2251 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2252 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2253 case DT_GNU_HASH
: return "GNU_HASH";
2254 case DT_GNU_FLAGS_1
: return "GNU_FLAGS_1";
2257 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2259 const char * result
;
2261 switch (filedata
->file_header
.e_machine
)
2264 result
= get_aarch64_dynamic_type (type
);
2267 case EM_MIPS_RS3_LE
:
2268 result
= get_mips_dynamic_type (type
);
2271 result
= get_sparc64_dynamic_type (type
);
2274 result
= get_ppc_dynamic_type (type
);
2277 result
= get_ppc64_dynamic_type (type
);
2280 result
= get_ia64_dynamic_type (type
);
2283 result
= get_alpha_dynamic_type (type
);
2286 result
= get_score_dynamic_type (type
);
2289 result
= get_tic6x_dynamic_type (type
);
2291 case EM_ALTERA_NIOS2
:
2292 result
= get_nios2_dynamic_type (type
);
2295 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2296 result
= get_solaris_dynamic_type (type
);
2305 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2307 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2308 || (filedata
->file_header
.e_machine
== EM_PARISC
2309 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2311 const char * result
;
2313 switch (filedata
->file_header
.e_machine
)
2316 result
= get_parisc_dynamic_type (type
);
2319 result
= get_ia64_dynamic_type (type
);
2322 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2323 result
= get_solaris_dynamic_type (type
);
2332 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2336 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2342 static bool get_program_headers (Filedata
*);
2343 static bool get_dynamic_section (Filedata
*);
2346 locate_dynamic_section (Filedata
*filedata
)
2348 unsigned long dynamic_addr
= 0;
2349 bfd_size_type dynamic_size
= 0;
2351 if (filedata
->file_header
.e_phnum
!= 0
2352 && get_program_headers (filedata
))
2354 Elf_Internal_Phdr
*segment
;
2357 for (i
= 0, segment
= filedata
->program_headers
;
2358 i
< filedata
->file_header
.e_phnum
;
2361 if (segment
->p_type
== PT_DYNAMIC
)
2363 dynamic_addr
= segment
->p_offset
;
2364 dynamic_size
= segment
->p_filesz
;
2366 if (filedata
->section_headers
!= NULL
)
2368 Elf_Internal_Shdr
*sec
;
2370 sec
= find_section (filedata
, ".dynamic");
2373 if (sec
->sh_size
== 0
2374 || sec
->sh_type
== SHT_NOBITS
)
2381 dynamic_addr
= sec
->sh_offset
;
2382 dynamic_size
= sec
->sh_size
;
2387 if (dynamic_addr
> filedata
->file_size
2388 || (dynamic_size
> filedata
->file_size
- dynamic_addr
))
2397 filedata
->dynamic_addr
= dynamic_addr
;
2398 filedata
->dynamic_size
= dynamic_size
? dynamic_size
: 1;
2402 is_pie (Filedata
*filedata
)
2404 Elf_Internal_Dyn
*entry
;
2406 if (filedata
->dynamic_size
== 0)
2407 locate_dynamic_section (filedata
);
2408 if (filedata
->dynamic_size
<= 1)
2411 if (!get_dynamic_section (filedata
))
2414 for (entry
= filedata
->dynamic_section
;
2415 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
2418 if (entry
->d_tag
== DT_FLAGS_1
)
2420 if ((entry
->d_un
.d_val
& DF_1_PIE
) != 0)
2429 get_file_type (Filedata
*filedata
)
2431 unsigned e_type
= filedata
->file_header
.e_type
;
2432 static char buff
[64];
2436 case ET_NONE
: return _("NONE (None)");
2437 case ET_REL
: return _("REL (Relocatable file)");
2438 case ET_EXEC
: return _("EXEC (Executable file)");
2440 if (is_pie (filedata
))
2441 return _("DYN (Position-Independent Executable file)");
2443 return _("DYN (Shared object file)");
2444 case ET_CORE
: return _("CORE (Core file)");
2447 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2448 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2449 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2450 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2452 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2458 get_machine_name (unsigned e_machine
)
2460 static char buff
[64]; /* XXX */
2464 /* Please keep this switch table sorted by increasing EM_ value. */
2466 case EM_NONE
: return _("None");
2467 case EM_M32
: return "WE32100";
2468 case EM_SPARC
: return "Sparc";
2469 case EM_386
: return "Intel 80386";
2470 case EM_68K
: return "MC68000";
2471 case EM_88K
: return "MC88000";
2472 case EM_IAMCU
: return "Intel MCU";
2473 case EM_860
: return "Intel 80860";
2474 case EM_MIPS
: return "MIPS R3000";
2475 case EM_S370
: return "IBM System/370";
2477 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2478 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2479 case EM_PARISC
: return "HPPA";
2480 case EM_VPP550
: return "Fujitsu VPP500";
2481 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2482 case EM_960
: return "Intel 80960";
2483 case EM_PPC
: return "PowerPC";
2485 case EM_PPC64
: return "PowerPC64";
2487 case EM_S390
: return "IBM S/390";
2488 case EM_SPU
: return "SPU";
2490 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2491 case EM_FR20
: return "Fujitsu FR20";
2492 case EM_RH32
: return "TRW RH32";
2493 case EM_MCORE
: return "MCORE";
2495 case EM_ARM
: return "ARM";
2496 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2497 case EM_SH
: return "Renesas / SuperH SH";
2498 case EM_SPARCV9
: return "Sparc v9";
2499 case EM_TRICORE
: return "Siemens Tricore";
2500 case EM_ARC
: return "ARC";
2501 case EM_H8_300
: return "Renesas H8/300";
2502 case EM_H8_300H
: return "Renesas H8/300H";
2503 case EM_H8S
: return "Renesas H8S";
2504 case EM_H8_500
: return "Renesas H8/500";
2506 case EM_IA_64
: return "Intel IA-64";
2507 case EM_MIPS_X
: return "Stanford MIPS-X";
2508 case EM_COLDFIRE
: return "Motorola Coldfire";
2509 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2510 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2511 case EM_PCP
: return "Siemens PCP";
2512 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2513 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2514 case EM_STARCORE
: return "Motorola Star*Core processor";
2515 case EM_ME16
: return "Toyota ME16 processor";
2517 case EM_ST100
: return "STMicroelectronics ST100 processor";
2518 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2519 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2520 case EM_PDSP
: return "Sony DSP processor";
2521 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2522 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2523 case EM_FX66
: return "Siemens FX66 microcontroller";
2524 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2525 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2526 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2528 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2529 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2530 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2531 case EM_SVX
: return "Silicon Graphics SVx";
2532 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2533 case EM_VAX
: return "Digital VAX";
2534 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2535 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2536 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2537 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2539 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2540 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2541 case EM_PRISM
: return "Vitesse Prism";
2543 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2544 case EM_CYGNUS_FR30
:
2545 case EM_FR30
: return "Fujitsu FR30";
2546 case EM_CYGNUS_D10V
:
2547 case EM_D10V
: return "d10v";
2548 case EM_CYGNUS_D30V
:
2549 case EM_D30V
: return "d30v";
2550 case EM_CYGNUS_V850
:
2551 case EM_V850
: return "Renesas V850";
2552 case EM_CYGNUS_M32R
:
2553 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2554 case EM_CYGNUS_MN10300
:
2555 case EM_MN10300
: return "mn10300";
2557 case EM_CYGNUS_MN10200
:
2558 case EM_MN10200
: return "mn10200";
2559 case EM_PJ
: return "picoJava";
2560 case EM_OR1K
: return "OpenRISC 1000";
2561 case EM_ARC_COMPACT
: return "ARCompact";
2563 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2564 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2565 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2566 case EM_NS32K
: return "National Semiconductor 32000 series";
2567 case EM_TPC
: return "Tenor Network TPC processor";
2568 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2570 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2572 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2573 case EM_MAX
: return "MAX Processor";
2574 case EM_CR
: return "National Semiconductor CompactRISC";
2575 case EM_F2MC16
: return "Fujitsu F2MC16";
2576 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2577 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2578 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2579 case EM_SEP
: return "Sharp embedded microprocessor";
2580 case EM_ARCA
: return "Arca RISC microprocessor";
2582 case EM_UNICORE
: return "Unicore";
2583 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2584 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2585 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2586 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2587 case EM_XGATE
: return "Motorola XGATE embedded processor";
2589 case EM_XC16X
: return "Infineon Technologies xc16x";
2590 case EM_M16C
: return "Renesas M16C series microprocessors";
2591 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2592 case EM_CE
: return "Freescale Communication Engine RISC core";
2594 case EM_M32C
: return "Renesas M32c";
2596 case EM_TSK3000
: return "Altium TSK3000 core";
2597 case EM_RS08
: return "Freescale RS08 embedded processor";
2598 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2599 case EM_SCORE
: return "SUNPLUS S+Core";
2600 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2601 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2602 case EM_LATTICEMICO32
: return "Lattice Mico32";
2603 case EM_SE_C17
: return "Seiko Epson C17 family";
2605 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2606 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2607 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2608 case EM_TI_PRU
: return "TI PRU I/O processor";
2610 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2611 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2612 case EM_R32C
: return "Renesas R32C series microprocessors";
2613 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2614 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2615 case EM_8051
: return "Intel 8051 and variants";
2616 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2617 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2618 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2619 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2621 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2622 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2623 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2624 case EM_RX
: return "Renesas RX";
2625 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2626 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2627 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2630 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2631 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2632 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2634 case EM_L1OM
: return "Intel L1OM";
2635 case EM_K1OM
: return "Intel K1OM";
2636 case EM_INTEL182
: return "Intel (reserved)";
2637 case EM_AARCH64
: return "AArch64";
2638 case EM_ARM184
: return "ARM (reserved)";
2639 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2640 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2641 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2642 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2644 case EM_CUDA
: return "NVIDIA CUDA architecture";
2645 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2646 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2647 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2648 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2649 case EM_ARC_COMPACT2
: return "ARCv2";
2650 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2651 case EM_RL78
: return "Renesas RL78";
2652 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2653 case EM_78K0R
: return "Renesas 78K0R";
2655 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2656 case EM_BA1
: return "Beyond BA1 CPU architecture";
2657 case EM_BA2
: return "Beyond BA2 CPU architecture";
2658 case EM_XCORE
: return "XMOS xCORE processor family";
2659 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2660 case EM_INTELGT
: return "Intel Graphics Technology";
2662 case EM_KM32
: return "KM211 KM32 32-bit processor";
2663 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2664 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2665 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2666 case EM_KVARC
: return "KM211 KVARC processor";
2667 case EM_CDP
: return "Paneve CDP architecture family";
2668 case EM_COGE
: return "Cognitive Smart Memory Processor";
2669 case EM_COOL
: return "Bluechip Systems CoolEngine";
2670 case EM_NORC
: return "Nanoradio Optimized RISC";
2671 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2673 case EM_Z80
: return "Zilog Z80";
2674 case EM_VISIUM
: return "CDS VISIUMcore processor";
2675 case EM_FT32
: return "FTDI Chip FT32";
2676 case EM_MOXIE
: return "Moxie";
2677 case EM_AMDGPU
: return "AMD GPU";
2678 /* 230 (all reserved) */
2680 case EM_RISCV
: return "RISC-V";
2681 case EM_LANAI
: return "Lanai 32-bit processor";
2682 case EM_CEVA
: return "CEVA Processor Architecture Family";
2683 case EM_CEVA_X2
: return "CEVA X2 Processor Family";
2684 case EM_BPF
: return "Linux BPF";
2685 case EM_GRAPHCORE_IPU
: return "Graphcore Intelligent Processing Unit";
2686 case EM_IMG1
: return "Imagination Technologies";
2688 case EM_NFP
: return "Netronome Flow Processor";
2689 case EM_VE
: return "NEC Vector Engine";
2690 case EM_CSKY
: return "C-SKY";
2691 case EM_ARC_COMPACT3_64
: return "Synopsys ARCv2.3 64-bit";
2692 case EM_MCS6502
: return "MOS Technology MCS 6502 processor";
2693 case EM_ARC_COMPACT3
: return "Synopsys ARCv2.3 32-bit";
2694 case EM_KVX
: return "Kalray VLIW core of the MPPA processor family";
2695 case EM_65816
: return "WDC 65816/65C816";
2696 case EM_LOONGARCH
: return "LoongArch";
2697 case EM_KF32
: return "ChipON KungFu32";
2699 /* Large numbers... */
2700 case EM_MT
: return "Morpho Techologies MT processor";
2701 case EM_ALPHA
: return "Alpha";
2702 case EM_WEBASSEMBLY
: return "Web Assembly";
2703 case EM_DLX
: return "OpenDLX";
2704 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2705 case EM_IQ2000
: return "Vitesse IQ2000";
2707 case EM_NIOS32
: return "Altera Nios";
2708 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2709 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2710 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2711 case EM_S12Z
: return "Freescale S12Z";
2714 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2720 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2722 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2723 other compilers don't specify an architecture type in the e_flags, and
2724 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2725 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2728 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2729 but also sets a specific architecture type in the e_flags field.
2731 However, when decoding the flags we don't worry if we see an
2732 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2733 ARCEM architecture type. */
2735 switch (e_flags
& EF_ARC_MACH_MSK
)
2737 /* We only expect these to occur for EM_ARC_COMPACT2. */
2738 case EF_ARC_CPU_ARCV2EM
:
2739 strcat (buf
, ", ARC EM");
2741 case EF_ARC_CPU_ARCV2HS
:
2742 strcat (buf
, ", ARC HS");
2745 /* We only expect these to occur for EM_ARC_COMPACT. */
2746 case E_ARC_MACH_ARC600
:
2747 strcat (buf
, ", ARC600");
2749 case E_ARC_MACH_ARC601
:
2750 strcat (buf
, ", ARC601");
2752 case E_ARC_MACH_ARC700
:
2753 strcat (buf
, ", ARC700");
2756 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2757 new ELF with new architecture being read by an old version of
2758 readelf, or (c) An ELF built with non-GNU compiler that does not
2759 set the architecture in the e_flags. */
2761 if (e_machine
== EM_ARC_COMPACT
)
2762 strcat (buf
, ", Unknown ARCompact");
2764 strcat (buf
, ", Unknown ARC");
2768 switch (e_flags
& EF_ARC_OSABI_MSK
)
2770 case E_ARC_OSABI_ORIG
:
2771 strcat (buf
, ", (ABI:legacy)");
2773 case E_ARC_OSABI_V2
:
2774 strcat (buf
, ", (ABI:v2)");
2776 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2777 case E_ARC_OSABI_V3
:
2778 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2780 case E_ARC_OSABI_V4
:
2781 strcat (buf
, ", v4 ABI");
2784 strcat (buf
, ", unrecognised ARC OSABI flag");
2790 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2793 bool unknown
= false;
2795 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2796 e_flags
&= ~ EF_ARM_EABIMASK
;
2798 /* Handle "generic" ARM flags. */
2799 if (e_flags
& EF_ARM_RELEXEC
)
2801 strcat (buf
, ", relocatable executable");
2802 e_flags
&= ~ EF_ARM_RELEXEC
;
2805 if (e_flags
& EF_ARM_PIC
)
2807 strcat (buf
, ", position independent");
2808 e_flags
&= ~ EF_ARM_PIC
;
2811 /* Now handle EABI specific flags. */
2815 strcat (buf
, ", <unrecognized EABI>");
2820 case EF_ARM_EABI_VER1
:
2821 strcat (buf
, ", Version1 EABI");
2826 /* Process flags one bit at a time. */
2827 flag
= e_flags
& - e_flags
;
2832 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2833 strcat (buf
, ", sorted symbol tables");
2843 case EF_ARM_EABI_VER2
:
2844 strcat (buf
, ", Version2 EABI");
2849 /* Process flags one bit at a time. */
2850 flag
= e_flags
& - e_flags
;
2855 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2856 strcat (buf
, ", sorted symbol tables");
2859 case EF_ARM_DYNSYMSUSESEGIDX
:
2860 strcat (buf
, ", dynamic symbols use segment index");
2863 case EF_ARM_MAPSYMSFIRST
:
2864 strcat (buf
, ", mapping symbols precede others");
2874 case EF_ARM_EABI_VER3
:
2875 strcat (buf
, ", Version3 EABI");
2878 case EF_ARM_EABI_VER4
:
2879 strcat (buf
, ", Version4 EABI");
2884 /* Process flags one bit at a time. */
2885 flag
= e_flags
& - e_flags
;
2891 strcat (buf
, ", BE8");
2895 strcat (buf
, ", LE8");
2905 case EF_ARM_EABI_VER5
:
2906 strcat (buf
, ", Version5 EABI");
2911 /* Process flags one bit at a time. */
2912 flag
= e_flags
& - e_flags
;
2918 strcat (buf
, ", BE8");
2922 strcat (buf
, ", LE8");
2925 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2926 strcat (buf
, ", soft-float ABI");
2929 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2930 strcat (buf
, ", hard-float ABI");
2940 case EF_ARM_EABI_UNKNOWN
:
2941 strcat (buf
, ", GNU EABI");
2946 /* Process flags one bit at a time. */
2947 flag
= e_flags
& - e_flags
;
2952 case EF_ARM_INTERWORK
:
2953 strcat (buf
, ", interworking enabled");
2956 case EF_ARM_APCS_26
:
2957 strcat (buf
, ", uses APCS/26");
2960 case EF_ARM_APCS_FLOAT
:
2961 strcat (buf
, ", uses APCS/float");
2965 strcat (buf
, ", position independent");
2969 strcat (buf
, ", 8 bit structure alignment");
2972 case EF_ARM_NEW_ABI
:
2973 strcat (buf
, ", uses new ABI");
2976 case EF_ARM_OLD_ABI
:
2977 strcat (buf
, ", uses old ABI");
2980 case EF_ARM_SOFT_FLOAT
:
2981 strcat (buf
, ", software FP");
2984 case EF_ARM_VFP_FLOAT
:
2985 strcat (buf
, ", VFP");
2988 case EF_ARM_MAVERICK_FLOAT
:
2989 strcat (buf
, ", Maverick FP");
3000 strcat (buf
,_(", <unknown>"));
3004 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
3006 --size
; /* Leave space for null terminator. */
3008 switch (e_flags
& EF_AVR_MACH
)
3010 case E_AVR_MACH_AVR1
:
3011 strncat (buf
, ", avr:1", size
);
3013 case E_AVR_MACH_AVR2
:
3014 strncat (buf
, ", avr:2", size
);
3016 case E_AVR_MACH_AVR25
:
3017 strncat (buf
, ", avr:25", size
);
3019 case E_AVR_MACH_AVR3
:
3020 strncat (buf
, ", avr:3", size
);
3022 case E_AVR_MACH_AVR31
:
3023 strncat (buf
, ", avr:31", size
);
3025 case E_AVR_MACH_AVR35
:
3026 strncat (buf
, ", avr:35", size
);
3028 case E_AVR_MACH_AVR4
:
3029 strncat (buf
, ", avr:4", size
);
3031 case E_AVR_MACH_AVR5
:
3032 strncat (buf
, ", avr:5", size
);
3034 case E_AVR_MACH_AVR51
:
3035 strncat (buf
, ", avr:51", size
);
3037 case E_AVR_MACH_AVR6
:
3038 strncat (buf
, ", avr:6", size
);
3040 case E_AVR_MACH_AVRTINY
:
3041 strncat (buf
, ", avr:100", size
);
3043 case E_AVR_MACH_XMEGA1
:
3044 strncat (buf
, ", avr:101", size
);
3046 case E_AVR_MACH_XMEGA2
:
3047 strncat (buf
, ", avr:102", size
);
3049 case E_AVR_MACH_XMEGA3
:
3050 strncat (buf
, ", avr:103", size
);
3052 case E_AVR_MACH_XMEGA4
:
3053 strncat (buf
, ", avr:104", size
);
3055 case E_AVR_MACH_XMEGA5
:
3056 strncat (buf
, ", avr:105", size
);
3058 case E_AVR_MACH_XMEGA6
:
3059 strncat (buf
, ", avr:106", size
);
3061 case E_AVR_MACH_XMEGA7
:
3062 strncat (buf
, ", avr:107", size
);
3065 strncat (buf
, ", avr:<unknown>", size
);
3069 size
-= strlen (buf
);
3070 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
3071 strncat (buf
, ", link-relax", size
);
3075 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
3081 bool has_fpu
= false;
3084 static const char *ABI_STRINGS
[] =
3086 "ABI v0", /* use r5 as return register; only used in N1213HC */
3087 "ABI v1", /* use r0 as return register */
3088 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
3089 "ABI v2fp", /* for FPU */
3093 static const char *VER_STRINGS
[] =
3095 "Andes ELF V1.3 or older",
3099 static const char *ARCH_STRINGS
[] =
3108 abi
= EF_NDS_ABI
& e_flags
;
3109 arch
= EF_NDS_ARCH
& e_flags
;
3110 config
= EF_NDS_INST
& e_flags
;
3111 version
= EF_NDS32_ELF_VERSION
& e_flags
;
3113 memset (buf
, 0, size
);
3120 case E_NDS_ABI_V2FP
:
3121 case E_NDS_ABI_AABI
:
3122 case E_NDS_ABI_V2FP_PLUS
:
3123 /* In case there are holes in the array. */
3124 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
3128 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
3134 case E_NDS32_ELF_VER_1_2
:
3135 case E_NDS32_ELF_VER_1_3
:
3136 case E_NDS32_ELF_VER_1_4
:
3137 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
3141 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
3145 if (E_NDS_ABI_V0
== abi
)
3147 /* OLD ABI; only used in N1213HC, has performance extension 1. */
3148 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
3149 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3150 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
3156 case E_NDS_ARCH_STAR_V1_0
:
3157 case E_NDS_ARCH_STAR_V2_0
:
3158 case E_NDS_ARCH_STAR_V3_0
:
3159 case E_NDS_ARCH_STAR_V3_M
:
3160 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
3164 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
3165 /* ARCH version determines how the e_flags are interpreted.
3166 If it is unknown, we cannot proceed. */
3170 /* Newer ABI; Now handle architecture specific flags. */
3171 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3173 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3174 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
3176 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
3177 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
3179 if (config
& E_NDS32_HAS_DIV_INST
)
3180 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
3182 if (config
& E_NDS32_HAS_16BIT_INST
)
3183 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3187 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3189 if (version
<= E_NDS32_ELF_VER_1_3
)
3190 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
3192 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
3195 if (config
& E_NDS32_HAS_MAC_DX_INST
)
3196 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
3198 if (config
& E_NDS32_HAS_DIV_DX_INST
)
3199 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
3201 if (config
& E_NDS32_HAS_16BIT_INST
)
3203 if (version
<= E_NDS32_ELF_VER_1_3
)
3204 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3206 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3210 if (config
& E_NDS32_HAS_EXT_INST
)
3211 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3213 if (config
& E_NDS32_HAS_EXT2_INST
)
3214 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3216 if (config
& E_NDS32_HAS_FPU_INST
)
3219 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3222 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3225 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3228 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3231 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3236 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3238 case E_NDS32_FPU_REG_8SP_4DP
:
3239 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3241 case E_NDS32_FPU_REG_16SP_8DP
:
3242 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3244 case E_NDS32_FPU_REG_32SP_16DP
:
3245 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3247 case E_NDS32_FPU_REG_32SP_32DP
:
3248 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3253 if (config
& E_NDS32_HAS_AUDIO_INST
)
3254 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3256 if (config
& E_NDS32_HAS_STRING_INST
)
3257 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3259 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3260 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3262 if (config
& E_NDS32_HAS_VIDEO_INST
)
3264 if (version
<= E_NDS32_ELF_VER_1_3
)
3265 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3267 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3270 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3271 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3273 if (config
& E_NDS32_HAS_L2C_INST
)
3274 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3278 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3280 static char buf
[1024];
3291 case EM_ARC_COMPACT2
:
3292 case EM_ARC_COMPACT
:
3293 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3297 decode_ARM_machine_flags (e_flags
, buf
);
3301 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3305 if (e_flags
& EF_BFIN_PIC
)
3306 strcat (buf
, ", PIC");
3308 if (e_flags
& EF_BFIN_FDPIC
)
3309 strcat (buf
, ", FDPIC");
3311 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3312 strcat (buf
, ", code in L1");
3314 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3315 strcat (buf
, ", data in L1");
3320 switch (e_flags
& EF_FRV_CPU_MASK
)
3322 case EF_FRV_CPU_GENERIC
:
3326 strcat (buf
, ", fr???");
3329 case EF_FRV_CPU_FR300
:
3330 strcat (buf
, ", fr300");
3333 case EF_FRV_CPU_FR400
:
3334 strcat (buf
, ", fr400");
3336 case EF_FRV_CPU_FR405
:
3337 strcat (buf
, ", fr405");
3340 case EF_FRV_CPU_FR450
:
3341 strcat (buf
, ", fr450");
3344 case EF_FRV_CPU_FR500
:
3345 strcat (buf
, ", fr500");
3347 case EF_FRV_CPU_FR550
:
3348 strcat (buf
, ", fr550");
3351 case EF_FRV_CPU_SIMPLE
:
3352 strcat (buf
, ", simple");
3354 case EF_FRV_CPU_TOMCAT
:
3355 strcat (buf
, ", tomcat");
3361 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3362 strcat (buf
, ", m68000");
3363 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3364 strcat (buf
, ", cpu32");
3365 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3366 strcat (buf
, ", fido_a");
3369 char const * isa
= _("unknown");
3370 char const * mac
= _("unknown mac");
3371 char const * additional
= NULL
;
3373 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3375 case EF_M68K_CF_ISA_A_NODIV
:
3377 additional
= ", nodiv";
3379 case EF_M68K_CF_ISA_A
:
3382 case EF_M68K_CF_ISA_A_PLUS
:
3385 case EF_M68K_CF_ISA_B_NOUSP
:
3387 additional
= ", nousp";
3389 case EF_M68K_CF_ISA_B
:
3392 case EF_M68K_CF_ISA_C
:
3395 case EF_M68K_CF_ISA_C_NODIV
:
3397 additional
= ", nodiv";
3400 strcat (buf
, ", cf, isa ");
3403 strcat (buf
, additional
);
3404 if (e_flags
& EF_M68K_CF_FLOAT
)
3405 strcat (buf
, ", float");
3406 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3411 case EF_M68K_CF_MAC
:
3414 case EF_M68K_CF_EMAC
:
3417 case EF_M68K_CF_EMAC_B
:
3430 switch (e_flags
& EF_MEP_CPU_MASK
)
3432 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3433 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3434 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3435 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3436 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3437 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3438 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3441 switch (e_flags
& EF_MEP_COP_MASK
)
3443 case EF_MEP_COP_NONE
: break;
3444 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3445 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3446 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3447 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3448 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3451 if (e_flags
& EF_MEP_LIBRARY
)
3452 strcat (buf
, ", Built for Library");
3454 if (e_flags
& EF_MEP_INDEX_MASK
)
3455 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3456 e_flags
& EF_MEP_INDEX_MASK
);
3458 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3459 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3460 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3464 if (e_flags
& EF_PPC_EMB
)
3465 strcat (buf
, ", emb");
3467 if (e_flags
& EF_PPC_RELOCATABLE
)
3468 strcat (buf
, _(", relocatable"));
3470 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3471 strcat (buf
, _(", relocatable-lib"));
3475 if (e_flags
& EF_PPC64_ABI
)
3477 char abi
[] = ", abiv0";
3479 abi
[6] += e_flags
& EF_PPC64_ABI
;
3485 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3486 strcat (buf
, ", RH850 ABI");
3488 if (e_flags
& EF_V800_850E3
)
3489 strcat (buf
, ", V3 architecture");
3491 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3492 strcat (buf
, ", FPU not used");
3494 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3495 strcat (buf
, ", regmode: COMMON");
3497 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3498 strcat (buf
, ", r4 not used");
3500 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3501 strcat (buf
, ", r30 not used");
3503 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3504 strcat (buf
, ", r5 not used");
3506 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3507 strcat (buf
, ", r2 not used");
3509 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3511 switch (e_flags
& - e_flags
)
3513 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3514 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3515 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3516 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3517 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3518 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3519 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3520 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3521 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3522 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3523 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3524 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3531 case EM_CYGNUS_V850
:
3532 switch (e_flags
& EF_V850_ARCH
)
3534 case E_V850E3V5_ARCH
:
3535 strcat (buf
, ", v850e3v5");
3537 case E_V850E2V3_ARCH
:
3538 strcat (buf
, ", v850e2v3");
3541 strcat (buf
, ", v850e2");
3544 strcat (buf
, ", v850e1");
3547 strcat (buf
, ", v850e");
3550 strcat (buf
, ", v850");
3553 strcat (buf
, _(", unknown v850 architecture variant"));
3559 case EM_CYGNUS_M32R
:
3560 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3561 strcat (buf
, ", m32r");
3565 case EM_MIPS_RS3_LE
:
3566 if (e_flags
& EF_MIPS_NOREORDER
)
3567 strcat (buf
, ", noreorder");
3569 if (e_flags
& EF_MIPS_PIC
)
3570 strcat (buf
, ", pic");
3572 if (e_flags
& EF_MIPS_CPIC
)
3573 strcat (buf
, ", cpic");
3575 if (e_flags
& EF_MIPS_UCODE
)
3576 strcat (buf
, ", ugen_reserved");
3578 if (e_flags
& EF_MIPS_ABI2
)
3579 strcat (buf
, ", abi2");
3581 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3582 strcat (buf
, ", odk first");
3584 if (e_flags
& EF_MIPS_32BITMODE
)
3585 strcat (buf
, ", 32bitmode");
3587 if (e_flags
& EF_MIPS_NAN2008
)
3588 strcat (buf
, ", nan2008");
3590 if (e_flags
& EF_MIPS_FP64
)
3591 strcat (buf
, ", fp64");
3593 switch ((e_flags
& EF_MIPS_MACH
))
3595 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3596 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3597 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3598 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3599 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3600 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3601 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3602 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3603 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3604 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3605 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3606 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3607 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3608 case E_MIPS_MACH_GS464
: strcat (buf
, ", gs464"); break;
3609 case E_MIPS_MACH_GS464E
: strcat (buf
, ", gs464e"); break;
3610 case E_MIPS_MACH_GS264E
: strcat (buf
, ", gs264e"); break;
3611 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3612 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3613 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3614 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3615 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3617 /* We simply ignore the field in this case to avoid confusion:
3618 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3621 default: strcat (buf
, _(", unknown CPU")); break;
3624 switch ((e_flags
& EF_MIPS_ABI
))
3626 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3627 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3628 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3629 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3631 /* We simply ignore the field in this case to avoid confusion:
3632 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3633 This means it is likely to be an o32 file, but not for
3636 default: strcat (buf
, _(", unknown ABI")); break;
3639 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3640 strcat (buf
, ", mdmx");
3642 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3643 strcat (buf
, ", mips16");
3645 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3646 strcat (buf
, ", micromips");
3648 switch ((e_flags
& EF_MIPS_ARCH
))
3650 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3651 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3652 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3653 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3654 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3655 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3656 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3657 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3658 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3659 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3660 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3661 default: strcat (buf
, _(", unknown ISA")); break;
3666 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3670 switch (EF_NFP_MACH (e_flags
))
3672 case E_NFP_MACH_3200
:
3673 strcat (buf
, ", NFP-32xx");
3675 case E_NFP_MACH_6000
:
3676 strcat (buf
, ", NFP-6xxx");
3682 if (e_flags
& EF_RISCV_RVC
)
3683 strcat (buf
, ", RVC");
3685 if (e_flags
& EF_RISCV_RVE
)
3686 strcat (buf
, ", RVE");
3688 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3690 case EF_RISCV_FLOAT_ABI_SOFT
:
3691 strcat (buf
, ", soft-float ABI");
3694 case EF_RISCV_FLOAT_ABI_SINGLE
:
3695 strcat (buf
, ", single-float ABI");
3698 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3699 strcat (buf
, ", double-float ABI");
3702 case EF_RISCV_FLOAT_ABI_QUAD
:
3703 strcat (buf
, ", quad-float ABI");
3709 switch ((e_flags
& EF_SH_MACH_MASK
))
3711 case EF_SH1
: strcat (buf
, ", sh1"); break;
3712 case EF_SH2
: strcat (buf
, ", sh2"); break;
3713 case EF_SH3
: strcat (buf
, ", sh3"); break;
3714 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3715 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3716 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3717 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3718 case EF_SH4
: strcat (buf
, ", sh4"); break;
3719 case EF_SH5
: strcat (buf
, ", sh5"); break;
3720 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3721 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3722 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3723 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3724 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3725 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3726 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3727 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3728 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3729 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3730 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3731 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3732 default: strcat (buf
, _(", unknown ISA")); break;
3735 if (e_flags
& EF_SH_PIC
)
3736 strcat (buf
, ", pic");
3738 if (e_flags
& EF_SH_FDPIC
)
3739 strcat (buf
, ", fdpic");
3743 if (e_flags
& EF_OR1K_NODELAY
)
3744 strcat (buf
, ", no delay");
3748 if (e_flags
& EF_SPARC_32PLUS
)
3749 strcat (buf
, ", v8+");
3751 if (e_flags
& EF_SPARC_SUN_US1
)
3752 strcat (buf
, ", ultrasparcI");
3754 if (e_flags
& EF_SPARC_SUN_US3
)
3755 strcat (buf
, ", ultrasparcIII");
3757 if (e_flags
& EF_SPARC_HAL_R1
)
3758 strcat (buf
, ", halr1");
3760 if (e_flags
& EF_SPARC_LEDATA
)
3761 strcat (buf
, ", ledata");
3763 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3764 strcat (buf
, ", tso");
3766 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3767 strcat (buf
, ", pso");
3769 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3770 strcat (buf
, ", rmo");
3774 switch (e_flags
& EF_PARISC_ARCH
)
3776 case EFA_PARISC_1_0
:
3777 strcpy (buf
, ", PA-RISC 1.0");
3779 case EFA_PARISC_1_1
:
3780 strcpy (buf
, ", PA-RISC 1.1");
3782 case EFA_PARISC_2_0
:
3783 strcpy (buf
, ", PA-RISC 2.0");
3788 if (e_flags
& EF_PARISC_TRAPNIL
)
3789 strcat (buf
, ", trapnil");
3790 if (e_flags
& EF_PARISC_EXT
)
3791 strcat (buf
, ", ext");
3792 if (e_flags
& EF_PARISC_LSB
)
3793 strcat (buf
, ", lsb");
3794 if (e_flags
& EF_PARISC_WIDE
)
3795 strcat (buf
, ", wide");
3796 if (e_flags
& EF_PARISC_NO_KABP
)
3797 strcat (buf
, ", no kabp");
3798 if (e_flags
& EF_PARISC_LAZYSWAP
)
3799 strcat (buf
, ", lazyswap");
3804 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3805 strcat (buf
, ", new calling convention");
3807 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3808 strcat (buf
, ", gnu calling convention");
3812 if ((e_flags
& EF_IA_64_ABI64
))
3813 strcat (buf
, ", 64-bit");
3815 strcat (buf
, ", 32-bit");
3816 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3817 strcat (buf
, ", reduced fp model");
3818 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3819 strcat (buf
, ", no function descriptors, constant gp");
3820 else if ((e_flags
& EF_IA_64_CONS_GP
))
3821 strcat (buf
, ", constant gp");
3822 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3823 strcat (buf
, ", absolute");
3824 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3826 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3827 strcat (buf
, ", vms_linkages");
3828 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3830 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3832 case EF_IA_64_VMS_COMCOD_WARNING
:
3833 strcat (buf
, ", warning");
3835 case EF_IA_64_VMS_COMCOD_ERROR
:
3836 strcat (buf
, ", error");
3838 case EF_IA_64_VMS_COMCOD_ABORT
:
3839 strcat (buf
, ", abort");
3842 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3843 e_flags
& EF_IA_64_VMS_COMCOD
);
3844 strcat (buf
, ", <unknown>");
3850 if ((e_flags
& EF_VAX_NONPIC
))
3851 strcat (buf
, ", non-PIC");
3852 if ((e_flags
& EF_VAX_DFLOAT
))
3853 strcat (buf
, ", D-Float");
3854 if ((e_flags
& EF_VAX_GFLOAT
))
3855 strcat (buf
, ", G-Float");
3859 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3860 strcat (buf
, ", mcm");
3861 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3862 strcat (buf
, ", mcm24");
3863 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3864 strcat (buf
, ", gr6");
3868 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3870 case E_FLAG_RL78_ANY_CPU
: break;
3871 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3872 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3873 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3875 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3876 strcat (buf
, ", 64-bit doubles");
3880 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3881 strcat (buf
, ", 64-bit doubles");
3882 if (e_flags
& E_FLAG_RX_DSP
)
3883 strcat (buf
, ", dsp");
3884 if (e_flags
& E_FLAG_RX_PID
)
3885 strcat (buf
, ", pid");
3886 if (e_flags
& E_FLAG_RX_ABI
)
3887 strcat (buf
, ", RX ABI");
3888 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3889 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3890 ? ", uses String instructions" : ", bans String instructions");
3891 if (e_flags
& E_FLAG_RX_V2
)
3892 strcat (buf
, ", V2");
3893 if (e_flags
& E_FLAG_RX_V3
)
3894 strcat (buf
, ", V3");
3898 if (e_flags
& EF_S390_HIGH_GPRS
)
3899 strcat (buf
, ", highgprs");
3903 if ((e_flags
& EF_C6000_REL
))
3904 strcat (buf
, ", relocatable module");
3908 strcat (buf
, _(": architecture variant: "));
3909 switch (e_flags
& EF_MSP430_MACH
)
3911 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3912 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3913 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3914 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3915 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3916 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3917 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3918 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3919 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3920 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3921 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3922 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3923 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3924 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3925 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3927 strcat (buf
, _(": unknown")); break;
3930 if (e_flags
& ~ EF_MSP430_MACH
)
3931 strcat (buf
, _(": unknown extra flag bits also present"));
3935 switch (e_flags
& EF_Z80_MACH_MSK
)
3937 case EF_Z80_MACH_Z80
: strcat (buf
, ", Z80"); break;
3938 case EF_Z80_MACH_Z180
: strcat (buf
, ", Z180"); break;
3939 case EF_Z80_MACH_R800
: strcat (buf
, ", R800"); break;
3940 case EF_Z80_MACH_EZ80_Z80
: strcat (buf
, ", EZ80"); break;
3941 case EF_Z80_MACH_EZ80_ADL
: strcat (buf
, ", EZ80, ADL"); break;
3942 case EF_Z80_MACH_GBZ80
: strcat (buf
, ", GBZ80"); break;
3943 case EF_Z80_MACH_Z80N
: strcat (buf
, ", Z80N"); break;
3945 strcat (buf
, _(", unknown")); break;
3955 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3957 static char buff
[32];
3961 case ELFOSABI_NONE
: return "UNIX - System V";
3962 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3963 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3964 case ELFOSABI_GNU
: return "UNIX - GNU";
3965 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3966 case ELFOSABI_AIX
: return "UNIX - AIX";
3967 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3968 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3969 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3970 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3971 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3972 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3973 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3974 case ELFOSABI_AROS
: return "AROS";
3975 case ELFOSABI_FENIXOS
: return "FenixOS";
3976 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3977 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3980 switch (filedata
->file_header
.e_machine
)
3985 case ELFOSABI_ARM
: return "ARM";
3986 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3997 case ELFOSABI_STANDALONE
: return _("Standalone App");
4006 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
4007 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
4016 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
4022 get_aarch64_segment_type (unsigned long type
)
4026 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
4027 default: return NULL
;
4032 get_arm_segment_type (unsigned long type
)
4036 case PT_ARM_EXIDX
: return "EXIDX";
4037 default: return NULL
;
4042 get_s390_segment_type (unsigned long type
)
4046 case PT_S390_PGSTE
: return "S390_PGSTE";
4047 default: return NULL
;
4052 get_mips_segment_type (unsigned long type
)
4056 case PT_MIPS_REGINFO
: return "REGINFO";
4057 case PT_MIPS_RTPROC
: return "RTPROC";
4058 case PT_MIPS_OPTIONS
: return "OPTIONS";
4059 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
4060 default: return NULL
;
4065 get_parisc_segment_type (unsigned long type
)
4069 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
4070 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
4071 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
4072 default: return NULL
;
4077 get_ia64_segment_type (unsigned long type
)
4081 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
4082 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
4083 default: return NULL
;
4088 get_tic6x_segment_type (unsigned long type
)
4092 case PT_C6000_PHATTR
: return "C6000_PHATTR";
4093 default: return NULL
;
4098 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
4100 if (e_machine
== EM_PARISC
)
4103 case PT_HP_TLS
: return "HP_TLS";
4104 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
4105 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
4106 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
4107 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
4108 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
4109 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
4110 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
4111 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
4112 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
4113 case PT_HP_PARALLEL
: return "HP_PARALLEL";
4114 case PT_HP_FASTBIND
: return "HP_FASTBIND";
4115 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
4116 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
4117 case PT_HP_STACK
: return "HP_STACK";
4118 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
4119 default: return NULL
;
4122 if (e_machine
== EM_IA_64
)
4125 case PT_HP_TLS
: return "HP_TLS";
4126 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
4127 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
4128 case PT_IA_64_HP_STACK
: return "HP_STACK";
4129 default: return NULL
;
4136 get_solaris_segment_type (unsigned long type
)
4140 case 0x6464e550: return "PT_SUNW_UNWIND";
4141 case 0x6474e550: return "PT_SUNW_EH_FRAME";
4142 case 0x6ffffff7: return "PT_LOSUNW";
4143 case 0x6ffffffa: return "PT_SUNWBSS";
4144 case 0x6ffffffb: return "PT_SUNWSTACK";
4145 case 0x6ffffffc: return "PT_SUNWDTRACE";
4146 case 0x6ffffffd: return "PT_SUNWCAP";
4147 case 0x6fffffff: return "PT_HISUNW";
4148 default: return NULL
;
4153 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
4155 static char buff
[32];
4159 case PT_NULL
: return "NULL";
4160 case PT_LOAD
: return "LOAD";
4161 case PT_DYNAMIC
: return "DYNAMIC";
4162 case PT_INTERP
: return "INTERP";
4163 case PT_NOTE
: return "NOTE";
4164 case PT_SHLIB
: return "SHLIB";
4165 case PT_PHDR
: return "PHDR";
4166 case PT_TLS
: return "TLS";
4167 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
4168 case PT_GNU_STACK
: return "GNU_STACK";
4169 case PT_GNU_RELRO
: return "GNU_RELRO";
4170 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
4172 case PT_OPENBSD_RANDOMIZE
: return "OPENBSD_RANDOMIZE";
4173 case PT_OPENBSD_WXNEEDED
: return "OPENBSD_WXNEEDED";
4174 case PT_OPENBSD_BOOTDATA
: return "OPENBSD_BOOTDATA";
4177 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
4179 const char * result
;
4181 switch (filedata
->file_header
.e_machine
)
4184 result
= get_aarch64_segment_type (p_type
);
4187 result
= get_arm_segment_type (p_type
);
4190 case EM_MIPS_RS3_LE
:
4191 result
= get_mips_segment_type (p_type
);
4194 result
= get_parisc_segment_type (p_type
);
4197 result
= get_ia64_segment_type (p_type
);
4200 result
= get_tic6x_segment_type (p_type
);
4204 result
= get_s390_segment_type (p_type
);
4214 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
4216 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
4218 const char * result
= NULL
;
4220 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
4223 case ELFOSABI_FREEBSD
:
4224 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
4226 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
4231 result
= get_hpux_segment_type (p_type
,
4232 filedata
->file_header
.e_machine
);
4234 case ELFOSABI_SOLARIS
:
4235 result
= get_solaris_segment_type (p_type
);
4243 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4246 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4253 get_arc_section_type_name (unsigned int sh_type
)
4257 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4265 get_mips_section_type_name (unsigned int sh_type
)
4269 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4270 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4271 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4272 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4273 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4274 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4275 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4276 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4277 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4278 case SHT_MIPS_RELD
: return "MIPS_RELD";
4279 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4280 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4281 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4282 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4283 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4284 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4285 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4286 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4287 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4288 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4289 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4290 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4291 case SHT_MIPS_LINE
: return "MIPS_LINE";
4292 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4293 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4294 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4295 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4296 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4297 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4298 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4299 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4300 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4301 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4302 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4303 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4304 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4305 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4306 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4307 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4308 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4309 case SHT_MIPS_XHASH
: return "MIPS_XHASH";
4317 get_parisc_section_type_name (unsigned int sh_type
)
4321 case SHT_PARISC_EXT
: return "PARISC_EXT";
4322 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4323 case SHT_PARISC_DOC
: return "PARISC_DOC";
4324 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4325 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4326 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4327 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4328 default: return NULL
;
4333 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4335 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4336 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4337 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4341 case SHT_IA_64_EXT
: return "IA_64_EXT";
4342 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4343 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4344 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4345 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4346 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4347 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4348 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4349 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4350 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4358 get_x86_64_section_type_name (unsigned int sh_type
)
4362 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4363 default: return NULL
;
4368 get_aarch64_section_type_name (unsigned int sh_type
)
4372 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4373 default: return NULL
;
4378 get_arm_section_type_name (unsigned int sh_type
)
4382 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4383 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4384 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4385 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4386 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4387 default: return NULL
;
4392 get_tic6x_section_type_name (unsigned int sh_type
)
4396 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4397 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4398 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4399 case SHT_TI_ICODE
: return "TI_ICODE";
4400 case SHT_TI_XREF
: return "TI_XREF";
4401 case SHT_TI_HANDLER
: return "TI_HANDLER";
4402 case SHT_TI_INITINFO
: return "TI_INITINFO";
4403 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4404 default: return NULL
;
4409 get_msp430_section_type_name (unsigned int sh_type
)
4413 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4414 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4415 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4416 default: return NULL
;
4421 get_nfp_section_type_name (unsigned int sh_type
)
4425 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4426 case SHT_NFP_INITREG
: return "NFP_INITREG";
4427 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4428 default: return NULL
;
4433 get_v850_section_type_name (unsigned int sh_type
)
4437 case SHT_V850_SCOMMON
: return "V850 Small Common";
4438 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4439 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4440 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4441 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4442 default: return NULL
;
4447 get_riscv_section_type_name (unsigned int sh_type
)
4451 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4452 default: return NULL
;
4457 get_csky_section_type_name (unsigned int sh_type
)
4461 case SHT_CSKY_ATTRIBUTES
: return "CSKY_ATTRIBUTES";
4462 default: return NULL
;
4467 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4469 static char buff
[32];
4470 const char * result
;
4474 case SHT_NULL
: return "NULL";
4475 case SHT_PROGBITS
: return "PROGBITS";
4476 case SHT_SYMTAB
: return "SYMTAB";
4477 case SHT_STRTAB
: return "STRTAB";
4478 case SHT_RELA
: return "RELA";
4479 case SHT_HASH
: return "HASH";
4480 case SHT_DYNAMIC
: return "DYNAMIC";
4481 case SHT_NOTE
: return "NOTE";
4482 case SHT_NOBITS
: return "NOBITS";
4483 case SHT_REL
: return "REL";
4484 case SHT_SHLIB
: return "SHLIB";
4485 case SHT_DYNSYM
: return "DYNSYM";
4486 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4487 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4488 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4489 case SHT_GNU_HASH
: return "GNU_HASH";
4490 case SHT_GROUP
: return "GROUP";
4491 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4492 case SHT_GNU_verdef
: return "VERDEF";
4493 case SHT_GNU_verneed
: return "VERNEED";
4494 case SHT_GNU_versym
: return "VERSYM";
4495 case 0x6ffffff0: return "VERSYM";
4496 case 0x6ffffffc: return "VERDEF";
4497 case 0x7ffffffd: return "AUXILIARY";
4498 case 0x7fffffff: return "FILTER";
4499 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4502 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4504 switch (filedata
->file_header
.e_machine
)
4507 case EM_ARC_COMPACT
:
4508 case EM_ARC_COMPACT2
:
4509 result
= get_arc_section_type_name (sh_type
);
4512 case EM_MIPS_RS3_LE
:
4513 result
= get_mips_section_type_name (sh_type
);
4516 result
= get_parisc_section_type_name (sh_type
);
4519 result
= get_ia64_section_type_name (filedata
, sh_type
);
4524 result
= get_x86_64_section_type_name (sh_type
);
4527 result
= get_aarch64_section_type_name (sh_type
);
4530 result
= get_arm_section_type_name (sh_type
);
4533 result
= get_tic6x_section_type_name (sh_type
);
4536 result
= get_msp430_section_type_name (sh_type
);
4539 result
= get_nfp_section_type_name (sh_type
);
4543 case EM_CYGNUS_V850
:
4544 result
= get_v850_section_type_name (sh_type
);
4547 result
= get_riscv_section_type_name (sh_type
);
4550 result
= get_csky_section_type_name (sh_type
);
4560 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4562 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4564 switch (filedata
->file_header
.e_machine
)
4567 result
= get_ia64_section_type_name (filedata
, sh_type
);
4570 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4571 result
= get_solaris_section_type (sh_type
);
4576 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4577 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4578 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4579 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4591 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4593 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4595 switch (filedata
->file_header
.e_machine
)
4599 case EM_CYGNUS_V850
:
4600 result
= get_v850_section_type_name (sh_type
);
4610 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4613 /* This message is probably going to be displayed in a 15
4614 character wide field, so put the hex value first. */
4615 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4621 enum long_option_values
4623 OPTION_DEBUG_DUMP
= 512,
4633 OPTION_WITH_SYMBOL_VERSIONS
,
4634 OPTION_RECURSE_LIMIT
,
4635 OPTION_NO_RECURSE_LIMIT
,
4636 OPTION_NO_DEMANGLING
,
4640 static struct option options
[] =
4642 /* Note - This table is alpha-sorted on the 'val'
4643 field in order to make adding new options easier. */
4644 {"arch-specific", no_argument
, 0, 'A'},
4645 {"all", no_argument
, 0, 'a'},
4646 {"demangle", optional_argument
, 0, 'C'},
4647 {"archive-index", no_argument
, 0, 'c'},
4648 {"use-dynamic", no_argument
, 0, 'D'},
4649 {"dynamic", no_argument
, 0, 'd'},
4650 {"headers", no_argument
, 0, 'e'},
4651 {"section-groups", no_argument
, 0, 'g'},
4652 {"help", no_argument
, 0, 'H'},
4653 {"file-header", no_argument
, 0, 'h'},
4654 {"histogram", no_argument
, 0, 'I'},
4655 {"lint", no_argument
, 0, 'L'},
4656 {"enable-checks", no_argument
, 0, 'L'},
4657 {"program-headers", no_argument
, 0, 'l'},
4658 {"segments", no_argument
, 0, 'l'},
4659 {"full-section-name",no_argument
, 0, 'N'},
4660 {"notes", no_argument
, 0, 'n'},
4661 {"process-links", no_argument
, 0, 'P'},
4662 {"string-dump", required_argument
, 0, 'p'},
4663 {"relocated-dump", required_argument
, 0, 'R'},
4664 {"relocs", no_argument
, 0, 'r'},
4665 {"section-headers", no_argument
, 0, 'S'},
4666 {"sections", no_argument
, 0, 'S'},
4667 {"symbols", no_argument
, 0, 's'},
4668 {"syms", no_argument
, 0, 's'},
4669 {"silent-truncation",no_argument
, 0, 'T'},
4670 {"section-details", no_argument
, 0, 't'},
4671 {"unwind", no_argument
, 0, 'u'},
4672 {"version-info", no_argument
, 0, 'V'},
4673 {"version", no_argument
, 0, 'v'},
4674 {"wide", no_argument
, 0, 'W'},
4675 {"hex-dump", required_argument
, 0, 'x'},
4676 {"decompress", no_argument
, 0, 'z'},
4678 {"no-demangle", no_argument
, 0, OPTION_NO_DEMANGLING
},
4679 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
4680 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
4681 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
4682 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4683 {"lto-syms", no_argument
, 0, OPTION_LTO_SYMS
},
4684 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4685 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4686 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4687 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4688 #ifdef ENABLE_LIBCTF
4689 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
4690 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
4691 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
4692 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
4694 {"sym-base", optional_argument
, 0, OPTION_SYM_BASE
},
4696 {0, no_argument
, 0, 0}
4700 usage (FILE * stream
)
4702 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4703 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4704 fprintf (stream
, _(" Options are:\n"));
4705 fprintf (stream
, _("\
4706 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
4707 fprintf (stream
, _("\
4708 -h --file-header Display the ELF file header\n"));
4709 fprintf (stream
, _("\
4710 -l --program-headers Display the program headers\n"));
4711 fprintf (stream
, _("\
4712 --segments An alias for --program-headers\n"));
4713 fprintf (stream
, _("\
4714 -S --section-headers Display the sections' header\n"));
4715 fprintf (stream
, _("\
4716 --sections An alias for --section-headers\n"));
4717 fprintf (stream
, _("\
4718 -g --section-groups Display the section groups\n"));
4719 fprintf (stream
, _("\
4720 -t --section-details Display the section details\n"));
4721 fprintf (stream
, _("\
4722 -e --headers Equivalent to: -h -l -S\n"));
4723 fprintf (stream
, _("\
4724 -s --syms Display the symbol table\n"));
4725 fprintf (stream
, _("\
4726 --symbols An alias for --syms\n"));
4727 fprintf (stream
, _("\
4728 --dyn-syms Display the dynamic symbol table\n"));
4729 fprintf (stream
, _("\
4730 --lto-syms Display LTO symbol tables\n"));
4731 fprintf (stream
, _("\
4732 --sym-base=[0|8|10|16] \n\
4733 Force base for symbol sizes. The options are \n\
4734 mixed (the default), octal, decimal, hexadecimal.\n"));
4735 fprintf (stream
, _("\
4736 -C --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
4737 The STYLE, if specified, can be `auto' (the default),\n\
4738 `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
4740 fprintf (stream
, _("\
4741 --no-demangle Do not demangle low-level symbol names. (default)\n"));
4742 fprintf (stream
, _("\
4743 --recurse-limit Enable a demangling recursion limit. (default)\n"));
4744 fprintf (stream
, _("\
4745 --no-recurse-limit Disable a demangling recursion limit\n"));
4746 fprintf (stream
, _("\
4747 -n --notes Display the core notes (if present)\n"));
4748 fprintf (stream
, _("\
4749 -r --relocs Display the relocations (if present)\n"));
4750 fprintf (stream
, _("\
4751 -u --unwind Display the unwind info (if present)\n"));
4752 fprintf (stream
, _("\
4753 -d --dynamic Display the dynamic section (if present)\n"));
4754 fprintf (stream
, _("\
4755 -V --version-info Display the version sections (if present)\n"));
4756 fprintf (stream
, _("\
4757 -A --arch-specific Display architecture specific information (if any)\n"));
4758 fprintf (stream
, _("\
4759 -c --archive-index Display the symbol/file index in an archive\n"));
4760 fprintf (stream
, _("\
4761 -D --use-dynamic Use the dynamic section info when displaying symbols\n"));
4762 fprintf (stream
, _("\
4763 -L --lint|--enable-checks\n\
4764 Display warning messages for possible problems\n"));
4765 fprintf (stream
, _("\
4766 -x --hex-dump=<number|name>\n\
4767 Dump the contents of section <number|name> as bytes\n"));
4768 fprintf (stream
, _("\
4769 -p --string-dump=<number|name>\n\
4770 Dump the contents of section <number|name> as strings\n"));
4771 fprintf (stream
, _("\
4772 -R --relocated-dump=<number|name>\n\
4773 Dump the relocated contents of section <number|name>\n"));
4774 fprintf (stream
, _("\
4775 -z --decompress Decompress section before dumping it\n"));
4776 fprintf (stream
, _("\
4777 -w --debug-dump[a/=abbrev, A/=addr, r/=aranges, c/=cu_index, L/=decodedline,\n\
4778 f/=frames, F/=frames-interp, g/=gdb_index, i/=info, o/=loc,\n\
4779 m/=macro, p/=pubnames, t/=pubtypes, R/=Ranges, l/=rawline,\n\
4780 s/=str, O/=str-offsets, u/=trace_abbrev, T/=trace_aranges,\n\
4782 Display the contents of DWARF debug sections\n"));
4783 fprintf (stream
, _("\
4784 -wk --debug-dump=links Display the contents of sections that link to separate\n\
4785 debuginfo files\n"));
4786 fprintf (stream
, _("\
4787 -P --process-links Display the contents of non-debug sections in separate\n\
4788 debuginfo files. (Implies -wK)\n"));
4789 #if DEFAULT_FOR_FOLLOW_LINKS
4790 fprintf (stream
, _("\
4791 -wK --debug-dump=follow-links\n\
4792 Follow links to separate debug info files (default)\n"));
4793 fprintf (stream
, _("\
4794 -wN --debug-dump=no-follow-links\n\
4795 Do not follow links to separate debug info files\n"));
4797 fprintf (stream
, _("\
4798 -wK --debug-dump=follow-links\n\
4799 Follow links to separate debug info files\n"));
4800 fprintf (stream
, _("\
4801 -wN --debug-dump=no-follow-links\n\
4802 Do not follow links to separate debug info files\n\
4805 fprintf (stream
, _("\
4806 --dwarf-depth=N Do not display DIEs at depth N or greater\n"));
4807 fprintf (stream
, _("\
4808 --dwarf-start=N Display DIEs starting at offset N\n"));
4809 #ifdef ENABLE_LIBCTF
4810 fprintf (stream
, _("\
4811 --ctf=<number|name> Display CTF info from section <number|name>\n"));
4812 fprintf (stream
, _("\
4813 --ctf-parent=<number|name>\n\
4814 Use section <number|name> as the CTF parent\n"));
4815 fprintf (stream
, _("\
4816 --ctf-symbols=<number|name>\n\
4817 Use section <number|name> as the CTF external symtab\n"));
4818 fprintf (stream
, _("\
4819 --ctf-strings=<number|name>\n\
4820 Use section <number|name> as the CTF external strtab\n"));
4823 #ifdef SUPPORT_DISASSEMBLY
4824 fprintf (stream
, _("\
4825 -i --instruction-dump=<number|name>\n\
4826 Disassemble the contents of section <number|name>\n"));
4828 fprintf (stream
, _("\
4829 -I --histogram Display histogram of bucket list lengths\n"));
4830 fprintf (stream
, _("\
4831 -W --wide Allow output width to exceed 80 characters\n"));
4832 fprintf (stream
, _("\
4833 -T --silent-truncation If a symbol name is truncated, do not add [...] suffix\n"));
4834 fprintf (stream
, _("\
4835 @<file> Read options from <file>\n"));
4836 fprintf (stream
, _("\
4837 -H --help Display this information\n"));
4838 fprintf (stream
, _("\
4839 -v --version Display the version number of readelf\n"));
4841 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4842 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4844 exit (stream
== stdout
? 0 : 1);
4847 /* Record the fact that the user wants the contents of section number
4848 SECTION to be displayed using the method(s) encoded as flags bits
4849 in TYPE. Note, TYPE can be zero if we are creating the array for
4853 request_dump_bynumber (struct dump_data
*dumpdata
,
4854 unsigned int section
, dump_type type
)
4856 if (section
>= dumpdata
->num_dump_sects
)
4858 dump_type
* new_dump_sects
;
4860 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4861 sizeof (* new_dump_sects
));
4863 if (new_dump_sects
== NULL
)
4864 error (_("Out of memory allocating dump request table.\n"));
4867 if (dumpdata
->dump_sects
)
4869 /* Copy current flag settings. */
4870 memcpy (new_dump_sects
, dumpdata
->dump_sects
,
4871 dumpdata
->num_dump_sects
* sizeof (* new_dump_sects
));
4873 free (dumpdata
->dump_sects
);
4876 dumpdata
->dump_sects
= new_dump_sects
;
4877 dumpdata
->num_dump_sects
= section
+ 1;
4881 if (dumpdata
->dump_sects
)
4882 dumpdata
->dump_sects
[section
] |= type
;
4885 /* Request a dump by section name. */
4888 request_dump_byname (const char * section
, dump_type type
)
4890 struct dump_list_entry
* new_request
;
4892 new_request
= (struct dump_list_entry
*)
4893 malloc (sizeof (struct dump_list_entry
));
4895 error (_("Out of memory allocating dump request table.\n"));
4897 new_request
->name
= strdup (section
);
4898 if (!new_request
->name
)
4899 error (_("Out of memory allocating dump request table.\n"));
4901 new_request
->type
= type
;
4903 new_request
->next
= dump_sects_byname
;
4904 dump_sects_byname
= new_request
;
4908 request_dump (struct dump_data
*dumpdata
, dump_type type
)
4914 section
= strtoul (optarg
, & cp
, 0);
4916 if (! *cp
&& section
>= 0)
4917 request_dump_bynumber (dumpdata
, section
, type
);
4919 request_dump_byname (optarg
, type
);
4923 parse_args (struct dump_data
*dumpdata
, int argc
, char ** argv
)
4930 while ((c
= getopt_long
4931 (argc
, argv
, "ACDHILNPR:STVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4949 do_section_groups
= true;
4952 do_histogram
= true;
4958 do_section_groups
= true;
4963 do_section_details
= true;
4974 do_using_dynamic
= true;
4998 do_histogram
= true;
5004 do_archive_index
= true;
5010 process_links
= true;
5011 do_follow_links
= true;
5014 request_dump (dumpdata
, HEX_DUMP
);
5017 request_dump (dumpdata
, STRING_DUMP
);
5020 request_dump (dumpdata
, RELOC_DUMP
);
5023 decompress_dumps
= true;
5029 do_debugging
= true;
5030 dwarf_select_sections_all ();
5034 do_debugging
= false;
5035 dwarf_select_sections_by_letters (optarg
);
5038 case OPTION_DEBUG_DUMP
:
5042 do_debugging
= true;
5043 dwarf_select_sections_all ();
5047 do_debugging
= false;
5048 dwarf_select_sections_by_names (optarg
);
5051 case OPTION_DWARF_DEPTH
:
5055 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
5058 case OPTION_DWARF_START
:
5062 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
5065 case OPTION_DWARF_CHECK
:
5068 case OPTION_CTF_DUMP
:
5070 request_dump (dumpdata
, CTF_DUMP
);
5072 case OPTION_CTF_SYMBOLS
:
5073 free (dump_ctf_symtab_name
);
5074 dump_ctf_symtab_name
= strdup (optarg
);
5076 case OPTION_CTF_STRINGS
:
5077 free (dump_ctf_strtab_name
);
5078 dump_ctf_strtab_name
= strdup (optarg
);
5080 case OPTION_CTF_PARENT
:
5081 free (dump_ctf_parent_name
);
5082 dump_ctf_parent_name
= strdup (optarg
);
5084 case OPTION_DYN_SYMS
:
5087 case OPTION_LTO_SYMS
:
5090 #ifdef SUPPORT_DISASSEMBLY
5092 request_dump (dumpdata
, DISASS_DUMP
);
5096 print_version (program_name
);
5105 do_not_show_symbol_truncation
= true;
5111 enum demangling_styles style
;
5113 style
= cplus_demangle_name_to_style (optarg
);
5114 if (style
== unknown_demangling
)
5115 error (_("unknown demangling style `%s'"), optarg
);
5117 cplus_demangle_set_style (style
);
5120 case OPTION_NO_DEMANGLING
:
5121 do_demangle
= false;
5123 case OPTION_RECURSE_LIMIT
:
5124 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
5126 case OPTION_NO_RECURSE_LIMIT
:
5127 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
5129 case OPTION_WITH_SYMBOL_VERSIONS
:
5130 /* Ignored for backward compatibility. */
5133 case OPTION_SYM_BASE
:
5137 sym_base
= strtoul (optarg
, NULL
, 0);
5154 /* xgettext:c-format */
5155 error (_("Invalid option '-%c'\n"), c
);
5162 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
5163 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
5164 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
5165 && !do_section_groups
&& !do_archive_index
5166 && !do_dyn_syms
&& !do_lto_syms
)
5171 do_dynamic
= do_syms
= do_reloc
= do_unwind
= do_sections
= true;
5172 do_segments
= do_header
= do_dump
= do_version
= true;
5173 do_histogram
= do_debugging
= do_arch
= do_notes
= true;
5174 do_section_groups
= do_archive_index
= do_dyn_syms
= true;
5183 get_elf_class (unsigned int elf_class
)
5185 static char buff
[32];
5189 case ELFCLASSNONE
: return _("none");
5190 case ELFCLASS32
: return "ELF32";
5191 case ELFCLASS64
: return "ELF64";
5193 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
5199 get_data_encoding (unsigned int encoding
)
5201 static char buff
[32];
5205 case ELFDATANONE
: return _("none");
5206 case ELFDATA2LSB
: return _("2's complement, little endian");
5207 case ELFDATA2MSB
: return _("2's complement, big endian");
5209 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
5214 /* Decode the data held in 'filedata->file_header'. */
5217 process_file_header (Filedata
* filedata
)
5219 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
5221 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
5222 || header
->e_ident
[EI_MAG1
] != ELFMAG1
5223 || header
->e_ident
[EI_MAG2
] != ELFMAG2
5224 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
5227 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
5231 if (! filedata
->is_separate
)
5232 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
5238 if (filedata
->is_separate
)
5239 printf (_("ELF Header in linked file '%s':\n"), filedata
->file_name
);
5241 printf (_("ELF Header:\n"));
5242 printf (_(" Magic: "));
5243 for (i
= 0; i
< EI_NIDENT
; i
++)
5244 printf ("%2.2x ", header
->e_ident
[i
]);
5246 printf (_(" Class: %s\n"),
5247 get_elf_class (header
->e_ident
[EI_CLASS
]));
5248 printf (_(" Data: %s\n"),
5249 get_data_encoding (header
->e_ident
[EI_DATA
]));
5250 printf (_(" Version: %d%s\n"),
5251 header
->e_ident
[EI_VERSION
],
5252 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
5254 : (header
->e_ident
[EI_VERSION
] != EV_NONE
5257 printf (_(" OS/ABI: %s\n"),
5258 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
5259 printf (_(" ABI Version: %d\n"),
5260 header
->e_ident
[EI_ABIVERSION
]);
5261 printf (_(" Type: %s\n"),
5262 get_file_type (filedata
));
5263 printf (_(" Machine: %s\n"),
5264 get_machine_name (header
->e_machine
));
5265 printf (_(" Version: 0x%lx\n"),
5268 printf (_(" Entry point address: "));
5269 print_vma (header
->e_entry
, PREFIX_HEX
);
5270 printf (_("\n Start of program headers: "));
5271 print_vma (header
->e_phoff
, DEC
);
5272 printf (_(" (bytes into file)\n Start of section headers: "));
5273 print_vma (header
->e_shoff
, DEC
);
5274 printf (_(" (bytes into file)\n"));
5276 printf (_(" Flags: 0x%lx%s\n"),
5278 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
5279 printf (_(" Size of this header: %u (bytes)\n"),
5281 printf (_(" Size of program headers: %u (bytes)\n"),
5282 header
->e_phentsize
);
5283 printf (_(" Number of program headers: %u"),
5285 if (filedata
->section_headers
!= NULL
5286 && header
->e_phnum
== PN_XNUM
5287 && filedata
->section_headers
[0].sh_info
!= 0)
5289 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
5290 printf (" (%u)", header
->e_phnum
);
5292 putc ('\n', stdout
);
5293 printf (_(" Size of section headers: %u (bytes)\n"),
5294 header
->e_shentsize
);
5295 printf (_(" Number of section headers: %u"),
5297 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
5299 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5300 printf (" (%u)", header
->e_shnum
);
5302 putc ('\n', stdout
);
5303 printf (_(" Section header string table index: %u"),
5304 header
->e_shstrndx
);
5305 if (filedata
->section_headers
!= NULL
5306 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5308 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5309 printf (" (%u)", header
->e_shstrndx
);
5311 if (header
->e_shstrndx
!= SHN_UNDEF
5312 && header
->e_shstrndx
>= header
->e_shnum
)
5314 header
->e_shstrndx
= SHN_UNDEF
;
5315 printf (_(" <corrupt: out of range>"));
5317 putc ('\n', stdout
);
5320 if (filedata
->section_headers
!= NULL
)
5322 if (header
->e_phnum
== PN_XNUM
5323 && filedata
->section_headers
[0].sh_info
!= 0)
5324 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
5325 if (header
->e_shnum
== SHN_UNDEF
)
5326 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5327 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5328 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5329 if (header
->e_shstrndx
>= header
->e_shnum
)
5330 header
->e_shstrndx
= SHN_UNDEF
;
5336 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5337 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
5340 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5342 Elf32_External_Phdr
* phdrs
;
5343 Elf32_External_Phdr
* external
;
5344 Elf_Internal_Phdr
* internal
;
5346 unsigned int size
= filedata
->file_header
.e_phentsize
;
5347 unsigned int num
= filedata
->file_header
.e_phnum
;
5349 /* PR binutils/17531: Cope with unexpected section header sizes. */
5350 if (size
== 0 || num
== 0)
5352 if (size
< sizeof * phdrs
)
5354 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5357 if (size
> sizeof * phdrs
)
5358 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5360 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5361 size
, num
, _("program headers"));
5365 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5366 i
< filedata
->file_header
.e_phnum
;
5367 i
++, internal
++, external
++)
5369 internal
->p_type
= BYTE_GET (external
->p_type
);
5370 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5371 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5372 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5373 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5374 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5375 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5376 internal
->p_align
= BYTE_GET (external
->p_align
);
5383 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5384 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5387 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5389 Elf64_External_Phdr
* phdrs
;
5390 Elf64_External_Phdr
* external
;
5391 Elf_Internal_Phdr
* internal
;
5393 unsigned int size
= filedata
->file_header
.e_phentsize
;
5394 unsigned int num
= filedata
->file_header
.e_phnum
;
5396 /* PR binutils/17531: Cope with unexpected section header sizes. */
5397 if (size
== 0 || num
== 0)
5399 if (size
< sizeof * phdrs
)
5401 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5404 if (size
> sizeof * phdrs
)
5405 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5407 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5408 size
, num
, _("program headers"));
5412 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5413 i
< filedata
->file_header
.e_phnum
;
5414 i
++, internal
++, external
++)
5416 internal
->p_type
= BYTE_GET (external
->p_type
);
5417 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5418 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5419 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5420 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5421 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5422 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5423 internal
->p_align
= BYTE_GET (external
->p_align
);
5430 /* Returns TRUE if the program headers were read into `program_headers'. */
5433 get_program_headers (Filedata
* filedata
)
5435 Elf_Internal_Phdr
* phdrs
;
5437 /* Check cache of prior read. */
5438 if (filedata
->program_headers
!= NULL
)
5441 /* Be kind to memory checkers by looking for
5442 e_phnum values which we know must be invalid. */
5443 if (filedata
->file_header
.e_phnum
5444 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5445 >= filedata
->file_size
)
5447 error (_("Too many program headers - %#x - the file is not that big\n"),
5448 filedata
->file_header
.e_phnum
);
5452 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5453 sizeof (Elf_Internal_Phdr
));
5456 error (_("Out of memory reading %u program headers\n"),
5457 filedata
->file_header
.e_phnum
);
5462 ? get_32bit_program_headers (filedata
, phdrs
)
5463 : get_64bit_program_headers (filedata
, phdrs
))
5465 filedata
->program_headers
= phdrs
;
5473 /* Print program header info and locate dynamic section. */
5476 process_program_headers (Filedata
* filedata
)
5478 Elf_Internal_Phdr
* segment
;
5480 Elf_Internal_Phdr
* previous_load
= NULL
;
5482 if (filedata
->file_header
.e_phnum
== 0)
5484 /* PR binutils/12467. */
5485 if (filedata
->file_header
.e_phoff
!= 0)
5486 warn (_("possibly corrupt ELF header - it has a non-zero program"
5487 " header offset, but no program headers\n"));
5488 else if (do_segments
)
5490 if (filedata
->is_separate
)
5491 printf (_("\nThere are no program headers in linked file '%s'.\n"),
5492 filedata
->file_name
);
5494 printf (_("\nThere are no program headers in this file.\n"));
5499 if (do_segments
&& !do_header
)
5501 if (filedata
->is_separate
)
5502 printf ("\nIn linked file '%s' the ELF file type is %s\n",
5503 filedata
->file_name
, get_file_type (filedata
));
5505 printf (_("\nElf file type is %s\n"), get_file_type (filedata
));
5506 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5507 printf (ngettext ("There is %d program header, starting at offset %s\n",
5508 "There are %d program headers, starting at offset %s\n",
5509 filedata
->file_header
.e_phnum
),
5510 filedata
->file_header
.e_phnum
,
5511 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5514 if (! get_program_headers (filedata
))
5519 if (filedata
->file_header
.e_phnum
> 1)
5520 printf (_("\nProgram Headers:\n"));
5522 printf (_("\nProgram Headers:\n"));
5526 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5529 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5533 (_(" Type Offset VirtAddr PhysAddr\n"));
5535 (_(" FileSiz MemSiz Flags Align\n"));
5539 unsigned long dynamic_addr
= 0;
5540 bfd_size_type dynamic_size
= 0;
5541 for (i
= 0, segment
= filedata
->program_headers
;
5542 i
< filedata
->file_header
.e_phnum
;
5547 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5551 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5552 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5553 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5554 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5555 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5557 (segment
->p_flags
& PF_R
? 'R' : ' '),
5558 (segment
->p_flags
& PF_W
? 'W' : ' '),
5559 (segment
->p_flags
& PF_X
? 'E' : ' '));
5560 printf ("%#lx", (unsigned long) segment
->p_align
);
5564 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5565 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5568 print_vma (segment
->p_offset
, FULL_HEX
);
5572 print_vma (segment
->p_vaddr
, FULL_HEX
);
5574 print_vma (segment
->p_paddr
, FULL_HEX
);
5577 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5578 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5581 print_vma (segment
->p_filesz
, FULL_HEX
);
5585 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5586 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5589 print_vma (segment
->p_memsz
, FULL_HEX
);
5593 (segment
->p_flags
& PF_R
? 'R' : ' '),
5594 (segment
->p_flags
& PF_W
? 'W' : ' '),
5595 (segment
->p_flags
& PF_X
? 'E' : ' '));
5597 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5598 printf ("%#lx", (unsigned long) segment
->p_align
);
5601 print_vma (segment
->p_align
, PREFIX_HEX
);
5606 print_vma (segment
->p_offset
, FULL_HEX
);
5608 print_vma (segment
->p_vaddr
, FULL_HEX
);
5610 print_vma (segment
->p_paddr
, FULL_HEX
);
5612 print_vma (segment
->p_filesz
, FULL_HEX
);
5614 print_vma (segment
->p_memsz
, FULL_HEX
);
5616 (segment
->p_flags
& PF_R
? 'R' : ' '),
5617 (segment
->p_flags
& PF_W
? 'W' : ' '),
5618 (segment
->p_flags
& PF_X
? 'E' : ' '));
5619 print_vma (segment
->p_align
, PREFIX_HEX
);
5622 putc ('\n', stdout
);
5625 switch (segment
->p_type
)
5628 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5629 required by the ELF standard, several programs, including the Linux
5630 kernel, make use of non-ordered segments. */
5632 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5633 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5635 if (segment
->p_memsz
< segment
->p_filesz
)
5636 error (_("the segment's file size is larger than its memory size\n"));
5637 previous_load
= segment
;
5641 /* PR 20815 - Verify that the program header is loaded into memory. */
5642 if (i
> 0 && previous_load
!= NULL
)
5643 error (_("the PHDR segment must occur before any LOAD segment\n"));
5644 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5648 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5650 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
5651 if (load
->p_type
== PT_LOAD
5652 && load
->p_offset
<= segment
->p_offset
5653 && (load
->p_offset
+ load
->p_filesz
5654 >= segment
->p_offset
+ segment
->p_filesz
)
5655 && load
->p_vaddr
<= segment
->p_vaddr
5656 && (load
->p_vaddr
+ load
->p_filesz
5657 >= segment
->p_vaddr
+ segment
->p_filesz
))
5660 if (j
== filedata
->file_header
.e_phnum
)
5661 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5667 error (_("more than one dynamic segment\n"));
5669 /* By default, assume that the .dynamic section is the first
5670 section in the DYNAMIC segment. */
5671 dynamic_addr
= segment
->p_offset
;
5672 dynamic_size
= segment
->p_filesz
;
5674 /* Try to locate the .dynamic section. If there is
5675 a section header table, we can easily locate it. */
5676 if (filedata
->section_headers
!= NULL
)
5678 Elf_Internal_Shdr
* sec
;
5680 sec
= find_section (filedata
, ".dynamic");
5681 if (sec
== NULL
|| sec
->sh_size
== 0)
5683 /* A corresponding .dynamic section is expected, but on
5684 IA-64/OpenVMS it is OK for it to be missing. */
5685 if (!is_ia64_vms (filedata
))
5686 error (_("no .dynamic section in the dynamic segment\n"));
5690 if (sec
->sh_type
== SHT_NOBITS
)
5697 dynamic_addr
= sec
->sh_offset
;
5698 dynamic_size
= sec
->sh_size
;
5700 /* The PT_DYNAMIC segment, which is used by the run-time
5701 loader, should exactly match the .dynamic section. */
5703 && (dynamic_addr
!= segment
->p_offset
5704 || dynamic_size
!= segment
->p_filesz
))
5706 the .dynamic section is not the same as the dynamic segment\n"));
5709 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5710 segment. Check this after matching against the section headers
5711 so we don't warn on debuginfo file (which have NOBITS .dynamic
5713 if (dynamic_addr
> filedata
->file_size
5714 || (dynamic_size
> filedata
->file_size
- dynamic_addr
))
5716 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5723 if (segment
->p_offset
>= filedata
->file_size
5724 || segment
->p_filesz
> filedata
->file_size
- segment
->p_offset
5725 || segment
->p_filesz
- 1 >= (size_t) -2
5726 || fseek (filedata
->handle
,
5727 filedata
->archive_file_offset
+ (long) segment
->p_offset
,
5729 error (_("Unable to find program interpreter name\n"));
5732 size_t len
= segment
->p_filesz
;
5733 free (filedata
->program_interpreter
);
5734 filedata
->program_interpreter
= xmalloc (len
+ 1);
5735 len
= fread (filedata
->program_interpreter
, 1, len
,
5737 filedata
->program_interpreter
[len
] = 0;
5740 printf (_(" [Requesting program interpreter: %s]\n"),
5741 filedata
->program_interpreter
);
5748 && filedata
->section_headers
!= NULL
5749 && filedata
->string_table
!= NULL
)
5751 printf (_("\n Section to Segment mapping:\n"));
5752 printf (_(" Segment Sections...\n"));
5754 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5757 Elf_Internal_Shdr
* section
;
5759 segment
= filedata
->program_headers
+ i
;
5760 section
= filedata
->section_headers
+ 1;
5762 printf (" %2.2d ", i
);
5764 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5766 if (!ELF_TBSS_SPECIAL (section
, segment
)
5767 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5768 printf ("%s ", printable_section_name (filedata
, section
));
5775 filedata
->dynamic_addr
= dynamic_addr
;
5776 filedata
->dynamic_size
= dynamic_size
? dynamic_size
: 1;
5780 filedata
->dynamic_addr
= 0;
5781 filedata
->dynamic_size
= 1;
5785 /* Find the file offset corresponding to VMA by using the program headers. */
5788 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5790 Elf_Internal_Phdr
* seg
;
5792 if (! get_program_headers (filedata
))
5794 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5798 for (seg
= filedata
->program_headers
;
5799 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5802 if (seg
->p_type
!= PT_LOAD
)
5805 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5806 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5807 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5810 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5811 (unsigned long) vma
);
5816 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5817 If PROBE is true, this is just a probe and we do not generate any error
5818 messages if the load fails. */
5821 get_32bit_section_headers (Filedata
* filedata
, bool probe
)
5823 Elf32_External_Shdr
* shdrs
;
5824 Elf_Internal_Shdr
* internal
;
5826 unsigned int size
= filedata
->file_header
.e_shentsize
;
5827 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5829 /* PR binutils/17531: Cope with unexpected section header sizes. */
5830 if (size
== 0 || num
== 0)
5832 if (size
< sizeof * shdrs
)
5835 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5838 if (!probe
&& size
> sizeof * shdrs
)
5839 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5841 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5843 probe
? NULL
: _("section headers"));
5847 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5848 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5849 if (filedata
->section_headers
== NULL
)
5852 error (_("Out of memory reading %u section headers\n"), num
);
5857 for (i
= 0, internal
= filedata
->section_headers
;
5861 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5862 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5863 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5864 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5865 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5866 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5867 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5868 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5869 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5870 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5871 if (!probe
&& internal
->sh_link
> num
)
5872 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5873 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5874 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5881 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5884 get_64bit_section_headers (Filedata
* filedata
, bool probe
)
5886 Elf64_External_Shdr
* shdrs
;
5887 Elf_Internal_Shdr
* internal
;
5889 unsigned int size
= filedata
->file_header
.e_shentsize
;
5890 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5892 /* PR binutils/17531: Cope with unexpected section header sizes. */
5893 if (size
== 0 || num
== 0)
5896 if (size
< sizeof * shdrs
)
5899 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5903 if (! probe
&& size
> sizeof * shdrs
)
5904 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5906 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5907 filedata
->file_header
.e_shoff
,
5909 probe
? NULL
: _("section headers"));
5913 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5914 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5915 if (filedata
->section_headers
== NULL
)
5918 error (_("Out of memory reading %u section headers\n"), num
);
5923 for (i
= 0, internal
= filedata
->section_headers
;
5927 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5928 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5929 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5930 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5931 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5932 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5933 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5934 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5935 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5936 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5937 if (!probe
&& internal
->sh_link
> num
)
5938 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5939 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5940 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5948 get_section_headers (Filedata
*filedata
, bool probe
)
5950 if (filedata
->section_headers
!= NULL
)
5954 return get_32bit_section_headers (filedata
, probe
);
5956 return get_64bit_section_headers (filedata
, probe
);
5959 static Elf_Internal_Sym
*
5960 get_32bit_elf_symbols (Filedata
* filedata
,
5961 Elf_Internal_Shdr
* section
,
5962 unsigned long * num_syms_return
)
5964 unsigned long number
= 0;
5965 Elf32_External_Sym
* esyms
= NULL
;
5966 Elf_External_Sym_Shndx
* shndx
= NULL
;
5967 Elf_Internal_Sym
* isyms
= NULL
;
5968 Elf_Internal_Sym
* psym
;
5970 elf_section_list
* entry
;
5972 if (section
->sh_size
== 0)
5974 if (num_syms_return
!= NULL
)
5975 * num_syms_return
= 0;
5979 /* Run some sanity checks first. */
5980 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5982 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5983 printable_section_name (filedata
, section
),
5984 (unsigned long) section
->sh_entsize
);
5988 if (section
->sh_size
> filedata
->file_size
)
5990 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5991 printable_section_name (filedata
, section
),
5992 (unsigned long) section
->sh_size
);
5996 number
= section
->sh_size
/ section
->sh_entsize
;
5998 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
6000 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
6001 (unsigned long) section
->sh_size
,
6002 printable_section_name (filedata
, section
),
6003 (unsigned long) section
->sh_entsize
);
6007 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
6008 section
->sh_size
, _("symbols"));
6013 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
6015 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
6020 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
6024 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
6025 entry
->hdr
->sh_offset
,
6026 1, entry
->hdr
->sh_size
,
6027 _("symbol table section indices"));
6031 /* PR17531: file: heap-buffer-overflow */
6032 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
6034 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
6035 printable_section_name (filedata
, entry
->hdr
),
6036 (unsigned long) entry
->hdr
->sh_size
,
6037 (unsigned long) section
->sh_size
);
6042 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
6046 error (_("Out of memory reading %lu symbols\n"),
6047 (unsigned long) number
);
6051 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
6053 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
6054 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
6055 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
6056 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
6057 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
6059 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
6060 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
6061 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
6062 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
6063 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
6070 if (num_syms_return
!= NULL
)
6071 * num_syms_return
= isyms
== NULL
? 0 : number
;
6076 static Elf_Internal_Sym
*
6077 get_64bit_elf_symbols (Filedata
* filedata
,
6078 Elf_Internal_Shdr
* section
,
6079 unsigned long * num_syms_return
)
6081 unsigned long number
= 0;
6082 Elf64_External_Sym
* esyms
= NULL
;
6083 Elf_External_Sym_Shndx
* shndx
= NULL
;
6084 Elf_Internal_Sym
* isyms
= NULL
;
6085 Elf_Internal_Sym
* psym
;
6087 elf_section_list
* entry
;
6089 if (section
->sh_size
== 0)
6091 if (num_syms_return
!= NULL
)
6092 * num_syms_return
= 0;
6096 /* Run some sanity checks first. */
6097 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
6099 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
6100 printable_section_name (filedata
, section
),
6101 (unsigned long) section
->sh_entsize
);
6105 if (section
->sh_size
> filedata
->file_size
)
6107 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
6108 printable_section_name (filedata
, section
),
6109 (unsigned long) section
->sh_size
);
6113 number
= section
->sh_size
/ section
->sh_entsize
;
6115 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
6117 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
6118 (unsigned long) section
->sh_size
,
6119 printable_section_name (filedata
, section
),
6120 (unsigned long) section
->sh_entsize
);
6124 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
6125 section
->sh_size
, _("symbols"));
6130 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
6132 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
6137 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
6141 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
6142 entry
->hdr
->sh_offset
,
6143 1, entry
->hdr
->sh_size
,
6144 _("symbol table section indices"));
6148 /* PR17531: file: heap-buffer-overflow */
6149 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
6151 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
6152 printable_section_name (filedata
, entry
->hdr
),
6153 (unsigned long) entry
->hdr
->sh_size
,
6154 (unsigned long) section
->sh_size
);
6159 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
6163 error (_("Out of memory reading %lu symbols\n"),
6164 (unsigned long) number
);
6168 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
6170 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
6171 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
6172 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
6173 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
6175 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
6177 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
6178 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
6179 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
6181 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
6182 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
6189 if (num_syms_return
!= NULL
)
6190 * num_syms_return
= isyms
== NULL
? 0 : number
;
6195 static Elf_Internal_Sym
*
6196 get_elf_symbols (Filedata
*filedata
,
6197 Elf_Internal_Shdr
*section
,
6198 unsigned long *num_syms_return
)
6201 return get_32bit_elf_symbols (filedata
, section
, num_syms_return
);
6203 return get_64bit_elf_symbols (filedata
, section
, num_syms_return
);
6207 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
6209 static char buff
[1024];
6211 unsigned int field_size
= is_32bit_elf
? 8 : 16;
6213 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
6214 bfd_vma os_flags
= 0;
6215 bfd_vma proc_flags
= 0;
6216 bfd_vma unknown_flags
= 0;
6224 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
6225 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
6226 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
6227 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
6228 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
6229 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
6230 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
6231 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
6232 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
6233 /* 9 */ { STRING_COMMA_LEN ("TLS") },
6234 /* IA-64 specific. */
6235 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
6236 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
6237 /* IA-64 OpenVMS specific. */
6238 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
6239 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
6240 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
6241 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
6242 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
6243 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
6245 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
6246 /* SPARC specific. */
6247 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
6248 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
6250 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
6251 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
6252 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
6254 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
6256 /* 25 */ { STRING_COMMA_LEN ("VLE") },
6258 /* 26 */ { STRING_COMMA_LEN ("GNU_RETAIN") },
6261 if (do_section_details
)
6263 sprintf (buff
, "[%*.*lx]: ",
6264 field_size
, field_size
, (unsigned long) sh_flags
);
6265 p
+= field_size
+ 4;
6272 flag
= sh_flags
& - sh_flags
;
6275 if (do_section_details
)
6279 case SHF_WRITE
: sindex
= 0; break;
6280 case SHF_ALLOC
: sindex
= 1; break;
6281 case SHF_EXECINSTR
: sindex
= 2; break;
6282 case SHF_MERGE
: sindex
= 3; break;
6283 case SHF_STRINGS
: sindex
= 4; break;
6284 case SHF_INFO_LINK
: sindex
= 5; break;
6285 case SHF_LINK_ORDER
: sindex
= 6; break;
6286 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
6287 case SHF_GROUP
: sindex
= 8; break;
6288 case SHF_TLS
: sindex
= 9; break;
6289 case SHF_EXCLUDE
: sindex
= 18; break;
6290 case SHF_COMPRESSED
: sindex
= 20; break;
6294 switch (filedata
->file_header
.e_machine
)
6297 if (flag
== SHF_IA_64_SHORT
)
6299 else if (flag
== SHF_IA_64_NORECOV
)
6302 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
6305 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
6306 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
6307 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
6308 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
6309 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
6310 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
6321 case EM_OLD_SPARCV9
:
6322 case EM_SPARC32PLUS
:
6325 if (flag
== SHF_ORDERED
)
6332 case SHF_ENTRYSECT
: sindex
= 21; break;
6333 case SHF_ARM_PURECODE
: sindex
= 22; break;
6334 case SHF_COMDEF
: sindex
= 23; break;
6339 if (flag
== SHF_PPC_VLE
)
6346 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
6349 case ELFOSABI_FREEBSD
:
6350 if (flag
== SHF_GNU_RETAIN
)
6354 if (flag
== SHF_GNU_MBIND
)
6355 /* We should not recognize SHF_GNU_MBIND for
6356 ELFOSABI_NONE, but binutils as of 2019-07-23 did
6357 not set the EI_OSABI header byte. */
6368 if (p
!= buff
+ field_size
+ 4)
6370 if (size
< (10 + 2))
6372 warn (_("Internal error: not enough buffer room for section flag info"));
6373 return _("<unknown>");
6380 size
-= flags
[sindex
].len
;
6381 p
= stpcpy (p
, flags
[sindex
].str
);
6383 else if (flag
& SHF_MASKOS
)
6385 else if (flag
& SHF_MASKPROC
)
6388 unknown_flags
|= flag
;
6394 case SHF_WRITE
: *p
= 'W'; break;
6395 case SHF_ALLOC
: *p
= 'A'; break;
6396 case SHF_EXECINSTR
: *p
= 'X'; break;
6397 case SHF_MERGE
: *p
= 'M'; break;
6398 case SHF_STRINGS
: *p
= 'S'; break;
6399 case SHF_INFO_LINK
: *p
= 'I'; break;
6400 case SHF_LINK_ORDER
: *p
= 'L'; break;
6401 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
6402 case SHF_GROUP
: *p
= 'G'; break;
6403 case SHF_TLS
: *p
= 'T'; break;
6404 case SHF_EXCLUDE
: *p
= 'E'; break;
6405 case SHF_COMPRESSED
: *p
= 'C'; break;
6408 if ((filedata
->file_header
.e_machine
== EM_X86_64
6409 || filedata
->file_header
.e_machine
== EM_L1OM
6410 || filedata
->file_header
.e_machine
== EM_K1OM
)
6411 && flag
== SHF_X86_64_LARGE
)
6413 else if (filedata
->file_header
.e_machine
== EM_ARM
6414 && flag
== SHF_ARM_PURECODE
)
6416 else if (filedata
->file_header
.e_machine
== EM_PPC
6417 && flag
== SHF_PPC_VLE
)
6419 else if (flag
& SHF_MASKOS
)
6421 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
6424 case ELFOSABI_FREEBSD
:
6425 if (flag
== SHF_GNU_RETAIN
)
6432 if (flag
== SHF_GNU_MBIND
)
6434 /* We should not recognize SHF_GNU_MBIND for
6435 ELFOSABI_NONE, but binutils as of 2019-07-23 did
6436 not set the EI_OSABI header byte. */
6443 sh_flags
&= ~SHF_MASKOS
;
6447 else if (flag
& SHF_MASKPROC
)
6450 sh_flags
&= ~ SHF_MASKPROC
;
6460 if (do_section_details
)
6464 size
-= 5 + field_size
;
6465 if (p
!= buff
+ field_size
+ 4)
6469 warn (_("Internal error: not enough buffer room for section flag info"));
6470 return _("<unknown>");
6476 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6477 (unsigned long) os_flags
);
6478 p
+= 5 + field_size
;
6482 size
-= 7 + field_size
;
6483 if (p
!= buff
+ field_size
+ 4)
6487 warn (_("Internal error: not enough buffer room for section flag info"));
6488 return _("<unknown>");
6494 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6495 (unsigned long) proc_flags
);
6496 p
+= 7 + field_size
;
6500 size
-= 10 + field_size
;
6501 if (p
!= buff
+ field_size
+ 4)
6505 warn (_("Internal error: not enough buffer room for section flag info"));
6506 return _("<unknown>");
6512 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6513 (unsigned long) unknown_flags
);
6514 p
+= 10 + field_size
;
6522 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
6523 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6527 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6529 if (size
< sizeof (* echdr
))
6531 error (_("Compressed section is too small even for a compression header\n"));
6535 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6536 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6537 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6538 return sizeof (*echdr
);
6542 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6544 if (size
< sizeof (* echdr
))
6546 error (_("Compressed section is too small even for a compression header\n"));
6550 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6551 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6552 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6553 return sizeof (*echdr
);
6558 process_section_headers (Filedata
* filedata
)
6560 Elf_Internal_Shdr
* section
;
6563 if (filedata
->file_header
.e_shnum
== 0)
6565 /* PR binutils/12467. */
6566 if (filedata
->file_header
.e_shoff
!= 0)
6568 warn (_("possibly corrupt ELF file header - it has a non-zero"
6569 " section header offset, but no section headers\n"));
6572 else if (do_sections
)
6573 printf (_("\nThere are no sections in this file.\n"));
6578 if (do_sections
&& !do_header
)
6580 if (filedata
->is_separate
&& process_links
)
6581 printf (_("In linked file '%s': "), filedata
->file_name
);
6582 if (! filedata
->is_separate
|| process_links
)
6583 printf (ngettext ("There is %d section header, "
6584 "starting at offset 0x%lx:\n",
6585 "There are %d section headers, "
6586 "starting at offset 0x%lx:\n",
6587 filedata
->file_header
.e_shnum
),
6588 filedata
->file_header
.e_shnum
,
6589 (unsigned long) filedata
->file_header
.e_shoff
);
6592 if (!get_section_headers (filedata
, false))
6595 /* Read in the string table, so that we have names to display. */
6596 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6597 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6599 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6601 if (section
->sh_size
!= 0)
6603 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6604 1, section
->sh_size
,
6607 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6611 /* Scan the sections for the dynamic symbol table
6612 and dynamic string table and debug sections. */
6613 eh_addr_size
= is_32bit_elf
? 4 : 8;
6614 switch (filedata
->file_header
.e_machine
)
6617 case EM_MIPS_RS3_LE
:
6618 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6619 FDE addresses. However, the ABI also has a semi-official ILP32
6620 variant for which the normal FDE address size rules apply.
6622 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6623 section, where XX is the size of longs in bits. Unfortunately,
6624 earlier compilers provided no way of distinguishing ILP32 objects
6625 from LP64 objects, so if there's any doubt, we should assume that
6626 the official LP64 form is being used. */
6627 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6628 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6634 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6636 case E_H8_MACH_H8300
:
6637 case E_H8_MACH_H8300HN
:
6638 case E_H8_MACH_H8300SN
:
6639 case E_H8_MACH_H8300SXN
:
6642 case E_H8_MACH_H8300H
:
6643 case E_H8_MACH_H8300S
:
6644 case E_H8_MACH_H8300SX
:
6652 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6654 case EF_M32C_CPU_M16C
:
6661 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6664 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6665 if (section->sh_entsize != expected_entsize) \
6668 sprintf_vma (buf, section->sh_entsize); \
6669 /* Note: coded this way so that there is a single string for \
6671 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6672 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6673 (unsigned) expected_entsize); \
6674 section->sh_entsize = expected_entsize; \
6679 #define CHECK_ENTSIZE(section, i, type) \
6680 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6681 sizeof (Elf64_External_##type))
6683 for (i
= 0, section
= filedata
->section_headers
;
6684 i
< filedata
->file_header
.e_shnum
;
6687 char * name
= SECTION_NAME_PRINT (section
);
6689 /* Run some sanity checks on the headers and
6690 possibly fill in some file data as well. */
6691 switch (section
->sh_type
)
6694 if (filedata
->dynamic_symbols
!= NULL
)
6696 error (_("File contains multiple dynamic symbol tables\n"));
6700 CHECK_ENTSIZE (section
, i
, Sym
);
6701 filedata
->dynamic_symbols
6702 = get_elf_symbols (filedata
, section
, &filedata
->num_dynamic_syms
);
6703 filedata
->dynamic_symtab_section
= section
;
6707 if (streq (name
, ".dynstr"))
6709 if (filedata
->dynamic_strings
!= NULL
)
6711 error (_("File contains multiple dynamic string tables\n"));
6715 filedata
->dynamic_strings
6716 = (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6717 1, section
->sh_size
, _("dynamic strings"));
6718 filedata
->dynamic_strings_length
6719 = filedata
->dynamic_strings
== NULL
? 0 : section
->sh_size
;
6720 filedata
->dynamic_strtab_section
= section
;
6724 case SHT_SYMTAB_SHNDX
:
6726 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6728 entry
->hdr
= section
;
6729 entry
->next
= filedata
->symtab_shndx_list
;
6730 filedata
->symtab_shndx_list
= entry
;
6735 CHECK_ENTSIZE (section
, i
, Sym
);
6739 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6743 CHECK_ENTSIZE (section
, i
, Rel
);
6744 if (do_checks
&& section
->sh_size
== 0)
6745 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6749 CHECK_ENTSIZE (section
, i
, Rela
);
6750 if (do_checks
&& section
->sh_size
== 0)
6751 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6756 /* Having a zero sized section is not illegal according to the
6757 ELF standard, but it might be an indication that something
6758 is wrong. So issue a warning if we are running in lint mode. */
6759 if (do_checks
&& section
->sh_size
== 0)
6760 warn (_("Section '%s': has a size of zero - is this intended ?\n"), name
);
6767 if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6768 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6769 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6770 || do_debug_str
|| do_debug_str_offsets
|| do_debug_loc
6772 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6773 && (startswith (name
, ".debug_")
6774 || startswith (name
, ".zdebug_")))
6777 name
+= sizeof (".zdebug_") - 1;
6779 name
+= sizeof (".debug_") - 1;
6782 || (do_debug_info
&& startswith (name
, "info"))
6783 || (do_debug_info
&& startswith (name
, "types"))
6784 || (do_debug_abbrevs
&& startswith (name
, "abbrev"))
6785 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6786 || (do_debug_lines
&& startswith (name
, "line."))
6787 || (do_debug_pubnames
&& startswith (name
, "pubnames"))
6788 || (do_debug_pubtypes
&& startswith (name
, "pubtypes"))
6789 || (do_debug_pubnames
&& startswith (name
, "gnu_pubnames"))
6790 || (do_debug_pubtypes
&& startswith (name
, "gnu_pubtypes"))
6791 || (do_debug_aranges
&& startswith (name
, "aranges"))
6792 || (do_debug_ranges
&& startswith (name
, "ranges"))
6793 || (do_debug_ranges
&& startswith (name
, "rnglists"))
6794 || (do_debug_frames
&& startswith (name
, "frame"))
6795 || (do_debug_macinfo
&& startswith (name
, "macinfo"))
6796 || (do_debug_macinfo
&& startswith (name
, "macro"))
6797 || (do_debug_str
&& startswith (name
, "str"))
6798 || (do_debug_links
&& startswith (name
, "sup"))
6799 || (do_debug_str_offsets
&& startswith (name
, "str_offsets"))
6800 || (do_debug_loc
&& startswith (name
, "loc"))
6801 || (do_debug_loc
&& startswith (name
, "loclists"))
6802 || (do_debug_addr
&& startswith (name
, "addr"))
6803 || (do_debug_cu_index
&& startswith (name
, "cu_index"))
6804 || (do_debug_cu_index
&& startswith (name
, "tu_index"))
6806 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6808 /* Linkonce section to be combined with .debug_info at link time. */
6809 else if ((do_debugging
|| do_debug_info
)
6810 && startswith (name
, ".gnu.linkonce.wi."))
6811 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6812 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6813 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6814 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6815 || streq (name
, ".debug_names")))
6816 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6817 /* Trace sections for Itanium VMS. */
6818 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6819 || do_trace_aranges
)
6820 && startswith (name
, ".trace_"))
6822 name
+= sizeof (".trace_") - 1;
6825 || (do_trace_info
&& streq (name
, "info"))
6826 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6827 || (do_trace_aranges
&& streq (name
, "aranges"))
6829 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6831 else if ((do_debugging
|| do_debug_links
)
6832 && (startswith (name
, ".gnu_debuglink")
6833 || startswith (name
, ".gnu_debugaltlink")))
6834 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6840 if (filedata
->is_separate
&& ! process_links
)
6843 if (filedata
->is_separate
)
6844 printf (_("\nSection Headers in linked file '%s':\n"), filedata
->file_name
);
6845 else if (filedata
->file_header
.e_shnum
> 1)
6846 printf (_("\nSection Headers:\n"));
6848 printf (_("\nSection Header:\n"));
6852 if (do_section_details
)
6854 printf (_(" [Nr] Name\n"));
6855 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6859 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6863 if (do_section_details
)
6865 printf (_(" [Nr] Name\n"));
6866 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6870 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6874 if (do_section_details
)
6876 printf (_(" [Nr] Name\n"));
6877 printf (_(" Type Address Offset Link\n"));
6878 printf (_(" Size EntSize Info Align\n"));
6882 printf (_(" [Nr] Name Type Address Offset\n"));
6883 printf (_(" Size EntSize Flags Link Info Align\n"));
6887 if (do_section_details
)
6888 printf (_(" Flags\n"));
6890 for (i
= 0, section
= filedata
->section_headers
;
6891 i
< filedata
->file_header
.e_shnum
;
6894 /* Run some sanity checks on the section header. */
6896 /* Check the sh_link field. */
6897 switch (section
->sh_type
)
6901 if (section
->sh_link
== 0
6902 && (filedata
->file_header
.e_type
== ET_EXEC
6903 || filedata
->file_header
.e_type
== ET_DYN
))
6904 /* A dynamic relocation section where all entries use a
6905 zero symbol index need not specify a symtab section. */
6908 case SHT_SYMTAB_SHNDX
:
6912 case SHT_GNU_versym
:
6913 if (section
->sh_link
== 0
6914 || section
->sh_link
>= filedata
->file_header
.e_shnum
6915 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6916 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6917 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6918 i
, section
->sh_link
);
6924 case SHT_GNU_verneed
:
6925 case SHT_GNU_verdef
:
6926 case SHT_GNU_LIBLIST
:
6927 if (section
->sh_link
== 0
6928 || section
->sh_link
>= filedata
->file_header
.e_shnum
6929 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6930 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6931 i
, section
->sh_link
);
6934 case SHT_INIT_ARRAY
:
6935 case SHT_FINI_ARRAY
:
6936 case SHT_PREINIT_ARRAY
:
6937 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6938 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6939 i
, section
->sh_link
);
6943 /* FIXME: Add support for target specific section types. */
6944 #if 0 /* Currently we do not check other section types as there are too
6945 many special cases. Stab sections for example have a type
6946 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6948 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6949 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6950 i
, section
->sh_link
);
6955 /* Check the sh_info field. */
6956 switch (section
->sh_type
)
6960 if (section
->sh_info
== 0
6961 && (filedata
->file_header
.e_type
== ET_EXEC
6962 || filedata
->file_header
.e_type
== ET_DYN
))
6963 /* Dynamic relocations apply to segments, so they do not
6964 need to specify the section they relocate. */
6966 if (section
->sh_info
== 0
6967 || section
->sh_info
>= filedata
->file_header
.e_shnum
6968 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6969 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6970 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6971 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6972 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6973 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6974 /* FIXME: Are other section types valid ? */
6975 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6976 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6977 i
, section
->sh_info
);
6982 case SHT_SYMTAB_SHNDX
:
6983 case SHT_INIT_ARRAY
:
6984 case SHT_FINI_ARRAY
:
6985 case SHT_PREINIT_ARRAY
:
6986 if (section
->sh_info
!= 0)
6987 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6988 i
, section
->sh_info
);
6994 /* A symbol index - we assume that it is valid. */
6998 /* FIXME: Add support for target specific section types. */
6999 if (section
->sh_type
== SHT_NOBITS
)
7000 /* NOBITS section headers with non-zero sh_info fields can be
7001 created when a binary is stripped of everything but its debug
7002 information. The stripped sections have their headers
7003 preserved but their types set to SHT_NOBITS. So do not check
7004 this type of section. */
7006 else if (section
->sh_flags
& SHF_INFO_LINK
)
7008 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
7009 warn (_("[%2u]: Expected link to another section in info field"), i
);
7011 else if (section
->sh_type
< SHT_LOOS
7012 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
7013 && section
->sh_info
!= 0)
7014 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
7015 i
, section
->sh_info
);
7019 /* Check the sh_size field. */
7020 if (section
->sh_size
> filedata
->file_size
7021 && section
->sh_type
!= SHT_NOBITS
7022 && section
->sh_type
!= SHT_NULL
7023 && section
->sh_type
< SHT_LOOS
)
7024 warn (_("Size of section %u is larger than the entire file!\n"), i
);
7026 printf (" [%2u] ", i
);
7027 if (do_section_details
)
7028 printf ("%s\n ", printable_section_name (filedata
, section
));
7030 print_symbol (-17, SECTION_NAME_PRINT (section
));
7032 printf (do_wide
? " %-15s " : " %-15.15s ",
7033 get_section_type_name (filedata
, section
->sh_type
));
7037 const char * link_too_big
= NULL
;
7039 print_vma (section
->sh_addr
, LONG_HEX
);
7041 printf ( " %6.6lx %6.6lx %2.2lx",
7042 (unsigned long) section
->sh_offset
,
7043 (unsigned long) section
->sh_size
,
7044 (unsigned long) section
->sh_entsize
);
7046 if (do_section_details
)
7047 fputs (" ", stdout
);
7049 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
7051 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
7054 /* The sh_link value is out of range. Normally this indicates
7055 an error but it can have special values in Solaris binaries. */
7056 switch (filedata
->file_header
.e_machine
)
7063 case EM_OLD_SPARCV9
:
7064 case EM_SPARC32PLUS
:
7067 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
7068 link_too_big
= "BEFORE";
7069 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
7070 link_too_big
= "AFTER";
7077 if (do_section_details
)
7079 if (link_too_big
!= NULL
&& * link_too_big
)
7080 printf ("<%s> ", link_too_big
);
7082 printf ("%2u ", section
->sh_link
);
7083 printf ("%3u %2lu\n", section
->sh_info
,
7084 (unsigned long) section
->sh_addralign
);
7087 printf ("%2u %3u %2lu\n",
7090 (unsigned long) section
->sh_addralign
);
7092 if (link_too_big
&& ! * link_too_big
)
7093 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
7094 i
, section
->sh_link
);
7098 print_vma (section
->sh_addr
, LONG_HEX
);
7100 if ((long) section
->sh_offset
== section
->sh_offset
)
7101 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
7105 print_vma (section
->sh_offset
, LONG_HEX
);
7108 if ((unsigned long) section
->sh_size
== section
->sh_size
)
7109 printf (" %6.6lx", (unsigned long) section
->sh_size
);
7113 print_vma (section
->sh_size
, LONG_HEX
);
7116 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
7117 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
7121 print_vma (section
->sh_entsize
, LONG_HEX
);
7124 if (do_section_details
)
7125 fputs (" ", stdout
);
7127 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
7129 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
7131 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
7132 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
7135 print_vma (section
->sh_addralign
, DEC
);
7139 else if (do_section_details
)
7142 print_vma (section
->sh_addr
, LONG_HEX
);
7143 if ((long) section
->sh_offset
== section
->sh_offset
)
7144 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
7148 print_vma (section
->sh_offset
, LONG_HEX
);
7150 printf (" %u\n ", section
->sh_link
);
7151 print_vma (section
->sh_size
, LONG_HEX
);
7153 print_vma (section
->sh_entsize
, LONG_HEX
);
7155 printf (" %-16u %lu\n",
7157 (unsigned long) section
->sh_addralign
);
7162 print_vma (section
->sh_addr
, LONG_HEX
);
7163 if ((long) section
->sh_offset
== section
->sh_offset
)
7164 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
7168 print_vma (section
->sh_offset
, LONG_HEX
);
7171 print_vma (section
->sh_size
, LONG_HEX
);
7173 print_vma (section
->sh_entsize
, LONG_HEX
);
7175 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
7177 printf (" %2u %3u %lu\n",
7180 (unsigned long) section
->sh_addralign
);
7183 if (do_section_details
)
7185 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
7186 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
7188 /* Minimum section size is 12 bytes for 32-bit compression
7189 header + 12 bytes for compressed data header. */
7190 unsigned char buf
[24];
7192 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
7193 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
7194 sizeof (buf
), _("compression header")))
7196 Elf_Internal_Chdr chdr
;
7198 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
7199 printf (_(" [<corrupt>]\n"));
7202 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
7205 printf (_(" [<unknown>: 0x%x], "),
7207 print_vma (chdr
.ch_size
, LONG_HEX
);
7208 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
7215 if (!do_section_details
)
7217 /* The ordering of the letters shown here matches the ordering of the
7218 corresponding SHF_xxx values, and hence the order in which these
7219 letters will be displayed to the user. */
7220 printf (_("Key to Flags:\n\
7221 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
7222 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
7223 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
7224 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
7227 case ELFOSABI_FREEBSD
:
7228 printf (_("R (retain), "));
7231 printf (_("D (mbind), "));
7236 if (filedata
->file_header
.e_machine
== EM_X86_64
7237 || filedata
->file_header
.e_machine
== EM_L1OM
7238 || filedata
->file_header
.e_machine
== EM_K1OM
)
7239 printf (_("l (large), "));
7240 else if (filedata
->file_header
.e_machine
== EM_ARM
)
7241 printf (_("y (purecode), "));
7242 else if (filedata
->file_header
.e_machine
== EM_PPC
)
7243 printf (_("v (VLE), "));
7244 printf ("p (processor specific)\n");
7251 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
7252 Elf_Internal_Sym
**symtab
, unsigned long *nsyms
,
7253 char **strtab
, unsigned long *strtablen
)
7257 *symtab
= get_elf_symbols (filedata
, symsec
, nsyms
);
7259 if (*symtab
== NULL
)
7262 if (symsec
->sh_link
!= 0)
7264 Elf_Internal_Shdr
*strsec
;
7266 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
7268 error (_("Bad sh_link in symbol table section\n"));
7275 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7277 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7278 1, strsec
->sh_size
, _("string table"));
7279 if (*strtab
== NULL
)
7286 *strtablen
= strsec
->sh_size
;
7292 get_group_flags (unsigned int flags
)
7294 static char buff
[128];
7298 else if (flags
== GRP_COMDAT
)
7301 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
7303 flags
& GRP_MASKOS
? _("<OS specific>") : "",
7304 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
7305 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
7306 ? _("<unknown>") : ""));
7312 process_section_groups (Filedata
* filedata
)
7314 Elf_Internal_Shdr
* section
;
7316 struct group
* group
;
7317 Elf_Internal_Shdr
* symtab_sec
;
7318 Elf_Internal_Shdr
* strtab_sec
;
7319 Elf_Internal_Sym
* symtab
;
7320 unsigned long num_syms
;
7324 /* Don't process section groups unless needed. */
7325 if (!do_unwind
&& !do_section_groups
)
7328 if (filedata
->file_header
.e_shnum
== 0)
7330 if (do_section_groups
)
7332 if (filedata
->is_separate
)
7333 printf (_("\nThere are no sections group in linked file '%s'.\n"),
7334 filedata
->file_name
);
7336 printf (_("\nThere are no section groups in this file.\n"));
7341 if (filedata
->section_headers
== NULL
)
7343 error (_("Section headers are not available!\n"));
7344 /* PR 13622: This can happen with a corrupt ELF header. */
7348 filedata
->section_headers_groups
7349 = (struct group
**) calloc (filedata
->file_header
.e_shnum
,
7350 sizeof (struct group
*));
7352 if (filedata
->section_headers_groups
== NULL
)
7354 error (_("Out of memory reading %u section group headers\n"),
7355 filedata
->file_header
.e_shnum
);
7359 /* Scan the sections for the group section. */
7360 filedata
->group_count
= 0;
7361 for (i
= 0, section
= filedata
->section_headers
;
7362 i
< filedata
->file_header
.e_shnum
;
7364 if (section
->sh_type
== SHT_GROUP
)
7365 filedata
->group_count
++;
7367 if (filedata
->group_count
== 0)
7369 if (do_section_groups
)
7371 if (filedata
->is_separate
)
7372 printf (_("\nThere are no section groups in linked file '%s'.\n"),
7373 filedata
->file_name
);
7375 printf (_("\nThere are no section groups in this file.\n"));
7381 filedata
->section_groups
= (struct group
*) calloc (filedata
->group_count
,
7382 sizeof (struct group
));
7384 if (filedata
->section_groups
== NULL
)
7386 error (_("Out of memory reading %lu groups\n"),
7387 (unsigned long) filedata
->group_count
);
7398 if (filedata
->is_separate
)
7399 printf (_("Section groups in linked file '%s'\n"), filedata
->file_name
);
7401 for (i
= 0, section
= filedata
->section_headers
, group
= filedata
->section_groups
;
7402 i
< filedata
->file_header
.e_shnum
;
7405 if (section
->sh_type
== SHT_GROUP
)
7407 const char * name
= printable_section_name (filedata
, section
);
7408 const char * group_name
;
7409 unsigned char * start
;
7410 unsigned char * indices
;
7411 unsigned int entry
, j
, size
;
7412 Elf_Internal_Shdr
* sec
;
7413 Elf_Internal_Sym
* sym
;
7415 /* Get the symbol table. */
7416 if (section
->sh_link
>= filedata
->file_header
.e_shnum
7417 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
7420 error (_("Bad sh_link in group section `%s'\n"), name
);
7424 if (symtab_sec
!= sec
)
7428 symtab
= get_elf_symbols (filedata
, symtab_sec
, & num_syms
);
7433 error (_("Corrupt header in group section `%s'\n"), name
);
7437 if (section
->sh_info
>= num_syms
)
7439 error (_("Bad sh_info in group section `%s'\n"), name
);
7443 sym
= symtab
+ section
->sh_info
;
7445 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
7447 if (sym
->st_shndx
== 0
7448 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
7450 error (_("Bad sh_info in group section `%s'\n"), name
);
7454 group_name
= SECTION_NAME_PRINT (filedata
->section_headers
7463 /* Get the string table. */
7464 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
7472 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
7477 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
7478 1, strtab_sec
->sh_size
,
7480 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
7482 group_name
= sym
->st_name
< strtab_size
7483 ? strtab
+ sym
->st_name
: _("<corrupt>");
7486 /* PR 17531: file: loop. */
7487 if (section
->sh_entsize
> section
->sh_size
)
7489 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7490 printable_section_name (filedata
, section
),
7491 (unsigned long) section
->sh_entsize
,
7492 (unsigned long) section
->sh_size
);
7496 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
7497 1, section
->sh_size
,
7503 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
7504 entry
= byte_get (indices
, 4);
7507 if (do_section_groups
)
7509 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7510 get_group_flags (entry
), i
, name
, group_name
, size
);
7512 printf (_(" [Index] Name\n"));
7515 group
->group_index
= i
;
7517 for (j
= 0; j
< size
; j
++)
7519 struct group_list
* g
;
7521 entry
= byte_get (indices
, 4);
7524 if (entry
>= filedata
->file_header
.e_shnum
)
7526 static unsigned num_group_errors
= 0;
7528 if (num_group_errors
++ < 10)
7530 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7531 entry
, i
, filedata
->file_header
.e_shnum
- 1);
7532 if (num_group_errors
== 10)
7533 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7538 if (filedata
->section_headers_groups
[entry
] != NULL
)
7542 static unsigned num_errs
= 0;
7544 if (num_errs
++ < 10)
7546 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7548 filedata
->section_headers_groups
[entry
]->group_index
);
7550 warn (_("Further error messages about already contained group sections suppressed\n"));
7556 /* Intel C/C++ compiler may put section 0 in a
7557 section group. We just warn it the first time
7558 and ignore it afterwards. */
7559 static bool warned
= false;
7562 error (_("section 0 in group section [%5u]\n"),
7563 filedata
->section_headers_groups
[entry
]->group_index
);
7569 filedata
->section_headers_groups
[entry
] = group
;
7571 if (do_section_groups
)
7573 sec
= filedata
->section_headers
+ entry
;
7574 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7577 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7578 g
->section_index
= entry
;
7579 g
->next
= group
->root
;
7594 /* Data used to display dynamic fixups. */
7596 struct ia64_vms_dynfixup
7598 bfd_vma needed_ident
; /* Library ident number. */
7599 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7600 bfd_vma fixup_needed
; /* Index of the library. */
7601 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7602 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7605 /* Data used to display dynamic relocations. */
7607 struct ia64_vms_dynimgrela
7609 bfd_vma img_rela_cnt
; /* Number of relocations. */
7610 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7613 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7617 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7618 struct ia64_vms_dynfixup
* fixup
,
7619 const char * strtab
,
7620 unsigned int strtab_sz
)
7622 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7624 const char * lib_name
;
7626 imfs
= get_data (NULL
, filedata
,
7627 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
7628 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
7629 _("dynamic section image fixups"));
7633 if (fixup
->needed
< strtab_sz
)
7634 lib_name
= strtab
+ fixup
->needed
;
7637 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7638 (unsigned long) fixup
->needed
);
7642 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7643 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7645 (_("Seg Offset Type SymVec DataType\n"));
7647 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7652 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7653 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7654 type
= BYTE_GET (imfs
[i
].type
);
7655 rtype
= elf_ia64_reloc_type (type
);
7657 printf (" 0x%08x ", type
);
7659 printf (" %-32s ", rtype
);
7660 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7661 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7668 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7671 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7673 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7676 imrs
= get_data (NULL
, filedata
,
7677 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
7678 sizeof (*imrs
), imgrela
->img_rela_cnt
,
7679 _("dynamic section image relocations"));
7683 printf (_("\nImage relocs\n"));
7685 (_("Seg Offset Type Addend Seg Sym Off\n"));
7687 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7692 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7693 printf ("%08" BFD_VMA_FMT
"x ",
7694 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7695 type
= BYTE_GET (imrs
[i
].type
);
7696 rtype
= elf_ia64_reloc_type (type
);
7698 printf ("0x%08x ", type
);
7700 printf ("%-31s ", rtype
);
7701 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7702 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7703 printf ("%08" BFD_VMA_FMT
"x\n",
7704 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7711 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7714 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7716 struct ia64_vms_dynfixup fixup
;
7717 struct ia64_vms_dynimgrela imgrela
;
7718 Elf_Internal_Dyn
*entry
;
7719 bfd_vma strtab_off
= 0;
7720 bfd_vma strtab_sz
= 0;
7721 char *strtab
= NULL
;
7724 memset (&fixup
, 0, sizeof (fixup
));
7725 memset (&imgrela
, 0, sizeof (imgrela
));
7727 /* Note: the order of the entries is specified by the OpenVMS specs. */
7728 for (entry
= filedata
->dynamic_section
;
7729 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
7732 switch (entry
->d_tag
)
7734 case DT_IA_64_VMS_STRTAB_OFFSET
:
7735 strtab_off
= entry
->d_un
.d_val
;
7738 strtab_sz
= entry
->d_un
.d_val
;
7740 strtab
= get_data (NULL
, filedata
,
7741 filedata
->dynamic_addr
+ strtab_off
,
7742 1, strtab_sz
, _("dynamic string section"));
7747 case DT_IA_64_VMS_NEEDED_IDENT
:
7748 fixup
.needed_ident
= entry
->d_un
.d_val
;
7751 fixup
.needed
= entry
->d_un
.d_val
;
7753 case DT_IA_64_VMS_FIXUP_NEEDED
:
7754 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7756 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7757 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7759 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7760 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7761 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7764 case DT_IA_64_VMS_IMG_RELA_CNT
:
7765 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7767 case DT_IA_64_VMS_IMG_RELA_OFF
:
7768 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7769 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7790 dynamic_relocations
[] =
7792 { "REL", DT_REL
, DT_RELSZ
, false },
7793 { "RELA", DT_RELA
, DT_RELASZ
, true },
7794 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7797 /* Process the reloc section. */
7800 process_relocs (Filedata
* filedata
)
7802 unsigned long rel_size
;
7803 unsigned long rel_offset
;
7808 if (do_using_dynamic
)
7812 bool has_dynamic_reloc
;
7815 has_dynamic_reloc
= false;
7817 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7819 is_rela
= dynamic_relocations
[i
].rela
;
7820 name
= dynamic_relocations
[i
].name
;
7821 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
7822 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
7825 has_dynamic_reloc
= true;
7827 if (is_rela
== UNKNOWN
)
7829 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7830 switch (filedata
->dynamic_info
[DT_PLTREL
])
7843 if (filedata
->is_separate
)
7845 (_("\nIn linked file '%s' section '%s' at offset 0x%lx contains %ld bytes:\n"),
7846 filedata
->file_name
, name
, rel_offset
, rel_size
);
7849 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7850 name
, rel_offset
, rel_size
);
7852 dump_relocations (filedata
,
7853 offset_from_vma (filedata
, rel_offset
, rel_size
),
7855 filedata
->dynamic_symbols
,
7856 filedata
->num_dynamic_syms
,
7857 filedata
->dynamic_strings
,
7858 filedata
->dynamic_strings_length
,
7859 is_rela
, true /* is_dynamic */);
7863 if (is_ia64_vms (filedata
))
7864 if (process_ia64_vms_dynamic_relocs (filedata
))
7865 has_dynamic_reloc
= true;
7867 if (! has_dynamic_reloc
)
7869 if (filedata
->is_separate
)
7870 printf (_("\nThere are no dynamic relocations in linked file '%s'.\n"),
7871 filedata
->file_name
);
7873 printf (_("\nThere are no dynamic relocations in this file.\n"));
7878 Elf_Internal_Shdr
* section
;
7882 for (i
= 0, section
= filedata
->section_headers
;
7883 i
< filedata
->file_header
.e_shnum
;
7886 if ( section
->sh_type
!= SHT_RELA
7887 && section
->sh_type
!= SHT_REL
)
7890 rel_offset
= section
->sh_offset
;
7891 rel_size
= section
->sh_size
;
7896 unsigned long num_rela
;
7898 if (filedata
->is_separate
)
7899 printf (_("\nIn linked file '%s' relocation section "),
7900 filedata
->file_name
);
7902 printf (_("\nRelocation section "));
7904 if (filedata
->string_table
== NULL
)
7905 printf ("%d", section
->sh_name
);
7907 printf ("'%s'", printable_section_name (filedata
, section
));
7909 num_rela
= rel_size
/ section
->sh_entsize
;
7910 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7911 " at offset 0x%lx contains %lu entries:\n",
7913 rel_offset
, num_rela
);
7915 is_rela
= section
->sh_type
== SHT_RELA
;
7917 if (section
->sh_link
!= 0
7918 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7920 Elf_Internal_Shdr
* symsec
;
7921 Elf_Internal_Sym
* symtab
;
7922 unsigned long nsyms
;
7923 unsigned long strtablen
= 0;
7924 char * strtab
= NULL
;
7926 symsec
= filedata
->section_headers
+ section
->sh_link
;
7927 if (symsec
->sh_type
!= SHT_SYMTAB
7928 && symsec
->sh_type
!= SHT_DYNSYM
)
7931 if (!get_symtab (filedata
, symsec
,
7932 &symtab
, &nsyms
, &strtab
, &strtablen
))
7935 dump_relocations (filedata
, rel_offset
, rel_size
,
7936 symtab
, nsyms
, strtab
, strtablen
,
7938 symsec
->sh_type
== SHT_DYNSYM
);
7943 dump_relocations (filedata
, rel_offset
, rel_size
,
7944 NULL
, 0, NULL
, 0, is_rela
,
7945 false /* is_dynamic */);
7953 /* Users sometimes forget the -D option, so try to be helpful. */
7954 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7956 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
7958 if (filedata
->is_separate
)
7959 printf (_("\nThere are no static relocations in linked file '%s'."),
7960 filedata
->file_name
);
7962 printf (_("\nThere are no static relocations in this file."));
7963 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7968 if (i
== ARRAY_SIZE (dynamic_relocations
))
7970 if (filedata
->is_separate
)
7971 printf (_("\nThere are no relocations in linked file '%s'.\n"),
7972 filedata
->file_name
);
7974 printf (_("\nThere are no relocations in this file.\n"));
7982 /* An absolute address consists of a section and an offset. If the
7983 section is NULL, the offset itself is the address, otherwise, the
7984 address equals to LOAD_ADDRESS(section) + offset. */
7988 unsigned short section
;
7992 /* Find the nearest symbol at or below ADDR. Returns the symbol
7993 name, if found, and the offset from the symbol to ADDR. */
7996 find_symbol_for_address (Filedata
* filedata
,
7997 Elf_Internal_Sym
* symtab
,
7998 unsigned long nsyms
,
7999 const char * strtab
,
8000 unsigned long strtab_size
,
8001 struct absaddr addr
,
8002 const char ** symname
,
8005 bfd_vma dist
= 0x100000;
8006 Elf_Internal_Sym
* sym
;
8007 Elf_Internal_Sym
* beg
;
8008 Elf_Internal_Sym
* end
;
8009 Elf_Internal_Sym
* best
= NULL
;
8011 REMOVE_ARCH_BITS (addr
.offset
);
8013 end
= symtab
+ nsyms
;
8019 sym
= beg
+ (end
- beg
) / 2;
8021 value
= sym
->st_value
;
8022 REMOVE_ARCH_BITS (value
);
8024 if (sym
->st_name
!= 0
8025 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
8026 && addr
.offset
>= value
8027 && addr
.offset
- value
< dist
)
8030 dist
= addr
.offset
- value
;
8035 if (addr
.offset
< value
)
8043 *symname
= (best
->st_name
>= strtab_size
8044 ? _("<corrupt>") : strtab
+ best
->st_name
);
8050 *offset
= addr
.offset
;
8053 static /* signed */ int
8054 symcmp (const void *p
, const void *q
)
8056 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
8057 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
8059 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
8062 /* Process the unwind section. */
8064 #include "unwind-ia64.h"
8066 struct ia64_unw_table_entry
8068 struct absaddr start
;
8070 struct absaddr info
;
8073 struct ia64_unw_aux_info
8075 struct ia64_unw_table_entry
* table
; /* Unwind table. */
8076 unsigned long table_len
; /* Length of unwind table. */
8077 unsigned char * info
; /* Unwind info. */
8078 unsigned long info_size
; /* Size of unwind info. */
8079 bfd_vma info_addr
; /* Starting address of unwind info. */
8080 bfd_vma seg_base
; /* Starting address of segment. */
8081 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8082 unsigned long nsyms
; /* Number of symbols. */
8083 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8084 unsigned long nfuns
; /* Number of entries in funtab. */
8085 char * strtab
; /* The string table. */
8086 unsigned long strtab_size
; /* Size of string table. */
8090 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
8092 struct ia64_unw_table_entry
* tp
;
8093 unsigned long j
, nfuns
;
8097 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8098 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8099 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8100 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8102 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8104 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8108 const unsigned char * dp
;
8109 const unsigned char * head
;
8110 const unsigned char * end
;
8111 const char * procname
;
8113 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8114 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
8116 fputs ("\n<", stdout
);
8120 fputs (procname
, stdout
);
8123 printf ("+%lx", (unsigned long) offset
);
8126 fputs (">: [", stdout
);
8127 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8128 fputc ('-', stdout
);
8129 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8130 printf ("], info at +0x%lx\n",
8131 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
8133 /* PR 17531: file: 86232b32. */
8134 if (aux
->info
== NULL
)
8137 offset
= tp
->info
.offset
;
8138 if (tp
->info
.section
)
8140 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
8142 warn (_("Invalid section %u in table entry %ld\n"),
8143 tp
->info
.section
, (long) (tp
- aux
->table
));
8147 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
8149 offset
-= aux
->info_addr
;
8150 /* PR 17531: file: 0997b4d1. */
8151 if (offset
>= aux
->info_size
8152 || aux
->info_size
- offset
< 8)
8154 warn (_("Invalid offset %lx in table entry %ld\n"),
8155 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
8160 head
= aux
->info
+ offset
;
8161 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
8163 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
8164 (unsigned) UNW_VER (stamp
),
8165 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
8166 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
8167 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
8168 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
8170 if (UNW_VER (stamp
) != 1)
8172 printf (_("\tUnknown version.\n"));
8177 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
8178 /* PR 17531: file: 16ceda89. */
8179 if (end
> aux
->info
+ aux
->info_size
)
8180 end
= aux
->info
+ aux
->info_size
;
8181 for (dp
= head
+ 8; dp
< end
;)
8182 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
8191 slurp_ia64_unwind_table (Filedata
* filedata
,
8192 struct ia64_unw_aux_info
* aux
,
8193 Elf_Internal_Shdr
* sec
)
8195 unsigned long size
, nrelas
, i
;
8196 Elf_Internal_Phdr
* seg
;
8197 struct ia64_unw_table_entry
* tep
;
8198 Elf_Internal_Shdr
* relsec
;
8199 Elf_Internal_Rela
* rela
;
8200 Elf_Internal_Rela
* rp
;
8201 unsigned char * table
;
8203 Elf_Internal_Sym
* sym
;
8204 const char * relname
;
8208 /* First, find the starting address of the segment that includes
8211 if (filedata
->file_header
.e_phnum
)
8213 if (! get_program_headers (filedata
))
8216 for (seg
= filedata
->program_headers
;
8217 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8220 if (seg
->p_type
!= PT_LOAD
)
8223 if (sec
->sh_addr
>= seg
->p_vaddr
8224 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8226 aux
->seg_base
= seg
->p_vaddr
;
8232 /* Second, build the unwind table from the contents of the unwind section: */
8233 size
= sec
->sh_size
;
8234 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8239 aux
->table_len
= size
/ (3 * eh_addr_size
);
8240 aux
->table
= (struct ia64_unw_table_entry
*)
8241 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
8244 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
8246 tep
->start
.section
= SHN_UNDEF
;
8247 tep
->end
.section
= SHN_UNDEF
;
8248 tep
->info
.section
= SHN_UNDEF
;
8249 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8250 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8251 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8252 tep
->start
.offset
+= aux
->seg_base
;
8253 tep
->end
.offset
+= aux
->seg_base
;
8254 tep
->info
.offset
+= aux
->seg_base
;
8258 /* Third, apply any relocations to the unwind table: */
8259 for (relsec
= filedata
->section_headers
;
8260 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8263 if (relsec
->sh_type
!= SHT_RELA
8264 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8265 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8268 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8277 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8279 unsigned int sym_ndx
;
8280 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8281 relname
= elf_ia64_reloc_type (r_type
);
8283 /* PR 17531: file: 9fa67536. */
8284 if (relname
== NULL
)
8286 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8290 if (! startswith (relname
, "R_IA64_SEGREL"))
8292 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8296 i
= rp
->r_offset
/ (3 * eh_addr_size
);
8298 /* PR 17531: file: 5bc8d9bf. */
8299 if (i
>= aux
->table_len
)
8301 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8305 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8306 if (sym_ndx
>= aux
->nsyms
)
8308 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8312 sym
= aux
->symtab
+ sym_ndx
;
8314 switch (rp
->r_offset
/ eh_addr_size
% 3)
8317 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8318 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
8321 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8322 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
8325 aux
->table
[i
].info
.section
= sym
->st_shndx
;
8326 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
8340 ia64_process_unwind (Filedata
* filedata
)
8342 Elf_Internal_Shdr
* sec
;
8343 Elf_Internal_Shdr
* unwsec
= NULL
;
8344 unsigned long i
, unwcount
= 0, unwstart
= 0;
8345 struct ia64_unw_aux_info aux
;
8348 memset (& aux
, 0, sizeof (aux
));
8350 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8352 if (sec
->sh_type
== SHT_SYMTAB
)
8356 error (_("Multiple symbol tables encountered\n"));
8362 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8363 &aux
.strtab
, &aux
.strtab_size
))
8366 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8371 printf (_("\nThere are no unwind sections in this file.\n"));
8373 while (unwcount
-- > 0)
8378 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
8379 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8380 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8385 /* We have already counted the number of SHT_IA64_UNWIND
8386 sections so the loop above should never fail. */
8387 assert (unwsec
!= NULL
);
8390 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
8392 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
8394 /* We need to find which section group it is in. */
8395 struct group_list
* g
;
8397 if (filedata
->section_headers_groups
== NULL
8398 || filedata
->section_headers_groups
[i
] == NULL
)
8399 i
= filedata
->file_header
.e_shnum
;
8402 g
= filedata
->section_headers_groups
[i
]->root
;
8404 for (; g
!= NULL
; g
= g
->next
)
8406 sec
= filedata
->section_headers
+ g
->section_index
;
8408 if (SECTION_NAME_VALID (sec
)
8409 && streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
8414 i
= filedata
->file_header
.e_shnum
;
8417 else if (SECTION_NAME_VALID (unwsec
)
8418 && startswith (SECTION_NAME (unwsec
),
8419 ELF_STRING_ia64_unwind_once
))
8421 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
8422 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
8423 suffix
= SECTION_NAME (unwsec
) + len
;
8424 for (i
= 0, sec
= filedata
->section_headers
;
8425 i
< filedata
->file_header
.e_shnum
;
8427 if (SECTION_NAME_VALID (sec
)
8428 && startswith (SECTION_NAME (sec
),
8429 ELF_STRING_ia64_unwind_info_once
)
8430 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8435 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
8436 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
8437 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
8438 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
8440 if (SECTION_NAME_VALID (unwsec
)
8441 && startswith (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
))
8442 suffix
= SECTION_NAME (unwsec
) + len
;
8443 for (i
= 0, sec
= filedata
->section_headers
;
8444 i
< filedata
->file_header
.e_shnum
;
8446 if (SECTION_NAME_VALID (sec
)
8447 && startswith (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
)
8448 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8452 if (i
== filedata
->file_header
.e_shnum
)
8454 printf (_("\nCould not find unwind info section for "));
8456 if (filedata
->string_table
== NULL
)
8457 printf ("%d", unwsec
->sh_name
);
8459 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8463 aux
.info_addr
= sec
->sh_addr
;
8464 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
8467 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
8469 printf (_("\nUnwind section "));
8471 if (filedata
->string_table
== NULL
)
8472 printf ("%d", unwsec
->sh_name
);
8474 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8476 printf (_(" at offset 0x%lx contains %lu entries:\n"),
8477 (unsigned long) unwsec
->sh_offset
,
8478 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
8480 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
8481 && aux
.table_len
> 0)
8482 dump_ia64_unwind (filedata
, & aux
);
8484 free ((char *) aux
.table
);
8485 free ((char *) aux
.info
);
8492 free ((char *) aux
.strtab
);
8497 struct hppa_unw_table_entry
8499 struct absaddr start
;
8501 unsigned int Cannot_unwind
:1; /* 0 */
8502 unsigned int Millicode
:1; /* 1 */
8503 unsigned int Millicode_save_sr0
:1; /* 2 */
8504 unsigned int Region_description
:2; /* 3..4 */
8505 unsigned int reserved1
:1; /* 5 */
8506 unsigned int Entry_SR
:1; /* 6 */
8507 unsigned int Entry_FR
:4; /* Number saved 7..10 */
8508 unsigned int Entry_GR
:5; /* Number saved 11..15 */
8509 unsigned int Args_stored
:1; /* 16 */
8510 unsigned int Variable_Frame
:1; /* 17 */
8511 unsigned int Separate_Package_Body
:1; /* 18 */
8512 unsigned int Frame_Extension_Millicode
:1; /* 19 */
8513 unsigned int Stack_Overflow_Check
:1; /* 20 */
8514 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
8515 unsigned int Ada_Region
:1; /* 22 */
8516 unsigned int cxx_info
:1; /* 23 */
8517 unsigned int cxx_try_catch
:1; /* 24 */
8518 unsigned int sched_entry_seq
:1; /* 25 */
8519 unsigned int reserved2
:1; /* 26 */
8520 unsigned int Save_SP
:1; /* 27 */
8521 unsigned int Save_RP
:1; /* 28 */
8522 unsigned int Save_MRP_in_frame
:1; /* 29 */
8523 unsigned int extn_ptr_defined
:1; /* 30 */
8524 unsigned int Cleanup_defined
:1; /* 31 */
8526 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
8527 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
8528 unsigned int Large_frame
:1; /* 2 */
8529 unsigned int Pseudo_SP_Set
:1; /* 3 */
8530 unsigned int reserved4
:1; /* 4 */
8531 unsigned int Total_frame_size
:27; /* 5..31 */
8534 struct hppa_unw_aux_info
8536 struct hppa_unw_table_entry
* table
; /* Unwind table. */
8537 unsigned long table_len
; /* Length of unwind table. */
8538 bfd_vma seg_base
; /* Starting address of segment. */
8539 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8540 unsigned long nsyms
; /* Number of symbols. */
8541 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8542 unsigned long nfuns
; /* Number of entries in funtab. */
8543 char * strtab
; /* The string table. */
8544 unsigned long strtab_size
; /* Size of string table. */
8548 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8550 struct hppa_unw_table_entry
* tp
;
8551 unsigned long j
, nfuns
;
8554 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8555 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8556 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8557 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8559 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8561 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8564 const char * procname
;
8566 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8567 aux
->strtab_size
, tp
->start
, &procname
,
8570 fputs ("\n<", stdout
);
8574 fputs (procname
, stdout
);
8577 printf ("+%lx", (unsigned long) offset
);
8580 fputs (">: [", stdout
);
8581 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8582 fputc ('-', stdout
);
8583 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8586 #define PF(_m) if (tp->_m) printf (#_m " ");
8587 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8590 PF(Millicode_save_sr0
);
8591 /* PV(Region_description); */
8597 PF(Separate_Package_Body
);
8598 PF(Frame_Extension_Millicode
);
8599 PF(Stack_Overflow_Check
);
8600 PF(Two_Instruction_SP_Increment
);
8604 PF(sched_entry_seq
);
8607 PF(Save_MRP_in_frame
);
8608 PF(extn_ptr_defined
);
8609 PF(Cleanup_defined
);
8610 PF(MPE_XL_interrupt_marker
);
8611 PF(HP_UX_interrupt_marker
);
8614 PV(Total_frame_size
);
8627 slurp_hppa_unwind_table (Filedata
* filedata
,
8628 struct hppa_unw_aux_info
* aux
,
8629 Elf_Internal_Shdr
* sec
)
8631 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8632 Elf_Internal_Phdr
* seg
;
8633 struct hppa_unw_table_entry
* tep
;
8634 Elf_Internal_Shdr
* relsec
;
8635 Elf_Internal_Rela
* rela
;
8636 Elf_Internal_Rela
* rp
;
8637 unsigned char * table
;
8639 Elf_Internal_Sym
* sym
;
8640 const char * relname
;
8642 /* First, find the starting address of the segment that includes
8644 if (filedata
->file_header
.e_phnum
)
8646 if (! get_program_headers (filedata
))
8649 for (seg
= filedata
->program_headers
;
8650 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8653 if (seg
->p_type
!= PT_LOAD
)
8656 if (sec
->sh_addr
>= seg
->p_vaddr
8657 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8659 aux
->seg_base
= seg
->p_vaddr
;
8665 /* Second, build the unwind table from the contents of the unwind
8667 size
= sec
->sh_size
;
8668 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8674 nentries
= size
/ unw_ent_size
;
8675 size
= unw_ent_size
* nentries
;
8677 aux
->table_len
= nentries
;
8678 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8679 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8681 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8683 unsigned int tmp1
, tmp2
;
8685 tep
->start
.section
= SHN_UNDEF
;
8686 tep
->end
.section
= SHN_UNDEF
;
8688 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8689 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8690 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8691 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8693 tep
->start
.offset
+= aux
->seg_base
;
8694 tep
->end
.offset
+= aux
->seg_base
;
8696 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8697 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8698 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8699 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8700 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8701 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8702 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8703 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8704 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8705 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8706 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8707 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8708 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8709 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8710 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8711 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8712 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8713 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8714 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8715 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8716 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8717 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8718 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8719 tep
->Cleanup_defined
= tmp1
& 0x1;
8721 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8722 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8723 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8724 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8725 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8726 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8730 /* Third, apply any relocations to the unwind table. */
8731 for (relsec
= filedata
->section_headers
;
8732 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8735 if (relsec
->sh_type
!= SHT_RELA
8736 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8737 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8740 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8744 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8746 unsigned int sym_ndx
;
8747 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8748 relname
= elf_hppa_reloc_type (r_type
);
8750 if (relname
== NULL
)
8752 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8756 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8757 if (! startswith (relname
, "R_PARISC_SEGREL"))
8759 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8763 i
= rp
->r_offset
/ unw_ent_size
;
8764 if (i
>= aux
->table_len
)
8766 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8770 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8771 if (sym_ndx
>= aux
->nsyms
)
8773 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8777 sym
= aux
->symtab
+ sym_ndx
;
8779 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8782 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8783 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8786 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8787 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8801 hppa_process_unwind (Filedata
* filedata
)
8803 struct hppa_unw_aux_info aux
;
8804 Elf_Internal_Shdr
* unwsec
= NULL
;
8805 Elf_Internal_Shdr
* sec
;
8809 if (filedata
->string_table
== NULL
)
8812 memset (& aux
, 0, sizeof (aux
));
8814 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8816 if (sec
->sh_type
== SHT_SYMTAB
)
8820 error (_("Multiple symbol tables encountered\n"));
8826 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8827 &aux
.strtab
, &aux
.strtab_size
))
8830 else if (SECTION_NAME_VALID (sec
)
8831 && streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8836 printf (_("\nThere are no unwind sections in this file.\n"));
8838 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8840 if (SECTION_NAME_VALID (sec
)
8841 && streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8843 unsigned long num_unwind
= sec
->sh_size
/ 16;
8845 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8846 "contains %lu entry:\n",
8847 "\nUnwind section '%s' at offset 0x%lx "
8848 "contains %lu entries:\n",
8850 printable_section_name (filedata
, sec
),
8851 (unsigned long) sec
->sh_offset
,
8854 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8857 if (res
&& aux
.table_len
> 0)
8859 if (! dump_hppa_unwind (filedata
, &aux
))
8863 free ((char *) aux
.table
);
8869 free ((char *) aux
.strtab
);
8876 unsigned char * data
; /* The unwind data. */
8877 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8878 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8879 unsigned long nrelas
; /* The number of relocations. */
8880 unsigned int rel_type
; /* REL or RELA ? */
8881 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8884 struct arm_unw_aux_info
8886 Filedata
* filedata
; /* The file containing the unwind sections. */
8887 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8888 unsigned long nsyms
; /* Number of symbols. */
8889 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8890 unsigned long nfuns
; /* Number of these symbols. */
8891 char * strtab
; /* The file's string table. */
8892 unsigned long strtab_size
; /* Size of string table. */
8896 arm_print_vma_and_name (Filedata
* filedata
,
8897 struct arm_unw_aux_info
* aux
,
8899 struct absaddr addr
)
8901 const char *procname
;
8904 if (addr
.section
== SHN_UNDEF
)
8907 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8908 aux
->strtab_size
, addr
, &procname
,
8911 print_vma (fn
, PREFIX_HEX
);
8915 fputs (" <", stdout
);
8916 fputs (procname
, stdout
);
8919 printf ("+0x%lx", (unsigned long) sym_offset
);
8920 fputc ('>', stdout
);
8927 arm_free_section (struct arm_section
*arm_sec
)
8929 free (arm_sec
->data
);
8930 free (arm_sec
->rela
);
8933 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8934 cached section and install SEC instead.
8935 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8936 and return its valued in * WORDP, relocating if necessary.
8937 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8938 relocation's offset in ADDR.
8939 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8940 into the string table of the symbol associated with the reloc. If no
8941 reloc was applied store -1 there.
8942 5) Return TRUE upon success, FALSE otherwise. */
8945 get_unwind_section_word (Filedata
* filedata
,
8946 struct arm_unw_aux_info
* aux
,
8947 struct arm_section
* arm_sec
,
8948 Elf_Internal_Shdr
* sec
,
8949 bfd_vma word_offset
,
8950 unsigned int * wordp
,
8951 struct absaddr
* addr
,
8954 Elf_Internal_Rela
*rp
;
8955 Elf_Internal_Sym
*sym
;
8956 const char * relname
;
8960 if (sec
== NULL
|| arm_sec
== NULL
)
8963 addr
->section
= SHN_UNDEF
;
8966 if (sym_name
!= NULL
)
8967 *sym_name
= (bfd_vma
) -1;
8969 /* If necessary, update the section cache. */
8970 if (sec
!= arm_sec
->sec
)
8972 Elf_Internal_Shdr
*relsec
;
8974 arm_free_section (arm_sec
);
8977 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8978 sec
->sh_size
, _("unwind data"));
8979 arm_sec
->rela
= NULL
;
8980 arm_sec
->nrelas
= 0;
8982 for (relsec
= filedata
->section_headers
;
8983 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8986 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8987 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8988 /* PR 15745: Check the section type as well. */
8989 || (relsec
->sh_type
!= SHT_REL
8990 && relsec
->sh_type
!= SHT_RELA
))
8993 arm_sec
->rel_type
= relsec
->sh_type
;
8994 if (relsec
->sh_type
== SHT_REL
)
8996 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8998 & arm_sec
->rela
, & arm_sec
->nrelas
))
9001 else /* relsec->sh_type == SHT_RELA */
9003 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
9005 & arm_sec
->rela
, & arm_sec
->nrelas
))
9011 arm_sec
->next_rela
= arm_sec
->rela
;
9014 /* If there is no unwind data we can do nothing. */
9015 if (arm_sec
->data
== NULL
)
9018 /* If the offset is invalid then fail. */
9019 if (/* PR 21343 *//* PR 18879 */
9021 || word_offset
> (sec
->sh_size
- 4)
9022 || ((bfd_signed_vma
) word_offset
) < 0)
9025 /* Get the word at the required offset. */
9026 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
9028 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
9029 if (arm_sec
->rela
== NULL
)
9035 /* Look through the relocs to find the one that applies to the provided offset. */
9037 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
9039 bfd_vma prelval
, offset
;
9041 if (rp
->r_offset
> word_offset
&& !wrapped
)
9046 if (rp
->r_offset
> word_offset
)
9049 if (rp
->r_offset
& 3)
9051 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
9052 (unsigned long) rp
->r_offset
);
9056 if (rp
->r_offset
< word_offset
)
9059 /* PR 17531: file: 027-161405-0.004 */
9060 if (aux
->symtab
== NULL
)
9063 if (arm_sec
->rel_type
== SHT_REL
)
9065 offset
= word
& 0x7fffffff;
9066 if (offset
& 0x40000000)
9067 offset
|= ~ (bfd_vma
) 0x7fffffff;
9069 else if (arm_sec
->rel_type
== SHT_RELA
)
9070 offset
= rp
->r_addend
;
9073 error (_("Unknown section relocation type %d encountered\n"),
9078 /* PR 17531 file: 027-1241568-0.004. */
9079 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
9081 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
9082 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
9086 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
9087 offset
+= sym
->st_value
;
9088 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
9090 /* Check that we are processing the expected reloc type. */
9091 if (filedata
->file_header
.e_machine
== EM_ARM
)
9093 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
9094 if (relname
== NULL
)
9096 warn (_("Skipping unknown ARM relocation type: %d\n"),
9097 (int) ELF32_R_TYPE (rp
->r_info
));
9101 if (streq (relname
, "R_ARM_NONE"))
9104 if (! streq (relname
, "R_ARM_PREL31"))
9106 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
9110 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9112 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
9113 if (relname
== NULL
)
9115 warn (_("Skipping unknown C6000 relocation type: %d\n"),
9116 (int) ELF32_R_TYPE (rp
->r_info
));
9120 if (streq (relname
, "R_C6000_NONE"))
9123 if (! streq (relname
, "R_C6000_PREL31"))
9125 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
9133 /* This function currently only supports ARM and TI unwinders. */
9134 warn (_("Only TI and ARM unwinders are currently supported\n"));
9138 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
9139 addr
->section
= sym
->st_shndx
;
9140 addr
->offset
= offset
;
9143 * sym_name
= sym
->st_name
;
9148 arm_sec
->next_rela
= rp
;
9153 static const char *tic6x_unwind_regnames
[16] =
9155 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
9156 "A14", "A13", "A12", "A11", "A10",
9157 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
9161 decode_tic6x_unwind_regmask (unsigned int mask
)
9165 for (i
= 12; mask
; mask
>>= 1, i
--)
9169 fputs (tic6x_unwind_regnames
[i
], stdout
);
9171 fputs (", ", stdout
);
9177 if (remaining == 0 && more_words) \
9180 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
9181 data_offset, & word, & addr, NULL)) \
9187 #define GET_OP(OP) \
9192 (OP) = word >> 24; \
9197 printf (_("[Truncated opcode]\n")); \
9200 printf ("0x%02x ", OP)
9203 decode_arm_unwind_bytecode (Filedata
* filedata
,
9204 struct arm_unw_aux_info
* aux
,
9206 unsigned int remaining
,
9207 unsigned int more_words
,
9208 bfd_vma data_offset
,
9209 Elf_Internal_Shdr
* data_sec
,
9210 struct arm_section
* data_arm_sec
)
9212 struct absaddr addr
;
9215 /* Decode the unwinding instructions. */
9218 unsigned int op
, op2
;
9227 printf (" 0x%02x ", op
);
9229 if ((op
& 0xc0) == 0x00)
9231 int offset
= ((op
& 0x3f) << 2) + 4;
9233 printf (" vsp = vsp + %d", offset
);
9235 else if ((op
& 0xc0) == 0x40)
9237 int offset
= ((op
& 0x3f) << 2) + 4;
9239 printf (" vsp = vsp - %d", offset
);
9241 else if ((op
& 0xf0) == 0x80)
9244 if (op
== 0x80 && op2
== 0)
9245 printf (_("Refuse to unwind"));
9248 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
9253 for (i
= 0; i
< 12; i
++)
9254 if (mask
& (1 << i
))
9260 printf ("r%d", 4 + i
);
9265 else if ((op
& 0xf0) == 0x90)
9267 if (op
== 0x9d || op
== 0x9f)
9268 printf (_(" [Reserved]"));
9270 printf (" vsp = r%d", op
& 0x0f);
9272 else if ((op
& 0xf0) == 0xa0)
9274 int end
= 4 + (op
& 0x07);
9279 for (i
= 4; i
<= end
; i
++)
9295 else if (op
== 0xb0)
9296 printf (_(" finish"));
9297 else if (op
== 0xb1)
9300 if (op2
== 0 || (op2
& 0xf0) != 0)
9301 printf (_("[Spare]"));
9304 unsigned int mask
= op2
& 0x0f;
9309 for (i
= 0; i
< 12; i
++)
9310 if (mask
& (1 << i
))
9321 else if (op
== 0xb2)
9323 unsigned char buf
[9];
9324 unsigned int i
, len
;
9325 unsigned long offset
;
9327 for (i
= 0; i
< sizeof (buf
); i
++)
9330 if ((buf
[i
] & 0x80) == 0)
9333 if (i
== sizeof (buf
))
9335 error (_("corrupt change to vsp\n"));
9340 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
9341 assert (len
== i
+ 1);
9342 offset
= offset
* 4 + 0x204;
9343 printf ("vsp = vsp + %ld", offset
);
9346 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
9348 unsigned int first
, last
;
9355 printf ("pop {D%d", first
);
9357 printf ("-D%d", first
+ last
);
9360 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
9362 unsigned int count
= op
& 0x07;
9366 printf ("-D%d", 8 + count
);
9369 else if (op
>= 0xc0 && op
<= 0xc5)
9371 unsigned int count
= op
& 0x07;
9373 printf (" pop {wR10");
9375 printf ("-wR%d", 10 + count
);
9378 else if (op
== 0xc6)
9380 unsigned int first
, last
;
9385 printf ("pop {wR%d", first
);
9387 printf ("-wR%d", first
+ last
);
9390 else if (op
== 0xc7)
9393 if (op2
== 0 || (op2
& 0xf0) != 0)
9394 printf (_("[Spare]"));
9397 unsigned int mask
= op2
& 0x0f;
9402 for (i
= 0; i
< 4; i
++)
9403 if (mask
& (1 << i
))
9409 printf ("wCGR%d", i
);
9416 printf (_(" [unsupported opcode]"));
9427 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
9428 struct arm_unw_aux_info
* aux
,
9430 unsigned int remaining
,
9431 unsigned int more_words
,
9432 bfd_vma data_offset
,
9433 Elf_Internal_Shdr
* data_sec
,
9434 struct arm_section
* data_arm_sec
)
9436 struct absaddr addr
;
9438 /* Decode the unwinding instructions. */
9441 unsigned int op
, op2
;
9450 printf (" 0x%02x ", op
);
9452 if ((op
& 0xc0) == 0x00)
9454 int offset
= ((op
& 0x3f) << 3) + 8;
9455 printf (" sp = sp + %d", offset
);
9457 else if ((op
& 0xc0) == 0x80)
9460 if (op
== 0x80 && op2
== 0)
9461 printf (_("Refuse to unwind"));
9464 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
9466 printf ("pop compact {");
9470 decode_tic6x_unwind_regmask (mask
);
9474 else if ((op
& 0xf0) == 0xc0)
9482 unsigned int offset
;
9486 /* Scan entire instruction first so that GET_OP output is not
9487 interleaved with disassembly. */
9489 for (i
= 0; nregs
< (op
& 0xf); i
++)
9495 regpos
[nregs
].offset
= i
* 2;
9496 regpos
[nregs
].reg
= reg
;
9503 regpos
[nregs
].offset
= i
* 2 + 1;
9504 regpos
[nregs
].reg
= reg
;
9509 printf (_("pop frame {"));
9512 printf (_("*corrupt* - no registers specified"));
9517 for (i
= i
* 2; i
> 0; i
--)
9519 if (regpos
[reg
].offset
== i
- 1)
9521 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
9528 fputs (name
, stdout
);
9536 else if (op
== 0xd0)
9537 printf (" MOV FP, SP");
9538 else if (op
== 0xd1)
9539 printf (" __c6xabi_pop_rts");
9540 else if (op
== 0xd2)
9542 unsigned char buf
[9];
9543 unsigned int i
, len
;
9544 unsigned long offset
;
9546 for (i
= 0; i
< sizeof (buf
); i
++)
9549 if ((buf
[i
] & 0x80) == 0)
9552 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9553 if (i
== sizeof (buf
))
9555 warn (_("Corrupt stack pointer adjustment detected\n"));
9559 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
9560 assert (len
== i
+ 1);
9561 offset
= offset
* 8 + 0x408;
9562 printf (_("sp = sp + %ld"), offset
);
9564 else if ((op
& 0xf0) == 0xe0)
9566 if ((op
& 0x0f) == 7)
9569 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9573 printf (_(" [unsupported opcode]"));
9582 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9586 offset
= word
& 0x7fffffff;
9587 if (offset
& 0x40000000)
9588 offset
|= ~ (bfd_vma
) 0x7fffffff;
9590 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9593 return offset
+ where
;
9597 decode_arm_unwind (Filedata
* filedata
,
9598 struct arm_unw_aux_info
* aux
,
9600 unsigned int remaining
,
9601 bfd_vma data_offset
,
9602 Elf_Internal_Shdr
* data_sec
,
9603 struct arm_section
* data_arm_sec
)
9606 unsigned int more_words
= 0;
9607 struct absaddr addr
;
9608 bfd_vma sym_name
= (bfd_vma
) -1;
9613 /* Fetch the first word.
9614 Note - when decoding an object file the address extracted
9615 here will always be 0. So we also pass in the sym_name
9616 parameter so that we can find the symbol associated with
9617 the personality routine. */
9618 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9619 & word
, & addr
, & sym_name
))
9626 addr
.section
= SHN_UNDEF
;
9630 if ((word
& 0x80000000) == 0)
9632 /* Expand prel31 for personality routine. */
9634 const char *procname
;
9636 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9637 printf (_(" Personality routine: "));
9639 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9640 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9642 procname
= aux
->strtab
+ sym_name
;
9643 print_vma (fn
, PREFIX_HEX
);
9646 fputs (" <", stdout
);
9647 fputs (procname
, stdout
);
9648 fputc ('>', stdout
);
9652 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9653 fputc ('\n', stdout
);
9655 /* The GCC personality routines use the standard compact
9656 encoding, starting with one byte giving the number of
9658 if (procname
!= NULL
9659 && (startswith (procname
, "__gcc_personality_v0")
9660 || startswith (procname
, "__gxx_personality_v0")
9661 || startswith (procname
, "__gcj_personality_v0")
9662 || startswith (procname
, "__gnu_objc_personality_v0")))
9669 printf (_(" [Truncated data]\n"));
9672 more_words
= word
>> 24;
9682 /* ARM EHABI Section 6.3:
9684 An exception-handling table entry for the compact model looks like:
9688 1 0 index Data for personalityRoutine[index] */
9690 if (filedata
->file_header
.e_machine
== EM_ARM
9691 && (word
& 0x70000000))
9693 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9697 per_index
= (word
>> 24) & 0x7f;
9698 printf (_(" Compact model index: %d\n"), per_index
);
9705 else if (per_index
< 3)
9707 more_words
= (word
>> 16) & 0xff;
9713 switch (filedata
->file_header
.e_machine
)
9718 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9719 data_offset
, data_sec
, data_arm_sec
))
9724 warn (_("Unknown ARM compact model index encountered\n"));
9725 printf (_(" [reserved]\n"));
9733 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9734 data_offset
, data_sec
, data_arm_sec
))
9737 else if (per_index
< 5)
9739 if (((word
>> 17) & 0x7f) == 0x7f)
9740 printf (_(" Restore stack from frame pointer\n"));
9742 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9743 printf (_(" Registers restored: "));
9745 printf (" (compact) ");
9746 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9748 printf (_(" Return register: %s\n"),
9749 tic6x_unwind_regnames
[word
& 0xf]);
9752 printf (_(" [reserved (%d)]\n"), per_index
);
9756 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9757 filedata
->file_header
.e_machine
);
9761 /* Decode the descriptors. Not implemented. */
9767 dump_arm_unwind (Filedata
* filedata
,
9768 struct arm_unw_aux_info
* aux
,
9769 Elf_Internal_Shdr
* exidx_sec
)
9771 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9772 unsigned int i
, exidx_len
;
9773 unsigned long j
, nfuns
;
9776 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9777 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9778 exidx_len
= exidx_sec
->sh_size
/ 8;
9780 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9781 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9782 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9783 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9785 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9787 for (i
= 0; i
< exidx_len
; i
++)
9789 unsigned int exidx_fn
, exidx_entry
;
9790 struct absaddr fn_addr
, entry_addr
;
9793 fputc ('\n', stdout
);
9795 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9796 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9797 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9798 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9801 arm_free_section (& exidx_arm_sec
);
9802 arm_free_section (& extab_arm_sec
);
9806 /* ARM EHABI, Section 5:
9807 An index table entry consists of 2 words.
9808 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9809 if (exidx_fn
& 0x80000000)
9811 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9815 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9817 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9818 fputs (": ", stdout
);
9820 if (exidx_entry
== 1)
9822 print_vma (exidx_entry
, PREFIX_HEX
);
9823 fputs (" [cantunwind]\n", stdout
);
9825 else if (exidx_entry
& 0x80000000)
9827 print_vma (exidx_entry
, PREFIX_HEX
);
9828 fputc ('\n', stdout
);
9829 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9833 bfd_vma table
, table_offset
= 0;
9834 Elf_Internal_Shdr
*table_sec
;
9836 fputs ("@", stdout
);
9837 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9838 print_vma (table
, PREFIX_HEX
);
9841 /* Locate the matching .ARM.extab. */
9842 if (entry_addr
.section
!= SHN_UNDEF
9843 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9845 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9846 table_offset
= entry_addr
.offset
;
9848 if (table_offset
> table_sec
->sh_size
9849 || ((bfd_signed_vma
) table_offset
) < 0)
9851 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9852 (unsigned long) table_offset
,
9853 printable_section_name (filedata
, table_sec
));
9860 table_sec
= find_section_by_address (filedata
, table
);
9861 if (table_sec
!= NULL
)
9862 table_offset
= table
- table_sec
->sh_addr
;
9865 if (table_sec
== NULL
)
9867 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9868 (unsigned long) table
);
9873 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9882 arm_free_section (&exidx_arm_sec
);
9883 arm_free_section (&extab_arm_sec
);
9888 /* Used for both ARM and C6X unwinding tables. */
9891 arm_process_unwind (Filedata
* filedata
)
9893 struct arm_unw_aux_info aux
;
9894 Elf_Internal_Shdr
*unwsec
= NULL
;
9895 Elf_Internal_Shdr
*sec
;
9897 unsigned int sec_type
;
9900 switch (filedata
->file_header
.e_machine
)
9903 sec_type
= SHT_ARM_EXIDX
;
9907 sec_type
= SHT_C6000_UNWIND
;
9911 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9912 filedata
->file_header
.e_machine
);
9916 if (filedata
->string_table
== NULL
)
9919 memset (& aux
, 0, sizeof (aux
));
9920 aux
.filedata
= filedata
;
9922 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9924 if (sec
->sh_type
== SHT_SYMTAB
)
9928 error (_("Multiple symbol tables encountered\n"));
9934 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9935 &aux
.strtab
, &aux
.strtab_size
))
9938 else if (sec
->sh_type
== sec_type
)
9943 printf (_("\nThere are no unwind sections in this file.\n"));
9945 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9947 if (sec
->sh_type
== sec_type
)
9949 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9950 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9951 "contains %lu entry:\n",
9952 "\nUnwind section '%s' at offset 0x%lx "
9953 "contains %lu entries:\n",
9955 printable_section_name (filedata
, sec
),
9956 (unsigned long) sec
->sh_offset
,
9959 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9965 free ((char *) aux
.strtab
);
9971 no_processor_specific_unwind (Filedata
* filedata ATTRIBUTE_UNUSED
)
9973 printf (_("No processor specific unwind information to decode\n"));
9978 process_unwind (Filedata
* filedata
)
9980 struct unwind_handler
9982 unsigned int machtype
;
9983 bool (* handler
)(Filedata
*);
9986 { EM_ARM
, arm_process_unwind
},
9987 { EM_IA_64
, ia64_process_unwind
},
9988 { EM_PARISC
, hppa_process_unwind
},
9989 { EM_TI_C6000
, arm_process_unwind
},
9990 { EM_386
, no_processor_specific_unwind
},
9991 { EM_X86_64
, no_processor_specific_unwind
},
9999 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
10000 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
10001 return handlers
[i
].handler (filedata
);
10003 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
10004 get_machine_name (filedata
->file_header
.e_machine
));
10009 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
10011 switch (entry
->d_tag
)
10013 case DT_AARCH64_BTI_PLT
:
10014 case DT_AARCH64_PAC_PLT
:
10017 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10024 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
10026 switch (entry
->d_tag
)
10028 case DT_MIPS_FLAGS
:
10029 if (entry
->d_un
.d_val
== 0)
10030 printf (_("NONE"));
10033 static const char * opts
[] =
10035 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
10036 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
10037 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
10038 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
10044 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
10045 if (entry
->d_un
.d_val
& (1 << cnt
))
10047 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
10053 case DT_MIPS_IVERSION
:
10054 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10055 printf (_("Interface Version: %s"),
10056 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
10060 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
10061 /* Note: coded this way so that there is a single string for translation. */
10062 printf (_("<corrupt: %s>"), buf
);
10066 case DT_MIPS_TIME_STAMP
:
10070 time_t atime
= entry
->d_un
.d_val
;
10072 tmp
= gmtime (&atime
);
10073 /* PR 17531: file: 6accc532. */
10075 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
10077 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
10078 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10079 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10080 printf (_("Time Stamp: %s"), timebuf
);
10084 case DT_MIPS_RLD_VERSION
:
10085 case DT_MIPS_LOCAL_GOTNO
:
10086 case DT_MIPS_CONFLICTNO
:
10087 case DT_MIPS_LIBLISTNO
:
10088 case DT_MIPS_SYMTABNO
:
10089 case DT_MIPS_UNREFEXTNO
:
10090 case DT_MIPS_HIPAGENO
:
10091 case DT_MIPS_DELTA_CLASS_NO
:
10092 case DT_MIPS_DELTA_INSTANCE_NO
:
10093 case DT_MIPS_DELTA_RELOC_NO
:
10094 case DT_MIPS_DELTA_SYM_NO
:
10095 case DT_MIPS_DELTA_CLASSSYM_NO
:
10096 case DT_MIPS_COMPACT_SIZE
:
10097 print_vma (entry
->d_un
.d_val
, DEC
);
10100 case DT_MIPS_XHASH
:
10101 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10102 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10103 /* Falls through. */
10106 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10112 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
10114 switch (entry
->d_tag
)
10116 case DT_HP_DLD_FLAGS
:
10125 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
10126 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
10127 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
10128 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
10129 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
10130 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
10131 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
10132 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
10133 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
10134 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
10135 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
10136 { DT_HP_GST
, "HP_GST" },
10137 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
10138 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
10139 { DT_HP_NODELETE
, "HP_NODELETE" },
10140 { DT_HP_GROUP
, "HP_GROUP" },
10141 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
10145 bfd_vma val
= entry
->d_un
.d_val
;
10147 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
10148 if (val
& flags
[cnt
].bit
)
10152 fputs (flags
[cnt
].str
, stdout
);
10154 val
^= flags
[cnt
].bit
;
10157 if (val
!= 0 || first
)
10161 print_vma (val
, HEX
);
10167 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10175 /* VMS vs Unix time offset and factor. */
10177 #define VMS_EPOCH_OFFSET 35067168000000000LL
10178 #define VMS_GRANULARITY_FACTOR 10000000
10180 #define INT64_MIN (-9223372036854775807LL - 1)
10183 /* Display a VMS time in a human readable format. */
10186 print_vms_time (bfd_int64_t vmstime
)
10188 struct tm
*tm
= NULL
;
10191 if (vmstime
>= INT64_MIN
+ VMS_EPOCH_OFFSET
)
10193 vmstime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
10195 if (unxtime
== vmstime
)
10196 tm
= gmtime (&unxtime
);
10199 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
10200 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
10201 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
10206 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
10208 switch (entry
->d_tag
)
10210 case DT_IA_64_PLT_RESERVE
:
10211 /* First 3 slots reserved. */
10212 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10214 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
10217 case DT_IA_64_VMS_LINKTIME
:
10219 print_vms_time (entry
->d_un
.d_val
);
10223 case DT_IA_64_VMS_LNKFLAGS
:
10224 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10225 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
10226 printf (" CALL_DEBUG");
10227 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
10228 printf (" NOP0BUFS");
10229 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
10230 printf (" P0IMAGE");
10231 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
10232 printf (" MKTHREADS");
10233 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
10234 printf (" UPCALLS");
10235 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
10236 printf (" IMGSTA");
10237 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
10238 printf (" INITIALIZE");
10239 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
10241 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
10242 printf (" EXE_INIT");
10243 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
10244 printf (" TBK_IN_IMG");
10245 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
10246 printf (" DBG_IN_IMG");
10247 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
10248 printf (" TBK_IN_DSF");
10249 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
10250 printf (" DBG_IN_DSF");
10251 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
10252 printf (" SIGNATURES");
10253 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
10254 printf (" REL_SEG_OFF");
10258 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10265 get_32bit_dynamic_section (Filedata
* filedata
)
10267 Elf32_External_Dyn
* edyn
;
10268 Elf32_External_Dyn
* ext
;
10269 Elf_Internal_Dyn
* entry
;
10271 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
10272 filedata
->dynamic_addr
, 1,
10273 filedata
->dynamic_size
,
10274 _("dynamic section"));
10278 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
10279 might not have the luxury of section headers. Look for the DT_NULL
10280 terminator to determine the number of entries. */
10281 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
10282 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
10285 filedata
->dynamic_nent
++;
10286 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
10290 filedata
->dynamic_section
10291 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
10292 if (filedata
->dynamic_section
== NULL
)
10294 error (_("Out of memory allocating space for %lu dynamic entries\n"),
10295 (unsigned long) filedata
->dynamic_nent
);
10300 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10301 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10304 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10305 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10314 get_64bit_dynamic_section (Filedata
* filedata
)
10316 Elf64_External_Dyn
* edyn
;
10317 Elf64_External_Dyn
* ext
;
10318 Elf_Internal_Dyn
* entry
;
10320 /* Read in the data. */
10321 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
10322 filedata
->dynamic_addr
, 1,
10323 filedata
->dynamic_size
,
10324 _("dynamic section"));
10328 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
10329 might not have the luxury of section headers. Look for the DT_NULL
10330 terminator to determine the number of entries. */
10331 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
10332 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
10333 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
10336 filedata
->dynamic_nent
++;
10337 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
10341 filedata
->dynamic_section
10342 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
10343 if (filedata
->dynamic_section
== NULL
)
10345 error (_("Out of memory allocating space for %lu dynamic entries\n"),
10346 (unsigned long) filedata
->dynamic_nent
);
10351 /* Convert from external to internal formats. */
10352 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10353 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10356 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10357 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10366 get_dynamic_section (Filedata
*filedata
)
10368 if (filedata
->dynamic_section
)
10372 return get_32bit_dynamic_section (filedata
);
10374 return get_64bit_dynamic_section (filedata
);
10378 print_dynamic_flags (bfd_vma flags
)
10386 flag
= flags
& - flags
;
10392 putc (' ', stdout
);
10396 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
10397 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
10398 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
10399 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
10400 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
10401 default: fputs (_("unknown"), stdout
); break;
10408 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
10410 unsigned char * e_data
;
10413 /* If the size_t type is smaller than the bfd_size_type, eg because
10414 you are building a 32-bit tool on a 64-bit host, then make sure
10415 that when (number) is cast to (size_t) no information is lost. */
10416 if (sizeof (size_t) < sizeof (bfd_size_type
)
10417 && (bfd_size_type
) ((size_t) number
) != number
)
10419 error (_("Size truncation prevents reading %s elements of size %u\n"),
10420 bfd_vmatoa ("u", number
), ent_size
);
10424 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
10425 attempting to allocate memory when the read is bound to fail. */
10426 if (ent_size
* number
> filedata
->file_size
)
10428 error (_("Invalid number of dynamic entries: %s\n"),
10429 bfd_vmatoa ("u", number
));
10433 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10434 if (e_data
== NULL
)
10436 error (_("Out of memory reading %s dynamic entries\n"),
10437 bfd_vmatoa ("u", number
));
10441 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
10443 error (_("Unable to read in %s bytes of dynamic data\n"),
10444 bfd_vmatoa ("u", number
* ent_size
));
10449 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10450 if (i_data
== NULL
)
10452 error (_("Out of memory allocating space for %s dynamic entries\n"),
10453 bfd_vmatoa ("u", number
));
10459 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10466 static unsigned long
10467 get_num_dynamic_syms (Filedata
* filedata
)
10469 unsigned long num_of_syms
= 0;
10471 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
10472 return num_of_syms
;
10474 if (filedata
->dynamic_info
[DT_HASH
])
10476 unsigned char nb
[8];
10477 unsigned char nc
[8];
10478 unsigned int hash_ent_size
= 4;
10480 if ((filedata
->file_header
.e_machine
== EM_ALPHA
10481 || filedata
->file_header
.e_machine
== EM_S390
10482 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
10483 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10486 if (fseek (filedata
->handle
,
10487 (filedata
->archive_file_offset
10488 + offset_from_vma (filedata
, filedata
->dynamic_info
[DT_HASH
],
10489 sizeof nb
+ sizeof nc
)),
10492 error (_("Unable to seek to start of dynamic information\n"));
10496 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
10498 error (_("Failed to read in number of buckets\n"));
10502 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
10504 error (_("Failed to read in number of chains\n"));
10508 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
10509 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
10511 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
10513 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
10515 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
10518 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
10519 num_of_syms
= filedata
->nchains
;
10522 if (num_of_syms
== 0)
10524 free (filedata
->buckets
);
10525 filedata
->buckets
= NULL
;
10526 free (filedata
->chains
);
10527 filedata
->chains
= NULL
;
10528 filedata
->nbuckets
= 0;
10532 if (filedata
->dynamic_info_DT_GNU_HASH
)
10534 unsigned char nb
[16];
10535 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10536 bfd_vma buckets_vma
;
10539 if (fseek (filedata
->handle
,
10540 (filedata
->archive_file_offset
10541 + offset_from_vma (filedata
,
10542 filedata
->dynamic_info_DT_GNU_HASH
,
10546 error (_("Unable to seek to start of dynamic information\n"));
10550 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
10552 error (_("Failed to read in number of buckets\n"));
10556 filedata
->ngnubuckets
= byte_get (nb
, 4);
10557 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
10558 bitmaskwords
= byte_get (nb
+ 8, 4);
10559 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
10561 buckets_vma
+= bitmaskwords
* 4;
10563 buckets_vma
+= bitmaskwords
* 8;
10565 if (fseek (filedata
->handle
,
10566 (filedata
->archive_file_offset
10567 + offset_from_vma (filedata
, buckets_vma
, 4)),
10570 error (_("Unable to seek to start of dynamic information\n"));
10574 filedata
->gnubuckets
10575 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
10577 if (filedata
->gnubuckets
== NULL
)
10580 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
10581 if (filedata
->gnubuckets
[i
] != 0)
10583 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
10586 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
10587 maxchain
= filedata
->gnubuckets
[i
];
10590 if (maxchain
== 0xffffffff)
10593 maxchain
-= filedata
->gnusymidx
;
10595 if (fseek (filedata
->handle
,
10596 (filedata
->archive_file_offset
10597 + offset_from_vma (filedata
,
10598 buckets_vma
+ 4 * (filedata
->ngnubuckets
10603 error (_("Unable to seek to start of dynamic information\n"));
10609 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
10611 error (_("Failed to determine last chain length\n"));
10615 if (maxchain
+ 1 == 0)
10620 while ((byte_get (nb
, 4) & 1) == 0);
10622 if (fseek (filedata
->handle
,
10623 (filedata
->archive_file_offset
10624 + offset_from_vma (filedata
, (buckets_vma
10625 + 4 * filedata
->ngnubuckets
),
10629 error (_("Unable to seek to start of dynamic information\n"));
10633 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
10634 filedata
->ngnuchains
= maxchain
;
10636 if (filedata
->gnuchains
== NULL
)
10639 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10641 if (fseek (filedata
->handle
,
10642 (filedata
->archive_file_offset
10643 + offset_from_vma (filedata
, (buckets_vma
10644 + 4 * (filedata
->ngnubuckets
10648 error (_("Unable to seek to start of dynamic information\n"));
10652 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
10653 if (filedata
->mipsxlat
== NULL
)
10657 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
10658 if (filedata
->gnubuckets
[hn
] != 0)
10660 bfd_vma si
= filedata
->gnubuckets
[hn
];
10661 bfd_vma off
= si
- filedata
->gnusymidx
;
10665 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10667 if (off
< filedata
->ngnuchains
10668 && filedata
->mipsxlat
[off
] >= num_of_syms
)
10669 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
10673 if (si
>= num_of_syms
)
10674 num_of_syms
= si
+ 1;
10678 while (off
< filedata
->ngnuchains
10679 && (filedata
->gnuchains
[off
++] & 1) == 0);
10682 if (num_of_syms
== 0)
10685 free (filedata
->mipsxlat
);
10686 filedata
->mipsxlat
= NULL
;
10687 free (filedata
->gnuchains
);
10688 filedata
->gnuchains
= NULL
;
10689 free (filedata
->gnubuckets
);
10690 filedata
->gnubuckets
= NULL
;
10691 filedata
->ngnubuckets
= 0;
10692 filedata
->ngnuchains
= 0;
10696 return num_of_syms
;
10699 /* Parse and display the contents of the dynamic section. */
10702 process_dynamic_section (Filedata
* filedata
)
10704 Elf_Internal_Dyn
* entry
;
10706 if (filedata
->dynamic_size
<= 1)
10710 if (filedata
->is_separate
)
10711 printf (_("\nThere is no dynamic section in linked file '%s'.\n"),
10712 filedata
->file_name
);
10714 printf (_("\nThere is no dynamic section in this file.\n"));
10720 if (!get_dynamic_section (filedata
))
10723 /* Find the appropriate symbol table. */
10724 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
10726 unsigned long num_of_syms
;
10728 for (entry
= filedata
->dynamic_section
;
10729 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10731 if (entry
->d_tag
== DT_SYMTAB
)
10732 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
10733 else if (entry
->d_tag
== DT_SYMENT
)
10734 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
10735 else if (entry
->d_tag
== DT_HASH
)
10736 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
10737 else if (entry
->d_tag
== DT_GNU_HASH
)
10738 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10739 else if ((filedata
->file_header
.e_machine
== EM_MIPS
10740 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
10741 && entry
->d_tag
== DT_MIPS_XHASH
)
10743 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10744 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10747 num_of_syms
= get_num_dynamic_syms (filedata
);
10749 if (num_of_syms
!= 0
10750 && filedata
->dynamic_symbols
== NULL
10751 && filedata
->dynamic_info
[DT_SYMTAB
]
10752 && filedata
->dynamic_info
[DT_SYMENT
])
10754 Elf_Internal_Phdr
*seg
;
10755 bfd_vma vma
= filedata
->dynamic_info
[DT_SYMTAB
];
10757 if (! get_program_headers (filedata
))
10759 error (_("Cannot interpret virtual addresses "
10760 "without program headers.\n"));
10764 for (seg
= filedata
->program_headers
;
10765 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
10768 if (seg
->p_type
!= PT_LOAD
)
10771 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
10773 /* See PR 21379 for a reproducer. */
10774 error (_("Invalid PT_LOAD entry\n"));
10778 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
10779 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
10781 /* Since we do not know how big the symbol table is,
10782 we default to reading in up to the end of PT_LOAD
10783 segment and processing that. This is overkill, I
10784 know, but it should work. */
10785 Elf_Internal_Shdr section
;
10786 section
.sh_offset
= (vma
- seg
->p_vaddr
10788 section
.sh_size
= (num_of_syms
10789 * filedata
->dynamic_info
[DT_SYMENT
]);
10790 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
10793 && filedata
->dynamic_symtab_section
!= NULL
10794 && ((filedata
->dynamic_symtab_section
->sh_offset
10795 != section
.sh_offset
)
10796 || (filedata
->dynamic_symtab_section
->sh_size
10797 != section
.sh_size
)
10798 || (filedata
->dynamic_symtab_section
->sh_entsize
10799 != section
.sh_entsize
)))
10801 the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
10803 section
.sh_name
= filedata
->string_table_length
;
10804 filedata
->dynamic_symbols
10805 = get_elf_symbols (filedata
, §ion
,
10806 &filedata
->num_dynamic_syms
);
10807 if (filedata
->dynamic_symbols
== NULL
10808 || filedata
->num_dynamic_syms
!= num_of_syms
)
10810 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
10819 /* Similarly find a string table. */
10820 if (filedata
->dynamic_strings
== NULL
)
10821 for (entry
= filedata
->dynamic_section
;
10822 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10825 if (entry
->d_tag
== DT_STRTAB
)
10826 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
10828 if (entry
->d_tag
== DT_STRSZ
)
10829 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
10831 if (filedata
->dynamic_info
[DT_STRTAB
]
10832 && filedata
->dynamic_info
[DT_STRSZ
])
10834 unsigned long offset
;
10835 bfd_size_type str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
10837 offset
= offset_from_vma (filedata
,
10838 filedata
->dynamic_info
[DT_STRTAB
],
10841 && filedata
->dynamic_strtab_section
10842 && ((filedata
->dynamic_strtab_section
->sh_offset
10843 != (file_ptr
) offset
)
10844 || (filedata
->dynamic_strtab_section
->sh_size
10847 the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
10849 filedata
->dynamic_strings
10850 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
10851 _("dynamic string table"));
10852 if (filedata
->dynamic_strings
== NULL
)
10854 error (_("Corrupt DT_STRTAB dynamic entry\n"));
10858 filedata
->dynamic_strings_length
= str_tab_len
;
10863 /* And find the syminfo section if available. */
10864 if (filedata
->dynamic_syminfo
== NULL
)
10866 unsigned long syminsz
= 0;
10868 for (entry
= filedata
->dynamic_section
;
10869 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10872 if (entry
->d_tag
== DT_SYMINENT
)
10874 /* Note: these braces are necessary to avoid a syntax
10875 error from the SunOS4 C compiler. */
10876 /* PR binutils/17531: A corrupt file can trigger this test.
10877 So do not use an assert, instead generate an error message. */
10878 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
10879 error (_("Bad value (%d) for SYMINENT entry\n"),
10880 (int) entry
->d_un
.d_val
);
10882 else if (entry
->d_tag
== DT_SYMINSZ
)
10883 syminsz
= entry
->d_un
.d_val
;
10884 else if (entry
->d_tag
== DT_SYMINFO
)
10885 filedata
->dynamic_syminfo_offset
10886 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
10889 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
10891 Elf_External_Syminfo
* extsyminfo
;
10892 Elf_External_Syminfo
* extsym
;
10893 Elf_Internal_Syminfo
* syminfo
;
10895 /* There is a syminfo section. Read the data. */
10896 extsyminfo
= (Elf_External_Syminfo
*)
10897 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
10898 1, syminsz
, _("symbol information"));
10902 if (filedata
->dynamic_syminfo
!= NULL
)
10904 error (_("Multiple dynamic symbol information sections found\n"));
10905 free (filedata
->dynamic_syminfo
);
10907 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10908 if (filedata
->dynamic_syminfo
== NULL
)
10910 error (_("Out of memory allocating %lu bytes "
10911 "for dynamic symbol info\n"),
10912 (unsigned long) syminsz
);
10916 filedata
->dynamic_syminfo_nent
10917 = syminsz
/ sizeof (Elf_External_Syminfo
);
10918 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
10919 syminfo
< (filedata
->dynamic_syminfo
10920 + filedata
->dynamic_syminfo_nent
);
10921 ++syminfo
, ++extsym
)
10923 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10924 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10931 if (do_dynamic
&& filedata
->dynamic_addr
)
10933 if (filedata
->dynamic_nent
== 1)
10935 if (filedata
->is_separate
)
10936 printf (_("\nIn linked file '%s' the dynamic section at offset 0x%lx contains 1 entry:\n"),
10937 filedata
->file_name
,
10938 filedata
->dynamic_addr
);
10940 printf (_("\nDynamic section at offset 0x%lx contains 1 entry:\n"),
10941 filedata
->dynamic_addr
);
10945 if (filedata
->is_separate
)
10946 printf (_("\nIn linked file '%s' the dynamic section at offset 0x%lx contains %lu entries:\n"),
10947 filedata
->file_name
,
10948 filedata
->dynamic_addr
,
10949 (unsigned long) filedata
->dynamic_nent
);
10951 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
10952 filedata
->dynamic_addr
,
10953 (unsigned long) filedata
->dynamic_nent
);
10957 printf (_(" Tag Type Name/Value\n"));
10959 for (entry
= filedata
->dynamic_section
;
10960 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10965 const char * dtype
;
10968 print_vma (entry
->d_tag
, FULL_HEX
);
10969 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10970 printf (" (%s)%*s", dtype
,
10971 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10974 switch (entry
->d_tag
)
10978 print_dynamic_flags (entry
->d_un
.d_val
);
10988 switch (entry
->d_tag
)
10991 printf (_("Auxiliary library"));
10995 printf (_("Filter library"));
10999 printf (_("Configuration file"));
11003 printf (_("Dependency audit library"));
11007 printf (_("Audit library"));
11011 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
11012 printf (": [%s]\n",
11013 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
11017 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11026 printf (_("Flags:"));
11028 if (entry
->d_un
.d_val
== 0)
11029 printf (_(" None\n"));
11032 unsigned long int val
= entry
->d_un
.d_val
;
11034 if (val
& DTF_1_PARINIT
)
11036 printf (" PARINIT");
11037 val
^= DTF_1_PARINIT
;
11039 if (val
& DTF_1_CONFEXP
)
11041 printf (" CONFEXP");
11042 val
^= DTF_1_CONFEXP
;
11045 printf (" %lx", val
);
11054 printf (_("Flags:"));
11056 if (entry
->d_un
.d_val
== 0)
11057 printf (_(" None\n"));
11060 unsigned long int val
= entry
->d_un
.d_val
;
11062 if (val
& DF_P1_LAZYLOAD
)
11064 printf (" LAZYLOAD");
11065 val
^= DF_P1_LAZYLOAD
;
11067 if (val
& DF_P1_GROUPPERM
)
11069 printf (" GROUPPERM");
11070 val
^= DF_P1_GROUPPERM
;
11073 printf (" %lx", val
);
11082 printf (_("Flags:"));
11083 if (entry
->d_un
.d_val
== 0)
11084 printf (_(" None\n"));
11087 unsigned long int val
= entry
->d_un
.d_val
;
11089 if (val
& DF_1_NOW
)
11094 if (val
& DF_1_GLOBAL
)
11096 printf (" GLOBAL");
11097 val
^= DF_1_GLOBAL
;
11099 if (val
& DF_1_GROUP
)
11104 if (val
& DF_1_NODELETE
)
11106 printf (" NODELETE");
11107 val
^= DF_1_NODELETE
;
11109 if (val
& DF_1_LOADFLTR
)
11111 printf (" LOADFLTR");
11112 val
^= DF_1_LOADFLTR
;
11114 if (val
& DF_1_INITFIRST
)
11116 printf (" INITFIRST");
11117 val
^= DF_1_INITFIRST
;
11119 if (val
& DF_1_NOOPEN
)
11121 printf (" NOOPEN");
11122 val
^= DF_1_NOOPEN
;
11124 if (val
& DF_1_ORIGIN
)
11126 printf (" ORIGIN");
11127 val
^= DF_1_ORIGIN
;
11129 if (val
& DF_1_DIRECT
)
11131 printf (" DIRECT");
11132 val
^= DF_1_DIRECT
;
11134 if (val
& DF_1_TRANS
)
11139 if (val
& DF_1_INTERPOSE
)
11141 printf (" INTERPOSE");
11142 val
^= DF_1_INTERPOSE
;
11144 if (val
& DF_1_NODEFLIB
)
11146 printf (" NODEFLIB");
11147 val
^= DF_1_NODEFLIB
;
11149 if (val
& DF_1_NODUMP
)
11151 printf (" NODUMP");
11152 val
^= DF_1_NODUMP
;
11154 if (val
& DF_1_CONFALT
)
11156 printf (" CONFALT");
11157 val
^= DF_1_CONFALT
;
11159 if (val
& DF_1_ENDFILTEE
)
11161 printf (" ENDFILTEE");
11162 val
^= DF_1_ENDFILTEE
;
11164 if (val
& DF_1_DISPRELDNE
)
11166 printf (" DISPRELDNE");
11167 val
^= DF_1_DISPRELDNE
;
11169 if (val
& DF_1_DISPRELPND
)
11171 printf (" DISPRELPND");
11172 val
^= DF_1_DISPRELPND
;
11174 if (val
& DF_1_NODIRECT
)
11176 printf (" NODIRECT");
11177 val
^= DF_1_NODIRECT
;
11179 if (val
& DF_1_IGNMULDEF
)
11181 printf (" IGNMULDEF");
11182 val
^= DF_1_IGNMULDEF
;
11184 if (val
& DF_1_NOKSYMS
)
11186 printf (" NOKSYMS");
11187 val
^= DF_1_NOKSYMS
;
11189 if (val
& DF_1_NOHDR
)
11194 if (val
& DF_1_EDITED
)
11196 printf (" EDITED");
11197 val
^= DF_1_EDITED
;
11199 if (val
& DF_1_NORELOC
)
11201 printf (" NORELOC");
11202 val
^= DF_1_NORELOC
;
11204 if (val
& DF_1_SYMINTPOSE
)
11206 printf (" SYMINTPOSE");
11207 val
^= DF_1_SYMINTPOSE
;
11209 if (val
& DF_1_GLOBAUDIT
)
11211 printf (" GLOBAUDIT");
11212 val
^= DF_1_GLOBAUDIT
;
11214 if (val
& DF_1_SINGLETON
)
11216 printf (" SINGLETON");
11217 val
^= DF_1_SINGLETON
;
11219 if (val
& DF_1_STUB
)
11224 if (val
& DF_1_PIE
)
11229 if (val
& DF_1_KMOD
)
11234 if (val
& DF_1_WEAKFILTER
)
11236 printf (" WEAKFILTER");
11237 val
^= DF_1_WEAKFILTER
;
11239 if (val
& DF_1_NOCOMMON
)
11241 printf (" NOCOMMON");
11242 val
^= DF_1_NOCOMMON
;
11245 printf (" %lx", val
);
11252 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11254 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
11274 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11280 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
11281 name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
11287 switch (entry
->d_tag
)
11290 printf (_("Shared library: [%s]"), name
);
11292 if (filedata
->program_interpreter
11293 && streq (name
, filedata
->program_interpreter
))
11294 printf (_(" program interpreter"));
11298 printf (_("Library soname: [%s]"), name
);
11302 printf (_("Library rpath: [%s]"), name
);
11306 printf (_("Library runpath: [%s]"), name
);
11310 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11315 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11328 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11329 /* Fall through. */
11333 case DT_INIT_ARRAYSZ
:
11334 case DT_FINI_ARRAYSZ
:
11335 case DT_GNU_CONFLICTSZ
:
11336 case DT_GNU_LIBLISTSZ
:
11339 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11340 printf (_(" (bytes)\n"));
11345 case DT_VERNEEDNUM
:
11350 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11359 case DT_INIT_ARRAY
:
11360 case DT_FINI_ARRAY
:
11363 if (entry
->d_tag
== DT_USED
11364 && VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
11366 char * name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
11370 printf (_("Not needed object: [%s]\n"), name
);
11375 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11381 /* The value of this entry is ignored. */
11386 case DT_GNU_PRELINKED
:
11390 time_t atime
= entry
->d_un
.d_val
;
11392 tmp
= gmtime (&atime
);
11393 /* PR 17533 file: 041-1244816-0.004. */
11395 printf (_("<corrupt time val: %lx"),
11396 (unsigned long) atime
);
11398 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
11399 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11400 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11406 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11409 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11414 case DT_GNU_FLAGS_1
:
11417 printf (_("Flags:"));
11418 if (entry
->d_un
.d_val
== 0)
11419 printf (_(" None\n"));
11422 unsigned long int val
= entry
->d_un
.d_val
;
11424 if (val
& DF_GNU_1_UNIQUE
)
11426 printf (" UNIQUE");
11427 val
^= DF_GNU_1_UNIQUE
;
11430 printf (" %lx", val
);
11437 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
11438 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
11439 = entry
->d_un
.d_val
;
11443 switch (filedata
->file_header
.e_machine
)
11446 dynamic_section_aarch64_val (entry
);
11449 case EM_MIPS_RS3_LE
:
11450 dynamic_section_mips_val (filedata
, entry
);
11453 dynamic_section_parisc_val (entry
);
11456 dynamic_section_ia64_val (entry
);
11459 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11471 get_ver_flags (unsigned int flags
)
11473 static char buff
[128];
11480 if (flags
& VER_FLG_BASE
)
11481 strcat (buff
, "BASE");
11483 if (flags
& VER_FLG_WEAK
)
11485 if (flags
& VER_FLG_BASE
)
11486 strcat (buff
, " | ");
11488 strcat (buff
, "WEAK");
11491 if (flags
& VER_FLG_INFO
)
11493 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
11494 strcat (buff
, " | ");
11496 strcat (buff
, "INFO");
11499 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11501 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11502 strcat (buff
, " | ");
11504 strcat (buff
, _("<unknown>"));
11510 /* Display the contents of the version sections. */
11513 process_version_sections (Filedata
* filedata
)
11515 Elf_Internal_Shdr
* section
;
11517 bool found
= false;
11522 for (i
= 0, section
= filedata
->section_headers
;
11523 i
< filedata
->file_header
.e_shnum
;
11526 switch (section
->sh_type
)
11528 case SHT_GNU_verdef
:
11530 Elf_External_Verdef
* edefs
;
11537 if (filedata
->is_separate
)
11538 printf (ngettext ("\nIn linked file '%s' the version definition section '%s' contains %u entry:\n",
11539 "\nIn linked file '%s' the version definition section '%s' contains %u entries:\n",
11541 filedata
->file_name
,
11542 printable_section_name (filedata
, section
),
11545 printf (ngettext ("\nVersion definition section '%s' "
11546 "contains %u entry:\n",
11547 "\nVersion definition section '%s' "
11548 "contains %u entries:\n",
11550 printable_section_name (filedata
, section
),
11553 printf (_(" Addr: 0x"));
11554 printf_vma (section
->sh_addr
);
11555 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11556 (unsigned long) section
->sh_offset
, section
->sh_link
,
11557 printable_section_name_from_index (filedata
, section
->sh_link
));
11559 edefs
= (Elf_External_Verdef
*)
11560 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
11561 _("version definition section"));
11564 endbuf
= (char *) edefs
+ section
->sh_size
;
11566 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11569 Elf_External_Verdef
* edef
;
11570 Elf_Internal_Verdef ent
;
11571 Elf_External_Verdaux
* eaux
;
11572 Elf_Internal_Verdaux aux
;
11573 unsigned long isum
;
11576 vstart
= ((char *) edefs
) + idx
;
11577 if (vstart
+ sizeof (*edef
) > endbuf
)
11580 edef
= (Elf_External_Verdef
*) vstart
;
11582 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
11583 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
11584 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
11585 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
11586 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
11587 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
11588 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
11590 printf (_(" %#06lx: Rev: %d Flags: %s"),
11591 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
11593 printf (_(" Index: %d Cnt: %d "),
11594 ent
.vd_ndx
, ent
.vd_cnt
);
11596 /* Check for overflow. */
11597 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
11600 vstart
+= ent
.vd_aux
;
11602 if (vstart
+ sizeof (*eaux
) > endbuf
)
11604 eaux
= (Elf_External_Verdaux
*) vstart
;
11606 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11607 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11609 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11610 printf (_("Name: %s\n"),
11611 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11613 printf (_("Name index: %ld\n"), aux
.vda_name
);
11615 isum
= idx
+ ent
.vd_aux
;
11617 for (j
= 1; j
< ent
.vd_cnt
; j
++)
11619 if (aux
.vda_next
< sizeof (*eaux
)
11620 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
11622 warn (_("Invalid vda_next field of %lx\n"),
11627 /* Check for overflow. */
11628 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
11631 isum
+= aux
.vda_next
;
11632 vstart
+= aux
.vda_next
;
11634 if (vstart
+ sizeof (*eaux
) > endbuf
)
11636 eaux
= (Elf_External_Verdaux
*) vstart
;
11638 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11639 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11641 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11642 printf (_(" %#06lx: Parent %d: %s\n"),
11644 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11646 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
11647 isum
, j
, aux
.vda_name
);
11650 if (j
< ent
.vd_cnt
)
11651 printf (_(" Version def aux past end of section\n"));
11654 file: id:000001,src:000172+005151,op:splice,rep:2. */
11655 if (ent
.vd_next
< sizeof (*edef
)
11656 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
11658 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
11659 cnt
= section
->sh_info
;
11662 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
11665 idx
+= ent
.vd_next
;
11668 if (cnt
< section
->sh_info
)
11669 printf (_(" Version definition past end of section\n"));
11675 case SHT_GNU_verneed
:
11677 Elf_External_Verneed
* eneed
;
11684 if (filedata
->is_separate
)
11685 printf (ngettext ("\nIn linked file '%s' the version needs section '%s' contains %u entry:\n",
11686 "\nIn linked file '%s' the version needs section '%s' contains %u entries:\n",
11688 filedata
->file_name
,
11689 printable_section_name (filedata
, section
),
11692 printf (ngettext ("\nVersion needs section '%s' "
11693 "contains %u entry:\n",
11694 "\nVersion needs section '%s' "
11695 "contains %u entries:\n",
11697 printable_section_name (filedata
, section
),
11700 printf (_(" Addr: 0x"));
11701 printf_vma (section
->sh_addr
);
11702 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11703 (unsigned long) section
->sh_offset
, section
->sh_link
,
11704 printable_section_name_from_index (filedata
, section
->sh_link
));
11706 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
11707 section
->sh_offset
, 1,
11709 _("Version Needs section"));
11712 endbuf
= (char *) eneed
+ section
->sh_size
;
11714 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11716 Elf_External_Verneed
* entry
;
11717 Elf_Internal_Verneed ent
;
11718 unsigned long isum
;
11722 vstart
= ((char *) eneed
) + idx
;
11723 if (vstart
+ sizeof (*entry
) > endbuf
)
11726 entry
= (Elf_External_Verneed
*) vstart
;
11728 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
11729 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
11730 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
11731 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
11732 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
11734 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
11736 if (VALID_DYNAMIC_NAME (filedata
, ent
.vn_file
))
11737 printf (_(" File: %s"),
11738 GET_DYNAMIC_NAME (filedata
, ent
.vn_file
));
11740 printf (_(" File: %lx"), ent
.vn_file
);
11742 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
11744 /* Check for overflow. */
11745 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
11747 vstart
+= ent
.vn_aux
;
11749 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
11751 Elf_External_Vernaux
* eaux
;
11752 Elf_Internal_Vernaux aux
;
11754 if (vstart
+ sizeof (*eaux
) > endbuf
)
11756 eaux
= (Elf_External_Vernaux
*) vstart
;
11758 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
11759 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
11760 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
11761 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
11762 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
11764 if (VALID_DYNAMIC_NAME (filedata
, aux
.vna_name
))
11765 printf (_(" %#06lx: Name: %s"),
11766 isum
, GET_DYNAMIC_NAME (filedata
, aux
.vna_name
));
11768 printf (_(" %#06lx: Name index: %lx"),
11769 isum
, aux
.vna_name
);
11771 printf (_(" Flags: %s Version: %d\n"),
11772 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
11774 if (aux
.vna_next
< sizeof (*eaux
)
11775 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
11777 warn (_("Invalid vna_next field of %lx\n"),
11782 /* Check for overflow. */
11783 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
11785 isum
+= aux
.vna_next
;
11786 vstart
+= aux
.vna_next
;
11789 if (j
< ent
.vn_cnt
)
11790 warn (_("Missing Version Needs auxiliary information\n"));
11792 if (ent
.vn_next
< sizeof (*entry
)
11793 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
11795 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
11796 cnt
= section
->sh_info
;
11799 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
11801 idx
+= ent
.vn_next
;
11804 if (cnt
< section
->sh_info
)
11805 warn (_("Missing Version Needs information\n"));
11811 case SHT_GNU_versym
:
11813 Elf_Internal_Shdr
* link_section
;
11816 unsigned char * edata
;
11817 unsigned short * data
;
11819 Elf_Internal_Sym
* symbols
;
11820 Elf_Internal_Shdr
* string_sec
;
11821 unsigned long num_syms
;
11824 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
11827 link_section
= filedata
->section_headers
+ section
->sh_link
;
11828 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
11830 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
11835 symbols
= get_elf_symbols (filedata
, link_section
, & num_syms
);
11836 if (symbols
== NULL
)
11839 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
11841 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
11842 string_sec
->sh_size
,
11843 _("version string table"));
11850 if (filedata
->is_separate
)
11851 printf (ngettext ("\nIn linked file '%s' the version symbols section '%s' contains %lu entry:\n",
11852 "\nIn linked file '%s' the version symbols section '%s' contains %lu entries:\n",
11854 filedata
->file_name
,
11855 printable_section_name (filedata
, section
),
11856 (unsigned long) total
);
11858 printf (ngettext ("\nVersion symbols section '%s' "
11859 "contains %lu entry:\n",
11860 "\nVersion symbols section '%s' "
11861 "contains %lu entries:\n",
11863 printable_section_name (filedata
, section
),
11864 (unsigned long) total
);
11866 printf (_(" Addr: 0x"));
11867 printf_vma (section
->sh_addr
);
11868 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11869 (unsigned long) section
->sh_offset
, section
->sh_link
,
11870 printable_section_name (filedata
, link_section
));
11872 off
= offset_from_vma (filedata
,
11873 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11874 total
* sizeof (short));
11875 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
11876 sizeof (short), total
,
11877 _("version symbol data"));
11885 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
11887 for (cnt
= total
; cnt
--;)
11888 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
11893 for (cnt
= 0; cnt
< total
; cnt
+= 4)
11897 char *invalid
= _("*invalid*");
11899 printf (" %03x:", cnt
);
11901 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
11902 switch (data
[cnt
+ j
])
11905 fputs (_(" 0 (*local*) "), stdout
);
11909 fputs (_(" 1 (*global*) "), stdout
);
11913 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
11914 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
11916 /* If this index value is greater than the size of the symbols
11917 array, break to avoid an out-of-bounds read. */
11918 if ((unsigned long)(cnt
+ j
) >= num_syms
)
11920 warn (_("invalid index into symbol array\n"));
11925 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11927 Elf_Internal_Verneed ivn
;
11928 unsigned long offset
;
11930 offset
= offset_from_vma
11932 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11933 sizeof (Elf_External_Verneed
));
11937 Elf_Internal_Vernaux ivna
;
11938 Elf_External_Verneed evn
;
11939 Elf_External_Vernaux evna
;
11940 unsigned long a_off
;
11942 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11943 _("version need")) == NULL
)
11946 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11947 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11949 a_off
= offset
+ ivn
.vn_aux
;
11953 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
11954 1, _("version need aux (2)")) == NULL
)
11957 ivna
.vna_other
= 0;
11961 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11962 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11965 a_off
+= ivna
.vna_next
;
11967 while (ivna
.vna_other
!= data
[cnt
+ j
]
11968 && ivna
.vna_next
!= 0);
11970 if (ivna
.vna_other
== data
[cnt
+ j
])
11972 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11974 if (ivna
.vna_name
>= string_sec
->sh_size
)
11977 name
= strtab
+ ivna
.vna_name
;
11981 offset
+= ivn
.vn_next
;
11983 while (ivn
.vn_next
);
11986 if (data
[cnt
+ j
] != 0x8001
11987 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11989 Elf_Internal_Verdef ivd
;
11990 Elf_External_Verdef evd
;
11991 unsigned long offset
;
11993 offset
= offset_from_vma
11995 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
12000 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
12001 _("version def")) == NULL
)
12004 /* PR 17531: file: 046-1082287-0.004. */
12005 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
12010 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
12011 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
12014 offset
+= ivd
.vd_next
;
12016 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
12017 && ivd
.vd_next
!= 0);
12019 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
12021 Elf_External_Verdaux evda
;
12022 Elf_Internal_Verdaux ivda
;
12024 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
12026 if (get_data (&evda
, filedata
,
12027 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
12029 _("version def aux")) == NULL
)
12032 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
12034 if (ivda
.vda_name
>= string_sec
->sh_size
)
12036 else if (name
!= NULL
&& name
!= invalid
)
12037 name
= _("*both*");
12039 name
= strtab
+ ivda
.vda_name
;
12043 nn
+= printf ("(%s%-*s",
12045 12 - (int) strlen (name
),
12049 printf ("%*c", 18 - nn
, ' ');
12068 if (filedata
->is_separate
)
12069 printf (_("\nNo version information found in linked file '%s'.\n"),
12070 filedata
->file_name
);
12072 printf (_("\nNo version information found in this file.\n"));
12078 static const char *
12079 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
12081 static char buff
[64];
12085 case STB_LOCAL
: return "LOCAL";
12086 case STB_GLOBAL
: return "GLOBAL";
12087 case STB_WEAK
: return "WEAK";
12089 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
12090 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
12092 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
12094 if (binding
== STB_GNU_UNIQUE
12095 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
12097 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
12100 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
12105 static const char *
12106 get_symbol_type (Filedata
* filedata
, unsigned int type
)
12108 static char buff
[64];
12112 case STT_NOTYPE
: return "NOTYPE";
12113 case STT_OBJECT
: return "OBJECT";
12114 case STT_FUNC
: return "FUNC";
12115 case STT_SECTION
: return "SECTION";
12116 case STT_FILE
: return "FILE";
12117 case STT_COMMON
: return "COMMON";
12118 case STT_TLS
: return "TLS";
12119 case STT_RELC
: return "RELC";
12120 case STT_SRELC
: return "SRELC";
12122 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
12124 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
12125 return "THUMB_FUNC";
12127 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
12130 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
12131 return "PARISC_MILLI";
12133 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
12135 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
12137 if (filedata
->file_header
.e_machine
== EM_PARISC
)
12139 if (type
== STT_HP_OPAQUE
)
12140 return "HP_OPAQUE";
12141 if (type
== STT_HP_STUB
)
12145 if (type
== STT_GNU_IFUNC
12146 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
12147 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
12150 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
12153 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
12158 static const char *
12159 get_symbol_visibility (unsigned int visibility
)
12161 switch (visibility
)
12163 case STV_DEFAULT
: return "DEFAULT";
12164 case STV_INTERNAL
: return "INTERNAL";
12165 case STV_HIDDEN
: return "HIDDEN";
12166 case STV_PROTECTED
: return "PROTECTED";
12168 error (_("Unrecognized visibility value: %u\n"), visibility
);
12169 return _("<unknown>");
12173 static const char *
12174 get_alpha_symbol_other (unsigned int other
)
12178 case STO_ALPHA_NOPV
: return "NOPV";
12179 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
12181 error (_("Unrecognized alpha specific other value: %u\n"), other
);
12182 return _("<unknown>");
12186 static const char *
12187 get_solaris_symbol_visibility (unsigned int visibility
)
12189 switch (visibility
)
12191 case 4: return "EXPORTED";
12192 case 5: return "SINGLETON";
12193 case 6: return "ELIMINATE";
12194 default: return get_symbol_visibility (visibility
);
12198 static const char *
12199 get_aarch64_symbol_other (unsigned int other
)
12201 static char buf
[32];
12203 if (other
& STO_AARCH64_VARIANT_PCS
)
12205 other
&= ~STO_AARCH64_VARIANT_PCS
;
12207 return "VARIANT_PCS";
12208 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
12214 static const char *
12215 get_mips_symbol_other (unsigned int other
)
12219 case STO_OPTIONAL
: return "OPTIONAL";
12220 case STO_MIPS_PLT
: return "MIPS PLT";
12221 case STO_MIPS_PIC
: return "MIPS PIC";
12222 case STO_MICROMIPS
: return "MICROMIPS";
12223 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
12224 case STO_MIPS16
: return "MIPS16";
12225 default: return NULL
;
12229 static const char *
12230 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
12232 if (is_ia64_vms (filedata
))
12234 static char res
[32];
12238 /* Function types is for images and .STB files only. */
12239 switch (filedata
->file_header
.e_type
)
12243 switch (VMS_ST_FUNC_TYPE (other
))
12245 case VMS_SFT_CODE_ADDR
:
12246 strcat (res
, " CA");
12248 case VMS_SFT_SYMV_IDX
:
12249 strcat (res
, " VEC");
12252 strcat (res
, " FD");
12254 case VMS_SFT_RESERVE
:
12255 strcat (res
, " RSV");
12258 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
12259 VMS_ST_FUNC_TYPE (other
));
12260 strcat (res
, " <unknown>");
12267 switch (VMS_ST_LINKAGE (other
))
12269 case VMS_STL_IGNORE
:
12270 strcat (res
, " IGN");
12272 case VMS_STL_RESERVE
:
12273 strcat (res
, " RSV");
12276 strcat (res
, " STD");
12279 strcat (res
, " LNK");
12282 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
12283 VMS_ST_LINKAGE (other
));
12284 strcat (res
, " <unknown>");
12296 static const char *
12297 get_ppc64_symbol_other (unsigned int other
)
12299 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
12302 other
>>= STO_PPC64_LOCAL_BIT
;
12305 static char buf
[64];
12307 other
= ppc64_decode_local_entry (other
);
12308 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
12314 static const char *
12315 get_symbol_other (Filedata
* filedata
, unsigned int other
)
12317 const char * result
= NULL
;
12318 static char buff
[64];
12323 switch (filedata
->file_header
.e_machine
)
12326 result
= get_alpha_symbol_other (other
);
12329 result
= get_aarch64_symbol_other (other
);
12332 result
= get_mips_symbol_other (other
);
12335 result
= get_ia64_symbol_other (filedata
, other
);
12338 result
= get_ppc64_symbol_other (other
);
12348 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
12352 static const char *
12353 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
12355 static char buff
[32];
12359 case SHN_UNDEF
: return "UND";
12360 case SHN_ABS
: return "ABS";
12361 case SHN_COMMON
: return "COM";
12363 if (type
== SHN_IA_64_ANSI_COMMON
12364 && filedata
->file_header
.e_machine
== EM_IA_64
12365 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
12367 else if ((filedata
->file_header
.e_machine
== EM_X86_64
12368 || filedata
->file_header
.e_machine
== EM_L1OM
12369 || filedata
->file_header
.e_machine
== EM_K1OM
)
12370 && type
== SHN_X86_64_LCOMMON
)
12371 return "LARGE_COM";
12372 else if ((type
== SHN_MIPS_SCOMMON
12373 && filedata
->file_header
.e_machine
== EM_MIPS
)
12374 || (type
== SHN_TIC6X_SCOMMON
12375 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
12377 else if (type
== SHN_MIPS_SUNDEFINED
12378 && filedata
->file_header
.e_machine
== EM_MIPS
)
12380 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
12381 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
12382 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
12383 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
12384 else if (type
>= SHN_LORESERVE
)
12385 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
12386 else if (filedata
->file_header
.e_shnum
!= 0
12387 && type
>= filedata
->file_header
.e_shnum
)
12388 sprintf (buff
, _("bad section index[%3d]"), type
);
12390 sprintf (buff
, "%3d", type
);
12397 static const char *
12398 get_symbol_version_string (Filedata
* filedata
,
12400 const char * strtab
,
12401 unsigned long int strtab_size
,
12403 Elf_Internal_Sym
* psym
,
12404 enum versioned_symbol_info
* sym_info
,
12405 unsigned short * vna_other
)
12407 unsigned char data
[2];
12408 unsigned short vers_data
;
12409 unsigned long offset
;
12410 unsigned short max_vd_ndx
;
12413 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
12416 offset
= offset_from_vma (filedata
,
12417 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
12418 sizeof data
+ si
* sizeof (vers_data
));
12420 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
12421 sizeof (data
), 1, _("version data")) == NULL
)
12424 vers_data
= byte_get (data
, 2);
12426 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
12429 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
12432 /* Usually we'd only see verdef for defined symbols, and verneed for
12433 undefined symbols. However, symbols defined by the linker in
12434 .dynbss for variables copied from a shared library in order to
12435 avoid text relocations are defined yet have verneed. We could
12436 use a heuristic to detect the special case, for example, check
12437 for verneed first on symbols defined in SHT_NOBITS sections, but
12438 it is simpler and more reliable to just look for both verdef and
12439 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
12441 if (psym
->st_shndx
!= SHN_UNDEF
12442 && vers_data
!= 0x8001
12443 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
12445 Elf_Internal_Verdef ivd
;
12446 Elf_Internal_Verdaux ivda
;
12447 Elf_External_Verdaux evda
;
12450 off
= offset_from_vma (filedata
,
12451 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
12452 sizeof (Elf_External_Verdef
));
12456 Elf_External_Verdef evd
;
12458 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
12459 _("version def")) == NULL
)
12468 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
12469 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
12470 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
12471 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
12474 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
12475 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
12477 off
+= ivd
.vd_next
;
12479 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
12481 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
12483 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
12486 off
-= ivd
.vd_next
;
12489 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
12490 _("version def aux")) != NULL
)
12492 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
12494 if (psym
->st_name
!= ivda
.vda_name
)
12495 return (ivda
.vda_name
< strtab_size
12496 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
12501 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
12503 Elf_External_Verneed evn
;
12504 Elf_Internal_Verneed ivn
;
12505 Elf_Internal_Vernaux ivna
;
12507 offset
= offset_from_vma (filedata
,
12508 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
12512 unsigned long vna_off
;
12514 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
12515 _("version need")) == NULL
)
12518 ivna
.vna_other
= 0;
12523 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
12524 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
12526 vna_off
= offset
+ ivn
.vn_aux
;
12530 Elf_External_Vernaux evna
;
12532 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
12533 _("version need aux (3)")) == NULL
)
12536 ivna
.vna_other
= 0;
12541 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
12542 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
12543 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
12546 vna_off
+= ivna
.vna_next
;
12548 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
12550 if (ivna
.vna_other
== vers_data
)
12553 offset
+= ivn
.vn_next
;
12555 while (ivn
.vn_next
!= 0);
12557 if (ivna
.vna_other
== vers_data
)
12559 *sym_info
= symbol_undefined
;
12560 *vna_other
= ivna
.vna_other
;
12561 return (ivna
.vna_name
< strtab_size
12562 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
12564 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
12565 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
12566 return _("<corrupt>");
12571 /* Display a symbol size on stdout. Format is based on --sym-base setting. */
12573 static unsigned int
12574 print_dynamic_symbol_size (bfd_vma vma
, int base
)
12579 return print_vma (vma
, OCTAL_5
);
12582 return print_vma (vma
, UNSIGNED_5
);
12585 return print_vma (vma
, PREFIX_HEX_5
);
12589 return print_vma (vma
, DEC_5
);
12594 print_dynamic_symbol (Filedata
*filedata
, unsigned long si
,
12595 Elf_Internal_Sym
*symtab
,
12596 Elf_Internal_Shdr
*section
,
12597 char *strtab
, size_t strtab_size
)
12599 const char *version_string
;
12600 enum versioned_symbol_info sym_info
;
12601 unsigned short vna_other
;
12604 Elf_Internal_Sym
*psym
= symtab
+ si
;
12606 printf ("%6ld: ", si
);
12607 print_vma (psym
->st_value
, LONG_HEX
);
12609 print_dynamic_symbol_size (psym
->st_size
, sym_base
);
12610 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12611 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12612 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12613 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12616 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12618 printf (" %-7s", get_symbol_visibility (vis
));
12619 /* Check to see if any other bits in the st_other field are set.
12620 Note - displaying this information disrupts the layout of the
12621 table being generated, but for the moment this case is very rare. */
12622 if (psym
->st_other
^ vis
)
12623 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12625 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12627 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
12628 && psym
->st_shndx
< filedata
->file_header
.e_shnum
12629 && psym
->st_name
== 0)
12631 is_valid
= SECTION_NAME_VALID (filedata
->section_headers
+ psym
->st_shndx
);
12633 SECTION_NAME_PRINT (filedata
->section_headers
+ psym
->st_shndx
)
12638 is_valid
= VALID_SYMBOL_NAME (strtab
, strtab_size
, psym
->st_name
);
12639 sstr
= is_valid
? strtab
+ psym
->st_name
: _("<corrupt>");
12643 = get_symbol_version_string (filedata
,
12645 || section
->sh_type
== SHT_DYNSYM
),
12646 strtab
, strtab_size
, si
,
12647 psym
, &sym_info
, &vna_other
);
12649 int len_avail
= 21;
12650 if (! do_wide
&& version_string
!= NULL
)
12654 len_avail
-= 1 + strlen (version_string
);
12656 if (sym_info
== symbol_undefined
)
12657 len_avail
-= sprintf (buffer
," (%d)", vna_other
);
12658 else if (sym_info
!= symbol_hidden
)
12662 print_symbol (len_avail
, sstr
);
12664 if (version_string
)
12666 if (sym_info
== symbol_undefined
)
12667 printf ("@%s (%d)", version_string
, vna_other
);
12669 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12675 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12677 && si
>= section
->sh_info
12678 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12679 && filedata
->file_header
.e_machine
!= EM_MIPS
12680 /* Solaris binaries have been found to violate this requirement as
12681 well. Not sure if this is a bug or an ABI requirement. */
12682 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12683 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12684 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12687 static const char *
12688 get_lto_kind (unsigned int kind
)
12692 case 0: return "DEF";
12693 case 1: return "WEAKDEF";
12694 case 2: return "UNDEF";
12695 case 3: return "WEAKUNDEF";
12696 case 4: return "COMMON";
12701 static char buffer
[30];
12702 error (_("Unknown LTO symbol definition encountered: %u\n"), kind
);
12703 sprintf (buffer
, "<unknown: %u>", kind
);
12707 static const char *
12708 get_lto_visibility (unsigned int visibility
)
12710 switch (visibility
)
12712 case 0: return "DEFAULT";
12713 case 1: return "PROTECTED";
12714 case 2: return "INTERNAL";
12715 case 3: return "HIDDEN";
12720 static char buffer
[30];
12721 error (_("Unknown LTO symbol visibility encountered: %u\n"), visibility
);
12722 sprintf (buffer
, "<unknown: %u>", visibility
);
12726 static const char *
12727 get_lto_sym_type (unsigned int sym_type
)
12731 case 0: return "UNKNOWN";
12732 case 1: return "FUNCTION";
12733 case 2: return "VARIABLE";
12738 static char buffer
[30];
12739 error (_("Unknown LTO symbol type encountered: %u\n"), sym_type
);
12740 sprintf (buffer
, "<unknown: %u>", sym_type
);
12744 /* Display an LTO format symbol table.
12745 FIXME: The format of LTO symbol tables is not formalized.
12746 So this code could need changing in the future. */
12749 display_lto_symtab (Filedata
* filedata
,
12750 Elf_Internal_Shdr
* section
)
12752 if (section
->sh_size
== 0)
12754 if (filedata
->is_separate
)
12755 printf (_("\nThe LTO Symbol table section '%s' in linked file '%s' is empty!\n"),
12756 printable_section_name (filedata
, section
),
12757 filedata
->file_name
);
12759 printf (_("\nLTO Symbol table '%s' is empty!\n"),
12760 printable_section_name (filedata
, section
));
12765 if (section
->sh_size
> filedata
->file_size
)
12767 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
12768 printable_section_name (filedata
, section
),
12769 (unsigned long) section
->sh_size
);
12773 void * alloced_data
= get_data (NULL
, filedata
, section
->sh_offset
,
12774 section
->sh_size
, 1, _("LTO symbols"));
12775 if (alloced_data
== NULL
)
12778 /* Look for extended data for the symbol table. */
12779 Elf_Internal_Shdr
* ext
;
12780 void * ext_data_orig
= NULL
;
12781 char * ext_data
= NULL
;
12782 char * ext_data_end
= NULL
;
12783 char * ext_name
= NULL
;
12785 if (asprintf (& ext_name
, ".gnu.lto_.ext_symtab.%s",
12786 SECTION_NAME (section
) + sizeof (".gnu.lto_.symtab.") - 1) > 0
12787 && ext_name
!= NULL
/* Paranoia. */
12788 && (ext
= find_section (filedata
, ext_name
)) != NULL
)
12790 if (ext
->sh_size
< 3)
12791 error (_("LTO Symbol extension table '%s' is empty!\n"),
12792 printable_section_name (filedata
, ext
));
12795 ext_data_orig
= ext_data
= get_data (NULL
, filedata
, ext
->sh_offset
,
12797 _("LTO ext symbol data"));
12798 if (ext_data
!= NULL
)
12800 ext_data_end
= ext_data
+ ext
->sh_size
;
12801 if (* ext_data
++ != 1)
12802 error (_("Unexpected version number in symbol extension table\n"));
12807 const unsigned char * data
= (const unsigned char *) alloced_data
;
12808 const unsigned char * end
= data
+ section
->sh_size
;
12810 if (filedata
->is_separate
)
12811 printf (_("\nIn linked file '%s': "), filedata
->file_name
);
12815 if (ext_data_orig
!= NULL
)
12818 printf (_("LTO Symbol table '%s' and extension table '%s' contain:\n"),
12819 printable_section_name (filedata
, section
),
12820 printable_section_name (filedata
, ext
));
12823 printf (_("LTO Symbol table '%s'\n"),
12824 printable_section_name (filedata
, section
));
12825 printf (_(" and extension table '%s' contain:\n"),
12826 printable_section_name (filedata
, ext
));
12830 printf (_("LTO Symbol table '%s' contains:\n"),
12831 printable_section_name (filedata
, section
));
12833 /* FIXME: Add a wide version. */
12834 if (ext_data_orig
!= NULL
)
12835 printf (_(" Comdat_Key Kind Visibility Size Slot Type Section Name\n"));
12837 printf (_(" Comdat_Key Kind Visibility Size Slot Name\n"));
12839 /* FIXME: We do not handle style prefixes. */
12843 const unsigned char * sym_name
= data
;
12844 data
+= strnlen ((const char *) sym_name
, end
- data
) + 1;
12848 const unsigned char * comdat_key
= data
;
12849 data
+= strnlen ((const char *) comdat_key
, end
- data
) + 1;
12853 if (data
+ 2 + 8 + 4 > end
)
12856 unsigned int kind
= *data
++;
12857 unsigned int visibility
= *data
++;
12859 elf_vma size
= byte_get (data
, 8);
12862 elf_vma slot
= byte_get (data
, 4);
12865 if (ext_data
!= NULL
)
12867 if (ext_data
< (ext_data_end
- 1))
12869 unsigned int sym_type
= * ext_data
++;
12870 unsigned int sec_kind
= * ext_data
++;
12872 printf (" %10s %10s %11s %08lx %08lx %9s %08lx _",
12873 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
12874 get_lto_kind (kind
),
12875 get_lto_visibility (visibility
),
12878 get_lto_sym_type (sym_type
),
12880 print_symbol (6, (const char *) sym_name
);
12884 error (_("Ran out of LTO symbol extension data\n"));
12886 /* FIXME: return FAIL result ? */
12891 printf (" %10s %10s %11s %08lx %08lx _",
12892 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
12893 get_lto_kind (kind
),
12894 get_lto_visibility (visibility
),
12897 print_symbol (21, (const char *) sym_name
);
12902 if (ext_data
!= NULL
&& ext_data
< ext_data_end
)
12904 error (_("Data remains in the LTO symbol extension table\n"));
12908 free (alloced_data
);
12909 free (ext_data_orig
);
12914 error (_("Buffer overrun encountered whilst decoding LTO symbol table\n"));
12915 free (alloced_data
);
12916 free (ext_data_orig
);
12921 /* Display LTO symbol tables. */
12924 process_lto_symbol_tables (Filedata
* filedata
)
12926 Elf_Internal_Shdr
* section
;
12933 if (filedata
->section_headers
== NULL
)
12936 for (i
= 0, section
= filedata
->section_headers
;
12937 i
< filedata
->file_header
.e_shnum
;
12939 if (SECTION_NAME_VALID (section
)
12940 && startswith (SECTION_NAME (section
), ".gnu.lto_.symtab."))
12941 res
&= display_lto_symtab (filedata
, section
);
12946 /* Dump the symbol table. */
12949 process_symbol_table (Filedata
* filedata
)
12951 Elf_Internal_Shdr
* section
;
12953 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
12956 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
12958 && do_using_dynamic
12959 && filedata
->dynamic_strings
!= NULL
12960 && filedata
->dynamic_symbols
!= NULL
)
12964 if (filedata
->is_separate
)
12966 printf (ngettext ("\nIn linked file '%s' the dynamic symbol table contains %lu entry:\n",
12967 "\nIn linked file '%s' the dynamic symbol table contains %lu entries:\n",
12968 filedata
->num_dynamic_syms
),
12969 filedata
->file_name
,
12970 filedata
->num_dynamic_syms
);
12974 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
12975 "\nSymbol table for image contains %lu entries:\n",
12976 filedata
->num_dynamic_syms
),
12977 filedata
->num_dynamic_syms
);
12980 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12982 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12984 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
12985 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
12986 filedata
->dynamic_strings
,
12987 filedata
->dynamic_strings_length
);
12989 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
12990 && filedata
->section_headers
!= NULL
)
12994 for (i
= 0, section
= filedata
->section_headers
;
12995 i
< filedata
->file_header
.e_shnum
;
12998 char * strtab
= NULL
;
12999 unsigned long int strtab_size
= 0;
13000 Elf_Internal_Sym
* symtab
;
13001 unsigned long si
, num_syms
;
13003 if ((section
->sh_type
!= SHT_SYMTAB
13004 && section
->sh_type
!= SHT_DYNSYM
)
13006 && section
->sh_type
== SHT_SYMTAB
))
13009 if (section
->sh_entsize
== 0)
13011 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
13012 printable_section_name (filedata
, section
));
13016 num_syms
= section
->sh_size
/ section
->sh_entsize
;
13018 if (filedata
->is_separate
)
13019 printf (ngettext ("\nIn linked file '%s' symbol section '%s' contains %lu entry:\n",
13020 "\nIn linked file '%s' symbol section '%s' contains %lu entries:\n",
13022 filedata
->file_name
,
13023 printable_section_name (filedata
, section
),
13026 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
13027 "\nSymbol table '%s' contains %lu entries:\n",
13029 printable_section_name (filedata
, section
),
13033 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
13035 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
13037 symtab
= get_elf_symbols (filedata
, section
, & num_syms
);
13038 if (symtab
== NULL
)
13041 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
13043 strtab
= filedata
->string_table
;
13044 strtab_size
= filedata
->string_table_length
;
13046 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
13048 Elf_Internal_Shdr
* string_sec
;
13050 string_sec
= filedata
->section_headers
+ section
->sh_link
;
13052 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
13053 1, string_sec
->sh_size
,
13054 _("string table"));
13055 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
13058 for (si
= 0; si
< num_syms
; si
++)
13059 print_dynamic_symbol (filedata
, si
, symtab
, section
,
13060 strtab
, strtab_size
);
13063 if (strtab
!= filedata
->string_table
)
13069 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
13071 if (do_histogram
&& filedata
->buckets
!= NULL
)
13073 unsigned long * lengths
;
13074 unsigned long * counts
;
13077 unsigned long maxlength
= 0;
13078 unsigned long nzero_counts
= 0;
13079 unsigned long nsyms
= 0;
13082 printf (ngettext ("\nHistogram for bucket list length "
13083 "(total of %lu bucket):\n",
13084 "\nHistogram for bucket list length "
13085 "(total of %lu buckets):\n",
13086 (unsigned long) filedata
->nbuckets
),
13087 (unsigned long) filedata
->nbuckets
);
13089 lengths
= (unsigned long *) calloc (filedata
->nbuckets
,
13090 sizeof (*lengths
));
13091 if (lengths
== NULL
)
13093 error (_("Out of memory allocating space for histogram buckets\n"));
13096 visited
= xcmalloc (filedata
->nchains
, 1);
13097 memset (visited
, 0, filedata
->nchains
);
13099 printf (_(" Length Number %% of total Coverage\n"));
13100 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
13102 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
13105 if (maxlength
< ++lengths
[hn
])
13107 if (si
>= filedata
->nchains
|| visited
[si
])
13109 error (_("histogram chain is corrupt\n"));
13117 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
13118 if (counts
== NULL
)
13121 error (_("Out of memory allocating space for histogram counts\n"));
13125 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
13126 ++counts
[lengths
[hn
]];
13128 if (filedata
->nbuckets
> 0)
13131 printf (" 0 %-10lu (%5.1f%%)\n",
13132 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
13133 for (i
= 1; i
<= maxlength
; ++i
)
13135 nzero_counts
+= counts
[i
] * i
;
13136 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
13137 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
13138 (nzero_counts
* 100.0) / nsyms
);
13146 free (filedata
->buckets
);
13147 filedata
->buckets
= NULL
;
13148 filedata
->nbuckets
= 0;
13149 free (filedata
->chains
);
13150 filedata
->chains
= NULL
;
13152 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
13154 unsigned long * lengths
;
13155 unsigned long * counts
;
13157 unsigned long maxlength
= 0;
13158 unsigned long nzero_counts
= 0;
13159 unsigned long nsyms
= 0;
13161 printf (ngettext ("\nHistogram for `%s' bucket list length "
13162 "(total of %lu bucket):\n",
13163 "\nHistogram for `%s' bucket list length "
13164 "(total of %lu buckets):\n",
13165 (unsigned long) filedata
->ngnubuckets
),
13166 GNU_HASH_SECTION_NAME (filedata
),
13167 (unsigned long) filedata
->ngnubuckets
);
13169 lengths
= (unsigned long *) calloc (filedata
->ngnubuckets
,
13170 sizeof (*lengths
));
13171 if (lengths
== NULL
)
13173 error (_("Out of memory allocating space for gnu histogram buckets\n"));
13177 printf (_(" Length Number %% of total Coverage\n"));
13179 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
13180 if (filedata
->gnubuckets
[hn
] != 0)
13182 bfd_vma off
, length
= 1;
13184 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
13185 /* PR 17531 file: 010-77222-0.004. */
13186 off
< filedata
->ngnuchains
13187 && (filedata
->gnuchains
[off
] & 1) == 0;
13190 lengths
[hn
] = length
;
13191 if (length
> maxlength
)
13192 maxlength
= length
;
13196 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
13197 if (counts
== NULL
)
13200 error (_("Out of memory allocating space for gnu histogram counts\n"));
13204 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
13205 ++counts
[lengths
[hn
]];
13207 if (filedata
->ngnubuckets
> 0)
13210 printf (" 0 %-10lu (%5.1f%%)\n",
13211 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
13212 for (j
= 1; j
<= maxlength
; ++j
)
13214 nzero_counts
+= counts
[j
] * j
;
13215 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
13216 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
13217 (nzero_counts
* 100.0) / nsyms
);
13224 free (filedata
->gnubuckets
);
13225 filedata
->gnubuckets
= NULL
;
13226 filedata
->ngnubuckets
= 0;
13227 free (filedata
->gnuchains
);
13228 filedata
->gnuchains
= NULL
;
13229 filedata
->ngnuchains
= 0;
13230 free (filedata
->mipsxlat
);
13231 filedata
->mipsxlat
= NULL
;
13235 free (filedata
->gnubuckets
);
13236 filedata
->gnubuckets
= NULL
;
13237 filedata
->ngnubuckets
= 0;
13238 free (filedata
->gnuchains
);
13239 filedata
->gnuchains
= NULL
;
13240 filedata
->ngnuchains
= 0;
13241 free (filedata
->mipsxlat
);
13242 filedata
->mipsxlat
= NULL
;
13243 free (filedata
->buckets
);
13244 filedata
->buckets
= NULL
;
13245 filedata
->nbuckets
= 0;
13246 free (filedata
->chains
);
13247 filedata
->chains
= NULL
;
13252 process_syminfo (Filedata
* filedata
)
13256 if (filedata
->dynamic_syminfo
== NULL
13258 /* No syminfo, this is ok. */
13261 /* There better should be a dynamic symbol section. */
13262 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
13265 if (filedata
->is_separate
)
13266 printf (ngettext ("\nIn linked file '%s: the dynamic info segment at offset 0x%lx contains %d entry:\n",
13267 "\nIn linked file '%s: the dynamic info segment at offset 0x%lx contains %d entries:\n",
13268 filedata
->dynamic_syminfo_nent
),
13269 filedata
->file_name
,
13270 filedata
->dynamic_syminfo_offset
,
13271 filedata
->dynamic_syminfo_nent
);
13273 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
13274 "contains %d entry:\n",
13275 "\nDynamic info segment at offset 0x%lx "
13276 "contains %d entries:\n",
13277 filedata
->dynamic_syminfo_nent
),
13278 filedata
->dynamic_syminfo_offset
,
13279 filedata
->dynamic_syminfo_nent
);
13281 printf (_(" Num: Name BoundTo Flags\n"));
13282 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
13284 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
13286 printf ("%4d: ", i
);
13287 if (i
>= filedata
->num_dynamic_syms
)
13288 printf (_("<corrupt index>"));
13289 else if (VALID_DYNAMIC_NAME (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
13290 print_symbol (30, GET_DYNAMIC_NAME (filedata
,
13291 filedata
->dynamic_symbols
[i
].st_name
));
13293 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
13296 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
13298 case SYMINFO_BT_SELF
:
13299 fputs ("SELF ", stdout
);
13301 case SYMINFO_BT_PARENT
:
13302 fputs ("PARENT ", stdout
);
13305 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
13306 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
13307 && VALID_DYNAMIC_NAME (filedata
,
13308 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
13310 print_symbol (10, GET_DYNAMIC_NAME (filedata
,
13311 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
13315 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
13319 if (flags
& SYMINFO_FLG_DIRECT
)
13320 printf (" DIRECT");
13321 if (flags
& SYMINFO_FLG_PASSTHRU
)
13322 printf (" PASSTHRU");
13323 if (flags
& SYMINFO_FLG_COPY
)
13325 if (flags
& SYMINFO_FLG_LAZYLOAD
)
13326 printf (" LAZYLOAD");
13334 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
13335 is contained by the region START .. END. The types of ADDR, START
13336 and END should all be the same. Note both ADDR + NELEM and END
13337 point to just beyond the end of the regions that are being tested. */
13338 #define IN_RANGE(START,END,ADDR,NELEM) \
13339 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
13341 /* Check to see if the given reloc needs to be handled in a target specific
13342 manner. If so then process the reloc and return TRUE otherwise return
13345 If called with reloc == NULL, then this is a signal that reloc processing
13346 for the current section has finished, and any saved state should be
13350 target_specific_reloc_handling (Filedata
* filedata
,
13351 Elf_Internal_Rela
* reloc
,
13352 unsigned char * start
,
13353 unsigned char * end
,
13354 Elf_Internal_Sym
* symtab
,
13355 unsigned long num_syms
)
13357 unsigned int reloc_type
= 0;
13358 unsigned long sym_index
= 0;
13362 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
13363 sym_index
= get_reloc_symindex (reloc
->r_info
);
13366 switch (filedata
->file_header
.e_machine
)
13369 case EM_MSP430_OLD
:
13371 static Elf_Internal_Sym
* saved_sym
= NULL
;
13379 switch (reloc_type
)
13381 case 10: /* R_MSP430_SYM_DIFF */
13382 case 12: /* R_MSP430_GNU_SUB_ULEB128 */
13383 if (uses_msp430x_relocs (filedata
))
13385 /* Fall through. */
13386 case 21: /* R_MSP430X_SYM_DIFF */
13387 case 23: /* R_MSP430X_GNU_SUB_ULEB128 */
13389 if (sym_index
>= num_syms
)
13390 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
13393 saved_sym
= symtab
+ sym_index
;
13396 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
13397 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
13398 goto handle_sym_diff
;
13400 case 5: /* R_MSP430_16_BYTE */
13401 case 9: /* R_MSP430_8 */
13402 case 11: /* R_MSP430_GNU_SET_ULEB128 */
13403 if (uses_msp430x_relocs (filedata
))
13405 goto handle_sym_diff
;
13407 case 2: /* R_MSP430_ABS16 */
13408 case 15: /* R_MSP430X_ABS16 */
13409 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
13410 if (! uses_msp430x_relocs (filedata
))
13412 goto handle_sym_diff
;
13415 if (saved_sym
!= NULL
)
13418 unsigned int reloc_size
= 0;
13420 switch (reloc_type
)
13422 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
13425 case 11: /* R_MSP430_GNU_SET_ULEB128 */
13426 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
13427 if (reloc
->r_offset
< (size_t) (end
- start
))
13428 read_leb128 (start
+ reloc
->r_offset
, end
, false,
13429 &reloc_size
, &leb_ret
);
13436 if (leb_ret
!= 0 || reloc_size
== 0 || reloc_size
> 8)
13437 error (_("MSP430 ULEB128 field at 0x%lx contains invalid "
13438 "ULEB128 value\n"),
13439 (long) reloc
->r_offset
);
13440 else if (sym_index
>= num_syms
)
13441 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
13445 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
13446 - saved_sym
->st_value
);
13448 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
13449 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
13452 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
13453 (long) reloc
->r_offset
);
13462 if (saved_sym
!= NULL
)
13463 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13470 case EM_CYGNUS_MN10300
:
13472 static Elf_Internal_Sym
* saved_sym
= NULL
;
13480 switch (reloc_type
)
13482 case 34: /* R_MN10300_ALIGN */
13484 case 33: /* R_MN10300_SYM_DIFF */
13485 if (sym_index
>= num_syms
)
13486 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
13489 saved_sym
= symtab
+ sym_index
;
13492 case 1: /* R_MN10300_32 */
13493 case 2: /* R_MN10300_16 */
13494 if (saved_sym
!= NULL
)
13496 int reloc_size
= reloc_type
== 1 ? 4 : 2;
13499 if (sym_index
>= num_syms
)
13500 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
13504 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
13505 - saved_sym
->st_value
);
13507 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
13508 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
13510 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
13511 (long) reloc
->r_offset
);
13519 if (saved_sym
!= NULL
)
13520 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
13528 static bfd_vma saved_sym1
= 0;
13529 static bfd_vma saved_sym2
= 0;
13530 static bfd_vma value
;
13534 saved_sym1
= saved_sym2
= 0;
13538 switch (reloc_type
)
13540 case 0x80: /* R_RL78_SYM. */
13541 saved_sym1
= saved_sym2
;
13542 if (sym_index
>= num_syms
)
13543 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
13547 saved_sym2
= symtab
[sym_index
].st_value
;
13548 saved_sym2
+= reloc
->r_addend
;
13552 case 0x83: /* R_RL78_OPsub. */
13553 value
= saved_sym1
- saved_sym2
;
13554 saved_sym2
= saved_sym1
= 0;
13558 case 0x41: /* R_RL78_ABS32. */
13559 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
13560 byte_put (start
+ reloc
->r_offset
, value
, 4);
13562 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
13563 (long) reloc
->r_offset
);
13567 case 0x43: /* R_RL78_ABS16. */
13568 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
13569 byte_put (start
+ reloc
->r_offset
, value
, 2);
13571 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
13572 (long) reloc
->r_offset
);
13586 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
13587 DWARF debug sections. This is a target specific test. Note - we do not
13588 go through the whole including-target-headers-multiple-times route, (as
13589 we have already done with <elf/h8.h>) because this would become very
13590 messy and even then this function would have to contain target specific
13591 information (the names of the relocs instead of their numeric values).
13592 FIXME: This is not the correct way to solve this problem. The proper way
13593 is to have target specific reloc sizing and typing functions created by
13594 the reloc-macros.h header, in the same way that it already creates the
13595 reloc naming functions. */
13598 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13600 /* Please keep this table alpha-sorted for ease of visual lookup. */
13601 switch (filedata
->file_header
.e_machine
)
13605 return reloc_type
== 1; /* R_386_32. */
13607 return reloc_type
== 1; /* R_68K_32. */
13609 return reloc_type
== 1; /* R_860_32. */
13611 return reloc_type
== 2; /* R_960_32. */
13613 return (reloc_type
== 258
13614 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
13616 return reloc_type
== 11; /* R_BPF_DATA_32 */
13617 case EM_ADAPTEVA_EPIPHANY
:
13618 return reloc_type
== 3;
13620 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
13622 return reloc_type
== 1; /* R_ARC_32. */
13623 case EM_ARC_COMPACT
:
13624 case EM_ARC_COMPACT2
:
13625 return reloc_type
== 4; /* R_ARC_32. */
13627 return reloc_type
== 2; /* R_ARM_ABS32 */
13630 return reloc_type
== 1;
13632 return reloc_type
== 0x12; /* R_byte4_data. */
13634 return reloc_type
== 3; /* R_CRIS_32. */
13636 return reloc_type
== 3; /* R_CR16_NUM32. */
13638 return reloc_type
== 15; /* R_CRX_NUM32. */
13640 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
13641 case EM_CYGNUS_FRV
:
13642 return reloc_type
== 1;
13643 case EM_CYGNUS_D10V
:
13645 return reloc_type
== 6; /* R_D10V_32. */
13646 case EM_CYGNUS_D30V
:
13648 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
13650 return reloc_type
== 3; /* R_DLX_RELOC_32. */
13651 case EM_CYGNUS_FR30
:
13653 return reloc_type
== 3; /* R_FR30_32. */
13655 return reloc_type
== 1; /* R_FT32_32. */
13659 return reloc_type
== 1; /* R_H8_DIR32. */
13661 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
13662 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
13663 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
13664 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
13667 return reloc_type
== 2; /* R_IP2K_32. */
13669 return reloc_type
== 2; /* R_IQ2000_32. */
13670 case EM_LATTICEMICO32
:
13671 return reloc_type
== 3; /* R_LM32_32. */
13674 return reloc_type
== 3; /* R_M32C_32. */
13676 return reloc_type
== 34; /* R_M32R_32_RELA. */
13679 return reloc_type
== 6; /* R_M68HC11_32. */
13681 return reloc_type
== 7 || /* R_S12Z_EXT32 */
13682 reloc_type
== 6; /* R_S12Z_CW32. */
13684 return reloc_type
== 1; /* R_MCORE_ADDR32. */
13685 case EM_CYGNUS_MEP
:
13686 return reloc_type
== 4; /* R_MEP_32. */
13688 return reloc_type
== 2; /* R_METAG_ADDR32. */
13689 case EM_MICROBLAZE
:
13690 return reloc_type
== 1; /* R_MICROBLAZE_32. */
13692 return reloc_type
== 2; /* R_MIPS_32. */
13694 return reloc_type
== 4; /* R_MMIX_32. */
13695 case EM_CYGNUS_MN10200
:
13697 return reloc_type
== 1; /* R_MN10200_32. */
13698 case EM_CYGNUS_MN10300
:
13700 return reloc_type
== 1; /* R_MN10300_32. */
13702 return reloc_type
== 1; /* R_MOXIE_32. */
13703 case EM_MSP430_OLD
:
13705 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
13707 return reloc_type
== 2; /* R_MT_32. */
13709 return reloc_type
== 20; /* R_NDS32_RELA. */
13710 case EM_ALTERA_NIOS2
:
13711 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
13713 return reloc_type
== 1; /* R_NIOS_32. */
13715 return reloc_type
== 1; /* R_OR1K_32. */
13717 return (reloc_type
== 1 /* R_PARISC_DIR32. */
13718 || reloc_type
== 2 /* R_PARISC_DIR21L. */
13719 || reloc_type
== 41); /* R_PARISC_SECREL32. */
13722 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
13724 return reloc_type
== 1; /* R_PPC64_ADDR32. */
13726 return reloc_type
== 1; /* R_PPC_ADDR32. */
13728 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
13730 return reloc_type
== 1; /* R_RISCV_32. */
13732 return reloc_type
== 1; /* R_RL78_DIR32. */
13734 return reloc_type
== 1; /* R_RX_DIR32. */
13736 return reloc_type
== 1; /* R_I370_ADDR31. */
13739 return reloc_type
== 4; /* R_S390_32. */
13741 return reloc_type
== 8; /* R_SCORE_ABS32. */
13743 return reloc_type
== 1; /* R_SH_DIR32. */
13744 case EM_SPARC32PLUS
:
13747 return reloc_type
== 3 /* R_SPARC_32. */
13748 || reloc_type
== 23; /* R_SPARC_UA32. */
13750 return reloc_type
== 6; /* R_SPU_ADDR32 */
13752 return reloc_type
== 1; /* R_C6000_ABS32. */
13754 return reloc_type
== 2; /* R_TILEGX_32. */
13756 return reloc_type
== 1; /* R_TILEPRO_32. */
13757 case EM_CYGNUS_V850
:
13759 return reloc_type
== 6; /* R_V850_ABS32. */
13761 return reloc_type
== 0x33; /* R_V810_WORD. */
13763 return reloc_type
== 1; /* R_VAX_32. */
13765 return reloc_type
== 3; /* R_VISIUM_32. */
13766 case EM_WEBASSEMBLY
:
13767 return reloc_type
== 1; /* R_WASM32_32. */
13771 return reloc_type
== 10; /* R_X86_64_32. */
13774 return reloc_type
== 3; /* R_XC16C_ABS_32. */
13776 return reloc_type
== 4; /* R_XGATE_32. */
13778 return reloc_type
== 1; /* R_XSTROMY16_32. */
13779 case EM_XTENSA_OLD
:
13781 return reloc_type
== 1; /* R_XTENSA_32. */
13783 return reloc_type
== 6; /* R_Z80_32. */
13786 static unsigned int prev_warn
= 0;
13788 /* Avoid repeating the same warning multiple times. */
13789 if (prev_warn
!= filedata
->file_header
.e_machine
)
13790 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
13791 filedata
->file_header
.e_machine
);
13792 prev_warn
= filedata
->file_header
.e_machine
;
13798 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13799 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
13802 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13804 switch (filedata
->file_header
.e_machine
)
13805 /* Please keep this table alpha-sorted for ease of visual lookup. */
13809 return reloc_type
== 2; /* R_386_PC32. */
13811 return reloc_type
== 4; /* R_68K_PC32. */
13813 return reloc_type
== 261; /* R_AARCH64_PREL32 */
13814 case EM_ADAPTEVA_EPIPHANY
:
13815 return reloc_type
== 6;
13817 return reloc_type
== 10; /* R_ALPHA_SREL32. */
13818 case EM_ARC_COMPACT
:
13819 case EM_ARC_COMPACT2
:
13820 return reloc_type
== 49; /* R_ARC_32_PCREL. */
13822 return reloc_type
== 3; /* R_ARM_REL32 */
13825 return reloc_type
== 36; /* R_AVR_32_PCREL. */
13826 case EM_MICROBLAZE
:
13827 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
13829 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
13831 return reloc_type
== 9; /* R_PARISC_PCREL32. */
13833 return reloc_type
== 26; /* R_PPC_REL32. */
13835 return reloc_type
== 26; /* R_PPC64_REL32. */
13837 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
13840 return reloc_type
== 5; /* R_390_PC32. */
13842 return reloc_type
== 2; /* R_SH_REL32. */
13843 case EM_SPARC32PLUS
:
13846 return reloc_type
== 6; /* R_SPARC_DISP32. */
13848 return reloc_type
== 13; /* R_SPU_REL32. */
13850 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
13852 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
13854 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
13858 return reloc_type
== 2; /* R_X86_64_PC32. */
13860 return reloc_type
== 4; /* R_VAX_PCREL32. */
13861 case EM_XTENSA_OLD
:
13863 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
13865 /* Do not abort or issue an error message here. Not all targets use
13866 pc-relative 32-bit relocs in their DWARF debug information and we
13867 have already tested for target coverage in is_32bit_abs_reloc. A
13868 more helpful warning message will be generated by apply_relocations
13869 anyway, so just return. */
13874 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13875 a 64-bit absolute RELA relocation used in DWARF debug sections. */
13878 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13880 switch (filedata
->file_header
.e_machine
)
13883 return reloc_type
== 257; /* R_AARCH64_ABS64. */
13885 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
13887 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
13888 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
13890 return reloc_type
== 80; /* R_PARISC_DIR64. */
13892 return reloc_type
== 38; /* R_PPC64_ADDR64. */
13894 return reloc_type
== 2; /* R_RISCV_64. */
13895 case EM_SPARC32PLUS
:
13898 return reloc_type
== 32 /* R_SPARC_64. */
13899 || reloc_type
== 54; /* R_SPARC_UA64. */
13903 return reloc_type
== 1; /* R_X86_64_64. */
13906 return reloc_type
== 22; /* R_S390_64. */
13908 return reloc_type
== 1; /* R_TILEGX_64. */
13910 return reloc_type
== 18; /* R_MIPS_64. */
13916 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
13917 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
13920 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13922 switch (filedata
->file_header
.e_machine
)
13925 return reloc_type
== 260; /* R_AARCH64_PREL64. */
13927 return reloc_type
== 11; /* R_ALPHA_SREL64. */
13929 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
13930 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
13932 return reloc_type
== 72; /* R_PARISC_PCREL64. */
13934 return reloc_type
== 44; /* R_PPC64_REL64. */
13935 case EM_SPARC32PLUS
:
13938 return reloc_type
== 46; /* R_SPARC_DISP64. */
13942 return reloc_type
== 24; /* R_X86_64_PC64. */
13945 return reloc_type
== 23; /* R_S390_PC64. */
13947 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
13953 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13954 a 24-bit absolute RELA relocation used in DWARF debug sections. */
13957 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13959 switch (filedata
->file_header
.e_machine
)
13961 case EM_CYGNUS_MN10200
:
13963 return reloc_type
== 4; /* R_MN10200_24. */
13965 return reloc_type
== 5; /* R_FT32_20. */
13967 return reloc_type
== 5; /* R_Z80_24. */
13973 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13974 a 16-bit absolute RELA relocation used in DWARF debug sections. */
13977 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13979 /* Please keep this table alpha-sorted for ease of visual lookup. */
13980 switch (filedata
->file_header
.e_machine
)
13983 case EM_ARC_COMPACT
:
13984 case EM_ARC_COMPACT2
:
13985 return reloc_type
== 2; /* R_ARC_16. */
13986 case EM_ADAPTEVA_EPIPHANY
:
13987 return reloc_type
== 5;
13990 return reloc_type
== 4; /* R_AVR_16. */
13991 case EM_CYGNUS_D10V
:
13993 return reloc_type
== 3; /* R_D10V_16. */
13995 return reloc_type
== 2; /* R_FT32_16. */
13999 return reloc_type
== R_H8_DIR16
;
14002 return reloc_type
== 1; /* R_IP2K_16. */
14005 return reloc_type
== 1; /* R_M32C_16 */
14006 case EM_CYGNUS_MN10200
:
14008 return reloc_type
== 2; /* R_MN10200_16. */
14009 case EM_CYGNUS_MN10300
:
14011 return reloc_type
== 2; /* R_MN10300_16. */
14013 if (uses_msp430x_relocs (filedata
))
14014 return reloc_type
== 2; /* R_MSP430_ABS16. */
14015 /* Fall through. */
14016 case EM_MSP430_OLD
:
14017 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
14019 return reloc_type
== 19; /* R_NDS32_RELA. */
14020 case EM_ALTERA_NIOS2
:
14021 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
14023 return reloc_type
== 9; /* R_NIOS_16. */
14025 return reloc_type
== 2; /* R_OR1K_16. */
14027 return reloc_type
== 55; /* R_RISCV_SET16. */
14029 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
14031 return reloc_type
== 2; /* R_C6000_ABS16. */
14033 return reloc_type
== 2; /* R_VISIUM_16. */
14036 return reloc_type
== 2; /* R_XC16C_ABS_16. */
14038 return reloc_type
== 3; /* R_XGATE_16. */
14040 return reloc_type
== 4; /* R_Z80_16. */
14046 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14047 a 8-bit absolute RELA relocation used in DWARF debug sections. */
14050 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14052 switch (filedata
->file_header
.e_machine
)
14055 return reloc_type
== 54; /* R_RISCV_SET8. */
14057 return reloc_type
== 1; /* R_Z80_8. */
14063 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14064 a 6-bit absolute RELA relocation used in DWARF debug sections. */
14067 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14069 switch (filedata
->file_header
.e_machine
)
14072 return reloc_type
== 53; /* R_RISCV_SET6. */
14078 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14079 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
14082 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14084 /* Please keep this table alpha-sorted for ease of visual lookup. */
14085 switch (filedata
->file_header
.e_machine
)
14088 return reloc_type
== 35; /* R_RISCV_ADD32. */
14094 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14095 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
14098 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14100 /* Please keep this table alpha-sorted for ease of visual lookup. */
14101 switch (filedata
->file_header
.e_machine
)
14104 return reloc_type
== 39; /* R_RISCV_SUB32. */
14110 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14111 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
14114 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14116 /* Please keep this table alpha-sorted for ease of visual lookup. */
14117 switch (filedata
->file_header
.e_machine
)
14120 return reloc_type
== 36; /* R_RISCV_ADD64. */
14126 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14127 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
14130 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14132 /* Please keep this table alpha-sorted for ease of visual lookup. */
14133 switch (filedata
->file_header
.e_machine
)
14136 return reloc_type
== 40; /* R_RISCV_SUB64. */
14142 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14143 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
14146 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14148 /* Please keep this table alpha-sorted for ease of visual lookup. */
14149 switch (filedata
->file_header
.e_machine
)
14152 return reloc_type
== 34; /* R_RISCV_ADD16. */
14158 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14159 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
14162 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14164 /* Please keep this table alpha-sorted for ease of visual lookup. */
14165 switch (filedata
->file_header
.e_machine
)
14168 return reloc_type
== 38; /* R_RISCV_SUB16. */
14174 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14175 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
14178 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14180 /* Please keep this table alpha-sorted for ease of visual lookup. */
14181 switch (filedata
->file_header
.e_machine
)
14184 return reloc_type
== 33; /* R_RISCV_ADD8. */
14190 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14191 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
14194 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14196 /* Please keep this table alpha-sorted for ease of visual lookup. */
14197 switch (filedata
->file_header
.e_machine
)
14200 return reloc_type
== 37; /* R_RISCV_SUB8. */
14206 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
14207 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
14210 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14212 switch (filedata
->file_header
.e_machine
)
14215 return reloc_type
== 52; /* R_RISCV_SUB6. */
14221 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
14222 relocation entries (possibly formerly used for SHT_GROUP sections). */
14225 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
14227 switch (filedata
->file_header
.e_machine
)
14229 case EM_386
: /* R_386_NONE. */
14230 case EM_68K
: /* R_68K_NONE. */
14231 case EM_ADAPTEVA_EPIPHANY
:
14232 case EM_ALPHA
: /* R_ALPHA_NONE. */
14233 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
14234 case EM_ARC
: /* R_ARC_NONE. */
14235 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
14236 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
14237 case EM_ARM
: /* R_ARM_NONE. */
14238 case EM_C166
: /* R_XC16X_NONE. */
14239 case EM_CRIS
: /* R_CRIS_NONE. */
14240 case EM_FT32
: /* R_FT32_NONE. */
14241 case EM_IA_64
: /* R_IA64_NONE. */
14242 case EM_K1OM
: /* R_X86_64_NONE. */
14243 case EM_L1OM
: /* R_X86_64_NONE. */
14244 case EM_M32R
: /* R_M32R_NONE. */
14245 case EM_MIPS
: /* R_MIPS_NONE. */
14246 case EM_MN10300
: /* R_MN10300_NONE. */
14247 case EM_MOXIE
: /* R_MOXIE_NONE. */
14248 case EM_NIOS32
: /* R_NIOS_NONE. */
14249 case EM_OR1K
: /* R_OR1K_NONE. */
14250 case EM_PARISC
: /* R_PARISC_NONE. */
14251 case EM_PPC64
: /* R_PPC64_NONE. */
14252 case EM_PPC
: /* R_PPC_NONE. */
14253 case EM_RISCV
: /* R_RISCV_NONE. */
14254 case EM_S390
: /* R_390_NONE. */
14256 case EM_SH
: /* R_SH_NONE. */
14257 case EM_SPARC32PLUS
:
14258 case EM_SPARC
: /* R_SPARC_NONE. */
14260 case EM_TILEGX
: /* R_TILEGX_NONE. */
14261 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
14262 case EM_TI_C6000
:/* R_C6000_NONE. */
14263 case EM_X86_64
: /* R_X86_64_NONE. */
14265 case EM_Z80
: /* R_Z80_NONE. */
14266 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
14267 return reloc_type
== 0;
14270 return reloc_type
== 0 || reloc_type
== 256;
14273 return (reloc_type
== 0 /* R_AVR_NONE. */
14274 || reloc_type
== 30 /* R_AVR_DIFF8. */
14275 || reloc_type
== 31 /* R_AVR_DIFF16. */
14276 || reloc_type
== 32 /* R_AVR_DIFF32. */);
14278 return reloc_type
== 3; /* R_METAG_NONE. */
14280 return (reloc_type
== 0 /* R_XTENSA_NONE. */
14281 || reloc_type
== 204 /* R_NDS32_DIFF8. */
14282 || reloc_type
== 205 /* R_NDS32_DIFF16. */
14283 || reloc_type
== 206 /* R_NDS32_DIFF32. */
14284 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
14286 return (reloc_type
== 0 /* R_PRU_NONE. */
14287 || reloc_type
== 65 /* R_PRU_DIFF8. */
14288 || reloc_type
== 66 /* R_PRU_DIFF16. */
14289 || reloc_type
== 67 /* R_PRU_DIFF32. */);
14290 case EM_XTENSA_OLD
:
14292 return (reloc_type
== 0 /* R_XTENSA_NONE. */
14293 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
14294 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
14295 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
14296 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
14297 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
14298 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
14299 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
14300 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
14301 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
14306 /* Returns TRUE if there is a relocation against
14307 section NAME at OFFSET bytes. */
14310 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
14312 Elf_Internal_Rela
* relocs
;
14313 Elf_Internal_Rela
* rp
;
14315 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
14318 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
14320 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
14321 if (rp
->r_offset
== offset
)
14327 /* Apply relocations to a section.
14328 Returns TRUE upon success, FALSE otherwise.
14329 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
14330 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
14331 will be set to the number of relocs loaded.
14333 Note: So far support has been added only for those relocations
14334 which can be found in debug sections. FIXME: Add support for
14335 more relocations ? */
14338 apply_relocations (Filedata
* filedata
,
14339 const Elf_Internal_Shdr
* section
,
14340 unsigned char * start
,
14341 bfd_size_type size
,
14342 void ** relocs_return
,
14343 unsigned long * num_relocs_return
)
14345 Elf_Internal_Shdr
* relsec
;
14346 unsigned char * end
= start
+ size
;
14348 if (relocs_return
!= NULL
)
14350 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
14351 * num_relocs_return
= 0;
14354 if (filedata
->file_header
.e_type
!= ET_REL
)
14355 /* No relocs to apply. */
14358 /* Find the reloc section associated with the section. */
14359 for (relsec
= filedata
->section_headers
;
14360 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14364 unsigned long num_relocs
;
14365 Elf_Internal_Rela
* relocs
;
14366 Elf_Internal_Rela
* rp
;
14367 Elf_Internal_Shdr
* symsec
;
14368 Elf_Internal_Sym
* symtab
;
14369 unsigned long num_syms
;
14370 Elf_Internal_Sym
* sym
;
14372 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14373 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14374 || filedata
->section_headers
+ relsec
->sh_info
!= section
14375 || relsec
->sh_size
== 0
14376 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14379 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
14380 if (symsec
->sh_type
!= SHT_SYMTAB
14381 && symsec
->sh_type
!= SHT_DYNSYM
)
14384 is_rela
= relsec
->sh_type
== SHT_RELA
;
14388 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
14389 relsec
->sh_size
, & relocs
, & num_relocs
))
14394 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
14395 relsec
->sh_size
, & relocs
, & num_relocs
))
14399 /* SH uses RELA but uses in place value instead of the addend field. */
14400 if (filedata
->file_header
.e_machine
== EM_SH
)
14403 symtab
= get_elf_symbols (filedata
, symsec
, & num_syms
);
14405 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
14408 unsigned int reloc_type
;
14409 unsigned int reloc_size
;
14410 bool reloc_inplace
= false;
14411 bool reloc_subtract
= false;
14412 unsigned char *rloc
;
14413 unsigned long sym_index
;
14415 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
14417 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
14419 else if (is_none_reloc (filedata
, reloc_type
))
14421 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
14422 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
14424 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
14425 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
14427 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
14429 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
14431 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
14432 || is_6bit_abs_reloc (filedata
, reloc_type
))
14434 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
14436 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
14439 reloc_inplace
= true;
14441 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
14443 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
14446 reloc_inplace
= true;
14448 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
14450 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
14453 reloc_inplace
= true;
14455 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
14457 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
14460 reloc_inplace
= true;
14462 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
14466 reloc_inplace
= true;
14470 static unsigned int prev_reloc
= 0;
14472 if (reloc_type
!= prev_reloc
)
14473 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
14474 reloc_type
, printable_section_name (filedata
, section
));
14475 prev_reloc
= reloc_type
;
14479 rloc
= start
+ rp
->r_offset
;
14480 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
14482 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
14483 (unsigned long) rp
->r_offset
,
14484 printable_section_name (filedata
, section
));
14488 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
14489 if (sym_index
>= num_syms
)
14491 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
14492 sym_index
, printable_section_name (filedata
, section
));
14495 sym
= symtab
+ sym_index
;
14497 /* If the reloc has a symbol associated with it,
14498 make sure that it is of an appropriate type.
14500 Relocations against symbols without type can happen.
14501 Gcc -feliminate-dwarf2-dups may generate symbols
14502 without type for debug info.
14504 Icc generates relocations against function symbols
14505 instead of local labels.
14507 Relocations against object symbols can happen, eg when
14508 referencing a global array. For an example of this see
14509 the _clz.o binary in libgcc.a. */
14511 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
14512 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
14514 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
14515 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
14516 printable_section_name (filedata
, relsec
),
14517 (long int)(rp
- relocs
));
14523 addend
+= rp
->r_addend
;
14524 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
14525 partial_inplace. */
14527 || (filedata
->file_header
.e_machine
== EM_XTENSA
14528 && reloc_type
== 1)
14529 || ((filedata
->file_header
.e_machine
== EM_PJ
14530 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
14531 && reloc_type
== 1)
14532 || ((filedata
->file_header
.e_machine
== EM_D30V
14533 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
14534 && reloc_type
== 12)
14537 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
14538 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
14540 addend
+= byte_get (rloc
, reloc_size
);
14543 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
14544 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
14546 /* On HPPA, all pc-relative relocations are biased by 8. */
14547 if (filedata
->file_header
.e_machine
== EM_PARISC
)
14549 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
14552 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
14553 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
14555 if (reloc_subtract
)
14556 addend
-= sym
->st_value
;
14558 addend
+= sym
->st_value
;
14559 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
14560 byte_put (rloc
, addend
, reloc_size
);
14562 else if (reloc_subtract
)
14563 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
14565 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
14569 /* Let the target specific reloc processing code know that
14570 we have finished with these relocs. */
14571 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
14575 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
14576 * num_relocs_return
= num_relocs
;
14587 #ifdef SUPPORT_DISASSEMBLY
14589 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14591 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
14593 /* FIXME: XXX -- to be done --- XXX */
14599 /* Reads in the contents of SECTION from FILE, returning a pointer
14600 to a malloc'ed buffer or NULL if something went wrong. */
14603 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14605 bfd_size_type num_bytes
= section
->sh_size
;
14607 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
14609 printf (_("Section '%s' has no data to dump.\n"),
14610 printable_section_name (filedata
, section
));
14614 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
14615 _("section contents"));
14618 /* Uncompresses a section that was compressed using zlib, in place. */
14621 uncompress_section_contents (unsigned char ** buffer
,
14622 dwarf_size_type uncompressed_size
,
14623 dwarf_size_type
* size
)
14625 dwarf_size_type compressed_size
= *size
;
14626 unsigned char * compressed_buffer
= *buffer
;
14627 unsigned char * uncompressed_buffer
;
14631 /* It is possible the section consists of several compressed
14632 buffers concatenated together, so we uncompress in a loop. */
14633 /* PR 18313: The state field in the z_stream structure is supposed
14634 to be invisible to the user (ie us), but some compilers will
14635 still complain about it being used without initialisation. So
14636 we first zero the entire z_stream structure and then set the fields
14638 memset (& strm
, 0, sizeof strm
);
14639 strm
.avail_in
= compressed_size
;
14640 strm
.next_in
= (Bytef
*) compressed_buffer
;
14641 strm
.avail_out
= uncompressed_size
;
14642 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
14644 rc
= inflateInit (& strm
);
14645 while (strm
.avail_in
> 0)
14649 strm
.next_out
= ((Bytef
*) uncompressed_buffer
14650 + (uncompressed_size
- strm
.avail_out
));
14651 rc
= inflate (&strm
, Z_FINISH
);
14652 if (rc
!= Z_STREAM_END
)
14654 rc
= inflateReset (& strm
);
14656 if (inflateEnd (& strm
) != Z_OK
14658 || strm
.avail_out
!= 0)
14661 *buffer
= uncompressed_buffer
;
14662 *size
= uncompressed_size
;
14666 free (uncompressed_buffer
);
14667 /* Indicate decompression failure. */
14673 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14675 Elf_Internal_Shdr
*relsec
;
14676 bfd_size_type num_bytes
;
14677 unsigned char *data
;
14678 unsigned char *end
;
14679 unsigned char *real_start
;
14680 unsigned char *start
;
14681 bool some_strings_shown
;
14683 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
14685 /* PR 21820: Do not fail if the section was empty. */
14686 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
14688 num_bytes
= section
->sh_size
;
14690 if (filedata
->is_separate
)
14691 printf (_("\nString dump of section '%s' in linked file %s:\n"),
14692 printable_section_name (filedata
, section
),
14693 filedata
->file_name
);
14695 printf (_("\nString dump of section '%s':\n"),
14696 printable_section_name (filedata
, section
));
14698 if (decompress_dumps
)
14700 dwarf_size_type new_size
= num_bytes
;
14701 dwarf_size_type uncompressed_size
= 0;
14703 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14705 Elf_Internal_Chdr chdr
;
14706 unsigned int compression_header_size
14707 = get_compression_header (& chdr
, (unsigned char *) start
,
14709 if (compression_header_size
== 0)
14710 /* An error message will have already been generated
14711 by get_compression_header. */
14714 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14716 warn (_("section '%s' has unsupported compress type: %d\n"),
14717 printable_section_name (filedata
, section
), chdr
.ch_type
);
14720 uncompressed_size
= chdr
.ch_size
;
14721 start
+= compression_header_size
;
14722 new_size
-= compression_header_size
;
14724 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14726 /* Read the zlib header. In this case, it should be "ZLIB"
14727 followed by the uncompressed section size, 8 bytes in
14728 big-endian order. */
14729 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14730 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14731 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14732 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14733 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14734 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14735 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14736 uncompressed_size
+= start
[11];
14741 if (uncompressed_size
)
14743 if (uncompress_section_contents (& start
,
14744 uncompressed_size
, & new_size
))
14745 num_bytes
= new_size
;
14748 error (_("Unable to decompress section %s\n"),
14749 printable_section_name (filedata
, section
));
14754 start
= real_start
;
14757 /* If the section being dumped has relocations against it the user might
14758 be expecting these relocations to have been applied. Check for this
14759 case and issue a warning message in order to avoid confusion.
14760 FIXME: Maybe we ought to have an option that dumps a section with
14761 relocs applied ? */
14762 for (relsec
= filedata
->section_headers
;
14763 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14766 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14767 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14768 || filedata
->section_headers
+ relsec
->sh_info
!= section
14769 || relsec
->sh_size
== 0
14770 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14773 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14778 end
= start
+ num_bytes
;
14779 some_strings_shown
= false;
14781 #ifdef HAVE_MBSTATE_T
14783 /* Initialise the multibyte conversion state. */
14784 memset (& state
, 0, sizeof (state
));
14787 bool continuing
= false;
14791 while (!ISPRINT (* data
))
14792 if (++ data
>= end
)
14797 size_t maxlen
= end
- data
;
14802 continuing
= false;
14806 printf (" [%6lx] ", (unsigned long) (data
- start
));
14820 /* PR 25543: Treat new-lines as string-ending characters. */
14829 /* Do not print control characters directly as they can affect terminal
14830 settings. Such characters usually appear in the names generated
14831 by the assembler for local labels. */
14834 printf ("^%c", c
+ 0x40);
14836 else if (ISPRINT (c
))
14843 #ifdef HAVE_MBSTATE_T
14846 /* Let printf do the hard work of displaying multibyte characters. */
14847 printf ("%.1s", data
- 1);
14848 #ifdef HAVE_MBSTATE_T
14849 /* Try to find out how many bytes made up the character that was
14850 just printed. Advance the symbol pointer past the bytes that
14852 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
14856 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
14866 printf (_("<corrupt>\n"));
14869 some_strings_shown
= true;
14873 if (! some_strings_shown
)
14874 printf (_(" No strings found in this section."));
14887 dump_section_as_bytes (Elf_Internal_Shdr
*section
,
14888 Filedata
*filedata
,
14891 Elf_Internal_Shdr
* relsec
;
14892 bfd_size_type bytes
;
14893 bfd_size_type section_size
;
14895 unsigned char * data
;
14896 unsigned char * real_start
;
14897 unsigned char * start
;
14899 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
14901 /* PR 21820: Do not fail if the section was empty. */
14902 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
14904 section_size
= section
->sh_size
;
14906 if (filedata
->is_separate
)
14907 printf (_("\nHex dump of section '%s' in linked file %s:\n"),
14908 printable_section_name (filedata
, section
),
14909 filedata
->file_name
);
14911 printf (_("\nHex dump of section '%s':\n"),
14912 printable_section_name (filedata
, section
));
14914 if (decompress_dumps
)
14916 dwarf_size_type new_size
= section_size
;
14917 dwarf_size_type uncompressed_size
= 0;
14919 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14921 Elf_Internal_Chdr chdr
;
14922 unsigned int compression_header_size
14923 = get_compression_header (& chdr
, start
, section_size
);
14925 if (compression_header_size
== 0)
14926 /* An error message will have already been generated
14927 by get_compression_header. */
14930 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14932 warn (_("section '%s' has unsupported compress type: %d\n"),
14933 printable_section_name (filedata
, section
), chdr
.ch_type
);
14936 uncompressed_size
= chdr
.ch_size
;
14937 start
+= compression_header_size
;
14938 new_size
-= compression_header_size
;
14940 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14942 /* Read the zlib header. In this case, it should be "ZLIB"
14943 followed by the uncompressed section size, 8 bytes in
14944 big-endian order. */
14945 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14946 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14947 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14948 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14949 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14950 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14951 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14952 uncompressed_size
+= start
[11];
14957 if (uncompressed_size
)
14959 if (uncompress_section_contents (& start
, uncompressed_size
,
14962 section_size
= new_size
;
14966 error (_("Unable to decompress section %s\n"),
14967 printable_section_name (filedata
, section
));
14968 /* FIXME: Print the section anyway ? */
14973 start
= real_start
;
14978 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
14983 /* If the section being dumped has relocations against it the user might
14984 be expecting these relocations to have been applied. Check for this
14985 case and issue a warning message in order to avoid confusion.
14986 FIXME: Maybe we ought to have an option that dumps a section with
14987 relocs applied ? */
14988 for (relsec
= filedata
->section_headers
;
14989 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14992 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14993 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14994 || filedata
->section_headers
+ relsec
->sh_info
!= section
14995 || relsec
->sh_size
== 0
14996 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14999 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
15004 addr
= section
->sh_addr
;
15005 bytes
= section_size
;
15014 lbytes
= (bytes
> 16 ? 16 : bytes
);
15016 printf (" 0x%8.8lx ", (unsigned long) addr
);
15018 for (j
= 0; j
< 16; j
++)
15021 printf ("%2.2x", data
[j
]);
15029 for (j
= 0; j
< lbytes
; j
++)
15032 if (k
>= ' ' && k
< 0x7f)
15055 #ifdef ENABLE_LIBCTF
15056 static ctf_sect_t
*
15057 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
15059 buf
->cts_name
= SECTION_NAME_PRINT (shdr
);
15060 buf
->cts_size
= shdr
->sh_size
;
15061 buf
->cts_entsize
= shdr
->sh_entsize
;
15066 /* Formatting callback function passed to ctf_dump. Returns either the pointer
15067 it is passed, or a pointer to newly-allocated storage, in which case
15068 dump_ctf() will free it when it no longer needs it. */
15071 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
15072 char *s
, void *arg
)
15074 const char *blanks
= arg
;
15077 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
15082 /* Dump CTF errors/warnings. */
15084 dump_ctf_errs (ctf_dict_t
*fp
)
15086 ctf_next_t
*it
= NULL
;
15091 /* Dump accumulated errors and warnings. */
15092 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
15094 error (_("%s: %s"), is_warning
? _("warning"): _("error"),
15098 if (err
!= ECTF_NEXT_END
)
15099 error (_("CTF error: cannot get CTF errors: `%s'"), ctf_errmsg (err
));
15102 /* Dump one CTF archive member. */
15105 dump_ctf_archive_member (ctf_dict_t
*ctf
, const char *name
, void *arg
)
15107 ctf_dict_t
*parent
= (ctf_dict_t
*) arg
;
15108 const char *things
[] = {"Header", "Labels", "Data objects",
15109 "Function objects", "Variables", "Types", "Strings",
15111 const char **thing
;
15115 /* Only print out the name of non-default-named archive members.
15116 The name .ctf appears everywhere, even for things that aren't
15117 really archives, so printing it out is liable to be confusing.
15119 The parent, if there is one, is the default-owned archive member:
15120 avoid importing it into itself. (This does no harm, but looks
15123 if (strcmp (name
, ".ctf") != 0)
15125 printf (_("\nCTF archive member: %s:\n"), name
);
15126 ctf_import (ctf
, parent
);
15129 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
15131 ctf_dump_state_t
*s
= NULL
;
15134 printf ("\n %s:\n", *thing
);
15135 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
15136 (void *) " ")) != NULL
)
15138 printf ("%s\n", item
);
15142 if (ctf_errno (ctf
))
15144 error (_("Iteration failed: %s, %s\n"), *thing
,
15145 ctf_errmsg (ctf_errno (ctf
)));
15152 dump_ctf_errs (ctf
);
15157 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15159 Elf_Internal_Shdr
* parent_sec
= NULL
;
15160 Elf_Internal_Shdr
* symtab_sec
= NULL
;
15161 Elf_Internal_Shdr
* strtab_sec
= NULL
;
15162 void * data
= NULL
;
15163 void * symdata
= NULL
;
15164 void * strdata
= NULL
;
15165 void * parentdata
= NULL
;
15166 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
15167 ctf_sect_t
* symsectp
= NULL
;
15168 ctf_sect_t
* strsectp
= NULL
;
15169 ctf_archive_t
* ctfa
= NULL
;
15170 ctf_archive_t
* parenta
= NULL
, *lookparent
;
15171 ctf_dict_t
* parent
= NULL
;
15176 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
15177 data
= get_section_contents (section
, filedata
);
15178 ctfsect
.cts_data
= data
;
15180 if (!dump_ctf_symtab_name
)
15181 dump_ctf_symtab_name
= strdup (".dynsym");
15183 if (!dump_ctf_strtab_name
)
15184 dump_ctf_strtab_name
= strdup (".dynstr");
15186 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
15188 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
15190 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
15193 if ((symdata
= (void *) get_data (NULL
, filedata
,
15194 symtab_sec
->sh_offset
, 1,
15195 symtab_sec
->sh_size
,
15196 _("symbols"))) == NULL
)
15198 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
15199 symsect
.cts_data
= symdata
;
15202 if (dump_ctf_strtab_name
&& dump_ctf_strtab_name
[0] != 0)
15204 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
15206 error (_("No string table section named %s\n"),
15207 dump_ctf_strtab_name
);
15210 if ((strdata
= (void *) get_data (NULL
, filedata
,
15211 strtab_sec
->sh_offset
, 1,
15212 strtab_sec
->sh_size
,
15213 _("strings"))) == NULL
)
15215 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
15216 strsect
.cts_data
= strdata
;
15219 if (dump_ctf_parent_name
)
15221 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
15223 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
15226 if ((parentdata
= (void *) get_data (NULL
, filedata
,
15227 parent_sec
->sh_offset
, 1,
15228 parent_sec
->sh_size
,
15229 _("CTF parent"))) == NULL
)
15231 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
15232 parentsect
.cts_data
= parentdata
;
15235 /* Load the CTF file and dump it. It may be a raw CTF section, or an archive:
15236 libctf papers over the difference, so we can pretend it is always an
15237 archive. Possibly open the parent as well, if one was specified. */
15239 if ((ctfa
= ctf_arc_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
15241 dump_ctf_errs (NULL
);
15242 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15246 ctf_arc_symsect_endianness (ctfa
, filedata
->file_header
.e_ident
[EI_DATA
]
15251 if ((parenta
= ctf_arc_bufopen (&parentsect
, symsectp
, strsectp
,
15254 dump_ctf_errs (NULL
);
15255 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15258 lookparent
= parenta
;
15263 /* Assume that the applicable parent archive member is the default one.
15264 (This is what all known implementations are expected to do, if they
15265 put CTFs and their parents in archives together.) */
15266 if ((parent
= ctf_dict_open (lookparent
, NULL
, &err
)) == NULL
)
15268 dump_ctf_errs (NULL
);
15269 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15275 if (filedata
->is_separate
)
15276 printf (_("\nDump of CTF section '%s' in linked file %s:\n"),
15277 printable_section_name (filedata
, section
),
15278 filedata
->file_name
);
15280 printf (_("\nDump of CTF section '%s':\n"),
15281 printable_section_name (filedata
, section
));
15283 if ((err
= ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
)) != 0)
15285 dump_ctf_errs (NULL
);
15286 error (_("CTF member open failure: %s\n"), ctf_errmsg (err
));
15291 ctf_dict_close (parent
);
15293 ctf_close (parenta
);
15303 load_specific_debug_section (enum dwarf_section_display_enum debug
,
15304 const Elf_Internal_Shdr
* sec
,
15307 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15309 Filedata
* filedata
= (Filedata
*) data
;
15311 if (section
->start
!= NULL
)
15313 /* If it is already loaded, do nothing. */
15314 if (streq (section
->filename
, filedata
->file_name
))
15316 free (section
->start
);
15319 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
15320 section
->address
= sec
->sh_addr
;
15321 section
->filename
= filedata
->file_name
;
15322 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
15324 sec
->sh_size
, buf
);
15325 if (section
->start
== NULL
)
15329 unsigned char *start
= section
->start
;
15330 dwarf_size_type size
= sec
->sh_size
;
15331 dwarf_size_type uncompressed_size
= 0;
15333 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
15335 Elf_Internal_Chdr chdr
;
15336 unsigned int compression_header_size
;
15338 if (size
< (is_32bit_elf
15339 ? sizeof (Elf32_External_Chdr
)
15340 : sizeof (Elf64_External_Chdr
)))
15342 warn (_("compressed section %s is too small to contain a compression header\n"),
15347 compression_header_size
= get_compression_header (&chdr
, start
, size
);
15348 if (compression_header_size
== 0)
15349 /* An error message will have already been generated
15350 by get_compression_header. */
15353 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
15355 warn (_("section '%s' has unsupported compress type: %d\n"),
15356 section
->name
, chdr
.ch_type
);
15359 uncompressed_size
= chdr
.ch_size
;
15360 start
+= compression_header_size
;
15361 size
-= compression_header_size
;
15363 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
15365 /* Read the zlib header. In this case, it should be "ZLIB"
15366 followed by the uncompressed section size, 8 bytes in
15367 big-endian order. */
15368 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
15369 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
15370 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
15371 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
15372 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
15373 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
15374 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
15375 uncompressed_size
+= start
[11];
15380 if (uncompressed_size
)
15382 if (uncompress_section_contents (&start
, uncompressed_size
,
15385 /* Free the compressed buffer, update the section buffer
15386 and the section size if uncompress is successful. */
15387 free (section
->start
);
15388 section
->start
= start
;
15392 error (_("Unable to decompress section %s\n"),
15393 printable_section_name (filedata
, sec
));
15398 section
->size
= size
;
15401 if (section
->start
== NULL
)
15404 if (debug_displays
[debug
].relocate
)
15406 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
15407 & section
->reloc_info
, & section
->num_relocs
))
15412 section
->reloc_info
= NULL
;
15413 section
->num_relocs
= 0;
15419 #if HAVE_LIBDEBUGINFOD
15420 /* Return a hex string representation of the build-id. */
15422 get_build_id (void * data
)
15424 Filedata
* filedata
= (Filedata
*) data
;
15425 Elf_Internal_Shdr
* shdr
;
15428 /* Iterate through notes to find note.gnu.build-id.
15429 FIXME: Only the first note in any note section is examined. */
15430 for (i
= 0, shdr
= filedata
->section_headers
;
15431 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
15434 if (shdr
->sh_type
!= SHT_NOTE
)
15439 size_t data_remaining
;
15441 Elf_External_Note
* enote
;
15442 Elf_Internal_Note inote
;
15444 bfd_vma offset
= shdr
->sh_offset
;
15445 bfd_vma align
= shdr
->sh_addralign
;
15446 bfd_vma length
= shdr
->sh_size
;
15448 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
15454 else if (align
!= 4 && align
!= 8)
15460 end
= (char *) enote
+ length
;
15461 data_remaining
= end
- (char *) enote
;
15463 if (!is_ia64_vms (filedata
))
15465 min_notesz
= offsetof (Elf_External_Note
, name
);
15466 if (data_remaining
< min_notesz
)
15469 malformed note encountered in section %s whilst scanning for build-id note\n"),
15470 printable_section_name (filedata
, shdr
));
15474 data_remaining
-= min_notesz
;
15476 inote
.type
= BYTE_GET (enote
->type
);
15477 inote
.namesz
= BYTE_GET (enote
->namesz
);
15478 inote
.namedata
= enote
->name
;
15479 inote
.descsz
= BYTE_GET (enote
->descsz
);
15480 inote
.descdata
= ((char *) enote
15481 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
15482 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
15483 next
= ((char *) enote
15484 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
15488 Elf64_External_VMS_Note
*vms_enote
;
15490 /* PR binutils/15191
15491 Make sure that there is enough data to read. */
15492 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
15493 if (data_remaining
< min_notesz
)
15496 malformed note encountered in section %s whilst scanning for build-id note\n"),
15497 printable_section_name (filedata
, shdr
));
15501 data_remaining
-= min_notesz
;
15503 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
15504 inote
.type
= BYTE_GET (vms_enote
->type
);
15505 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
15506 inote
.namedata
= vms_enote
->name
;
15507 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
15508 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
15509 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
15510 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
15513 /* Skip malformed notes. */
15514 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
15515 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
15516 || (size_t) (next
- inote
.descdata
) < inote
.descsz
15517 || ((size_t) (next
- inote
.descdata
)
15518 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
15521 malformed note encountered in section %s whilst scanning for build-id note\n"),
15522 printable_section_name (filedata
, shdr
));
15527 /* Check if this is the build-id note. If so then convert the build-id
15528 bytes to a hex string. */
15529 if (inote
.namesz
> 0
15530 && startswith (inote
.namedata
, "GNU")
15531 && inote
.type
== NT_GNU_BUILD_ID
)
15536 build_id
= malloc (inote
.descsz
* 2 + 1);
15537 if (build_id
== NULL
)
15543 for (j
= 0; j
< inote
.descsz
; ++j
)
15544 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
15545 build_id
[inote
.descsz
* 2] = '\0';
15548 return (unsigned char *) build_id
;
15555 #endif /* HAVE_LIBDEBUGINFOD */
15557 /* If this is not NULL, load_debug_section will only look for sections
15558 within the list of sections given here. */
15559 static unsigned int * section_subset
= NULL
;
15562 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
15564 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15565 Elf_Internal_Shdr
* sec
;
15566 Filedata
* filedata
= (Filedata
*) data
;
15568 /* Without section headers we cannot find any sections. */
15569 if (filedata
->section_headers
== NULL
)
15572 if (filedata
->string_table
== NULL
15573 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
15574 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
15576 Elf_Internal_Shdr
* strs
;
15578 /* Read in the string table, so that we have section names to scan. */
15579 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
15581 if (strs
!= NULL
&& strs
->sh_size
!= 0)
15583 filedata
->string_table
15584 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
15585 1, strs
->sh_size
, _("string table"));
15587 filedata
->string_table_length
15588 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
15592 /* Locate the debug section. */
15593 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
15595 section
->name
= section
->uncompressed_name
;
15598 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
15600 section
->name
= section
->compressed_name
;
15605 /* If we're loading from a subset of sections, and we've loaded
15606 a section matching this name before, it's likely that it's a
15608 if (section_subset
!= NULL
)
15609 free_debug_section (debug
);
15611 return load_specific_debug_section (debug
, sec
, data
);
15615 free_debug_section (enum dwarf_section_display_enum debug
)
15617 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15619 if (section
->start
== NULL
)
15622 free ((char *) section
->start
);
15623 section
->start
= NULL
;
15624 section
->address
= 0;
15627 free (section
->reloc_info
);
15628 section
->reloc_info
= NULL
;
15629 section
->num_relocs
= 0;
15633 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15635 char * name
= SECTION_NAME_VALID (section
) ? SECTION_NAME (section
) : "";
15636 const char * print_name
= printable_section_name (filedata
, section
);
15637 bfd_size_type length
;
15638 bool result
= true;
15641 length
= section
->sh_size
;
15644 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
15647 if (section
->sh_type
== SHT_NOBITS
)
15649 /* There is no point in dumping the contents of a debugging section
15650 which has the NOBITS type - the bits in the file will be random.
15651 This can happen when a file containing a .eh_frame section is
15652 stripped with the --only-keep-debug command line option. */
15653 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
15658 if (startswith (name
, ".gnu.linkonce.wi."))
15659 name
= ".debug_info";
15661 /* See if we know how to display the contents of this section. */
15662 for (i
= 0; i
< max
; i
++)
15664 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
15665 struct dwarf_section_display
* display
= debug_displays
+ i
;
15666 struct dwarf_section
* sec
= & display
->section
;
15668 if (streq (sec
->uncompressed_name
, name
)
15669 || (id
== line
&& startswith (name
, ".debug_line."))
15670 || streq (sec
->compressed_name
, name
))
15672 bool secondary
= (section
!= find_section (filedata
, name
));
15675 free_debug_section (id
);
15677 if (i
== line
&& startswith (name
, ".debug_line."))
15679 else if (streq (sec
->uncompressed_name
, name
))
15680 sec
->name
= sec
->uncompressed_name
;
15682 sec
->name
= sec
->compressed_name
;
15684 if (load_specific_debug_section (id
, section
, filedata
))
15686 /* If this debug section is part of a CU/TU set in a .dwp file,
15687 restrict load_debug_section to the sections in that set. */
15688 section_subset
= find_cu_tu_set (filedata
, shndx
);
15690 result
&= display
->display (sec
, filedata
);
15692 section_subset
= NULL
;
15694 if (secondary
|| (id
!= info
&& id
!= abbrev
&& id
!= debug_addr
))
15695 free_debug_section (id
);
15703 printf (_("Unrecognized debug section: %s\n"), print_name
);
15710 /* Set DUMP_SECTS for all sections where dumps were requested
15711 based on section name. */
15714 initialise_dumps_byname (Filedata
* filedata
)
15716 struct dump_list_entry
* cur
;
15718 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
15723 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
15724 if (SECTION_NAME_VALID (filedata
->section_headers
+ i
)
15725 && streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
15727 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
15731 if (!any
&& !filedata
->is_separate
)
15732 warn (_("Section '%s' was not dumped because it does not exist\n"),
15738 process_section_contents (Filedata
* filedata
)
15740 Elf_Internal_Shdr
* section
;
15747 initialise_dumps_byname (filedata
);
15749 for (i
= 0, section
= filedata
->section_headers
;
15750 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
15753 dump_type dump
= filedata
->dump
.dump_sects
[i
];
15755 if (filedata
->is_separate
&& ! process_links
)
15756 dump
&= DEBUG_DUMP
;
15758 #ifdef SUPPORT_DISASSEMBLY
15759 if (dump
& DISASS_DUMP
)
15761 if (! disassemble_section (section
, filedata
))
15765 if (dump
& HEX_DUMP
)
15767 if (! dump_section_as_bytes (section
, filedata
, false))
15771 if (dump
& RELOC_DUMP
)
15773 if (! dump_section_as_bytes (section
, filedata
, true))
15777 if (dump
& STRING_DUMP
)
15779 if (! dump_section_as_strings (section
, filedata
))
15783 if (dump
& DEBUG_DUMP
)
15785 if (! display_debug_section (i
, section
, filedata
))
15789 #ifdef ENABLE_LIBCTF
15790 if (dump
& CTF_DUMP
)
15792 if (! dump_section_as_ctf (section
, filedata
))
15798 if (! filedata
->is_separate
)
15800 /* Check to see if the user requested a
15801 dump of a section that does not exist. */
15802 for (; i
< filedata
->dump
.num_dump_sects
; i
++)
15803 if (filedata
->dump
.dump_sects
[i
])
15805 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
15814 process_mips_fpe_exception (int mask
)
15820 if (mask
& OEX_FPU_INEX
)
15821 fputs ("INEX", stdout
), first
= false;
15822 if (mask
& OEX_FPU_UFLO
)
15823 printf ("%sUFLO", first
? "" : "|"), first
= false;
15824 if (mask
& OEX_FPU_OFLO
)
15825 printf ("%sOFLO", first
? "" : "|"), first
= false;
15826 if (mask
& OEX_FPU_DIV0
)
15827 printf ("%sDIV0", first
? "" : "|"), first
= false;
15828 if (mask
& OEX_FPU_INVAL
)
15829 printf ("%sINVAL", first
? "" : "|");
15832 fputs ("0", stdout
);
15835 /* Display's the value of TAG at location P. If TAG is
15836 greater than 0 it is assumed to be an unknown tag, and
15837 a message is printed to this effect. Otherwise it is
15838 assumed that a message has already been printed.
15840 If the bottom bit of TAG is set it assumed to have a
15841 string value, otherwise it is assumed to have an integer
15844 Returns an updated P pointing to the first unread byte
15845 beyond the end of TAG's value.
15847 Reads at or beyond END will not be made. */
15849 static unsigned char *
15850 display_tag_value (signed int tag
,
15852 const unsigned char * const end
)
15857 printf (" Tag_unknown_%d: ", tag
);
15861 warn (_("<corrupt tag>\n"));
15865 /* PR 17531 file: 027-19978-0.004. */
15866 size_t maxlen
= (end
- p
) - 1;
15871 print_symbol ((int) maxlen
, (const char *) p
);
15872 p
+= strnlen ((char *) p
, maxlen
) + 1;
15876 printf (_("<corrupt string tag>"));
15877 p
= (unsigned char *) end
;
15883 READ_ULEB (val
, p
, end
);
15884 printf ("%ld (0x%lx)\n", val
, val
);
15891 /* ARC ABI attributes section. */
15893 static unsigned char *
15894 display_arc_attribute (unsigned char * p
,
15895 const unsigned char * const end
)
15900 READ_ULEB (tag
, p
, end
);
15904 case Tag_ARC_PCS_config
:
15905 READ_ULEB (val
, p
, end
);
15906 printf (" Tag_ARC_PCS_config: ");
15910 printf (_("Absent/Non standard\n"));
15913 printf (_("Bare metal/mwdt\n"));
15916 printf (_("Bare metal/newlib\n"));
15919 printf (_("Linux/uclibc\n"));
15922 printf (_("Linux/glibc\n"));
15925 printf (_("Unknown\n"));
15930 case Tag_ARC_CPU_base
:
15931 READ_ULEB (val
, p
, end
);
15932 printf (" Tag_ARC_CPU_base: ");
15937 printf (_("Absent\n"));
15939 case TAG_CPU_ARC6xx
:
15940 printf ("ARC6xx\n");
15942 case TAG_CPU_ARC7xx
:
15943 printf ("ARC7xx\n");
15945 case TAG_CPU_ARCEM
:
15946 printf ("ARCEM\n");
15948 case TAG_CPU_ARCHS
:
15949 printf ("ARCHS\n");
15954 case Tag_ARC_CPU_variation
:
15955 READ_ULEB (val
, p
, end
);
15956 printf (" Tag_ARC_CPU_variation: ");
15960 if (val
> 0 && val
< 16)
15961 printf ("Core%d\n", val
);
15963 printf ("Unknown\n");
15967 printf (_("Absent\n"));
15972 case Tag_ARC_CPU_name
:
15973 printf (" Tag_ARC_CPU_name: ");
15974 p
= display_tag_value (-1, p
, end
);
15977 case Tag_ARC_ABI_rf16
:
15978 READ_ULEB (val
, p
, end
);
15979 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
15982 case Tag_ARC_ABI_osver
:
15983 READ_ULEB (val
, p
, end
);
15984 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
15987 case Tag_ARC_ABI_pic
:
15988 case Tag_ARC_ABI_sda
:
15989 READ_ULEB (val
, p
, end
);
15990 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
15991 : " Tag_ARC_ABI_pic: ");
15995 printf (_("Absent\n"));
16004 printf (_("Unknown\n"));
16009 case Tag_ARC_ABI_tls
:
16010 READ_ULEB (val
, p
, end
);
16011 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
16014 case Tag_ARC_ABI_enumsize
:
16015 READ_ULEB (val
, p
, end
);
16016 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
16020 case Tag_ARC_ABI_exceptions
:
16021 READ_ULEB (val
, p
, end
);
16022 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
16026 case Tag_ARC_ABI_double_size
:
16027 READ_ULEB (val
, p
, end
);
16028 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
16031 case Tag_ARC_ISA_config
:
16032 printf (" Tag_ARC_ISA_config: ");
16033 p
= display_tag_value (-1, p
, end
);
16036 case Tag_ARC_ISA_apex
:
16037 printf (" Tag_ARC_ISA_apex: ");
16038 p
= display_tag_value (-1, p
, end
);
16041 case Tag_ARC_ISA_mpy_option
:
16042 READ_ULEB (val
, p
, end
);
16043 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
16046 case Tag_ARC_ATR_version
:
16047 READ_ULEB (val
, p
, end
);
16048 printf (" Tag_ARC_ATR_version: %d\n", val
);
16052 return display_tag_value (tag
& 1, p
, end
);
16058 /* ARM EABI attributes section. */
16063 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
16065 const char *const *table
;
16066 } arm_attr_public_tag
;
16068 static const char *const arm_attr_tag_CPU_arch
[] =
16069 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
16070 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
16071 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
16072 static const char *const arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
16073 static const char *const arm_attr_tag_THUMB_ISA_use
[] =
16074 {"No", "Thumb-1", "Thumb-2", "Yes"};
16075 static const char *const arm_attr_tag_FP_arch
[] =
16076 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
16077 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
16078 static const char *const arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
16079 static const char *const arm_attr_tag_Advanced_SIMD_arch
[] =
16080 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
16081 "NEON for ARMv8.1"};
16082 static const char *const arm_attr_tag_PCS_config
[] =
16083 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
16084 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
16085 static const char *const arm_attr_tag_ABI_PCS_R9_use
[] =
16086 {"V6", "SB", "TLS", "Unused"};
16087 static const char *const arm_attr_tag_ABI_PCS_RW_data
[] =
16088 {"Absolute", "PC-relative", "SB-relative", "None"};
16089 static const char *const arm_attr_tag_ABI_PCS_RO_data
[] =
16090 {"Absolute", "PC-relative", "None"};
16091 static const char *const arm_attr_tag_ABI_PCS_GOT_use
[] =
16092 {"None", "direct", "GOT-indirect"};
16093 static const char *const arm_attr_tag_ABI_PCS_wchar_t
[] =
16094 {"None", "??? 1", "2", "??? 3", "4"};
16095 static const char *const arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
16096 static const char *const arm_attr_tag_ABI_FP_denormal
[] =
16097 {"Unused", "Needed", "Sign only"};
16098 static const char *const arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
16099 static const char *const arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
16100 static const char *const arm_attr_tag_ABI_FP_number_model
[] =
16101 {"Unused", "Finite", "RTABI", "IEEE 754"};
16102 static const char *const arm_attr_tag_ABI_enum_size
[] =
16103 {"Unused", "small", "int", "forced to int"};
16104 static const char *const arm_attr_tag_ABI_HardFP_use
[] =
16105 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
16106 static const char *const arm_attr_tag_ABI_VFP_args
[] =
16107 {"AAPCS", "VFP registers", "custom", "compatible"};
16108 static const char *const arm_attr_tag_ABI_WMMX_args
[] =
16109 {"AAPCS", "WMMX registers", "custom"};
16110 static const char *const arm_attr_tag_ABI_optimization_goals
[] =
16111 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
16112 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
16113 static const char *const arm_attr_tag_ABI_FP_optimization_goals
[] =
16114 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
16115 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
16116 static const char *const arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
16117 static const char *const arm_attr_tag_FP_HP_extension
[] =
16118 {"Not Allowed", "Allowed"};
16119 static const char *const arm_attr_tag_ABI_FP_16bit_format
[] =
16120 {"None", "IEEE 754", "Alternative Format"};
16121 static const char *const arm_attr_tag_DSP_extension
[] =
16122 {"Follow architecture", "Allowed"};
16123 static const char *const arm_attr_tag_MPextension_use
[] =
16124 {"Not Allowed", "Allowed"};
16125 static const char *const arm_attr_tag_DIV_use
[] =
16126 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
16127 "Allowed in v7-A with integer division extension"};
16128 static const char *const arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
16129 static const char *const arm_attr_tag_Virtualization_use
[] =
16130 {"Not Allowed", "TrustZone", "Virtualization Extensions",
16131 "TrustZone and Virtualization Extensions"};
16132 static const char *const arm_attr_tag_MPextension_use_legacy
[] =
16133 {"Not Allowed", "Allowed"};
16135 static const char *const arm_attr_tag_MVE_arch
[] =
16136 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
16138 #define LOOKUP(id, name) \
16139 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
16140 static arm_attr_public_tag arm_attr_public_tags
[] =
16142 {4, "CPU_raw_name", 1, NULL
},
16143 {5, "CPU_name", 1, NULL
},
16144 LOOKUP(6, CPU_arch
),
16145 {7, "CPU_arch_profile", 0, NULL
},
16146 LOOKUP(8, ARM_ISA_use
),
16147 LOOKUP(9, THUMB_ISA_use
),
16148 LOOKUP(10, FP_arch
),
16149 LOOKUP(11, WMMX_arch
),
16150 LOOKUP(12, Advanced_SIMD_arch
),
16151 LOOKUP(13, PCS_config
),
16152 LOOKUP(14, ABI_PCS_R9_use
),
16153 LOOKUP(15, ABI_PCS_RW_data
),
16154 LOOKUP(16, ABI_PCS_RO_data
),
16155 LOOKUP(17, ABI_PCS_GOT_use
),
16156 LOOKUP(18, ABI_PCS_wchar_t
),
16157 LOOKUP(19, ABI_FP_rounding
),
16158 LOOKUP(20, ABI_FP_denormal
),
16159 LOOKUP(21, ABI_FP_exceptions
),
16160 LOOKUP(22, ABI_FP_user_exceptions
),
16161 LOOKUP(23, ABI_FP_number_model
),
16162 {24, "ABI_align_needed", 0, NULL
},
16163 {25, "ABI_align_preserved", 0, NULL
},
16164 LOOKUP(26, ABI_enum_size
),
16165 LOOKUP(27, ABI_HardFP_use
),
16166 LOOKUP(28, ABI_VFP_args
),
16167 LOOKUP(29, ABI_WMMX_args
),
16168 LOOKUP(30, ABI_optimization_goals
),
16169 LOOKUP(31, ABI_FP_optimization_goals
),
16170 {32, "compatibility", 0, NULL
},
16171 LOOKUP(34, CPU_unaligned_access
),
16172 LOOKUP(36, FP_HP_extension
),
16173 LOOKUP(38, ABI_FP_16bit_format
),
16174 LOOKUP(42, MPextension_use
),
16175 LOOKUP(44, DIV_use
),
16176 LOOKUP(46, DSP_extension
),
16177 LOOKUP(48, MVE_arch
),
16178 {64, "nodefaults", 0, NULL
},
16179 {65, "also_compatible_with", 0, NULL
},
16180 LOOKUP(66, T2EE_use
),
16181 {67, "conformance", 1, NULL
},
16182 LOOKUP(68, Virtualization_use
),
16183 LOOKUP(70, MPextension_use_legacy
)
16187 static unsigned char *
16188 display_arm_attribute (unsigned char * p
,
16189 const unsigned char * const end
)
16193 arm_attr_public_tag
* attr
;
16197 READ_ULEB (tag
, p
, end
);
16199 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
16201 if (arm_attr_public_tags
[i
].tag
== tag
)
16203 attr
= &arm_attr_public_tags
[i
];
16210 printf (" Tag_%s: ", attr
->name
);
16211 switch (attr
->type
)
16216 case 7: /* Tag_CPU_arch_profile. */
16217 READ_ULEB (val
, p
, end
);
16220 case 0: printf (_("None\n")); break;
16221 case 'A': printf (_("Application\n")); break;
16222 case 'R': printf (_("Realtime\n")); break;
16223 case 'M': printf (_("Microcontroller\n")); break;
16224 case 'S': printf (_("Application or Realtime\n")); break;
16225 default: printf ("??? (%d)\n", val
); break;
16229 case 24: /* Tag_align_needed. */
16230 READ_ULEB (val
, p
, end
);
16233 case 0: printf (_("None\n")); break;
16234 case 1: printf (_("8-byte\n")); break;
16235 case 2: printf (_("4-byte\n")); break;
16236 case 3: printf ("??? 3\n"); break;
16239 printf (_("8-byte and up to %d-byte extended\n"),
16242 printf ("??? (%d)\n", val
);
16247 case 25: /* Tag_align_preserved. */
16248 READ_ULEB (val
, p
, end
);
16251 case 0: printf (_("None\n")); break;
16252 case 1: printf (_("8-byte, except leaf SP\n")); break;
16253 case 2: printf (_("8-byte\n")); break;
16254 case 3: printf ("??? 3\n"); break;
16257 printf (_("8-byte and up to %d-byte extended\n"),
16260 printf ("??? (%d)\n", val
);
16265 case 32: /* Tag_compatibility. */
16267 READ_ULEB (val
, p
, end
);
16268 printf (_("flag = %d, vendor = "), val
);
16271 size_t maxlen
= (end
- p
) - 1;
16273 print_symbol ((int) maxlen
, (const char *) p
);
16274 p
+= strnlen ((char *) p
, maxlen
) + 1;
16278 printf (_("<corrupt>"));
16279 p
= (unsigned char *) end
;
16285 case 64: /* Tag_nodefaults. */
16286 /* PR 17531: file: 001-505008-0.01. */
16289 printf (_("True\n"));
16292 case 65: /* Tag_also_compatible_with. */
16293 READ_ULEB (val
, p
, end
);
16294 if (val
== 6 /* Tag_CPU_arch. */)
16296 READ_ULEB (val
, p
, end
);
16297 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
16298 printf ("??? (%d)\n", val
);
16300 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
16304 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
16309 printf (_("<unknown: %d>\n"), tag
);
16315 return display_tag_value (-1, p
, end
);
16317 return display_tag_value (0, p
, end
);
16320 assert (attr
->type
& 0x80);
16321 READ_ULEB (val
, p
, end
);
16322 type
= attr
->type
& 0x7f;
16324 printf ("??? (%d)\n", val
);
16326 printf ("%s\n", attr
->table
[val
]);
16331 return display_tag_value (tag
, p
, end
);
16334 static unsigned char *
16335 display_gnu_attribute (unsigned char * p
,
16336 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
16337 const unsigned char * const end
)
16342 READ_ULEB (tag
, p
, end
);
16344 /* Tag_compatibility is the only generic GNU attribute defined at
16348 READ_ULEB (val
, p
, end
);
16350 printf (_("flag = %d, vendor = "), val
);
16353 printf (_("<corrupt>\n"));
16354 warn (_("corrupt vendor attribute\n"));
16360 size_t maxlen
= (end
- p
) - 1;
16362 print_symbol ((int) maxlen
, (const char *) p
);
16363 p
+= strnlen ((char *) p
, maxlen
) + 1;
16367 printf (_("<corrupt>"));
16368 p
= (unsigned char *) end
;
16375 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
16376 return display_proc_gnu_attribute (p
, tag
, end
);
16378 return display_tag_value (tag
, p
, end
);
16381 static unsigned char *
16382 display_m68k_gnu_attribute (unsigned char * p
,
16384 const unsigned char * const end
)
16388 if (tag
== Tag_GNU_M68K_ABI_FP
)
16390 printf (" Tag_GNU_M68K_ABI_FP: ");
16393 printf (_("<corrupt>\n"));
16396 READ_ULEB (val
, p
, end
);
16399 printf ("(%#x), ", val
);
16404 printf (_("unspecified hard/soft float\n"));
16407 printf (_("hard float\n"));
16410 printf (_("soft float\n"));
16416 return display_tag_value (tag
& 1, p
, end
);
16419 static unsigned char *
16420 display_power_gnu_attribute (unsigned char * p
,
16422 const unsigned char * const end
)
16426 if (tag
== Tag_GNU_Power_ABI_FP
)
16428 printf (" Tag_GNU_Power_ABI_FP: ");
16431 printf (_("<corrupt>\n"));
16434 READ_ULEB (val
, p
, end
);
16437 printf ("(%#x), ", val
);
16442 printf (_("unspecified hard/soft float, "));
16445 printf (_("hard float, "));
16448 printf (_("soft float, "));
16451 printf (_("single-precision hard float, "));
16458 printf (_("unspecified long double\n"));
16461 printf (_("128-bit IBM long double\n"));
16464 printf (_("64-bit long double\n"));
16467 printf (_("128-bit IEEE long double\n"));
16473 if (tag
== Tag_GNU_Power_ABI_Vector
)
16475 printf (" Tag_GNU_Power_ABI_Vector: ");
16478 printf (_("<corrupt>\n"));
16481 READ_ULEB (val
, p
, end
);
16484 printf ("(%#x), ", val
);
16489 printf (_("unspecified\n"));
16492 printf (_("generic\n"));
16495 printf ("AltiVec\n");
16504 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
16506 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
16509 printf (_("<corrupt>\n"));
16512 READ_ULEB (val
, p
, end
);
16515 printf ("(%#x), ", val
);
16520 printf (_("unspecified\n"));
16523 printf ("r3/r4\n");
16526 printf (_("memory\n"));
16535 return display_tag_value (tag
& 1, p
, end
);
16538 static unsigned char *
16539 display_s390_gnu_attribute (unsigned char * p
,
16541 const unsigned char * const end
)
16545 if (tag
== Tag_GNU_S390_ABI_Vector
)
16547 printf (" Tag_GNU_S390_ABI_Vector: ");
16548 READ_ULEB (val
, p
, end
);
16553 printf (_("any\n"));
16556 printf (_("software\n"));
16559 printf (_("hardware\n"));
16562 printf ("??? (%d)\n", val
);
16568 return display_tag_value (tag
& 1, p
, end
);
16572 display_sparc_hwcaps (unsigned int mask
)
16578 if (mask
& ELF_SPARC_HWCAP_MUL32
)
16579 fputs ("mul32", stdout
), first
= false;
16580 if (mask
& ELF_SPARC_HWCAP_DIV32
)
16581 printf ("%sdiv32", first
? "" : "|"), first
= false;
16582 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
16583 printf ("%sfsmuld", first
? "" : "|"), first
= false;
16584 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
16585 printf ("%sv8plus", first
? "" : "|"), first
= false;
16586 if (mask
& ELF_SPARC_HWCAP_POPC
)
16587 printf ("%spopc", first
? "" : "|"), first
= false;
16588 if (mask
& ELF_SPARC_HWCAP_VIS
)
16589 printf ("%svis", first
? "" : "|"), first
= false;
16590 if (mask
& ELF_SPARC_HWCAP_VIS2
)
16591 printf ("%svis2", first
? "" : "|"), first
= false;
16592 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
16593 printf ("%sASIBlkInit", first
? "" : "|"), first
= false;
16594 if (mask
& ELF_SPARC_HWCAP_FMAF
)
16595 printf ("%sfmaf", first
? "" : "|"), first
= false;
16596 if (mask
& ELF_SPARC_HWCAP_VIS3
)
16597 printf ("%svis3", first
? "" : "|"), first
= false;
16598 if (mask
& ELF_SPARC_HWCAP_HPC
)
16599 printf ("%shpc", first
? "" : "|"), first
= false;
16600 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
16601 printf ("%srandom", first
? "" : "|"), first
= false;
16602 if (mask
& ELF_SPARC_HWCAP_TRANS
)
16603 printf ("%strans", first
? "" : "|"), first
= false;
16604 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
16605 printf ("%sfjfmau", first
? "" : "|"), first
= false;
16606 if (mask
& ELF_SPARC_HWCAP_IMA
)
16607 printf ("%sima", first
? "" : "|"), first
= false;
16608 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
16609 printf ("%scspare", first
? "" : "|"), first
= false;
16612 fputc ('0', stdout
);
16613 fputc ('\n', stdout
);
16617 display_sparc_hwcaps2 (unsigned int mask
)
16623 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
16624 fputs ("fjathplus", stdout
), first
= false;
16625 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
16626 printf ("%svis3b", first
? "" : "|"), first
= false;
16627 if (mask
& ELF_SPARC_HWCAP2_ADP
)
16628 printf ("%sadp", first
? "" : "|"), first
= false;
16629 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
16630 printf ("%ssparc5", first
? "" : "|"), first
= false;
16631 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
16632 printf ("%smwait", first
? "" : "|"), first
= false;
16633 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
16634 printf ("%sxmpmul", first
? "" : "|"), first
= false;
16635 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
16636 printf ("%sxmont2", first
? "" : "|"), first
= false;
16637 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
16638 printf ("%snsec", first
? "" : "|"), first
= false;
16639 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
16640 printf ("%sfjathhpc", first
? "" : "|"), first
= false;
16641 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
16642 printf ("%sfjdes", first
? "" : "|"), first
= false;
16643 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
16644 printf ("%sfjaes", first
? "" : "|"), first
= false;
16647 fputc ('0', stdout
);
16648 fputc ('\n', stdout
);
16651 static unsigned char *
16652 display_sparc_gnu_attribute (unsigned char * p
,
16654 const unsigned char * const end
)
16658 if (tag
== Tag_GNU_Sparc_HWCAPS
)
16660 READ_ULEB (val
, p
, end
);
16661 printf (" Tag_GNU_Sparc_HWCAPS: ");
16662 display_sparc_hwcaps (val
);
16665 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
16667 READ_ULEB (val
, p
, end
);
16668 printf (" Tag_GNU_Sparc_HWCAPS2: ");
16669 display_sparc_hwcaps2 (val
);
16673 return display_tag_value (tag
, p
, end
);
16677 print_mips_fp_abi_value (unsigned int val
)
16681 case Val_GNU_MIPS_ABI_FP_ANY
:
16682 printf (_("Hard or soft float\n"));
16684 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
16685 printf (_("Hard float (double precision)\n"));
16687 case Val_GNU_MIPS_ABI_FP_SINGLE
:
16688 printf (_("Hard float (single precision)\n"));
16690 case Val_GNU_MIPS_ABI_FP_SOFT
:
16691 printf (_("Soft float\n"));
16693 case Val_GNU_MIPS_ABI_FP_OLD_64
:
16694 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
16696 case Val_GNU_MIPS_ABI_FP_XX
:
16697 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
16699 case Val_GNU_MIPS_ABI_FP_64
:
16700 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
16702 case Val_GNU_MIPS_ABI_FP_64A
:
16703 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
16705 case Val_GNU_MIPS_ABI_FP_NAN2008
:
16706 printf (_("NaN 2008 compatibility\n"));
16709 printf ("??? (%d)\n", val
);
16714 static unsigned char *
16715 display_mips_gnu_attribute (unsigned char * p
,
16717 const unsigned char * const end
)
16719 if (tag
== Tag_GNU_MIPS_ABI_FP
)
16723 printf (" Tag_GNU_MIPS_ABI_FP: ");
16724 READ_ULEB (val
, p
, end
);
16725 print_mips_fp_abi_value (val
);
16729 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
16733 printf (" Tag_GNU_MIPS_ABI_MSA: ");
16734 READ_ULEB (val
, p
, end
);
16738 case Val_GNU_MIPS_ABI_MSA_ANY
:
16739 printf (_("Any MSA or not\n"));
16741 case Val_GNU_MIPS_ABI_MSA_128
:
16742 printf (_("128-bit MSA\n"));
16745 printf ("??? (%d)\n", val
);
16751 return display_tag_value (tag
& 1, p
, end
);
16754 static unsigned char *
16755 display_tic6x_attribute (unsigned char * p
,
16756 const unsigned char * const end
)
16761 READ_ULEB (tag
, p
, end
);
16766 printf (" Tag_ISA: ");
16767 READ_ULEB (val
, p
, end
);
16771 case C6XABI_Tag_ISA_none
:
16772 printf (_("None\n"));
16774 case C6XABI_Tag_ISA_C62X
:
16777 case C6XABI_Tag_ISA_C67X
:
16780 case C6XABI_Tag_ISA_C67XP
:
16781 printf ("C67x+\n");
16783 case C6XABI_Tag_ISA_C64X
:
16786 case C6XABI_Tag_ISA_C64XP
:
16787 printf ("C64x+\n");
16789 case C6XABI_Tag_ISA_C674X
:
16790 printf ("C674x\n");
16793 printf ("??? (%d)\n", val
);
16798 case Tag_ABI_wchar_t
:
16799 printf (" Tag_ABI_wchar_t: ");
16800 READ_ULEB (val
, p
, end
);
16804 printf (_("Not used\n"));
16807 printf (_("2 bytes\n"));
16810 printf (_("4 bytes\n"));
16813 printf ("??? (%d)\n", val
);
16818 case Tag_ABI_stack_align_needed
:
16819 printf (" Tag_ABI_stack_align_needed: ");
16820 READ_ULEB (val
, p
, end
);
16824 printf (_("8-byte\n"));
16827 printf (_("16-byte\n"));
16830 printf ("??? (%d)\n", val
);
16835 case Tag_ABI_stack_align_preserved
:
16836 READ_ULEB (val
, p
, end
);
16837 printf (" Tag_ABI_stack_align_preserved: ");
16841 printf (_("8-byte\n"));
16844 printf (_("16-byte\n"));
16847 printf ("??? (%d)\n", val
);
16853 READ_ULEB (val
, p
, end
);
16854 printf (" Tag_ABI_DSBT: ");
16858 printf (_("DSBT addressing not used\n"));
16861 printf (_("DSBT addressing used\n"));
16864 printf ("??? (%d)\n", val
);
16870 READ_ULEB (val
, p
, end
);
16871 printf (" Tag_ABI_PID: ");
16875 printf (_("Data addressing position-dependent\n"));
16878 printf (_("Data addressing position-independent, GOT near DP\n"));
16881 printf (_("Data addressing position-independent, GOT far from DP\n"));
16884 printf ("??? (%d)\n", val
);
16890 READ_ULEB (val
, p
, end
);
16891 printf (" Tag_ABI_PIC: ");
16895 printf (_("Code addressing position-dependent\n"));
16898 printf (_("Code addressing position-independent\n"));
16901 printf ("??? (%d)\n", val
);
16906 case Tag_ABI_array_object_alignment
:
16907 READ_ULEB (val
, p
, end
);
16908 printf (" Tag_ABI_array_object_alignment: ");
16912 printf (_("8-byte\n"));
16915 printf (_("4-byte\n"));
16918 printf (_("16-byte\n"));
16921 printf ("??? (%d)\n", val
);
16926 case Tag_ABI_array_object_align_expected
:
16927 READ_ULEB (val
, p
, end
);
16928 printf (" Tag_ABI_array_object_align_expected: ");
16932 printf (_("8-byte\n"));
16935 printf (_("4-byte\n"));
16938 printf (_("16-byte\n"));
16941 printf ("??? (%d)\n", val
);
16946 case Tag_ABI_compatibility
:
16948 READ_ULEB (val
, p
, end
);
16949 printf (" Tag_ABI_compatibility: ");
16950 printf (_("flag = %d, vendor = "), val
);
16953 size_t maxlen
= (end
- p
) - 1;
16955 print_symbol ((int) maxlen
, (const char *) p
);
16956 p
+= strnlen ((char *) p
, maxlen
) + 1;
16960 printf (_("<corrupt>"));
16961 p
= (unsigned char *) end
;
16967 case Tag_ABI_conformance
:
16969 printf (" Tag_ABI_conformance: \"");
16972 size_t maxlen
= (end
- p
) - 1;
16974 print_symbol ((int) maxlen
, (const char *) p
);
16975 p
+= strnlen ((char *) p
, maxlen
) + 1;
16979 printf (_("<corrupt>"));
16980 p
= (unsigned char *) end
;
16987 return display_tag_value (tag
, p
, end
);
16991 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
16993 unsigned long addr
= 0;
16994 size_t bytes
= end
- p
;
17001 int lbytes
= (bytes
> 16 ? 16 : bytes
);
17003 printf (" 0x%8.8lx ", addr
);
17005 for (j
= 0; j
< 16; j
++)
17008 printf ("%2.2x", p
[j
]);
17016 for (j
= 0; j
< lbytes
; j
++)
17019 if (k
>= ' ' && k
< 0x7f)
17035 static unsigned char *
17036 display_msp430_attribute (unsigned char * p
,
17037 const unsigned char * const end
)
17042 READ_ULEB (tag
, p
, end
);
17046 case OFBA_MSPABI_Tag_ISA
:
17047 printf (" Tag_ISA: ");
17048 READ_ULEB (val
, p
, end
);
17051 case 0: printf (_("None\n")); break;
17052 case 1: printf (_("MSP430\n")); break;
17053 case 2: printf (_("MSP430X\n")); break;
17054 default: printf ("??? (%d)\n", val
); break;
17058 case OFBA_MSPABI_Tag_Code_Model
:
17059 printf (" Tag_Code_Model: ");
17060 READ_ULEB (val
, p
, end
);
17063 case 0: printf (_("None\n")); break;
17064 case 1: printf (_("Small\n")); break;
17065 case 2: printf (_("Large\n")); break;
17066 default: printf ("??? (%d)\n", val
); break;
17070 case OFBA_MSPABI_Tag_Data_Model
:
17071 printf (" Tag_Data_Model: ");
17072 READ_ULEB (val
, p
, end
);
17075 case 0: printf (_("None\n")); break;
17076 case 1: printf (_("Small\n")); break;
17077 case 2: printf (_("Large\n")); break;
17078 case 3: printf (_("Restricted Large\n")); break;
17079 default: printf ("??? (%d)\n", val
); break;
17084 printf (_(" <unknown tag %d>: "), tag
);
17091 size_t maxlen
= (end
- p
) - 1;
17093 print_symbol ((int) maxlen
, (const char *) p
);
17094 p
+= strnlen ((char *) p
, maxlen
) + 1;
17098 printf (_("<corrupt>"));
17099 p
= (unsigned char *) end
;
17105 READ_ULEB (val
, p
, end
);
17106 printf ("%d (0x%x)\n", val
, val
);
17115 static unsigned char *
17116 display_msp430_gnu_attribute (unsigned char * p
,
17118 const unsigned char * const end
)
17120 if (tag
== Tag_GNU_MSP430_Data_Region
)
17124 printf (" Tag_GNU_MSP430_Data_Region: ");
17125 READ_ULEB (val
, p
, end
);
17129 case Val_GNU_MSP430_Data_Region_Any
:
17130 printf (_("Any Region\n"));
17132 case Val_GNU_MSP430_Data_Region_Lower
:
17133 printf (_("Lower Region Only\n"));
17136 printf ("??? (%u)\n", val
);
17140 return display_tag_value (tag
& 1, p
, end
);
17143 struct riscv_attr_tag_t
{
17148 static struct riscv_attr_tag_t riscv_attr_tag
[] =
17150 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
17153 T(priv_spec_minor
),
17154 T(priv_spec_revision
),
17155 T(unaligned_access
),
17160 static unsigned char *
17161 display_riscv_attribute (unsigned char *p
,
17162 const unsigned char * const end
)
17166 struct riscv_attr_tag_t
*attr
= NULL
;
17169 READ_ULEB (tag
, p
, end
);
17171 /* Find the name of attribute. */
17172 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
17174 if (riscv_attr_tag
[i
].tag
== tag
)
17176 attr
= &riscv_attr_tag
[i
];
17182 printf (" %s: ", attr
->name
);
17184 return display_tag_value (tag
, p
, end
);
17188 case Tag_RISCV_priv_spec
:
17189 case Tag_RISCV_priv_spec_minor
:
17190 case Tag_RISCV_priv_spec_revision
:
17191 READ_ULEB (val
, p
, end
);
17192 printf (_("%u\n"), val
);
17194 case Tag_RISCV_unaligned_access
:
17195 READ_ULEB (val
, p
, end
);
17199 printf (_("No unaligned access\n"));
17202 printf (_("Unaligned access\n"));
17206 case Tag_RISCV_stack_align
:
17207 READ_ULEB (val
, p
, end
);
17208 printf (_("%u-bytes\n"), val
);
17210 case Tag_RISCV_arch
:
17211 p
= display_tag_value (-1, p
, end
);
17214 return display_tag_value (tag
, p
, end
);
17220 static unsigned char *
17221 display_csky_attribute (unsigned char * p
,
17222 const unsigned char * const end
)
17226 READ_ULEB (tag
, p
, end
);
17228 if (tag
>= Tag_CSKY_MAX
)
17230 return display_tag_value (-1, p
, end
);
17235 case Tag_CSKY_ARCH_NAME
:
17236 printf (" Tag_CSKY_ARCH_NAME:\t\t");
17237 return display_tag_value (-1, p
, end
);
17238 case Tag_CSKY_CPU_NAME
:
17239 printf (" Tag_CSKY_CPU_NAME:\t\t");
17240 return display_tag_value (-1, p
, end
);
17242 case Tag_CSKY_ISA_FLAGS
:
17243 printf (" Tag_CSKY_ISA_FLAGS:\t\t");
17244 return display_tag_value (0, p
, end
);
17245 case Tag_CSKY_ISA_EXT_FLAGS
:
17246 printf (" Tag_CSKY_ISA_EXT_FLAGS:\t");
17247 return display_tag_value (0, p
, end
);
17249 case Tag_CSKY_DSP_VERSION
:
17250 printf (" Tag_CSKY_DSP_VERSION:\t\t");
17251 READ_ULEB (val
, p
, end
);
17252 if (val
== VAL_CSKY_DSP_VERSION_EXTENSION
)
17253 printf ("DSP Extension\n");
17254 else if (val
== VAL_CSKY_DSP_VERSION_2
)
17255 printf ("DSP 2.0\n");
17258 case Tag_CSKY_VDSP_VERSION
:
17259 printf (" Tag_CSKY_VDSP_VERSION:\t");
17260 READ_ULEB (val
, p
, end
);
17261 printf ("VDSP Version %d\n", val
);
17264 case Tag_CSKY_FPU_VERSION
:
17265 printf (" Tag_CSKY_FPU_VERSION:\t\t");
17266 READ_ULEB (val
, p
, end
);
17267 if (val
== VAL_CSKY_FPU_VERSION_1
)
17268 printf ("ABIV1 FPU Version 1\n");
17269 else if (val
== VAL_CSKY_FPU_VERSION_2
)
17270 printf ("FPU Version 2\n");
17273 case Tag_CSKY_FPU_ABI
:
17274 printf (" Tag_CSKY_FPU_ABI:\t\t");
17275 READ_ULEB (val
, p
, end
);
17276 if (val
== VAL_CSKY_FPU_ABI_HARD
)
17278 else if (val
== VAL_CSKY_FPU_ABI_SOFTFP
)
17279 printf ("SoftFP\n");
17280 else if (val
== VAL_CSKY_FPU_ABI_SOFT
)
17283 case Tag_CSKY_FPU_ROUNDING
:
17284 READ_ULEB (val
, p
, end
);
17286 printf (" Tag_CSKY_FPU_ROUNDING:\t");
17287 printf ("Needed\n");
17290 case Tag_CSKY_FPU_DENORMAL
:
17291 READ_ULEB (val
, p
, end
);
17293 printf (" Tag_CSKY_FPU_DENORMAL:\t");
17294 printf ("Needed\n");
17297 case Tag_CSKY_FPU_Exception
:
17298 READ_ULEB (val
, p
, end
);
17300 printf (" Tag_CSKY_FPU_Exception:\t");
17301 printf ("Needed\n");
17304 case Tag_CSKY_FPU_NUMBER_MODULE
:
17305 printf (" Tag_CSKY_FPU_NUMBER_MODULE:\t");
17306 return display_tag_value (-1, p
, end
);
17307 case Tag_CSKY_FPU_HARDFP
:
17308 printf (" Tag_CSKY_FPU_HARDFP:\t\t");
17309 READ_ULEB (val
, p
, end
);
17310 if (val
& VAL_CSKY_FPU_HARDFP_HALF
)
17312 if (val
& VAL_CSKY_FPU_HARDFP_SINGLE
)
17313 printf (" Single");
17314 if (val
& VAL_CSKY_FPU_HARDFP_DOUBLE
)
17315 printf (" Double");
17319 return display_tag_value (tag
, p
, end
);
17325 process_attributes (Filedata
* filedata
,
17326 const char * public_name
,
17327 unsigned int proc_type
,
17328 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
17329 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
17331 Elf_Internal_Shdr
* sect
;
17335 /* Find the section header so that we get the size. */
17336 for (i
= 0, sect
= filedata
->section_headers
;
17337 i
< filedata
->file_header
.e_shnum
;
17340 unsigned char * contents
;
17343 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
17346 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17347 sect
->sh_size
, _("attributes"));
17348 if (contents
== NULL
)
17355 /* The first character is the version of the attributes.
17356 Currently only version 1, (aka 'A') is recognised here. */
17359 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
17364 bfd_vma section_len
;
17366 section_len
= sect
->sh_size
- 1;
17369 while (section_len
> 0)
17372 unsigned int namelen
;
17373 bool public_section
;
17376 if (section_len
<= 4)
17378 error (_("Tag section ends prematurely\n"));
17382 attr_len
= byte_get (p
, 4);
17385 if (attr_len
> section_len
)
17387 error (_("Bad attribute length (%u > %u)\n"),
17388 (unsigned) attr_len
, (unsigned) section_len
);
17389 attr_len
= section_len
;
17392 /* PR 17531: file: 001-101425-0.004 */
17393 else if (attr_len
< 5)
17395 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
17400 section_len
-= attr_len
;
17403 namelen
= strnlen ((char *) p
, attr_len
) + 1;
17404 if (namelen
== 0 || namelen
>= attr_len
)
17406 error (_("Corrupt attribute section name\n"));
17411 printf (_("Attribute Section: "));
17412 print_symbol (INT_MAX
, (const char *) p
);
17415 if (public_name
&& streq ((char *) p
, public_name
))
17416 public_section
= true;
17418 public_section
= false;
17420 if (streq ((char *) p
, "gnu"))
17421 gnu_section
= true;
17423 gnu_section
= false;
17426 attr_len
-= namelen
;
17428 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
17433 unsigned char * end
;
17435 /* PR binutils/17531: Safe handling of corrupt files. */
17438 error (_("Unused bytes at end of section\n"));
17445 size
= byte_get (p
, 4);
17446 if (size
> attr_len
)
17448 error (_("Bad subsection length (%u > %u)\n"),
17449 (unsigned) size
, (unsigned) attr_len
);
17453 /* PR binutils/17531: Safe handling of corrupt files. */
17456 error (_("Bad subsection length (%u < 6)\n"),
17464 end
= p
+ size
- 1;
17465 assert (end
<= contents
+ sect
->sh_size
);
17471 printf (_("File Attributes\n"));
17474 printf (_("Section Attributes:"));
17477 printf (_("Symbol Attributes:"));
17478 /* Fall through. */
17482 READ_ULEB (val
, p
, end
);
17485 printf (" %d", val
);
17490 printf (_("Unknown tag: %d\n"), tag
);
17491 public_section
= false;
17495 if (public_section
&& display_pub_attribute
!= NULL
)
17498 p
= display_pub_attribute (p
, end
);
17501 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
17504 p
= display_gnu_attribute (p
,
17505 display_proc_gnu_attribute
,
17511 printf (_(" Unknown attribute:\n"));
17512 display_raw_attribute (p
, end
);
17527 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
17528 Print the Address, Access and Initial fields of an entry at VMA ADDR
17529 and return the VMA of the next entry, or -1 if there was a problem.
17530 Does not read from DATA_END or beyond. */
17533 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
17534 unsigned char * data_end
)
17537 print_vma (addr
, LONG_HEX
);
17539 if (addr
< pltgot
+ 0xfff0)
17540 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
17542 printf ("%10s", "");
17545 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
17549 unsigned char * from
= data
+ addr
- pltgot
;
17551 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
17553 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
17554 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
17555 return (bfd_vma
) -1;
17559 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
17560 print_vma (entry
, LONG_HEX
);
17563 return addr
+ (is_32bit_elf
? 4 : 8);
17566 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
17567 PLTGOT. Print the Address and Initial fields of an entry at VMA
17568 ADDR and return the VMA of the next entry. */
17571 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
17574 print_vma (addr
, LONG_HEX
);
17577 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
17582 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
17583 print_vma (entry
, LONG_HEX
);
17585 return addr
+ (is_32bit_elf
? 4 : 8);
17589 print_mips_ases (unsigned int mask
)
17591 if (mask
& AFL_ASE_DSP
)
17592 fputs ("\n\tDSP ASE", stdout
);
17593 if (mask
& AFL_ASE_DSPR2
)
17594 fputs ("\n\tDSP R2 ASE", stdout
);
17595 if (mask
& AFL_ASE_DSPR3
)
17596 fputs ("\n\tDSP R3 ASE", stdout
);
17597 if (mask
& AFL_ASE_EVA
)
17598 fputs ("\n\tEnhanced VA Scheme", stdout
);
17599 if (mask
& AFL_ASE_MCU
)
17600 fputs ("\n\tMCU (MicroController) ASE", stdout
);
17601 if (mask
& AFL_ASE_MDMX
)
17602 fputs ("\n\tMDMX ASE", stdout
);
17603 if (mask
& AFL_ASE_MIPS3D
)
17604 fputs ("\n\tMIPS-3D ASE", stdout
);
17605 if (mask
& AFL_ASE_MT
)
17606 fputs ("\n\tMT ASE", stdout
);
17607 if (mask
& AFL_ASE_SMARTMIPS
)
17608 fputs ("\n\tSmartMIPS ASE", stdout
);
17609 if (mask
& AFL_ASE_VIRT
)
17610 fputs ("\n\tVZ ASE", stdout
);
17611 if (mask
& AFL_ASE_MSA
)
17612 fputs ("\n\tMSA ASE", stdout
);
17613 if (mask
& AFL_ASE_MIPS16
)
17614 fputs ("\n\tMIPS16 ASE", stdout
);
17615 if (mask
& AFL_ASE_MICROMIPS
)
17616 fputs ("\n\tMICROMIPS ASE", stdout
);
17617 if (mask
& AFL_ASE_XPA
)
17618 fputs ("\n\tXPA ASE", stdout
);
17619 if (mask
& AFL_ASE_MIPS16E2
)
17620 fputs ("\n\tMIPS16e2 ASE", stdout
);
17621 if (mask
& AFL_ASE_CRC
)
17622 fputs ("\n\tCRC ASE", stdout
);
17623 if (mask
& AFL_ASE_GINV
)
17624 fputs ("\n\tGINV ASE", stdout
);
17625 if (mask
& AFL_ASE_LOONGSON_MMI
)
17626 fputs ("\n\tLoongson MMI ASE", stdout
);
17627 if (mask
& AFL_ASE_LOONGSON_CAM
)
17628 fputs ("\n\tLoongson CAM ASE", stdout
);
17629 if (mask
& AFL_ASE_LOONGSON_EXT
)
17630 fputs ("\n\tLoongson EXT ASE", stdout
);
17631 if (mask
& AFL_ASE_LOONGSON_EXT2
)
17632 fputs ("\n\tLoongson EXT2 ASE", stdout
);
17634 fprintf (stdout
, "\n\t%s", _("None"));
17635 else if ((mask
& ~AFL_ASE_MASK
) != 0)
17636 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
17640 print_mips_isa_ext (unsigned int isa_ext
)
17645 fputs (_("None"), stdout
);
17648 fputs ("RMI XLR", stdout
);
17650 case AFL_EXT_OCTEON3
:
17651 fputs ("Cavium Networks Octeon3", stdout
);
17653 case AFL_EXT_OCTEON2
:
17654 fputs ("Cavium Networks Octeon2", stdout
);
17656 case AFL_EXT_OCTEONP
:
17657 fputs ("Cavium Networks OcteonP", stdout
);
17659 case AFL_EXT_OCTEON
:
17660 fputs ("Cavium Networks Octeon", stdout
);
17663 fputs ("Toshiba R5900", stdout
);
17666 fputs ("MIPS R4650", stdout
);
17669 fputs ("LSI R4010", stdout
);
17672 fputs ("NEC VR4100", stdout
);
17675 fputs ("Toshiba R3900", stdout
);
17677 case AFL_EXT_10000
:
17678 fputs ("MIPS R10000", stdout
);
17681 fputs ("Broadcom SB-1", stdout
);
17684 fputs ("NEC VR4111/VR4181", stdout
);
17687 fputs ("NEC VR4120", stdout
);
17690 fputs ("NEC VR5400", stdout
);
17693 fputs ("NEC VR5500", stdout
);
17695 case AFL_EXT_LOONGSON_2E
:
17696 fputs ("ST Microelectronics Loongson 2E", stdout
);
17698 case AFL_EXT_LOONGSON_2F
:
17699 fputs ("ST Microelectronics Loongson 2F", stdout
);
17701 case AFL_EXT_INTERAPTIV_MR2
:
17702 fputs ("Imagination interAptiv MR2", stdout
);
17705 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
17710 get_mips_reg_size (int reg_size
)
17712 return (reg_size
== AFL_REG_NONE
) ? 0
17713 : (reg_size
== AFL_REG_32
) ? 32
17714 : (reg_size
== AFL_REG_64
) ? 64
17715 : (reg_size
== AFL_REG_128
) ? 128
17720 process_mips_specific (Filedata
* filedata
)
17722 Elf_Internal_Dyn
* entry
;
17723 Elf_Internal_Shdr
*sect
= NULL
;
17724 size_t liblist_offset
= 0;
17725 size_t liblistno
= 0;
17726 size_t conflictsno
= 0;
17727 size_t options_offset
= 0;
17728 size_t conflicts_offset
= 0;
17729 size_t pltrelsz
= 0;
17731 bfd_vma pltgot
= 0;
17732 bfd_vma mips_pltgot
= 0;
17733 bfd_vma jmprel
= 0;
17734 bfd_vma local_gotno
= 0;
17735 bfd_vma gotsym
= 0;
17736 bfd_vma symtabno
= 0;
17739 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17740 display_mips_gnu_attribute
))
17743 sect
= find_section (filedata
, ".MIPS.abiflags");
17747 Elf_External_ABIFlags_v0
*abiflags_ext
;
17748 Elf_Internal_ABIFlags_v0 abiflags_in
;
17750 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
17752 error (_("Corrupt MIPS ABI Flags section.\n"));
17757 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17758 sect
->sh_size
, _("MIPS ABI Flags section"));
17761 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
17762 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
17763 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
17764 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
17765 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
17766 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
17767 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
17768 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
17769 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
17770 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
17771 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
17773 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
17774 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
17775 if (abiflags_in
.isa_rev
> 1)
17776 printf ("r%d", abiflags_in
.isa_rev
);
17777 printf ("\nGPR size: %d",
17778 get_mips_reg_size (abiflags_in
.gpr_size
));
17779 printf ("\nCPR1 size: %d",
17780 get_mips_reg_size (abiflags_in
.cpr1_size
));
17781 printf ("\nCPR2 size: %d",
17782 get_mips_reg_size (abiflags_in
.cpr2_size
));
17783 fputs ("\nFP ABI: ", stdout
);
17784 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
17785 fputs ("ISA Extension: ", stdout
);
17786 print_mips_isa_ext (abiflags_in
.isa_ext
);
17787 fputs ("\nASEs:", stdout
);
17788 print_mips_ases (abiflags_in
.ases
);
17789 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
17790 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
17791 fputc ('\n', stdout
);
17792 free (abiflags_ext
);
17797 /* We have a lot of special sections. Thanks SGI! */
17798 if (filedata
->dynamic_section
== NULL
)
17800 /* No dynamic information available. See if there is static GOT. */
17801 sect
= find_section (filedata
, ".got");
17804 unsigned char *data_end
;
17805 unsigned char *data
;
17809 pltgot
= sect
->sh_addr
;
17812 addr_size
= (is_32bit_elf
? 4 : 8);
17813 end
= pltgot
+ sect
->sh_size
;
17815 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
17817 _("Global Offset Table data"));
17818 /* PR 12855: Null data is handled gracefully throughout. */
17819 data_end
= data
+ (end
- pltgot
);
17821 printf (_("\nStatic GOT:\n"));
17822 printf (_(" Canonical gp value: "));
17823 print_vma (ent
+ 0x7ff0, LONG_HEX
);
17826 /* In a dynamic binary GOT[0] is reserved for the dynamic
17827 loader to store the lazy resolver pointer, however in
17828 a static binary it may well have been omitted and GOT
17829 reduced to a table of addresses.
17830 PR 21344: Check for the entry being fully available
17831 before fetching it. */
17833 && data
+ ent
- pltgot
+ addr_size
<= data_end
17834 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
17836 printf (_(" Reserved entries:\n"));
17837 printf (_(" %*s %10s %*s\n"),
17838 addr_size
* 2, _("Address"), _("Access"),
17839 addr_size
* 2, _("Value"));
17840 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17842 if (ent
== (bfd_vma
) -1)
17843 goto sgot_print_fail
;
17845 /* Check for the MSB of GOT[1] being set, identifying a
17846 GNU object. This entry will be used by some runtime
17847 loaders, to store the module pointer. Otherwise this
17848 is an ordinary local entry.
17849 PR 21344: Check for the entry being fully available
17850 before fetching it. */
17852 && data
+ ent
- pltgot
+ addr_size
<= data_end
17853 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17854 >> (addr_size
* 8 - 1)) != 0)
17856 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17858 if (ent
== (bfd_vma
) -1)
17859 goto sgot_print_fail
;
17864 if (data
!= NULL
&& ent
< end
)
17866 printf (_(" Local entries:\n"));
17867 printf (" %*s %10s %*s\n",
17868 addr_size
* 2, _("Address"), _("Access"),
17869 addr_size
* 2, _("Value"));
17872 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17874 if (ent
== (bfd_vma
) -1)
17875 goto sgot_print_fail
;
17886 for (entry
= filedata
->dynamic_section
;
17887 /* PR 17531 file: 012-50589-0.004. */
17888 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
17889 && entry
->d_tag
!= DT_NULL
);
17891 switch (entry
->d_tag
)
17893 case DT_MIPS_LIBLIST
:
17895 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
17896 liblistno
* sizeof (Elf32_External_Lib
));
17898 case DT_MIPS_LIBLISTNO
:
17899 liblistno
= entry
->d_un
.d_val
;
17901 case DT_MIPS_OPTIONS
:
17902 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
17904 case DT_MIPS_CONFLICT
:
17906 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
17907 conflictsno
* sizeof (Elf32_External_Conflict
));
17909 case DT_MIPS_CONFLICTNO
:
17910 conflictsno
= entry
->d_un
.d_val
;
17913 pltgot
= entry
->d_un
.d_ptr
;
17915 case DT_MIPS_LOCAL_GOTNO
:
17916 local_gotno
= entry
->d_un
.d_val
;
17918 case DT_MIPS_GOTSYM
:
17919 gotsym
= entry
->d_un
.d_val
;
17921 case DT_MIPS_SYMTABNO
:
17922 symtabno
= entry
->d_un
.d_val
;
17924 case DT_MIPS_PLTGOT
:
17925 mips_pltgot
= entry
->d_un
.d_ptr
;
17928 pltrel
= entry
->d_un
.d_val
;
17931 pltrelsz
= entry
->d_un
.d_val
;
17934 jmprel
= entry
->d_un
.d_ptr
;
17940 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
17942 Elf32_External_Lib
* elib
;
17945 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
17946 sizeof (Elf32_External_Lib
),
17948 _("liblist section data"));
17951 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
17952 "\nSection '.liblist' contains %lu entries:\n",
17953 (unsigned long) liblistno
),
17954 (unsigned long) liblistno
);
17955 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
17958 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
17965 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17966 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17967 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17968 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17969 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17971 tmp
= gmtime (&atime
);
17972 snprintf (timebuf
, sizeof (timebuf
),
17973 "%04u-%02u-%02uT%02u:%02u:%02u",
17974 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17975 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17977 printf ("%3lu: ", (unsigned long) cnt
);
17978 if (VALID_DYNAMIC_NAME (filedata
, liblist
.l_name
))
17979 print_symbol (20, GET_DYNAMIC_NAME (filedata
, liblist
.l_name
));
17981 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
17982 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
17983 liblist
.l_version
);
17985 if (liblist
.l_flags
== 0)
17989 static const struct
17996 { " EXACT_MATCH", LL_EXACT_MATCH
},
17997 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
17998 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
17999 { " EXPORTS", LL_EXPORTS
},
18000 { " DELAY_LOAD", LL_DELAY_LOAD
},
18001 { " DELTA", LL_DELTA
}
18003 int flags
= liblist
.l_flags
;
18006 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
18007 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
18009 fputs (l_flags_vals
[fcnt
].name
, stdout
);
18010 flags
^= l_flags_vals
[fcnt
].bit
;
18013 printf (" %#x", (unsigned int) flags
);
18025 if (options_offset
!= 0)
18027 Elf_External_Options
* eopt
;
18030 sect
= filedata
->section_headers
;
18032 /* Find the section header so that we get the size. */
18033 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
18034 /* PR 17533 file: 012-277276-0.004. */
18037 error (_("No MIPS_OPTIONS header found\n"));
18041 if (sect
->sh_size
< sizeof (* eopt
))
18043 error (_("The MIPS options section is too small.\n"));
18047 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
18048 sect
->sh_size
, _("options"));
18051 Elf_Internal_Options option
;
18054 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
18056 Elf_External_Options
* eoption
;
18057 unsigned int optsize
;
18059 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
18061 optsize
= BYTE_GET (eoption
->size
);
18063 /* PR 17531: file: ffa0fa3b. */
18064 if (optsize
< sizeof (* eopt
)
18065 || optsize
> sect
->sh_size
- offset
)
18067 error (_("Invalid size (%u) for MIPS option\n"),
18076 printf (ngettext ("\nSection '%s' contains %d entry:\n",
18077 "\nSection '%s' contains %d entries:\n",
18079 printable_section_name (filedata
, sect
), cnt
);
18085 Elf_External_Options
* eoption
;
18087 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
18089 option
.kind
= BYTE_GET (eoption
->kind
);
18090 option
.size
= BYTE_GET (eoption
->size
);
18091 option
.section
= BYTE_GET (eoption
->section
);
18092 option
.info
= BYTE_GET (eoption
->info
);
18094 switch (option
.kind
)
18097 /* This shouldn't happen. */
18098 printf (" NULL %" PRId16
" %" PRIx32
,
18099 option
.section
, option
.info
);
18103 printf (" REGINFO ");
18104 if (filedata
->file_header
.e_machine
== EM_MIPS
)
18106 Elf32_External_RegInfo
* ereg
;
18107 Elf32_RegInfo reginfo
;
18110 if (option
.size
< (sizeof (Elf_External_Options
)
18111 + sizeof (Elf32_External_RegInfo
)))
18113 printf (_("<corrupt>\n"));
18114 error (_("Truncated MIPS REGINFO option\n"));
18119 ereg
= (Elf32_External_RegInfo
*) (eoption
+ 1);
18121 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
18122 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
18123 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
18124 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
18125 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
18126 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
18128 printf ("GPR %08" PRIx32
" GP 0x%" PRIx32
"\n",
18129 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
18131 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
18132 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
18133 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
18134 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
18139 Elf64_External_RegInfo
* ereg
;
18140 Elf64_Internal_RegInfo reginfo
;
18142 if (option
.size
< (sizeof (Elf_External_Options
)
18143 + sizeof (Elf64_External_RegInfo
)))
18145 printf (_("<corrupt>\n"));
18146 error (_("Truncated MIPS REGINFO option\n"));
18151 ereg
= (Elf64_External_RegInfo
*) (eoption
+ 1);
18152 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
18153 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
18154 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
18155 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
18156 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
18157 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
18159 printf ("GPR %08" PRIx32
" GP 0x%" PRIx64
"\n",
18160 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
18162 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
18163 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
18164 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
18165 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
18167 offset
+= option
.size
;
18170 case ODK_EXCEPTIONS
:
18171 fputs (" EXCEPTIONS fpe_min(", stdout
);
18172 process_mips_fpe_exception (option
.info
& OEX_FPU_MIN
);
18173 fputs (") fpe_max(", stdout
);
18174 process_mips_fpe_exception ((option
.info
& OEX_FPU_MAX
) >> 8);
18175 fputs (")", stdout
);
18177 if (option
.info
& OEX_PAGE0
)
18178 fputs (" PAGE0", stdout
);
18179 if (option
.info
& OEX_SMM
)
18180 fputs (" SMM", stdout
);
18181 if (option
.info
& OEX_FPDBUG
)
18182 fputs (" FPDBUG", stdout
);
18183 if (option
.info
& OEX_DISMISS
)
18184 fputs (" DISMISS", stdout
);
18188 fputs (" PAD ", stdout
);
18189 if (option
.info
& OPAD_PREFIX
)
18190 fputs (" PREFIX", stdout
);
18191 if (option
.info
& OPAD_POSTFIX
)
18192 fputs (" POSTFIX", stdout
);
18193 if (option
.info
& OPAD_SYMBOL
)
18194 fputs (" SYMBOL", stdout
);
18198 fputs (" HWPATCH ", stdout
);
18199 if (option
.info
& OHW_R4KEOP
)
18200 fputs (" R4KEOP", stdout
);
18201 if (option
.info
& OHW_R8KPFETCH
)
18202 fputs (" R8KPFETCH", stdout
);
18203 if (option
.info
& OHW_R5KEOP
)
18204 fputs (" R5KEOP", stdout
);
18205 if (option
.info
& OHW_R5KCVTL
)
18206 fputs (" R5KCVTL", stdout
);
18210 fputs (" FILL ", stdout
);
18211 /* XXX Print content of info word? */
18215 fputs (" TAGS ", stdout
);
18216 /* XXX Print content of info word? */
18220 fputs (" HWAND ", stdout
);
18221 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
18222 fputs (" R4KEOP_CHECKED", stdout
);
18223 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
18224 fputs (" R4KEOP_CLEAN", stdout
);
18228 fputs (" HWOR ", stdout
);
18229 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
18230 fputs (" R4KEOP_CHECKED", stdout
);
18231 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
18232 fputs (" R4KEOP_CLEAN", stdout
);
18236 printf (" GP_GROUP %#06x self-contained %#06x",
18237 option
.info
& OGP_GROUP
,
18238 (option
.info
& OGP_SELF
) >> 16);
18242 printf (" IDENT %#06x self-contained %#06x",
18243 option
.info
& OGP_GROUP
,
18244 (option
.info
& OGP_SELF
) >> 16);
18248 /* This shouldn't happen. */
18249 printf (" %3d ??? %" PRId16
" %" PRIx32
,
18250 option
.kind
, option
.section
, option
.info
);
18254 len
= sizeof (* eopt
);
18255 while (len
< option
.size
)
18257 unsigned char datum
= *((unsigned char *) eoption
+ len
);
18259 if (ISPRINT (datum
))
18260 printf ("%c", datum
);
18262 printf ("\\%03o", datum
);
18265 fputs ("\n", stdout
);
18267 offset
+= option
.size
;
18275 if (conflicts_offset
!= 0 && conflictsno
!= 0)
18277 Elf32_Conflict
* iconf
;
18280 if (filedata
->dynamic_symbols
== NULL
)
18282 error (_("conflict list found without a dynamic symbol table\n"));
18286 /* PR 21345 - print a slightly more helpful error message
18287 if we are sure that the cmalloc will fail. */
18288 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
18290 error (_("Overlarge number of conflicts detected: %lx\n"),
18291 (long) conflictsno
);
18295 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
18298 error (_("Out of memory allocating space for dynamic conflicts\n"));
18304 Elf32_External_Conflict
* econf32
;
18306 econf32
= (Elf32_External_Conflict
*)
18307 get_data (NULL
, filedata
, conflicts_offset
,
18308 sizeof (*econf32
), conflictsno
, _("conflict"));
18315 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18316 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
18322 Elf64_External_Conflict
* econf64
;
18324 econf64
= (Elf64_External_Conflict
*)
18325 get_data (NULL
, filedata
, conflicts_offset
,
18326 sizeof (*econf64
), conflictsno
, _("conflict"));
18333 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18334 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
18339 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
18340 "\nSection '.conflict' contains %lu entries:\n",
18341 (unsigned long) conflictsno
),
18342 (unsigned long) conflictsno
);
18343 puts (_(" Num: Index Value Name"));
18345 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18347 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
18349 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
18350 printf (_("<corrupt symbol index>"));
18353 Elf_Internal_Sym
* psym
;
18355 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
18356 print_vma (psym
->st_value
, FULL_HEX
);
18358 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
18359 print_symbol (25, GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
18361 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18369 if (pltgot
!= 0 && local_gotno
!= 0)
18371 bfd_vma ent
, local_end
, global_end
;
18373 unsigned char * data
;
18374 unsigned char * data_end
;
18378 addr_size
= (is_32bit_elf
? 4 : 8);
18379 local_end
= pltgot
+ local_gotno
* addr_size
;
18381 /* PR binutils/17533 file: 012-111227-0.004 */
18382 if (symtabno
< gotsym
)
18384 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
18385 (unsigned long) gotsym
, (unsigned long) symtabno
);
18389 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
18390 /* PR 17531: file: 54c91a34. */
18391 if (global_end
< local_end
)
18393 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
18397 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
18398 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
18399 global_end
- pltgot
, 1,
18400 _("Global Offset Table data"));
18401 /* PR 12855: Null data is handled gracefully throughout. */
18402 data_end
= data
+ (global_end
- pltgot
);
18404 printf (_("\nPrimary GOT:\n"));
18405 printf (_(" Canonical gp value: "));
18406 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
18409 printf (_(" Reserved entries:\n"));
18410 printf (_(" %*s %10s %*s Purpose\n"),
18411 addr_size
* 2, _("Address"), _("Access"),
18412 addr_size
* 2, _("Initial"));
18413 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18414 printf (_(" Lazy resolver\n"));
18415 if (ent
== (bfd_vma
) -1)
18416 goto got_print_fail
;
18418 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
18419 This entry will be used by some runtime loaders, to store the
18420 module pointer. Otherwise this is an ordinary local entry.
18421 PR 21344: Check for the entry being fully available before
18424 && data
+ ent
- pltgot
+ addr_size
<= data_end
18425 && (byte_get (data
+ ent
- pltgot
, addr_size
)
18426 >> (addr_size
* 8 - 1)) != 0)
18428 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18429 printf (_(" Module pointer (GNU extension)\n"));
18430 if (ent
== (bfd_vma
) -1)
18431 goto got_print_fail
;
18435 if (data
!= NULL
&& ent
< local_end
)
18437 printf (_(" Local entries:\n"));
18438 printf (" %*s %10s %*s\n",
18439 addr_size
* 2, _("Address"), _("Access"),
18440 addr_size
* 2, _("Initial"));
18441 while (ent
< local_end
)
18443 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18445 if (ent
== (bfd_vma
) -1)
18446 goto got_print_fail
;
18451 if (data
!= NULL
&& gotsym
< symtabno
)
18455 printf (_(" Global entries:\n"));
18456 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
18457 addr_size
* 2, _("Address"),
18459 addr_size
* 2, _("Initial"),
18460 addr_size
* 2, _("Sym.Val."),
18462 /* Note for translators: "Ndx" = abbreviated form of "Index". */
18463 _("Ndx"), _("Name"));
18465 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
18467 for (i
= gotsym
; i
< symtabno
; i
++)
18469 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18472 if (filedata
->dynamic_symbols
== NULL
)
18473 printf (_("<no dynamic symbols>"));
18474 else if (i
< filedata
->num_dynamic_syms
)
18476 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
18478 print_vma (psym
->st_value
, LONG_HEX
);
18479 printf (" %-7s %3s ",
18480 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
18481 get_symbol_index_type (filedata
, psym
->st_shndx
));
18483 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
18484 print_symbol (sym_width
,
18485 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
18487 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18490 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
18491 (unsigned long) i
);
18494 if (ent
== (bfd_vma
) -1)
18504 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
18507 size_t offset
, rel_offset
;
18508 unsigned long count
, i
;
18509 unsigned char * data
;
18510 int addr_size
, sym_width
;
18511 Elf_Internal_Rela
* rels
;
18513 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
18514 if (pltrel
== DT_RELA
)
18516 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
18521 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
18526 addr_size
= (is_32bit_elf
? 4 : 8);
18527 end
= mips_pltgot
+ (2 + count
) * addr_size
;
18529 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
18530 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
18531 1, _("Procedure Linkage Table data"));
18538 printf ("\nPLT GOT:\n\n");
18539 printf (_(" Reserved entries:\n"));
18540 printf (_(" %*s %*s Purpose\n"),
18541 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
18542 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18543 printf (_(" PLT lazy resolver\n"));
18544 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18545 printf (_(" Module pointer\n"));
18548 printf (_(" Entries:\n"));
18549 printf (" %*s %*s %*s %-7s %3s %s\n",
18550 addr_size
* 2, _("Address"),
18551 addr_size
* 2, _("Initial"),
18552 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
18553 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
18554 for (i
= 0; i
< count
; i
++)
18556 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
18558 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18561 if (idx
>= filedata
->num_dynamic_syms
)
18562 printf (_("<corrupt symbol index: %lu>"), idx
);
18565 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
18567 print_vma (psym
->st_value
, LONG_HEX
);
18568 printf (" %-7s %3s ",
18569 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
18570 get_symbol_index_type (filedata
, psym
->st_shndx
));
18571 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
18572 print_symbol (sym_width
,
18573 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
18575 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18589 process_nds32_specific (Filedata
* filedata
)
18591 Elf_Internal_Shdr
*sect
= NULL
;
18593 sect
= find_section (filedata
, ".nds32_e_flags");
18594 if (sect
!= NULL
&& sect
->sh_size
>= 4)
18596 unsigned char *buf
;
18599 printf ("\nNDS32 elf flags section:\n");
18600 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
18601 _("NDS32 elf flags section"));
18606 flag
= byte_get (buf
, 4);
18608 switch (flag
& 0x3)
18611 printf ("(VEC_SIZE):\tNo entry.\n");
18614 printf ("(VEC_SIZE):\t4 bytes\n");
18617 printf ("(VEC_SIZE):\t16 bytes\n");
18620 printf ("(VEC_SIZE):\treserved\n");
18629 process_gnu_liblist (Filedata
* filedata
)
18631 Elf_Internal_Shdr
* section
;
18632 Elf_Internal_Shdr
* string_sec
;
18633 Elf32_External_Lib
* elib
;
18635 size_t strtab_size
;
18637 unsigned long num_liblist
;
18644 for (i
= 0, section
= filedata
->section_headers
;
18645 i
< filedata
->file_header
.e_shnum
;
18648 switch (section
->sh_type
)
18650 case SHT_GNU_LIBLIST
:
18651 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
18654 elib
= (Elf32_External_Lib
*)
18655 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
18656 _("liblist section data"));
18664 string_sec
= filedata
->section_headers
+ section
->sh_link
;
18665 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
18666 string_sec
->sh_size
,
18667 _("liblist string table"));
18669 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
18676 strtab_size
= string_sec
->sh_size
;
18678 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
18679 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
18680 "\nLibrary list section '%s' contains %lu entries:\n",
18682 printable_section_name (filedata
, section
),
18685 puts (_(" Library Time Stamp Checksum Version Flags"));
18687 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
18695 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
18696 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
18697 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
18698 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
18699 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
18701 tmp
= gmtime (&atime
);
18702 snprintf (timebuf
, sizeof (timebuf
),
18703 "%04u-%02u-%02uT%02u:%02u:%02u",
18704 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
18705 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
18707 printf ("%3lu: ", (unsigned long) cnt
);
18709 printf ("%-20s", liblist
.l_name
< strtab_size
18710 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
18712 printf ("%-20.20s", liblist
.l_name
< strtab_size
18713 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
18714 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
18715 liblist
.l_version
, liblist
.l_flags
);
18726 static const char *
18727 get_note_type (Filedata
* filedata
, unsigned e_type
)
18729 static char buff
[64];
18731 if (filedata
->file_header
.e_type
== ET_CORE
)
18735 return _("NT_AUXV (auxiliary vector)");
18737 return _("NT_PRSTATUS (prstatus structure)");
18739 return _("NT_FPREGSET (floating point registers)");
18741 return _("NT_PRPSINFO (prpsinfo structure)");
18742 case NT_TASKSTRUCT
:
18743 return _("NT_TASKSTRUCT (task structure)");
18745 return _("NT_GDB_TDESC (GDB XML target description)");
18747 return _("NT_PRXFPREG (user_xfpregs structure)");
18749 return _("NT_PPC_VMX (ppc Altivec registers)");
18751 return _("NT_PPC_VSX (ppc VSX registers)");
18753 return _("NT_PPC_TAR (ppc TAR register)");
18755 return _("NT_PPC_PPR (ppc PPR register)");
18757 return _("NT_PPC_DSCR (ppc DSCR register)");
18759 return _("NT_PPC_EBB (ppc EBB registers)");
18761 return _("NT_PPC_PMU (ppc PMU registers)");
18762 case NT_PPC_TM_CGPR
:
18763 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
18764 case NT_PPC_TM_CFPR
:
18765 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
18766 case NT_PPC_TM_CVMX
:
18767 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
18768 case NT_PPC_TM_CVSX
:
18769 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
18770 case NT_PPC_TM_SPR
:
18771 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
18772 case NT_PPC_TM_CTAR
:
18773 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
18774 case NT_PPC_TM_CPPR
:
18775 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
18776 case NT_PPC_TM_CDSCR
:
18777 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
18779 return _("NT_386_TLS (x86 TLS information)");
18780 case NT_386_IOPERM
:
18781 return _("NT_386_IOPERM (x86 I/O permissions)");
18782 case NT_X86_XSTATE
:
18783 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
18785 return _("NT_X86_CET (x86 CET state)");
18786 case NT_S390_HIGH_GPRS
:
18787 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
18788 case NT_S390_TIMER
:
18789 return _("NT_S390_TIMER (s390 timer register)");
18790 case NT_S390_TODCMP
:
18791 return _("NT_S390_TODCMP (s390 TOD comparator register)");
18792 case NT_S390_TODPREG
:
18793 return _("NT_S390_TODPREG (s390 TOD programmable register)");
18795 return _("NT_S390_CTRS (s390 control registers)");
18796 case NT_S390_PREFIX
:
18797 return _("NT_S390_PREFIX (s390 prefix register)");
18798 case NT_S390_LAST_BREAK
:
18799 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
18800 case NT_S390_SYSTEM_CALL
:
18801 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
18803 return _("NT_S390_TDB (s390 transaction diagnostic block)");
18804 case NT_S390_VXRS_LOW
:
18805 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
18806 case NT_S390_VXRS_HIGH
:
18807 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
18808 case NT_S390_GS_CB
:
18809 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
18810 case NT_S390_GS_BC
:
18811 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
18813 return _("NT_ARM_VFP (arm VFP registers)");
18815 return _("NT_ARM_TLS (AArch TLS registers)");
18816 case NT_ARM_HW_BREAK
:
18817 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
18818 case NT_ARM_HW_WATCH
:
18819 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
18821 return _("NT_ARM_SVE (AArch SVE registers)");
18822 case NT_ARM_PAC_MASK
:
18823 return _("NT_ARM_PAC_MASK (AArch pointer authentication code masks)");
18824 case NT_ARM_TAGGED_ADDR_CTRL
:
18825 return _("NT_ARM_TAGGED_ADDR_CTRL (AArch tagged address control)");
18827 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
18829 return _("NT_RISCV_CSR (RISC-V control and status registers)");
18831 return _("NT_PSTATUS (pstatus structure)");
18833 return _("NT_FPREGS (floating point registers)");
18835 return _("NT_PSINFO (psinfo structure)");
18837 return _("NT_LWPSTATUS (lwpstatus_t structure)");
18839 return _("NT_LWPSINFO (lwpsinfo_t structure)");
18840 case NT_WIN32PSTATUS
:
18841 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
18843 return _("NT_SIGINFO (siginfo_t data)");
18845 return _("NT_FILE (mapped files)");
18853 return _("NT_VERSION (version)");
18855 return _("NT_ARCH (architecture)");
18856 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
18858 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
18860 case NT_GO_BUILDID
:
18861 return _("GO BUILDID");
18866 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18871 print_core_note (Elf_Internal_Note
*pnote
)
18873 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
18874 bfd_vma count
, page_size
;
18875 unsigned char *descdata
, *filenames
, *descend
;
18877 if (pnote
->type
!= NT_FILE
)
18887 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
18888 /* Still "successful". */
18893 if (pnote
->descsz
< 2 * addr_size
)
18895 error (_(" Malformed note - too short for header\n"));
18899 descdata
= (unsigned char *) pnote
->descdata
;
18900 descend
= descdata
+ pnote
->descsz
;
18902 if (descdata
[pnote
->descsz
- 1] != '\0')
18904 error (_(" Malformed note - does not end with \\0\n"));
18908 count
= byte_get (descdata
, addr_size
);
18909 descdata
+= addr_size
;
18911 page_size
= byte_get (descdata
, addr_size
);
18912 descdata
+= addr_size
;
18914 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
18915 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
18917 error (_(" Malformed note - too short for supplied file count\n"));
18921 printf (_(" Page size: "));
18922 print_vma (page_size
, DEC
);
18925 printf (_(" %*s%*s%*s\n"),
18926 (int) (2 + 2 * addr_size
), _("Start"),
18927 (int) (4 + 2 * addr_size
), _("End"),
18928 (int) (4 + 2 * addr_size
), _("Page Offset"));
18929 filenames
= descdata
+ count
* 3 * addr_size
;
18930 while (count
-- > 0)
18932 bfd_vma start
, end
, file_ofs
;
18934 if (filenames
== descend
)
18936 error (_(" Malformed note - filenames end too early\n"));
18940 start
= byte_get (descdata
, addr_size
);
18941 descdata
+= addr_size
;
18942 end
= byte_get (descdata
, addr_size
);
18943 descdata
+= addr_size
;
18944 file_ofs
= byte_get (descdata
, addr_size
);
18945 descdata
+= addr_size
;
18948 print_vma (start
, FULL_HEX
);
18950 print_vma (end
, FULL_HEX
);
18952 print_vma (file_ofs
, FULL_HEX
);
18953 printf ("\n %s\n", filenames
);
18955 filenames
+= 1 + strlen ((char *) filenames
);
18961 static const char *
18962 get_gnu_elf_note_type (unsigned e_type
)
18964 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
18967 case NT_GNU_ABI_TAG
:
18968 return _("NT_GNU_ABI_TAG (ABI version tag)");
18970 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
18971 case NT_GNU_BUILD_ID
:
18972 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
18973 case NT_GNU_GOLD_VERSION
:
18974 return _("NT_GNU_GOLD_VERSION (gold version)");
18975 case NT_GNU_PROPERTY_TYPE_0
:
18976 return _("NT_GNU_PROPERTY_TYPE_0");
18977 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
18978 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
18979 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
18980 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
18983 static char buff
[64];
18985 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18992 decode_x86_compat_isa (unsigned int bitmask
)
18996 unsigned int bit
= bitmask
& (- bitmask
);
19001 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
19004 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
19007 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
19010 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
19013 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
19016 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
19019 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
19022 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
19025 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
19028 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
19031 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
19034 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
19035 printf ("AVX512F");
19037 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
19038 printf ("AVX512CD");
19040 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
19041 printf ("AVX512ER");
19043 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
19044 printf ("AVX512PF");
19046 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
19047 printf ("AVX512VL");
19049 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
19050 printf ("AVX512DQ");
19052 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
19053 printf ("AVX512BW");
19056 printf (_("<unknown: %x>"), bit
);
19065 decode_x86_compat_2_isa (unsigned int bitmask
)
19069 printf (_("<None>"));
19075 unsigned int bit
= bitmask
& (- bitmask
);
19080 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_CMOV
:
19083 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE
:
19086 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE2
:
19089 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE3
:
19092 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSSE3
:
19095 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_1
:
19098 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_2
:
19101 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX
:
19104 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX2
:
19107 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_FMA
:
19110 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512F
:
19111 printf ("AVX512F");
19113 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512CD
:
19114 printf ("AVX512CD");
19116 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512ER
:
19117 printf ("AVX512ER");
19119 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512PF
:
19120 printf ("AVX512PF");
19122 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512VL
:
19123 printf ("AVX512VL");
19125 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512DQ
:
19126 printf ("AVX512DQ");
19128 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512BW
:
19129 printf ("AVX512BW");
19131 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4FMAPS
:
19132 printf ("AVX512_4FMAPS");
19134 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4VNNIW
:
19135 printf ("AVX512_4VNNIW");
19137 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BITALG
:
19138 printf ("AVX512_BITALG");
19140 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_IFMA
:
19141 printf ("AVX512_IFMA");
19143 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI
:
19144 printf ("AVX512_VBMI");
19146 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI2
:
19147 printf ("AVX512_VBMI2");
19149 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VNNI
:
19150 printf ("AVX512_VNNI");
19152 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BF16
:
19153 printf ("AVX512_BF16");
19156 printf (_("<unknown: %x>"), bit
);
19165 decode_x86_isa (unsigned int bitmask
)
19169 unsigned int bit
= bitmask
& (- bitmask
);
19174 case GNU_PROPERTY_X86_ISA_1_BASELINE
:
19175 printf ("x86-64-baseline");
19177 case GNU_PROPERTY_X86_ISA_1_V2
:
19178 printf ("x86-64-v2");
19180 case GNU_PROPERTY_X86_ISA_1_V3
:
19181 printf ("x86-64-v3");
19183 case GNU_PROPERTY_X86_ISA_1_V4
:
19184 printf ("x86-64-v4");
19187 printf (_("<unknown: %x>"), bit
);
19196 decode_x86_feature_1 (unsigned int bitmask
)
19200 printf (_("<None>"));
19206 unsigned int bit
= bitmask
& (- bitmask
);
19211 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
19214 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
19217 case GNU_PROPERTY_X86_FEATURE_1_LAM_U48
:
19218 printf ("LAM_U48");
19220 case GNU_PROPERTY_X86_FEATURE_1_LAM_U57
:
19221 printf ("LAM_U57");
19224 printf (_("<unknown: %x>"), bit
);
19233 decode_x86_feature_2 (unsigned int bitmask
)
19237 printf (_("<None>"));
19243 unsigned int bit
= bitmask
& (- bitmask
);
19248 case GNU_PROPERTY_X86_FEATURE_2_X86
:
19251 case GNU_PROPERTY_X86_FEATURE_2_X87
:
19254 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
19257 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
19260 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
19263 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
19266 case GNU_PROPERTY_X86_FEATURE_2_TMM
:
19269 case GNU_PROPERTY_X86_FEATURE_2_MASK
:
19272 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
19275 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
19278 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
19279 printf ("XSAVEOPT");
19281 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
19285 printf (_("<unknown: %x>"), bit
);
19294 decode_aarch64_feature_1_and (unsigned int bitmask
)
19298 unsigned int bit
= bitmask
& (- bitmask
);
19303 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
19307 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
19312 printf (_("<unknown: %x>"), bit
);
19321 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
19323 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
19324 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
19325 unsigned int size
= is_32bit_elf
? 4 : 8;
19327 printf (_(" Properties: "));
19329 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
19331 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
19335 while (ptr
< ptr_end
)
19339 unsigned int datasz
;
19341 if ((size_t) (ptr_end
- ptr
) < 8)
19343 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
19347 type
= byte_get (ptr
, 4);
19348 datasz
= byte_get (ptr
+ 4, 4);
19352 if (datasz
> (size_t) (ptr_end
- ptr
))
19354 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
19359 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
19361 if (filedata
->file_header
.e_machine
== EM_X86_64
19362 || filedata
->file_header
.e_machine
== EM_IAMCU
19363 || filedata
->file_header
.e_machine
== EM_386
)
19365 unsigned int bitmask
;
19368 bitmask
= byte_get (ptr
, 4);
19374 case GNU_PROPERTY_X86_ISA_1_USED
:
19376 printf (_("x86 ISA used: <corrupt length: %#x> "),
19380 printf ("x86 ISA used: ");
19381 decode_x86_isa (bitmask
);
19385 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
19387 printf (_("x86 ISA needed: <corrupt length: %#x> "),
19391 printf ("x86 ISA needed: ");
19392 decode_x86_isa (bitmask
);
19396 case GNU_PROPERTY_X86_FEATURE_1_AND
:
19398 printf (_("x86 feature: <corrupt length: %#x> "),
19402 printf ("x86 feature: ");
19403 decode_x86_feature_1 (bitmask
);
19407 case GNU_PROPERTY_X86_FEATURE_2_USED
:
19409 printf (_("x86 feature used: <corrupt length: %#x> "),
19413 printf ("x86 feature used: ");
19414 decode_x86_feature_2 (bitmask
);
19418 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
19420 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
19423 printf ("x86 feature needed: ");
19424 decode_x86_feature_2 (bitmask
);
19428 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
19430 printf (_("x86 ISA used: <corrupt length: %#x> "),
19434 printf ("x86 ISA used: ");
19435 decode_x86_compat_isa (bitmask
);
19439 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
19441 printf (_("x86 ISA needed: <corrupt length: %#x> "),
19445 printf ("x86 ISA needed: ");
19446 decode_x86_compat_isa (bitmask
);
19450 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_USED
:
19452 printf (_("x86 ISA used: <corrupt length: %#x> "),
19456 printf ("x86 ISA used: ");
19457 decode_x86_compat_2_isa (bitmask
);
19461 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_NEEDED
:
19463 printf (_("x86 ISA needed: <corrupt length: %#x> "),
19467 printf ("x86 ISA needed: ");
19468 decode_x86_compat_2_isa (bitmask
);
19476 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
19478 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
19480 printf ("AArch64 feature: ");
19482 printf (_("<corrupt length: %#x> "), datasz
);
19484 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
19493 case GNU_PROPERTY_STACK_SIZE
:
19494 printf (_("stack size: "));
19495 if (datasz
!= size
)
19496 printf (_("<corrupt length: %#x> "), datasz
);
19498 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
19501 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
19502 printf ("no copy on protected ");
19504 printf (_("<corrupt length: %#x> "), datasz
);
19508 if ((type
>= GNU_PROPERTY_UINT32_AND_LO
19509 && type
<= GNU_PROPERTY_UINT32_AND_HI
)
19510 || (type
>= GNU_PROPERTY_UINT32_OR_LO
19511 && type
<= GNU_PROPERTY_UINT32_OR_HI
))
19513 if (type
<= GNU_PROPERTY_UINT32_AND_HI
)
19514 printf (_("UINT32_AND (%#x): "), type
);
19516 printf (_("UINT32_OR (%#x): "), type
);
19518 printf (_("<corrupt length: %#x> "), datasz
);
19520 printf ("%#x", (unsigned int) byte_get (ptr
, 4));
19527 if (type
< GNU_PROPERTY_LOPROC
)
19528 printf (_("<unknown type %#x data: "), type
);
19529 else if (type
< GNU_PROPERTY_LOUSER
)
19530 printf (_("<processor-specific type %#x data: "), type
);
19532 printf (_("<application-specific type %#x data: "), type
);
19533 for (j
= 0; j
< datasz
; ++j
)
19534 printf ("%02x ", ptr
[j
] & 0xff);
19538 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
19539 if (ptr
== ptr_end
)
19552 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
19554 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
19555 switch (pnote
->type
)
19557 case NT_GNU_BUILD_ID
:
19561 printf (_(" Build ID: "));
19562 for (i
= 0; i
< pnote
->descsz
; ++i
)
19563 printf ("%02x", pnote
->descdata
[i
] & 0xff);
19568 case NT_GNU_ABI_TAG
:
19570 unsigned long os
, major
, minor
, subminor
;
19571 const char *osname
;
19573 /* PR 17531: file: 030-599401-0.004. */
19574 if (pnote
->descsz
< 16)
19576 printf (_(" <corrupt GNU_ABI_TAG>\n"));
19580 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19581 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19582 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
19583 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
19587 case GNU_ABI_TAG_LINUX
:
19590 case GNU_ABI_TAG_HURD
:
19593 case GNU_ABI_TAG_SOLARIS
:
19594 osname
= "Solaris";
19596 case GNU_ABI_TAG_FREEBSD
:
19597 osname
= "FreeBSD";
19599 case GNU_ABI_TAG_NETBSD
:
19602 case GNU_ABI_TAG_SYLLABLE
:
19603 osname
= "Syllable";
19605 case GNU_ABI_TAG_NACL
:
19609 osname
= "Unknown";
19613 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
19614 major
, minor
, subminor
);
19618 case NT_GNU_GOLD_VERSION
:
19622 printf (_(" Version: "));
19623 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
19624 printf ("%c", pnote
->descdata
[i
]);
19631 unsigned long num_entries
, mask
;
19633 /* Hardware capabilities information. Word 0 is the number of entries.
19634 Word 1 is a bitmask of enabled entries. The rest of the descriptor
19635 is a series of entries, where each entry is a single byte followed
19636 by a nul terminated string. The byte gives the bit number to test
19637 if enabled in the bitmask. */
19638 printf (_(" Hardware Capabilities: "));
19639 if (pnote
->descsz
< 8)
19641 error (_("<corrupt GNU_HWCAP>\n"));
19644 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19645 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19646 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
19647 /* FIXME: Add code to display the entries... */
19651 case NT_GNU_PROPERTY_TYPE_0
:
19652 print_gnu_property_note (filedata
, pnote
);
19656 /* Handle unrecognised types. An error message should have already been
19657 created by get_gnu_elf_note_type(), so all that we need to do is to
19658 display the data. */
19662 printf (_(" Description data: "));
19663 for (i
= 0; i
< pnote
->descsz
; ++i
)
19664 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19673 static const char *
19674 get_v850_elf_note_type (enum v850_notes n_type
)
19676 static char buff
[64];
19680 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
19681 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
19682 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
19683 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
19684 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
19685 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
19687 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
19693 print_v850_note (Elf_Internal_Note
* pnote
)
19697 if (pnote
->descsz
!= 4)
19700 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
19704 printf (_("not set\n"));
19708 switch (pnote
->type
)
19710 case V850_NOTE_ALIGNMENT
:
19713 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return true;
19714 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return true;
19718 case V850_NOTE_DATA_SIZE
:
19721 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return true;
19722 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return true;
19726 case V850_NOTE_FPU_INFO
:
19729 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return true;
19730 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return true;
19734 case V850_NOTE_MMU_INFO
:
19735 case V850_NOTE_CACHE_INFO
:
19736 case V850_NOTE_SIMD_INFO
:
19737 if (val
== EF_RH850_SIMD
)
19739 printf (_("yes\n"));
19745 /* An 'unknown note type' message will already have been displayed. */
19749 printf (_("unknown value: %x\n"), val
);
19754 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
19756 unsigned int version
;
19758 switch (pnote
->type
)
19760 case NT_NETBSD_IDENT
:
19761 if (pnote
->descsz
< 1)
19763 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
19764 if ((version
/ 10000) % 100)
19765 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
19766 version
, version
/ 100000000, (version
/ 1000000) % 100,
19767 (version
/ 10000) % 100 > 26 ? "Z" : "",
19768 'A' + (version
/ 10000) % 26);
19770 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
19771 version
, version
/ 100000000, (version
/ 1000000) % 100,
19772 (version
/ 100) % 100);
19775 case NT_NETBSD_MARCH
:
19776 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
19780 case NT_NETBSD_PAX
:
19781 if (pnote
->descsz
< 1)
19783 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
19784 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
19785 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
19786 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
19787 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
19788 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
19789 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
19790 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
19794 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
19795 pnote
->descsz
, pnote
->type
);
19799 static const char *
19800 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
19804 case NT_FREEBSD_THRMISC
:
19805 return _("NT_THRMISC (thrmisc structure)");
19806 case NT_FREEBSD_PROCSTAT_PROC
:
19807 return _("NT_PROCSTAT_PROC (proc data)");
19808 case NT_FREEBSD_PROCSTAT_FILES
:
19809 return _("NT_PROCSTAT_FILES (files data)");
19810 case NT_FREEBSD_PROCSTAT_VMMAP
:
19811 return _("NT_PROCSTAT_VMMAP (vmmap data)");
19812 case NT_FREEBSD_PROCSTAT_GROUPS
:
19813 return _("NT_PROCSTAT_GROUPS (groups data)");
19814 case NT_FREEBSD_PROCSTAT_UMASK
:
19815 return _("NT_PROCSTAT_UMASK (umask data)");
19816 case NT_FREEBSD_PROCSTAT_RLIMIT
:
19817 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
19818 case NT_FREEBSD_PROCSTAT_OSREL
:
19819 return _("NT_PROCSTAT_OSREL (osreldate data)");
19820 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
19821 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
19822 case NT_FREEBSD_PROCSTAT_AUXV
:
19823 return _("NT_PROCSTAT_AUXV (auxv data)");
19824 case NT_FREEBSD_PTLWPINFO
:
19825 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
19827 return get_note_type (filedata
, e_type
);
19830 static const char *
19831 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
19833 static char buff
[64];
19837 case NT_NETBSDCORE_PROCINFO
:
19838 /* NetBSD core "procinfo" structure. */
19839 return _("NetBSD procinfo structure");
19841 case NT_NETBSDCORE_AUXV
:
19842 return _("NetBSD ELF auxiliary vector data");
19844 case NT_NETBSDCORE_LWPSTATUS
:
19845 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
19848 /* As of Jan 2020 there are no other machine-independent notes
19849 defined for NetBSD core files. If the note type is less
19850 than the start of the machine-dependent note types, we don't
19853 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
19855 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19861 switch (filedata
->file_header
.e_machine
)
19863 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
19864 and PT_GETFPREGS == mach+2. */
19869 case EM_SPARC32PLUS
:
19873 case NT_NETBSDCORE_FIRSTMACH
+ 0:
19874 return _("PT_GETREGS (reg structure)");
19875 case NT_NETBSDCORE_FIRSTMACH
+ 2:
19876 return _("PT_GETFPREGS (fpreg structure)");
19882 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
19883 There's also old PT___GETREGS40 == mach + 1 for old reg
19884 structure which lacks GBR. */
19888 case NT_NETBSDCORE_FIRSTMACH
+ 1:
19889 return _("PT___GETREGS40 (old reg structure)");
19890 case NT_NETBSDCORE_FIRSTMACH
+ 3:
19891 return _("PT_GETREGS (reg structure)");
19892 case NT_NETBSDCORE_FIRSTMACH
+ 5:
19893 return _("PT_GETFPREGS (fpreg structure)");
19899 /* On all other arch's, PT_GETREGS == mach+1 and
19900 PT_GETFPREGS == mach+3. */
19904 case NT_NETBSDCORE_FIRSTMACH
+ 1:
19905 return _("PT_GETREGS (reg structure)");
19906 case NT_NETBSDCORE_FIRSTMACH
+ 3:
19907 return _("PT_GETFPREGS (fpreg structure)");
19913 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
19914 e_type
- NT_NETBSDCORE_FIRSTMACH
);
19918 static const char *
19919 get_stapsdt_note_type (unsigned e_type
)
19921 static char buff
[64];
19926 return _("NT_STAPSDT (SystemTap probe descriptors)");
19932 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19937 print_stapsdt_note (Elf_Internal_Note
*pnote
)
19939 size_t len
, maxlen
;
19940 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
19941 char *data
= pnote
->descdata
;
19942 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
19943 bfd_vma pc
, base_addr
, semaphore
;
19944 char *provider
, *probe
, *arg_fmt
;
19946 if (pnote
->descsz
< (addr_size
* 3))
19947 goto stapdt_note_too_small
;
19949 pc
= byte_get ((unsigned char *) data
, addr_size
);
19952 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
19955 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
19958 if (data
>= data_end
)
19959 goto stapdt_note_too_small
;
19960 maxlen
= data_end
- data
;
19961 len
= strnlen (data
, maxlen
);
19968 goto stapdt_note_too_small
;
19970 if (data
>= data_end
)
19971 goto stapdt_note_too_small
;
19972 maxlen
= data_end
- data
;
19973 len
= strnlen (data
, maxlen
);
19980 goto stapdt_note_too_small
;
19982 if (data
>= data_end
)
19983 goto stapdt_note_too_small
;
19984 maxlen
= data_end
- data
;
19985 len
= strnlen (data
, maxlen
);
19992 goto stapdt_note_too_small
;
19994 printf (_(" Provider: %s\n"), provider
);
19995 printf (_(" Name: %s\n"), probe
);
19996 printf (_(" Location: "));
19997 print_vma (pc
, FULL_HEX
);
19998 printf (_(", Base: "));
19999 print_vma (base_addr
, FULL_HEX
);
20000 printf (_(", Semaphore: "));
20001 print_vma (semaphore
, FULL_HEX
);
20003 printf (_(" Arguments: %s\n"), arg_fmt
);
20005 return data
== data_end
;
20007 stapdt_note_too_small
:
20008 printf (_(" <corrupt - note is too small>\n"));
20009 error (_("corrupt stapdt note - the data size is too small\n"));
20013 static const char *
20014 get_ia64_vms_note_type (unsigned e_type
)
20016 static char buff
[64];
20021 return _("NT_VMS_MHD (module header)");
20023 return _("NT_VMS_LNM (language name)");
20025 return _("NT_VMS_SRC (source files)");
20027 return "NT_VMS_TITLE";
20029 return _("NT_VMS_EIDC (consistency check)");
20030 case NT_VMS_FPMODE
:
20031 return _("NT_VMS_FPMODE (FP mode)");
20032 case NT_VMS_LINKTIME
:
20033 return "NT_VMS_LINKTIME";
20034 case NT_VMS_IMGNAM
:
20035 return _("NT_VMS_IMGNAM (image name)");
20037 return _("NT_VMS_IMGID (image id)");
20038 case NT_VMS_LINKID
:
20039 return _("NT_VMS_LINKID (link id)");
20040 case NT_VMS_IMGBID
:
20041 return _("NT_VMS_IMGBID (build id)");
20042 case NT_VMS_GSTNAM
:
20043 return _("NT_VMS_GSTNAM (sym table name)");
20044 case NT_VMS_ORIG_DYN
:
20045 return "NT_VMS_ORIG_DYN";
20046 case NT_VMS_PATCHTIME
:
20047 return "NT_VMS_PATCHTIME";
20049 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
20055 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
20057 int maxlen
= pnote
->descsz
;
20059 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
20060 goto desc_size_fail
;
20062 switch (pnote
->type
)
20066 goto desc_size_fail
;
20068 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
20070 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
20071 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
20072 if (l
+ 34 < maxlen
)
20074 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
20075 if (l
+ 35 < maxlen
)
20076 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
20078 printf (_(" Module version : <missing>\n"));
20082 printf (_(" Module name : <missing>\n"));
20083 printf (_(" Module version : <missing>\n"));
20088 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
20092 case NT_VMS_FPMODE
:
20093 printf (_(" Floating Point mode: "));
20095 goto desc_size_fail
;
20096 /* FIXME: Generate an error if descsz > 8 ? */
20098 printf ("0x%016" BFD_VMA_FMT
"x\n",
20099 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
20102 case NT_VMS_LINKTIME
:
20103 printf (_(" Link time: "));
20105 goto desc_size_fail
;
20106 /* FIXME: Generate an error if descsz > 8 ? */
20109 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
20113 case NT_VMS_PATCHTIME
:
20114 printf (_(" Patch time: "));
20116 goto desc_size_fail
;
20117 /* FIXME: Generate an error if descsz > 8 ? */
20120 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
20124 case NT_VMS_ORIG_DYN
:
20126 goto desc_size_fail
;
20128 printf (_(" Major id: %u, minor id: %u\n"),
20129 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
20130 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
20131 printf (_(" Last modified : "));
20133 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
20134 printf (_("\n Link flags : "));
20135 printf ("0x%016" BFD_VMA_FMT
"x\n",
20136 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
20137 printf (_(" Header flags: 0x%08x\n"),
20138 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
20139 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
20143 case NT_VMS_IMGNAM
:
20144 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
20147 case NT_VMS_GSTNAM
:
20148 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
20152 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
20155 case NT_VMS_LINKID
:
20156 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
20166 printf (_(" <corrupt - data size is too small>\n"));
20167 error (_("corrupt IA64 note: data size is too small\n"));
20171 struct build_attr_cache
{
20172 Filedata
*filedata
;
20174 unsigned long strtablen
;
20175 Elf_Internal_Sym
*symtab
;
20176 unsigned long nsyms
;
20179 /* Find the symbol associated with a build attribute that is attached
20180 to address OFFSET. If PNAME is non-NULL then store the name of
20181 the symbol (if found) in the provided pointer, Returns NULL if a
20182 symbol could not be found. */
20184 static Elf_Internal_Sym
*
20185 get_symbol_for_build_attribute (Filedata
*filedata
,
20186 unsigned long offset
,
20188 const char **pname
)
20190 Elf_Internal_Sym
*saved_sym
= NULL
;
20191 Elf_Internal_Sym
*sym
;
20193 if (filedata
->section_headers
!= NULL
20194 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
20196 Elf_Internal_Shdr
* symsec
;
20198 free (ba_cache
.strtab
);
20199 ba_cache
.strtab
= NULL
;
20200 free (ba_cache
.symtab
);
20201 ba_cache
.symtab
= NULL
;
20203 /* Load the symbol and string sections. */
20204 for (symsec
= filedata
->section_headers
;
20205 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
20208 if (symsec
->sh_type
== SHT_SYMTAB
20209 && get_symtab (filedata
, symsec
,
20210 &ba_cache
.symtab
, &ba_cache
.nsyms
,
20211 &ba_cache
.strtab
, &ba_cache
.strtablen
))
20214 ba_cache
.filedata
= filedata
;
20217 if (ba_cache
.symtab
== NULL
)
20220 /* Find a symbol whose value matches offset. */
20221 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
20222 if (sym
->st_value
== offset
)
20224 if (sym
->st_name
>= ba_cache
.strtablen
)
20225 /* Huh ? This should not happen. */
20228 if (ba_cache
.strtab
[sym
->st_name
] == 0)
20231 /* The AArch64 and ARM architectures define mapping symbols
20232 (eg $d, $x, $t) which we want to ignore. */
20233 if (ba_cache
.strtab
[sym
->st_name
] == '$'
20234 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
20235 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
20240 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
20241 and FILE or OBJECT symbols over NOTYPE symbols. We skip
20242 FUNC symbols entirely. */
20243 switch (ELF_ST_TYPE (sym
->st_info
))
20250 /* If the symbol has a size associated
20251 with it then we can stop searching. */
20252 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
20257 /* Ignore function symbols. */
20264 switch (ELF_ST_BIND (sym
->st_info
))
20267 if (saved_sym
== NULL
20268 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
20273 if (saved_sym
== NULL
)
20283 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
20291 if (saved_sym
&& pname
)
20292 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
20297 /* Returns true iff addr1 and addr2 are in the same section. */
20300 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
20302 Elf_Internal_Shdr
* a1
;
20303 Elf_Internal_Shdr
* a2
;
20305 a1
= find_section_by_address (filedata
, addr1
);
20306 a2
= find_section_by_address (filedata
, addr2
);
20308 return a1
== a2
&& a1
!= NULL
;
20312 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
20313 Filedata
* filedata
)
20315 static unsigned long global_offset
= 0;
20316 static unsigned long global_end
= 0;
20317 static unsigned long func_offset
= 0;
20318 static unsigned long func_end
= 0;
20320 Elf_Internal_Sym
*sym
;
20322 unsigned long start
;
20324 bool is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
20326 switch (pnote
->descsz
)
20329 /* A zero-length description means that the range of
20330 the previous note of the same type should be used. */
20333 if (global_end
> global_offset
)
20334 printf (_(" Applies to region from %#lx to %#lx\n"),
20335 global_offset
, global_end
);
20337 printf (_(" Applies to region from %#lx\n"), global_offset
);
20341 if (func_end
> func_offset
)
20342 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
20344 printf (_(" Applies to region from %#lx\n"), func_offset
);
20349 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20354 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20355 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
20359 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
20360 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
20364 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
20365 printf (_(" <invalid descsz>"));
20370 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
20371 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
20372 in order to avoid them being confused with the start address of the
20373 first function in the file... */
20374 if (sym
== NULL
&& is_open_attr
)
20375 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
20378 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
20379 end
= start
+ sym
->st_size
;
20383 /* FIXME: Need to properly allow for section alignment.
20384 16 is just the alignment used on x86_64. */
20386 && start
> BFD_ALIGN (global_end
, 16)
20387 /* Build notes are not guaranteed to be organised in order of
20388 increasing address, but we should find the all of the notes
20389 for one section in the same place. */
20390 && same_section (filedata
, start
, global_end
))
20391 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
20392 global_end
+ 1, start
- 1);
20394 printf (_(" Applies to region from %#lx"), start
);
20395 global_offset
= start
;
20399 printf (_(" to %#lx"), end
);
20405 printf (_(" Applies to region from %#lx"), start
);
20406 func_offset
= start
;
20410 printf (_(" to %#lx"), end
);
20416 printf (_(" (%s)"), name
);
20423 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
20425 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
20426 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
20427 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
20429 char name_attribute
;
20430 const char * expected_types
;
20431 const char * name
= pnote
->namedata
;
20435 if (name
== NULL
|| pnote
->namesz
< 2)
20437 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
20438 print_symbol (-20, _(" <corrupt name>"));
20447 /* Version 2 of the spec adds a "GA" prefix to the name field. */
20448 if (name
[0] == 'G' && name
[1] == 'A')
20450 if (pnote
->namesz
< 4)
20452 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
20453 print_symbol (-20, _(" <corrupt name>"));
20462 switch ((name_type
= * name
))
20464 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
20465 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
20466 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
20467 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
20468 printf ("%c", * name
);
20472 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
20473 print_symbol (-20, _("<unknown name type>"));
20480 switch ((name_attribute
= * name
))
20482 case GNU_BUILD_ATTRIBUTE_VERSION
:
20483 text
= _("<version>");
20484 expected_types
= string_expected
;
20487 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
20488 text
= _("<stack prot>");
20489 expected_types
= "!+*";
20492 case GNU_BUILD_ATTRIBUTE_RELRO
:
20493 text
= _("<relro>");
20494 expected_types
= bool_expected
;
20497 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
20498 text
= _("<stack size>");
20499 expected_types
= number_expected
;
20502 case GNU_BUILD_ATTRIBUTE_TOOL
:
20503 text
= _("<tool>");
20504 expected_types
= string_expected
;
20507 case GNU_BUILD_ATTRIBUTE_ABI
:
20509 expected_types
= "$*";
20512 case GNU_BUILD_ATTRIBUTE_PIC
:
20514 expected_types
= number_expected
;
20517 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
20518 text
= _("<short enum>");
20519 expected_types
= bool_expected
;
20523 if (ISPRINT (* name
))
20525 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
20527 if (len
> left
&& ! do_wide
)
20529 printf ("%.*s:", len
, name
);
20535 static char tmpbuf
[128];
20537 error (_("unrecognised byte in name field: %d\n"), * name
);
20538 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
20542 expected_types
= "*$!+";
20547 left
-= printf ("%s", text
);
20549 if (strchr (expected_types
, name_type
) == NULL
)
20550 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
20552 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
20554 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
20555 (unsigned long) pnote
->namesz
,
20556 (long) (name
- pnote
->namedata
));
20560 if (left
< 1 && ! do_wide
)
20565 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
20567 unsigned int bytes
;
20568 unsigned long long val
= 0;
20569 unsigned int shift
= 0;
20570 char * decoded
= NULL
;
20572 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
20574 /* The -1 is because the name field is always 0 terminated, and we
20575 want to be able to ensure that the shift in the while loop below
20576 will not overflow. */
20579 if (bytes
> sizeof (val
))
20581 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
20583 bytes
= sizeof (val
);
20585 /* We do not bother to warn if bytes == 0 as this can
20586 happen with some early versions of the gcc plugin. */
20590 unsigned long long byte
= *name
++ & 0xff;
20592 val
|= byte
<< shift
;
20596 switch (name_attribute
)
20598 case GNU_BUILD_ATTRIBUTE_PIC
:
20601 case 0: decoded
= "static"; break;
20602 case 1: decoded
= "pic"; break;
20603 case 2: decoded
= "PIC"; break;
20604 case 3: decoded
= "pie"; break;
20605 case 4: decoded
= "PIE"; break;
20609 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
20612 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
20613 case 0: decoded
= "off"; break;
20614 case 1: decoded
= "on"; break;
20615 case 2: decoded
= "all"; break;
20616 case 3: decoded
= "strong"; break;
20617 case 4: decoded
= "explicit"; break;
20625 if (decoded
!= NULL
)
20627 print_symbol (-left
, decoded
);
20638 left
-= printf ("0x%llx", val
);
20640 left
-= printf ("0x%-.*llx", left
, val
);
20644 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
20645 left
-= print_symbol (- left
, name
);
20647 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
20648 left
-= print_symbol (- left
, "true");
20650 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
20651 left
-= print_symbol (- left
, "false");
20655 if (do_wide
&& left
> 0)
20656 printf ("%-*s", left
, " ");
20661 /* Note that by the ELF standard, the name field is already null byte
20662 terminated, and namesz includes the terminating null byte.
20663 I.E. the value of namesz for the name "FSF" is 4.
20665 If the value of namesz is zero, there is no name present. */
20668 process_note (Elf_Internal_Note
* pnote
,
20669 Filedata
* filedata
)
20671 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
20674 if (pnote
->namesz
== 0)
20675 /* If there is no note name, then use the default set of
20676 note type strings. */
20677 nt
= get_note_type (filedata
, pnote
->type
);
20679 else if (startswith (pnote
->namedata
, "GNU"))
20680 /* GNU-specific object file notes. */
20681 nt
= get_gnu_elf_note_type (pnote
->type
);
20683 else if (startswith (pnote
->namedata
, "FreeBSD"))
20684 /* FreeBSD-specific core file notes. */
20685 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
20687 else if (startswith (pnote
->namedata
, "NetBSD-CORE"))
20688 /* NetBSD-specific core file notes. */
20689 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
20691 else if (startswith (pnote
->namedata
, "NetBSD"))
20692 /* NetBSD-specific core file notes. */
20693 return process_netbsd_elf_note (pnote
);
20695 else if (startswith (pnote
->namedata
, "PaX"))
20696 /* NetBSD-specific core file notes. */
20697 return process_netbsd_elf_note (pnote
);
20699 else if (startswith (pnote
->namedata
, "SPU/"))
20701 /* SPU-specific core file notes. */
20702 nt
= pnote
->namedata
+ 4;
20706 else if (startswith (pnote
->namedata
, "IPF/VMS"))
20707 /* VMS/ia64-specific file notes. */
20708 nt
= get_ia64_vms_note_type (pnote
->type
);
20710 else if (startswith (pnote
->namedata
, "stapsdt"))
20711 nt
= get_stapsdt_note_type (pnote
->type
);
20714 /* Don't recognize this note name; just use the default set of
20715 note type strings. */
20716 nt
= get_note_type (filedata
, pnote
->type
);
20720 if (((startswith (pnote
->namedata
, "GA")
20721 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
20722 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
20723 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
20724 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
20725 print_gnu_build_attribute_name (pnote
);
20727 print_symbol (-20, name
);
20730 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
20732 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
20734 if (startswith (pnote
->namedata
, "IPF/VMS"))
20735 return print_ia64_vms_note (pnote
);
20736 else if (startswith (pnote
->namedata
, "GNU"))
20737 return print_gnu_note (filedata
, pnote
);
20738 else if (startswith (pnote
->namedata
, "stapsdt"))
20739 return print_stapsdt_note (pnote
);
20740 else if (startswith (pnote
->namedata
, "CORE"))
20741 return print_core_note (pnote
);
20742 else if (((startswith (pnote
->namedata
, "GA")
20743 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
20744 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
20745 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
20746 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
20747 return print_gnu_build_attribute_description (pnote
, filedata
);
20753 printf (_(" description data: "));
20754 for (i
= 0; i
< pnote
->descsz
; i
++)
20755 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
20767 process_notes_at (Filedata
* filedata
,
20768 Elf_Internal_Shdr
* section
,
20773 Elf_External_Note
*pnotes
;
20774 Elf_External_Note
*external
;
20783 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
20786 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
20794 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
20797 if (pnotes
== NULL
)
20802 if (filedata
->is_separate
)
20803 printf (_("In linked file '%s': "), filedata
->file_name
);
20807 printf (_("Displaying notes found in: %s\n"), printable_section_name (filedata
, section
));
20809 printf (_("Displaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
20810 (unsigned long) offset
, (unsigned long) length
);
20812 /* NB: Some note sections may have alignment value of 0 or 1. gABI
20813 specifies that notes should be aligned to 4 bytes in 32-bit
20814 objects and to 8 bytes in 64-bit objects. As a Linux extension,
20815 we also support 4 byte alignment in 64-bit objects. If section
20816 alignment is less than 4, we treate alignment as 4 bytes. */
20819 else if (align
!= 4 && align
!= 8)
20821 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
20827 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
20829 end
= (char *) pnotes
+ length
;
20830 while ((char *) external
< end
)
20832 Elf_Internal_Note inote
;
20835 char * temp
= NULL
;
20836 size_t data_remaining
= end
- (char *) external
;
20838 if (!is_ia64_vms (filedata
))
20840 /* PR binutils/15191
20841 Make sure that there is enough data to read. */
20842 min_notesz
= offsetof (Elf_External_Note
, name
);
20843 if (data_remaining
< min_notesz
)
20845 warn (ngettext ("Corrupt note: only %ld byte remains, "
20846 "not enough for a full note\n",
20847 "Corrupt note: only %ld bytes remain, "
20848 "not enough for a full note\n",
20850 (long) data_remaining
);
20853 data_remaining
-= min_notesz
;
20855 inote
.type
= BYTE_GET (external
->type
);
20856 inote
.namesz
= BYTE_GET (external
->namesz
);
20857 inote
.namedata
= external
->name
;
20858 inote
.descsz
= BYTE_GET (external
->descsz
);
20859 inote
.descdata
= ((char *) external
20860 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
20861 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20862 next
= ((char *) external
20863 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
20867 Elf64_External_VMS_Note
*vms_external
;
20869 /* PR binutils/15191
20870 Make sure that there is enough data to read. */
20871 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
20872 if (data_remaining
< min_notesz
)
20874 warn (ngettext ("Corrupt note: only %ld byte remains, "
20875 "not enough for a full note\n",
20876 "Corrupt note: only %ld bytes remain, "
20877 "not enough for a full note\n",
20879 (long) data_remaining
);
20882 data_remaining
-= min_notesz
;
20884 vms_external
= (Elf64_External_VMS_Note
*) external
;
20885 inote
.type
= BYTE_GET (vms_external
->type
);
20886 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
20887 inote
.namedata
= vms_external
->name
;
20888 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
20889 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
20890 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20891 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
20894 /* PR 17531: file: 3443835e. */
20895 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
20896 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
20897 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
20898 || (size_t) (next
- inote
.descdata
) < inote
.descsz
20899 || ((size_t) (next
- inote
.descdata
)
20900 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
20902 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
20903 (unsigned long) ((char *) external
- (char *) pnotes
));
20904 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
20905 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
20909 external
= (Elf_External_Note
*) next
;
20911 /* Verify that name is null terminated. It appears that at least
20912 one version of Linux (RedHat 6.0) generates corefiles that don't
20913 comply with the ELF spec by failing to include the null byte in
20915 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
20917 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
20919 temp
= (char *) malloc (inote
.namesz
+ 1);
20922 error (_("Out of memory allocating space for inote name\n"));
20927 memcpy (temp
, inote
.namedata
, inote
.namesz
);
20928 inote
.namedata
= temp
;
20930 inote
.namedata
[inote
.namesz
] = 0;
20933 if (! process_note (& inote
, filedata
))
20946 process_corefile_note_segments (Filedata
* filedata
)
20948 Elf_Internal_Phdr
*segment
;
20952 if (! get_program_headers (filedata
))
20955 for (i
= 0, segment
= filedata
->program_headers
;
20956 i
< filedata
->file_header
.e_phnum
;
20959 if (segment
->p_type
== PT_NOTE
)
20960 if (! process_notes_at (filedata
, NULL
,
20961 (bfd_vma
) segment
->p_offset
,
20962 (bfd_vma
) segment
->p_filesz
,
20963 (bfd_vma
) segment
->p_align
))
20971 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
20973 Elf_External_Note
* pnotes
;
20974 Elf_External_Note
* external
;
20981 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
20983 if (pnotes
== NULL
)
20987 end
= (char*) pnotes
+ length
;
20989 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
20990 (unsigned long) offset
, (unsigned long) length
);
20992 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
20994 Elf_External_Note
* next
;
20995 Elf_Internal_Note inote
;
20997 inote
.type
= BYTE_GET (external
->type
);
20998 inote
.namesz
= BYTE_GET (external
->namesz
);
20999 inote
.namedata
= external
->name
;
21000 inote
.descsz
= BYTE_GET (external
->descsz
);
21001 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
21002 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
21004 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
21006 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
21007 inote
.descdata
= inote
.namedata
;
21011 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
21013 if ( ((char *) next
> end
)
21014 || ((char *) next
< (char *) pnotes
))
21016 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
21017 (unsigned long) ((char *) external
- (char *) pnotes
));
21018 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
21019 inote
.type
, inote
.namesz
, inote
.descsz
);
21025 /* Prevent out-of-bounds indexing. */
21026 if ( inote
.namedata
+ inote
.namesz
> end
21027 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
21029 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
21030 (unsigned long) ((char *) external
- (char *) pnotes
));
21031 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
21032 inote
.type
, inote
.namesz
, inote
.descsz
);
21036 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
21038 if (! print_v850_note (& inote
))
21041 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
21042 inote
.namesz
, inote
.descsz
);
21052 process_note_sections (Filedata
* filedata
)
21054 Elf_Internal_Shdr
*section
;
21056 unsigned int n
= 0;
21059 for (i
= 0, section
= filedata
->section_headers
;
21060 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
21063 if (section
->sh_type
== SHT_NOTE
)
21065 if (! process_notes_at (filedata
, section
,
21066 (bfd_vma
) section
->sh_offset
,
21067 (bfd_vma
) section
->sh_size
,
21068 (bfd_vma
) section
->sh_addralign
))
21073 if (( filedata
->file_header
.e_machine
== EM_V800
21074 || filedata
->file_header
.e_machine
== EM_V850
21075 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
21076 && section
->sh_type
== SHT_RENESAS_INFO
)
21078 if (! process_v850_notes (filedata
,
21079 (bfd_vma
) section
->sh_offset
,
21080 (bfd_vma
) section
->sh_size
))
21087 /* Try processing NOTE segments instead. */
21088 return process_corefile_note_segments (filedata
);
21094 process_notes (Filedata
* filedata
)
21096 /* If we have not been asked to display the notes then do nothing. */
21100 if (filedata
->file_header
.e_type
!= ET_CORE
)
21101 return process_note_sections (filedata
);
21103 /* No program headers means no NOTE segment. */
21104 if (filedata
->file_header
.e_phnum
> 0)
21105 return process_corefile_note_segments (filedata
);
21107 if (filedata
->is_separate
)
21108 printf (_("No notes found in linked file '%s'.\n"),
21109 filedata
->file_name
);
21111 printf (_("No notes found file.\n"));
21116 static unsigned char *
21117 display_public_gnu_attributes (unsigned char * start
,
21118 const unsigned char * const end
)
21120 printf (_(" Unknown GNU attribute: %s\n"), start
);
21122 start
+= strnlen ((char *) start
, end
- start
);
21123 display_raw_attribute (start
, end
);
21125 return (unsigned char *) end
;
21128 static unsigned char *
21129 display_generic_attribute (unsigned char * start
,
21131 const unsigned char * const end
)
21134 return (unsigned char *) end
;
21136 return display_tag_value (tag
, start
, end
);
21140 process_arch_specific (Filedata
* filedata
)
21145 switch (filedata
->file_header
.e_machine
)
21148 case EM_ARC_COMPACT
:
21149 case EM_ARC_COMPACT2
:
21150 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
21151 display_arc_attribute
,
21152 display_generic_attribute
);
21154 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
21155 display_arm_attribute
,
21156 display_generic_attribute
);
21159 case EM_MIPS_RS3_LE
:
21160 return process_mips_specific (filedata
);
21163 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
21164 display_msp430_attribute
,
21165 display_msp430_gnu_attribute
);
21168 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
21169 display_riscv_attribute
,
21170 display_generic_attribute
);
21173 return process_nds32_specific (filedata
);
21176 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21177 display_m68k_gnu_attribute
);
21181 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21182 display_power_gnu_attribute
);
21186 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21187 display_s390_gnu_attribute
);
21190 case EM_SPARC32PLUS
:
21192 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
21193 display_sparc_gnu_attribute
);
21196 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
21197 display_tic6x_attribute
,
21198 display_generic_attribute
);
21201 return process_attributes (filedata
, "csky", SHT_CSKY_ATTRIBUTES
,
21202 display_csky_attribute
, NULL
);
21205 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
21206 display_public_gnu_attributes
,
21207 display_generic_attribute
);
21212 get_file_header (Filedata
* filedata
)
21214 /* Read in the identity array. */
21215 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
21218 /* Determine how to read the rest of the header. */
21219 switch (filedata
->file_header
.e_ident
[EI_DATA
])
21224 byte_get
= byte_get_little_endian
;
21225 byte_put
= byte_put_little_endian
;
21228 byte_get
= byte_get_big_endian
;
21229 byte_put
= byte_put_big_endian
;
21233 /* For now we only support 32 bit and 64 bit ELF files. */
21234 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
21236 /* Read in the rest of the header. */
21239 Elf32_External_Ehdr ehdr32
;
21241 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
21244 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
21245 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
21246 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
21247 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
21248 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
21249 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
21250 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
21251 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
21252 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
21253 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
21254 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
21255 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
21256 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
21260 Elf64_External_Ehdr ehdr64
;
21262 /* If we have been compiled with sizeof (bfd_vma) == 4, then
21263 we will not be able to cope with the 64bit data found in
21264 64 ELF files. Detect this now and abort before we start
21265 overwriting things. */
21266 if (sizeof (bfd_vma
) < 8)
21268 error (_("This instance of readelf has been built without support for a\n\
21269 64 bit data type and so it cannot read 64 bit ELF files.\n"));
21273 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
21276 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
21277 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
21278 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
21279 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
21280 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
21281 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
21282 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
21283 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
21284 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
21285 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
21286 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
21287 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
21288 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
21295 free_filedata (Filedata
*filedata
)
21297 free (filedata
->program_interpreter
);
21298 free (filedata
->program_headers
);
21299 free (filedata
->section_headers
);
21300 free (filedata
->string_table
);
21301 free (filedata
->dump
.dump_sects
);
21302 free (filedata
->dynamic_strings
);
21303 free (filedata
->dynamic_symbols
);
21304 free (filedata
->dynamic_syminfo
);
21305 free (filedata
->dynamic_section
);
21307 while (filedata
->symtab_shndx_list
!= NULL
)
21309 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
21310 free (filedata
->symtab_shndx_list
);
21311 filedata
->symtab_shndx_list
= next
;
21314 free (filedata
->section_headers_groups
);
21316 if (filedata
->section_groups
)
21319 struct group_list
* g
;
21320 struct group_list
* next
;
21322 for (i
= 0; i
< filedata
->group_count
; i
++)
21324 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
21331 free (filedata
->section_groups
);
21333 memset (&filedata
->section_headers
, 0,
21334 sizeof (Filedata
) - offsetof (Filedata
, section_headers
));
21338 close_file (Filedata
* filedata
)
21342 if (filedata
->handle
)
21343 fclose (filedata
->handle
);
21349 close_debug_file (void * data
)
21351 free_filedata ((Filedata
*) data
);
21352 close_file ((Filedata
*) data
);
21356 open_file (const char * pathname
, bool is_separate
)
21358 struct stat statbuf
;
21359 Filedata
* filedata
= NULL
;
21361 if (stat (pathname
, & statbuf
) < 0
21362 || ! S_ISREG (statbuf
.st_mode
))
21365 filedata
= calloc (1, sizeof * filedata
);
21366 if (filedata
== NULL
)
21369 filedata
->handle
= fopen (pathname
, "rb");
21370 if (filedata
->handle
== NULL
)
21373 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
21374 filedata
->file_name
= pathname
;
21375 filedata
->is_separate
= is_separate
;
21377 if (! get_file_header (filedata
))
21380 if (!get_section_headers (filedata
, false))
21388 if (filedata
->handle
)
21389 fclose (filedata
->handle
);
21396 open_debug_file (const char * pathname
)
21398 return open_file (pathname
, true);
21402 initialise_dump_sects (Filedata
* filedata
)
21404 /* Initialise the dump_sects array from the cmdline_dump_sects array.
21405 Note we do this even if cmdline_dump_sects is empty because we
21406 must make sure that the dump_sets array is zeroed out before each
21407 object file is processed. */
21408 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
21409 memset (filedata
->dump
.dump_sects
, 0,
21410 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
21412 if (cmdline
.num_dump_sects
> 0)
21414 if (filedata
->dump
.num_dump_sects
== 0)
21415 /* A sneaky way of allocating the dump_sects array. */
21416 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
21418 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
21419 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
21420 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
21424 /* Process one ELF object file according to the command line options.
21425 This file may actually be stored in an archive. The file is
21426 positioned at the start of the ELF object. Returns TRUE if no
21427 problems were encountered, FALSE otherwise. */
21430 process_object (Filedata
* filedata
)
21432 bool have_separate_files
;
21436 if (! get_file_header (filedata
))
21438 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
21442 /* Initialise per file variables. */
21443 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
21444 filedata
->version_info
[i
] = 0;
21446 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
21447 filedata
->dynamic_info
[i
] = 0;
21448 filedata
->dynamic_info_DT_GNU_HASH
= 0;
21449 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
21451 /* Process the file. */
21453 printf (_("\nFile: %s\n"), filedata
->file_name
);
21455 initialise_dump_sects (filedata
);
21457 /* There may be some extensions in the first section header. Don't
21458 bomb if we can't read it. */
21459 get_section_headers (filedata
, true);
21461 if (! process_file_header (filedata
))
21467 /* Throw away the single section header read above, so that we
21468 re-read the entire set. */
21469 free (filedata
->section_headers
);
21470 filedata
->section_headers
= NULL
;
21472 if (! process_section_headers (filedata
))
21474 /* Without loaded section headers we cannot process lots of things. */
21475 do_unwind
= do_version
= do_dump
= do_arch
= false;
21477 if (! do_using_dynamic
)
21478 do_syms
= do_dyn_syms
= do_reloc
= false;
21481 if (! process_section_groups (filedata
))
21482 /* Without loaded section groups we cannot process unwind. */
21485 process_program_headers (filedata
);
21487 res
= process_dynamic_section (filedata
);
21489 if (! process_relocs (filedata
))
21492 if (! process_unwind (filedata
))
21495 if (! process_symbol_table (filedata
))
21498 if (! process_lto_symbol_tables (filedata
))
21501 if (! process_syminfo (filedata
))
21504 if (! process_version_sections (filedata
))
21507 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
21508 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
21510 have_separate_files
= false;
21512 if (! process_section_contents (filedata
))
21515 if (have_separate_files
)
21519 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
21521 initialise_dump_sects (d
->handle
);
21523 if (process_links
&& ! process_file_header (d
->handle
))
21525 else if (! process_section_headers (d
->handle
))
21527 else if (! process_section_contents (d
->handle
))
21529 else if (process_links
)
21531 if (! process_section_groups (d
->handle
))
21533 process_program_headers (d
->handle
);
21534 if (! process_dynamic_section (d
->handle
))
21536 if (! process_relocs (d
->handle
))
21538 if (! process_unwind (d
->handle
))
21540 if (! process_symbol_table (d
->handle
))
21542 if (! process_lto_symbol_tables (d
->handle
))
21544 if (! process_syminfo (d
->handle
))
21546 if (! process_version_sections (d
->handle
))
21548 if (! process_notes (d
->handle
))
21553 /* The file handles are closed by the call to free_debug_memory() below. */
21556 if (! process_notes (filedata
))
21559 if (! process_gnu_liblist (filedata
))
21562 if (! process_arch_specific (filedata
))
21566 free_filedata (filedata
);
21568 free_debug_memory ();
21573 /* Process an ELF archive.
21574 On entry the file is positioned just after the ARMAG string.
21575 Returns TRUE upon success, FALSE otherwise. */
21578 process_archive (Filedata
* filedata
, bool is_thin_archive
)
21580 struct archive_info arch
;
21581 struct archive_info nested_arch
;
21587 /* The ARCH structure is used to hold information about this archive. */
21588 arch
.file_name
= NULL
;
21590 arch
.index_array
= NULL
;
21591 arch
.sym_table
= NULL
;
21592 arch
.longnames
= NULL
;
21594 /* The NESTED_ARCH structure is used as a single-item cache of information
21595 about a nested archive (when members of a thin archive reside within
21596 another regular archive file). */
21597 nested_arch
.file_name
= NULL
;
21598 nested_arch
.file
= NULL
;
21599 nested_arch
.index_array
= NULL
;
21600 nested_arch
.sym_table
= NULL
;
21601 nested_arch
.longnames
= NULL
;
21603 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
21604 filedata
->file_size
, is_thin_archive
,
21605 do_archive_index
) != 0)
21611 if (do_archive_index
)
21613 if (arch
.sym_table
== NULL
)
21614 error (_("%s: unable to dump the index as none was found\n"),
21615 filedata
->file_name
);
21618 unsigned long i
, l
;
21619 unsigned long current_pos
;
21621 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
21622 "in the symbol table)\n"),
21623 filedata
->file_name
, (unsigned long) arch
.index_num
,
21626 current_pos
= ftell (filedata
->handle
);
21628 for (i
= l
= 0; i
< arch
.index_num
; i
++)
21631 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
21634 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
21637 if (member_name
!= NULL
)
21639 char * qualified_name
21640 = make_qualified_name (&arch
, &nested_arch
,
21643 if (qualified_name
!= NULL
)
21645 printf (_("Contents of binary %s at offset "),
21647 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
21649 free (qualified_name
);
21651 free (member_name
);
21655 if (l
>= arch
.sym_size
)
21657 error (_("%s: end of the symbol table reached "
21658 "before the end of the index\n"),
21659 filedata
->file_name
);
21663 /* PR 17531: file: 0b6630b2. */
21664 printf ("\t%.*s\n",
21665 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
21666 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
21669 if (arch
.uses_64bit_indices
)
21674 if (l
< arch
.sym_size
)
21676 error (ngettext ("%s: %ld byte remains in the symbol table, "
21677 "but without corresponding entries in "
21678 "the index table\n",
21679 "%s: %ld bytes remain in the symbol table, "
21680 "but without corresponding entries in "
21681 "the index table\n",
21682 arch
.sym_size
- l
),
21683 filedata
->file_name
, arch
.sym_size
- l
);
21687 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
21689 error (_("%s: failed to seek back to start of object files "
21690 "in the archive\n"),
21691 filedata
->file_name
);
21697 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
21698 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
21699 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
21700 && !do_section_groups
&& !do_dyn_syms
)
21702 ret
= true; /* Archive index only. */
21711 char * qualified_name
;
21713 /* Read the next archive header. */
21714 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
21716 error (_("%s: failed to seek to next archive header\n"),
21721 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
21722 if (got
!= sizeof arch
.arhdr
)
21726 /* PR 24049 - we cannot use filedata->file_name as this will
21727 have already been freed. */
21728 error (_("%s: failed to read archive header\n"), arch
.file_name
);
21733 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
21735 error (_("%s: did not find a valid archive header\n"),
21741 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
21743 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
21744 if (filedata
->archive_file_size
& 01)
21745 ++filedata
->archive_file_size
;
21747 name
= get_archive_member_name (&arch
, &nested_arch
);
21750 error (_("%s: bad archive file name\n"), arch
.file_name
);
21754 namelen
= strlen (name
);
21756 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
21757 if (qualified_name
== NULL
)
21759 error (_("%s: bad archive file name\n"), arch
.file_name
);
21765 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
21767 /* This is a proxy for an external member of a thin archive. */
21768 Filedata
* member_filedata
;
21769 char * member_file_name
= adjust_relative_path
21770 (filedata
->file_name
, name
, namelen
);
21773 if (member_file_name
== NULL
)
21775 free (qualified_name
);
21780 member_filedata
= open_file (member_file_name
, false);
21781 if (member_filedata
== NULL
)
21783 error (_("Input file '%s' is not readable.\n"), member_file_name
);
21784 free (member_file_name
);
21785 free (qualified_name
);
21790 filedata
->archive_file_offset
= arch
.nested_member_origin
;
21791 member_filedata
->file_name
= qualified_name
;
21793 /* The call to process_object() expects the file to be at the beginning. */
21794 rewind (member_filedata
->handle
);
21796 if (! process_object (member_filedata
))
21799 close_file (member_filedata
);
21800 free (member_file_name
);
21802 else if (is_thin_archive
)
21804 Filedata thin_filedata
;
21806 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
21808 /* PR 15140: Allow for corrupt thin archives. */
21809 if (nested_arch
.file
== NULL
)
21811 error (_("%s: contains corrupt thin archive: %s\n"),
21812 qualified_name
, name
);
21813 free (qualified_name
);
21820 /* This is a proxy for a member of a nested archive. */
21821 filedata
->archive_file_offset
21822 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
21824 /* The nested archive file will have been opened and setup by
21825 get_archive_member_name. */
21826 if (fseek (nested_arch
.file
, filedata
->archive_file_offset
,
21829 error (_("%s: failed to seek to archive member.\n"),
21830 nested_arch
.file_name
);
21831 free (qualified_name
);
21836 thin_filedata
.handle
= nested_arch
.file
;
21837 thin_filedata
.file_name
= qualified_name
;
21839 if (! process_object (& thin_filedata
))
21845 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
21846 filedata
->file_name
= qualified_name
;
21847 if (! process_object (filedata
))
21849 arch
.next_arhdr_offset
+= filedata
->archive_file_size
;
21850 /* Stop looping with "negative" archive_file_size. */
21851 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
21852 arch
.next_arhdr_offset
= -1ul;
21855 free (qualified_name
);
21859 if (nested_arch
.file
!= NULL
)
21860 fclose (nested_arch
.file
);
21861 release_archive (&nested_arch
);
21862 release_archive (&arch
);
21868 process_file (char * file_name
)
21870 Filedata
* filedata
= NULL
;
21871 struct stat statbuf
;
21872 char armag
[SARMAG
];
21875 if (stat (file_name
, &statbuf
) < 0)
21877 if (errno
== ENOENT
)
21878 error (_("'%s': No such file\n"), file_name
);
21880 error (_("Could not locate '%s'. System error message: %s\n"),
21881 file_name
, strerror (errno
));
21885 if (! S_ISREG (statbuf
.st_mode
))
21887 error (_("'%s' is not an ordinary file\n"), file_name
);
21891 filedata
= calloc (1, sizeof * filedata
);
21892 if (filedata
== NULL
)
21894 error (_("Out of memory allocating file data structure\n"));
21898 filedata
->file_name
= file_name
;
21899 filedata
->handle
= fopen (file_name
, "rb");
21900 if (filedata
->handle
== NULL
)
21902 error (_("Input file '%s' is not readable.\n"), file_name
);
21907 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
21909 error (_("%s: Failed to read file's magic number\n"), file_name
);
21910 fclose (filedata
->handle
);
21915 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
21916 filedata
->is_separate
= false;
21918 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
21920 if (! process_archive (filedata
, false))
21923 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
21925 if ( ! process_archive (filedata
, true))
21930 if (do_archive_index
&& !check_all
)
21931 error (_("File %s is not an archive so its index cannot be displayed.\n"),
21934 rewind (filedata
->handle
);
21935 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
21937 if (! process_object (filedata
))
21941 fclose (filedata
->handle
);
21942 free (filedata
->section_headers
);
21943 free (filedata
->program_headers
);
21944 free (filedata
->string_table
);
21945 free (filedata
->dump
.dump_sects
);
21948 free (ba_cache
.strtab
);
21949 ba_cache
.strtab
= NULL
;
21950 free (ba_cache
.symtab
);
21951 ba_cache
.symtab
= NULL
;
21952 ba_cache
.filedata
= NULL
;
21957 #ifdef SUPPORT_DISASSEMBLY
21958 /* Needed by the i386 disassembler. For extra credit, someone could
21959 fix this so that we insert symbolic addresses here, esp for GOT/PLT
21963 print_address (unsigned int addr
, FILE * outfile
)
21965 fprintf (outfile
,"0x%8.8x", addr
);
21968 /* Needed by the i386 disassembler. */
21971 db_task_printsym (unsigned int addr
)
21973 print_address (addr
, stderr
);
21978 main (int argc
, char ** argv
)
21982 #ifdef HAVE_LC_MESSAGES
21983 setlocale (LC_MESSAGES
, "");
21985 setlocale (LC_CTYPE
, "");
21986 bindtextdomain (PACKAGE
, LOCALEDIR
);
21987 textdomain (PACKAGE
);
21989 expandargv (&argc
, &argv
);
21991 parse_args (& cmdline
, argc
, argv
);
21993 if (optind
< (argc
- 1))
21994 /* When displaying information for more than one file,
21995 prefix the information with the file name. */
21997 else if (optind
>= argc
)
21999 /* Ensure that the warning is always displayed. */
22002 warn (_("Nothing to do.\n"));
22007 while (optind
< argc
)
22008 if (! process_file (argv
[optind
++]))
22011 free (cmdline
.dump_sects
);
22013 free (dump_ctf_symtab_name
);
22014 free (dump_ctf_strtab_name
);
22015 free (dump_ctf_parent_name
);
22017 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;