1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2020 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. */
52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
53 as this will allow us to read in and parse 64bit and 32bit ELF files.
54 Only do this if we believe that the compiler can support a 64 bit
55 data type. For now we only rely on GCC being able to do this. */
66 #include "elf/common.h"
67 #include "elf/external.h"
68 #include "elf/internal.h"
71 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
72 we can obtain the H8 reloc numbers. We need these for the
73 get_reloc_size() function. We include h8.h again after defining
74 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
79 /* Undo the effects of #including reloc-macros.h. */
81 #undef START_RELOC_NUMBERS
85 #undef END_RELOC_NUMBERS
86 #undef _RELOC_MACROS_H
88 /* The following headers use the elf/reloc-macros.h file to
89 automatically generate relocation recognition functions
90 such as elf_mips_reloc_type() */
92 #define RELOC_MACROS_GEN_FUNC
94 #include "elf/aarch64.h"
95 #include "elf/alpha.h"
100 #include "elf/cr16.h"
101 #include "elf/cris.h"
103 #include "elf/csky.h"
104 #include "elf/d10v.h"
105 #include "elf/d30v.h"
108 #include "elf/epiphany.h"
109 #include "elf/fr30.h"
111 #include "elf/ft32.h"
113 #include "elf/hppa.h"
114 #include "elf/i386.h"
115 #include "elf/i370.h"
116 #include "elf/i860.h"
117 #include "elf/i960.h"
118 #include "elf/ia64.h"
119 #include "elf/ip2k.h"
120 #include "elf/lm32.h"
121 #include "elf/iq2000.h"
122 #include "elf/m32c.h"
123 #include "elf/m32r.h"
124 #include "elf/m68k.h"
125 #include "elf/m68hc11.h"
126 #include "elf/s12z.h"
127 #include "elf/mcore.h"
129 #include "elf/metag.h"
130 #include "elf/microblaze.h"
131 #include "elf/mips.h"
132 #include "elf/mmix.h"
133 #include "elf/mn10200.h"
134 #include "elf/mn10300.h"
135 #include "elf/moxie.h"
137 #include "elf/msp430.h"
138 #include "elf/nds32.h"
140 #include "elf/nios2.h"
141 #include "elf/or1k.h"
144 #include "elf/ppc64.h"
146 #include "elf/riscv.h"
147 #include "elf/rl78.h"
149 #include "elf/s390.h"
150 #include "elf/score.h"
152 #include "elf/sparc.h"
154 #include "elf/tic6x.h"
155 #include "elf/tilegx.h"
156 #include "elf/tilepro.h"
157 #include "elf/v850.h"
159 #include "elf/visium.h"
160 #include "elf/wasm32.h"
161 #include "elf/x86-64.h"
162 #include "elf/xc16x.h"
163 #include "elf/xgate.h"
164 #include "elf/xstormy16.h"
165 #include "elf/xtensa.h"
169 #include "libiberty.h"
170 #include "safe-ctype.h"
171 #include "filenames.h"
174 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
177 typedef struct elf_section_list
179 Elf_Internal_Shdr
* hdr
;
180 struct elf_section_list
* next
;
183 /* Flag bits indicating particular types of dump. */
184 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
185 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
186 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
187 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
188 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
189 #define CTF_DUMP (1 << 5) /* The --ctf command line switch. */
191 typedef unsigned char dump_type
;
193 /* A linked list of the section names for which dumps were requested. */
194 struct dump_list_entry
198 struct dump_list_entry
* next
;
201 /* A dynamic array of flags indicating for which sections a dump
202 has been requested via command line switches. */
205 dump_type
* dump_sects
;
206 unsigned int num_dump_sects
;
209 static struct dump_data cmdline
;
211 static struct dump_list_entry
* dump_sects_byname
;
213 char * program_name
= "readelf";
215 static bfd_boolean show_name
= FALSE
;
216 static bfd_boolean do_dynamic
= FALSE
;
217 static bfd_boolean do_syms
= FALSE
;
218 static bfd_boolean do_dyn_syms
= FALSE
;
219 static bfd_boolean do_reloc
= FALSE
;
220 static bfd_boolean do_sections
= FALSE
;
221 static bfd_boolean do_section_groups
= FALSE
;
222 static bfd_boolean do_section_details
= FALSE
;
223 static bfd_boolean do_segments
= FALSE
;
224 static bfd_boolean do_unwind
= FALSE
;
225 static bfd_boolean do_using_dynamic
= FALSE
;
226 static bfd_boolean do_header
= FALSE
;
227 static bfd_boolean do_dump
= FALSE
;
228 static bfd_boolean do_version
= FALSE
;
229 static bfd_boolean do_histogram
= FALSE
;
230 static bfd_boolean do_debugging
= FALSE
;
231 static bfd_boolean do_ctf
= FALSE
;
232 static bfd_boolean do_arch
= FALSE
;
233 static bfd_boolean do_notes
= FALSE
;
234 static bfd_boolean do_archive_index
= FALSE
;
235 static bfd_boolean check_all
= FALSE
;
236 static bfd_boolean is_32bit_elf
= FALSE
;
237 static bfd_boolean decompress_dumps
= FALSE
;
238 static bfd_boolean do_not_show_symbol_truncation
= FALSE
;
239 static bfd_boolean do_demangle
= FALSE
; /* Pretty print C++ symbol names. */
240 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
242 static char *dump_ctf_parent_name
;
243 static char *dump_ctf_symtab_name
;
244 static char *dump_ctf_strtab_name
;
248 struct group_list
* next
;
249 unsigned int section_index
;
254 struct group_list
* root
;
255 unsigned int group_index
;
258 typedef struct filedata
260 const char * file_name
;
262 bfd_size_type file_size
;
263 Elf_Internal_Ehdr file_header
;
264 Elf_Internal_Shdr
* section_headers
;
265 Elf_Internal_Phdr
* program_headers
;
267 unsigned long string_table_length
;
268 unsigned long archive_file_offset
;
269 unsigned long archive_file_size
;
270 unsigned long dynamic_addr
;
271 bfd_size_type dynamic_size
;
273 Elf_Internal_Dyn
* dynamic_section
;
274 Elf_Internal_Shdr
* dynamic_strtab_section
;
275 char * dynamic_strings
;
276 unsigned long dynamic_strings_length
;
277 Elf_Internal_Shdr
* dynamic_symtab_section
;
278 unsigned long num_dynamic_syms
;
279 Elf_Internal_Sym
* dynamic_symbols
;
280 bfd_vma version_info
[16];
281 unsigned int dynamic_syminfo_nent
;
282 Elf_Internal_Syminfo
* dynamic_syminfo
;
283 unsigned long dynamic_syminfo_offset
;
284 bfd_size_type nbuckets
;
285 bfd_size_type nchains
;
288 bfd_size_type ngnubuckets
;
289 bfd_size_type ngnuchains
;
290 bfd_vma
* gnubuckets
;
294 char program_interpreter
[PATH_MAX
];
295 bfd_vma dynamic_info
[DT_ENCODING
];
296 bfd_vma dynamic_info_DT_GNU_HASH
;
297 bfd_vma dynamic_info_DT_MIPS_XHASH
;
298 elf_section_list
* symtab_shndx_list
;
300 struct group
* section_groups
;
301 struct group
** section_headers_groups
;
302 /* A dynamic array of flags indicating for which sections a dump of
303 some kind has been requested. It is reset on a per-object file
304 basis and then initialised from the cmdline_dump_sects array,
305 the results of interpreting the -w switch, and the
306 dump_sects_byname list. */
307 struct dump_data dump
;
310 /* How to print a vma value. */
311 typedef enum print_mode
323 /* Versioned symbol info. */
324 enum versioned_symbol_info
331 static const char * get_symbol_version_string
332 (Filedata
*, bfd_boolean
, const char *, unsigned long, unsigned,
333 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
337 #define SECTION_NAME(X) \
338 ((X) == NULL ? _("<none>") \
339 : filedata->string_table == NULL ? _("<no-strings>") \
340 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
341 : filedata->string_table + (X)->sh_name))
343 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
345 #define GET_ELF_SYMBOLS(file, section, sym_count) \
346 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
347 : get_64bit_elf_symbols (file, section, sym_count))
349 #define VALID_SYMBOL_NAME(strtab, strtab_size, offset) \
350 (strtab != NULL && offset < strtab_size)
351 #define VALID_DYNAMIC_NAME(filedata, offset) \
352 VALID_SYMBOL_NAME (filedata->dynamic_strings, \
353 filedata->dynamic_strings_length, offset)
354 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
355 already been called and verified that the string exists. */
356 #define GET_DYNAMIC_NAME(filedata, offset) \
357 (filedata->dynamic_strings + offset)
359 #define REMOVE_ARCH_BITS(ADDR) \
362 if (filedata->file_header.e_machine == EM_ARM) \
367 /* Get the correct GNU hash section name. */
368 #define GNU_HASH_SECTION_NAME(filedata) \
369 filedata->dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
371 /* Print a BFD_VMA to an internal buffer, for use in error messages.
372 BFD_FMA_FMT can't be used in translated strings. */
375 bfd_vmatoa (char *fmtch
, bfd_vma value
)
377 /* bfd_vmatoa is used more then once in a printf call for output.
378 Cycle through an array of buffers. */
379 static int buf_pos
= 0;
380 static struct bfd_vmatoa_buf
387 ret
= buf
[buf_pos
++].place
;
388 buf_pos
%= ARRAY_SIZE (buf
);
390 sprintf (fmt
, "%%%s%s", BFD_VMA_FMT
, fmtch
);
391 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
395 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
396 OFFSET + the offset of the current archive member, if we are examining an
397 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
398 allocate a buffer using malloc and fill that. In either case return the
399 pointer to the start of the retrieved data or NULL if something went wrong.
400 If something does go wrong and REASON is not NULL then emit an error
401 message using REASON as part of the context. */
404 get_data (void * var
,
406 unsigned long offset
,
412 bfd_size_type amt
= size
* nmemb
;
414 if (size
== 0 || nmemb
== 0)
417 /* If the size_t type is smaller than the bfd_size_type, eg because
418 you are building a 32-bit tool on a 64-bit host, then make sure
419 that when the sizes are cast to (size_t) no information is lost. */
420 if ((size_t) size
!= size
421 || (size_t) nmemb
!= nmemb
422 || (size_t) amt
!= amt
)
425 error (_("Size truncation prevents reading %s"
426 " elements of size %s for %s\n"),
427 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
431 /* Check for size overflow. */
432 if (amt
/ size
!= nmemb
|| (size_t) amt
+ 1 == 0)
435 error (_("Size overflow prevents reading %s"
436 " elements of size %s for %s\n"),
437 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
441 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
442 attempting to allocate memory when the read is bound to fail. */
443 if (filedata
->archive_file_offset
> filedata
->file_size
444 || offset
> filedata
->file_size
- filedata
->archive_file_offset
445 || amt
> filedata
->file_size
- filedata
->archive_file_offset
- offset
)
448 error (_("Reading %s bytes extends past end of file for %s\n"),
449 bfd_vmatoa ("u", amt
), reason
);
453 if (fseek (filedata
->handle
, filedata
->archive_file_offset
+ offset
,
457 error (_("Unable to seek to 0x%lx for %s\n"),
458 filedata
->archive_file_offset
+ offset
, reason
);
465 /* + 1 so that we can '\0' terminate invalid string table sections. */
466 mvar
= malloc ((size_t) amt
+ 1);
471 error (_("Out of memory allocating %s bytes for %s\n"),
472 bfd_vmatoa ("u", amt
), reason
);
476 ((char *) mvar
)[amt
] = '\0';
479 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
482 error (_("Unable to read in %s bytes of %s\n"),
483 bfd_vmatoa ("u", amt
), reason
);
492 /* Print a VMA value in the MODE specified.
493 Returns the number of characters displayed. */
496 print_vma (bfd_vma vma
, print_mode mode
)
508 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
515 return printf ("%5" BFD_VMA_FMT
"d", vma
);
521 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
524 return printf ("%" BFD_VMA_FMT
"d", vma
);
527 return printf ("%" BFD_VMA_FMT
"u", vma
);
530 /* FIXME: Report unrecognised mode ? */
535 /* Display a symbol on stdout. Handles the display of control characters and
536 multibye characters (assuming the host environment supports them).
538 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
540 If truncation will happen and do_not_show_symbol_truncation is FALSE then display
541 abs(WIDTH) - 5 characters followed by "[...]".
543 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
544 padding as necessary.
546 Returns the number of emitted characters. */
549 print_symbol (signed int width
, const char * symbol
)
551 bfd_boolean extra_padding
= FALSE
;
552 bfd_boolean do_dots
= FALSE
;
553 signed int num_printed
= 0;
554 #ifdef HAVE_MBSTATE_T
557 unsigned int width_remaining
;
558 const void * alloced_symbol
= NULL
;
562 /* Keep the width positive. This helps the code below. */
564 extra_padding
= TRUE
;
570 /* Set the remaining width to a very large value.
571 This simplifies the code below. */
572 width_remaining
= INT_MAX
;
575 width_remaining
= width
;
576 if (! do_not_show_symbol_truncation
577 && (int) strlen (symbol
) > width
)
579 width_remaining
-= 5;
580 if ((int) width_remaining
< 0)
586 #ifdef HAVE_MBSTATE_T
587 /* Initialise the multibyte conversion state. */
588 memset (& state
, 0, sizeof (state
));
591 if (do_demangle
&& *symbol
)
593 const char * res
= cplus_demangle (symbol
, demangle_flags
);
596 alloced_symbol
= symbol
= res
;
599 while (width_remaining
)
602 const char c
= *symbol
++;
607 /* Do not print control characters directly as they can affect terminal
608 settings. Such characters usually appear in the names generated
609 by the assembler for local labels. */
612 if (width_remaining
< 2)
615 printf ("^%c", c
+ 0x40);
616 width_remaining
-= 2;
619 else if (ISPRINT (c
))
627 #ifdef HAVE_MBSTATE_T
630 /* Let printf do the hard work of displaying multibyte characters. */
631 printf ("%.1s", symbol
- 1);
635 #ifdef HAVE_MBSTATE_T
636 /* Try to find out how many bytes made up the character that was
637 just printed. Advance the symbol pointer past the bytes that
639 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
643 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
649 num_printed
+= printf ("[...]");
651 if (extra_padding
&& num_printed
< width
)
653 /* Fill in the remaining spaces. */
654 printf ("%-*s", width
- num_printed
, " ");
658 free ((void *) alloced_symbol
);
662 /* Returns a pointer to a static buffer containing a printable version of
663 the given section's name. Like print_symbol, except that it does not try
664 to print multibyte characters, it just interprets them as hex values. */
667 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
669 #define MAX_PRINT_SEC_NAME_LEN 128
670 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
671 const char * name
= SECTION_NAME (sec
);
672 char * buf
= sec_name_buf
;
674 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
676 while ((c
= * name
++) != 0)
687 else if (ISPRINT (c
))
694 static char hex
[17] = "0123456789ABCDEF";
699 * buf
++ = hex
[(c
& 0xf0) >> 4];
700 * buf
++ = hex
[c
& 0x0f];
714 printable_section_name_from_index (Filedata
* filedata
, unsigned long ndx
)
716 if (ndx
>= filedata
->file_header
.e_shnum
)
717 return _("<corrupt>");
719 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
722 /* Return a pointer to section NAME, or NULL if no such section exists. */
724 static Elf_Internal_Shdr
*
725 find_section (Filedata
* filedata
, const char * name
)
729 if (filedata
->section_headers
== NULL
)
732 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
733 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
734 return filedata
->section_headers
+ i
;
739 /* Return a pointer to a section containing ADDR, or NULL if no such
742 static Elf_Internal_Shdr
*
743 find_section_by_address (Filedata
* filedata
, bfd_vma addr
)
747 if (filedata
->section_headers
== NULL
)
750 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
752 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
754 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
761 static Elf_Internal_Shdr
*
762 find_section_by_type (Filedata
* filedata
, unsigned int type
)
766 if (filedata
->section_headers
== NULL
)
769 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
771 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
773 if (sec
->sh_type
== type
)
780 /* Return a pointer to section NAME, or NULL if no such section exists,
781 restricted to the list of sections given in SET. */
783 static Elf_Internal_Shdr
*
784 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
788 if (filedata
->section_headers
== NULL
)
793 while ((i
= *set
++) > 0)
795 /* See PR 21156 for a reproducer. */
796 if (i
>= filedata
->file_header
.e_shnum
)
797 continue; /* FIXME: Should we issue an error message ? */
799 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
800 return filedata
->section_headers
+ i
;
804 return find_section (filedata
, name
);
807 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
808 This OS has so many departures from the ELF standard that we test it at
811 static inline bfd_boolean
812 is_ia64_vms (Filedata
* filedata
)
814 return filedata
->file_header
.e_machine
== EM_IA_64
815 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
818 /* Guess the relocation size commonly used by the specific machines. */
821 guess_is_rela (unsigned int e_machine
)
825 /* Targets that use REL relocations. */
842 /* Targets that use RELA relocations. */
846 case EM_ADAPTEVA_EPIPHANY
:
848 case EM_ALTERA_NIOS2
:
851 case EM_ARC_COMPACT2
:
872 case EM_LATTICEMICO32
:
881 case EM_CYGNUS_MN10200
:
883 case EM_CYGNUS_MN10300
:
919 case EM_MICROBLAZE_OLD
:
941 warn (_("Don't know about relocations on this machine architecture\n"));
946 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
947 Returns TRUE upon success, FALSE otherwise. If successful then a
948 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
949 and the number of relocs loaded is placed in *NRELASP. It is the caller's
950 responsibility to free the allocated buffer. */
953 slurp_rela_relocs (Filedata
* filedata
,
954 unsigned long rel_offset
,
955 unsigned long rel_size
,
956 Elf_Internal_Rela
** relasp
,
957 unsigned long * nrelasp
)
959 Elf_Internal_Rela
* relas
;
965 Elf32_External_Rela
* erelas
;
967 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
968 rel_size
, _("32-bit relocation data"));
972 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
974 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
975 sizeof (Elf_Internal_Rela
));
980 error (_("out of memory parsing relocs\n"));
984 for (i
= 0; i
< nrelas
; i
++)
986 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
987 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
988 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
995 Elf64_External_Rela
* erelas
;
997 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
998 rel_size
, _("64-bit relocation data"));
1002 nrelas
= rel_size
/ sizeof (Elf64_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
);
1020 /* The #ifdef BFD64 below is to prevent a compile time
1021 warning. We know that if we do not have a 64 bit data
1022 type that we will never execute this code anyway. */
1024 if (filedata
->file_header
.e_machine
== EM_MIPS
1025 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1027 /* In little-endian objects, r_info isn't really a
1028 64-bit little-endian value: it has a 32-bit
1029 little-endian symbol index followed by four
1030 individual byte fields. Reorder INFO
1032 bfd_vma inf
= relas
[i
].r_info
;
1033 inf
= (((inf
& 0xffffffff) << 32)
1034 | ((inf
>> 56) & 0xff)
1035 | ((inf
>> 40) & 0xff00)
1036 | ((inf
>> 24) & 0xff0000)
1037 | ((inf
>> 8) & 0xff000000));
1038 relas
[i
].r_info
= inf
;
1051 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1052 Returns TRUE upon success, FALSE otherwise. If successful then a
1053 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1054 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1055 responsibility to free the allocated buffer. */
1058 slurp_rel_relocs (Filedata
* filedata
,
1059 unsigned long rel_offset
,
1060 unsigned long rel_size
,
1061 Elf_Internal_Rela
** relsp
,
1062 unsigned long * nrelsp
)
1064 Elf_Internal_Rela
* rels
;
1070 Elf32_External_Rel
* erels
;
1072 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1073 rel_size
, _("32-bit relocation data"));
1077 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1079 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1084 error (_("out of memory parsing relocs\n"));
1088 for (i
= 0; i
< nrels
; i
++)
1090 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1091 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1092 rels
[i
].r_addend
= 0;
1099 Elf64_External_Rel
* erels
;
1101 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1102 rel_size
, _("64-bit relocation data"));
1106 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1108 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1113 error (_("out of memory parsing relocs\n"));
1117 for (i
= 0; i
< nrels
; i
++)
1119 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1120 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1121 rels
[i
].r_addend
= 0;
1123 /* The #ifdef BFD64 below is to prevent a compile time
1124 warning. We know that if we do not have a 64 bit data
1125 type that we will never execute this code anyway. */
1127 if (filedata
->file_header
.e_machine
== EM_MIPS
1128 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1130 /* In little-endian objects, r_info isn't really a
1131 64-bit little-endian value: it has a 32-bit
1132 little-endian symbol index followed by four
1133 individual byte fields. Reorder INFO
1135 bfd_vma inf
= rels
[i
].r_info
;
1136 inf
= (((inf
& 0xffffffff) << 32)
1137 | ((inf
>> 56) & 0xff)
1138 | ((inf
>> 40) & 0xff00)
1139 | ((inf
>> 24) & 0xff0000)
1140 | ((inf
>> 8) & 0xff000000));
1141 rels
[i
].r_info
= inf
;
1154 /* Returns the reloc type extracted from the reloc info field. */
1157 get_reloc_type (Filedata
* filedata
, bfd_vma reloc_info
)
1160 return ELF32_R_TYPE (reloc_info
);
1162 switch (filedata
->file_header
.e_machine
)
1165 /* Note: We assume that reloc_info has already been adjusted for us. */
1166 return ELF64_MIPS_R_TYPE (reloc_info
);
1169 return ELF64_R_TYPE_ID (reloc_info
);
1172 return ELF64_R_TYPE (reloc_info
);
1176 /* Return the symbol index extracted from the reloc info field. */
1179 get_reloc_symindex (bfd_vma reloc_info
)
1181 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1184 static inline bfd_boolean
1185 uses_msp430x_relocs (Filedata
* filedata
)
1188 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1189 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1190 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1191 /* TI compiler uses ELFOSABI_NONE. */
1192 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1195 /* Display the contents of the relocation data found at the specified
1199 dump_relocations (Filedata
* filedata
,
1200 unsigned long rel_offset
,
1201 unsigned long rel_size
,
1202 Elf_Internal_Sym
* symtab
,
1203 unsigned long nsyms
,
1205 unsigned long strtablen
,
1207 bfd_boolean is_dynsym
)
1210 Elf_Internal_Rela
* rels
;
1211 bfd_boolean res
= TRUE
;
1213 if (is_rela
== UNKNOWN
)
1214 is_rela
= guess_is_rela (filedata
->file_header
.e_machine
);
1218 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1223 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1232 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1234 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1239 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1241 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1249 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1251 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1256 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1258 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1262 for (i
= 0; i
< rel_size
; i
++)
1267 bfd_vma symtab_index
;
1270 offset
= rels
[i
].r_offset
;
1271 inf
= rels
[i
].r_info
;
1273 type
= get_reloc_type (filedata
, inf
);
1274 symtab_index
= get_reloc_symindex (inf
);
1278 printf ("%8.8lx %8.8lx ",
1279 (unsigned long) offset
& 0xffffffff,
1280 (unsigned long) inf
& 0xffffffff);
1285 ? "%16.16" BFD_VMA_FMT
"x %16.16" BFD_VMA_FMT
"x "
1286 : "%12.12" BFD_VMA_FMT
"x %12.12" BFD_VMA_FMT
"x ",
1290 switch (filedata
->file_header
.e_machine
)
1297 rtype
= elf_aarch64_reloc_type (type
);
1301 case EM_CYGNUS_M32R
:
1302 rtype
= elf_m32r_reloc_type (type
);
1307 rtype
= elf_i386_reloc_type (type
);
1312 rtype
= elf_m68hc11_reloc_type (type
);
1316 rtype
= elf_s12z_reloc_type (type
);
1320 rtype
= elf_m68k_reloc_type (type
);
1324 rtype
= elf_i960_reloc_type (type
);
1329 rtype
= elf_avr_reloc_type (type
);
1332 case EM_OLD_SPARCV9
:
1333 case EM_SPARC32PLUS
:
1336 rtype
= elf_sparc_reloc_type (type
);
1340 rtype
= elf_spu_reloc_type (type
);
1344 rtype
= v800_reloc_type (type
);
1347 case EM_CYGNUS_V850
:
1348 rtype
= v850_reloc_type (type
);
1352 case EM_CYGNUS_D10V
:
1353 rtype
= elf_d10v_reloc_type (type
);
1357 case EM_CYGNUS_D30V
:
1358 rtype
= elf_d30v_reloc_type (type
);
1362 rtype
= elf_dlx_reloc_type (type
);
1366 rtype
= elf_sh_reloc_type (type
);
1370 case EM_CYGNUS_MN10300
:
1371 rtype
= elf_mn10300_reloc_type (type
);
1375 case EM_CYGNUS_MN10200
:
1376 rtype
= elf_mn10200_reloc_type (type
);
1380 case EM_CYGNUS_FR30
:
1381 rtype
= elf_fr30_reloc_type (type
);
1385 rtype
= elf_frv_reloc_type (type
);
1389 rtype
= elf_csky_reloc_type (type
);
1393 rtype
= elf_ft32_reloc_type (type
);
1397 rtype
= elf_mcore_reloc_type (type
);
1401 rtype
= elf_mmix_reloc_type (type
);
1405 rtype
= elf_moxie_reloc_type (type
);
1409 if (uses_msp430x_relocs (filedata
))
1411 rtype
= elf_msp430x_reloc_type (type
);
1416 rtype
= elf_msp430_reloc_type (type
);
1420 rtype
= elf_nds32_reloc_type (type
);
1424 rtype
= elf_ppc_reloc_type (type
);
1428 rtype
= elf_ppc64_reloc_type (type
);
1432 case EM_MIPS_RS3_LE
:
1433 rtype
= elf_mips_reloc_type (type
);
1437 rtype
= elf_riscv_reloc_type (type
);
1441 rtype
= elf_alpha_reloc_type (type
);
1445 rtype
= elf_arm_reloc_type (type
);
1449 case EM_ARC_COMPACT
:
1450 case EM_ARC_COMPACT2
:
1451 rtype
= elf_arc_reloc_type (type
);
1455 rtype
= elf_hppa_reloc_type (type
);
1461 rtype
= elf_h8_reloc_type (type
);
1465 rtype
= elf_or1k_reloc_type (type
);
1470 rtype
= elf_pj_reloc_type (type
);
1473 rtype
= elf_ia64_reloc_type (type
);
1477 rtype
= elf_cris_reloc_type (type
);
1481 rtype
= elf_i860_reloc_type (type
);
1487 rtype
= elf_x86_64_reloc_type (type
);
1491 rtype
= i370_reloc_type (type
);
1496 rtype
= elf_s390_reloc_type (type
);
1500 rtype
= elf_score_reloc_type (type
);
1504 rtype
= elf_xstormy16_reloc_type (type
);
1508 rtype
= elf_crx_reloc_type (type
);
1512 rtype
= elf_vax_reloc_type (type
);
1516 rtype
= elf_visium_reloc_type (type
);
1520 rtype
= elf_bpf_reloc_type (type
);
1523 case EM_ADAPTEVA_EPIPHANY
:
1524 rtype
= elf_epiphany_reloc_type (type
);
1529 rtype
= elf_ip2k_reloc_type (type
);
1533 rtype
= elf_iq2000_reloc_type (type
);
1538 rtype
= elf_xtensa_reloc_type (type
);
1541 case EM_LATTICEMICO32
:
1542 rtype
= elf_lm32_reloc_type (type
);
1547 rtype
= elf_m32c_reloc_type (type
);
1551 rtype
= elf_mt_reloc_type (type
);
1555 rtype
= elf_bfin_reloc_type (type
);
1559 rtype
= elf_mep_reloc_type (type
);
1563 rtype
= elf_cr16_reloc_type (type
);
1567 case EM_MICROBLAZE_OLD
:
1568 rtype
= elf_microblaze_reloc_type (type
);
1572 rtype
= elf_rl78_reloc_type (type
);
1576 rtype
= elf_rx_reloc_type (type
);
1580 rtype
= elf_metag_reloc_type (type
);
1585 rtype
= elf_xc16x_reloc_type (type
);
1589 rtype
= elf_tic6x_reloc_type (type
);
1593 rtype
= elf_tilegx_reloc_type (type
);
1597 rtype
= elf_tilepro_reloc_type (type
);
1600 case EM_WEBASSEMBLY
:
1601 rtype
= elf_wasm32_reloc_type (type
);
1605 rtype
= elf_xgate_reloc_type (type
);
1608 case EM_ALTERA_NIOS2
:
1609 rtype
= elf_nios2_reloc_type (type
);
1613 rtype
= elf_pru_reloc_type (type
);
1617 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
1618 rtype
= elf_nfp3200_reloc_type (type
);
1620 rtype
= elf_nfp_reloc_type (type
);
1624 rtype
= elf_z80_reloc_type (type
);
1629 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1631 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1633 if (filedata
->file_header
.e_machine
== EM_ALPHA
1635 && streq (rtype
, "R_ALPHA_LITUSE")
1638 switch (rels
[i
].r_addend
)
1640 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1641 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1642 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1643 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1644 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1645 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1646 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1647 default: rtype
= NULL
;
1651 printf (" (%s)", rtype
);
1655 printf (_("<unknown addend: %lx>"),
1656 (unsigned long) rels
[i
].r_addend
);
1660 else if (symtab_index
)
1662 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1664 error (_(" bad symbol index: %08lx in reloc\n"),
1665 (unsigned long) symtab_index
);
1670 Elf_Internal_Sym
* psym
;
1671 const char * version_string
;
1672 enum versioned_symbol_info sym_info
;
1673 unsigned short vna_other
;
1675 psym
= symtab
+ symtab_index
;
1678 = get_symbol_version_string (filedata
, is_dynsym
,
1687 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1691 unsigned int width
= is_32bit_elf
? 8 : 14;
1693 /* Relocations against GNU_IFUNC symbols do not use the value
1694 of the symbol as the address to relocate against. Instead
1695 they invoke the function named by the symbol and use its
1696 result as the address for relocation.
1698 To indicate this to the user, do not display the value of
1699 the symbol in the "Symbols's Value" field. Instead show
1700 its name followed by () as a hint that the symbol is
1704 || psym
->st_name
== 0
1705 || psym
->st_name
>= strtablen
)
1708 name
= strtab
+ psym
->st_name
;
1710 len
= print_symbol (width
, name
);
1712 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1714 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1718 print_vma (psym
->st_value
, LONG_HEX
);
1720 printf (is_32bit_elf
? " " : " ");
1723 if (psym
->st_name
== 0)
1725 const char * sec_name
= "<null>";
1728 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1730 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
)
1731 sec_name
= SECTION_NAME (filedata
->section_headers
+ psym
->st_shndx
);
1732 else if (psym
->st_shndx
== SHN_ABS
)
1734 else if (psym
->st_shndx
== SHN_COMMON
)
1735 sec_name
= "COMMON";
1736 else if ((filedata
->file_header
.e_machine
== EM_MIPS
1737 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1738 || (filedata
->file_header
.e_machine
== EM_TI_C6000
1739 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1740 sec_name
= "SCOMMON";
1741 else if (filedata
->file_header
.e_machine
== EM_MIPS
1742 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1743 sec_name
= "SUNDEF";
1744 else if ((filedata
->file_header
.e_machine
== EM_X86_64
1745 || filedata
->file_header
.e_machine
== EM_L1OM
1746 || filedata
->file_header
.e_machine
== EM_K1OM
)
1747 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1748 sec_name
= "LARGE_COMMON";
1749 else if (filedata
->file_header
.e_machine
== EM_IA_64
1750 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1751 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1752 sec_name
= "ANSI_COM";
1753 else if (is_ia64_vms (filedata
)
1754 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1755 sec_name
= "VMS_SYMVEC";
1758 sprintf (name_buf
, "<section 0x%x>",
1759 (unsigned int) psym
->st_shndx
);
1760 sec_name
= name_buf
;
1763 print_symbol (22, sec_name
);
1765 else if (strtab
== NULL
)
1766 printf (_("<string table index: %3ld>"), psym
->st_name
);
1767 else if (psym
->st_name
>= strtablen
)
1769 error (_("<corrupt string table index: %3ld>\n"),
1775 print_symbol (22, strtab
+ psym
->st_name
);
1777 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1783 bfd_vma off
= rels
[i
].r_addend
;
1785 if ((bfd_signed_vma
) off
< 0)
1786 printf (" - %" BFD_VMA_FMT
"x", - off
);
1788 printf (" + %" BFD_VMA_FMT
"x", off
);
1794 bfd_vma off
= rels
[i
].r_addend
;
1796 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1797 if ((bfd_signed_vma
) off
< 0)
1798 printf ("-%" BFD_VMA_FMT
"x", - off
);
1800 printf ("%" BFD_VMA_FMT
"x", off
);
1803 if (filedata
->file_header
.e_machine
== EM_SPARCV9
1805 && streq (rtype
, "R_SPARC_OLO10"))
1806 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1811 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
1813 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1814 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1815 const char * rtype2
= elf_mips_reloc_type (type2
);
1816 const char * rtype3
= elf_mips_reloc_type (type3
);
1818 printf (" Type2: ");
1821 printf (_("unrecognized: %-7lx"),
1822 (unsigned long) type2
& 0xffffffff);
1824 printf ("%-17.17s", rtype2
);
1826 printf ("\n Type3: ");
1829 printf (_("unrecognized: %-7lx"),
1830 (unsigned long) type3
& 0xffffffff);
1832 printf ("%-17.17s", rtype3
);
1845 get_aarch64_dynamic_type (unsigned long type
)
1849 case DT_AARCH64_BTI_PLT
: return "AARCH64_BTI_PLT";
1850 case DT_AARCH64_PAC_PLT
: return "AARCH64_PAC_PLT";
1851 case DT_AARCH64_VARIANT_PCS
: return "AARCH64_VARIANT_PCS";
1858 get_mips_dynamic_type (unsigned long type
)
1862 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1863 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1864 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1865 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1866 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1867 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1868 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1869 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1870 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1871 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1872 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1873 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1874 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1875 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1876 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1877 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1878 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1879 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1880 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1881 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1882 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1883 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1884 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1885 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1886 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1887 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1888 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1889 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1890 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1891 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1892 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1893 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1894 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1895 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1896 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1897 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1898 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1899 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1900 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1901 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1902 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1903 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1904 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1905 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1906 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1907 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1908 case DT_MIPS_XHASH
: return "MIPS_XHASH";
1915 get_sparc64_dynamic_type (unsigned long type
)
1919 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1926 get_ppc_dynamic_type (unsigned long type
)
1930 case DT_PPC_GOT
: return "PPC_GOT";
1931 case DT_PPC_OPT
: return "PPC_OPT";
1938 get_ppc64_dynamic_type (unsigned long type
)
1942 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1943 case DT_PPC64_OPD
: return "PPC64_OPD";
1944 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1945 case DT_PPC64_OPT
: return "PPC64_OPT";
1952 get_parisc_dynamic_type (unsigned long type
)
1956 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1957 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1958 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1959 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1960 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1961 case DT_HP_PREINIT
: return "HP_PREINIT";
1962 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1963 case DT_HP_NEEDED
: return "HP_NEEDED";
1964 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1965 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1966 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1967 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1968 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1969 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1970 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1971 case DT_HP_FILTERED
: return "HP_FILTERED";
1972 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1973 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1974 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1975 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1976 case DT_PLT
: return "PLT";
1977 case DT_PLT_SIZE
: return "PLT_SIZE";
1978 case DT_DLT
: return "DLT";
1979 case DT_DLT_SIZE
: return "DLT_SIZE";
1986 get_ia64_dynamic_type (unsigned long type
)
1990 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1991 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1992 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1993 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1994 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1995 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1996 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1997 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1998 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1999 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
2000 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
2001 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
2002 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
2003 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
2004 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
2005 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
2006 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
2007 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
2008 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
2009 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
2010 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
2011 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
2012 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
2013 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
2014 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
2015 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
2016 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
2017 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
2018 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
2019 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
2020 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
2027 get_solaris_section_type (unsigned long type
)
2031 case 0x6fffffee: return "SUNW_ancillary";
2032 case 0x6fffffef: return "SUNW_capchain";
2033 case 0x6ffffff0: return "SUNW_capinfo";
2034 case 0x6ffffff1: return "SUNW_symsort";
2035 case 0x6ffffff2: return "SUNW_tlssort";
2036 case 0x6ffffff3: return "SUNW_LDYNSYM";
2037 case 0x6ffffff4: return "SUNW_dof";
2038 case 0x6ffffff5: return "SUNW_cap";
2039 case 0x6ffffff6: return "SUNW_SIGNATURE";
2040 case 0x6ffffff7: return "SUNW_ANNOTATE";
2041 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2042 case 0x6ffffff9: return "SUNW_DEBUG";
2043 case 0x6ffffffa: return "SUNW_move";
2044 case 0x6ffffffb: return "SUNW_COMDAT";
2045 case 0x6ffffffc: return "SUNW_syminfo";
2046 case 0x6ffffffd: return "SUNW_verdef";
2047 case 0x6ffffffe: return "SUNW_verneed";
2048 case 0x6fffffff: return "SUNW_versym";
2049 case 0x70000000: return "SPARC_GOTDATA";
2050 default: return NULL
;
2055 get_alpha_dynamic_type (unsigned long type
)
2059 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2060 default: return NULL
;
2065 get_score_dynamic_type (unsigned long type
)
2069 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2070 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2071 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2072 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2073 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2074 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2075 default: return NULL
;
2080 get_tic6x_dynamic_type (unsigned long type
)
2084 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2085 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2086 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2087 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2088 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2089 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2090 default: return NULL
;
2095 get_nios2_dynamic_type (unsigned long type
)
2099 case DT_NIOS2_GP
: return "NIOS2_GP";
2100 default: return NULL
;
2105 get_solaris_dynamic_type (unsigned long type
)
2109 case 0x6000000d: return "SUNW_AUXILIARY";
2110 case 0x6000000e: return "SUNW_RTLDINF";
2111 case 0x6000000f: return "SUNW_FILTER";
2112 case 0x60000010: return "SUNW_CAP";
2113 case 0x60000011: return "SUNW_SYMTAB";
2114 case 0x60000012: return "SUNW_SYMSZ";
2115 case 0x60000013: return "SUNW_SORTENT";
2116 case 0x60000014: return "SUNW_SYMSORT";
2117 case 0x60000015: return "SUNW_SYMSORTSZ";
2118 case 0x60000016: return "SUNW_TLSSORT";
2119 case 0x60000017: return "SUNW_TLSSORTSZ";
2120 case 0x60000018: return "SUNW_CAPINFO";
2121 case 0x60000019: return "SUNW_STRPAD";
2122 case 0x6000001a: return "SUNW_CAPCHAIN";
2123 case 0x6000001b: return "SUNW_LDMACH";
2124 case 0x6000001d: return "SUNW_CAPCHAINENT";
2125 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2126 case 0x60000021: return "SUNW_PARENT";
2127 case 0x60000023: return "SUNW_ASLR";
2128 case 0x60000025: return "SUNW_RELAX";
2129 case 0x60000029: return "SUNW_NXHEAP";
2130 case 0x6000002b: return "SUNW_NXSTACK";
2132 case 0x70000001: return "SPARC_REGISTER";
2133 case 0x7ffffffd: return "AUXILIARY";
2134 case 0x7ffffffe: return "USED";
2135 case 0x7fffffff: return "FILTER";
2137 default: return NULL
;
2142 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2144 static char buff
[64];
2148 case DT_NULL
: return "NULL";
2149 case DT_NEEDED
: return "NEEDED";
2150 case DT_PLTRELSZ
: return "PLTRELSZ";
2151 case DT_PLTGOT
: return "PLTGOT";
2152 case DT_HASH
: return "HASH";
2153 case DT_STRTAB
: return "STRTAB";
2154 case DT_SYMTAB
: return "SYMTAB";
2155 case DT_RELA
: return "RELA";
2156 case DT_RELASZ
: return "RELASZ";
2157 case DT_RELAENT
: return "RELAENT";
2158 case DT_STRSZ
: return "STRSZ";
2159 case DT_SYMENT
: return "SYMENT";
2160 case DT_INIT
: return "INIT";
2161 case DT_FINI
: return "FINI";
2162 case DT_SONAME
: return "SONAME";
2163 case DT_RPATH
: return "RPATH";
2164 case DT_SYMBOLIC
: return "SYMBOLIC";
2165 case DT_REL
: return "REL";
2166 case DT_RELSZ
: return "RELSZ";
2167 case DT_RELENT
: return "RELENT";
2168 case DT_PLTREL
: return "PLTREL";
2169 case DT_DEBUG
: return "DEBUG";
2170 case DT_TEXTREL
: return "TEXTREL";
2171 case DT_JMPREL
: return "JMPREL";
2172 case DT_BIND_NOW
: return "BIND_NOW";
2173 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2174 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2175 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2176 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2177 case DT_RUNPATH
: return "RUNPATH";
2178 case DT_FLAGS
: return "FLAGS";
2180 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2181 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2182 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2184 case DT_CHECKSUM
: return "CHECKSUM";
2185 case DT_PLTPADSZ
: return "PLTPADSZ";
2186 case DT_MOVEENT
: return "MOVEENT";
2187 case DT_MOVESZ
: return "MOVESZ";
2188 case DT_FEATURE
: return "FEATURE";
2189 case DT_POSFLAG_1
: return "POSFLAG_1";
2190 case DT_SYMINSZ
: return "SYMINSZ";
2191 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2193 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2194 case DT_CONFIG
: return "CONFIG";
2195 case DT_DEPAUDIT
: return "DEPAUDIT";
2196 case DT_AUDIT
: return "AUDIT";
2197 case DT_PLTPAD
: return "PLTPAD";
2198 case DT_MOVETAB
: return "MOVETAB";
2199 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2201 case DT_VERSYM
: return "VERSYM";
2203 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2204 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2205 case DT_RELACOUNT
: return "RELACOUNT";
2206 case DT_RELCOUNT
: return "RELCOUNT";
2207 case DT_FLAGS_1
: return "FLAGS_1";
2208 case DT_VERDEF
: return "VERDEF";
2209 case DT_VERDEFNUM
: return "VERDEFNUM";
2210 case DT_VERNEED
: return "VERNEED";
2211 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2213 case DT_AUXILIARY
: return "AUXILIARY";
2214 case DT_USED
: return "USED";
2215 case DT_FILTER
: return "FILTER";
2217 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2218 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2219 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2220 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2221 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2222 case DT_GNU_HASH
: return "GNU_HASH";
2225 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2227 const char * result
;
2229 switch (filedata
->file_header
.e_machine
)
2232 result
= get_aarch64_dynamic_type (type
);
2235 case EM_MIPS_RS3_LE
:
2236 result
= get_mips_dynamic_type (type
);
2239 result
= get_sparc64_dynamic_type (type
);
2242 result
= get_ppc_dynamic_type (type
);
2245 result
= get_ppc64_dynamic_type (type
);
2248 result
= get_ia64_dynamic_type (type
);
2251 result
= get_alpha_dynamic_type (type
);
2254 result
= get_score_dynamic_type (type
);
2257 result
= get_tic6x_dynamic_type (type
);
2259 case EM_ALTERA_NIOS2
:
2260 result
= get_nios2_dynamic_type (type
);
2263 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2264 result
= get_solaris_dynamic_type (type
);
2273 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2275 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2276 || (filedata
->file_header
.e_machine
== EM_PARISC
2277 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2279 const char * result
;
2281 switch (filedata
->file_header
.e_machine
)
2284 result
= get_parisc_dynamic_type (type
);
2287 result
= get_ia64_dynamic_type (type
);
2290 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2291 result
= get_solaris_dynamic_type (type
);
2300 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2304 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2311 get_file_type (unsigned e_type
)
2313 static char buff
[64];
2317 case ET_NONE
: return _("NONE (None)");
2318 case ET_REL
: return _("REL (Relocatable file)");
2319 case ET_EXEC
: return _("EXEC (Executable file)");
2320 case ET_DYN
: return _("DYN (Shared object file)");
2321 case ET_CORE
: return _("CORE (Core file)");
2324 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2325 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2326 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2327 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2329 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2335 get_machine_name (unsigned e_machine
)
2337 static char buff
[64]; /* XXX */
2341 /* Please keep this switch table sorted by increasing EM_ value. */
2343 case EM_NONE
: return _("None");
2344 case EM_M32
: return "WE32100";
2345 case EM_SPARC
: return "Sparc";
2346 case EM_386
: return "Intel 80386";
2347 case EM_68K
: return "MC68000";
2348 case EM_88K
: return "MC88000";
2349 case EM_IAMCU
: return "Intel MCU";
2350 case EM_860
: return "Intel 80860";
2351 case EM_MIPS
: return "MIPS R3000";
2352 case EM_S370
: return "IBM System/370";
2354 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2355 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2356 case EM_PARISC
: return "HPPA";
2357 case EM_VPP550
: return "Fujitsu VPP500";
2358 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2359 case EM_960
: return "Intel 80960";
2360 case EM_PPC
: return "PowerPC";
2362 case EM_PPC64
: return "PowerPC64";
2364 case EM_S390
: return "IBM S/390";
2365 case EM_SPU
: return "SPU";
2367 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2368 case EM_FR20
: return "Fujitsu FR20";
2369 case EM_RH32
: return "TRW RH32";
2370 case EM_MCORE
: return "MCORE";
2372 case EM_ARM
: return "ARM";
2373 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2374 case EM_SH
: return "Renesas / SuperH SH";
2375 case EM_SPARCV9
: return "Sparc v9";
2376 case EM_TRICORE
: return "Siemens Tricore";
2377 case EM_ARC
: return "ARC";
2378 case EM_H8_300
: return "Renesas H8/300";
2379 case EM_H8_300H
: return "Renesas H8/300H";
2380 case EM_H8S
: return "Renesas H8S";
2381 case EM_H8_500
: return "Renesas H8/500";
2383 case EM_IA_64
: return "Intel IA-64";
2384 case EM_MIPS_X
: return "Stanford MIPS-X";
2385 case EM_COLDFIRE
: return "Motorola Coldfire";
2386 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2387 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2388 case EM_PCP
: return "Siemens PCP";
2389 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2390 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2391 case EM_STARCORE
: return "Motorola Star*Core processor";
2392 case EM_ME16
: return "Toyota ME16 processor";
2394 case EM_ST100
: return "STMicroelectronics ST100 processor";
2395 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2396 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2397 case EM_PDSP
: return "Sony DSP processor";
2398 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2399 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2400 case EM_FX66
: return "Siemens FX66 microcontroller";
2401 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2402 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2403 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2405 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2406 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2407 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2408 case EM_SVX
: return "Silicon Graphics SVx";
2409 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2410 case EM_VAX
: return "Digital VAX";
2411 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2412 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2413 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2414 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2416 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2417 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2418 case EM_PRISM
: return "Vitesse Prism";
2420 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2421 case EM_CYGNUS_FR30
:
2422 case EM_FR30
: return "Fujitsu FR30";
2423 case EM_CYGNUS_D10V
:
2424 case EM_D10V
: return "d10v";
2425 case EM_CYGNUS_D30V
:
2426 case EM_D30V
: return "d30v";
2427 case EM_CYGNUS_V850
:
2428 case EM_V850
: return "Renesas V850";
2429 case EM_CYGNUS_M32R
:
2430 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2431 case EM_CYGNUS_MN10300
:
2432 case EM_MN10300
: return "mn10300";
2434 case EM_CYGNUS_MN10200
:
2435 case EM_MN10200
: return "mn10200";
2436 case EM_PJ
: return "picoJava";
2437 case EM_OR1K
: return "OpenRISC 1000";
2438 case EM_ARC_COMPACT
: return "ARCompact";
2440 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2441 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2442 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2443 case EM_NS32K
: return "National Semiconductor 32000 series";
2444 case EM_TPC
: return "Tenor Network TPC processor";
2445 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2447 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2449 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2450 case EM_MAX
: return "MAX Processor";
2451 case EM_CR
: return "National Semiconductor CompactRISC";
2452 case EM_F2MC16
: return "Fujitsu F2MC16";
2453 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2454 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2455 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2456 case EM_SEP
: return "Sharp embedded microprocessor";
2457 case EM_ARCA
: return "Arca RISC microprocessor";
2459 case EM_UNICORE
: return "Unicore";
2460 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2461 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2462 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2463 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2464 case EM_XGATE
: return "Motorola XGATE embedded processor";
2466 case EM_XC16X
: return "Infineon Technologies xc16x";
2467 case EM_M16C
: return "Renesas M16C series microprocessors";
2468 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2469 case EM_CE
: return "Freescale Communication Engine RISC core";
2471 case EM_M32C
: return "Renesas M32c";
2473 case EM_TSK3000
: return "Altium TSK3000 core";
2474 case EM_RS08
: return "Freescale RS08 embedded processor";
2475 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2476 case EM_SCORE
: return "SUNPLUS S+Core";
2477 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2478 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2479 case EM_LATTICEMICO32
: return "Lattice Mico32";
2480 case EM_SE_C17
: return "Seiko Epson C17 family";
2482 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2483 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2484 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2485 case EM_TI_PRU
: return "TI PRU I/O processor";
2487 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2488 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2489 case EM_R32C
: return "Renesas R32C series microprocessors";
2490 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2491 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2492 case EM_8051
: return "Intel 8051 and variants";
2493 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2494 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2495 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2496 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2498 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2499 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2500 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2501 case EM_RX
: return "Renesas RX";
2502 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2503 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2504 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2507 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2508 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2509 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2511 case EM_L1OM
: return "Intel L1OM";
2512 case EM_K1OM
: return "Intel K1OM";
2513 case EM_INTEL182
: return "Intel (reserved)";
2514 case EM_AARCH64
: return "AArch64";
2515 case EM_ARM184
: return "ARM (reserved)";
2516 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2517 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2518 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2519 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2521 case EM_CUDA
: return "NVIDIA CUDA architecture";
2522 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2523 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2524 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2525 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2526 case EM_ARC_COMPACT2
: return "ARCv2";
2527 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2528 case EM_RL78
: return "Renesas RL78";
2529 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2530 case EM_78K0R
: return "Renesas 78K0R";
2532 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2533 case EM_BA1
: return "Beyond BA1 CPU architecture";
2534 case EM_BA2
: return "Beyond BA2 CPU architecture";
2535 case EM_XCORE
: return "XMOS xCORE processor family";
2536 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2538 case EM_KM32
: return "KM211 KM32 32-bit processor";
2539 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2540 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2541 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2542 case EM_KVARC
: return "KM211 KVARC processor";
2543 case EM_CDP
: return "Paneve CDP architecture family";
2544 case EM_COGE
: return "Cognitive Smart Memory Processor";
2545 case EM_COOL
: return "Bluechip Systems CoolEngine";
2546 case EM_NORC
: return "Nanoradio Optimized RISC";
2547 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2549 case EM_Z80
: return "Zilog Z80";
2550 case EM_VISIUM
: return "CDS VISIUMcore processor";
2551 case EM_FT32
: return "FTDI Chip FT32";
2552 case EM_MOXIE
: return "Moxie";
2553 case EM_AMDGPU
: return "AMD GPU";
2554 case EM_RISCV
: return "RISC-V";
2555 case EM_LANAI
: return "Lanai 32-bit processor";
2556 case EM_BPF
: return "Linux BPF";
2557 case EM_NFP
: return "Netronome Flow Processor";
2559 /* Large numbers... */
2560 case EM_MT
: return "Morpho Techologies MT processor";
2561 case EM_ALPHA
: return "Alpha";
2562 case EM_WEBASSEMBLY
: return "Web Assembly";
2563 case EM_DLX
: return "OpenDLX";
2564 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2565 case EM_IQ2000
: return "Vitesse IQ2000";
2567 case EM_NIOS32
: return "Altera Nios";
2568 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2569 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2570 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2571 case EM_S12Z
: return "Freescale S12Z";
2572 case EM_CSKY
: return "C-SKY";
2575 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2581 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2583 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2584 other compilers don't a specific architecture type in the e_flags, and
2585 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2586 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2589 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2590 but also sets a specific architecture type in the e_flags field.
2592 However, when decoding the flags we don't worry if we see an
2593 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2594 ARCEM architecture type. */
2596 switch (e_flags
& EF_ARC_MACH_MSK
)
2598 /* We only expect these to occur for EM_ARC_COMPACT2. */
2599 case EF_ARC_CPU_ARCV2EM
:
2600 strcat (buf
, ", ARC EM");
2602 case EF_ARC_CPU_ARCV2HS
:
2603 strcat (buf
, ", ARC HS");
2606 /* We only expect these to occur for EM_ARC_COMPACT. */
2607 case E_ARC_MACH_ARC600
:
2608 strcat (buf
, ", ARC600");
2610 case E_ARC_MACH_ARC601
:
2611 strcat (buf
, ", ARC601");
2613 case E_ARC_MACH_ARC700
:
2614 strcat (buf
, ", ARC700");
2617 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2618 new ELF with new architecture being read by an old version of
2619 readelf, or (c) An ELF built with non-GNU compiler that does not
2620 set the architecture in the e_flags. */
2622 if (e_machine
== EM_ARC_COMPACT
)
2623 strcat (buf
, ", Unknown ARCompact");
2625 strcat (buf
, ", Unknown ARC");
2629 switch (e_flags
& EF_ARC_OSABI_MSK
)
2631 case E_ARC_OSABI_ORIG
:
2632 strcat (buf
, ", (ABI:legacy)");
2634 case E_ARC_OSABI_V2
:
2635 strcat (buf
, ", (ABI:v2)");
2637 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2638 case E_ARC_OSABI_V3
:
2639 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2641 case E_ARC_OSABI_V4
:
2642 strcat (buf
, ", v4 ABI");
2645 strcat (buf
, ", unrecognised ARC OSABI flag");
2651 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2654 bfd_boolean unknown
= FALSE
;
2656 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2657 e_flags
&= ~ EF_ARM_EABIMASK
;
2659 /* Handle "generic" ARM flags. */
2660 if (e_flags
& EF_ARM_RELEXEC
)
2662 strcat (buf
, ", relocatable executable");
2663 e_flags
&= ~ EF_ARM_RELEXEC
;
2666 if (e_flags
& EF_ARM_PIC
)
2668 strcat (buf
, ", position independent");
2669 e_flags
&= ~ EF_ARM_PIC
;
2672 /* Now handle EABI specific flags. */
2676 strcat (buf
, ", <unrecognized EABI>");
2681 case EF_ARM_EABI_VER1
:
2682 strcat (buf
, ", Version1 EABI");
2687 /* Process flags one bit at a time. */
2688 flag
= e_flags
& - e_flags
;
2693 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2694 strcat (buf
, ", sorted symbol tables");
2704 case EF_ARM_EABI_VER2
:
2705 strcat (buf
, ", Version2 EABI");
2710 /* Process flags one bit at a time. */
2711 flag
= e_flags
& - e_flags
;
2716 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2717 strcat (buf
, ", sorted symbol tables");
2720 case EF_ARM_DYNSYMSUSESEGIDX
:
2721 strcat (buf
, ", dynamic symbols use segment index");
2724 case EF_ARM_MAPSYMSFIRST
:
2725 strcat (buf
, ", mapping symbols precede others");
2735 case EF_ARM_EABI_VER3
:
2736 strcat (buf
, ", Version3 EABI");
2739 case EF_ARM_EABI_VER4
:
2740 strcat (buf
, ", Version4 EABI");
2745 /* Process flags one bit at a time. */
2746 flag
= e_flags
& - e_flags
;
2752 strcat (buf
, ", BE8");
2756 strcat (buf
, ", LE8");
2766 case EF_ARM_EABI_VER5
:
2767 strcat (buf
, ", Version5 EABI");
2772 /* Process flags one bit at a time. */
2773 flag
= e_flags
& - e_flags
;
2779 strcat (buf
, ", BE8");
2783 strcat (buf
, ", LE8");
2786 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2787 strcat (buf
, ", soft-float ABI");
2790 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2791 strcat (buf
, ", hard-float ABI");
2801 case EF_ARM_EABI_UNKNOWN
:
2802 strcat (buf
, ", GNU EABI");
2807 /* Process flags one bit at a time. */
2808 flag
= e_flags
& - e_flags
;
2813 case EF_ARM_INTERWORK
:
2814 strcat (buf
, ", interworking enabled");
2817 case EF_ARM_APCS_26
:
2818 strcat (buf
, ", uses APCS/26");
2821 case EF_ARM_APCS_FLOAT
:
2822 strcat (buf
, ", uses APCS/float");
2826 strcat (buf
, ", position independent");
2830 strcat (buf
, ", 8 bit structure alignment");
2833 case EF_ARM_NEW_ABI
:
2834 strcat (buf
, ", uses new ABI");
2837 case EF_ARM_OLD_ABI
:
2838 strcat (buf
, ", uses old ABI");
2841 case EF_ARM_SOFT_FLOAT
:
2842 strcat (buf
, ", software FP");
2845 case EF_ARM_VFP_FLOAT
:
2846 strcat (buf
, ", VFP");
2849 case EF_ARM_MAVERICK_FLOAT
:
2850 strcat (buf
, ", Maverick FP");
2861 strcat (buf
,_(", <unknown>"));
2865 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2867 --size
; /* Leave space for null terminator. */
2869 switch (e_flags
& EF_AVR_MACH
)
2871 case E_AVR_MACH_AVR1
:
2872 strncat (buf
, ", avr:1", size
);
2874 case E_AVR_MACH_AVR2
:
2875 strncat (buf
, ", avr:2", size
);
2877 case E_AVR_MACH_AVR25
:
2878 strncat (buf
, ", avr:25", size
);
2880 case E_AVR_MACH_AVR3
:
2881 strncat (buf
, ", avr:3", size
);
2883 case E_AVR_MACH_AVR31
:
2884 strncat (buf
, ", avr:31", size
);
2886 case E_AVR_MACH_AVR35
:
2887 strncat (buf
, ", avr:35", size
);
2889 case E_AVR_MACH_AVR4
:
2890 strncat (buf
, ", avr:4", size
);
2892 case E_AVR_MACH_AVR5
:
2893 strncat (buf
, ", avr:5", size
);
2895 case E_AVR_MACH_AVR51
:
2896 strncat (buf
, ", avr:51", size
);
2898 case E_AVR_MACH_AVR6
:
2899 strncat (buf
, ", avr:6", size
);
2901 case E_AVR_MACH_AVRTINY
:
2902 strncat (buf
, ", avr:100", size
);
2904 case E_AVR_MACH_XMEGA1
:
2905 strncat (buf
, ", avr:101", size
);
2907 case E_AVR_MACH_XMEGA2
:
2908 strncat (buf
, ", avr:102", size
);
2910 case E_AVR_MACH_XMEGA3
:
2911 strncat (buf
, ", avr:103", size
);
2913 case E_AVR_MACH_XMEGA4
:
2914 strncat (buf
, ", avr:104", size
);
2916 case E_AVR_MACH_XMEGA5
:
2917 strncat (buf
, ", avr:105", size
);
2919 case E_AVR_MACH_XMEGA6
:
2920 strncat (buf
, ", avr:106", size
);
2922 case E_AVR_MACH_XMEGA7
:
2923 strncat (buf
, ", avr:107", size
);
2926 strncat (buf
, ", avr:<unknown>", size
);
2930 size
-= strlen (buf
);
2931 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2932 strncat (buf
, ", link-relax", size
);
2936 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2942 bfd_boolean has_fpu
= FALSE
;
2945 static const char *ABI_STRINGS
[] =
2947 "ABI v0", /* use r5 as return register; only used in N1213HC */
2948 "ABI v1", /* use r0 as return register */
2949 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2950 "ABI v2fp", /* for FPU */
2954 static const char *VER_STRINGS
[] =
2956 "Andes ELF V1.3 or older",
2960 static const char *ARCH_STRINGS
[] =
2969 abi
= EF_NDS_ABI
& e_flags
;
2970 arch
= EF_NDS_ARCH
& e_flags
;
2971 config
= EF_NDS_INST
& e_flags
;
2972 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2974 memset (buf
, 0, size
);
2981 case E_NDS_ABI_V2FP
:
2982 case E_NDS_ABI_AABI
:
2983 case E_NDS_ABI_V2FP_PLUS
:
2984 /* In case there are holes in the array. */
2985 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2989 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2995 case E_NDS32_ELF_VER_1_2
:
2996 case E_NDS32_ELF_VER_1_3
:
2997 case E_NDS32_ELF_VER_1_4
:
2998 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
3002 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
3006 if (E_NDS_ABI_V0
== abi
)
3008 /* OLD ABI; only used in N1213HC, has performance extension 1. */
3009 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
3010 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3011 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
3017 case E_NDS_ARCH_STAR_V1_0
:
3018 case E_NDS_ARCH_STAR_V2_0
:
3019 case E_NDS_ARCH_STAR_V3_0
:
3020 case E_NDS_ARCH_STAR_V3_M
:
3021 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
3025 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
3026 /* ARCH version determines how the e_flags are interpreted.
3027 If it is unknown, we cannot proceed. */
3031 /* Newer ABI; Now handle architecture specific flags. */
3032 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3034 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3035 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
3037 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
3038 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
3040 if (config
& E_NDS32_HAS_DIV_INST
)
3041 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
3043 if (config
& E_NDS32_HAS_16BIT_INST
)
3044 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3048 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3050 if (version
<= E_NDS32_ELF_VER_1_3
)
3051 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
3053 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
3056 if (config
& E_NDS32_HAS_MAC_DX_INST
)
3057 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
3059 if (config
& E_NDS32_HAS_DIV_DX_INST
)
3060 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
3062 if (config
& E_NDS32_HAS_16BIT_INST
)
3064 if (version
<= E_NDS32_ELF_VER_1_3
)
3065 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3067 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3071 if (config
& E_NDS32_HAS_EXT_INST
)
3072 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3074 if (config
& E_NDS32_HAS_EXT2_INST
)
3075 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3077 if (config
& E_NDS32_HAS_FPU_INST
)
3080 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3083 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3086 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3089 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3092 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3097 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3099 case E_NDS32_FPU_REG_8SP_4DP
:
3100 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3102 case E_NDS32_FPU_REG_16SP_8DP
:
3103 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3105 case E_NDS32_FPU_REG_32SP_16DP
:
3106 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3108 case E_NDS32_FPU_REG_32SP_32DP
:
3109 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3114 if (config
& E_NDS32_HAS_AUDIO_INST
)
3115 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3117 if (config
& E_NDS32_HAS_STRING_INST
)
3118 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3120 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3121 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3123 if (config
& E_NDS32_HAS_VIDEO_INST
)
3125 if (version
<= E_NDS32_ELF_VER_1_3
)
3126 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3128 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3131 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3132 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3134 if (config
& E_NDS32_HAS_L2C_INST
)
3135 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3139 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3141 static char buf
[1024];
3152 case EM_ARC_COMPACT2
:
3153 case EM_ARC_COMPACT
:
3154 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3158 decode_ARM_machine_flags (e_flags
, buf
);
3162 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3166 if (e_flags
& EF_BFIN_PIC
)
3167 strcat (buf
, ", PIC");
3169 if (e_flags
& EF_BFIN_FDPIC
)
3170 strcat (buf
, ", FDPIC");
3172 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3173 strcat (buf
, ", code in L1");
3175 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3176 strcat (buf
, ", data in L1");
3181 switch (e_flags
& EF_FRV_CPU_MASK
)
3183 case EF_FRV_CPU_GENERIC
:
3187 strcat (buf
, ", fr???");
3190 case EF_FRV_CPU_FR300
:
3191 strcat (buf
, ", fr300");
3194 case EF_FRV_CPU_FR400
:
3195 strcat (buf
, ", fr400");
3197 case EF_FRV_CPU_FR405
:
3198 strcat (buf
, ", fr405");
3201 case EF_FRV_CPU_FR450
:
3202 strcat (buf
, ", fr450");
3205 case EF_FRV_CPU_FR500
:
3206 strcat (buf
, ", fr500");
3208 case EF_FRV_CPU_FR550
:
3209 strcat (buf
, ", fr550");
3212 case EF_FRV_CPU_SIMPLE
:
3213 strcat (buf
, ", simple");
3215 case EF_FRV_CPU_TOMCAT
:
3216 strcat (buf
, ", tomcat");
3222 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3223 strcat (buf
, ", m68000");
3224 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3225 strcat (buf
, ", cpu32");
3226 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3227 strcat (buf
, ", fido_a");
3230 char const * isa
= _("unknown");
3231 char const * mac
= _("unknown mac");
3232 char const * additional
= NULL
;
3234 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3236 case EF_M68K_CF_ISA_A_NODIV
:
3238 additional
= ", nodiv";
3240 case EF_M68K_CF_ISA_A
:
3243 case EF_M68K_CF_ISA_A_PLUS
:
3246 case EF_M68K_CF_ISA_B_NOUSP
:
3248 additional
= ", nousp";
3250 case EF_M68K_CF_ISA_B
:
3253 case EF_M68K_CF_ISA_C
:
3256 case EF_M68K_CF_ISA_C_NODIV
:
3258 additional
= ", nodiv";
3261 strcat (buf
, ", cf, isa ");
3264 strcat (buf
, additional
);
3265 if (e_flags
& EF_M68K_CF_FLOAT
)
3266 strcat (buf
, ", float");
3267 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3272 case EF_M68K_CF_MAC
:
3275 case EF_M68K_CF_EMAC
:
3278 case EF_M68K_CF_EMAC_B
:
3291 switch (e_flags
& EF_MEP_CPU_MASK
)
3293 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3294 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3295 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3296 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3297 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3298 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3299 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3302 switch (e_flags
& EF_MEP_COP_MASK
)
3304 case EF_MEP_COP_NONE
: break;
3305 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3306 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3307 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3308 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3309 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3312 if (e_flags
& EF_MEP_LIBRARY
)
3313 strcat (buf
, ", Built for Library");
3315 if (e_flags
& EF_MEP_INDEX_MASK
)
3316 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3317 e_flags
& EF_MEP_INDEX_MASK
);
3319 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3320 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3321 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3325 if (e_flags
& EF_PPC_EMB
)
3326 strcat (buf
, ", emb");
3328 if (e_flags
& EF_PPC_RELOCATABLE
)
3329 strcat (buf
, _(", relocatable"));
3331 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3332 strcat (buf
, _(", relocatable-lib"));
3336 if (e_flags
& EF_PPC64_ABI
)
3338 char abi
[] = ", abiv0";
3340 abi
[6] += e_flags
& EF_PPC64_ABI
;
3346 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3347 strcat (buf
, ", RH850 ABI");
3349 if (e_flags
& EF_V800_850E3
)
3350 strcat (buf
, ", V3 architecture");
3352 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3353 strcat (buf
, ", FPU not used");
3355 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3356 strcat (buf
, ", regmode: COMMON");
3358 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3359 strcat (buf
, ", r4 not used");
3361 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3362 strcat (buf
, ", r30 not used");
3364 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3365 strcat (buf
, ", r5 not used");
3367 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3368 strcat (buf
, ", r2 not used");
3370 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3372 switch (e_flags
& - e_flags
)
3374 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3375 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3376 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3377 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3378 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3379 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3380 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3381 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3382 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3383 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3384 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3385 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3392 case EM_CYGNUS_V850
:
3393 switch (e_flags
& EF_V850_ARCH
)
3395 case E_V850E3V5_ARCH
:
3396 strcat (buf
, ", v850e3v5");
3398 case E_V850E2V3_ARCH
:
3399 strcat (buf
, ", v850e2v3");
3402 strcat (buf
, ", v850e2");
3405 strcat (buf
, ", v850e1");
3408 strcat (buf
, ", v850e");
3411 strcat (buf
, ", v850");
3414 strcat (buf
, _(", unknown v850 architecture variant"));
3420 case EM_CYGNUS_M32R
:
3421 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3422 strcat (buf
, ", m32r");
3426 case EM_MIPS_RS3_LE
:
3427 if (e_flags
& EF_MIPS_NOREORDER
)
3428 strcat (buf
, ", noreorder");
3430 if (e_flags
& EF_MIPS_PIC
)
3431 strcat (buf
, ", pic");
3433 if (e_flags
& EF_MIPS_CPIC
)
3434 strcat (buf
, ", cpic");
3436 if (e_flags
& EF_MIPS_UCODE
)
3437 strcat (buf
, ", ugen_reserved");
3439 if (e_flags
& EF_MIPS_ABI2
)
3440 strcat (buf
, ", abi2");
3442 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3443 strcat (buf
, ", odk first");
3445 if (e_flags
& EF_MIPS_32BITMODE
)
3446 strcat (buf
, ", 32bitmode");
3448 if (e_flags
& EF_MIPS_NAN2008
)
3449 strcat (buf
, ", nan2008");
3451 if (e_flags
& EF_MIPS_FP64
)
3452 strcat (buf
, ", fp64");
3454 switch ((e_flags
& EF_MIPS_MACH
))
3456 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3457 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3458 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3459 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3460 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3461 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3462 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3463 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3464 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3465 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3466 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3467 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3468 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3469 case E_MIPS_MACH_GS464
: strcat (buf
, ", gs464"); break;
3470 case E_MIPS_MACH_GS464E
: strcat (buf
, ", gs464e"); break;
3471 case E_MIPS_MACH_GS264E
: strcat (buf
, ", gs264e"); break;
3472 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3473 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3474 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3475 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3476 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3478 /* We simply ignore the field in this case to avoid confusion:
3479 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3482 default: strcat (buf
, _(", unknown CPU")); break;
3485 switch ((e_flags
& EF_MIPS_ABI
))
3487 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3488 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3489 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3490 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3492 /* We simply ignore the field in this case to avoid confusion:
3493 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3494 This means it is likely to be an o32 file, but not for
3497 default: strcat (buf
, _(", unknown ABI")); break;
3500 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3501 strcat (buf
, ", mdmx");
3503 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3504 strcat (buf
, ", mips16");
3506 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3507 strcat (buf
, ", micromips");
3509 switch ((e_flags
& EF_MIPS_ARCH
))
3511 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3512 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3513 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3514 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3515 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3516 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3517 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3518 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3519 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3520 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3521 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3522 default: strcat (buf
, _(", unknown ISA")); break;
3527 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3531 switch (EF_NFP_MACH (e_flags
))
3533 case E_NFP_MACH_3200
:
3534 strcat (buf
, ", NFP-32xx");
3536 case E_NFP_MACH_6000
:
3537 strcat (buf
, ", NFP-6xxx");
3543 if (e_flags
& EF_RISCV_RVC
)
3544 strcat (buf
, ", RVC");
3546 if (e_flags
& EF_RISCV_RVE
)
3547 strcat (buf
, ", RVE");
3549 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3551 case EF_RISCV_FLOAT_ABI_SOFT
:
3552 strcat (buf
, ", soft-float ABI");
3555 case EF_RISCV_FLOAT_ABI_SINGLE
:
3556 strcat (buf
, ", single-float ABI");
3559 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3560 strcat (buf
, ", double-float ABI");
3563 case EF_RISCV_FLOAT_ABI_QUAD
:
3564 strcat (buf
, ", quad-float ABI");
3570 switch ((e_flags
& EF_SH_MACH_MASK
))
3572 case EF_SH1
: strcat (buf
, ", sh1"); break;
3573 case EF_SH2
: strcat (buf
, ", sh2"); break;
3574 case EF_SH3
: strcat (buf
, ", sh3"); break;
3575 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3576 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3577 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3578 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3579 case EF_SH4
: strcat (buf
, ", sh4"); break;
3580 case EF_SH5
: strcat (buf
, ", sh5"); break;
3581 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3582 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3583 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3584 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3585 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3586 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3587 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3588 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3589 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3590 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3591 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3592 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3593 default: strcat (buf
, _(", unknown ISA")); break;
3596 if (e_flags
& EF_SH_PIC
)
3597 strcat (buf
, ", pic");
3599 if (e_flags
& EF_SH_FDPIC
)
3600 strcat (buf
, ", fdpic");
3604 if (e_flags
& EF_OR1K_NODELAY
)
3605 strcat (buf
, ", no delay");
3609 if (e_flags
& EF_SPARC_32PLUS
)
3610 strcat (buf
, ", v8+");
3612 if (e_flags
& EF_SPARC_SUN_US1
)
3613 strcat (buf
, ", ultrasparcI");
3615 if (e_flags
& EF_SPARC_SUN_US3
)
3616 strcat (buf
, ", ultrasparcIII");
3618 if (e_flags
& EF_SPARC_HAL_R1
)
3619 strcat (buf
, ", halr1");
3621 if (e_flags
& EF_SPARC_LEDATA
)
3622 strcat (buf
, ", ledata");
3624 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3625 strcat (buf
, ", tso");
3627 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3628 strcat (buf
, ", pso");
3630 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3631 strcat (buf
, ", rmo");
3635 switch (e_flags
& EF_PARISC_ARCH
)
3637 case EFA_PARISC_1_0
:
3638 strcpy (buf
, ", PA-RISC 1.0");
3640 case EFA_PARISC_1_1
:
3641 strcpy (buf
, ", PA-RISC 1.1");
3643 case EFA_PARISC_2_0
:
3644 strcpy (buf
, ", PA-RISC 2.0");
3649 if (e_flags
& EF_PARISC_TRAPNIL
)
3650 strcat (buf
, ", trapnil");
3651 if (e_flags
& EF_PARISC_EXT
)
3652 strcat (buf
, ", ext");
3653 if (e_flags
& EF_PARISC_LSB
)
3654 strcat (buf
, ", lsb");
3655 if (e_flags
& EF_PARISC_WIDE
)
3656 strcat (buf
, ", wide");
3657 if (e_flags
& EF_PARISC_NO_KABP
)
3658 strcat (buf
, ", no kabp");
3659 if (e_flags
& EF_PARISC_LAZYSWAP
)
3660 strcat (buf
, ", lazyswap");
3665 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3666 strcat (buf
, ", new calling convention");
3668 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3669 strcat (buf
, ", gnu calling convention");
3673 if ((e_flags
& EF_IA_64_ABI64
))
3674 strcat (buf
, ", 64-bit");
3676 strcat (buf
, ", 32-bit");
3677 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3678 strcat (buf
, ", reduced fp model");
3679 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3680 strcat (buf
, ", no function descriptors, constant gp");
3681 else if ((e_flags
& EF_IA_64_CONS_GP
))
3682 strcat (buf
, ", constant gp");
3683 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3684 strcat (buf
, ", absolute");
3685 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3687 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3688 strcat (buf
, ", vms_linkages");
3689 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3691 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3693 case EF_IA_64_VMS_COMCOD_WARNING
:
3694 strcat (buf
, ", warning");
3696 case EF_IA_64_VMS_COMCOD_ERROR
:
3697 strcat (buf
, ", error");
3699 case EF_IA_64_VMS_COMCOD_ABORT
:
3700 strcat (buf
, ", abort");
3703 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3704 e_flags
& EF_IA_64_VMS_COMCOD
);
3705 strcat (buf
, ", <unknown>");
3711 if ((e_flags
& EF_VAX_NONPIC
))
3712 strcat (buf
, ", non-PIC");
3713 if ((e_flags
& EF_VAX_DFLOAT
))
3714 strcat (buf
, ", D-Float");
3715 if ((e_flags
& EF_VAX_GFLOAT
))
3716 strcat (buf
, ", G-Float");
3720 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3721 strcat (buf
, ", mcm");
3722 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3723 strcat (buf
, ", mcm24");
3724 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3725 strcat (buf
, ", gr6");
3729 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3731 case E_FLAG_RL78_ANY_CPU
: break;
3732 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3733 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3734 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3736 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3737 strcat (buf
, ", 64-bit doubles");
3741 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3742 strcat (buf
, ", 64-bit doubles");
3743 if (e_flags
& E_FLAG_RX_DSP
)
3744 strcat (buf
, ", dsp");
3745 if (e_flags
& E_FLAG_RX_PID
)
3746 strcat (buf
, ", pid");
3747 if (e_flags
& E_FLAG_RX_ABI
)
3748 strcat (buf
, ", RX ABI");
3749 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3750 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3751 ? ", uses String instructions" : ", bans String instructions");
3752 if (e_flags
& E_FLAG_RX_V2
)
3753 strcat (buf
, ", V2");
3754 if (e_flags
& E_FLAG_RX_V3
)
3755 strcat (buf
, ", V3");
3759 if (e_flags
& EF_S390_HIGH_GPRS
)
3760 strcat (buf
, ", highgprs");
3764 if ((e_flags
& EF_C6000_REL
))
3765 strcat (buf
, ", relocatable module");
3769 strcat (buf
, _(": architecture variant: "));
3770 switch (e_flags
& EF_MSP430_MACH
)
3772 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3773 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3774 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3775 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3776 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3777 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3778 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3779 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3780 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3781 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3782 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3783 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3784 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3785 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3786 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3788 strcat (buf
, _(": unknown")); break;
3791 if (e_flags
& ~ EF_MSP430_MACH
)
3792 strcat (buf
, _(": unknown extra flag bits also present"));
3796 switch (e_flags
& EF_Z80_MACH_MSK
)
3798 case EF_Z80_MACH_Z80
: strcat (buf
, ", Z80"); break;
3799 case EF_Z80_MACH_Z180
: strcat (buf
, ", Z180"); break;
3800 case EF_Z80_MACH_R800
: strcat (buf
, ", R800"); break;
3801 case EF_Z80_MACH_EZ80_Z80
: strcat (buf
, ", EZ80"); break;
3802 case EF_Z80_MACH_EZ80_ADL
: strcat (buf
, ", EZ80, ADL"); break;
3803 case EF_Z80_MACH_GBZ80
: strcat (buf
, ", GBZ80"); break;
3804 case EF_Z80_MACH_Z80N
: strcat (buf
, ", Z80N"); break;
3806 strcat (buf
, _(", unknown")); break;
3816 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3818 static char buff
[32];
3822 case ELFOSABI_NONE
: return "UNIX - System V";
3823 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3824 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3825 case ELFOSABI_GNU
: return "UNIX - GNU";
3826 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3827 case ELFOSABI_AIX
: return "UNIX - AIX";
3828 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3829 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3830 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3831 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3832 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3833 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3834 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3835 case ELFOSABI_AROS
: return "AROS";
3836 case ELFOSABI_FENIXOS
: return "FenixOS";
3837 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3838 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3841 switch (filedata
->file_header
.e_machine
)
3846 case ELFOSABI_ARM
: return "ARM";
3847 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3858 case ELFOSABI_STANDALONE
: return _("Standalone App");
3867 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3868 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3877 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3883 get_aarch64_segment_type (unsigned long type
)
3887 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3888 default: return NULL
;
3893 get_arm_segment_type (unsigned long type
)
3897 case PT_ARM_EXIDX
: return "EXIDX";
3898 default: return NULL
;
3903 get_s390_segment_type (unsigned long type
)
3907 case PT_S390_PGSTE
: return "S390_PGSTE";
3908 default: return NULL
;
3913 get_mips_segment_type (unsigned long type
)
3917 case PT_MIPS_REGINFO
: return "REGINFO";
3918 case PT_MIPS_RTPROC
: return "RTPROC";
3919 case PT_MIPS_OPTIONS
: return "OPTIONS";
3920 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3921 default: return NULL
;
3926 get_parisc_segment_type (unsigned long type
)
3930 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3931 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3932 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3933 default: return NULL
;
3938 get_ia64_segment_type (unsigned long type
)
3942 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3943 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3944 default: return NULL
;
3949 get_tic6x_segment_type (unsigned long type
)
3953 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3954 default: return NULL
;
3959 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
3961 if (e_machine
== EM_PARISC
)
3964 case PT_HP_TLS
: return "HP_TLS";
3965 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3966 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3967 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3968 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3969 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3970 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3971 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3972 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3973 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3974 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3975 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3976 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3977 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3978 case PT_HP_STACK
: return "HP_STACK";
3979 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3980 default: return NULL
;
3983 if (e_machine
== EM_IA_64
)
3986 case PT_HP_TLS
: return "HP_TLS";
3987 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3988 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3989 case PT_IA_64_HP_STACK
: return "HP_STACK";
3990 default: return NULL
;
3997 get_solaris_segment_type (unsigned long type
)
4001 case 0x6464e550: return "PT_SUNW_UNWIND";
4002 case 0x6474e550: return "PT_SUNW_EH_FRAME";
4003 case 0x6ffffff7: return "PT_LOSUNW";
4004 case 0x6ffffffa: return "PT_SUNWBSS";
4005 case 0x6ffffffb: return "PT_SUNWSTACK";
4006 case 0x6ffffffc: return "PT_SUNWDTRACE";
4007 case 0x6ffffffd: return "PT_SUNWCAP";
4008 case 0x6fffffff: return "PT_HISUNW";
4009 default: return NULL
;
4014 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
4016 static char buff
[32];
4020 case PT_NULL
: return "NULL";
4021 case PT_LOAD
: return "LOAD";
4022 case PT_DYNAMIC
: return "DYNAMIC";
4023 case PT_INTERP
: return "INTERP";
4024 case PT_NOTE
: return "NOTE";
4025 case PT_SHLIB
: return "SHLIB";
4026 case PT_PHDR
: return "PHDR";
4027 case PT_TLS
: return "TLS";
4028 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
4029 case PT_GNU_STACK
: return "GNU_STACK";
4030 case PT_GNU_RELRO
: return "GNU_RELRO";
4031 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
4033 case PT_OPENBSD_RANDOMIZE
: return "OPENBSD_RANDOMIZE";
4034 case PT_OPENBSD_WXNEEDED
: return "OPENBSD_WXNEEDED";
4035 case PT_OPENBSD_BOOTDATA
: return "OPENBSD_BOOTDATA";
4038 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
4040 const char * result
;
4042 switch (filedata
->file_header
.e_machine
)
4045 result
= get_aarch64_segment_type (p_type
);
4048 result
= get_arm_segment_type (p_type
);
4051 case EM_MIPS_RS3_LE
:
4052 result
= get_mips_segment_type (p_type
);
4055 result
= get_parisc_segment_type (p_type
);
4058 result
= get_ia64_segment_type (p_type
);
4061 result
= get_tic6x_segment_type (p_type
);
4065 result
= get_s390_segment_type (p_type
);
4075 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
4077 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
4079 const char * result
= NULL
;
4081 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
4084 case ELFOSABI_FREEBSD
:
4085 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
4087 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
4092 result
= get_hpux_segment_type (p_type
,
4093 filedata
->file_header
.e_machine
);
4095 case ELFOSABI_SOLARIS
:
4096 result
= get_solaris_segment_type (p_type
);
4104 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4107 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4114 get_arc_section_type_name (unsigned int sh_type
)
4118 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4126 get_mips_section_type_name (unsigned int sh_type
)
4130 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4131 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4132 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4133 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4134 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4135 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4136 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4137 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4138 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4139 case SHT_MIPS_RELD
: return "MIPS_RELD";
4140 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4141 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4142 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4143 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4144 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4145 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4146 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4147 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4148 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4149 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4150 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4151 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4152 case SHT_MIPS_LINE
: return "MIPS_LINE";
4153 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4154 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4155 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4156 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4157 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4158 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4159 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4160 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4161 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4162 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4163 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4164 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4165 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4166 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4167 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4168 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4169 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4170 case SHT_MIPS_XHASH
: return "MIPS_XHASH";
4178 get_parisc_section_type_name (unsigned int sh_type
)
4182 case SHT_PARISC_EXT
: return "PARISC_EXT";
4183 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4184 case SHT_PARISC_DOC
: return "PARISC_DOC";
4185 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4186 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4187 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4188 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4189 default: return NULL
;
4194 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4196 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4197 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4198 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4202 case SHT_IA_64_EXT
: return "IA_64_EXT";
4203 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4204 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4205 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4206 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4207 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4208 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4209 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4210 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4211 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4219 get_x86_64_section_type_name (unsigned int sh_type
)
4223 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4224 default: return NULL
;
4229 get_aarch64_section_type_name (unsigned int sh_type
)
4233 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4234 default: return NULL
;
4239 get_arm_section_type_name (unsigned int sh_type
)
4243 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4244 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4245 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4246 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4247 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4248 default: return NULL
;
4253 get_tic6x_section_type_name (unsigned int sh_type
)
4257 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4258 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4259 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4260 case SHT_TI_ICODE
: return "TI_ICODE";
4261 case SHT_TI_XREF
: return "TI_XREF";
4262 case SHT_TI_HANDLER
: return "TI_HANDLER";
4263 case SHT_TI_INITINFO
: return "TI_INITINFO";
4264 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4265 default: return NULL
;
4270 get_msp430_section_type_name (unsigned int sh_type
)
4274 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4275 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4276 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4277 default: return NULL
;
4282 get_nfp_section_type_name (unsigned int sh_type
)
4286 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4287 case SHT_NFP_INITREG
: return "NFP_INITREG";
4288 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4289 default: return NULL
;
4294 get_v850_section_type_name (unsigned int sh_type
)
4298 case SHT_V850_SCOMMON
: return "V850 Small Common";
4299 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4300 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4301 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4302 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4303 default: return NULL
;
4308 get_riscv_section_type_name (unsigned int sh_type
)
4312 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4313 default: return NULL
;
4318 get_csky_section_type_name (unsigned int sh_type
)
4322 case SHT_CSKY_ATTRIBUTES
: return "CSKY_ATTRIBUTES";
4323 default: return NULL
;
4328 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4330 static char buff
[32];
4331 const char * result
;
4335 case SHT_NULL
: return "NULL";
4336 case SHT_PROGBITS
: return "PROGBITS";
4337 case SHT_SYMTAB
: return "SYMTAB";
4338 case SHT_STRTAB
: return "STRTAB";
4339 case SHT_RELA
: return "RELA";
4340 case SHT_HASH
: return "HASH";
4341 case SHT_DYNAMIC
: return "DYNAMIC";
4342 case SHT_NOTE
: return "NOTE";
4343 case SHT_NOBITS
: return "NOBITS";
4344 case SHT_REL
: return "REL";
4345 case SHT_SHLIB
: return "SHLIB";
4346 case SHT_DYNSYM
: return "DYNSYM";
4347 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4348 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4349 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4350 case SHT_GNU_HASH
: return "GNU_HASH";
4351 case SHT_GROUP
: return "GROUP";
4352 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4353 case SHT_GNU_verdef
: return "VERDEF";
4354 case SHT_GNU_verneed
: return "VERNEED";
4355 case SHT_GNU_versym
: return "VERSYM";
4356 case 0x6ffffff0: return "VERSYM";
4357 case 0x6ffffffc: return "VERDEF";
4358 case 0x7ffffffd: return "AUXILIARY";
4359 case 0x7fffffff: return "FILTER";
4360 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4363 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4365 switch (filedata
->file_header
.e_machine
)
4368 case EM_ARC_COMPACT
:
4369 case EM_ARC_COMPACT2
:
4370 result
= get_arc_section_type_name (sh_type
);
4373 case EM_MIPS_RS3_LE
:
4374 result
= get_mips_section_type_name (sh_type
);
4377 result
= get_parisc_section_type_name (sh_type
);
4380 result
= get_ia64_section_type_name (filedata
, sh_type
);
4385 result
= get_x86_64_section_type_name (sh_type
);
4388 result
= get_aarch64_section_type_name (sh_type
);
4391 result
= get_arm_section_type_name (sh_type
);
4394 result
= get_tic6x_section_type_name (sh_type
);
4397 result
= get_msp430_section_type_name (sh_type
);
4400 result
= get_nfp_section_type_name (sh_type
);
4404 case EM_CYGNUS_V850
:
4405 result
= get_v850_section_type_name (sh_type
);
4408 result
= get_riscv_section_type_name (sh_type
);
4411 result
= get_csky_section_type_name (sh_type
);
4421 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4423 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4425 switch (filedata
->file_header
.e_machine
)
4428 result
= get_ia64_section_type_name (filedata
, sh_type
);
4431 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4432 result
= get_solaris_section_type (sh_type
);
4437 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4438 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4439 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4440 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4452 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4454 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4456 switch (filedata
->file_header
.e_machine
)
4460 case EM_CYGNUS_V850
:
4461 result
= get_v850_section_type_name (sh_type
);
4471 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4474 /* This message is probably going to be displayed in a 15
4475 character wide field, so put the hex value first. */
4476 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4482 enum long_option_values
4484 OPTION_DEBUG_DUMP
= 512,
4493 OPTION_WITH_SYMBOL_VERSIONS
,
4494 OPTION_RECURSE_LIMIT
,
4495 OPTION_NO_RECURSE_LIMIT
,
4496 OPTION_NO_DEMANGLING
4499 static struct option options
[] =
4501 /* Note - This table is alpha-sorted on the 'val'
4502 field in order to make adding new options easier. */
4503 {"arch-specific", no_argument
, 0, 'A'},
4504 {"all", no_argument
, 0, 'a'},
4505 {"demangle", optional_argument
, 0, 'C'},
4506 {"archive-index", no_argument
, 0, 'c'},
4507 {"use-dynamic", no_argument
, 0, 'D'},
4508 {"dynamic", no_argument
, 0, 'd'},
4509 {"headers", no_argument
, 0, 'e'},
4510 {"section-groups", no_argument
, 0, 'g'},
4511 {"help", no_argument
, 0, 'H'},
4512 {"file-header", no_argument
, 0, 'h'},
4513 {"histogram", no_argument
, 0, 'I'},
4514 {"lint", no_argument
, 0, 'L'},
4515 {"enable-checks", no_argument
, 0, 'L'},
4516 {"program-headers", no_argument
, 0, 'l'},
4517 {"segments", no_argument
, 0, 'l'},
4518 {"full-section-name",no_argument
, 0, 'N'},
4519 {"notes", no_argument
, 0, 'n'},
4520 {"string-dump", required_argument
, 0, 'p'},
4521 {"relocated-dump", required_argument
, 0, 'R'},
4522 {"relocs", no_argument
, 0, 'r'},
4523 {"section-headers", no_argument
, 0, 'S'},
4524 {"sections", no_argument
, 0, 'S'},
4525 {"symbols", no_argument
, 0, 's'},
4526 {"syms", no_argument
, 0, 's'},
4527 {"silent-truncation",no_argument
, 0, 'T'},
4528 {"section-details", no_argument
, 0, 't'},
4529 {"unwind", no_argument
, 0, 'u'},
4530 {"version-info", no_argument
, 0, 'V'},
4531 {"version", no_argument
, 0, 'v'},
4532 {"wide", no_argument
, 0, 'W'},
4533 {"hex-dump", required_argument
, 0, 'x'},
4534 {"decompress", no_argument
, 0, 'z'},
4536 {"no-demangle", no_argument
, 0, OPTION_NO_DEMANGLING
},
4537 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
4538 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
4539 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
4540 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4541 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4542 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4543 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4544 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4545 #ifdef ENABLE_LIBCTF
4546 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
4547 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
4548 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
4549 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
4552 {0, no_argument
, 0, 0}
4556 usage (FILE * stream
)
4558 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4559 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4560 fprintf (stream
, _(" Options are:\n\
4561 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4562 -h --file-header Display the ELF file header\n\
4563 -l --program-headers Display the program headers\n\
4564 --segments An alias for --program-headers\n\
4565 -S --section-headers Display the sections' header\n\
4566 --sections An alias for --section-headers\n\
4567 -g --section-groups Display the section groups\n\
4568 -t --section-details Display the section details\n\
4569 -e --headers Equivalent to: -h -l -S\n\
4570 -s --syms Display the symbol table\n\
4571 --symbols An alias for --syms\n\
4572 --dyn-syms Display the dynamic symbol table\n\
4573 -C --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
4574 The STYLE, if specified, can be `auto' (the default),\n\
4575 `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
4577 --no-demangle Do not demangle low-level symbol names. (This is the default)\n\
4578 --recurse-limit Enable a demangling recursion limit. (This is the default)\n\
4579 --no-recurse-limit Disable a demangling recursion limit\n\
4580 -n --notes Display the core notes (if present)\n\
4581 -r --relocs Display the relocations (if present)\n\
4582 -u --unwind Display the unwind info (if present)\n\
4583 -d --dynamic Display the dynamic section (if present)\n\
4584 -V --version-info Display the version sections (if present)\n\
4585 -A --arch-specific Display architecture specific information (if any)\n\
4586 -c --archive-index Display the symbol/file index in an archive\n\
4587 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4588 -L --lint|--enable-checks Display warning messages for possible problems\n\
4589 -x --hex-dump=<number|name>\n\
4590 Dump the contents of section <number|name> as bytes\n\
4591 -p --string-dump=<number|name>\n\
4592 Dump the contents of section <number|name> as strings\n\
4593 -R --relocated-dump=<number|name>\n\
4594 Dump the contents of section <number|name> as relocated bytes\n\
4595 -z --decompress Decompress section before dumping it\n\
4596 -w[lLiaprmfFsoORtUuTgAckK] or\n\
4597 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4598 =frames-interp,=str,=str-offsets,=loc,=Ranges,=pubtypes,\n\
4599 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4600 =addr,=cu_index,=links,=follow-links]\n\
4601 Display the contents of DWARF debug sections\n"));
4602 fprintf (stream
, _("\
4603 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4604 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4606 #ifdef ENABLE_LIBCTF
4607 fprintf (stream
, _("\
4608 --ctf=<number|name> Display CTF info from section <number|name>\n\
4609 --ctf-parent=<number|name>\n\
4610 Use section <number|name> as the CTF parent\n\n\
4611 --ctf-symbols=<number|name>\n\
4612 Use section <number|name> as the CTF external symtab\n\n\
4613 --ctf-strings=<number|name>\n\
4614 Use section <number|name> as the CTF external strtab\n\n"));
4617 #ifdef SUPPORT_DISASSEMBLY
4618 fprintf (stream
, _("\
4619 -i --instruction-dump=<number|name>\n\
4620 Disassemble the contents of section <number|name>\n"));
4622 fprintf (stream
, _("\
4623 -I --histogram Display histogram of bucket list lengths\n\
4624 -W --wide Allow output width to exceed 80 characters\n\
4625 -T --silent-truncation If a symbol name is truncated, do not add a suffix [...]\n\
4626 @<file> Read options from <file>\n\
4627 -H --help Display this information\n\
4628 -v --version Display the version number of readelf\n"));
4630 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4631 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4633 exit (stream
== stdout
? 0 : 1);
4636 /* Record the fact that the user wants the contents of section number
4637 SECTION to be displayed using the method(s) encoded as flags bits
4638 in TYPE. Note, TYPE can be zero if we are creating the array for
4642 request_dump_bynumber (struct dump_data
*dumpdata
,
4643 unsigned int section
, dump_type type
)
4645 if (section
>= dumpdata
->num_dump_sects
)
4647 dump_type
* new_dump_sects
;
4649 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4650 sizeof (* new_dump_sects
));
4652 if (new_dump_sects
== NULL
)
4653 error (_("Out of memory allocating dump request table.\n"));
4656 if (dumpdata
->dump_sects
)
4658 /* Copy current flag settings. */
4659 memcpy (new_dump_sects
, dumpdata
->dump_sects
,
4660 dumpdata
->num_dump_sects
* sizeof (* new_dump_sects
));
4662 free (dumpdata
->dump_sects
);
4665 dumpdata
->dump_sects
= new_dump_sects
;
4666 dumpdata
->num_dump_sects
= section
+ 1;
4670 if (dumpdata
->dump_sects
)
4671 dumpdata
->dump_sects
[section
] |= type
;
4674 /* Request a dump by section name. */
4677 request_dump_byname (const char * section
, dump_type type
)
4679 struct dump_list_entry
* new_request
;
4681 new_request
= (struct dump_list_entry
*)
4682 malloc (sizeof (struct dump_list_entry
));
4684 error (_("Out of memory allocating dump request table.\n"));
4686 new_request
->name
= strdup (section
);
4687 if (!new_request
->name
)
4688 error (_("Out of memory allocating dump request table.\n"));
4690 new_request
->type
= type
;
4692 new_request
->next
= dump_sects_byname
;
4693 dump_sects_byname
= new_request
;
4697 request_dump (struct dump_data
*dumpdata
, dump_type type
)
4703 section
= strtoul (optarg
, & cp
, 0);
4705 if (! *cp
&& section
>= 0)
4706 request_dump_bynumber (dumpdata
, section
, type
);
4708 request_dump_byname (optarg
, type
);
4712 parse_args (struct dump_data
*dumpdata
, int argc
, char ** argv
)
4719 while ((c
= getopt_long
4720 (argc
, argv
, "ACDHILNR:STVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4738 do_section_groups
= TRUE
;
4741 do_histogram
= TRUE
;
4747 do_section_groups
= TRUE
;
4752 do_section_details
= TRUE
;
4763 do_using_dynamic
= TRUE
;
4787 do_histogram
= TRUE
;
4793 do_archive_index
= TRUE
;
4799 request_dump (dumpdata
, HEX_DUMP
);
4802 request_dump (dumpdata
, STRING_DUMP
);
4805 request_dump (dumpdata
, RELOC_DUMP
);
4808 decompress_dumps
= TRUE
;
4814 do_debugging
= TRUE
;
4815 dwarf_select_sections_all ();
4819 do_debugging
= FALSE
;
4820 dwarf_select_sections_by_letters (optarg
);
4823 case OPTION_DEBUG_DUMP
:
4826 do_debugging
= TRUE
;
4829 do_debugging
= FALSE
;
4830 dwarf_select_sections_by_names (optarg
);
4833 case OPTION_DWARF_DEPTH
:
4837 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4840 case OPTION_DWARF_START
:
4844 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4847 case OPTION_DWARF_CHECK
:
4850 case OPTION_CTF_DUMP
:
4852 request_dump (dumpdata
, CTF_DUMP
);
4854 case OPTION_CTF_SYMBOLS
:
4855 free (dump_ctf_symtab_name
);
4856 dump_ctf_symtab_name
= strdup (optarg
);
4858 case OPTION_CTF_STRINGS
:
4859 free (dump_ctf_strtab_name
);
4860 dump_ctf_strtab_name
= strdup (optarg
);
4862 case OPTION_CTF_PARENT
:
4863 free (dump_ctf_parent_name
);
4864 dump_ctf_parent_name
= strdup (optarg
);
4866 case OPTION_DYN_SYMS
:
4869 #ifdef SUPPORT_DISASSEMBLY
4871 request_dump (dumpdata
, DISASS_DUMP
);
4875 print_version (program_name
);
4884 do_not_show_symbol_truncation
= TRUE
;
4890 enum demangling_styles style
;
4892 style
= cplus_demangle_name_to_style (optarg
);
4893 if (style
== unknown_demangling
)
4894 error (_("unknown demangling style `%s'"), optarg
);
4896 cplus_demangle_set_style (style
);
4899 case OPTION_NO_DEMANGLING
:
4900 do_demangle
= FALSE
;
4902 case OPTION_RECURSE_LIMIT
:
4903 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
4905 case OPTION_NO_RECURSE_LIMIT
:
4906 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
4908 case OPTION_WITH_SYMBOL_VERSIONS
:
4909 /* Ignored for backward compatibility. */
4913 /* xgettext:c-format */
4914 error (_("Invalid option '-%c'\n"), c
);
4921 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4922 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4923 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4924 && !do_section_groups
&& !do_archive_index
4930 do_dynamic
= do_syms
= do_reloc
= do_unwind
= do_sections
= TRUE
;
4931 do_segments
= do_header
= do_dump
= do_version
= TRUE
;
4932 do_histogram
= do_debugging
= do_arch
= do_notes
= TRUE
;
4933 do_section_groups
= do_archive_index
= do_dyn_syms
= TRUE
;
4941 get_elf_class (unsigned int elf_class
)
4943 static char buff
[32];
4947 case ELFCLASSNONE
: return _("none");
4948 case ELFCLASS32
: return "ELF32";
4949 case ELFCLASS64
: return "ELF64";
4951 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4957 get_data_encoding (unsigned int encoding
)
4959 static char buff
[32];
4963 case ELFDATANONE
: return _("none");
4964 case ELFDATA2LSB
: return _("2's complement, little endian");
4965 case ELFDATA2MSB
: return _("2's complement, big endian");
4967 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4972 /* Decode the data held in 'filedata->file_header'. */
4975 process_file_header (Filedata
* filedata
)
4977 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4979 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4980 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4981 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4982 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4985 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4989 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
4995 printf (_("ELF Header:\n"));
4996 printf (_(" Magic: "));
4997 for (i
= 0; i
< EI_NIDENT
; i
++)
4998 printf ("%2.2x ", header
->e_ident
[i
]);
5000 printf (_(" Class: %s\n"),
5001 get_elf_class (header
->e_ident
[EI_CLASS
]));
5002 printf (_(" Data: %s\n"),
5003 get_data_encoding (header
->e_ident
[EI_DATA
]));
5004 printf (_(" Version: %d%s\n"),
5005 header
->e_ident
[EI_VERSION
],
5006 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
5008 : (header
->e_ident
[EI_VERSION
] != EV_NONE
5011 printf (_(" OS/ABI: %s\n"),
5012 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
5013 printf (_(" ABI Version: %d\n"),
5014 header
->e_ident
[EI_ABIVERSION
]);
5015 printf (_(" Type: %s\n"),
5016 get_file_type (header
->e_type
));
5017 printf (_(" Machine: %s\n"),
5018 get_machine_name (header
->e_machine
));
5019 printf (_(" Version: 0x%lx\n"),
5022 printf (_(" Entry point address: "));
5023 print_vma (header
->e_entry
, PREFIX_HEX
);
5024 printf (_("\n Start of program headers: "));
5025 print_vma (header
->e_phoff
, DEC
);
5026 printf (_(" (bytes into file)\n Start of section headers: "));
5027 print_vma (header
->e_shoff
, DEC
);
5028 printf (_(" (bytes into file)\n"));
5030 printf (_(" Flags: 0x%lx%s\n"),
5032 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
5033 printf (_(" Size of this header: %u (bytes)\n"),
5035 printf (_(" Size of program headers: %u (bytes)\n"),
5036 header
->e_phentsize
);
5037 printf (_(" Number of program headers: %u"),
5039 if (filedata
->section_headers
!= NULL
5040 && header
->e_phnum
== PN_XNUM
5041 && filedata
->section_headers
[0].sh_info
!= 0)
5043 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
5044 printf (" (%u)", header
->e_phnum
);
5046 putc ('\n', stdout
);
5047 printf (_(" Size of section headers: %u (bytes)\n"),
5048 header
->e_shentsize
);
5049 printf (_(" Number of section headers: %u"),
5051 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
5053 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5054 printf (" (%u)", header
->e_shnum
);
5056 putc ('\n', stdout
);
5057 printf (_(" Section header string table index: %u"),
5058 header
->e_shstrndx
);
5059 if (filedata
->section_headers
!= NULL
5060 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5062 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5063 printf (" (%u)", header
->e_shstrndx
);
5065 if (header
->e_shstrndx
!= SHN_UNDEF
5066 && header
->e_shstrndx
>= header
->e_shnum
)
5068 header
->e_shstrndx
= SHN_UNDEF
;
5069 printf (_(" <corrupt: out of range>"));
5071 putc ('\n', stdout
);
5074 if (filedata
->section_headers
!= NULL
)
5076 if (header
->e_phnum
== PN_XNUM
5077 && filedata
->section_headers
[0].sh_info
!= 0)
5078 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
5079 if (header
->e_shnum
== SHN_UNDEF
)
5080 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5081 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5082 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5083 if (header
->e_shstrndx
>= header
->e_shnum
)
5084 header
->e_shstrndx
= SHN_UNDEF
;
5085 free (filedata
->section_headers
);
5086 filedata
->section_headers
= NULL
;
5092 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5093 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
5096 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5098 Elf32_External_Phdr
* phdrs
;
5099 Elf32_External_Phdr
* external
;
5100 Elf_Internal_Phdr
* internal
;
5102 unsigned int size
= filedata
->file_header
.e_phentsize
;
5103 unsigned int num
= filedata
->file_header
.e_phnum
;
5105 /* PR binutils/17531: Cope with unexpected section header sizes. */
5106 if (size
== 0 || num
== 0)
5108 if (size
< sizeof * phdrs
)
5110 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5113 if (size
> sizeof * phdrs
)
5114 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5116 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5117 size
, num
, _("program headers"));
5121 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5122 i
< filedata
->file_header
.e_phnum
;
5123 i
++, internal
++, external
++)
5125 internal
->p_type
= BYTE_GET (external
->p_type
);
5126 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5127 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5128 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5129 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5130 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5131 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5132 internal
->p_align
= BYTE_GET (external
->p_align
);
5139 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5140 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5143 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5145 Elf64_External_Phdr
* phdrs
;
5146 Elf64_External_Phdr
* external
;
5147 Elf_Internal_Phdr
* internal
;
5149 unsigned int size
= filedata
->file_header
.e_phentsize
;
5150 unsigned int num
= filedata
->file_header
.e_phnum
;
5152 /* PR binutils/17531: Cope with unexpected section header sizes. */
5153 if (size
== 0 || num
== 0)
5155 if (size
< sizeof * phdrs
)
5157 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5160 if (size
> sizeof * phdrs
)
5161 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5163 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5164 size
, num
, _("program headers"));
5168 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5169 i
< filedata
->file_header
.e_phnum
;
5170 i
++, internal
++, external
++)
5172 internal
->p_type
= BYTE_GET (external
->p_type
);
5173 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5174 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5175 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5176 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5177 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5178 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5179 internal
->p_align
= BYTE_GET (external
->p_align
);
5186 /* Returns TRUE if the program headers were read into `program_headers'. */
5189 get_program_headers (Filedata
* filedata
)
5191 Elf_Internal_Phdr
* phdrs
;
5193 /* Check cache of prior read. */
5194 if (filedata
->program_headers
!= NULL
)
5197 /* Be kind to memory checkers by looking for
5198 e_phnum values which we know must be invalid. */
5199 if (filedata
->file_header
.e_phnum
5200 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5201 >= filedata
->file_size
)
5203 error (_("Too many program headers - %#x - the file is not that big\n"),
5204 filedata
->file_header
.e_phnum
);
5208 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5209 sizeof (Elf_Internal_Phdr
));
5212 error (_("Out of memory reading %u program headers\n"),
5213 filedata
->file_header
.e_phnum
);
5218 ? get_32bit_program_headers (filedata
, phdrs
)
5219 : get_64bit_program_headers (filedata
, phdrs
))
5221 filedata
->program_headers
= phdrs
;
5229 /* Returns TRUE if the program headers were loaded. */
5232 process_program_headers (Filedata
* filedata
)
5234 Elf_Internal_Phdr
* segment
;
5236 Elf_Internal_Phdr
* previous_load
= NULL
;
5238 filedata
->dynamic_addr
= 0;
5239 filedata
->dynamic_size
= 0;
5241 if (filedata
->file_header
.e_phnum
== 0)
5243 /* PR binutils/12467. */
5244 if (filedata
->file_header
.e_phoff
!= 0)
5246 warn (_("possibly corrupt ELF header - it has a non-zero program"
5247 " header offset, but no program headers\n"));
5250 else if (do_segments
)
5251 printf (_("\nThere are no program headers in this file.\n"));
5255 if (do_segments
&& !do_header
)
5257 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5258 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5259 printf (ngettext ("There is %d program header, starting at offset %s\n",
5260 "There are %d program headers, starting at offset %s\n",
5261 filedata
->file_header
.e_phnum
),
5262 filedata
->file_header
.e_phnum
,
5263 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5266 if (! get_program_headers (filedata
))
5271 if (filedata
->file_header
.e_phnum
> 1)
5272 printf (_("\nProgram Headers:\n"));
5274 printf (_("\nProgram Headers:\n"));
5278 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5281 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5285 (_(" Type Offset VirtAddr PhysAddr\n"));
5287 (_(" FileSiz MemSiz Flags Align\n"));
5291 for (i
= 0, segment
= filedata
->program_headers
;
5292 i
< filedata
->file_header
.e_phnum
;
5297 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5301 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5302 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5303 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5304 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5305 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5307 (segment
->p_flags
& PF_R
? 'R' : ' '),
5308 (segment
->p_flags
& PF_W
? 'W' : ' '),
5309 (segment
->p_flags
& PF_X
? 'E' : ' '));
5310 printf ("%#lx", (unsigned long) segment
->p_align
);
5314 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5315 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5318 print_vma (segment
->p_offset
, FULL_HEX
);
5322 print_vma (segment
->p_vaddr
, FULL_HEX
);
5324 print_vma (segment
->p_paddr
, FULL_HEX
);
5327 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5328 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5331 print_vma (segment
->p_filesz
, FULL_HEX
);
5335 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5336 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5339 print_vma (segment
->p_memsz
, FULL_HEX
);
5343 (segment
->p_flags
& PF_R
? 'R' : ' '),
5344 (segment
->p_flags
& PF_W
? 'W' : ' '),
5345 (segment
->p_flags
& PF_X
? 'E' : ' '));
5347 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5348 printf ("%#lx", (unsigned long) segment
->p_align
);
5351 print_vma (segment
->p_align
, PREFIX_HEX
);
5356 print_vma (segment
->p_offset
, FULL_HEX
);
5358 print_vma (segment
->p_vaddr
, FULL_HEX
);
5360 print_vma (segment
->p_paddr
, FULL_HEX
);
5362 print_vma (segment
->p_filesz
, FULL_HEX
);
5364 print_vma (segment
->p_memsz
, FULL_HEX
);
5366 (segment
->p_flags
& PF_R
? 'R' : ' '),
5367 (segment
->p_flags
& PF_W
? 'W' : ' '),
5368 (segment
->p_flags
& PF_X
? 'E' : ' '));
5369 print_vma (segment
->p_align
, PREFIX_HEX
);
5372 putc ('\n', stdout
);
5375 switch (segment
->p_type
)
5378 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5379 required by the ELF standard, several programs, including the Linux
5380 kernel, make use of non-ordered segments. */
5382 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5383 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5385 if (segment
->p_memsz
< segment
->p_filesz
)
5386 error (_("the segment's file size is larger than its memory size\n"));
5387 previous_load
= segment
;
5391 /* PR 20815 - Verify that the program header is loaded into memory. */
5392 if (i
> 0 && previous_load
!= NULL
)
5393 error (_("the PHDR segment must occur before any LOAD segment\n"));
5394 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5398 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5400 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
5401 if (load
->p_type
== PT_LOAD
5402 && load
->p_offset
<= segment
->p_offset
5403 && (load
->p_offset
+ load
->p_filesz
5404 >= segment
->p_offset
+ segment
->p_filesz
)
5405 && load
->p_vaddr
<= segment
->p_vaddr
5406 && (load
->p_vaddr
+ load
->p_filesz
5407 >= segment
->p_vaddr
+ segment
->p_filesz
))
5410 if (j
== filedata
->file_header
.e_phnum
)
5411 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5416 if (filedata
->dynamic_addr
)
5417 error (_("more than one dynamic segment\n"));
5419 /* By default, assume that the .dynamic section is the first
5420 section in the DYNAMIC segment. */
5421 filedata
->dynamic_addr
= segment
->p_offset
;
5422 filedata
->dynamic_size
= segment
->p_filesz
;
5424 /* Try to locate the .dynamic section. If there is
5425 a section header table, we can easily locate it. */
5426 if (filedata
->section_headers
!= NULL
)
5428 Elf_Internal_Shdr
* sec
;
5430 sec
= find_section (filedata
, ".dynamic");
5431 if (sec
== NULL
|| sec
->sh_size
== 0)
5433 /* A corresponding .dynamic section is expected, but on
5434 IA-64/OpenVMS it is OK for it to be missing. */
5435 if (!is_ia64_vms (filedata
))
5436 error (_("no .dynamic section in the dynamic segment\n"));
5440 if (sec
->sh_type
== SHT_NOBITS
)
5442 filedata
->dynamic_size
= 0;
5446 filedata
->dynamic_addr
= sec
->sh_offset
;
5447 filedata
->dynamic_size
= sec
->sh_size
;
5449 /* The PT_DYNAMIC segment, which is used by the run-time
5450 loader, should exactly match the .dynamic section. */
5452 && (filedata
->dynamic_addr
!= segment
->p_offset
5453 || filedata
->dynamic_size
!= segment
->p_filesz
))
5455 the .dynamic section is not the same as the dynamic segment\n"));
5458 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5459 segment. Check this after matching against the section headers
5460 so we don't warn on debuginfo file (which have NOBITS .dynamic
5462 if (filedata
->dynamic_addr
> filedata
->file_size
5463 || (filedata
->dynamic_size
5464 > filedata
->file_size
- filedata
->dynamic_addr
))
5466 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5467 filedata
->dynamic_addr
= filedata
->dynamic_size
= 0;
5472 if (fseek (filedata
->handle
,
5473 filedata
->archive_file_offset
+ (long) segment
->p_offset
,
5475 error (_("Unable to find program interpreter name\n"));
5479 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5481 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5482 error (_("Internal error: failed to create format string to display program interpreter\n"));
5484 filedata
->program_interpreter
[0] = 0;
5485 if (fscanf (filedata
->handle
, fmt
,
5486 filedata
->program_interpreter
) <= 0)
5487 error (_("Unable to read program interpreter name\n"));
5490 printf (_(" [Requesting program interpreter: %s]\n"),
5491 filedata
->program_interpreter
);
5498 && filedata
->section_headers
!= NULL
5499 && filedata
->string_table
!= NULL
)
5501 printf (_("\n Section to Segment mapping:\n"));
5502 printf (_(" Segment Sections...\n"));
5504 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5507 Elf_Internal_Shdr
* section
;
5509 segment
= filedata
->program_headers
+ i
;
5510 section
= filedata
->section_headers
+ 1;
5512 printf (" %2.2d ", i
);
5514 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5516 if (!ELF_TBSS_SPECIAL (section
, segment
)
5517 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5518 printf ("%s ", printable_section_name (filedata
, section
));
5529 /* Find the file offset corresponding to VMA by using the program headers. */
5532 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5534 Elf_Internal_Phdr
* seg
;
5536 if (! get_program_headers (filedata
))
5538 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5542 for (seg
= filedata
->program_headers
;
5543 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5546 if (seg
->p_type
!= PT_LOAD
)
5549 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5550 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5551 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5554 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5555 (unsigned long) vma
);
5560 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5561 If PROBE is true, this is just a probe and we do not generate any error
5562 messages if the load fails. */
5565 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5567 Elf32_External_Shdr
* shdrs
;
5568 Elf_Internal_Shdr
* internal
;
5570 unsigned int size
= filedata
->file_header
.e_shentsize
;
5571 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5573 /* PR binutils/17531: Cope with unexpected section header sizes. */
5574 if (size
== 0 || num
== 0)
5576 if (size
< sizeof * shdrs
)
5579 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5582 if (!probe
&& size
> sizeof * shdrs
)
5583 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5585 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5587 probe
? NULL
: _("section headers"));
5591 free (filedata
->section_headers
);
5592 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5593 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5594 if (filedata
->section_headers
== NULL
)
5597 error (_("Out of memory reading %u section headers\n"), num
);
5602 for (i
= 0, internal
= filedata
->section_headers
;
5606 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5607 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5608 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5609 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5610 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5611 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5612 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5613 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5614 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5615 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5616 if (!probe
&& internal
->sh_link
> num
)
5617 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5618 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5619 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5626 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5629 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5631 Elf64_External_Shdr
* shdrs
;
5632 Elf_Internal_Shdr
* internal
;
5634 unsigned int size
= filedata
->file_header
.e_shentsize
;
5635 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5637 /* PR binutils/17531: Cope with unexpected section header sizes. */
5638 if (size
== 0 || num
== 0)
5641 if (size
< sizeof * shdrs
)
5644 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5648 if (! probe
&& size
> sizeof * shdrs
)
5649 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5651 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5652 filedata
->file_header
.e_shoff
,
5654 probe
? NULL
: _("section headers"));
5658 free (filedata
->section_headers
);
5659 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5660 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5661 if (filedata
->section_headers
== NULL
)
5664 error (_("Out of memory reading %u section headers\n"), num
);
5669 for (i
= 0, internal
= filedata
->section_headers
;
5673 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5674 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5675 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5676 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5677 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5678 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5679 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5680 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5681 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5682 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5683 if (!probe
&& internal
->sh_link
> num
)
5684 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5685 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5686 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5693 static Elf_Internal_Sym
*
5694 get_32bit_elf_symbols (Filedata
* filedata
,
5695 Elf_Internal_Shdr
* section
,
5696 unsigned long * num_syms_return
)
5698 unsigned long number
= 0;
5699 Elf32_External_Sym
* esyms
= NULL
;
5700 Elf_External_Sym_Shndx
* shndx
= NULL
;
5701 Elf_Internal_Sym
* isyms
= NULL
;
5702 Elf_Internal_Sym
* psym
;
5704 elf_section_list
* entry
;
5706 if (section
->sh_size
== 0)
5708 if (num_syms_return
!= NULL
)
5709 * num_syms_return
= 0;
5713 /* Run some sanity checks first. */
5714 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5716 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5717 printable_section_name (filedata
, section
),
5718 (unsigned long) section
->sh_entsize
);
5722 if (section
->sh_size
> filedata
->file_size
)
5724 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5725 printable_section_name (filedata
, section
),
5726 (unsigned long) section
->sh_size
);
5730 number
= section
->sh_size
/ section
->sh_entsize
;
5732 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5734 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5735 (unsigned long) section
->sh_size
,
5736 printable_section_name (filedata
, section
),
5737 (unsigned long) section
->sh_entsize
);
5741 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5742 section
->sh_size
, _("symbols"));
5747 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5749 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5754 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5758 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5759 entry
->hdr
->sh_offset
,
5760 1, entry
->hdr
->sh_size
,
5761 _("symbol table section indices"));
5765 /* PR17531: file: heap-buffer-overflow */
5766 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5768 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5769 printable_section_name (filedata
, entry
->hdr
),
5770 (unsigned long) entry
->hdr
->sh_size
,
5771 (unsigned long) section
->sh_size
);
5776 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5780 error (_("Out of memory reading %lu symbols\n"),
5781 (unsigned long) number
);
5785 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5787 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5788 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5789 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5790 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5791 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5793 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5794 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5795 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5796 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5797 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5804 if (num_syms_return
!= NULL
)
5805 * num_syms_return
= isyms
== NULL
? 0 : number
;
5810 static Elf_Internal_Sym
*
5811 get_64bit_elf_symbols (Filedata
* filedata
,
5812 Elf_Internal_Shdr
* section
,
5813 unsigned long * num_syms_return
)
5815 unsigned long number
= 0;
5816 Elf64_External_Sym
* esyms
= NULL
;
5817 Elf_External_Sym_Shndx
* shndx
= NULL
;
5818 Elf_Internal_Sym
* isyms
= NULL
;
5819 Elf_Internal_Sym
* psym
;
5821 elf_section_list
* entry
;
5823 if (section
->sh_size
== 0)
5825 if (num_syms_return
!= NULL
)
5826 * num_syms_return
= 0;
5830 /* Run some sanity checks first. */
5831 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5833 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5834 printable_section_name (filedata
, section
),
5835 (unsigned long) section
->sh_entsize
);
5839 if (section
->sh_size
> filedata
->file_size
)
5841 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5842 printable_section_name (filedata
, section
),
5843 (unsigned long) section
->sh_size
);
5847 number
= section
->sh_size
/ section
->sh_entsize
;
5849 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5851 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5852 (unsigned long) section
->sh_size
,
5853 printable_section_name (filedata
, section
),
5854 (unsigned long) section
->sh_entsize
);
5858 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5859 section
->sh_size
, _("symbols"));
5864 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5866 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5871 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5875 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5876 entry
->hdr
->sh_offset
,
5877 1, entry
->hdr
->sh_size
,
5878 _("symbol table section indices"));
5882 /* PR17531: file: heap-buffer-overflow */
5883 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5885 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5886 printable_section_name (filedata
, entry
->hdr
),
5887 (unsigned long) entry
->hdr
->sh_size
,
5888 (unsigned long) section
->sh_size
);
5893 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5897 error (_("Out of memory reading %lu symbols\n"),
5898 (unsigned long) number
);
5902 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5904 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5905 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5906 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5907 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5909 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5911 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5912 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5913 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5915 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5916 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5923 if (num_syms_return
!= NULL
)
5924 * num_syms_return
= isyms
== NULL
? 0 : number
;
5930 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5932 static char buff
[1024];
5934 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5936 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5937 bfd_vma os_flags
= 0;
5938 bfd_vma proc_flags
= 0;
5939 bfd_vma unknown_flags
= 0;
5947 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5948 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5949 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5950 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5951 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5952 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5953 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5954 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5955 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5956 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5957 /* IA-64 specific. */
5958 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5959 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5960 /* IA-64 OpenVMS specific. */
5961 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5962 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5963 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5964 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5965 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5966 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5968 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5969 /* SPARC specific. */
5970 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5971 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5973 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5974 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5975 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5977 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5979 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5982 if (do_section_details
)
5984 sprintf (buff
, "[%*.*lx]: ",
5985 field_size
, field_size
, (unsigned long) sh_flags
);
5986 p
+= field_size
+ 4;
5993 flag
= sh_flags
& - sh_flags
;
5996 if (do_section_details
)
6000 case SHF_WRITE
: sindex
= 0; break;
6001 case SHF_ALLOC
: sindex
= 1; break;
6002 case SHF_EXECINSTR
: sindex
= 2; break;
6003 case SHF_MERGE
: sindex
= 3; break;
6004 case SHF_STRINGS
: sindex
= 4; break;
6005 case SHF_INFO_LINK
: sindex
= 5; break;
6006 case SHF_LINK_ORDER
: sindex
= 6; break;
6007 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
6008 case SHF_GROUP
: sindex
= 8; break;
6009 case SHF_TLS
: sindex
= 9; break;
6010 case SHF_EXCLUDE
: sindex
= 18; break;
6011 case SHF_COMPRESSED
: sindex
= 20; break;
6012 case SHF_GNU_MBIND
: sindex
= 24; break;
6016 switch (filedata
->file_header
.e_machine
)
6019 if (flag
== SHF_IA_64_SHORT
)
6021 else if (flag
== SHF_IA_64_NORECOV
)
6024 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
6027 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
6028 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
6029 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
6030 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
6031 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
6032 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
6043 case EM_OLD_SPARCV9
:
6044 case EM_SPARC32PLUS
:
6047 if (flag
== SHF_ORDERED
)
6054 case SHF_ENTRYSECT
: sindex
= 21; break;
6055 case SHF_ARM_PURECODE
: sindex
= 22; break;
6056 case SHF_COMDEF
: sindex
= 23; break;
6061 if (flag
== SHF_PPC_VLE
)
6072 if (p
!= buff
+ field_size
+ 4)
6074 if (size
< (10 + 2))
6076 warn (_("Internal error: not enough buffer room for section flag info"));
6077 return _("<unknown>");
6084 size
-= flags
[sindex
].len
;
6085 p
= stpcpy (p
, flags
[sindex
].str
);
6087 else if (flag
& SHF_MASKOS
)
6089 else if (flag
& SHF_MASKPROC
)
6092 unknown_flags
|= flag
;
6098 case SHF_WRITE
: *p
= 'W'; break;
6099 case SHF_ALLOC
: *p
= 'A'; break;
6100 case SHF_EXECINSTR
: *p
= 'X'; break;
6101 case SHF_MERGE
: *p
= 'M'; break;
6102 case SHF_STRINGS
: *p
= 'S'; break;
6103 case SHF_INFO_LINK
: *p
= 'I'; break;
6104 case SHF_LINK_ORDER
: *p
= 'L'; break;
6105 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
6106 case SHF_GROUP
: *p
= 'G'; break;
6107 case SHF_TLS
: *p
= 'T'; break;
6108 case SHF_EXCLUDE
: *p
= 'E'; break;
6109 case SHF_COMPRESSED
: *p
= 'C'; break;
6110 case SHF_GNU_MBIND
: *p
= 'D'; break;
6113 if ((filedata
->file_header
.e_machine
== EM_X86_64
6114 || filedata
->file_header
.e_machine
== EM_L1OM
6115 || filedata
->file_header
.e_machine
== EM_K1OM
)
6116 && flag
== SHF_X86_64_LARGE
)
6118 else if (filedata
->file_header
.e_machine
== EM_ARM
6119 && flag
== SHF_ARM_PURECODE
)
6121 else if (filedata
->file_header
.e_machine
== EM_PPC
6122 && flag
== SHF_PPC_VLE
)
6124 else if (flag
& SHF_MASKOS
)
6127 sh_flags
&= ~ SHF_MASKOS
;
6129 else if (flag
& SHF_MASKPROC
)
6132 sh_flags
&= ~ SHF_MASKPROC
;
6142 if (do_section_details
)
6146 size
-= 5 + field_size
;
6147 if (p
!= buff
+ field_size
+ 4)
6151 warn (_("Internal error: not enough buffer room for section flag info"));
6152 return _("<unknown>");
6158 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6159 (unsigned long) os_flags
);
6160 p
+= 5 + field_size
;
6164 size
-= 7 + field_size
;
6165 if (p
!= buff
+ field_size
+ 4)
6169 warn (_("Internal error: not enough buffer room for section flag info"));
6170 return _("<unknown>");
6176 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6177 (unsigned long) proc_flags
);
6178 p
+= 7 + field_size
;
6182 size
-= 10 + field_size
;
6183 if (p
!= buff
+ field_size
+ 4)
6187 warn (_("Internal error: not enough buffer room for section flag info"));
6188 return _("<unknown>");
6194 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6195 (unsigned long) unknown_flags
);
6196 p
+= 10 + field_size
;
6204 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
6205 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6209 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6211 if (size
< sizeof (* echdr
))
6213 error (_("Compressed section is too small even for a compression header\n"));
6217 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6218 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6219 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6220 return sizeof (*echdr
);
6224 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6226 if (size
< sizeof (* echdr
))
6228 error (_("Compressed section is too small even for a compression header\n"));
6232 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6233 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6234 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6235 return sizeof (*echdr
);
6240 process_section_headers (Filedata
* filedata
)
6242 Elf_Internal_Shdr
* section
;
6245 free (filedata
->section_headers
);
6246 filedata
->section_headers
= NULL
;
6247 free (filedata
->dynamic_symbols
);
6248 filedata
->dynamic_symbols
= NULL
;
6249 filedata
->num_dynamic_syms
= 0;
6250 free (filedata
->dynamic_strings
);
6251 filedata
->dynamic_strings
= NULL
;
6252 filedata
->dynamic_strings_length
= 0;
6253 free (filedata
->dynamic_syminfo
);
6254 filedata
->dynamic_syminfo
= NULL
;
6255 while (filedata
->symtab_shndx_list
!= NULL
)
6257 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
6258 free (filedata
->symtab_shndx_list
);
6259 filedata
->symtab_shndx_list
= next
;
6262 if (filedata
->file_header
.e_shnum
== 0)
6264 /* PR binutils/12467. */
6265 if (filedata
->file_header
.e_shoff
!= 0)
6267 warn (_("possibly corrupt ELF file header - it has a non-zero"
6268 " section header offset, but no section headers\n"));
6271 else if (do_sections
)
6272 printf (_("\nThere are no sections in this file.\n"));
6277 if (do_sections
&& !do_header
)
6278 printf (ngettext ("There is %d section header, "
6279 "starting at offset 0x%lx:\n",
6280 "There are %d section headers, "
6281 "starting at offset 0x%lx:\n",
6282 filedata
->file_header
.e_shnum
),
6283 filedata
->file_header
.e_shnum
,
6284 (unsigned long) filedata
->file_header
.e_shoff
);
6288 if (! get_32bit_section_headers (filedata
, FALSE
))
6293 if (! get_64bit_section_headers (filedata
, FALSE
))
6297 /* Read in the string table, so that we have names to display. */
6298 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6299 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6301 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6303 if (section
->sh_size
!= 0)
6305 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6306 1, section
->sh_size
,
6309 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6313 /* Scan the sections for the dynamic symbol table
6314 and dynamic string table and debug sections. */
6315 eh_addr_size
= is_32bit_elf
? 4 : 8;
6316 switch (filedata
->file_header
.e_machine
)
6319 case EM_MIPS_RS3_LE
:
6320 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6321 FDE addresses. However, the ABI also has a semi-official ILP32
6322 variant for which the normal FDE address size rules apply.
6324 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6325 section, where XX is the size of longs in bits. Unfortunately,
6326 earlier compilers provided no way of distinguishing ILP32 objects
6327 from LP64 objects, so if there's any doubt, we should assume that
6328 the official LP64 form is being used. */
6329 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6330 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6336 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6338 case E_H8_MACH_H8300
:
6339 case E_H8_MACH_H8300HN
:
6340 case E_H8_MACH_H8300SN
:
6341 case E_H8_MACH_H8300SXN
:
6344 case E_H8_MACH_H8300H
:
6345 case E_H8_MACH_H8300S
:
6346 case E_H8_MACH_H8300SX
:
6354 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6356 case EF_M32C_CPU_M16C
:
6363 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6366 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6367 if (section->sh_entsize != expected_entsize) \
6370 sprintf_vma (buf, section->sh_entsize); \
6371 /* Note: coded this way so that there is a single string for \
6373 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6374 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6375 (unsigned) expected_entsize); \
6376 section->sh_entsize = expected_entsize; \
6381 #define CHECK_ENTSIZE(section, i, type) \
6382 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6383 sizeof (Elf64_External_##type))
6385 for (i
= 0, section
= filedata
->section_headers
;
6386 i
< filedata
->file_header
.e_shnum
;
6389 char * name
= SECTION_NAME (section
);
6391 /* Run some sanity checks on the headers and
6392 possibly fill in some file data as well. */
6393 switch (section
->sh_type
)
6396 if (filedata
->dynamic_symbols
!= NULL
)
6398 error (_("File contains multiple dynamic symbol tables\n"));
6402 CHECK_ENTSIZE (section
, i
, Sym
);
6403 filedata
->dynamic_symbols
6404 = GET_ELF_SYMBOLS (filedata
, section
, &filedata
->num_dynamic_syms
);
6405 filedata
->dynamic_symtab_section
= section
;
6409 if (streq (name
, ".dynstr"))
6411 if (filedata
->dynamic_strings
!= NULL
)
6413 error (_("File contains multiple dynamic string tables\n"));
6417 filedata
->dynamic_strings
6418 = (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6419 1, section
->sh_size
, _("dynamic strings"));
6420 filedata
->dynamic_strings_length
6421 = filedata
->dynamic_strings
== NULL
? 0 : section
->sh_size
;
6422 filedata
->dynamic_strtab_section
= section
;
6426 case SHT_SYMTAB_SHNDX
:
6428 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6430 entry
->hdr
= section
;
6431 entry
->next
= filedata
->symtab_shndx_list
;
6432 filedata
->symtab_shndx_list
= entry
;
6437 CHECK_ENTSIZE (section
, i
, Sym
);
6441 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6445 CHECK_ENTSIZE (section
, i
, Rel
);
6446 if (do_checks
&& section
->sh_size
== 0)
6447 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6451 CHECK_ENTSIZE (section
, i
, Rela
);
6452 if (do_checks
&& section
->sh_size
== 0)
6453 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6458 /* Having a zero sized section is not illegal according to the
6459 ELF standard, but it might be an indication that something
6460 is wrong. So issue a warning if we are running in lint mode. */
6461 if (do_checks
&& section
->sh_size
== 0)
6462 warn (_("Section '%s': has a size of zero - is this intended ?\n"), name
);
6469 if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6470 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6471 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6472 || do_debug_str
|| do_debug_str_offsets
|| do_debug_loc
|| do_debug_ranges
6473 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6474 && (const_strneq (name
, ".debug_")
6475 || const_strneq (name
, ".zdebug_")))
6478 name
+= sizeof (".zdebug_") - 1;
6480 name
+= sizeof (".debug_") - 1;
6483 || (do_debug_info
&& const_strneq (name
, "info"))
6484 || (do_debug_info
&& const_strneq (name
, "types"))
6485 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6486 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6487 || (do_debug_lines
&& const_strneq (name
, "line."))
6488 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6489 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6490 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6491 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6492 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6493 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6494 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6495 || (do_debug_frames
&& const_strneq (name
, "frame"))
6496 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6497 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6498 || (do_debug_str
&& const_strneq (name
, "str"))
6499 || (do_debug_str_offsets
&& const_strneq (name
, "str_offsets"))
6500 || (do_debug_loc
&& const_strneq (name
, "loc"))
6501 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6502 || (do_debug_addr
&& const_strneq (name
, "addr"))
6503 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6504 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6506 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6508 /* Linkonce section to be combined with .debug_info at link time. */
6509 else if ((do_debugging
|| do_debug_info
)
6510 && const_strneq (name
, ".gnu.linkonce.wi."))
6511 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6512 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6513 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6514 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6515 || streq (name
, ".debug_names")))
6516 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6517 /* Trace sections for Itanium VMS. */
6518 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6519 || do_trace_aranges
)
6520 && const_strneq (name
, ".trace_"))
6522 name
+= sizeof (".trace_") - 1;
6525 || (do_trace_info
&& streq (name
, "info"))
6526 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6527 || (do_trace_aranges
&& streq (name
, "aranges"))
6529 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6531 else if ((do_debugging
|| do_debug_links
)
6532 && (const_strneq (name
, ".gnu_debuglink")
6533 || const_strneq (name
, ".gnu_debugaltlink")))
6534 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6540 if (filedata
->file_header
.e_shnum
> 1)
6541 printf (_("\nSection Headers:\n"));
6543 printf (_("\nSection Header:\n"));
6547 if (do_section_details
)
6549 printf (_(" [Nr] Name\n"));
6550 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6554 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6558 if (do_section_details
)
6560 printf (_(" [Nr] Name\n"));
6561 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6565 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6569 if (do_section_details
)
6571 printf (_(" [Nr] Name\n"));
6572 printf (_(" Type Address Offset Link\n"));
6573 printf (_(" Size EntSize Info Align\n"));
6577 printf (_(" [Nr] Name Type Address Offset\n"));
6578 printf (_(" Size EntSize Flags Link Info Align\n"));
6582 if (do_section_details
)
6583 printf (_(" Flags\n"));
6585 for (i
= 0, section
= filedata
->section_headers
;
6586 i
< filedata
->file_header
.e_shnum
;
6589 /* Run some sanity checks on the section header. */
6591 /* Check the sh_link field. */
6592 switch (section
->sh_type
)
6596 if (section
->sh_link
== 0
6597 && (filedata
->file_header
.e_type
== ET_EXEC
6598 || filedata
->file_header
.e_type
== ET_DYN
))
6599 /* A dynamic relocation section where all entries use a
6600 zero symbol index need not specify a symtab section. */
6603 case SHT_SYMTAB_SHNDX
:
6607 case SHT_GNU_versym
:
6608 if (section
->sh_link
== 0
6609 || section
->sh_link
>= filedata
->file_header
.e_shnum
6610 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6611 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6612 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6613 i
, section
->sh_link
);
6619 case SHT_GNU_verneed
:
6620 case SHT_GNU_verdef
:
6621 case SHT_GNU_LIBLIST
:
6622 if (section
->sh_link
== 0
6623 || section
->sh_link
>= filedata
->file_header
.e_shnum
6624 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6625 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6626 i
, section
->sh_link
);
6629 case SHT_INIT_ARRAY
:
6630 case SHT_FINI_ARRAY
:
6631 case SHT_PREINIT_ARRAY
:
6632 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6633 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6634 i
, section
->sh_link
);
6638 /* FIXME: Add support for target specific section types. */
6639 #if 0 /* Currently we do not check other section types as there are too
6640 many special cases. Stab sections for example have a type
6641 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6643 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6644 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6645 i
, section
->sh_link
);
6650 /* Check the sh_info field. */
6651 switch (section
->sh_type
)
6655 if (section
->sh_info
== 0
6656 && (filedata
->file_header
.e_type
== ET_EXEC
6657 || filedata
->file_header
.e_type
== ET_DYN
))
6658 /* Dynamic relocations apply to segments, so they do not
6659 need to specify the section they relocate. */
6661 if (section
->sh_info
== 0
6662 || section
->sh_info
>= filedata
->file_header
.e_shnum
6663 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6664 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6665 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6666 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6667 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6668 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6669 /* FIXME: Are other section types valid ? */
6670 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6671 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6672 i
, section
->sh_info
);
6677 case SHT_SYMTAB_SHNDX
:
6678 case SHT_INIT_ARRAY
:
6679 case SHT_FINI_ARRAY
:
6680 case SHT_PREINIT_ARRAY
:
6681 if (section
->sh_info
!= 0)
6682 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6683 i
, section
->sh_info
);
6689 /* A symbol index - we assume that it is valid. */
6693 /* FIXME: Add support for target specific section types. */
6694 if (section
->sh_type
== SHT_NOBITS
)
6695 /* NOBITS section headers with non-zero sh_info fields can be
6696 created when a binary is stripped of everything but its debug
6697 information. The stripped sections have their headers
6698 preserved but their types set to SHT_NOBITS. So do not check
6699 this type of section. */
6701 else if (section
->sh_flags
& SHF_INFO_LINK
)
6703 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6704 warn (_("[%2u]: Expected link to another section in info field"), i
);
6706 else if (section
->sh_type
< SHT_LOOS
6707 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6708 && section
->sh_info
!= 0)
6709 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6710 i
, section
->sh_info
);
6714 /* Check the sh_size field. */
6715 if (section
->sh_size
> filedata
->file_size
6716 && section
->sh_type
!= SHT_NOBITS
6717 && section
->sh_type
!= SHT_NULL
6718 && section
->sh_type
< SHT_LOOS
)
6719 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6721 printf (" [%2u] ", i
);
6722 if (do_section_details
)
6723 printf ("%s\n ", printable_section_name (filedata
, section
));
6725 print_symbol (-17, SECTION_NAME (section
));
6727 printf (do_wide
? " %-15s " : " %-15.15s ",
6728 get_section_type_name (filedata
, section
->sh_type
));
6732 const char * link_too_big
= NULL
;
6734 print_vma (section
->sh_addr
, LONG_HEX
);
6736 printf ( " %6.6lx %6.6lx %2.2lx",
6737 (unsigned long) section
->sh_offset
,
6738 (unsigned long) section
->sh_size
,
6739 (unsigned long) section
->sh_entsize
);
6741 if (do_section_details
)
6742 fputs (" ", stdout
);
6744 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6746 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6749 /* The sh_link value is out of range. Normally this indicates
6750 an error but it can have special values in Solaris binaries. */
6751 switch (filedata
->file_header
.e_machine
)
6758 case EM_OLD_SPARCV9
:
6759 case EM_SPARC32PLUS
:
6762 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6763 link_too_big
= "BEFORE";
6764 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6765 link_too_big
= "AFTER";
6772 if (do_section_details
)
6774 if (link_too_big
!= NULL
&& * link_too_big
)
6775 printf ("<%s> ", link_too_big
);
6777 printf ("%2u ", section
->sh_link
);
6778 printf ("%3u %2lu\n", section
->sh_info
,
6779 (unsigned long) section
->sh_addralign
);
6782 printf ("%2u %3u %2lu\n",
6785 (unsigned long) section
->sh_addralign
);
6787 if (link_too_big
&& ! * link_too_big
)
6788 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6789 i
, section
->sh_link
);
6793 print_vma (section
->sh_addr
, LONG_HEX
);
6795 if ((long) section
->sh_offset
== section
->sh_offset
)
6796 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6800 print_vma (section
->sh_offset
, LONG_HEX
);
6803 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6804 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6808 print_vma (section
->sh_size
, LONG_HEX
);
6811 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6812 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6816 print_vma (section
->sh_entsize
, LONG_HEX
);
6819 if (do_section_details
)
6820 fputs (" ", stdout
);
6822 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6824 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6826 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6827 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6830 print_vma (section
->sh_addralign
, DEC
);
6834 else if (do_section_details
)
6837 print_vma (section
->sh_addr
, LONG_HEX
);
6838 if ((long) section
->sh_offset
== section
->sh_offset
)
6839 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6843 print_vma (section
->sh_offset
, LONG_HEX
);
6845 printf (" %u\n ", section
->sh_link
);
6846 print_vma (section
->sh_size
, LONG_HEX
);
6848 print_vma (section
->sh_entsize
, LONG_HEX
);
6850 printf (" %-16u %lu\n",
6852 (unsigned long) section
->sh_addralign
);
6857 print_vma (section
->sh_addr
, LONG_HEX
);
6858 if ((long) section
->sh_offset
== section
->sh_offset
)
6859 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6863 print_vma (section
->sh_offset
, LONG_HEX
);
6866 print_vma (section
->sh_size
, LONG_HEX
);
6868 print_vma (section
->sh_entsize
, LONG_HEX
);
6870 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6872 printf (" %2u %3u %lu\n",
6875 (unsigned long) section
->sh_addralign
);
6878 if (do_section_details
)
6880 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6881 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6883 /* Minimum section size is 12 bytes for 32-bit compression
6884 header + 12 bytes for compressed data header. */
6885 unsigned char buf
[24];
6887 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6888 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6889 sizeof (buf
), _("compression header")))
6891 Elf_Internal_Chdr chdr
;
6893 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
6894 printf (_(" [<corrupt>]\n"));
6897 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6900 printf (_(" [<unknown>: 0x%x], "),
6902 print_vma (chdr
.ch_size
, LONG_HEX
);
6903 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6910 if (!do_section_details
)
6912 /* The ordering of the letters shown here matches the ordering of the
6913 corresponding SHF_xxx values, and hence the order in which these
6914 letters will be displayed to the user. */
6915 printf (_("Key to Flags:\n\
6916 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6917 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6918 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6919 if (filedata
->file_header
.e_machine
== EM_X86_64
6920 || filedata
->file_header
.e_machine
== EM_L1OM
6921 || filedata
->file_header
.e_machine
== EM_K1OM
)
6922 printf (_("l (large), "));
6923 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6924 printf (_("y (purecode), "));
6925 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6926 printf (_("v (VLE), "));
6927 printf ("p (processor specific)\n");
6934 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
6935 Elf_Internal_Sym
**symtab
, unsigned long *nsyms
,
6936 char **strtab
, unsigned long *strtablen
)
6940 *symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, nsyms
);
6942 if (*symtab
== NULL
)
6945 if (symsec
->sh_link
!= 0)
6947 Elf_Internal_Shdr
*strsec
;
6949 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
6951 error (_("Bad sh_link in symbol table section\n"));
6958 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
6960 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
6961 1, strsec
->sh_size
, _("string table"));
6962 if (*strtab
== NULL
)
6969 *strtablen
= strsec
->sh_size
;
6975 get_group_flags (unsigned int flags
)
6977 static char buff
[128];
6981 else if (flags
== GRP_COMDAT
)
6984 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
6986 flags
& GRP_MASKOS
? _("<OS specific>") : "",
6987 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
6988 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
6989 ? _("<unknown>") : ""));
6995 process_section_groups (Filedata
* filedata
)
6997 Elf_Internal_Shdr
* section
;
6999 struct group
* group
;
7000 Elf_Internal_Shdr
* symtab_sec
;
7001 Elf_Internal_Shdr
* strtab_sec
;
7002 Elf_Internal_Sym
* symtab
;
7003 unsigned long num_syms
;
7007 /* Don't process section groups unless needed. */
7008 if (!do_unwind
&& !do_section_groups
)
7011 if (filedata
->file_header
.e_shnum
== 0)
7013 if (do_section_groups
)
7014 printf (_("\nThere are no sections to group in this file.\n"));
7019 if (filedata
->section_headers
== NULL
)
7021 error (_("Section headers are not available!\n"));
7022 /* PR 13622: This can happen with a corrupt ELF header. */
7026 filedata
->section_headers_groups
7027 = (struct group
**) calloc (filedata
->file_header
.e_shnum
,
7028 sizeof (struct group
*));
7030 if (filedata
->section_headers_groups
== NULL
)
7032 error (_("Out of memory reading %u section group headers\n"),
7033 filedata
->file_header
.e_shnum
);
7037 /* Scan the sections for the group section. */
7038 filedata
->group_count
= 0;
7039 for (i
= 0, section
= filedata
->section_headers
;
7040 i
< filedata
->file_header
.e_shnum
;
7042 if (section
->sh_type
== SHT_GROUP
)
7043 filedata
->group_count
++;
7045 if (filedata
->group_count
== 0)
7047 if (do_section_groups
)
7048 printf (_("\nThere are no section groups in this file.\n"));
7053 filedata
->section_groups
= (struct group
*) calloc (filedata
->group_count
,
7054 sizeof (struct group
));
7056 if (filedata
->section_groups
== NULL
)
7058 error (_("Out of memory reading %lu groups\n"),
7059 (unsigned long) filedata
->group_count
);
7069 for (i
= 0, section
= filedata
->section_headers
, group
= filedata
->section_groups
;
7070 i
< filedata
->file_header
.e_shnum
;
7073 if (section
->sh_type
== SHT_GROUP
)
7075 const char * name
= printable_section_name (filedata
, section
);
7076 const char * group_name
;
7077 unsigned char * start
;
7078 unsigned char * indices
;
7079 unsigned int entry
, j
, size
;
7080 Elf_Internal_Shdr
* sec
;
7081 Elf_Internal_Sym
* sym
;
7083 /* Get the symbol table. */
7084 if (section
->sh_link
>= filedata
->file_header
.e_shnum
7085 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
7088 error (_("Bad sh_link in group section `%s'\n"), name
);
7092 if (symtab_sec
!= sec
)
7096 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
7101 error (_("Corrupt header in group section `%s'\n"), name
);
7105 if (section
->sh_info
>= num_syms
)
7107 error (_("Bad sh_info in group section `%s'\n"), name
);
7111 sym
= symtab
+ section
->sh_info
;
7113 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
7115 if (sym
->st_shndx
== 0
7116 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
7118 error (_("Bad sh_info in group section `%s'\n"), name
);
7122 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
7130 /* Get the string table. */
7131 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
7139 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
7144 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
7145 1, strtab_sec
->sh_size
,
7147 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
7149 group_name
= sym
->st_name
< strtab_size
7150 ? strtab
+ sym
->st_name
: _("<corrupt>");
7153 /* PR 17531: file: loop. */
7154 if (section
->sh_entsize
> section
->sh_size
)
7156 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7157 printable_section_name (filedata
, section
),
7158 (unsigned long) section
->sh_entsize
,
7159 (unsigned long) section
->sh_size
);
7163 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
7164 1, section
->sh_size
,
7170 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
7171 entry
= byte_get (indices
, 4);
7174 if (do_section_groups
)
7176 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7177 get_group_flags (entry
), i
, name
, group_name
, size
);
7179 printf (_(" [Index] Name\n"));
7182 group
->group_index
= i
;
7184 for (j
= 0; j
< size
; j
++)
7186 struct group_list
* g
;
7188 entry
= byte_get (indices
, 4);
7191 if (entry
>= filedata
->file_header
.e_shnum
)
7193 static unsigned num_group_errors
= 0;
7195 if (num_group_errors
++ < 10)
7197 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7198 entry
, i
, filedata
->file_header
.e_shnum
- 1);
7199 if (num_group_errors
== 10)
7200 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7205 if (filedata
->section_headers_groups
[entry
] != NULL
)
7209 static unsigned num_errs
= 0;
7211 if (num_errs
++ < 10)
7213 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7215 filedata
->section_headers_groups
[entry
]->group_index
);
7217 warn (_("Further error messages about already contained group sections suppressed\n"));
7223 /* Intel C/C++ compiler may put section 0 in a
7224 section group. We just warn it the first time
7225 and ignore it afterwards. */
7226 static bfd_boolean warned
= FALSE
;
7229 error (_("section 0 in group section [%5u]\n"),
7230 filedata
->section_headers_groups
[entry
]->group_index
);
7236 filedata
->section_headers_groups
[entry
] = group
;
7238 if (do_section_groups
)
7240 sec
= filedata
->section_headers
+ entry
;
7241 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7244 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7245 g
->section_index
= entry
;
7246 g
->next
= group
->root
;
7261 /* Data used to display dynamic fixups. */
7263 struct ia64_vms_dynfixup
7265 bfd_vma needed_ident
; /* Library ident number. */
7266 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7267 bfd_vma fixup_needed
; /* Index of the library. */
7268 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7269 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7272 /* Data used to display dynamic relocations. */
7274 struct ia64_vms_dynimgrela
7276 bfd_vma img_rela_cnt
; /* Number of relocations. */
7277 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7280 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7284 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7285 struct ia64_vms_dynfixup
* fixup
,
7286 const char * strtab
,
7287 unsigned int strtab_sz
)
7289 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7291 const char * lib_name
;
7293 imfs
= get_data (NULL
, filedata
,
7294 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
7295 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
7296 _("dynamic section image fixups"));
7300 if (fixup
->needed
< strtab_sz
)
7301 lib_name
= strtab
+ fixup
->needed
;
7304 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7305 (unsigned long) fixup
->needed
);
7309 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7310 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7312 (_("Seg Offset Type SymVec DataType\n"));
7314 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7319 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7320 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7321 type
= BYTE_GET (imfs
[i
].type
);
7322 rtype
= elf_ia64_reloc_type (type
);
7324 printf (" 0x%08x ", type
);
7326 printf (" %-32s ", rtype
);
7327 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7328 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7335 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7338 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7340 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7343 imrs
= get_data (NULL
, filedata
,
7344 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
7345 sizeof (*imrs
), imgrela
->img_rela_cnt
,
7346 _("dynamic section image relocations"));
7350 printf (_("\nImage relocs\n"));
7352 (_("Seg Offset Type Addend Seg Sym Off\n"));
7354 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7359 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7360 printf ("%08" BFD_VMA_FMT
"x ",
7361 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7362 type
= BYTE_GET (imrs
[i
].type
);
7363 rtype
= elf_ia64_reloc_type (type
);
7365 printf ("0x%08x ", type
);
7367 printf ("%-31s ", rtype
);
7368 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7369 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7370 printf ("%08" BFD_VMA_FMT
"x\n",
7371 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7378 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7381 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7383 struct ia64_vms_dynfixup fixup
;
7384 struct ia64_vms_dynimgrela imgrela
;
7385 Elf_Internal_Dyn
*entry
;
7386 bfd_vma strtab_off
= 0;
7387 bfd_vma strtab_sz
= 0;
7388 char *strtab
= NULL
;
7389 bfd_boolean res
= TRUE
;
7391 memset (&fixup
, 0, sizeof (fixup
));
7392 memset (&imgrela
, 0, sizeof (imgrela
));
7394 /* Note: the order of the entries is specified by the OpenVMS specs. */
7395 for (entry
= filedata
->dynamic_section
;
7396 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
7399 switch (entry
->d_tag
)
7401 case DT_IA_64_VMS_STRTAB_OFFSET
:
7402 strtab_off
= entry
->d_un
.d_val
;
7405 strtab_sz
= entry
->d_un
.d_val
;
7407 strtab
= get_data (NULL
, filedata
,
7408 filedata
->dynamic_addr
+ strtab_off
,
7409 1, strtab_sz
, _("dynamic string section"));
7414 case DT_IA_64_VMS_NEEDED_IDENT
:
7415 fixup
.needed_ident
= entry
->d_un
.d_val
;
7418 fixup
.needed
= entry
->d_un
.d_val
;
7420 case DT_IA_64_VMS_FIXUP_NEEDED
:
7421 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7423 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7424 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7426 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7427 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7428 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7431 case DT_IA_64_VMS_IMG_RELA_CNT
:
7432 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7434 case DT_IA_64_VMS_IMG_RELA_OFF
:
7435 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7436 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7457 dynamic_relocations
[] =
7459 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7460 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7461 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7464 /* Process the reloc section. */
7467 process_relocs (Filedata
* filedata
)
7469 unsigned long rel_size
;
7470 unsigned long rel_offset
;
7475 if (do_using_dynamic
)
7479 bfd_boolean has_dynamic_reloc
;
7482 has_dynamic_reloc
= FALSE
;
7484 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7486 is_rela
= dynamic_relocations
[i
].rela
;
7487 name
= dynamic_relocations
[i
].name
;
7488 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
7489 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
7492 has_dynamic_reloc
= TRUE
;
7494 if (is_rela
== UNKNOWN
)
7496 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7497 switch (filedata
->dynamic_info
[DT_PLTREL
])
7511 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7512 name
, rel_offset
, rel_size
);
7514 dump_relocations (filedata
,
7515 offset_from_vma (filedata
, rel_offset
, rel_size
),
7517 filedata
->dynamic_symbols
,
7518 filedata
->num_dynamic_syms
,
7519 filedata
->dynamic_strings
,
7520 filedata
->dynamic_strings_length
,
7521 is_rela
, TRUE
/* is_dynamic */);
7525 if (is_ia64_vms (filedata
))
7526 if (process_ia64_vms_dynamic_relocs (filedata
))
7527 has_dynamic_reloc
= TRUE
;
7529 if (! has_dynamic_reloc
)
7530 printf (_("\nThere are no dynamic relocations in this file.\n"));
7534 Elf_Internal_Shdr
* section
;
7536 bfd_boolean found
= FALSE
;
7538 for (i
= 0, section
= filedata
->section_headers
;
7539 i
< filedata
->file_header
.e_shnum
;
7542 if ( section
->sh_type
!= SHT_RELA
7543 && section
->sh_type
!= SHT_REL
)
7546 rel_offset
= section
->sh_offset
;
7547 rel_size
= section
->sh_size
;
7552 unsigned long num_rela
;
7554 printf (_("\nRelocation section "));
7556 if (filedata
->string_table
== NULL
)
7557 printf ("%d", section
->sh_name
);
7559 printf ("'%s'", printable_section_name (filedata
, section
));
7561 num_rela
= rel_size
/ section
->sh_entsize
;
7562 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7563 " at offset 0x%lx contains %lu entries:\n",
7565 rel_offset
, num_rela
);
7567 is_rela
= section
->sh_type
== SHT_RELA
;
7569 if (section
->sh_link
!= 0
7570 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7572 Elf_Internal_Shdr
* symsec
;
7573 Elf_Internal_Sym
* symtab
;
7574 unsigned long nsyms
;
7575 unsigned long strtablen
= 0;
7576 char * strtab
= NULL
;
7578 symsec
= filedata
->section_headers
+ section
->sh_link
;
7579 if (symsec
->sh_type
!= SHT_SYMTAB
7580 && symsec
->sh_type
!= SHT_DYNSYM
)
7583 if (!get_symtab (filedata
, symsec
,
7584 &symtab
, &nsyms
, &strtab
, &strtablen
))
7587 dump_relocations (filedata
, rel_offset
, rel_size
,
7588 symtab
, nsyms
, strtab
, strtablen
,
7590 symsec
->sh_type
== SHT_DYNSYM
);
7595 dump_relocations (filedata
, rel_offset
, rel_size
,
7596 NULL
, 0, NULL
, 0, is_rela
,
7597 FALSE
/* is_dynamic */);
7605 /* Users sometimes forget the -D option, so try to be helpful. */
7606 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7608 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
7610 printf (_("\nThere are no static relocations in this file."));
7611 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7616 if (i
== ARRAY_SIZE (dynamic_relocations
))
7617 printf (_("\nThere are no relocations in this file.\n"));
7624 /* An absolute address consists of a section and an offset. If the
7625 section is NULL, the offset itself is the address, otherwise, the
7626 address equals to LOAD_ADDRESS(section) + offset. */
7630 unsigned short section
;
7634 /* Find the nearest symbol at or below ADDR. Returns the symbol
7635 name, if found, and the offset from the symbol to ADDR. */
7638 find_symbol_for_address (Filedata
* filedata
,
7639 Elf_Internal_Sym
* symtab
,
7640 unsigned long nsyms
,
7641 const char * strtab
,
7642 unsigned long strtab_size
,
7643 struct absaddr addr
,
7644 const char ** symname
,
7647 bfd_vma dist
= 0x100000;
7648 Elf_Internal_Sym
* sym
;
7649 Elf_Internal_Sym
* beg
;
7650 Elf_Internal_Sym
* end
;
7651 Elf_Internal_Sym
* best
= NULL
;
7653 REMOVE_ARCH_BITS (addr
.offset
);
7655 end
= symtab
+ nsyms
;
7661 sym
= beg
+ (end
- beg
) / 2;
7663 value
= sym
->st_value
;
7664 REMOVE_ARCH_BITS (value
);
7666 if (sym
->st_name
!= 0
7667 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7668 && addr
.offset
>= value
7669 && addr
.offset
- value
< dist
)
7672 dist
= addr
.offset
- value
;
7677 if (addr
.offset
< value
)
7685 *symname
= (best
->st_name
>= strtab_size
7686 ? _("<corrupt>") : strtab
+ best
->st_name
);
7692 *offset
= addr
.offset
;
7695 static /* signed */ int
7696 symcmp (const void *p
, const void *q
)
7698 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7699 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7701 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7704 /* Process the unwind section. */
7706 #include "unwind-ia64.h"
7708 struct ia64_unw_table_entry
7710 struct absaddr start
;
7712 struct absaddr info
;
7715 struct ia64_unw_aux_info
7717 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7718 unsigned long table_len
; /* Length of unwind table. */
7719 unsigned char * info
; /* Unwind info. */
7720 unsigned long info_size
; /* Size of unwind info. */
7721 bfd_vma info_addr
; /* Starting address of unwind info. */
7722 bfd_vma seg_base
; /* Starting address of segment. */
7723 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7724 unsigned long nsyms
; /* Number of symbols. */
7725 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7726 unsigned long nfuns
; /* Number of entries in funtab. */
7727 char * strtab
; /* The string table. */
7728 unsigned long strtab_size
; /* Size of string table. */
7732 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7734 struct ia64_unw_table_entry
* tp
;
7735 unsigned long j
, nfuns
;
7737 bfd_boolean res
= TRUE
;
7739 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7740 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7741 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7742 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7744 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7746 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7750 const unsigned char * dp
;
7751 const unsigned char * head
;
7752 const unsigned char * end
;
7753 const char * procname
;
7755 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7756 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7758 fputs ("\n<", stdout
);
7762 fputs (procname
, stdout
);
7765 printf ("+%lx", (unsigned long) offset
);
7768 fputs (">: [", stdout
);
7769 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7770 fputc ('-', stdout
);
7771 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7772 printf ("], info at +0x%lx\n",
7773 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7775 /* PR 17531: file: 86232b32. */
7776 if (aux
->info
== NULL
)
7779 offset
= tp
->info
.offset
;
7780 if (tp
->info
.section
)
7782 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
7784 warn (_("Invalid section %u in table entry %ld\n"),
7785 tp
->info
.section
, (long) (tp
- aux
->table
));
7789 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
7791 offset
-= aux
->info_addr
;
7792 /* PR 17531: file: 0997b4d1. */
7793 if (offset
>= aux
->info_size
7794 || aux
->info_size
- offset
< 8)
7796 warn (_("Invalid offset %lx in table entry %ld\n"),
7797 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7802 head
= aux
->info
+ offset
;
7803 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7805 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7806 (unsigned) UNW_VER (stamp
),
7807 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7808 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7809 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7810 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7812 if (UNW_VER (stamp
) != 1)
7814 printf (_("\tUnknown version.\n"));
7819 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7820 /* PR 17531: file: 16ceda89. */
7821 if (end
> aux
->info
+ aux
->info_size
)
7822 end
= aux
->info
+ aux
->info_size
;
7823 for (dp
= head
+ 8; dp
< end
;)
7824 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7833 slurp_ia64_unwind_table (Filedata
* filedata
,
7834 struct ia64_unw_aux_info
* aux
,
7835 Elf_Internal_Shdr
* sec
)
7837 unsigned long size
, nrelas
, i
;
7838 Elf_Internal_Phdr
* seg
;
7839 struct ia64_unw_table_entry
* tep
;
7840 Elf_Internal_Shdr
* relsec
;
7841 Elf_Internal_Rela
* rela
;
7842 Elf_Internal_Rela
* rp
;
7843 unsigned char * table
;
7845 Elf_Internal_Sym
* sym
;
7846 const char * relname
;
7850 /* First, find the starting address of the segment that includes
7853 if (filedata
->file_header
.e_phnum
)
7855 if (! get_program_headers (filedata
))
7858 for (seg
= filedata
->program_headers
;
7859 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7862 if (seg
->p_type
!= PT_LOAD
)
7865 if (sec
->sh_addr
>= seg
->p_vaddr
7866 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7868 aux
->seg_base
= seg
->p_vaddr
;
7874 /* Second, build the unwind table from the contents of the unwind section: */
7875 size
= sec
->sh_size
;
7876 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7881 aux
->table_len
= size
/ (3 * eh_addr_size
);
7882 aux
->table
= (struct ia64_unw_table_entry
*)
7883 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7886 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7888 tep
->start
.section
= SHN_UNDEF
;
7889 tep
->end
.section
= SHN_UNDEF
;
7890 tep
->info
.section
= SHN_UNDEF
;
7891 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7892 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7893 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7894 tep
->start
.offset
+= aux
->seg_base
;
7895 tep
->end
.offset
+= aux
->seg_base
;
7896 tep
->info
.offset
+= aux
->seg_base
;
7900 /* Third, apply any relocations to the unwind table: */
7901 for (relsec
= filedata
->section_headers
;
7902 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7905 if (relsec
->sh_type
!= SHT_RELA
7906 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7907 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7910 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7919 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7921 unsigned int sym_ndx
;
7922 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7923 relname
= elf_ia64_reloc_type (r_type
);
7925 /* PR 17531: file: 9fa67536. */
7926 if (relname
== NULL
)
7928 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
7932 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7934 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7938 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7940 /* PR 17531: file: 5bc8d9bf. */
7941 if (i
>= aux
->table_len
)
7943 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7947 sym_ndx
= get_reloc_symindex (rp
->r_info
);
7948 if (sym_ndx
>= aux
->nsyms
)
7950 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7954 sym
= aux
->symtab
+ sym_ndx
;
7956 switch (rp
->r_offset
/ eh_addr_size
% 3)
7959 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7960 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7963 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7964 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7967 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7968 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7982 ia64_process_unwind (Filedata
* filedata
)
7984 Elf_Internal_Shdr
* sec
;
7985 Elf_Internal_Shdr
* unwsec
= NULL
;
7986 unsigned long i
, unwcount
= 0, unwstart
= 0;
7987 struct ia64_unw_aux_info aux
;
7988 bfd_boolean res
= TRUE
;
7990 memset (& aux
, 0, sizeof (aux
));
7992 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7994 if (sec
->sh_type
== SHT_SYMTAB
)
7998 error (_("Multiple symbol tables encountered\n"));
8004 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8005 &aux
.strtab
, &aux
.strtab_size
))
8008 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8013 printf (_("\nThere are no unwind sections in this file.\n"));
8015 while (unwcount
-- > 0)
8020 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
8021 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8022 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8027 /* We have already counted the number of SHT_IA64_UNWIND
8028 sections so the loop above should never fail. */
8029 assert (unwsec
!= NULL
);
8032 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
8034 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
8036 /* We need to find which section group it is in. */
8037 struct group_list
* g
;
8039 if (filedata
->section_headers_groups
== NULL
8040 || filedata
->section_headers_groups
[i
] == NULL
)
8041 i
= filedata
->file_header
.e_shnum
;
8044 g
= filedata
->section_headers_groups
[i
]->root
;
8046 for (; g
!= NULL
; g
= g
->next
)
8048 sec
= filedata
->section_headers
+ g
->section_index
;
8050 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
8055 i
= filedata
->file_header
.e_shnum
;
8058 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
8060 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
8061 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
8062 suffix
= SECTION_NAME (unwsec
) + len
;
8063 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
8065 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
8066 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8071 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
8072 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
8073 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
8074 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
8076 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
8077 suffix
= SECTION_NAME (unwsec
) + len
;
8078 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
8080 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
8081 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8085 if (i
== filedata
->file_header
.e_shnum
)
8087 printf (_("\nCould not find unwind info section for "));
8089 if (filedata
->string_table
== NULL
)
8090 printf ("%d", unwsec
->sh_name
);
8092 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8096 aux
.info_addr
= sec
->sh_addr
;
8097 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
8100 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
8102 printf (_("\nUnwind section "));
8104 if (filedata
->string_table
== NULL
)
8105 printf ("%d", unwsec
->sh_name
);
8107 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8109 printf (_(" at offset 0x%lx contains %lu entries:\n"),
8110 (unsigned long) unwsec
->sh_offset
,
8111 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
8113 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
8114 && aux
.table_len
> 0)
8115 dump_ia64_unwind (filedata
, & aux
);
8117 free ((char *) aux
.table
);
8118 free ((char *) aux
.info
);
8125 free ((char *) aux
.strtab
);
8130 struct hppa_unw_table_entry
8132 struct absaddr start
;
8134 unsigned int Cannot_unwind
:1; /* 0 */
8135 unsigned int Millicode
:1; /* 1 */
8136 unsigned int Millicode_save_sr0
:1; /* 2 */
8137 unsigned int Region_description
:2; /* 3..4 */
8138 unsigned int reserved1
:1; /* 5 */
8139 unsigned int Entry_SR
:1; /* 6 */
8140 unsigned int Entry_FR
:4; /* Number saved 7..10 */
8141 unsigned int Entry_GR
:5; /* Number saved 11..15 */
8142 unsigned int Args_stored
:1; /* 16 */
8143 unsigned int Variable_Frame
:1; /* 17 */
8144 unsigned int Separate_Package_Body
:1; /* 18 */
8145 unsigned int Frame_Extension_Millicode
:1; /* 19 */
8146 unsigned int Stack_Overflow_Check
:1; /* 20 */
8147 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
8148 unsigned int Ada_Region
:1; /* 22 */
8149 unsigned int cxx_info
:1; /* 23 */
8150 unsigned int cxx_try_catch
:1; /* 24 */
8151 unsigned int sched_entry_seq
:1; /* 25 */
8152 unsigned int reserved2
:1; /* 26 */
8153 unsigned int Save_SP
:1; /* 27 */
8154 unsigned int Save_RP
:1; /* 28 */
8155 unsigned int Save_MRP_in_frame
:1; /* 29 */
8156 unsigned int extn_ptr_defined
:1; /* 30 */
8157 unsigned int Cleanup_defined
:1; /* 31 */
8159 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
8160 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
8161 unsigned int Large_frame
:1; /* 2 */
8162 unsigned int Pseudo_SP_Set
:1; /* 3 */
8163 unsigned int reserved4
:1; /* 4 */
8164 unsigned int Total_frame_size
:27; /* 5..31 */
8167 struct hppa_unw_aux_info
8169 struct hppa_unw_table_entry
* table
; /* Unwind table. */
8170 unsigned long table_len
; /* Length of unwind table. */
8171 bfd_vma seg_base
; /* Starting address of segment. */
8172 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8173 unsigned long nsyms
; /* Number of symbols. */
8174 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8175 unsigned long nfuns
; /* Number of entries in funtab. */
8176 char * strtab
; /* The string table. */
8177 unsigned long strtab_size
; /* Size of string table. */
8181 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8183 struct hppa_unw_table_entry
* tp
;
8184 unsigned long j
, nfuns
;
8185 bfd_boolean res
= TRUE
;
8187 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8188 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8189 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8190 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8192 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8194 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8197 const char * procname
;
8199 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8200 aux
->strtab_size
, tp
->start
, &procname
,
8203 fputs ("\n<", stdout
);
8207 fputs (procname
, stdout
);
8210 printf ("+%lx", (unsigned long) offset
);
8213 fputs (">: [", stdout
);
8214 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8215 fputc ('-', stdout
);
8216 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8219 #define PF(_m) if (tp->_m) printf (#_m " ");
8220 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8223 PF(Millicode_save_sr0
);
8224 /* PV(Region_description); */
8230 PF(Separate_Package_Body
);
8231 PF(Frame_Extension_Millicode
);
8232 PF(Stack_Overflow_Check
);
8233 PF(Two_Instruction_SP_Increment
);
8237 PF(sched_entry_seq
);
8240 PF(Save_MRP_in_frame
);
8241 PF(extn_ptr_defined
);
8242 PF(Cleanup_defined
);
8243 PF(MPE_XL_interrupt_marker
);
8244 PF(HP_UX_interrupt_marker
);
8247 PV(Total_frame_size
);
8260 slurp_hppa_unwind_table (Filedata
* filedata
,
8261 struct hppa_unw_aux_info
* aux
,
8262 Elf_Internal_Shdr
* sec
)
8264 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8265 Elf_Internal_Phdr
* seg
;
8266 struct hppa_unw_table_entry
* tep
;
8267 Elf_Internal_Shdr
* relsec
;
8268 Elf_Internal_Rela
* rela
;
8269 Elf_Internal_Rela
* rp
;
8270 unsigned char * table
;
8272 Elf_Internal_Sym
* sym
;
8273 const char * relname
;
8275 /* First, find the starting address of the segment that includes
8277 if (filedata
->file_header
.e_phnum
)
8279 if (! get_program_headers (filedata
))
8282 for (seg
= filedata
->program_headers
;
8283 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8286 if (seg
->p_type
!= PT_LOAD
)
8289 if (sec
->sh_addr
>= seg
->p_vaddr
8290 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8292 aux
->seg_base
= seg
->p_vaddr
;
8298 /* Second, build the unwind table from the contents of the unwind
8300 size
= sec
->sh_size
;
8301 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8307 nentries
= size
/ unw_ent_size
;
8308 size
= unw_ent_size
* nentries
;
8310 aux
->table_len
= nentries
;
8311 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8312 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8314 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8316 unsigned int tmp1
, tmp2
;
8318 tep
->start
.section
= SHN_UNDEF
;
8319 tep
->end
.section
= SHN_UNDEF
;
8321 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8322 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8323 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8324 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8326 tep
->start
.offset
+= aux
->seg_base
;
8327 tep
->end
.offset
+= aux
->seg_base
;
8329 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8330 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8331 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8332 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8333 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8334 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8335 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8336 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8337 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8338 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8339 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8340 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8341 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8342 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8343 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8344 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8345 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8346 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8347 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8348 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8349 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8350 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8351 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8352 tep
->Cleanup_defined
= tmp1
& 0x1;
8354 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8355 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8356 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8357 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8358 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8359 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8363 /* Third, apply any relocations to the unwind table. */
8364 for (relsec
= filedata
->section_headers
;
8365 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8368 if (relsec
->sh_type
!= SHT_RELA
8369 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8370 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8373 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8377 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8379 unsigned int sym_ndx
;
8380 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8381 relname
= elf_hppa_reloc_type (r_type
);
8383 if (relname
== NULL
)
8385 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8389 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8390 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8392 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8396 i
= rp
->r_offset
/ unw_ent_size
;
8397 if (i
>= aux
->table_len
)
8399 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8403 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8404 if (sym_ndx
>= aux
->nsyms
)
8406 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8410 sym
= aux
->symtab
+ sym_ndx
;
8412 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8415 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8416 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8419 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8420 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8434 hppa_process_unwind (Filedata
* filedata
)
8436 struct hppa_unw_aux_info aux
;
8437 Elf_Internal_Shdr
* unwsec
= NULL
;
8438 Elf_Internal_Shdr
* sec
;
8440 bfd_boolean res
= TRUE
;
8442 if (filedata
->string_table
== NULL
)
8445 memset (& aux
, 0, sizeof (aux
));
8447 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8449 if (sec
->sh_type
== SHT_SYMTAB
)
8453 error (_("Multiple symbol tables encountered\n"));
8459 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8460 &aux
.strtab
, &aux
.strtab_size
))
8463 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8468 printf (_("\nThere are no unwind sections in this file.\n"));
8470 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8472 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8474 unsigned long num_unwind
= sec
->sh_size
/ 16;
8476 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8477 "contains %lu entry:\n",
8478 "\nUnwind section '%s' at offset 0x%lx "
8479 "contains %lu entries:\n",
8481 printable_section_name (filedata
, sec
),
8482 (unsigned long) sec
->sh_offset
,
8485 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8488 if (res
&& aux
.table_len
> 0)
8490 if (! dump_hppa_unwind (filedata
, &aux
))
8494 free ((char *) aux
.table
);
8500 free ((char *) aux
.strtab
);
8507 unsigned char * data
; /* The unwind data. */
8508 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8509 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8510 unsigned long nrelas
; /* The number of relocations. */
8511 unsigned int rel_type
; /* REL or RELA ? */
8512 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8515 struct arm_unw_aux_info
8517 Filedata
* filedata
; /* The file containing the unwind sections. */
8518 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8519 unsigned long nsyms
; /* Number of symbols. */
8520 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8521 unsigned long nfuns
; /* Number of these symbols. */
8522 char * strtab
; /* The file's string table. */
8523 unsigned long strtab_size
; /* Size of string table. */
8527 arm_print_vma_and_name (Filedata
* filedata
,
8528 struct arm_unw_aux_info
* aux
,
8530 struct absaddr addr
)
8532 const char *procname
;
8535 if (addr
.section
== SHN_UNDEF
)
8538 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8539 aux
->strtab_size
, addr
, &procname
,
8542 print_vma (fn
, PREFIX_HEX
);
8546 fputs (" <", stdout
);
8547 fputs (procname
, stdout
);
8550 printf ("+0x%lx", (unsigned long) sym_offset
);
8551 fputc ('>', stdout
);
8558 arm_free_section (struct arm_section
*arm_sec
)
8560 free (arm_sec
->data
);
8561 free (arm_sec
->rela
);
8564 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8565 cached section and install SEC instead.
8566 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8567 and return its valued in * WORDP, relocating if necessary.
8568 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8569 relocation's offset in ADDR.
8570 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8571 into the string table of the symbol associated with the reloc. If no
8572 reloc was applied store -1 there.
8573 5) Return TRUE upon success, FALSE otherwise. */
8576 get_unwind_section_word (Filedata
* filedata
,
8577 struct arm_unw_aux_info
* aux
,
8578 struct arm_section
* arm_sec
,
8579 Elf_Internal_Shdr
* sec
,
8580 bfd_vma word_offset
,
8581 unsigned int * wordp
,
8582 struct absaddr
* addr
,
8585 Elf_Internal_Rela
*rp
;
8586 Elf_Internal_Sym
*sym
;
8587 const char * relname
;
8589 bfd_boolean wrapped
;
8591 if (sec
== NULL
|| arm_sec
== NULL
)
8594 addr
->section
= SHN_UNDEF
;
8597 if (sym_name
!= NULL
)
8598 *sym_name
= (bfd_vma
) -1;
8600 /* If necessary, update the section cache. */
8601 if (sec
!= arm_sec
->sec
)
8603 Elf_Internal_Shdr
*relsec
;
8605 arm_free_section (arm_sec
);
8608 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8609 sec
->sh_size
, _("unwind data"));
8610 arm_sec
->rela
= NULL
;
8611 arm_sec
->nrelas
= 0;
8613 for (relsec
= filedata
->section_headers
;
8614 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8617 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8618 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8619 /* PR 15745: Check the section type as well. */
8620 || (relsec
->sh_type
!= SHT_REL
8621 && relsec
->sh_type
!= SHT_RELA
))
8624 arm_sec
->rel_type
= relsec
->sh_type
;
8625 if (relsec
->sh_type
== SHT_REL
)
8627 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8629 & arm_sec
->rela
, & arm_sec
->nrelas
))
8632 else /* relsec->sh_type == SHT_RELA */
8634 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8636 & arm_sec
->rela
, & arm_sec
->nrelas
))
8642 arm_sec
->next_rela
= arm_sec
->rela
;
8645 /* If there is no unwind data we can do nothing. */
8646 if (arm_sec
->data
== NULL
)
8649 /* If the offset is invalid then fail. */
8650 if (/* PR 21343 *//* PR 18879 */
8652 || word_offset
> (sec
->sh_size
- 4)
8653 || ((bfd_signed_vma
) word_offset
) < 0)
8656 /* Get the word at the required offset. */
8657 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8659 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8660 if (arm_sec
->rela
== NULL
)
8666 /* Look through the relocs to find the one that applies to the provided offset. */
8668 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8670 bfd_vma prelval
, offset
;
8672 if (rp
->r_offset
> word_offset
&& !wrapped
)
8677 if (rp
->r_offset
> word_offset
)
8680 if (rp
->r_offset
& 3)
8682 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8683 (unsigned long) rp
->r_offset
);
8687 if (rp
->r_offset
< word_offset
)
8690 /* PR 17531: file: 027-161405-0.004 */
8691 if (aux
->symtab
== NULL
)
8694 if (arm_sec
->rel_type
== SHT_REL
)
8696 offset
= word
& 0x7fffffff;
8697 if (offset
& 0x40000000)
8698 offset
|= ~ (bfd_vma
) 0x7fffffff;
8700 else if (arm_sec
->rel_type
== SHT_RELA
)
8701 offset
= rp
->r_addend
;
8704 error (_("Unknown section relocation type %d encountered\n"),
8709 /* PR 17531 file: 027-1241568-0.004. */
8710 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8712 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8713 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8717 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8718 offset
+= sym
->st_value
;
8719 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8721 /* Check that we are processing the expected reloc type. */
8722 if (filedata
->file_header
.e_machine
== EM_ARM
)
8724 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8725 if (relname
== NULL
)
8727 warn (_("Skipping unknown ARM relocation type: %d\n"),
8728 (int) ELF32_R_TYPE (rp
->r_info
));
8732 if (streq (relname
, "R_ARM_NONE"))
8735 if (! streq (relname
, "R_ARM_PREL31"))
8737 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8741 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8743 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8744 if (relname
== NULL
)
8746 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8747 (int) ELF32_R_TYPE (rp
->r_info
));
8751 if (streq (relname
, "R_C6000_NONE"))
8754 if (! streq (relname
, "R_C6000_PREL31"))
8756 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8764 /* This function currently only supports ARM and TI unwinders. */
8765 warn (_("Only TI and ARM unwinders are currently supported\n"));
8769 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8770 addr
->section
= sym
->st_shndx
;
8771 addr
->offset
= offset
;
8774 * sym_name
= sym
->st_name
;
8779 arm_sec
->next_rela
= rp
;
8784 static const char *tic6x_unwind_regnames
[16] =
8786 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8787 "A14", "A13", "A12", "A11", "A10",
8788 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8792 decode_tic6x_unwind_regmask (unsigned int mask
)
8796 for (i
= 12; mask
; mask
>>= 1, i
--)
8800 fputs (tic6x_unwind_regnames
[i
], stdout
);
8802 fputs (", ", stdout
);
8808 if (remaining == 0 && more_words) \
8811 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8812 data_offset, & word, & addr, NULL)) \
8818 #define GET_OP(OP) \
8823 (OP) = word >> 24; \
8828 printf (_("[Truncated opcode]\n")); \
8831 printf ("0x%02x ", OP)
8834 decode_arm_unwind_bytecode (Filedata
* filedata
,
8835 struct arm_unw_aux_info
* aux
,
8837 unsigned int remaining
,
8838 unsigned int more_words
,
8839 bfd_vma data_offset
,
8840 Elf_Internal_Shdr
* data_sec
,
8841 struct arm_section
* data_arm_sec
)
8843 struct absaddr addr
;
8844 bfd_boolean res
= TRUE
;
8846 /* Decode the unwinding instructions. */
8849 unsigned int op
, op2
;
8858 printf (" 0x%02x ", op
);
8860 if ((op
& 0xc0) == 0x00)
8862 int offset
= ((op
& 0x3f) << 2) + 4;
8864 printf (" vsp = vsp + %d", offset
);
8866 else if ((op
& 0xc0) == 0x40)
8868 int offset
= ((op
& 0x3f) << 2) + 4;
8870 printf (" vsp = vsp - %d", offset
);
8872 else if ((op
& 0xf0) == 0x80)
8875 if (op
== 0x80 && op2
== 0)
8876 printf (_("Refuse to unwind"));
8879 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8880 bfd_boolean first
= TRUE
;
8884 for (i
= 0; i
< 12; i
++)
8885 if (mask
& (1 << i
))
8891 printf ("r%d", 4 + i
);
8896 else if ((op
& 0xf0) == 0x90)
8898 if (op
== 0x9d || op
== 0x9f)
8899 printf (_(" [Reserved]"));
8901 printf (" vsp = r%d", op
& 0x0f);
8903 else if ((op
& 0xf0) == 0xa0)
8905 int end
= 4 + (op
& 0x07);
8906 bfd_boolean first
= TRUE
;
8910 for (i
= 4; i
<= end
; i
++)
8926 else if (op
== 0xb0)
8927 printf (_(" finish"));
8928 else if (op
== 0xb1)
8931 if (op2
== 0 || (op2
& 0xf0) != 0)
8932 printf (_("[Spare]"));
8935 unsigned int mask
= op2
& 0x0f;
8936 bfd_boolean first
= TRUE
;
8940 for (i
= 0; i
< 12; i
++)
8941 if (mask
& (1 << i
))
8952 else if (op
== 0xb2)
8954 unsigned char buf
[9];
8955 unsigned int i
, len
;
8956 unsigned long offset
;
8958 for (i
= 0; i
< sizeof (buf
); i
++)
8961 if ((buf
[i
] & 0x80) == 0)
8964 if (i
== sizeof (buf
))
8966 error (_("corrupt change to vsp\n"));
8971 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
8972 assert (len
== i
+ 1);
8973 offset
= offset
* 4 + 0x204;
8974 printf ("vsp = vsp + %ld", offset
);
8977 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8979 unsigned int first
, last
;
8986 printf ("pop {D%d", first
);
8988 printf ("-D%d", first
+ last
);
8991 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8993 unsigned int count
= op
& 0x07;
8997 printf ("-D%d", 8 + count
);
9000 else if (op
>= 0xc0 && op
<= 0xc5)
9002 unsigned int count
= op
& 0x07;
9004 printf (" pop {wR10");
9006 printf ("-wR%d", 10 + count
);
9009 else if (op
== 0xc6)
9011 unsigned int first
, last
;
9016 printf ("pop {wR%d", first
);
9018 printf ("-wR%d", first
+ last
);
9021 else if (op
== 0xc7)
9024 if (op2
== 0 || (op2
& 0xf0) != 0)
9025 printf (_("[Spare]"));
9028 unsigned int mask
= op2
& 0x0f;
9029 bfd_boolean first
= TRUE
;
9033 for (i
= 0; i
< 4; i
++)
9034 if (mask
& (1 << i
))
9040 printf ("wCGR%d", i
);
9047 printf (_(" [unsupported opcode]"));
9058 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
9059 struct arm_unw_aux_info
* aux
,
9061 unsigned int remaining
,
9062 unsigned int more_words
,
9063 bfd_vma data_offset
,
9064 Elf_Internal_Shdr
* data_sec
,
9065 struct arm_section
* data_arm_sec
)
9067 struct absaddr addr
;
9069 /* Decode the unwinding instructions. */
9072 unsigned int op
, op2
;
9081 printf (" 0x%02x ", op
);
9083 if ((op
& 0xc0) == 0x00)
9085 int offset
= ((op
& 0x3f) << 3) + 8;
9086 printf (" sp = sp + %d", offset
);
9088 else if ((op
& 0xc0) == 0x80)
9091 if (op
== 0x80 && op2
== 0)
9092 printf (_("Refuse to unwind"));
9095 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
9097 printf ("pop compact {");
9101 decode_tic6x_unwind_regmask (mask
);
9105 else if ((op
& 0xf0) == 0xc0)
9113 unsigned int offset
;
9117 /* Scan entire instruction first so that GET_OP output is not
9118 interleaved with disassembly. */
9120 for (i
= 0; nregs
< (op
& 0xf); i
++)
9126 regpos
[nregs
].offset
= i
* 2;
9127 regpos
[nregs
].reg
= reg
;
9134 regpos
[nregs
].offset
= i
* 2 + 1;
9135 regpos
[nregs
].reg
= reg
;
9140 printf (_("pop frame {"));
9143 printf (_("*corrupt* - no registers specified"));
9148 for (i
= i
* 2; i
> 0; i
--)
9150 if (regpos
[reg
].offset
== i
- 1)
9152 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
9159 fputs (name
, stdout
);
9167 else if (op
== 0xd0)
9168 printf (" MOV FP, SP");
9169 else if (op
== 0xd1)
9170 printf (" __c6xabi_pop_rts");
9171 else if (op
== 0xd2)
9173 unsigned char buf
[9];
9174 unsigned int i
, len
;
9175 unsigned long offset
;
9177 for (i
= 0; i
< sizeof (buf
); i
++)
9180 if ((buf
[i
] & 0x80) == 0)
9183 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9184 if (i
== sizeof (buf
))
9186 warn (_("Corrupt stack pointer adjustment detected\n"));
9190 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
9191 assert (len
== i
+ 1);
9192 offset
= offset
* 8 + 0x408;
9193 printf (_("sp = sp + %ld"), offset
);
9195 else if ((op
& 0xf0) == 0xe0)
9197 if ((op
& 0x0f) == 7)
9200 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9204 printf (_(" [unsupported opcode]"));
9213 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9217 offset
= word
& 0x7fffffff;
9218 if (offset
& 0x40000000)
9219 offset
|= ~ (bfd_vma
) 0x7fffffff;
9221 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9224 return offset
+ where
;
9228 decode_arm_unwind (Filedata
* filedata
,
9229 struct arm_unw_aux_info
* aux
,
9231 unsigned int remaining
,
9232 bfd_vma data_offset
,
9233 Elf_Internal_Shdr
* data_sec
,
9234 struct arm_section
* data_arm_sec
)
9237 unsigned int more_words
= 0;
9238 struct absaddr addr
;
9239 bfd_vma sym_name
= (bfd_vma
) -1;
9240 bfd_boolean res
= TRUE
;
9244 /* Fetch the first word.
9245 Note - when decoding an object file the address extracted
9246 here will always be 0. So we also pass in the sym_name
9247 parameter so that we can find the symbol associated with
9248 the personality routine. */
9249 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9250 & word
, & addr
, & sym_name
))
9257 addr
.section
= SHN_UNDEF
;
9261 if ((word
& 0x80000000) == 0)
9263 /* Expand prel31 for personality routine. */
9265 const char *procname
;
9267 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9268 printf (_(" Personality routine: "));
9270 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9271 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9273 procname
= aux
->strtab
+ sym_name
;
9274 print_vma (fn
, PREFIX_HEX
);
9277 fputs (" <", stdout
);
9278 fputs (procname
, stdout
);
9279 fputc ('>', stdout
);
9283 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9284 fputc ('\n', stdout
);
9286 /* The GCC personality routines use the standard compact
9287 encoding, starting with one byte giving the number of
9289 if (procname
!= NULL
9290 && (const_strneq (procname
, "__gcc_personality_v0")
9291 || const_strneq (procname
, "__gxx_personality_v0")
9292 || const_strneq (procname
, "__gcj_personality_v0")
9293 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9300 printf (_(" [Truncated data]\n"));
9303 more_words
= word
>> 24;
9313 /* ARM EHABI Section 6.3:
9315 An exception-handling table entry for the compact model looks like:
9319 1 0 index Data for personalityRoutine[index] */
9321 if (filedata
->file_header
.e_machine
== EM_ARM
9322 && (word
& 0x70000000))
9324 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9328 per_index
= (word
>> 24) & 0x7f;
9329 printf (_(" Compact model index: %d\n"), per_index
);
9336 else if (per_index
< 3)
9338 more_words
= (word
>> 16) & 0xff;
9344 switch (filedata
->file_header
.e_machine
)
9349 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9350 data_offset
, data_sec
, data_arm_sec
))
9355 warn (_("Unknown ARM compact model index encountered\n"));
9356 printf (_(" [reserved]\n"));
9364 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9365 data_offset
, data_sec
, data_arm_sec
))
9368 else if (per_index
< 5)
9370 if (((word
>> 17) & 0x7f) == 0x7f)
9371 printf (_(" Restore stack from frame pointer\n"));
9373 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9374 printf (_(" Registers restored: "));
9376 printf (" (compact) ");
9377 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9379 printf (_(" Return register: %s\n"),
9380 tic6x_unwind_regnames
[word
& 0xf]);
9383 printf (_(" [reserved (%d)]\n"), per_index
);
9387 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9388 filedata
->file_header
.e_machine
);
9392 /* Decode the descriptors. Not implemented. */
9398 dump_arm_unwind (Filedata
* filedata
,
9399 struct arm_unw_aux_info
* aux
,
9400 Elf_Internal_Shdr
* exidx_sec
)
9402 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9403 unsigned int i
, exidx_len
;
9404 unsigned long j
, nfuns
;
9405 bfd_boolean res
= TRUE
;
9407 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9408 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9409 exidx_len
= exidx_sec
->sh_size
/ 8;
9411 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9412 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9413 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9414 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9416 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9418 for (i
= 0; i
< exidx_len
; i
++)
9420 unsigned int exidx_fn
, exidx_entry
;
9421 struct absaddr fn_addr
, entry_addr
;
9424 fputc ('\n', stdout
);
9426 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9427 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9428 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9429 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9432 arm_free_section (& exidx_arm_sec
);
9433 arm_free_section (& extab_arm_sec
);
9437 /* ARM EHABI, Section 5:
9438 An index table entry consists of 2 words.
9439 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9440 if (exidx_fn
& 0x80000000)
9442 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9446 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9448 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9449 fputs (": ", stdout
);
9451 if (exidx_entry
== 1)
9453 print_vma (exidx_entry
, PREFIX_HEX
);
9454 fputs (" [cantunwind]\n", stdout
);
9456 else if (exidx_entry
& 0x80000000)
9458 print_vma (exidx_entry
, PREFIX_HEX
);
9459 fputc ('\n', stdout
);
9460 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9464 bfd_vma table
, table_offset
= 0;
9465 Elf_Internal_Shdr
*table_sec
;
9467 fputs ("@", stdout
);
9468 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9469 print_vma (table
, PREFIX_HEX
);
9472 /* Locate the matching .ARM.extab. */
9473 if (entry_addr
.section
!= SHN_UNDEF
9474 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9476 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9477 table_offset
= entry_addr
.offset
;
9479 if (table_offset
> table_sec
->sh_size
9480 || ((bfd_signed_vma
) table_offset
) < 0)
9482 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9483 (unsigned long) table_offset
,
9484 printable_section_name (filedata
, table_sec
));
9491 table_sec
= find_section_by_address (filedata
, table
);
9492 if (table_sec
!= NULL
)
9493 table_offset
= table
- table_sec
->sh_addr
;
9496 if (table_sec
== NULL
)
9498 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9499 (unsigned long) table
);
9504 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9513 arm_free_section (&exidx_arm_sec
);
9514 arm_free_section (&extab_arm_sec
);
9519 /* Used for both ARM and C6X unwinding tables. */
9522 arm_process_unwind (Filedata
* filedata
)
9524 struct arm_unw_aux_info aux
;
9525 Elf_Internal_Shdr
*unwsec
= NULL
;
9526 Elf_Internal_Shdr
*sec
;
9528 unsigned int sec_type
;
9529 bfd_boolean res
= TRUE
;
9531 switch (filedata
->file_header
.e_machine
)
9534 sec_type
= SHT_ARM_EXIDX
;
9538 sec_type
= SHT_C6000_UNWIND
;
9542 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9543 filedata
->file_header
.e_machine
);
9547 if (filedata
->string_table
== NULL
)
9550 memset (& aux
, 0, sizeof (aux
));
9551 aux
.filedata
= filedata
;
9553 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9555 if (sec
->sh_type
== SHT_SYMTAB
)
9559 error (_("Multiple symbol tables encountered\n"));
9565 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9566 &aux
.strtab
, &aux
.strtab_size
))
9569 else if (sec
->sh_type
== sec_type
)
9574 printf (_("\nThere are no unwind sections in this file.\n"));
9576 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9578 if (sec
->sh_type
== sec_type
)
9580 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9581 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9582 "contains %lu entry:\n",
9583 "\nUnwind section '%s' at offset 0x%lx "
9584 "contains %lu entries:\n",
9586 printable_section_name (filedata
, sec
),
9587 (unsigned long) sec
->sh_offset
,
9590 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9596 free ((char *) aux
.strtab
);
9602 process_unwind (Filedata
* filedata
)
9604 struct unwind_handler
9606 unsigned int machtype
;
9607 bfd_boolean (* handler
)(Filedata
*);
9610 { EM_ARM
, arm_process_unwind
},
9611 { EM_IA_64
, ia64_process_unwind
},
9612 { EM_PARISC
, hppa_process_unwind
},
9613 { EM_TI_C6000
, arm_process_unwind
},
9621 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9622 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9623 return handlers
[i
].handler (filedata
);
9625 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9626 get_machine_name (filedata
->file_header
.e_machine
));
9631 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9633 switch (entry
->d_tag
)
9635 case DT_AARCH64_BTI_PLT
:
9636 case DT_AARCH64_PAC_PLT
:
9639 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9646 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
9648 switch (entry
->d_tag
)
9651 if (entry
->d_un
.d_val
== 0)
9655 static const char * opts
[] =
9657 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9658 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9659 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9660 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9664 bfd_boolean first
= TRUE
;
9666 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9667 if (entry
->d_un
.d_val
& (1 << cnt
))
9669 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9675 case DT_MIPS_IVERSION
:
9676 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
9677 printf (_("Interface Version: %s"),
9678 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
9682 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9683 /* Note: coded this way so that there is a single string for translation. */
9684 printf (_("<corrupt: %s>"), buf
);
9688 case DT_MIPS_TIME_STAMP
:
9692 time_t atime
= entry
->d_un
.d_val
;
9694 tmp
= gmtime (&atime
);
9695 /* PR 17531: file: 6accc532. */
9697 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9699 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9700 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9701 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9702 printf (_("Time Stamp: %s"), timebuf
);
9706 case DT_MIPS_RLD_VERSION
:
9707 case DT_MIPS_LOCAL_GOTNO
:
9708 case DT_MIPS_CONFLICTNO
:
9709 case DT_MIPS_LIBLISTNO
:
9710 case DT_MIPS_SYMTABNO
:
9711 case DT_MIPS_UNREFEXTNO
:
9712 case DT_MIPS_HIPAGENO
:
9713 case DT_MIPS_DELTA_CLASS_NO
:
9714 case DT_MIPS_DELTA_INSTANCE_NO
:
9715 case DT_MIPS_DELTA_RELOC_NO
:
9716 case DT_MIPS_DELTA_SYM_NO
:
9717 case DT_MIPS_DELTA_CLASSSYM_NO
:
9718 case DT_MIPS_COMPACT_SIZE
:
9719 print_vma (entry
->d_un
.d_val
, DEC
);
9723 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
9724 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9725 /* Falls through. */
9728 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9734 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9736 switch (entry
->d_tag
)
9738 case DT_HP_DLD_FLAGS
:
9747 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9748 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9749 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9750 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9751 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9752 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9753 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9754 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9755 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9756 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9757 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9758 { DT_HP_GST
, "HP_GST" },
9759 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9760 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9761 { DT_HP_NODELETE
, "HP_NODELETE" },
9762 { DT_HP_GROUP
, "HP_GROUP" },
9763 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9765 bfd_boolean first
= TRUE
;
9767 bfd_vma val
= entry
->d_un
.d_val
;
9769 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9770 if (val
& flags
[cnt
].bit
)
9774 fputs (flags
[cnt
].str
, stdout
);
9776 val
^= flags
[cnt
].bit
;
9779 if (val
!= 0 || first
)
9783 print_vma (val
, HEX
);
9789 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9797 /* VMS vs Unix time offset and factor. */
9799 #define VMS_EPOCH_OFFSET 35067168000000000LL
9800 #define VMS_GRANULARITY_FACTOR 10000000
9802 /* Display a VMS time in a human readable format. */
9805 print_vms_time (bfd_int64_t vmstime
)
9810 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9811 tm
= gmtime (&unxtime
);
9812 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9813 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9814 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9819 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9821 switch (entry
->d_tag
)
9823 case DT_IA_64_PLT_RESERVE
:
9824 /* First 3 slots reserved. */
9825 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9827 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9830 case DT_IA_64_VMS_LINKTIME
:
9832 print_vms_time (entry
->d_un
.d_val
);
9836 case DT_IA_64_VMS_LNKFLAGS
:
9837 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9838 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9839 printf (" CALL_DEBUG");
9840 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9841 printf (" NOP0BUFS");
9842 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9843 printf (" P0IMAGE");
9844 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9845 printf (" MKTHREADS");
9846 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9847 printf (" UPCALLS");
9848 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9850 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9851 printf (" INITIALIZE");
9852 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9854 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9855 printf (" EXE_INIT");
9856 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9857 printf (" TBK_IN_IMG");
9858 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9859 printf (" DBG_IN_IMG");
9860 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9861 printf (" TBK_IN_DSF");
9862 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9863 printf (" DBG_IN_DSF");
9864 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9865 printf (" SIGNATURES");
9866 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9867 printf (" REL_SEG_OFF");
9871 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9878 get_32bit_dynamic_section (Filedata
* filedata
)
9880 Elf32_External_Dyn
* edyn
;
9881 Elf32_External_Dyn
* ext
;
9882 Elf_Internal_Dyn
* entry
;
9884 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
9885 filedata
->dynamic_addr
, 1,
9886 filedata
->dynamic_size
,
9887 _("dynamic section"));
9891 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9892 might not have the luxury of section headers. Look for the DT_NULL
9893 terminator to determine the number of entries. */
9894 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
9895 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
9898 filedata
->dynamic_nent
++;
9899 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9903 filedata
->dynamic_section
9904 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
9905 if (filedata
->dynamic_section
== NULL
)
9907 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9908 (unsigned long) filedata
->dynamic_nent
);
9913 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
9914 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
9917 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9918 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9927 get_64bit_dynamic_section (Filedata
* filedata
)
9929 Elf64_External_Dyn
* edyn
;
9930 Elf64_External_Dyn
* ext
;
9931 Elf_Internal_Dyn
* entry
;
9933 /* Read in the data. */
9934 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
9935 filedata
->dynamic_addr
, 1,
9936 filedata
->dynamic_size
,
9937 _("dynamic section"));
9941 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9942 might not have the luxury of section headers. Look for the DT_NULL
9943 terminator to determine the number of entries. */
9944 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
9945 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9946 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
9949 filedata
->dynamic_nent
++;
9950 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9954 filedata
->dynamic_section
9955 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
9956 if (filedata
->dynamic_section
== NULL
)
9958 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9959 (unsigned long) filedata
->dynamic_nent
);
9964 /* Convert from external to internal formats. */
9965 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
9966 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
9969 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9970 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9979 print_dynamic_flags (bfd_vma flags
)
9981 bfd_boolean first
= TRUE
;
9987 flag
= flags
& - flags
;
9997 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9998 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9999 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
10000 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
10001 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
10002 default: fputs (_("unknown"), stdout
); break;
10009 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
10011 unsigned char * e_data
;
10014 /* If the size_t type is smaller than the bfd_size_type, eg because
10015 you are building a 32-bit tool on a 64-bit host, then make sure
10016 that when (number) is cast to (size_t) no information is lost. */
10017 if (sizeof (size_t) < sizeof (bfd_size_type
)
10018 && (bfd_size_type
) ((size_t) number
) != number
)
10020 error (_("Size truncation prevents reading %s elements of size %u\n"),
10021 bfd_vmatoa ("u", number
), ent_size
);
10025 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
10026 attempting to allocate memory when the read is bound to fail. */
10027 if (ent_size
* number
> filedata
->file_size
)
10029 error (_("Invalid number of dynamic entries: %s\n"),
10030 bfd_vmatoa ("u", number
));
10034 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10035 if (e_data
== NULL
)
10037 error (_("Out of memory reading %s dynamic entries\n"),
10038 bfd_vmatoa ("u", number
));
10042 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
10044 error (_("Unable to read in %s bytes of dynamic data\n"),
10045 bfd_vmatoa ("u", number
* ent_size
));
10050 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10051 if (i_data
== NULL
)
10053 error (_("Out of memory allocating space for %s dynamic entries\n"),
10054 bfd_vmatoa ("u", number
));
10060 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10067 static unsigned long
10068 get_num_dynamic_syms (Filedata
* filedata
)
10070 unsigned long num_of_syms
= 0;
10072 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
10073 return num_of_syms
;
10075 if (filedata
->dynamic_info
[DT_HASH
])
10077 unsigned char nb
[8];
10078 unsigned char nc
[8];
10079 unsigned int hash_ent_size
= 4;
10081 if ((filedata
->file_header
.e_machine
== EM_ALPHA
10082 || filedata
->file_header
.e_machine
== EM_S390
10083 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
10084 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10087 if (fseek (filedata
->handle
,
10088 (filedata
->archive_file_offset
10089 + offset_from_vma (filedata
, filedata
->dynamic_info
[DT_HASH
],
10090 sizeof nb
+ sizeof nc
)),
10093 error (_("Unable to seek to start of dynamic information\n"));
10097 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
10099 error (_("Failed to read in number of buckets\n"));
10103 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
10105 error (_("Failed to read in number of chains\n"));
10109 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
10110 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
10112 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
10114 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
10116 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
10119 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
10120 num_of_syms
= filedata
->nchains
;
10123 if (num_of_syms
== 0)
10125 free (filedata
->buckets
);
10126 filedata
->buckets
= NULL
;
10127 free (filedata
->chains
);
10128 filedata
->chains
= NULL
;
10129 filedata
->nbuckets
= 0;
10133 if (filedata
->dynamic_info_DT_GNU_HASH
)
10135 unsigned char nb
[16];
10136 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10137 bfd_vma buckets_vma
;
10140 if (fseek (filedata
->handle
,
10141 (filedata
->archive_file_offset
10142 + offset_from_vma (filedata
,
10143 filedata
->dynamic_info_DT_GNU_HASH
,
10147 error (_("Unable to seek to start of dynamic information\n"));
10151 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
10153 error (_("Failed to read in number of buckets\n"));
10157 filedata
->ngnubuckets
= byte_get (nb
, 4);
10158 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
10159 bitmaskwords
= byte_get (nb
+ 8, 4);
10160 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
10162 buckets_vma
+= bitmaskwords
* 4;
10164 buckets_vma
+= bitmaskwords
* 8;
10166 if (fseek (filedata
->handle
,
10167 (filedata
->archive_file_offset
10168 + offset_from_vma (filedata
, buckets_vma
, 4)),
10171 error (_("Unable to seek to start of dynamic information\n"));
10175 filedata
->gnubuckets
10176 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
10178 if (filedata
->gnubuckets
== NULL
)
10181 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
10182 if (filedata
->gnubuckets
[i
] != 0)
10184 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
10187 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
10188 maxchain
= filedata
->gnubuckets
[i
];
10191 if (maxchain
== 0xffffffff)
10194 maxchain
-= filedata
->gnusymidx
;
10196 if (fseek (filedata
->handle
,
10197 (filedata
->archive_file_offset
10198 + offset_from_vma (filedata
,
10199 buckets_vma
+ 4 * (filedata
->ngnubuckets
10204 error (_("Unable to seek to start of dynamic information\n"));
10210 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
10212 error (_("Failed to determine last chain length\n"));
10216 if (maxchain
+ 1 == 0)
10221 while ((byte_get (nb
, 4) & 1) == 0);
10223 if (fseek (filedata
->handle
,
10224 (filedata
->archive_file_offset
10225 + offset_from_vma (filedata
, (buckets_vma
10226 + 4 * filedata
->ngnubuckets
),
10230 error (_("Unable to seek to start of dynamic information\n"));
10234 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
10235 filedata
->ngnuchains
= maxchain
;
10237 if (filedata
->gnuchains
== NULL
)
10240 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10242 if (fseek (filedata
->handle
,
10243 (filedata
->archive_file_offset
10244 + offset_from_vma (filedata
, (buckets_vma
10245 + 4 * (filedata
->ngnubuckets
10249 error (_("Unable to seek to start of dynamic information\n"));
10253 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
10254 if (filedata
->mipsxlat
== NULL
)
10258 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
10259 if (filedata
->gnubuckets
[hn
] != 0)
10261 bfd_vma si
= filedata
->gnubuckets
[hn
];
10262 bfd_vma off
= si
- filedata
->gnusymidx
;
10266 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10268 if (off
< filedata
->ngnuchains
10269 && filedata
->mipsxlat
[off
] >= num_of_syms
)
10270 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
10274 if (si
>= num_of_syms
)
10275 num_of_syms
= si
+ 1;
10279 while (off
< filedata
->ngnuchains
10280 && (filedata
->gnuchains
[off
++] & 1) == 0);
10283 if (num_of_syms
== 0)
10286 free (filedata
->mipsxlat
);
10287 filedata
->mipsxlat
= NULL
;
10288 free (filedata
->gnuchains
);
10289 filedata
->gnuchains
= NULL
;
10290 free (filedata
->gnubuckets
);
10291 filedata
->gnubuckets
= NULL
;
10292 filedata
->ngnubuckets
= 0;
10293 filedata
->ngnuchains
= 0;
10297 return num_of_syms
;
10300 /* Parse and display the contents of the dynamic section. */
10303 process_dynamic_section (Filedata
* filedata
)
10305 Elf_Internal_Dyn
* entry
;
10307 if (filedata
->dynamic_size
== 0)
10310 printf (_("\nThere is no dynamic section in this file.\n"));
10317 if (! get_32bit_dynamic_section (filedata
))
10322 if (! get_64bit_dynamic_section (filedata
))
10326 /* Find the appropriate symbol table. */
10327 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
10329 unsigned long num_of_syms
;
10331 for (entry
= filedata
->dynamic_section
;
10332 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10334 if (entry
->d_tag
== DT_SYMTAB
)
10335 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
10336 else if (entry
->d_tag
== DT_SYMENT
)
10337 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
10338 else if (entry
->d_tag
== DT_HASH
)
10339 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
10340 else if (entry
->d_tag
== DT_GNU_HASH
)
10341 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10342 else if ((filedata
->file_header
.e_machine
== EM_MIPS
10343 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
10344 && entry
->d_tag
== DT_MIPS_XHASH
)
10346 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10347 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10350 num_of_syms
= get_num_dynamic_syms (filedata
);
10352 if (num_of_syms
!= 0
10353 && filedata
->dynamic_symbols
== NULL
10354 && filedata
->dynamic_info
[DT_SYMTAB
]
10355 && filedata
->dynamic_info
[DT_SYMENT
])
10357 Elf_Internal_Phdr
*seg
;
10358 bfd_vma vma
= filedata
->dynamic_info
[DT_SYMTAB
];
10360 if (! get_program_headers (filedata
))
10362 error (_("Cannot interpret virtual addresses "
10363 "without program headers.\n"));
10367 for (seg
= filedata
->program_headers
;
10368 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
10371 if (seg
->p_type
!= PT_LOAD
)
10374 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
10376 /* See PR 21379 for a reproducer. */
10377 error (_("Invalid PT_LOAD entry\n"));
10381 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
10382 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
10384 /* Since we do not know how big the symbol table is,
10385 we default to reading in up to the end of PT_LOAD
10386 segment and processing that. This is overkill, I
10387 know, but it should work. */
10388 Elf_Internal_Shdr section
;
10389 section
.sh_offset
= (vma
- seg
->p_vaddr
10391 section
.sh_size
= (num_of_syms
10392 * filedata
->dynamic_info
[DT_SYMENT
]);
10393 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
10396 && filedata
->dynamic_symtab_section
!= NULL
10397 && ((filedata
->dynamic_symtab_section
->sh_offset
10398 != section
.sh_offset
)
10399 || (filedata
->dynamic_symtab_section
->sh_size
10400 != section
.sh_size
)
10401 || (filedata
->dynamic_symtab_section
->sh_entsize
10402 != section
.sh_entsize
)))
10404 the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
10406 section
.sh_name
= filedata
->string_table_length
;
10407 filedata
->dynamic_symbols
10408 = GET_ELF_SYMBOLS (filedata
, §ion
,
10409 &filedata
->num_dynamic_syms
);
10410 if (filedata
->dynamic_symbols
== NULL
10411 || filedata
->num_dynamic_syms
!= num_of_syms
)
10413 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
10422 /* Similarly find a string table. */
10423 if (filedata
->dynamic_strings
== NULL
)
10424 for (entry
= filedata
->dynamic_section
;
10425 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10428 if (entry
->d_tag
== DT_STRTAB
)
10429 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
10431 if (entry
->d_tag
== DT_STRSZ
)
10432 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
10434 if (filedata
->dynamic_info
[DT_STRTAB
]
10435 && filedata
->dynamic_info
[DT_STRSZ
])
10437 unsigned long offset
;
10438 bfd_size_type str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
10440 offset
= offset_from_vma (filedata
,
10441 filedata
->dynamic_info
[DT_STRTAB
],
10444 && filedata
->dynamic_strtab_section
10445 && ((filedata
->dynamic_strtab_section
->sh_offset
10446 != (file_ptr
) offset
)
10447 || (filedata
->dynamic_strtab_section
->sh_size
10450 the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
10452 filedata
->dynamic_strings
10453 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
10454 _("dynamic string table"));
10455 if (filedata
->dynamic_strings
== NULL
)
10457 error (_("Corrupt DT_STRTAB dynamic entry\n"));
10461 filedata
->dynamic_strings_length
= str_tab_len
;
10466 /* And find the syminfo section if available. */
10467 if (filedata
->dynamic_syminfo
== NULL
)
10469 unsigned long syminsz
= 0;
10471 for (entry
= filedata
->dynamic_section
;
10472 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10475 if (entry
->d_tag
== DT_SYMINENT
)
10477 /* Note: these braces are necessary to avoid a syntax
10478 error from the SunOS4 C compiler. */
10479 /* PR binutils/17531: A corrupt file can trigger this test.
10480 So do not use an assert, instead generate an error message. */
10481 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
10482 error (_("Bad value (%d) for SYMINENT entry\n"),
10483 (int) entry
->d_un
.d_val
);
10485 else if (entry
->d_tag
== DT_SYMINSZ
)
10486 syminsz
= entry
->d_un
.d_val
;
10487 else if (entry
->d_tag
== DT_SYMINFO
)
10488 filedata
->dynamic_syminfo_offset
10489 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
10492 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
10494 Elf_External_Syminfo
* extsyminfo
;
10495 Elf_External_Syminfo
* extsym
;
10496 Elf_Internal_Syminfo
* syminfo
;
10498 /* There is a syminfo section. Read the data. */
10499 extsyminfo
= (Elf_External_Syminfo
*)
10500 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
10501 1, syminsz
, _("symbol information"));
10505 if (filedata
->dynamic_syminfo
!= NULL
)
10507 error (_("Multiple dynamic symbol information sections found\n"));
10508 free (filedata
->dynamic_syminfo
);
10510 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10511 if (filedata
->dynamic_syminfo
== NULL
)
10513 error (_("Out of memory allocating %lu bytes "
10514 "for dynamic symbol info\n"),
10515 (unsigned long) syminsz
);
10519 filedata
->dynamic_syminfo_nent
10520 = syminsz
/ sizeof (Elf_External_Syminfo
);
10521 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
10522 syminfo
< (filedata
->dynamic_syminfo
10523 + filedata
->dynamic_syminfo_nent
);
10524 ++syminfo
, ++extsym
)
10526 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10527 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10534 if (do_dynamic
&& filedata
->dynamic_addr
)
10535 printf (ngettext ("\nDynamic section at offset 0x%lx "
10536 "contains %lu entry:\n",
10537 "\nDynamic section at offset 0x%lx "
10538 "contains %lu entries:\n",
10539 filedata
->dynamic_nent
),
10540 filedata
->dynamic_addr
, (unsigned long) filedata
->dynamic_nent
);
10542 printf (_(" Tag Type Name/Value\n"));
10544 for (entry
= filedata
->dynamic_section
;
10545 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10550 const char * dtype
;
10553 print_vma (entry
->d_tag
, FULL_HEX
);
10554 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10555 printf (" (%s)%*s", dtype
,
10556 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10559 switch (entry
->d_tag
)
10563 print_dynamic_flags (entry
->d_un
.d_val
);
10573 switch (entry
->d_tag
)
10576 printf (_("Auxiliary library"));
10580 printf (_("Filter library"));
10584 printf (_("Configuration file"));
10588 printf (_("Dependency audit library"));
10592 printf (_("Audit library"));
10596 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10597 printf (": [%s]\n",
10598 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
10602 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10611 printf (_("Flags:"));
10613 if (entry
->d_un
.d_val
== 0)
10614 printf (_(" None\n"));
10617 unsigned long int val
= entry
->d_un
.d_val
;
10619 if (val
& DTF_1_PARINIT
)
10621 printf (" PARINIT");
10622 val
^= DTF_1_PARINIT
;
10624 if (val
& DTF_1_CONFEXP
)
10626 printf (" CONFEXP");
10627 val
^= DTF_1_CONFEXP
;
10630 printf (" %lx", val
);
10639 printf (_("Flags:"));
10641 if (entry
->d_un
.d_val
== 0)
10642 printf (_(" None\n"));
10645 unsigned long int val
= entry
->d_un
.d_val
;
10647 if (val
& DF_P1_LAZYLOAD
)
10649 printf (" LAZYLOAD");
10650 val
^= DF_P1_LAZYLOAD
;
10652 if (val
& DF_P1_GROUPPERM
)
10654 printf (" GROUPPERM");
10655 val
^= DF_P1_GROUPPERM
;
10658 printf (" %lx", val
);
10667 printf (_("Flags:"));
10668 if (entry
->d_un
.d_val
== 0)
10669 printf (_(" None\n"));
10672 unsigned long int val
= entry
->d_un
.d_val
;
10674 if (val
& DF_1_NOW
)
10679 if (val
& DF_1_GLOBAL
)
10681 printf (" GLOBAL");
10682 val
^= DF_1_GLOBAL
;
10684 if (val
& DF_1_GROUP
)
10689 if (val
& DF_1_NODELETE
)
10691 printf (" NODELETE");
10692 val
^= DF_1_NODELETE
;
10694 if (val
& DF_1_LOADFLTR
)
10696 printf (" LOADFLTR");
10697 val
^= DF_1_LOADFLTR
;
10699 if (val
& DF_1_INITFIRST
)
10701 printf (" INITFIRST");
10702 val
^= DF_1_INITFIRST
;
10704 if (val
& DF_1_NOOPEN
)
10706 printf (" NOOPEN");
10707 val
^= DF_1_NOOPEN
;
10709 if (val
& DF_1_ORIGIN
)
10711 printf (" ORIGIN");
10712 val
^= DF_1_ORIGIN
;
10714 if (val
& DF_1_DIRECT
)
10716 printf (" DIRECT");
10717 val
^= DF_1_DIRECT
;
10719 if (val
& DF_1_TRANS
)
10724 if (val
& DF_1_INTERPOSE
)
10726 printf (" INTERPOSE");
10727 val
^= DF_1_INTERPOSE
;
10729 if (val
& DF_1_NODEFLIB
)
10731 printf (" NODEFLIB");
10732 val
^= DF_1_NODEFLIB
;
10734 if (val
& DF_1_NODUMP
)
10736 printf (" NODUMP");
10737 val
^= DF_1_NODUMP
;
10739 if (val
& DF_1_CONFALT
)
10741 printf (" CONFALT");
10742 val
^= DF_1_CONFALT
;
10744 if (val
& DF_1_ENDFILTEE
)
10746 printf (" ENDFILTEE");
10747 val
^= DF_1_ENDFILTEE
;
10749 if (val
& DF_1_DISPRELDNE
)
10751 printf (" DISPRELDNE");
10752 val
^= DF_1_DISPRELDNE
;
10754 if (val
& DF_1_DISPRELPND
)
10756 printf (" DISPRELPND");
10757 val
^= DF_1_DISPRELPND
;
10759 if (val
& DF_1_NODIRECT
)
10761 printf (" NODIRECT");
10762 val
^= DF_1_NODIRECT
;
10764 if (val
& DF_1_IGNMULDEF
)
10766 printf (" IGNMULDEF");
10767 val
^= DF_1_IGNMULDEF
;
10769 if (val
& DF_1_NOKSYMS
)
10771 printf (" NOKSYMS");
10772 val
^= DF_1_NOKSYMS
;
10774 if (val
& DF_1_NOHDR
)
10779 if (val
& DF_1_EDITED
)
10781 printf (" EDITED");
10782 val
^= DF_1_EDITED
;
10784 if (val
& DF_1_NORELOC
)
10786 printf (" NORELOC");
10787 val
^= DF_1_NORELOC
;
10789 if (val
& DF_1_SYMINTPOSE
)
10791 printf (" SYMINTPOSE");
10792 val
^= DF_1_SYMINTPOSE
;
10794 if (val
& DF_1_GLOBAUDIT
)
10796 printf (" GLOBAUDIT");
10797 val
^= DF_1_GLOBAUDIT
;
10799 if (val
& DF_1_SINGLETON
)
10801 printf (" SINGLETON");
10802 val
^= DF_1_SINGLETON
;
10804 if (val
& DF_1_STUB
)
10809 if (val
& DF_1_PIE
)
10814 if (val
& DF_1_KMOD
)
10819 if (val
& DF_1_WEAKFILTER
)
10821 printf (" WEAKFILTER");
10822 val
^= DF_1_WEAKFILTER
;
10824 if (val
& DF_1_NOCOMMON
)
10826 printf (" NOCOMMON");
10827 val
^= DF_1_NOCOMMON
;
10830 printf (" %lx", val
);
10837 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10839 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10859 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10865 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10866 name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
10872 switch (entry
->d_tag
)
10875 printf (_("Shared library: [%s]"), name
);
10877 if (streq (name
, filedata
->program_interpreter
))
10878 printf (_(" program interpreter"));
10882 printf (_("Library soname: [%s]"), name
);
10886 printf (_("Library rpath: [%s]"), name
);
10890 printf (_("Library runpath: [%s]"), name
);
10894 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10899 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10912 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10913 /* Fall through. */
10917 case DT_INIT_ARRAYSZ
:
10918 case DT_FINI_ARRAYSZ
:
10919 case DT_GNU_CONFLICTSZ
:
10920 case DT_GNU_LIBLISTSZ
:
10923 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10924 printf (_(" (bytes)\n"));
10929 case DT_VERNEEDNUM
:
10934 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10943 case DT_INIT_ARRAY
:
10944 case DT_FINI_ARRAY
:
10947 if (entry
->d_tag
== DT_USED
10948 && VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10950 char * name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
10954 printf (_("Not needed object: [%s]\n"), name
);
10959 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10965 /* The value of this entry is ignored. */
10970 case DT_GNU_PRELINKED
:
10974 time_t atime
= entry
->d_un
.d_val
;
10976 tmp
= gmtime (&atime
);
10977 /* PR 17533 file: 041-1244816-0.004. */
10979 printf (_("<corrupt time val: %lx"),
10980 (unsigned long) atime
);
10982 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10983 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10984 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10990 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10993 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10999 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
11000 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
11001 = entry
->d_un
.d_val
;
11005 switch (filedata
->file_header
.e_machine
)
11008 dynamic_section_aarch64_val (entry
);
11011 case EM_MIPS_RS3_LE
:
11012 dynamic_section_mips_val (filedata
, entry
);
11015 dynamic_section_parisc_val (entry
);
11018 dynamic_section_ia64_val (entry
);
11021 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11033 get_ver_flags (unsigned int flags
)
11035 static char buff
[128];
11042 if (flags
& VER_FLG_BASE
)
11043 strcat (buff
, "BASE");
11045 if (flags
& VER_FLG_WEAK
)
11047 if (flags
& VER_FLG_BASE
)
11048 strcat (buff
, " | ");
11050 strcat (buff
, "WEAK");
11053 if (flags
& VER_FLG_INFO
)
11055 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
11056 strcat (buff
, " | ");
11058 strcat (buff
, "INFO");
11061 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11063 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11064 strcat (buff
, " | ");
11066 strcat (buff
, _("<unknown>"));
11072 /* Display the contents of the version sections. */
11075 process_version_sections (Filedata
* filedata
)
11077 Elf_Internal_Shdr
* section
;
11079 bfd_boolean found
= FALSE
;
11084 for (i
= 0, section
= filedata
->section_headers
;
11085 i
< filedata
->file_header
.e_shnum
;
11088 switch (section
->sh_type
)
11090 case SHT_GNU_verdef
:
11092 Elf_External_Verdef
* edefs
;
11099 printf (ngettext ("\nVersion definition section '%s' "
11100 "contains %u entry:\n",
11101 "\nVersion definition section '%s' "
11102 "contains %u entries:\n",
11104 printable_section_name (filedata
, section
),
11107 printf (_(" Addr: 0x"));
11108 printf_vma (section
->sh_addr
);
11109 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11110 (unsigned long) section
->sh_offset
, section
->sh_link
,
11111 printable_section_name_from_index (filedata
, section
->sh_link
));
11113 edefs
= (Elf_External_Verdef
*)
11114 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
11115 _("version definition section"));
11118 endbuf
= (char *) edefs
+ section
->sh_size
;
11120 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11123 Elf_External_Verdef
* edef
;
11124 Elf_Internal_Verdef ent
;
11125 Elf_External_Verdaux
* eaux
;
11126 Elf_Internal_Verdaux aux
;
11127 unsigned long isum
;
11130 vstart
= ((char *) edefs
) + idx
;
11131 if (vstart
+ sizeof (*edef
) > endbuf
)
11134 edef
= (Elf_External_Verdef
*) vstart
;
11136 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
11137 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
11138 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
11139 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
11140 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
11141 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
11142 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
11144 printf (_(" %#06lx: Rev: %d Flags: %s"),
11145 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
11147 printf (_(" Index: %d Cnt: %d "),
11148 ent
.vd_ndx
, ent
.vd_cnt
);
11150 /* Check for overflow. */
11151 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
11154 vstart
+= ent
.vd_aux
;
11156 if (vstart
+ sizeof (*eaux
) > endbuf
)
11158 eaux
= (Elf_External_Verdaux
*) vstart
;
11160 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11161 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11163 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11164 printf (_("Name: %s\n"),
11165 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11167 printf (_("Name index: %ld\n"), aux
.vda_name
);
11169 isum
= idx
+ ent
.vd_aux
;
11171 for (j
= 1; j
< ent
.vd_cnt
; j
++)
11173 if (aux
.vda_next
< sizeof (*eaux
)
11174 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
11176 warn (_("Invalid vda_next field of %lx\n"),
11181 /* Check for overflow. */
11182 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
11185 isum
+= aux
.vda_next
;
11186 vstart
+= aux
.vda_next
;
11188 if (vstart
+ sizeof (*eaux
) > endbuf
)
11190 eaux
= (Elf_External_Verdaux
*) vstart
;
11192 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11193 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11195 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11196 printf (_(" %#06lx: Parent %d: %s\n"),
11198 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11200 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
11201 isum
, j
, aux
.vda_name
);
11204 if (j
< ent
.vd_cnt
)
11205 printf (_(" Version def aux past end of section\n"));
11208 file: id:000001,src:000172+005151,op:splice,rep:2. */
11209 if (ent
.vd_next
< sizeof (*edef
)
11210 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
11212 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
11213 cnt
= section
->sh_info
;
11216 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
11219 idx
+= ent
.vd_next
;
11222 if (cnt
< section
->sh_info
)
11223 printf (_(" Version definition past end of section\n"));
11229 case SHT_GNU_verneed
:
11231 Elf_External_Verneed
* eneed
;
11238 printf (ngettext ("\nVersion needs section '%s' "
11239 "contains %u entry:\n",
11240 "\nVersion needs section '%s' "
11241 "contains %u entries:\n",
11243 printable_section_name (filedata
, section
), section
->sh_info
);
11245 printf (_(" Addr: 0x"));
11246 printf_vma (section
->sh_addr
);
11247 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11248 (unsigned long) section
->sh_offset
, section
->sh_link
,
11249 printable_section_name_from_index (filedata
, section
->sh_link
));
11251 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
11252 section
->sh_offset
, 1,
11254 _("Version Needs section"));
11257 endbuf
= (char *) eneed
+ section
->sh_size
;
11259 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11261 Elf_External_Verneed
* entry
;
11262 Elf_Internal_Verneed ent
;
11263 unsigned long isum
;
11267 vstart
= ((char *) eneed
) + idx
;
11268 if (vstart
+ sizeof (*entry
) > endbuf
)
11271 entry
= (Elf_External_Verneed
*) vstart
;
11273 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
11274 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
11275 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
11276 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
11277 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
11279 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
11281 if (VALID_DYNAMIC_NAME (filedata
, ent
.vn_file
))
11282 printf (_(" File: %s"),
11283 GET_DYNAMIC_NAME (filedata
, ent
.vn_file
));
11285 printf (_(" File: %lx"), ent
.vn_file
);
11287 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
11289 /* Check for overflow. */
11290 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
11292 vstart
+= ent
.vn_aux
;
11294 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
11296 Elf_External_Vernaux
* eaux
;
11297 Elf_Internal_Vernaux aux
;
11299 if (vstart
+ sizeof (*eaux
) > endbuf
)
11301 eaux
= (Elf_External_Vernaux
*) vstart
;
11303 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
11304 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
11305 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
11306 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
11307 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
11309 if (VALID_DYNAMIC_NAME (filedata
, aux
.vna_name
))
11310 printf (_(" %#06lx: Name: %s"),
11311 isum
, GET_DYNAMIC_NAME (filedata
, aux
.vna_name
));
11313 printf (_(" %#06lx: Name index: %lx"),
11314 isum
, aux
.vna_name
);
11316 printf (_(" Flags: %s Version: %d\n"),
11317 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
11319 if (aux
.vna_next
< sizeof (*eaux
)
11320 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
11322 warn (_("Invalid vna_next field of %lx\n"),
11327 /* Check for overflow. */
11328 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
11330 isum
+= aux
.vna_next
;
11331 vstart
+= aux
.vna_next
;
11334 if (j
< ent
.vn_cnt
)
11335 warn (_("Missing Version Needs auxillary information\n"));
11337 if (ent
.vn_next
< sizeof (*entry
)
11338 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
11340 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
11341 cnt
= section
->sh_info
;
11344 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
11346 idx
+= ent
.vn_next
;
11349 if (cnt
< section
->sh_info
)
11350 warn (_("Missing Version Needs information\n"));
11356 case SHT_GNU_versym
:
11358 Elf_Internal_Shdr
* link_section
;
11361 unsigned char * edata
;
11362 unsigned short * data
;
11364 Elf_Internal_Sym
* symbols
;
11365 Elf_Internal_Shdr
* string_sec
;
11366 unsigned long num_syms
;
11369 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
11372 link_section
= filedata
->section_headers
+ section
->sh_link
;
11373 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
11375 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
11380 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
11381 if (symbols
== NULL
)
11384 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
11386 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
11387 string_sec
->sh_size
,
11388 _("version string table"));
11395 printf (ngettext ("\nVersion symbols section '%s' "
11396 "contains %lu entry:\n",
11397 "\nVersion symbols section '%s' "
11398 "contains %lu entries:\n",
11400 printable_section_name (filedata
, section
), (unsigned long) total
);
11402 printf (_(" Addr: 0x"));
11403 printf_vma (section
->sh_addr
);
11404 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11405 (unsigned long) section
->sh_offset
, section
->sh_link
,
11406 printable_section_name (filedata
, link_section
));
11408 off
= offset_from_vma (filedata
,
11409 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11410 total
* sizeof (short));
11411 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
11412 sizeof (short), total
,
11413 _("version symbol data"));
11421 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
11423 for (cnt
= total
; cnt
--;)
11424 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
11429 for (cnt
= 0; cnt
< total
; cnt
+= 4)
11433 char *invalid
= _("*invalid*");
11435 printf (" %03x:", cnt
);
11437 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
11438 switch (data
[cnt
+ j
])
11441 fputs (_(" 0 (*local*) "), stdout
);
11445 fputs (_(" 1 (*global*) "), stdout
);
11449 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
11450 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
11452 /* If this index value is greater than the size of the symbols
11453 array, break to avoid an out-of-bounds read. */
11454 if ((unsigned long)(cnt
+ j
) >= num_syms
)
11456 warn (_("invalid index into symbol array\n"));
11461 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11463 Elf_Internal_Verneed ivn
;
11464 unsigned long offset
;
11466 offset
= offset_from_vma
11468 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11469 sizeof (Elf_External_Verneed
));
11473 Elf_Internal_Vernaux ivna
;
11474 Elf_External_Verneed evn
;
11475 Elf_External_Vernaux evna
;
11476 unsigned long a_off
;
11478 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11479 _("version need")) == NULL
)
11482 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11483 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11485 a_off
= offset
+ ivn
.vn_aux
;
11489 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
11490 1, _("version need aux (2)")) == NULL
)
11493 ivna
.vna_other
= 0;
11497 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11498 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11501 a_off
+= ivna
.vna_next
;
11503 while (ivna
.vna_other
!= data
[cnt
+ j
]
11504 && ivna
.vna_next
!= 0);
11506 if (ivna
.vna_other
== data
[cnt
+ j
])
11508 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11510 if (ivna
.vna_name
>= string_sec
->sh_size
)
11513 name
= strtab
+ ivna
.vna_name
;
11517 offset
+= ivn
.vn_next
;
11519 while (ivn
.vn_next
);
11522 if (data
[cnt
+ j
] != 0x8001
11523 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11525 Elf_Internal_Verdef ivd
;
11526 Elf_External_Verdef evd
;
11527 unsigned long offset
;
11529 offset
= offset_from_vma
11531 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11536 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11537 _("version def")) == NULL
)
11540 /* PR 17531: file: 046-1082287-0.004. */
11541 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11546 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11547 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11550 offset
+= ivd
.vd_next
;
11552 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11553 && ivd
.vd_next
!= 0);
11555 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11557 Elf_External_Verdaux evda
;
11558 Elf_Internal_Verdaux ivda
;
11560 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11562 if (get_data (&evda
, filedata
,
11563 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11565 _("version def aux")) == NULL
)
11568 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11570 if (ivda
.vda_name
>= string_sec
->sh_size
)
11572 else if (name
!= NULL
&& name
!= invalid
)
11573 name
= _("*both*");
11575 name
= strtab
+ ivda
.vda_name
;
11579 nn
+= printf ("(%s%-*s",
11581 12 - (int) strlen (name
),
11585 printf ("%*c", 18 - nn
, ' ');
11603 printf (_("\nNo version information found in this file.\n"));
11608 static const char *
11609 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11611 static char buff
[64];
11615 case STB_LOCAL
: return "LOCAL";
11616 case STB_GLOBAL
: return "GLOBAL";
11617 case STB_WEAK
: return "WEAK";
11619 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11620 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11622 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11624 if (binding
== STB_GNU_UNIQUE
11625 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11627 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11630 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11635 static const char *
11636 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11638 static char buff
[64];
11642 case STT_NOTYPE
: return "NOTYPE";
11643 case STT_OBJECT
: return "OBJECT";
11644 case STT_FUNC
: return "FUNC";
11645 case STT_SECTION
: return "SECTION";
11646 case STT_FILE
: return "FILE";
11647 case STT_COMMON
: return "COMMON";
11648 case STT_TLS
: return "TLS";
11649 case STT_RELC
: return "RELC";
11650 case STT_SRELC
: return "SRELC";
11652 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11654 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11655 return "THUMB_FUNC";
11657 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11660 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11661 return "PARISC_MILLI";
11663 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11665 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11667 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11669 if (type
== STT_HP_OPAQUE
)
11670 return "HP_OPAQUE";
11671 if (type
== STT_HP_STUB
)
11675 if (type
== STT_GNU_IFUNC
11676 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11677 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
11680 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11683 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11688 static const char *
11689 get_symbol_visibility (unsigned int visibility
)
11691 switch (visibility
)
11693 case STV_DEFAULT
: return "DEFAULT";
11694 case STV_INTERNAL
: return "INTERNAL";
11695 case STV_HIDDEN
: return "HIDDEN";
11696 case STV_PROTECTED
: return "PROTECTED";
11698 error (_("Unrecognized visibility value: %u\n"), visibility
);
11699 return _("<unknown>");
11703 static const char *
11704 get_alpha_symbol_other (unsigned int other
)
11708 case STO_ALPHA_NOPV
: return "NOPV";
11709 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
11711 error (_("Unrecognized alpha specific other value: %u\n"), other
);
11712 return _("<unknown>");
11716 static const char *
11717 get_solaris_symbol_visibility (unsigned int visibility
)
11719 switch (visibility
)
11721 case 4: return "EXPORTED";
11722 case 5: return "SINGLETON";
11723 case 6: return "ELIMINATE";
11724 default: return get_symbol_visibility (visibility
);
11728 static const char *
11729 get_aarch64_symbol_other (unsigned int other
)
11731 static char buf
[32];
11733 if (other
& STO_AARCH64_VARIANT_PCS
)
11735 other
&= ~STO_AARCH64_VARIANT_PCS
;
11737 return "VARIANT_PCS";
11738 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
11744 static const char *
11745 get_mips_symbol_other (unsigned int other
)
11749 case STO_OPTIONAL
: return "OPTIONAL";
11750 case STO_MIPS_PLT
: return "MIPS PLT";
11751 case STO_MIPS_PIC
: return "MIPS PIC";
11752 case STO_MICROMIPS
: return "MICROMIPS";
11753 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11754 case STO_MIPS16
: return "MIPS16";
11755 default: return NULL
;
11759 static const char *
11760 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11762 if (is_ia64_vms (filedata
))
11764 static char res
[32];
11768 /* Function types is for images and .STB files only. */
11769 switch (filedata
->file_header
.e_type
)
11773 switch (VMS_ST_FUNC_TYPE (other
))
11775 case VMS_SFT_CODE_ADDR
:
11776 strcat (res
, " CA");
11778 case VMS_SFT_SYMV_IDX
:
11779 strcat (res
, " VEC");
11782 strcat (res
, " FD");
11784 case VMS_SFT_RESERVE
:
11785 strcat (res
, " RSV");
11788 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11789 VMS_ST_FUNC_TYPE (other
));
11790 strcat (res
, " <unknown>");
11797 switch (VMS_ST_LINKAGE (other
))
11799 case VMS_STL_IGNORE
:
11800 strcat (res
, " IGN");
11802 case VMS_STL_RESERVE
:
11803 strcat (res
, " RSV");
11806 strcat (res
, " STD");
11809 strcat (res
, " LNK");
11812 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11813 VMS_ST_LINKAGE (other
));
11814 strcat (res
, " <unknown>");
11826 static const char *
11827 get_ppc64_symbol_other (unsigned int other
)
11829 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11832 other
>>= STO_PPC64_LOCAL_BIT
;
11835 static char buf
[64];
11837 other
= ppc64_decode_local_entry (other
);
11838 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11844 static const char *
11845 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11847 const char * result
= NULL
;
11848 static char buff
[64];
11853 switch (filedata
->file_header
.e_machine
)
11856 result
= get_alpha_symbol_other (other
);
11859 result
= get_aarch64_symbol_other (other
);
11862 result
= get_mips_symbol_other (other
);
11865 result
= get_ia64_symbol_other (filedata
, other
);
11868 result
= get_ppc64_symbol_other (other
);
11878 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11882 static const char *
11883 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11885 static char buff
[32];
11889 case SHN_UNDEF
: return "UND";
11890 case SHN_ABS
: return "ABS";
11891 case SHN_COMMON
: return "COM";
11893 if (type
== SHN_IA_64_ANSI_COMMON
11894 && filedata
->file_header
.e_machine
== EM_IA_64
11895 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11897 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11898 || filedata
->file_header
.e_machine
== EM_L1OM
11899 || filedata
->file_header
.e_machine
== EM_K1OM
)
11900 && type
== SHN_X86_64_LCOMMON
)
11901 return "LARGE_COM";
11902 else if ((type
== SHN_MIPS_SCOMMON
11903 && filedata
->file_header
.e_machine
== EM_MIPS
)
11904 || (type
== SHN_TIC6X_SCOMMON
11905 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11907 else if (type
== SHN_MIPS_SUNDEFINED
11908 && filedata
->file_header
.e_machine
== EM_MIPS
)
11910 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11911 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11912 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11913 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11914 else if (type
>= SHN_LORESERVE
)
11915 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11916 else if (filedata
->file_header
.e_shnum
!= 0
11917 && type
>= filedata
->file_header
.e_shnum
)
11918 sprintf (buff
, _("bad section index[%3d]"), type
);
11920 sprintf (buff
, "%3d", type
);
11927 static const char *
11928 get_symbol_version_string (Filedata
* filedata
,
11929 bfd_boolean is_dynsym
,
11930 const char * strtab
,
11931 unsigned long int strtab_size
,
11933 Elf_Internal_Sym
* psym
,
11934 enum versioned_symbol_info
* sym_info
,
11935 unsigned short * vna_other
)
11937 unsigned char data
[2];
11938 unsigned short vers_data
;
11939 unsigned long offset
;
11940 unsigned short max_vd_ndx
;
11943 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11946 offset
= offset_from_vma (filedata
,
11947 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11948 sizeof data
+ si
* sizeof (vers_data
));
11950 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11951 sizeof (data
), 1, _("version data")) == NULL
)
11954 vers_data
= byte_get (data
, 2);
11956 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11959 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
11962 /* Usually we'd only see verdef for defined symbols, and verneed for
11963 undefined symbols. However, symbols defined by the linker in
11964 .dynbss for variables copied from a shared library in order to
11965 avoid text relocations are defined yet have verneed. We could
11966 use a heuristic to detect the special case, for example, check
11967 for verneed first on symbols defined in SHT_NOBITS sections, but
11968 it is simpler and more reliable to just look for both verdef and
11969 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11971 if (psym
->st_shndx
!= SHN_UNDEF
11972 && vers_data
!= 0x8001
11973 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11975 Elf_Internal_Verdef ivd
;
11976 Elf_Internal_Verdaux ivda
;
11977 Elf_External_Verdaux evda
;
11980 off
= offset_from_vma (filedata
,
11981 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11982 sizeof (Elf_External_Verdef
));
11986 Elf_External_Verdef evd
;
11988 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11989 _("version def")) == NULL
)
11998 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11999 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
12000 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
12001 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
12004 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
12005 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
12007 off
+= ivd
.vd_next
;
12009 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
12011 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
12013 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
12016 off
-= ivd
.vd_next
;
12019 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
12020 _("version def aux")) != NULL
)
12022 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
12024 if (psym
->st_name
!= ivda
.vda_name
)
12025 return (ivda
.vda_name
< strtab_size
12026 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
12031 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
12033 Elf_External_Verneed evn
;
12034 Elf_Internal_Verneed ivn
;
12035 Elf_Internal_Vernaux ivna
;
12037 offset
= offset_from_vma (filedata
,
12038 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
12042 unsigned long vna_off
;
12044 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
12045 _("version need")) == NULL
)
12048 ivna
.vna_other
= 0;
12053 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
12054 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
12056 vna_off
= offset
+ ivn
.vn_aux
;
12060 Elf_External_Vernaux evna
;
12062 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
12063 _("version need aux (3)")) == NULL
)
12066 ivna
.vna_other
= 0;
12071 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
12072 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
12073 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
12076 vna_off
+= ivna
.vna_next
;
12078 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
12080 if (ivna
.vna_other
== vers_data
)
12083 offset
+= ivn
.vn_next
;
12085 while (ivn
.vn_next
!= 0);
12087 if (ivna
.vna_other
== vers_data
)
12089 *sym_info
= symbol_undefined
;
12090 *vna_other
= ivna
.vna_other
;
12091 return (ivna
.vna_name
< strtab_size
12092 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
12094 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
12095 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
12096 return _("<corrupt>");
12102 print_dynamic_symbol (Filedata
*filedata
, unsigned long si
,
12103 Elf_Internal_Sym
*symtab
,
12104 Elf_Internal_Shdr
*section
,
12105 char *strtab
, size_t strtab_size
)
12107 const char *version_string
;
12108 enum versioned_symbol_info sym_info
;
12109 unsigned short vna_other
;
12110 Elf_Internal_Sym
*psym
= symtab
+ si
;
12112 printf ("%6ld: ", si
);
12113 print_vma (psym
->st_value
, LONG_HEX
);
12115 print_vma (psym
->st_size
, DEC_5
);
12116 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12117 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12118 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12119 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12122 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12124 printf (" %-7s", get_symbol_visibility (vis
));
12125 /* Check to see if any other bits in the st_other field are set.
12126 Note - displaying this information disrupts the layout of the
12127 table being generated, but for the moment this case is very rare. */
12128 if (psym
->st_other
^ vis
)
12129 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12131 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12133 bfd_boolean is_valid
= VALID_SYMBOL_NAME (strtab
, strtab_size
,
12135 const char * sstr
= is_valid
? strtab
+ psym
->st_name
: _("<corrupt>");
12138 = get_symbol_version_string (filedata
,
12140 || section
->sh_type
== SHT_DYNSYM
),
12141 strtab
, strtab_size
, si
,
12142 psym
, &sym_info
, &vna_other
);
12144 int len_avail
= 21;
12145 if (! do_wide
&& version_string
!= NULL
)
12149 len_avail
-= 1 + strlen (version_string
);
12151 if (sym_info
== symbol_undefined
)
12152 len_avail
-= sprintf (buffer
," (%d)", vna_other
);
12153 else if (sym_info
!= symbol_hidden
)
12157 print_symbol (len_avail
, sstr
);
12159 if (version_string
)
12161 if (sym_info
== symbol_undefined
)
12162 printf ("@%s (%d)", version_string
, vna_other
);
12164 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12170 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12172 && si
>= section
->sh_info
12173 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12174 && filedata
->file_header
.e_machine
!= EM_MIPS
12175 /* Solaris binaries have been found to violate this requirement as
12176 well. Not sure if this is a bug or an ABI requirement. */
12177 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12178 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12179 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12182 /* Dump the symbol table. */
12184 process_symbol_table (Filedata
* filedata
)
12186 Elf_Internal_Shdr
* section
;
12188 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
12191 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
12193 && do_using_dynamic
12194 && filedata
->dynamic_strings
!= NULL
12195 && filedata
->dynamic_symbols
!= NULL
)
12199 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
12200 "\nSymbol table for image contains %lu entries:\n",
12201 filedata
->num_dynamic_syms
),
12202 filedata
->num_dynamic_syms
);
12204 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12206 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12208 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
12209 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
12210 filedata
->dynamic_strings
,
12211 filedata
->dynamic_strings_length
);
12213 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
12214 && filedata
->section_headers
!= NULL
)
12218 for (i
= 0, section
= filedata
->section_headers
;
12219 i
< filedata
->file_header
.e_shnum
;
12222 char * strtab
= NULL
;
12223 unsigned long int strtab_size
= 0;
12224 Elf_Internal_Sym
* symtab
;
12225 unsigned long si
, num_syms
;
12227 if ((section
->sh_type
!= SHT_SYMTAB
12228 && section
->sh_type
!= SHT_DYNSYM
)
12230 && section
->sh_type
== SHT_SYMTAB
))
12233 if (section
->sh_entsize
== 0)
12235 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12236 printable_section_name (filedata
, section
));
12240 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12241 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12242 "\nSymbol table '%s' contains %lu entries:\n",
12244 printable_section_name (filedata
, section
),
12248 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12250 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12252 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
12253 if (symtab
== NULL
)
12256 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12258 strtab
= filedata
->string_table
;
12259 strtab_size
= filedata
->string_table_length
;
12261 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12263 Elf_Internal_Shdr
* string_sec
;
12265 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12267 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12268 1, string_sec
->sh_size
,
12269 _("string table"));
12270 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12273 for (si
= 0; si
< num_syms
; si
++)
12274 print_dynamic_symbol (filedata
, si
, symtab
, section
,
12275 strtab
, strtab_size
);
12278 if (strtab
!= filedata
->string_table
)
12284 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12286 if (do_histogram
&& filedata
->buckets
!= NULL
)
12288 unsigned long * lengths
;
12289 unsigned long * counts
;
12292 unsigned long maxlength
= 0;
12293 unsigned long nzero_counts
= 0;
12294 unsigned long nsyms
= 0;
12297 printf (ngettext ("\nHistogram for bucket list length "
12298 "(total of %lu bucket):\n",
12299 "\nHistogram for bucket list length "
12300 "(total of %lu buckets):\n",
12301 (unsigned long) filedata
->nbuckets
),
12302 (unsigned long) filedata
->nbuckets
);
12304 lengths
= (unsigned long *) calloc (filedata
->nbuckets
,
12305 sizeof (*lengths
));
12306 if (lengths
== NULL
)
12308 error (_("Out of memory allocating space for histogram buckets\n"));
12311 visited
= xcmalloc (filedata
->nchains
, 1);
12312 memset (visited
, 0, filedata
->nchains
);
12314 printf (_(" Length Number %% of total Coverage\n"));
12315 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12317 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
12320 if (maxlength
< ++lengths
[hn
])
12322 if (si
>= filedata
->nchains
|| visited
[si
])
12324 error (_("histogram chain is corrupt\n"));
12332 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12333 if (counts
== NULL
)
12336 error (_("Out of memory allocating space for histogram counts\n"));
12340 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12341 ++counts
[lengths
[hn
]];
12343 if (filedata
->nbuckets
> 0)
12346 printf (" 0 %-10lu (%5.1f%%)\n",
12347 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
12348 for (i
= 1; i
<= maxlength
; ++i
)
12350 nzero_counts
+= counts
[i
] * i
;
12351 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12352 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
12353 (nzero_counts
* 100.0) / nsyms
);
12361 free (filedata
->buckets
);
12362 filedata
->buckets
= NULL
;
12363 filedata
->nbuckets
= 0;
12364 free (filedata
->chains
);
12365 filedata
->chains
= NULL
;
12367 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
12369 unsigned long * lengths
;
12370 unsigned long * counts
;
12372 unsigned long maxlength
= 0;
12373 unsigned long nzero_counts
= 0;
12374 unsigned long nsyms
= 0;
12376 printf (ngettext ("\nHistogram for `%s' bucket list length "
12377 "(total of %lu bucket):\n",
12378 "\nHistogram for `%s' bucket list length "
12379 "(total of %lu buckets):\n",
12380 (unsigned long) filedata
->ngnubuckets
),
12381 GNU_HASH_SECTION_NAME (filedata
),
12382 (unsigned long) filedata
->ngnubuckets
);
12384 lengths
= (unsigned long *) calloc (filedata
->ngnubuckets
,
12385 sizeof (*lengths
));
12386 if (lengths
== NULL
)
12388 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12392 printf (_(" Length Number %% of total Coverage\n"));
12394 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12395 if (filedata
->gnubuckets
[hn
] != 0)
12397 bfd_vma off
, length
= 1;
12399 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
12400 /* PR 17531 file: 010-77222-0.004. */
12401 off
< filedata
->ngnuchains
12402 && (filedata
->gnuchains
[off
] & 1) == 0;
12405 lengths
[hn
] = length
;
12406 if (length
> maxlength
)
12407 maxlength
= length
;
12411 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12412 if (counts
== NULL
)
12415 error (_("Out of memory allocating space for gnu histogram counts\n"));
12419 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12420 ++counts
[lengths
[hn
]];
12422 if (filedata
->ngnubuckets
> 0)
12425 printf (" 0 %-10lu (%5.1f%%)\n",
12426 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
12427 for (j
= 1; j
<= maxlength
; ++j
)
12429 nzero_counts
+= counts
[j
] * j
;
12430 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12431 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
12432 (nzero_counts
* 100.0) / nsyms
);
12439 free (filedata
->gnubuckets
);
12440 filedata
->gnubuckets
= NULL
;
12441 filedata
->ngnubuckets
= 0;
12442 free (filedata
->gnuchains
);
12443 filedata
->gnuchains
= NULL
;
12444 filedata
->ngnuchains
= 0;
12445 free (filedata
->mipsxlat
);
12446 filedata
->mipsxlat
= NULL
;
12450 free (filedata
->gnubuckets
);
12451 filedata
->gnubuckets
= NULL
;
12452 filedata
->ngnubuckets
= 0;
12453 free (filedata
->gnuchains
);
12454 filedata
->gnuchains
= NULL
;
12455 filedata
->ngnuchains
= 0;
12456 free (filedata
->mipsxlat
);
12457 filedata
->mipsxlat
= NULL
;
12458 free (filedata
->buckets
);
12459 filedata
->buckets
= NULL
;
12460 filedata
->nbuckets
= 0;
12461 free (filedata
->chains
);
12462 filedata
->chains
= NULL
;
12467 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12471 if (filedata
->dynamic_syminfo
== NULL
12473 /* No syminfo, this is ok. */
12476 /* There better should be a dynamic symbol section. */
12477 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
12480 if (filedata
->dynamic_addr
)
12481 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12482 "contains %d entry:\n",
12483 "\nDynamic info segment at offset 0x%lx "
12484 "contains %d entries:\n",
12485 filedata
->dynamic_syminfo_nent
),
12486 filedata
->dynamic_syminfo_offset
, filedata
->dynamic_syminfo_nent
);
12488 printf (_(" Num: Name BoundTo Flags\n"));
12489 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
12491 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
12493 printf ("%4d: ", i
);
12494 if (i
>= filedata
->num_dynamic_syms
)
12495 printf (_("<corrupt index>"));
12496 else if (VALID_DYNAMIC_NAME (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
12497 print_symbol (30, GET_DYNAMIC_NAME (filedata
,
12498 filedata
->dynamic_symbols
[i
].st_name
));
12500 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
12503 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
12505 case SYMINFO_BT_SELF
:
12506 fputs ("SELF ", stdout
);
12508 case SYMINFO_BT_PARENT
:
12509 fputs ("PARENT ", stdout
);
12512 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
12513 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
12514 && VALID_DYNAMIC_NAME (filedata
,
12515 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12517 print_symbol (10, GET_DYNAMIC_NAME (filedata
,
12518 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12522 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
12526 if (flags
& SYMINFO_FLG_DIRECT
)
12527 printf (" DIRECT");
12528 if (flags
& SYMINFO_FLG_PASSTHRU
)
12529 printf (" PASSTHRU");
12530 if (flags
& SYMINFO_FLG_COPY
)
12532 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12533 printf (" LAZYLOAD");
12541 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12542 is contained by the region START .. END. The types of ADDR, START
12543 and END should all be the same. Note both ADDR + NELEM and END
12544 point to just beyond the end of the regions that are being tested. */
12545 #define IN_RANGE(START,END,ADDR,NELEM) \
12546 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12548 /* Check to see if the given reloc needs to be handled in a target specific
12549 manner. If so then process the reloc and return TRUE otherwise return
12552 If called with reloc == NULL, then this is a signal that reloc processing
12553 for the current section has finished, and any saved state should be
12557 target_specific_reloc_handling (Filedata
* filedata
,
12558 Elf_Internal_Rela
* reloc
,
12559 unsigned char * start
,
12560 unsigned char * end
,
12561 Elf_Internal_Sym
* symtab
,
12562 unsigned long num_syms
)
12564 unsigned int reloc_type
= 0;
12565 unsigned long sym_index
= 0;
12569 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12570 sym_index
= get_reloc_symindex (reloc
->r_info
);
12573 switch (filedata
->file_header
.e_machine
)
12576 case EM_MSP430_OLD
:
12578 static Elf_Internal_Sym
* saved_sym
= NULL
;
12586 switch (reloc_type
)
12588 case 10: /* R_MSP430_SYM_DIFF */
12589 case 12: /* R_MSP430_GNU_SUB_ULEB128 */
12590 if (uses_msp430x_relocs (filedata
))
12592 /* Fall through. */
12593 case 21: /* R_MSP430X_SYM_DIFF */
12594 case 23: /* R_MSP430X_GNU_SUB_ULEB128 */
12596 if (sym_index
>= num_syms
)
12597 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12600 saved_sym
= symtab
+ sym_index
;
12603 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12604 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12605 goto handle_sym_diff
;
12607 case 5: /* R_MSP430_16_BYTE */
12608 case 9: /* R_MSP430_8 */
12609 case 11: /* R_MSP430_GNU_SET_ULEB128 */
12610 if (uses_msp430x_relocs (filedata
))
12612 goto handle_sym_diff
;
12614 case 2: /* R_MSP430_ABS16 */
12615 case 15: /* R_MSP430X_ABS16 */
12616 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
12617 if (! uses_msp430x_relocs (filedata
))
12619 goto handle_sym_diff
;
12622 if (saved_sym
!= NULL
)
12625 unsigned int reloc_size
;
12627 switch (reloc_type
)
12629 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12632 case 11: /* R_MSP430_GNU_SET_ULEB128 */
12633 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
12634 read_leb128 (start
+ reloc
->r_offset
, end
, FALSE
,
12635 &reloc_size
, &leb_ret
);
12643 error (_("MSP430 ULEB128 field at 0x%lx contains invalid "
12644 "ULEB128 value\n"),
12645 (long) reloc
->r_offset
);
12646 else if (sym_index
>= num_syms
)
12647 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12651 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12652 - saved_sym
->st_value
);
12654 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12655 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12658 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12659 (long) reloc
->r_offset
);
12668 if (saved_sym
!= NULL
)
12669 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12676 case EM_CYGNUS_MN10300
:
12678 static Elf_Internal_Sym
* saved_sym
= NULL
;
12686 switch (reloc_type
)
12688 case 34: /* R_MN10300_ALIGN */
12690 case 33: /* R_MN10300_SYM_DIFF */
12691 if (sym_index
>= num_syms
)
12692 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12695 saved_sym
= symtab
+ sym_index
;
12698 case 1: /* R_MN10300_32 */
12699 case 2: /* R_MN10300_16 */
12700 if (saved_sym
!= NULL
)
12702 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12705 if (sym_index
>= num_syms
)
12706 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12710 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12711 - saved_sym
->st_value
);
12713 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12714 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12716 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12717 (long) reloc
->r_offset
);
12725 if (saved_sym
!= NULL
)
12726 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12734 static bfd_vma saved_sym1
= 0;
12735 static bfd_vma saved_sym2
= 0;
12736 static bfd_vma value
;
12740 saved_sym1
= saved_sym2
= 0;
12744 switch (reloc_type
)
12746 case 0x80: /* R_RL78_SYM. */
12747 saved_sym1
= saved_sym2
;
12748 if (sym_index
>= num_syms
)
12749 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12753 saved_sym2
= symtab
[sym_index
].st_value
;
12754 saved_sym2
+= reloc
->r_addend
;
12758 case 0x83: /* R_RL78_OPsub. */
12759 value
= saved_sym1
- saved_sym2
;
12760 saved_sym2
= saved_sym1
= 0;
12764 case 0x41: /* R_RL78_ABS32. */
12765 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12766 byte_put (start
+ reloc
->r_offset
, value
, 4);
12768 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12769 (long) reloc
->r_offset
);
12773 case 0x43: /* R_RL78_ABS16. */
12774 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12775 byte_put (start
+ reloc
->r_offset
, value
, 2);
12777 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12778 (long) reloc
->r_offset
);
12792 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12793 DWARF debug sections. This is a target specific test. Note - we do not
12794 go through the whole including-target-headers-multiple-times route, (as
12795 we have already done with <elf/h8.h>) because this would become very
12796 messy and even then this function would have to contain target specific
12797 information (the names of the relocs instead of their numeric values).
12798 FIXME: This is not the correct way to solve this problem. The proper way
12799 is to have target specific reloc sizing and typing functions created by
12800 the reloc-macros.h header, in the same way that it already creates the
12801 reloc naming functions. */
12804 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12806 /* Please keep this table alpha-sorted for ease of visual lookup. */
12807 switch (filedata
->file_header
.e_machine
)
12811 return reloc_type
== 1; /* R_386_32. */
12813 return reloc_type
== 1; /* R_68K_32. */
12815 return reloc_type
== 1; /* R_860_32. */
12817 return reloc_type
== 2; /* R_960_32. */
12819 return (reloc_type
== 258
12820 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12822 return reloc_type
== 11; /* R_BPF_DATA_32 */
12823 case EM_ADAPTEVA_EPIPHANY
:
12824 return reloc_type
== 3;
12826 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12828 return reloc_type
== 1; /* R_ARC_32. */
12829 case EM_ARC_COMPACT
:
12830 case EM_ARC_COMPACT2
:
12831 return reloc_type
== 4; /* R_ARC_32. */
12833 return reloc_type
== 2; /* R_ARM_ABS32 */
12836 return reloc_type
== 1;
12838 return reloc_type
== 0x12; /* R_byte4_data. */
12840 return reloc_type
== 3; /* R_CRIS_32. */
12842 return reloc_type
== 3; /* R_CR16_NUM32. */
12844 return reloc_type
== 15; /* R_CRX_NUM32. */
12846 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12847 case EM_CYGNUS_FRV
:
12848 return reloc_type
== 1;
12849 case EM_CYGNUS_D10V
:
12851 return reloc_type
== 6; /* R_D10V_32. */
12852 case EM_CYGNUS_D30V
:
12854 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12856 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12857 case EM_CYGNUS_FR30
:
12859 return reloc_type
== 3; /* R_FR30_32. */
12861 return reloc_type
== 1; /* R_FT32_32. */
12865 return reloc_type
== 1; /* R_H8_DIR32. */
12867 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12868 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12869 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12870 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12873 return reloc_type
== 2; /* R_IP2K_32. */
12875 return reloc_type
== 2; /* R_IQ2000_32. */
12876 case EM_LATTICEMICO32
:
12877 return reloc_type
== 3; /* R_LM32_32. */
12880 return reloc_type
== 3; /* R_M32C_32. */
12882 return reloc_type
== 34; /* R_M32R_32_RELA. */
12885 return reloc_type
== 6; /* R_M68HC11_32. */
12887 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12888 reloc_type
== 6; /* R_S12Z_CW32. */
12890 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12891 case EM_CYGNUS_MEP
:
12892 return reloc_type
== 4; /* R_MEP_32. */
12894 return reloc_type
== 2; /* R_METAG_ADDR32. */
12895 case EM_MICROBLAZE
:
12896 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12898 return reloc_type
== 2; /* R_MIPS_32. */
12900 return reloc_type
== 4; /* R_MMIX_32. */
12901 case EM_CYGNUS_MN10200
:
12903 return reloc_type
== 1; /* R_MN10200_32. */
12904 case EM_CYGNUS_MN10300
:
12906 return reloc_type
== 1; /* R_MN10300_32. */
12908 return reloc_type
== 1; /* R_MOXIE_32. */
12909 case EM_MSP430_OLD
:
12911 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12913 return reloc_type
== 2; /* R_MT_32. */
12915 return reloc_type
== 20; /* R_NDS32_RELA. */
12916 case EM_ALTERA_NIOS2
:
12917 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12919 return reloc_type
== 1; /* R_NIOS_32. */
12921 return reloc_type
== 1; /* R_OR1K_32. */
12923 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12924 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12925 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12928 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12930 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12932 return reloc_type
== 1; /* R_PPC_ADDR32. */
12934 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12936 return reloc_type
== 1; /* R_RISCV_32. */
12938 return reloc_type
== 1; /* R_RL78_DIR32. */
12940 return reloc_type
== 1; /* R_RX_DIR32. */
12942 return reloc_type
== 1; /* R_I370_ADDR31. */
12945 return reloc_type
== 4; /* R_S390_32. */
12947 return reloc_type
== 8; /* R_SCORE_ABS32. */
12949 return reloc_type
== 1; /* R_SH_DIR32. */
12950 case EM_SPARC32PLUS
:
12953 return reloc_type
== 3 /* R_SPARC_32. */
12954 || reloc_type
== 23; /* R_SPARC_UA32. */
12956 return reloc_type
== 6; /* R_SPU_ADDR32 */
12958 return reloc_type
== 1; /* R_C6000_ABS32. */
12960 return reloc_type
== 2; /* R_TILEGX_32. */
12962 return reloc_type
== 1; /* R_TILEPRO_32. */
12963 case EM_CYGNUS_V850
:
12965 return reloc_type
== 6; /* R_V850_ABS32. */
12967 return reloc_type
== 0x33; /* R_V810_WORD. */
12969 return reloc_type
== 1; /* R_VAX_32. */
12971 return reloc_type
== 3; /* R_VISIUM_32. */
12972 case EM_WEBASSEMBLY
:
12973 return reloc_type
== 1; /* R_WASM32_32. */
12977 return reloc_type
== 10; /* R_X86_64_32. */
12980 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12982 return reloc_type
== 4; /* R_XGATE_32. */
12984 return reloc_type
== 1; /* R_XSTROMY16_32. */
12985 case EM_XTENSA_OLD
:
12987 return reloc_type
== 1; /* R_XTENSA_32. */
12989 return reloc_type
== 6; /* R_Z80_32. */
12992 static unsigned int prev_warn
= 0;
12994 /* Avoid repeating the same warning multiple times. */
12995 if (prev_warn
!= filedata
->file_header
.e_machine
)
12996 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12997 filedata
->file_header
.e_machine
);
12998 prev_warn
= filedata
->file_header
.e_machine
;
13004 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13005 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
13008 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13010 switch (filedata
->file_header
.e_machine
)
13011 /* Please keep this table alpha-sorted for ease of visual lookup. */
13015 return reloc_type
== 2; /* R_386_PC32. */
13017 return reloc_type
== 4; /* R_68K_PC32. */
13019 return reloc_type
== 261; /* R_AARCH64_PREL32 */
13020 case EM_ADAPTEVA_EPIPHANY
:
13021 return reloc_type
== 6;
13023 return reloc_type
== 10; /* R_ALPHA_SREL32. */
13024 case EM_ARC_COMPACT
:
13025 case EM_ARC_COMPACT2
:
13026 return reloc_type
== 49; /* R_ARC_32_PCREL. */
13028 return reloc_type
== 3; /* R_ARM_REL32 */
13031 return reloc_type
== 36; /* R_AVR_32_PCREL. */
13032 case EM_MICROBLAZE
:
13033 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
13035 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
13037 return reloc_type
== 9; /* R_PARISC_PCREL32. */
13039 return reloc_type
== 26; /* R_PPC_REL32. */
13041 return reloc_type
== 26; /* R_PPC64_REL32. */
13043 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
13046 return reloc_type
== 5; /* R_390_PC32. */
13048 return reloc_type
== 2; /* R_SH_REL32. */
13049 case EM_SPARC32PLUS
:
13052 return reloc_type
== 6; /* R_SPARC_DISP32. */
13054 return reloc_type
== 13; /* R_SPU_REL32. */
13056 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
13058 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
13060 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
13064 return reloc_type
== 2; /* R_X86_64_PC32. */
13066 return reloc_type
== 4; /* R_VAX_PCREL32. */
13067 case EM_XTENSA_OLD
:
13069 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
13071 /* Do not abort or issue an error message here. Not all targets use
13072 pc-relative 32-bit relocs in their DWARF debug information and we
13073 have already tested for target coverage in is_32bit_abs_reloc. A
13074 more helpful warning message will be generated by apply_relocations
13075 anyway, so just return. */
13080 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13081 a 64-bit absolute RELA relocation used in DWARF debug sections. */
13084 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13086 switch (filedata
->file_header
.e_machine
)
13089 return reloc_type
== 257; /* R_AARCH64_ABS64. */
13091 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
13093 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
13094 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
13096 return reloc_type
== 80; /* R_PARISC_DIR64. */
13098 return reloc_type
== 38; /* R_PPC64_ADDR64. */
13100 return reloc_type
== 2; /* R_RISCV_64. */
13101 case EM_SPARC32PLUS
:
13104 return reloc_type
== 32 /* R_SPARC_64. */
13105 || reloc_type
== 54; /* R_SPARC_UA64. */
13109 return reloc_type
== 1; /* R_X86_64_64. */
13112 return reloc_type
== 22; /* R_S390_64. */
13114 return reloc_type
== 1; /* R_TILEGX_64. */
13116 return reloc_type
== 18; /* R_MIPS_64. */
13122 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
13123 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
13126 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13128 switch (filedata
->file_header
.e_machine
)
13131 return reloc_type
== 260; /* R_AARCH64_PREL64. */
13133 return reloc_type
== 11; /* R_ALPHA_SREL64. */
13135 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
13136 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
13138 return reloc_type
== 72; /* R_PARISC_PCREL64. */
13140 return reloc_type
== 44; /* R_PPC64_REL64. */
13141 case EM_SPARC32PLUS
:
13144 return reloc_type
== 46; /* R_SPARC_DISP64. */
13148 return reloc_type
== 24; /* R_X86_64_PC64. */
13151 return reloc_type
== 23; /* R_S390_PC64. */
13153 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
13159 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13160 a 24-bit absolute RELA relocation used in DWARF debug sections. */
13163 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13165 switch (filedata
->file_header
.e_machine
)
13167 case EM_CYGNUS_MN10200
:
13169 return reloc_type
== 4; /* R_MN10200_24. */
13171 return reloc_type
== 5; /* R_FT32_20. */
13173 return reloc_type
== 5; /* R_Z80_24. */
13179 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13180 a 16-bit absolute RELA relocation used in DWARF debug sections. */
13183 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13185 /* Please keep this table alpha-sorted for ease of visual lookup. */
13186 switch (filedata
->file_header
.e_machine
)
13189 case EM_ARC_COMPACT
:
13190 case EM_ARC_COMPACT2
:
13191 return reloc_type
== 2; /* R_ARC_16. */
13192 case EM_ADAPTEVA_EPIPHANY
:
13193 return reloc_type
== 5;
13196 return reloc_type
== 4; /* R_AVR_16. */
13197 case EM_CYGNUS_D10V
:
13199 return reloc_type
== 3; /* R_D10V_16. */
13201 return reloc_type
== 2; /* R_FT32_16. */
13205 return reloc_type
== R_H8_DIR16
;
13208 return reloc_type
== 1; /* R_IP2K_16. */
13211 return reloc_type
== 1; /* R_M32C_16 */
13212 case EM_CYGNUS_MN10200
:
13214 return reloc_type
== 2; /* R_MN10200_16. */
13215 case EM_CYGNUS_MN10300
:
13217 return reloc_type
== 2; /* R_MN10300_16. */
13219 if (uses_msp430x_relocs (filedata
))
13220 return reloc_type
== 2; /* R_MSP430_ABS16. */
13221 /* Fall through. */
13222 case EM_MSP430_OLD
:
13223 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13225 return reloc_type
== 19; /* R_NDS32_RELA. */
13226 case EM_ALTERA_NIOS2
:
13227 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13229 return reloc_type
== 9; /* R_NIOS_16. */
13231 return reloc_type
== 2; /* R_OR1K_16. */
13233 return reloc_type
== 55; /* R_RISCV_SET16. */
13235 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13237 return reloc_type
== 2; /* R_C6000_ABS16. */
13239 return reloc_type
== 2; /* R_VISIUM_16. */
13242 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13244 return reloc_type
== 3; /* R_XGATE_16. */
13246 return reloc_type
== 4; /* R_Z80_16. */
13252 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13253 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13256 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13258 switch (filedata
->file_header
.e_machine
)
13261 return reloc_type
== 54; /* R_RISCV_SET8. */
13263 return reloc_type
== 1; /* R_Z80_8. */
13269 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13270 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13273 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13275 switch (filedata
->file_header
.e_machine
)
13278 return reloc_type
== 53; /* R_RISCV_SET6. */
13284 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13285 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13288 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13290 /* Please keep this table alpha-sorted for ease of visual lookup. */
13291 switch (filedata
->file_header
.e_machine
)
13294 return reloc_type
== 35; /* R_RISCV_ADD32. */
13300 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13301 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13304 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13306 /* Please keep this table alpha-sorted for ease of visual lookup. */
13307 switch (filedata
->file_header
.e_machine
)
13310 return reloc_type
== 39; /* R_RISCV_SUB32. */
13316 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13317 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13320 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13322 /* Please keep this table alpha-sorted for ease of visual lookup. */
13323 switch (filedata
->file_header
.e_machine
)
13326 return reloc_type
== 36; /* R_RISCV_ADD64. */
13332 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13333 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13336 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13338 /* Please keep this table alpha-sorted for ease of visual lookup. */
13339 switch (filedata
->file_header
.e_machine
)
13342 return reloc_type
== 40; /* R_RISCV_SUB64. */
13348 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13349 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13352 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13354 /* Please keep this table alpha-sorted for ease of visual lookup. */
13355 switch (filedata
->file_header
.e_machine
)
13358 return reloc_type
== 34; /* R_RISCV_ADD16. */
13364 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13365 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13368 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13370 /* Please keep this table alpha-sorted for ease of visual lookup. */
13371 switch (filedata
->file_header
.e_machine
)
13374 return reloc_type
== 38; /* R_RISCV_SUB16. */
13380 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13381 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13384 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13386 /* Please keep this table alpha-sorted for ease of visual lookup. */
13387 switch (filedata
->file_header
.e_machine
)
13390 return reloc_type
== 33; /* R_RISCV_ADD8. */
13396 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13397 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13400 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13402 /* Please keep this table alpha-sorted for ease of visual lookup. */
13403 switch (filedata
->file_header
.e_machine
)
13406 return reloc_type
== 37; /* R_RISCV_SUB8. */
13412 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13413 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13416 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13418 switch (filedata
->file_header
.e_machine
)
13421 return reloc_type
== 52; /* R_RISCV_SUB6. */
13427 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13428 relocation entries (possibly formerly used for SHT_GROUP sections). */
13431 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13433 switch (filedata
->file_header
.e_machine
)
13435 case EM_386
: /* R_386_NONE. */
13436 case EM_68K
: /* R_68K_NONE. */
13437 case EM_ADAPTEVA_EPIPHANY
:
13438 case EM_ALPHA
: /* R_ALPHA_NONE. */
13439 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13440 case EM_ARC
: /* R_ARC_NONE. */
13441 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13442 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13443 case EM_ARM
: /* R_ARM_NONE. */
13444 case EM_C166
: /* R_XC16X_NONE. */
13445 case EM_CRIS
: /* R_CRIS_NONE. */
13446 case EM_FT32
: /* R_FT32_NONE. */
13447 case EM_IA_64
: /* R_IA64_NONE. */
13448 case EM_K1OM
: /* R_X86_64_NONE. */
13449 case EM_L1OM
: /* R_X86_64_NONE. */
13450 case EM_M32R
: /* R_M32R_NONE. */
13451 case EM_MIPS
: /* R_MIPS_NONE. */
13452 case EM_MN10300
: /* R_MN10300_NONE. */
13453 case EM_MOXIE
: /* R_MOXIE_NONE. */
13454 case EM_NIOS32
: /* R_NIOS_NONE. */
13455 case EM_OR1K
: /* R_OR1K_NONE. */
13456 case EM_PARISC
: /* R_PARISC_NONE. */
13457 case EM_PPC64
: /* R_PPC64_NONE. */
13458 case EM_PPC
: /* R_PPC_NONE. */
13459 case EM_RISCV
: /* R_RISCV_NONE. */
13460 case EM_S390
: /* R_390_NONE. */
13462 case EM_SH
: /* R_SH_NONE. */
13463 case EM_SPARC32PLUS
:
13464 case EM_SPARC
: /* R_SPARC_NONE. */
13466 case EM_TILEGX
: /* R_TILEGX_NONE. */
13467 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13468 case EM_TI_C6000
:/* R_C6000_NONE. */
13469 case EM_X86_64
: /* R_X86_64_NONE. */
13471 case EM_Z80
: /* R_Z80_NONE. */
13472 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13473 return reloc_type
== 0;
13476 return reloc_type
== 0 || reloc_type
== 256;
13479 return (reloc_type
== 0 /* R_AVR_NONE. */
13480 || reloc_type
== 30 /* R_AVR_DIFF8. */
13481 || reloc_type
== 31 /* R_AVR_DIFF16. */
13482 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13484 return reloc_type
== 3; /* R_METAG_NONE. */
13486 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13487 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13488 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13489 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13490 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13492 return (reloc_type
== 0 /* R_PRU_NONE. */
13493 || reloc_type
== 65 /* R_PRU_DIFF8. */
13494 || reloc_type
== 66 /* R_PRU_DIFF16. */
13495 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13496 case EM_XTENSA_OLD
:
13498 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13499 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13500 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13501 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
13502 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
13503 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
13504 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
13505 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
13506 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
13507 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
13512 /* Returns TRUE if there is a relocation against
13513 section NAME at OFFSET bytes. */
13516 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13518 Elf_Internal_Rela
* relocs
;
13519 Elf_Internal_Rela
* rp
;
13521 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13524 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13526 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13527 if (rp
->r_offset
== offset
)
13533 /* Apply relocations to a section.
13534 Returns TRUE upon success, FALSE otherwise.
13535 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13536 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13537 will be set to the number of relocs loaded.
13539 Note: So far support has been added only for those relocations
13540 which can be found in debug sections. FIXME: Add support for
13541 more relocations ? */
13544 apply_relocations (Filedata
* filedata
,
13545 const Elf_Internal_Shdr
* section
,
13546 unsigned char * start
,
13547 bfd_size_type size
,
13548 void ** relocs_return
,
13549 unsigned long * num_relocs_return
)
13551 Elf_Internal_Shdr
* relsec
;
13552 unsigned char * end
= start
+ size
;
13554 if (relocs_return
!= NULL
)
13556 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13557 * num_relocs_return
= 0;
13560 if (filedata
->file_header
.e_type
!= ET_REL
)
13561 /* No relocs to apply. */
13564 /* Find the reloc section associated with the section. */
13565 for (relsec
= filedata
->section_headers
;
13566 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13569 bfd_boolean is_rela
;
13570 unsigned long num_relocs
;
13571 Elf_Internal_Rela
* relocs
;
13572 Elf_Internal_Rela
* rp
;
13573 Elf_Internal_Shdr
* symsec
;
13574 Elf_Internal_Sym
* symtab
;
13575 unsigned long num_syms
;
13576 Elf_Internal_Sym
* sym
;
13578 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13579 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13580 || filedata
->section_headers
+ relsec
->sh_info
!= section
13581 || relsec
->sh_size
== 0
13582 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13585 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13586 if (symsec
->sh_type
!= SHT_SYMTAB
13587 && symsec
->sh_type
!= SHT_DYNSYM
)
13590 is_rela
= relsec
->sh_type
== SHT_RELA
;
13594 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13595 relsec
->sh_size
, & relocs
, & num_relocs
))
13600 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13601 relsec
->sh_size
, & relocs
, & num_relocs
))
13605 /* SH uses RELA but uses in place value instead of the addend field. */
13606 if (filedata
->file_header
.e_machine
== EM_SH
)
13609 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13611 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13614 unsigned int reloc_type
;
13615 unsigned int reloc_size
;
13616 bfd_boolean reloc_inplace
= FALSE
;
13617 bfd_boolean reloc_subtract
= FALSE
;
13618 unsigned char * rloc
;
13619 unsigned long sym_index
;
13621 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13623 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13625 else if (is_none_reloc (filedata
, reloc_type
))
13627 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13628 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13630 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13631 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13633 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13635 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13637 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13638 || is_6bit_abs_reloc (filedata
, reloc_type
))
13640 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13642 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13645 reloc_inplace
= TRUE
;
13647 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13649 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13652 reloc_inplace
= TRUE
;
13654 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13656 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13659 reloc_inplace
= TRUE
;
13661 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13663 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13666 reloc_inplace
= TRUE
;
13668 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13672 reloc_inplace
= TRUE
;
13676 static unsigned int prev_reloc
= 0;
13678 if (reloc_type
!= prev_reloc
)
13679 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13680 reloc_type
, printable_section_name (filedata
, section
));
13681 prev_reloc
= reloc_type
;
13685 rloc
= start
+ rp
->r_offset
;
13686 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
13688 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13689 (unsigned long) rp
->r_offset
,
13690 printable_section_name (filedata
, section
));
13694 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13695 if (sym_index
>= num_syms
)
13697 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13698 sym_index
, printable_section_name (filedata
, section
));
13701 sym
= symtab
+ sym_index
;
13703 /* If the reloc has a symbol associated with it,
13704 make sure that it is of an appropriate type.
13706 Relocations against symbols without type can happen.
13707 Gcc -feliminate-dwarf2-dups may generate symbols
13708 without type for debug info.
13710 Icc generates relocations against function symbols
13711 instead of local labels.
13713 Relocations against object symbols can happen, eg when
13714 referencing a global array. For an example of this see
13715 the _clz.o binary in libgcc.a. */
13717 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13718 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13720 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13721 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13722 printable_section_name (filedata
, relsec
),
13723 (long int)(rp
- relocs
));
13729 addend
+= rp
->r_addend
;
13730 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13731 partial_inplace. */
13733 || (filedata
->file_header
.e_machine
== EM_XTENSA
13734 && reloc_type
== 1)
13735 || ((filedata
->file_header
.e_machine
== EM_PJ
13736 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13737 && reloc_type
== 1)
13738 || ((filedata
->file_header
.e_machine
== EM_D30V
13739 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13740 && reloc_type
== 12)
13743 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13744 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13746 addend
+= byte_get (rloc
, reloc_size
);
13749 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13750 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13752 /* On HPPA, all pc-relative relocations are biased by 8. */
13753 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13755 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13758 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13759 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13761 if (reloc_subtract
)
13762 addend
-= sym
->st_value
;
13764 addend
+= sym
->st_value
;
13765 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13766 byte_put (rloc
, addend
, reloc_size
);
13768 else if (reloc_subtract
)
13769 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13771 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13775 /* Let the target specific reloc processing code know that
13776 we have finished with these relocs. */
13777 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13781 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13782 * num_relocs_return
= num_relocs
;
13793 #ifdef SUPPORT_DISASSEMBLY
13795 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13797 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13799 /* FIXME: XXX -- to be done --- XXX */
13805 /* Reads in the contents of SECTION from FILE, returning a pointer
13806 to a malloc'ed buffer or NULL if something went wrong. */
13809 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13811 bfd_size_type num_bytes
= section
->sh_size
;
13813 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13815 printf (_("Section '%s' has no data to dump.\n"),
13816 printable_section_name (filedata
, section
));
13820 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13821 _("section contents"));
13824 /* Uncompresses a section that was compressed using zlib, in place. */
13827 uncompress_section_contents (unsigned char ** buffer
,
13828 dwarf_size_type uncompressed_size
,
13829 dwarf_size_type
* size
)
13831 dwarf_size_type compressed_size
= *size
;
13832 unsigned char * compressed_buffer
= *buffer
;
13833 unsigned char * uncompressed_buffer
;
13837 /* It is possible the section consists of several compressed
13838 buffers concatenated together, so we uncompress in a loop. */
13839 /* PR 18313: The state field in the z_stream structure is supposed
13840 to be invisible to the user (ie us), but some compilers will
13841 still complain about it being used without initialisation. So
13842 we first zero the entire z_stream structure and then set the fields
13844 memset (& strm
, 0, sizeof strm
);
13845 strm
.avail_in
= compressed_size
;
13846 strm
.next_in
= (Bytef
*) compressed_buffer
;
13847 strm
.avail_out
= uncompressed_size
;
13848 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13850 rc
= inflateInit (& strm
);
13851 while (strm
.avail_in
> 0)
13855 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13856 + (uncompressed_size
- strm
.avail_out
));
13857 rc
= inflate (&strm
, Z_FINISH
);
13858 if (rc
!= Z_STREAM_END
)
13860 rc
= inflateReset (& strm
);
13862 rc
= inflateEnd (& strm
);
13864 || strm
.avail_out
!= 0)
13867 *buffer
= uncompressed_buffer
;
13868 *size
= uncompressed_size
;
13872 free (uncompressed_buffer
);
13873 /* Indicate decompression failure. */
13879 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13881 Elf_Internal_Shdr
* relsec
;
13882 bfd_size_type num_bytes
;
13883 unsigned char * data
;
13884 unsigned char * end
;
13885 unsigned char * real_start
;
13886 unsigned char * start
;
13887 bfd_boolean some_strings_shown
;
13889 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13891 /* PR 21820: Do not fail if the section was empty. */
13892 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13894 num_bytes
= section
->sh_size
;
13896 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13898 if (decompress_dumps
)
13900 dwarf_size_type new_size
= num_bytes
;
13901 dwarf_size_type uncompressed_size
= 0;
13903 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13905 Elf_Internal_Chdr chdr
;
13906 unsigned int compression_header_size
13907 = get_compression_header (& chdr
, (unsigned char *) start
,
13909 if (compression_header_size
== 0)
13910 /* An error message will have already been generated
13911 by get_compression_header. */
13914 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13916 warn (_("section '%s' has unsupported compress type: %d\n"),
13917 printable_section_name (filedata
, section
), chdr
.ch_type
);
13920 uncompressed_size
= chdr
.ch_size
;
13921 start
+= compression_header_size
;
13922 new_size
-= compression_header_size
;
13924 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13926 /* Read the zlib header. In this case, it should be "ZLIB"
13927 followed by the uncompressed section size, 8 bytes in
13928 big-endian order. */
13929 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13930 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13931 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13932 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13933 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13934 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13935 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13936 uncompressed_size
+= start
[11];
13941 if (uncompressed_size
)
13943 if (uncompress_section_contents (& start
,
13944 uncompressed_size
, & new_size
))
13945 num_bytes
= new_size
;
13948 error (_("Unable to decompress section %s\n"),
13949 printable_section_name (filedata
, section
));
13954 start
= real_start
;
13957 /* If the section being dumped has relocations against it the user might
13958 be expecting these relocations to have been applied. Check for this
13959 case and issue a warning message in order to avoid confusion.
13960 FIXME: Maybe we ought to have an option that dumps a section with
13961 relocs applied ? */
13962 for (relsec
= filedata
->section_headers
;
13963 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13966 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13967 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13968 || filedata
->section_headers
+ relsec
->sh_info
!= section
13969 || relsec
->sh_size
== 0
13970 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13973 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13978 end
= start
+ num_bytes
;
13979 some_strings_shown
= FALSE
;
13981 #ifdef HAVE_MBSTATE_T
13983 /* Initialise the multibyte conversion state. */
13984 memset (& state
, 0, sizeof (state
));
13987 bfd_boolean continuing
= FALSE
;
13991 while (!ISPRINT (* data
))
13992 if (++ data
>= end
)
13997 size_t maxlen
= end
- data
;
14002 continuing
= FALSE
;
14006 printf (" [%6lx] ", (unsigned long) (data
- start
));
14020 /* PR 25543: Treat new-lines as string-ending characters. */
14029 /* Do not print control characters directly as they can affect terminal
14030 settings. Such characters usually appear in the names generated
14031 by the assembler for local labels. */
14034 printf ("^%c", c
+ 0x40);
14036 else if (ISPRINT (c
))
14043 #ifdef HAVE_MBSTATE_T
14046 /* Let printf do the hard work of displaying multibyte characters. */
14047 printf ("%.1s", data
- 1);
14048 #ifdef HAVE_MBSTATE_T
14049 /* Try to find out how many bytes made up the character that was
14050 just printed. Advance the symbol pointer past the bytes that
14052 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
14056 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
14066 printf (_("<corrupt>\n"));
14069 some_strings_shown
= TRUE
;
14073 if (! some_strings_shown
)
14074 printf (_(" No strings found in this section."));
14087 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
14088 Filedata
* filedata
,
14089 bfd_boolean relocate
)
14091 Elf_Internal_Shdr
* relsec
;
14092 bfd_size_type bytes
;
14093 bfd_size_type section_size
;
14095 unsigned char * data
;
14096 unsigned char * real_start
;
14097 unsigned char * start
;
14099 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
14101 /* PR 21820: Do not fail if the section was empty. */
14102 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
14104 section_size
= section
->sh_size
;
14106 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
14108 if (decompress_dumps
)
14110 dwarf_size_type new_size
= section_size
;
14111 dwarf_size_type uncompressed_size
= 0;
14113 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14115 Elf_Internal_Chdr chdr
;
14116 unsigned int compression_header_size
14117 = get_compression_header (& chdr
, start
, section_size
);
14119 if (compression_header_size
== 0)
14120 /* An error message will have already been generated
14121 by get_compression_header. */
14124 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14126 warn (_("section '%s' has unsupported compress type: %d\n"),
14127 printable_section_name (filedata
, section
), chdr
.ch_type
);
14130 uncompressed_size
= chdr
.ch_size
;
14131 start
+= compression_header_size
;
14132 new_size
-= compression_header_size
;
14134 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14136 /* Read the zlib header. In this case, it should be "ZLIB"
14137 followed by the uncompressed section size, 8 bytes in
14138 big-endian order. */
14139 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14140 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14141 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14142 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14143 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14144 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14145 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14146 uncompressed_size
+= start
[11];
14151 if (uncompressed_size
)
14153 if (uncompress_section_contents (& start
, uncompressed_size
,
14156 section_size
= new_size
;
14160 error (_("Unable to decompress section %s\n"),
14161 printable_section_name (filedata
, section
));
14162 /* FIXME: Print the section anyway ? */
14167 start
= real_start
;
14172 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
14177 /* If the section being dumped has relocations against it the user might
14178 be expecting these relocations to have been applied. Check for this
14179 case and issue a warning message in order to avoid confusion.
14180 FIXME: Maybe we ought to have an option that dumps a section with
14181 relocs applied ? */
14182 for (relsec
= filedata
->section_headers
;
14183 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14186 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14187 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14188 || filedata
->section_headers
+ relsec
->sh_info
!= section
14189 || relsec
->sh_size
== 0
14190 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14193 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14198 addr
= section
->sh_addr
;
14199 bytes
= section_size
;
14208 lbytes
= (bytes
> 16 ? 16 : bytes
);
14210 printf (" 0x%8.8lx ", (unsigned long) addr
);
14212 for (j
= 0; j
< 16; j
++)
14215 printf ("%2.2x", data
[j
]);
14223 for (j
= 0; j
< lbytes
; j
++)
14226 if (k
>= ' ' && k
< 0x7f)
14249 #ifdef ENABLE_LIBCTF
14250 static ctf_sect_t
*
14251 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14253 buf
->cts_name
= SECTION_NAME (shdr
);
14254 buf
->cts_size
= shdr
->sh_size
;
14255 buf
->cts_entsize
= shdr
->sh_entsize
;
14260 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14261 it is passed, or a pointer to newly-allocated storage, in which case
14262 dump_ctf() will free it when it no longer needs it. */
14265 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14266 char *s
, void *arg
)
14268 const char *blanks
= arg
;
14271 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14276 /* Dump CTF errors/warnings. */
14278 dump_ctf_errs (ctf_file_t
*fp
)
14280 ctf_next_t
*it
= NULL
;
14285 /* Dump accumulated errors and warnings. */
14286 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
14288 error (_("%s: %s"), is_warning
? _("warning"): _("error"),
14292 if (err
!= ECTF_NEXT_END
)
14293 error (_("CTF error: cannot get CTF errors: `%s'"), ctf_errmsg (err
));
14296 /* Dump one CTF archive member. */
14299 dump_ctf_archive_member (ctf_file_t
*ctf
, const char *name
, void *arg
)
14301 ctf_file_t
*parent
= (ctf_file_t
*) arg
;
14302 const char *things
[] = {"Header", "Labels", "Data objects",
14303 "Function objects", "Variables", "Types", "Strings",
14305 const char **thing
;
14309 /* Only print out the name of non-default-named archive members.
14310 The name .ctf appears everywhere, even for things that aren't
14311 really archives, so printing it out is liable to be confusing.
14313 The parent, if there is one, is the default-owned archive member:
14314 avoid importing it into itself. (This does no harm, but looks
14317 if (strcmp (name
, ".ctf") != 0)
14319 printf (_("\nCTF archive member: %s:\n"), name
);
14320 ctf_import (ctf
, parent
);
14323 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14325 ctf_dump_state_t
*s
= NULL
;
14328 printf ("\n %s:\n", *thing
);
14329 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14330 (void *) " ")) != NULL
)
14332 printf ("%s\n", item
);
14336 if (ctf_errno (ctf
))
14338 error (_("Iteration failed: %s, %s\n"), *thing
,
14339 ctf_errmsg (ctf_errno (ctf
)));
14346 dump_ctf_errs (ctf
);
14351 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14353 Elf_Internal_Shdr
* parent_sec
= NULL
;
14354 Elf_Internal_Shdr
* symtab_sec
= NULL
;
14355 Elf_Internal_Shdr
* strtab_sec
= NULL
;
14356 void * data
= NULL
;
14357 void * symdata
= NULL
;
14358 void * strdata
= NULL
;
14359 void * parentdata
= NULL
;
14360 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
14361 ctf_sect_t
* symsectp
= NULL
;
14362 ctf_sect_t
* strsectp
= NULL
;
14363 ctf_archive_t
* ctfa
= NULL
;
14364 ctf_archive_t
* parenta
= NULL
, *lookparent
;
14365 ctf_file_t
* parent
= NULL
;
14368 bfd_boolean ret
= FALSE
;
14370 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
14371 data
= get_section_contents (section
, filedata
);
14372 ctfsect
.cts_data
= data
;
14374 if (!dump_ctf_symtab_name
)
14375 dump_ctf_symtab_name
= strdup (".symtab");
14377 if (!dump_ctf_strtab_name
)
14378 dump_ctf_strtab_name
= strdup (".strtab");
14380 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
14382 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
14384 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
14387 if ((symdata
= (void *) get_data (NULL
, filedata
,
14388 symtab_sec
->sh_offset
, 1,
14389 symtab_sec
->sh_size
,
14390 _("symbols"))) == NULL
)
14392 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
14393 symsect
.cts_data
= symdata
;
14395 if (dump_ctf_strtab_name
&& dump_ctf_strtab_name
[0] != 0)
14397 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
14399 error (_("No string table section named %s\n"),
14400 dump_ctf_strtab_name
);
14403 if ((strdata
= (void *) get_data (NULL
, filedata
,
14404 strtab_sec
->sh_offset
, 1,
14405 strtab_sec
->sh_size
,
14406 _("strings"))) == NULL
)
14408 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
14409 strsect
.cts_data
= strdata
;
14411 if (dump_ctf_parent_name
)
14413 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
14415 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
14418 if ((parentdata
= (void *) get_data (NULL
, filedata
,
14419 parent_sec
->sh_offset
, 1,
14420 parent_sec
->sh_size
,
14421 _("CTF parent"))) == NULL
)
14423 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
14424 parentsect
.cts_data
= parentdata
;
14427 /* Load the CTF file and dump it. It may be a raw CTF section, or an archive:
14428 libctf papers over the difference, so we can pretend it is always an
14429 archive. Possibly open the parent as well, if one was specified. */
14431 if ((ctfa
= ctf_arc_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14433 dump_ctf_errs (NULL
);
14434 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14440 if ((parenta
= ctf_arc_bufopen (&parentsect
, symsectp
, strsectp
,
14443 dump_ctf_errs (NULL
);
14444 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14447 lookparent
= parenta
;
14452 /* Assume that the applicable parent archive member is the default one.
14453 (This is what all known implementations are expected to do, if they
14454 put CTFs and their parents in archives together.) */
14455 if ((parent
= ctf_arc_open_by_name (lookparent
, NULL
, &err
)) == NULL
)
14457 dump_ctf_errs (NULL
);
14458 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14464 printf (_("\nDump of CTF section '%s':\n"),
14465 printable_section_name (filedata
, section
));
14467 if (ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
) != 0)
14471 ctf_file_close (parent
);
14473 ctf_close (parenta
);
14483 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14484 const Elf_Internal_Shdr
* sec
,
14487 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14489 Filedata
* filedata
= (Filedata
*) data
;
14491 if (section
->start
!= NULL
)
14493 /* If it is already loaded, do nothing. */
14494 if (streq (section
->filename
, filedata
->file_name
))
14496 free (section
->start
);
14499 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14500 section
->address
= sec
->sh_addr
;
14501 section
->user_data
= NULL
;
14502 section
->filename
= filedata
->file_name
;
14503 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14505 sec
->sh_size
, buf
);
14506 if (section
->start
== NULL
)
14510 unsigned char *start
= section
->start
;
14511 dwarf_size_type size
= sec
->sh_size
;
14512 dwarf_size_type uncompressed_size
= 0;
14514 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14516 Elf_Internal_Chdr chdr
;
14517 unsigned int compression_header_size
;
14519 if (size
< (is_32bit_elf
14520 ? sizeof (Elf32_External_Chdr
)
14521 : sizeof (Elf64_External_Chdr
)))
14523 warn (_("compressed section %s is too small to contain a compression header\n"),
14528 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14529 if (compression_header_size
== 0)
14530 /* An error message will have already been generated
14531 by get_compression_header. */
14534 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14536 warn (_("section '%s' has unsupported compress type: %d\n"),
14537 section
->name
, chdr
.ch_type
);
14540 uncompressed_size
= chdr
.ch_size
;
14541 start
+= compression_header_size
;
14542 size
-= compression_header_size
;
14544 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14546 /* Read the zlib header. In this case, it should be "ZLIB"
14547 followed by the uncompressed section size, 8 bytes in
14548 big-endian order. */
14549 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14550 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14551 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14552 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14553 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14554 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14555 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14556 uncompressed_size
+= start
[11];
14561 if (uncompressed_size
)
14563 if (uncompress_section_contents (&start
, uncompressed_size
,
14566 /* Free the compressed buffer, update the section buffer
14567 and the section size if uncompress is successful. */
14568 free (section
->start
);
14569 section
->start
= start
;
14573 error (_("Unable to decompress section %s\n"),
14574 printable_section_name (filedata
, sec
));
14579 section
->size
= size
;
14582 if (section
->start
== NULL
)
14585 if (debug_displays
[debug
].relocate
)
14587 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14588 & section
->reloc_info
, & section
->num_relocs
))
14593 section
->reloc_info
= NULL
;
14594 section
->num_relocs
= 0;
14600 #if HAVE_LIBDEBUGINFOD
14601 /* Return a hex string representation of the build-id. */
14603 get_build_id (void * data
)
14605 Filedata
* filedata
= (Filedata
*)data
;
14606 Elf_Internal_Shdr
* shdr
;
14609 /* Iterate through notes to find note.gnu.build-id.
14610 FIXME: Only the first note in any note section is examined. */
14611 for (i
= 0, shdr
= filedata
->section_headers
;
14612 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
14615 if (shdr
->sh_type
!= SHT_NOTE
)
14620 size_t data_remaining
;
14622 Elf_External_Note
* enote
;
14623 Elf_Internal_Note inote
;
14625 bfd_vma offset
= shdr
->sh_offset
;
14626 bfd_vma align
= shdr
->sh_addralign
;
14627 bfd_vma length
= shdr
->sh_size
;
14629 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
14635 else if (align
!= 4 && align
!= 8)
14641 end
= (char *) enote
+ length
;
14642 data_remaining
= end
- (char *) enote
;
14644 if (!is_ia64_vms (filedata
))
14646 min_notesz
= offsetof (Elf_External_Note
, name
);
14647 if (data_remaining
< min_notesz
)
14650 malformed note encountered in section %s whilst scanning for build-id note\n"),
14651 printable_section_name (filedata
, shdr
));
14655 data_remaining
-= min_notesz
;
14657 inote
.type
= BYTE_GET (enote
->type
);
14658 inote
.namesz
= BYTE_GET (enote
->namesz
);
14659 inote
.namedata
= enote
->name
;
14660 inote
.descsz
= BYTE_GET (enote
->descsz
);
14661 inote
.descdata
= ((char *) enote
14662 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
14663 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14664 next
= ((char *) enote
14665 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
14669 Elf64_External_VMS_Note
*vms_enote
;
14671 /* PR binutils/15191
14672 Make sure that there is enough data to read. */
14673 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14674 if (data_remaining
< min_notesz
)
14677 malformed note encountered in section %s whilst scanning for build-id note\n"),
14678 printable_section_name (filedata
, shdr
));
14682 data_remaining
-= min_notesz
;
14684 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
14685 inote
.type
= BYTE_GET (vms_enote
->type
);
14686 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
14687 inote
.namedata
= vms_enote
->name
;
14688 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
14689 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14690 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14691 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14694 /* Skip malformed notes. */
14695 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
14696 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
14697 || (size_t) (next
- inote
.descdata
) < inote
.descsz
14698 || ((size_t) (next
- inote
.descdata
)
14699 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
14702 malformed note encountered in section %s whilst scanning for build-id note\n"),
14703 printable_section_name (filedata
, shdr
));
14708 /* Check if this is the build-id note. If so then convert the build-id
14709 bytes to a hex string. */
14710 if (inote
.namesz
> 0
14711 && const_strneq (inote
.namedata
, "GNU")
14712 && inote
.type
== NT_GNU_BUILD_ID
)
14717 build_id
= malloc (inote
.descsz
* 2 + 1);
14718 if (build_id
== NULL
)
14724 for (j
= 0; j
< inote
.descsz
; ++j
)
14725 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
14726 build_id
[inote
.descsz
* 2] = '\0';
14729 return (unsigned char *) build_id
;
14736 #endif /* HAVE_LIBDEBUGINFOD */
14738 /* If this is not NULL, load_debug_section will only look for sections
14739 within the list of sections given here. */
14740 static unsigned int * section_subset
= NULL
;
14743 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
14745 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14746 Elf_Internal_Shdr
* sec
;
14747 Filedata
* filedata
= (Filedata
*) data
;
14749 /* Without section headers we cannot find any sections. */
14750 if (filedata
->section_headers
== NULL
)
14753 if (filedata
->string_table
== NULL
14754 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
14755 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
14757 Elf_Internal_Shdr
* strs
;
14759 /* Read in the string table, so that we have section names to scan. */
14760 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
14762 if (strs
!= NULL
&& strs
->sh_size
!= 0)
14764 filedata
->string_table
14765 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
14766 1, strs
->sh_size
, _("string table"));
14768 filedata
->string_table_length
14769 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
14773 /* Locate the debug section. */
14774 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
14776 section
->name
= section
->uncompressed_name
;
14779 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
14781 section
->name
= section
->compressed_name
;
14786 /* If we're loading from a subset of sections, and we've loaded
14787 a section matching this name before, it's likely that it's a
14789 if (section_subset
!= NULL
)
14790 free_debug_section (debug
);
14792 return load_specific_debug_section (debug
, sec
, data
);
14796 free_debug_section (enum dwarf_section_display_enum debug
)
14798 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14800 if (section
->start
== NULL
)
14803 free ((char *) section
->start
);
14804 section
->start
= NULL
;
14805 section
->address
= 0;
14808 free (section
->reloc_info
);
14809 section
->reloc_info
= NULL
;
14810 section
->num_relocs
= 0;
14814 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14816 char * name
= SECTION_NAME (section
);
14817 const char * print_name
= printable_section_name (filedata
, section
);
14818 bfd_size_type length
;
14819 bfd_boolean result
= TRUE
;
14822 length
= section
->sh_size
;
14825 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
14828 if (section
->sh_type
== SHT_NOBITS
)
14830 /* There is no point in dumping the contents of a debugging section
14831 which has the NOBITS type - the bits in the file will be random.
14832 This can happen when a file containing a .eh_frame section is
14833 stripped with the --only-keep-debug command line option. */
14834 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14839 if (const_strneq (name
, ".gnu.linkonce.wi."))
14840 name
= ".debug_info";
14842 /* See if we know how to display the contents of this section. */
14843 for (i
= 0; i
< max
; i
++)
14845 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
14846 struct dwarf_section_display
* display
= debug_displays
+ i
;
14847 struct dwarf_section
* sec
= & display
->section
;
14849 if (streq (sec
->uncompressed_name
, name
)
14850 || (id
== line
&& const_strneq (name
, ".debug_line."))
14851 || streq (sec
->compressed_name
, name
))
14853 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
14856 free_debug_section (id
);
14858 if (i
== line
&& const_strneq (name
, ".debug_line."))
14860 else if (streq (sec
->uncompressed_name
, name
))
14861 sec
->name
= sec
->uncompressed_name
;
14863 sec
->name
= sec
->compressed_name
;
14865 if (load_specific_debug_section (id
, section
, filedata
))
14867 /* If this debug section is part of a CU/TU set in a .dwp file,
14868 restrict load_debug_section to the sections in that set. */
14869 section_subset
= find_cu_tu_set (filedata
, shndx
);
14871 result
&= display
->display (sec
, filedata
);
14873 section_subset
= NULL
;
14875 if (secondary
|| (id
!= info
&& id
!= abbrev
))
14876 free_debug_section (id
);
14884 printf (_("Unrecognized debug section: %s\n"), print_name
);
14891 /* Set DUMP_SECTS for all sections where dumps were requested
14892 based on section name. */
14895 initialise_dumps_byname (Filedata
* filedata
)
14897 struct dump_list_entry
* cur
;
14899 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14902 bfd_boolean any
= FALSE
;
14904 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14905 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14907 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
14912 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14918 process_section_contents (Filedata
* filedata
)
14920 Elf_Internal_Shdr
* section
;
14922 bfd_boolean res
= TRUE
;
14927 initialise_dumps_byname (filedata
);
14929 for (i
= 0, section
= filedata
->section_headers
;
14930 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
14933 dump_type dump
= filedata
->dump
.dump_sects
[i
];
14935 #ifdef SUPPORT_DISASSEMBLY
14936 if (dump
& DISASS_DUMP
)
14938 if (! disassemble_section (section
, filedata
))
14942 if (dump
& HEX_DUMP
)
14944 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14948 if (dump
& RELOC_DUMP
)
14950 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14954 if (dump
& STRING_DUMP
)
14956 if (! dump_section_as_strings (section
, filedata
))
14960 if (dump
& DEBUG_DUMP
)
14962 if (! display_debug_section (i
, section
, filedata
))
14966 #ifdef ENABLE_LIBCTF
14967 if (dump
& CTF_DUMP
)
14969 if (! dump_section_as_ctf (section
, filedata
))
14975 /* Check to see if the user requested a
14976 dump of a section that does not exist. */
14977 while (i
< filedata
->dump
.num_dump_sects
)
14979 if (filedata
->dump
.dump_sects
[i
])
14981 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14991 process_mips_fpe_exception (int mask
)
14995 bfd_boolean first
= TRUE
;
14997 if (mask
& OEX_FPU_INEX
)
14998 fputs ("INEX", stdout
), first
= FALSE
;
14999 if (mask
& OEX_FPU_UFLO
)
15000 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
15001 if (mask
& OEX_FPU_OFLO
)
15002 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
15003 if (mask
& OEX_FPU_DIV0
)
15004 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
15005 if (mask
& OEX_FPU_INVAL
)
15006 printf ("%sINVAL", first
? "" : "|");
15009 fputs ("0", stdout
);
15012 /* Display's the value of TAG at location P. If TAG is
15013 greater than 0 it is assumed to be an unknown tag, and
15014 a message is printed to this effect. Otherwise it is
15015 assumed that a message has already been printed.
15017 If the bottom bit of TAG is set it assumed to have a
15018 string value, otherwise it is assumed to have an integer
15021 Returns an updated P pointing to the first unread byte
15022 beyond the end of TAG's value.
15024 Reads at or beyond END will not be made. */
15026 static unsigned char *
15027 display_tag_value (signed int tag
,
15029 const unsigned char * const end
)
15034 printf (" Tag_unknown_%d: ", tag
);
15038 warn (_("<corrupt tag>\n"));
15042 /* PR 17531 file: 027-19978-0.004. */
15043 size_t maxlen
= (end
- p
) - 1;
15048 print_symbol ((int) maxlen
, (const char *) p
);
15049 p
+= strnlen ((char *) p
, maxlen
) + 1;
15053 printf (_("<corrupt string tag>"));
15054 p
= (unsigned char *) end
;
15060 READ_ULEB (val
, p
, end
);
15061 printf ("%ld (0x%lx)\n", val
, val
);
15068 /* ARC ABI attributes section. */
15070 static unsigned char *
15071 display_arc_attribute (unsigned char * p
,
15072 const unsigned char * const end
)
15077 READ_ULEB (tag
, p
, end
);
15081 case Tag_ARC_PCS_config
:
15082 READ_ULEB (val
, p
, end
);
15083 printf (" Tag_ARC_PCS_config: ");
15087 printf (_("Absent/Non standard\n"));
15090 printf (_("Bare metal/mwdt\n"));
15093 printf (_("Bare metal/newlib\n"));
15096 printf (_("Linux/uclibc\n"));
15099 printf (_("Linux/glibc\n"));
15102 printf (_("Unknown\n"));
15107 case Tag_ARC_CPU_base
:
15108 READ_ULEB (val
, p
, end
);
15109 printf (" Tag_ARC_CPU_base: ");
15114 printf (_("Absent\n"));
15116 case TAG_CPU_ARC6xx
:
15117 printf ("ARC6xx\n");
15119 case TAG_CPU_ARC7xx
:
15120 printf ("ARC7xx\n");
15122 case TAG_CPU_ARCEM
:
15123 printf ("ARCEM\n");
15125 case TAG_CPU_ARCHS
:
15126 printf ("ARCHS\n");
15131 case Tag_ARC_CPU_variation
:
15132 READ_ULEB (val
, p
, end
);
15133 printf (" Tag_ARC_CPU_variation: ");
15137 if (val
> 0 && val
< 16)
15138 printf ("Core%d\n", val
);
15140 printf ("Unknown\n");
15144 printf (_("Absent\n"));
15149 case Tag_ARC_CPU_name
:
15150 printf (" Tag_ARC_CPU_name: ");
15151 p
= display_tag_value (-1, p
, end
);
15154 case Tag_ARC_ABI_rf16
:
15155 READ_ULEB (val
, p
, end
);
15156 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
15159 case Tag_ARC_ABI_osver
:
15160 READ_ULEB (val
, p
, end
);
15161 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
15164 case Tag_ARC_ABI_pic
:
15165 case Tag_ARC_ABI_sda
:
15166 READ_ULEB (val
, p
, end
);
15167 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
15168 : " Tag_ARC_ABI_pic: ");
15172 printf (_("Absent\n"));
15181 printf (_("Unknown\n"));
15186 case Tag_ARC_ABI_tls
:
15187 READ_ULEB (val
, p
, end
);
15188 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
15191 case Tag_ARC_ABI_enumsize
:
15192 READ_ULEB (val
, p
, end
);
15193 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
15197 case Tag_ARC_ABI_exceptions
:
15198 READ_ULEB (val
, p
, end
);
15199 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
15203 case Tag_ARC_ABI_double_size
:
15204 READ_ULEB (val
, p
, end
);
15205 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
15208 case Tag_ARC_ISA_config
:
15209 printf (" Tag_ARC_ISA_config: ");
15210 p
= display_tag_value (-1, p
, end
);
15213 case Tag_ARC_ISA_apex
:
15214 printf (" Tag_ARC_ISA_apex: ");
15215 p
= display_tag_value (-1, p
, end
);
15218 case Tag_ARC_ISA_mpy_option
:
15219 READ_ULEB (val
, p
, end
);
15220 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
15223 case Tag_ARC_ATR_version
:
15224 READ_ULEB (val
, p
, end
);
15225 printf (" Tag_ARC_ATR_version: %d\n", val
);
15229 return display_tag_value (tag
& 1, p
, end
);
15235 /* ARM EABI attributes section. */
15240 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
15242 const char ** table
;
15243 } arm_attr_public_tag
;
15245 static const char * arm_attr_tag_CPU_arch
[] =
15246 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
15247 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
15248 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
15249 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
15250 static const char * arm_attr_tag_THUMB_ISA_use
[] =
15251 {"No", "Thumb-1", "Thumb-2", "Yes"};
15252 static const char * arm_attr_tag_FP_arch
[] =
15253 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
15254 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
15255 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
15256 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
15257 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
15258 "NEON for ARMv8.1"};
15259 static const char * arm_attr_tag_PCS_config
[] =
15260 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
15261 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
15262 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
15263 {"V6", "SB", "TLS", "Unused"};
15264 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
15265 {"Absolute", "PC-relative", "SB-relative", "None"};
15266 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
15267 {"Absolute", "PC-relative", "None"};
15268 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
15269 {"None", "direct", "GOT-indirect"};
15270 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
15271 {"None", "??? 1", "2", "??? 3", "4"};
15272 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
15273 static const char * arm_attr_tag_ABI_FP_denormal
[] =
15274 {"Unused", "Needed", "Sign only"};
15275 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
15276 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
15277 static const char * arm_attr_tag_ABI_FP_number_model
[] =
15278 {"Unused", "Finite", "RTABI", "IEEE 754"};
15279 static const char * arm_attr_tag_ABI_enum_size
[] =
15280 {"Unused", "small", "int", "forced to int"};
15281 static const char * arm_attr_tag_ABI_HardFP_use
[] =
15282 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
15283 static const char * arm_attr_tag_ABI_VFP_args
[] =
15284 {"AAPCS", "VFP registers", "custom", "compatible"};
15285 static const char * arm_attr_tag_ABI_WMMX_args
[] =
15286 {"AAPCS", "WMMX registers", "custom"};
15287 static const char * arm_attr_tag_ABI_optimization_goals
[] =
15288 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15289 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
15290 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
15291 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15292 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
15293 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
15294 static const char * arm_attr_tag_FP_HP_extension
[] =
15295 {"Not Allowed", "Allowed"};
15296 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
15297 {"None", "IEEE 754", "Alternative Format"};
15298 static const char * arm_attr_tag_DSP_extension
[] =
15299 {"Follow architecture", "Allowed"};
15300 static const char * arm_attr_tag_MPextension_use
[] =
15301 {"Not Allowed", "Allowed"};
15302 static const char * arm_attr_tag_DIV_use
[] =
15303 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
15304 "Allowed in v7-A with integer division extension"};
15305 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
15306 static const char * arm_attr_tag_Virtualization_use
[] =
15307 {"Not Allowed", "TrustZone", "Virtualization Extensions",
15308 "TrustZone and Virtualization Extensions"};
15309 static const char * arm_attr_tag_MPextension_use_legacy
[] =
15310 {"Not Allowed", "Allowed"};
15312 static const char * arm_attr_tag_MVE_arch
[] =
15313 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
15315 #define LOOKUP(id, name) \
15316 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
15317 static arm_attr_public_tag arm_attr_public_tags
[] =
15319 {4, "CPU_raw_name", 1, NULL
},
15320 {5, "CPU_name", 1, NULL
},
15321 LOOKUP(6, CPU_arch
),
15322 {7, "CPU_arch_profile", 0, NULL
},
15323 LOOKUP(8, ARM_ISA_use
),
15324 LOOKUP(9, THUMB_ISA_use
),
15325 LOOKUP(10, FP_arch
),
15326 LOOKUP(11, WMMX_arch
),
15327 LOOKUP(12, Advanced_SIMD_arch
),
15328 LOOKUP(13, PCS_config
),
15329 LOOKUP(14, ABI_PCS_R9_use
),
15330 LOOKUP(15, ABI_PCS_RW_data
),
15331 LOOKUP(16, ABI_PCS_RO_data
),
15332 LOOKUP(17, ABI_PCS_GOT_use
),
15333 LOOKUP(18, ABI_PCS_wchar_t
),
15334 LOOKUP(19, ABI_FP_rounding
),
15335 LOOKUP(20, ABI_FP_denormal
),
15336 LOOKUP(21, ABI_FP_exceptions
),
15337 LOOKUP(22, ABI_FP_user_exceptions
),
15338 LOOKUP(23, ABI_FP_number_model
),
15339 {24, "ABI_align_needed", 0, NULL
},
15340 {25, "ABI_align_preserved", 0, NULL
},
15341 LOOKUP(26, ABI_enum_size
),
15342 LOOKUP(27, ABI_HardFP_use
),
15343 LOOKUP(28, ABI_VFP_args
),
15344 LOOKUP(29, ABI_WMMX_args
),
15345 LOOKUP(30, ABI_optimization_goals
),
15346 LOOKUP(31, ABI_FP_optimization_goals
),
15347 {32, "compatibility", 0, NULL
},
15348 LOOKUP(34, CPU_unaligned_access
),
15349 LOOKUP(36, FP_HP_extension
),
15350 LOOKUP(38, ABI_FP_16bit_format
),
15351 LOOKUP(42, MPextension_use
),
15352 LOOKUP(44, DIV_use
),
15353 LOOKUP(46, DSP_extension
),
15354 LOOKUP(48, MVE_arch
),
15355 {64, "nodefaults", 0, NULL
},
15356 {65, "also_compatible_with", 0, NULL
},
15357 LOOKUP(66, T2EE_use
),
15358 {67, "conformance", 1, NULL
},
15359 LOOKUP(68, Virtualization_use
),
15360 LOOKUP(70, MPextension_use_legacy
)
15364 static unsigned char *
15365 display_arm_attribute (unsigned char * p
,
15366 const unsigned char * const end
)
15370 arm_attr_public_tag
* attr
;
15374 READ_ULEB (tag
, p
, end
);
15376 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
15378 if (arm_attr_public_tags
[i
].tag
== tag
)
15380 attr
= &arm_attr_public_tags
[i
];
15387 printf (" Tag_%s: ", attr
->name
);
15388 switch (attr
->type
)
15393 case 7: /* Tag_CPU_arch_profile. */
15394 READ_ULEB (val
, p
, end
);
15397 case 0: printf (_("None\n")); break;
15398 case 'A': printf (_("Application\n")); break;
15399 case 'R': printf (_("Realtime\n")); break;
15400 case 'M': printf (_("Microcontroller\n")); break;
15401 case 'S': printf (_("Application or Realtime\n")); break;
15402 default: printf ("??? (%d)\n", val
); break;
15406 case 24: /* Tag_align_needed. */
15407 READ_ULEB (val
, p
, end
);
15410 case 0: printf (_("None\n")); break;
15411 case 1: printf (_("8-byte\n")); break;
15412 case 2: printf (_("4-byte\n")); break;
15413 case 3: printf ("??? 3\n"); break;
15416 printf (_("8-byte and up to %d-byte extended\n"),
15419 printf ("??? (%d)\n", val
);
15424 case 25: /* Tag_align_preserved. */
15425 READ_ULEB (val
, p
, end
);
15428 case 0: printf (_("None\n")); break;
15429 case 1: printf (_("8-byte, except leaf SP\n")); break;
15430 case 2: printf (_("8-byte\n")); break;
15431 case 3: printf ("??? 3\n"); break;
15434 printf (_("8-byte and up to %d-byte extended\n"),
15437 printf ("??? (%d)\n", val
);
15442 case 32: /* Tag_compatibility. */
15444 READ_ULEB (val
, p
, end
);
15445 printf (_("flag = %d, vendor = "), val
);
15448 size_t maxlen
= (end
- p
) - 1;
15450 print_symbol ((int) maxlen
, (const char *) p
);
15451 p
+= strnlen ((char *) p
, maxlen
) + 1;
15455 printf (_("<corrupt>"));
15456 p
= (unsigned char *) end
;
15462 case 64: /* Tag_nodefaults. */
15463 /* PR 17531: file: 001-505008-0.01. */
15466 printf (_("True\n"));
15469 case 65: /* Tag_also_compatible_with. */
15470 READ_ULEB (val
, p
, end
);
15471 if (val
== 6 /* Tag_CPU_arch. */)
15473 READ_ULEB (val
, p
, end
);
15474 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
15475 printf ("??? (%d)\n", val
);
15477 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
15481 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
15486 printf (_("<unknown: %d>\n"), tag
);
15492 return display_tag_value (-1, p
, end
);
15494 return display_tag_value (0, p
, end
);
15497 assert (attr
->type
& 0x80);
15498 READ_ULEB (val
, p
, end
);
15499 type
= attr
->type
& 0x7f;
15501 printf ("??? (%d)\n", val
);
15503 printf ("%s\n", attr
->table
[val
]);
15508 return display_tag_value (tag
, p
, end
);
15511 static unsigned char *
15512 display_gnu_attribute (unsigned char * p
,
15513 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
15514 const unsigned char * const end
)
15519 READ_ULEB (tag
, p
, end
);
15521 /* Tag_compatibility is the only generic GNU attribute defined at
15525 READ_ULEB (val
, p
, end
);
15527 printf (_("flag = %d, vendor = "), val
);
15530 printf (_("<corrupt>\n"));
15531 warn (_("corrupt vendor attribute\n"));
15537 size_t maxlen
= (end
- p
) - 1;
15539 print_symbol ((int) maxlen
, (const char *) p
);
15540 p
+= strnlen ((char *) p
, maxlen
) + 1;
15544 printf (_("<corrupt>"));
15545 p
= (unsigned char *) end
;
15552 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15553 return display_proc_gnu_attribute (p
, tag
, end
);
15555 return display_tag_value (tag
, p
, end
);
15558 static unsigned char *
15559 display_m68k_gnu_attribute (unsigned char * p
,
15561 const unsigned char * const end
)
15565 if (tag
== Tag_GNU_M68K_ABI_FP
)
15567 printf (" Tag_GNU_M68K_ABI_FP: ");
15570 printf (_("<corrupt>\n"));
15573 READ_ULEB (val
, p
, end
);
15576 printf ("(%#x), ", val
);
15581 printf (_("unspecified hard/soft float\n"));
15584 printf (_("hard float\n"));
15587 printf (_("soft float\n"));
15593 return display_tag_value (tag
& 1, p
, end
);
15596 static unsigned char *
15597 display_power_gnu_attribute (unsigned char * p
,
15599 const unsigned char * const end
)
15603 if (tag
== Tag_GNU_Power_ABI_FP
)
15605 printf (" Tag_GNU_Power_ABI_FP: ");
15608 printf (_("<corrupt>\n"));
15611 READ_ULEB (val
, p
, end
);
15614 printf ("(%#x), ", val
);
15619 printf (_("unspecified hard/soft float, "));
15622 printf (_("hard float, "));
15625 printf (_("soft float, "));
15628 printf (_("single-precision hard float, "));
15635 printf (_("unspecified long double\n"));
15638 printf (_("128-bit IBM long double\n"));
15641 printf (_("64-bit long double\n"));
15644 printf (_("128-bit IEEE long double\n"));
15650 if (tag
== Tag_GNU_Power_ABI_Vector
)
15652 printf (" Tag_GNU_Power_ABI_Vector: ");
15655 printf (_("<corrupt>\n"));
15658 READ_ULEB (val
, p
, end
);
15661 printf ("(%#x), ", val
);
15666 printf (_("unspecified\n"));
15669 printf (_("generic\n"));
15672 printf ("AltiVec\n");
15681 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
15683 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15686 printf (_("<corrupt>\n"));
15689 READ_ULEB (val
, p
, end
);
15692 printf ("(%#x), ", val
);
15697 printf (_("unspecified\n"));
15700 printf ("r3/r4\n");
15703 printf (_("memory\n"));
15712 return display_tag_value (tag
& 1, p
, end
);
15715 static unsigned char *
15716 display_s390_gnu_attribute (unsigned char * p
,
15718 const unsigned char * const end
)
15722 if (tag
== Tag_GNU_S390_ABI_Vector
)
15724 printf (" Tag_GNU_S390_ABI_Vector: ");
15725 READ_ULEB (val
, p
, end
);
15730 printf (_("any\n"));
15733 printf (_("software\n"));
15736 printf (_("hardware\n"));
15739 printf ("??? (%d)\n", val
);
15745 return display_tag_value (tag
& 1, p
, end
);
15749 display_sparc_hwcaps (unsigned int mask
)
15753 bfd_boolean first
= TRUE
;
15755 if (mask
& ELF_SPARC_HWCAP_MUL32
)
15756 fputs ("mul32", stdout
), first
= FALSE
;
15757 if (mask
& ELF_SPARC_HWCAP_DIV32
)
15758 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
15759 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
15760 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
15761 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
15762 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
15763 if (mask
& ELF_SPARC_HWCAP_POPC
)
15764 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
15765 if (mask
& ELF_SPARC_HWCAP_VIS
)
15766 printf ("%svis", first
? "" : "|"), first
= FALSE
;
15767 if (mask
& ELF_SPARC_HWCAP_VIS2
)
15768 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
15769 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
15770 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
15771 if (mask
& ELF_SPARC_HWCAP_FMAF
)
15772 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
15773 if (mask
& ELF_SPARC_HWCAP_VIS3
)
15774 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
15775 if (mask
& ELF_SPARC_HWCAP_HPC
)
15776 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
15777 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
15778 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
15779 if (mask
& ELF_SPARC_HWCAP_TRANS
)
15780 printf ("%strans", first
? "" : "|"), first
= FALSE
;
15781 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
15782 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
15783 if (mask
& ELF_SPARC_HWCAP_IMA
)
15784 printf ("%sima", first
? "" : "|"), first
= FALSE
;
15785 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
15786 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
15789 fputc ('0', stdout
);
15790 fputc ('\n', stdout
);
15794 display_sparc_hwcaps2 (unsigned int mask
)
15798 bfd_boolean first
= TRUE
;
15800 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
15801 fputs ("fjathplus", stdout
), first
= FALSE
;
15802 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
15803 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
15804 if (mask
& ELF_SPARC_HWCAP2_ADP
)
15805 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
15806 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
15807 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
15808 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
15809 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
15810 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
15811 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
15812 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
15813 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
15814 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
15815 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
15816 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
15817 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
15818 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
15819 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
15820 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
15821 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
15824 fputc ('0', stdout
);
15825 fputc ('\n', stdout
);
15828 static unsigned char *
15829 display_sparc_gnu_attribute (unsigned char * p
,
15831 const unsigned char * const end
)
15835 if (tag
== Tag_GNU_Sparc_HWCAPS
)
15837 READ_ULEB (val
, p
, end
);
15838 printf (" Tag_GNU_Sparc_HWCAPS: ");
15839 display_sparc_hwcaps (val
);
15842 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
15844 READ_ULEB (val
, p
, end
);
15845 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15846 display_sparc_hwcaps2 (val
);
15850 return display_tag_value (tag
, p
, end
);
15854 print_mips_fp_abi_value (unsigned int val
)
15858 case Val_GNU_MIPS_ABI_FP_ANY
:
15859 printf (_("Hard or soft float\n"));
15861 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15862 printf (_("Hard float (double precision)\n"));
15864 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15865 printf (_("Hard float (single precision)\n"));
15867 case Val_GNU_MIPS_ABI_FP_SOFT
:
15868 printf (_("Soft float\n"));
15870 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15871 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15873 case Val_GNU_MIPS_ABI_FP_XX
:
15874 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15876 case Val_GNU_MIPS_ABI_FP_64
:
15877 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15879 case Val_GNU_MIPS_ABI_FP_64A
:
15880 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15882 case Val_GNU_MIPS_ABI_FP_NAN2008
:
15883 printf (_("NaN 2008 compatibility\n"));
15886 printf ("??? (%d)\n", val
);
15891 static unsigned char *
15892 display_mips_gnu_attribute (unsigned char * p
,
15894 const unsigned char * const end
)
15896 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15900 printf (" Tag_GNU_MIPS_ABI_FP: ");
15901 READ_ULEB (val
, p
, end
);
15902 print_mips_fp_abi_value (val
);
15906 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15910 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15911 READ_ULEB (val
, p
, end
);
15915 case Val_GNU_MIPS_ABI_MSA_ANY
:
15916 printf (_("Any MSA or not\n"));
15918 case Val_GNU_MIPS_ABI_MSA_128
:
15919 printf (_("128-bit MSA\n"));
15922 printf ("??? (%d)\n", val
);
15928 return display_tag_value (tag
& 1, p
, end
);
15931 static unsigned char *
15932 display_tic6x_attribute (unsigned char * p
,
15933 const unsigned char * const end
)
15938 READ_ULEB (tag
, p
, end
);
15943 printf (" Tag_ISA: ");
15944 READ_ULEB (val
, p
, end
);
15948 case C6XABI_Tag_ISA_none
:
15949 printf (_("None\n"));
15951 case C6XABI_Tag_ISA_C62X
:
15954 case C6XABI_Tag_ISA_C67X
:
15957 case C6XABI_Tag_ISA_C67XP
:
15958 printf ("C67x+\n");
15960 case C6XABI_Tag_ISA_C64X
:
15963 case C6XABI_Tag_ISA_C64XP
:
15964 printf ("C64x+\n");
15966 case C6XABI_Tag_ISA_C674X
:
15967 printf ("C674x\n");
15970 printf ("??? (%d)\n", val
);
15975 case Tag_ABI_wchar_t
:
15976 printf (" Tag_ABI_wchar_t: ");
15977 READ_ULEB (val
, p
, end
);
15981 printf (_("Not used\n"));
15984 printf (_("2 bytes\n"));
15987 printf (_("4 bytes\n"));
15990 printf ("??? (%d)\n", val
);
15995 case Tag_ABI_stack_align_needed
:
15996 printf (" Tag_ABI_stack_align_needed: ");
15997 READ_ULEB (val
, p
, end
);
16001 printf (_("8-byte\n"));
16004 printf (_("16-byte\n"));
16007 printf ("??? (%d)\n", val
);
16012 case Tag_ABI_stack_align_preserved
:
16013 READ_ULEB (val
, p
, end
);
16014 printf (" Tag_ABI_stack_align_preserved: ");
16018 printf (_("8-byte\n"));
16021 printf (_("16-byte\n"));
16024 printf ("??? (%d)\n", val
);
16030 READ_ULEB (val
, p
, end
);
16031 printf (" Tag_ABI_DSBT: ");
16035 printf (_("DSBT addressing not used\n"));
16038 printf (_("DSBT addressing used\n"));
16041 printf ("??? (%d)\n", val
);
16047 READ_ULEB (val
, p
, end
);
16048 printf (" Tag_ABI_PID: ");
16052 printf (_("Data addressing position-dependent\n"));
16055 printf (_("Data addressing position-independent, GOT near DP\n"));
16058 printf (_("Data addressing position-independent, GOT far from DP\n"));
16061 printf ("??? (%d)\n", val
);
16067 READ_ULEB (val
, p
, end
);
16068 printf (" Tag_ABI_PIC: ");
16072 printf (_("Code addressing position-dependent\n"));
16075 printf (_("Code addressing position-independent\n"));
16078 printf ("??? (%d)\n", val
);
16083 case Tag_ABI_array_object_alignment
:
16084 READ_ULEB (val
, p
, end
);
16085 printf (" Tag_ABI_array_object_alignment: ");
16089 printf (_("8-byte\n"));
16092 printf (_("4-byte\n"));
16095 printf (_("16-byte\n"));
16098 printf ("??? (%d)\n", val
);
16103 case Tag_ABI_array_object_align_expected
:
16104 READ_ULEB (val
, p
, end
);
16105 printf (" Tag_ABI_array_object_align_expected: ");
16109 printf (_("8-byte\n"));
16112 printf (_("4-byte\n"));
16115 printf (_("16-byte\n"));
16118 printf ("??? (%d)\n", val
);
16123 case Tag_ABI_compatibility
:
16125 READ_ULEB (val
, p
, end
);
16126 printf (" Tag_ABI_compatibility: ");
16127 printf (_("flag = %d, vendor = "), val
);
16130 size_t maxlen
= (end
- p
) - 1;
16132 print_symbol ((int) maxlen
, (const char *) p
);
16133 p
+= strnlen ((char *) p
, maxlen
) + 1;
16137 printf (_("<corrupt>"));
16138 p
= (unsigned char *) end
;
16144 case Tag_ABI_conformance
:
16146 printf (" Tag_ABI_conformance: \"");
16149 size_t maxlen
= (end
- p
) - 1;
16151 print_symbol ((int) maxlen
, (const char *) p
);
16152 p
+= strnlen ((char *) p
, maxlen
) + 1;
16156 printf (_("<corrupt>"));
16157 p
= (unsigned char *) end
;
16164 return display_tag_value (tag
, p
, end
);
16168 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
16170 unsigned long addr
= 0;
16171 size_t bytes
= end
- p
;
16178 int lbytes
= (bytes
> 16 ? 16 : bytes
);
16180 printf (" 0x%8.8lx ", addr
);
16182 for (j
= 0; j
< 16; j
++)
16185 printf ("%2.2x", p
[j
]);
16193 for (j
= 0; j
< lbytes
; j
++)
16196 if (k
>= ' ' && k
< 0x7f)
16212 static unsigned char *
16213 display_msp430_attribute (unsigned char * p
,
16214 const unsigned char * const end
)
16219 READ_ULEB (tag
, p
, end
);
16223 case OFBA_MSPABI_Tag_ISA
:
16224 printf (" Tag_ISA: ");
16225 READ_ULEB (val
, p
, end
);
16228 case 0: printf (_("None\n")); break;
16229 case 1: printf (_("MSP430\n")); break;
16230 case 2: printf (_("MSP430X\n")); break;
16231 default: printf ("??? (%d)\n", val
); break;
16235 case OFBA_MSPABI_Tag_Code_Model
:
16236 printf (" Tag_Code_Model: ");
16237 READ_ULEB (val
, p
, end
);
16240 case 0: printf (_("None\n")); break;
16241 case 1: printf (_("Small\n")); break;
16242 case 2: printf (_("Large\n")); break;
16243 default: printf ("??? (%d)\n", val
); break;
16247 case OFBA_MSPABI_Tag_Data_Model
:
16248 printf (" Tag_Data_Model: ");
16249 READ_ULEB (val
, p
, end
);
16252 case 0: printf (_("None\n")); break;
16253 case 1: printf (_("Small\n")); break;
16254 case 2: printf (_("Large\n")); break;
16255 case 3: printf (_("Restricted Large\n")); break;
16256 default: printf ("??? (%d)\n", val
); break;
16261 printf (_(" <unknown tag %d>: "), tag
);
16268 size_t maxlen
= (end
- p
) - 1;
16270 print_symbol ((int) maxlen
, (const char *) p
);
16271 p
+= strnlen ((char *) p
, maxlen
) + 1;
16275 printf (_("<corrupt>"));
16276 p
= (unsigned char *) end
;
16282 READ_ULEB (val
, p
, end
);
16283 printf ("%d (0x%x)\n", val
, val
);
16292 static unsigned char *
16293 display_msp430_gnu_attribute (unsigned char * p
,
16295 const unsigned char * const end
)
16297 if (tag
== Tag_GNU_MSP430_Data_Region
)
16301 printf (" Tag_GNU_MSP430_Data_Region: ");
16302 READ_ULEB (val
, p
, end
);
16306 case Val_GNU_MSP430_Data_Region_Any
:
16307 printf (_("Any Region\n"));
16309 case Val_GNU_MSP430_Data_Region_Lower
:
16310 printf (_("Lower Region Only\n"));
16313 printf ("??? (%u)\n", val
);
16317 return display_tag_value (tag
& 1, p
, end
);
16320 struct riscv_attr_tag_t
{
16325 static struct riscv_attr_tag_t riscv_attr_tag
[] =
16327 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
16330 T(priv_spec_minor
),
16331 T(priv_spec_revision
),
16332 T(unaligned_access
),
16337 static unsigned char *
16338 display_riscv_attribute (unsigned char *p
,
16339 const unsigned char * const end
)
16343 struct riscv_attr_tag_t
*attr
= NULL
;
16346 READ_ULEB (tag
, p
, end
);
16348 /* Find the name of attribute. */
16349 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
16351 if (riscv_attr_tag
[i
].tag
== tag
)
16353 attr
= &riscv_attr_tag
[i
];
16359 printf (" %s: ", attr
->name
);
16361 return display_tag_value (tag
, p
, end
);
16365 case Tag_RISCV_priv_spec
:
16366 case Tag_RISCV_priv_spec_minor
:
16367 case Tag_RISCV_priv_spec_revision
:
16368 READ_ULEB (val
, p
, end
);
16369 printf (_("%u\n"), val
);
16371 case Tag_RISCV_unaligned_access
:
16372 READ_ULEB (val
, p
, end
);
16376 printf (_("No unaligned access\n"));
16379 printf (_("Unaligned access\n"));
16383 case Tag_RISCV_stack_align
:
16384 READ_ULEB (val
, p
, end
);
16385 printf (_("%u-bytes\n"), val
);
16387 case Tag_RISCV_arch
:
16388 p
= display_tag_value (-1, p
, end
);
16391 return display_tag_value (tag
, p
, end
);
16397 static unsigned char *
16398 display_csky_attribute (unsigned char * p
,
16399 const unsigned char * const end
)
16403 READ_ULEB (tag
, p
, end
);
16405 if (tag
>= Tag_CSKY_MAX
)
16407 return display_tag_value (-1, p
, end
);
16412 case Tag_CSKY_ARCH_NAME
:
16413 printf (" Tag_CSKY_ARCH_NAME:\t\t");
16414 return display_tag_value (-1, p
, end
);
16415 case Tag_CSKY_CPU_NAME
:
16416 printf (" Tag_CSKY_CPU_NAME:\t\t");
16417 return display_tag_value (-1, p
, end
);
16419 case Tag_CSKY_ISA_FLAGS
:
16420 printf (" Tag_CSKY_ISA_FLAGS:\t\t");
16421 return display_tag_value (0, p
, end
);
16422 case Tag_CSKY_ISA_EXT_FLAGS
:
16423 printf (" Tag_CSKY_ISA_EXT_FLAGS:\t");
16424 return display_tag_value (0, p
, end
);
16426 case Tag_CSKY_DSP_VERSION
:
16427 printf (" Tag_CSKY_DSP_VERSION:\t\t");
16428 READ_ULEB (val
, p
, end
);
16429 if (val
== VAL_CSKY_DSP_VERSION_EXTENSION
)
16430 printf ("DSP Extension\n");
16431 else if (val
== VAL_CSKY_DSP_VERSION_2
)
16432 printf ("DSP 2.0\n");
16435 case Tag_CSKY_VDSP_VERSION
:
16436 printf (" Tag_CSKY_VDSP_VERSION:\t");
16437 READ_ULEB (val
, p
, end
);
16438 printf ("VDSP Version %d\n", val
);
16441 case Tag_CSKY_FPU_VERSION
:
16442 printf (" Tag_CSKY_FPU_VERSION:\t\t");
16443 READ_ULEB (val
, p
, end
);
16444 if (val
== VAL_CSKY_FPU_VERSION_1
)
16445 printf ("ABIV1 FPU Version 1\n");
16446 else if (val
== VAL_CSKY_FPU_VERSION_2
)
16447 printf ("FPU Version 2\n");
16450 case Tag_CSKY_FPU_ABI
:
16451 printf (" Tag_CSKY_FPU_ABI:\t\t");
16452 READ_ULEB (val
, p
, end
);
16453 if (val
== VAL_CSKY_FPU_ABI_HARD
)
16455 else if (val
== VAL_CSKY_FPU_ABI_SOFTFP
)
16456 printf ("SoftFP\n");
16457 else if (val
== VAL_CSKY_FPU_ABI_SOFT
)
16460 case Tag_CSKY_FPU_ROUNDING
:
16461 READ_ULEB (val
, p
, end
);
16463 printf (" Tag_CSKY_FPU_ROUNDING:\t");
16464 printf ("Needed\n");
16467 case Tag_CSKY_FPU_DENORMAL
:
16468 READ_ULEB (val
, p
, end
);
16470 printf (" Tag_CSKY_FPU_DENORMAL:\t");
16471 printf ("Needed\n");
16474 case Tag_CSKY_FPU_Exception
:
16475 READ_ULEB (val
, p
, end
);
16477 printf (" Tag_CSKY_FPU_Exception:\t");
16478 printf ("Needed\n");
16481 case Tag_CSKY_FPU_NUMBER_MODULE
:
16482 printf (" Tag_CSKY_FPU_NUMBER_MODULE:\t");
16483 return display_tag_value (-1, p
, end
);
16484 case Tag_CSKY_FPU_HARDFP
:
16485 printf (" Tag_CSKY_FPU_HARDFP:\t\t");
16486 READ_ULEB (val
, p
, end
);
16487 if (val
& VAL_CSKY_FPU_HARDFP_HALF
)
16489 if (val
& VAL_CSKY_FPU_HARDFP_SINGLE
)
16490 printf (" Single");
16491 if (val
& VAL_CSKY_FPU_HARDFP_DOUBLE
)
16492 printf (" Double");
16496 return display_tag_value (tag
, p
, end
);
16502 process_attributes (Filedata
* filedata
,
16503 const char * public_name
,
16504 unsigned int proc_type
,
16505 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
16506 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
16508 Elf_Internal_Shdr
* sect
;
16510 bfd_boolean res
= TRUE
;
16512 /* Find the section header so that we get the size. */
16513 for (i
= 0, sect
= filedata
->section_headers
;
16514 i
< filedata
->file_header
.e_shnum
;
16517 unsigned char * contents
;
16520 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
16523 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16524 sect
->sh_size
, _("attributes"));
16525 if (contents
== NULL
)
16532 /* The first character is the version of the attributes.
16533 Currently only version 1, (aka 'A') is recognised here. */
16536 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
16541 bfd_vma section_len
;
16543 section_len
= sect
->sh_size
- 1;
16546 while (section_len
> 0)
16549 unsigned int namelen
;
16550 bfd_boolean public_section
;
16551 bfd_boolean gnu_section
;
16553 if (section_len
<= 4)
16555 error (_("Tag section ends prematurely\n"));
16559 attr_len
= byte_get (p
, 4);
16562 if (attr_len
> section_len
)
16564 error (_("Bad attribute length (%u > %u)\n"),
16565 (unsigned) attr_len
, (unsigned) section_len
);
16566 attr_len
= section_len
;
16569 /* PR 17531: file: 001-101425-0.004 */
16570 else if (attr_len
< 5)
16572 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
16577 section_len
-= attr_len
;
16580 namelen
= strnlen ((char *) p
, attr_len
) + 1;
16581 if (namelen
== 0 || namelen
>= attr_len
)
16583 error (_("Corrupt attribute section name\n"));
16588 printf (_("Attribute Section: "));
16589 print_symbol (INT_MAX
, (const char *) p
);
16592 if (public_name
&& streq ((char *) p
, public_name
))
16593 public_section
= TRUE
;
16595 public_section
= FALSE
;
16597 if (streq ((char *) p
, "gnu"))
16598 gnu_section
= TRUE
;
16600 gnu_section
= FALSE
;
16603 attr_len
-= namelen
;
16605 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
16610 unsigned char * end
;
16612 /* PR binutils/17531: Safe handling of corrupt files. */
16615 error (_("Unused bytes at end of section\n"));
16622 size
= byte_get (p
, 4);
16623 if (size
> attr_len
)
16625 error (_("Bad subsection length (%u > %u)\n"),
16626 (unsigned) size
, (unsigned) attr_len
);
16630 /* PR binutils/17531: Safe handling of corrupt files. */
16633 error (_("Bad subsection length (%u < 6)\n"),
16641 end
= p
+ size
- 1;
16642 assert (end
<= contents
+ sect
->sh_size
);
16648 printf (_("File Attributes\n"));
16651 printf (_("Section Attributes:"));
16654 printf (_("Symbol Attributes:"));
16655 /* Fall through. */
16659 READ_ULEB (val
, p
, end
);
16662 printf (" %d", val
);
16667 printf (_("Unknown tag: %d\n"), tag
);
16668 public_section
= FALSE
;
16672 if (public_section
&& display_pub_attribute
!= NULL
)
16675 p
= display_pub_attribute (p
, end
);
16678 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
16681 p
= display_gnu_attribute (p
,
16682 display_proc_gnu_attribute
,
16688 printf (_(" Unknown attribute:\n"));
16689 display_raw_attribute (p
, end
);
16704 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16705 Print the Address, Access and Initial fields of an entry at VMA ADDR
16706 and return the VMA of the next entry, or -1 if there was a problem.
16707 Does not read from DATA_END or beyond. */
16710 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
16711 unsigned char * data_end
)
16714 print_vma (addr
, LONG_HEX
);
16716 if (addr
< pltgot
+ 0xfff0)
16717 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
16719 printf ("%10s", "");
16722 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16726 unsigned char * from
= data
+ addr
- pltgot
;
16728 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
16730 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16731 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
16732 return (bfd_vma
) -1;
16736 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16737 print_vma (entry
, LONG_HEX
);
16740 return addr
+ (is_32bit_elf
? 4 : 8);
16743 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16744 PLTGOT. Print the Address and Initial fields of an entry at VMA
16745 ADDR and return the VMA of the next entry. */
16748 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
16751 print_vma (addr
, LONG_HEX
);
16754 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16759 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16760 print_vma (entry
, LONG_HEX
);
16762 return addr
+ (is_32bit_elf
? 4 : 8);
16766 print_mips_ases (unsigned int mask
)
16768 if (mask
& AFL_ASE_DSP
)
16769 fputs ("\n\tDSP ASE", stdout
);
16770 if (mask
& AFL_ASE_DSPR2
)
16771 fputs ("\n\tDSP R2 ASE", stdout
);
16772 if (mask
& AFL_ASE_DSPR3
)
16773 fputs ("\n\tDSP R3 ASE", stdout
);
16774 if (mask
& AFL_ASE_EVA
)
16775 fputs ("\n\tEnhanced VA Scheme", stdout
);
16776 if (mask
& AFL_ASE_MCU
)
16777 fputs ("\n\tMCU (MicroController) ASE", stdout
);
16778 if (mask
& AFL_ASE_MDMX
)
16779 fputs ("\n\tMDMX ASE", stdout
);
16780 if (mask
& AFL_ASE_MIPS3D
)
16781 fputs ("\n\tMIPS-3D ASE", stdout
);
16782 if (mask
& AFL_ASE_MT
)
16783 fputs ("\n\tMT ASE", stdout
);
16784 if (mask
& AFL_ASE_SMARTMIPS
)
16785 fputs ("\n\tSmartMIPS ASE", stdout
);
16786 if (mask
& AFL_ASE_VIRT
)
16787 fputs ("\n\tVZ ASE", stdout
);
16788 if (mask
& AFL_ASE_MSA
)
16789 fputs ("\n\tMSA ASE", stdout
);
16790 if (mask
& AFL_ASE_MIPS16
)
16791 fputs ("\n\tMIPS16 ASE", stdout
);
16792 if (mask
& AFL_ASE_MICROMIPS
)
16793 fputs ("\n\tMICROMIPS ASE", stdout
);
16794 if (mask
& AFL_ASE_XPA
)
16795 fputs ("\n\tXPA ASE", stdout
);
16796 if (mask
& AFL_ASE_MIPS16E2
)
16797 fputs ("\n\tMIPS16e2 ASE", stdout
);
16798 if (mask
& AFL_ASE_CRC
)
16799 fputs ("\n\tCRC ASE", stdout
);
16800 if (mask
& AFL_ASE_GINV
)
16801 fputs ("\n\tGINV ASE", stdout
);
16802 if (mask
& AFL_ASE_LOONGSON_MMI
)
16803 fputs ("\n\tLoongson MMI ASE", stdout
);
16804 if (mask
& AFL_ASE_LOONGSON_CAM
)
16805 fputs ("\n\tLoongson CAM ASE", stdout
);
16806 if (mask
& AFL_ASE_LOONGSON_EXT
)
16807 fputs ("\n\tLoongson EXT ASE", stdout
);
16808 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16809 fputs ("\n\tLoongson EXT2 ASE", stdout
);
16811 fprintf (stdout
, "\n\t%s", _("None"));
16812 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16813 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16817 print_mips_isa_ext (unsigned int isa_ext
)
16822 fputs (_("None"), stdout
);
16825 fputs ("RMI XLR", stdout
);
16827 case AFL_EXT_OCTEON3
:
16828 fputs ("Cavium Networks Octeon3", stdout
);
16830 case AFL_EXT_OCTEON2
:
16831 fputs ("Cavium Networks Octeon2", stdout
);
16833 case AFL_EXT_OCTEONP
:
16834 fputs ("Cavium Networks OcteonP", stdout
);
16836 case AFL_EXT_OCTEON
:
16837 fputs ("Cavium Networks Octeon", stdout
);
16840 fputs ("Toshiba R5900", stdout
);
16843 fputs ("MIPS R4650", stdout
);
16846 fputs ("LSI R4010", stdout
);
16849 fputs ("NEC VR4100", stdout
);
16852 fputs ("Toshiba R3900", stdout
);
16854 case AFL_EXT_10000
:
16855 fputs ("MIPS R10000", stdout
);
16858 fputs ("Broadcom SB-1", stdout
);
16861 fputs ("NEC VR4111/VR4181", stdout
);
16864 fputs ("NEC VR4120", stdout
);
16867 fputs ("NEC VR5400", stdout
);
16870 fputs ("NEC VR5500", stdout
);
16872 case AFL_EXT_LOONGSON_2E
:
16873 fputs ("ST Microelectronics Loongson 2E", stdout
);
16875 case AFL_EXT_LOONGSON_2F
:
16876 fputs ("ST Microelectronics Loongson 2F", stdout
);
16878 case AFL_EXT_INTERAPTIV_MR2
:
16879 fputs ("Imagination interAptiv MR2", stdout
);
16882 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
16887 get_mips_reg_size (int reg_size
)
16889 return (reg_size
== AFL_REG_NONE
) ? 0
16890 : (reg_size
== AFL_REG_32
) ? 32
16891 : (reg_size
== AFL_REG_64
) ? 64
16892 : (reg_size
== AFL_REG_128
) ? 128
16897 process_mips_specific (Filedata
* filedata
)
16899 Elf_Internal_Dyn
* entry
;
16900 Elf_Internal_Shdr
*sect
= NULL
;
16901 size_t liblist_offset
= 0;
16902 size_t liblistno
= 0;
16903 size_t conflictsno
= 0;
16904 size_t options_offset
= 0;
16905 size_t conflicts_offset
= 0;
16906 size_t pltrelsz
= 0;
16908 bfd_vma pltgot
= 0;
16909 bfd_vma mips_pltgot
= 0;
16910 bfd_vma jmprel
= 0;
16911 bfd_vma local_gotno
= 0;
16912 bfd_vma gotsym
= 0;
16913 bfd_vma symtabno
= 0;
16914 bfd_boolean res
= TRUE
;
16916 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16917 display_mips_gnu_attribute
))
16920 sect
= find_section (filedata
, ".MIPS.abiflags");
16924 Elf_External_ABIFlags_v0
*abiflags_ext
;
16925 Elf_Internal_ABIFlags_v0 abiflags_in
;
16927 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
16929 error (_("Corrupt MIPS ABI Flags section.\n"));
16934 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16935 sect
->sh_size
, _("MIPS ABI Flags section"));
16938 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
16939 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
16940 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
16941 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
16942 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
16943 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
16944 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
16945 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
16946 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
16947 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
16948 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
16950 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
16951 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
16952 if (abiflags_in
.isa_rev
> 1)
16953 printf ("r%d", abiflags_in
.isa_rev
);
16954 printf ("\nGPR size: %d",
16955 get_mips_reg_size (abiflags_in
.gpr_size
));
16956 printf ("\nCPR1 size: %d",
16957 get_mips_reg_size (abiflags_in
.cpr1_size
));
16958 printf ("\nCPR2 size: %d",
16959 get_mips_reg_size (abiflags_in
.cpr2_size
));
16960 fputs ("\nFP ABI: ", stdout
);
16961 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
16962 fputs ("ISA Extension: ", stdout
);
16963 print_mips_isa_ext (abiflags_in
.isa_ext
);
16964 fputs ("\nASEs:", stdout
);
16965 print_mips_ases (abiflags_in
.ases
);
16966 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
16967 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
16968 fputc ('\n', stdout
);
16969 free (abiflags_ext
);
16974 /* We have a lot of special sections. Thanks SGI! */
16975 if (filedata
->dynamic_section
== NULL
)
16977 /* No dynamic information available. See if there is static GOT. */
16978 sect
= find_section (filedata
, ".got");
16981 unsigned char *data_end
;
16982 unsigned char *data
;
16986 pltgot
= sect
->sh_addr
;
16989 addr_size
= (is_32bit_elf
? 4 : 8);
16990 end
= pltgot
+ sect
->sh_size
;
16992 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
16994 _("Global Offset Table data"));
16995 /* PR 12855: Null data is handled gracefully throughout. */
16996 data_end
= data
+ (end
- pltgot
);
16998 printf (_("\nStatic GOT:\n"));
16999 printf (_(" Canonical gp value: "));
17000 print_vma (ent
+ 0x7ff0, LONG_HEX
);
17003 /* In a dynamic binary GOT[0] is reserved for the dynamic
17004 loader to store the lazy resolver pointer, however in
17005 a static binary it may well have been omitted and GOT
17006 reduced to a table of addresses.
17007 PR 21344: Check for the entry being fully available
17008 before fetching it. */
17010 && data
+ ent
- pltgot
+ addr_size
<= data_end
17011 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
17013 printf (_(" Reserved entries:\n"));
17014 printf (_(" %*s %10s %*s\n"),
17015 addr_size
* 2, _("Address"), _("Access"),
17016 addr_size
* 2, _("Value"));
17017 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17019 if (ent
== (bfd_vma
) -1)
17020 goto sgot_print_fail
;
17022 /* Check for the MSB of GOT[1] being set, identifying a
17023 GNU object. This entry will be used by some runtime
17024 loaders, to store the module pointer. Otherwise this
17025 is an ordinary local entry.
17026 PR 21344: Check for the entry being fully available
17027 before fetching it. */
17029 && data
+ ent
- pltgot
+ addr_size
<= data_end
17030 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17031 >> (addr_size
* 8 - 1)) != 0)
17033 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17035 if (ent
== (bfd_vma
) -1)
17036 goto sgot_print_fail
;
17041 if (data
!= NULL
&& ent
< end
)
17043 printf (_(" Local entries:\n"));
17044 printf (" %*s %10s %*s\n",
17045 addr_size
* 2, _("Address"), _("Access"),
17046 addr_size
* 2, _("Value"));
17049 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17051 if (ent
== (bfd_vma
) -1)
17052 goto sgot_print_fail
;
17063 for (entry
= filedata
->dynamic_section
;
17064 /* PR 17531 file: 012-50589-0.004. */
17065 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
17066 && entry
->d_tag
!= DT_NULL
);
17068 switch (entry
->d_tag
)
17070 case DT_MIPS_LIBLIST
:
17072 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
17073 liblistno
* sizeof (Elf32_External_Lib
));
17075 case DT_MIPS_LIBLISTNO
:
17076 liblistno
= entry
->d_un
.d_val
;
17078 case DT_MIPS_OPTIONS
:
17079 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
17081 case DT_MIPS_CONFLICT
:
17083 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
17084 conflictsno
* sizeof (Elf32_External_Conflict
));
17086 case DT_MIPS_CONFLICTNO
:
17087 conflictsno
= entry
->d_un
.d_val
;
17090 pltgot
= entry
->d_un
.d_ptr
;
17092 case DT_MIPS_LOCAL_GOTNO
:
17093 local_gotno
= entry
->d_un
.d_val
;
17095 case DT_MIPS_GOTSYM
:
17096 gotsym
= entry
->d_un
.d_val
;
17098 case DT_MIPS_SYMTABNO
:
17099 symtabno
= entry
->d_un
.d_val
;
17101 case DT_MIPS_PLTGOT
:
17102 mips_pltgot
= entry
->d_un
.d_ptr
;
17105 pltrel
= entry
->d_un
.d_val
;
17108 pltrelsz
= entry
->d_un
.d_val
;
17111 jmprel
= entry
->d_un
.d_ptr
;
17117 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
17119 Elf32_External_Lib
* elib
;
17122 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
17123 sizeof (Elf32_External_Lib
),
17125 _("liblist section data"));
17128 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
17129 "\nSection '.liblist' contains %lu entries:\n",
17130 (unsigned long) liblistno
),
17131 (unsigned long) liblistno
);
17132 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
17135 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
17142 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17143 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17144 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17145 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17146 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17148 tmp
= gmtime (&atime
);
17149 snprintf (timebuf
, sizeof (timebuf
),
17150 "%04u-%02u-%02uT%02u:%02u:%02u",
17151 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17152 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17154 printf ("%3lu: ", (unsigned long) cnt
);
17155 if (VALID_DYNAMIC_NAME (filedata
, liblist
.l_name
))
17156 print_symbol (20, GET_DYNAMIC_NAME (filedata
, liblist
.l_name
));
17158 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
17159 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
17160 liblist
.l_version
);
17162 if (liblist
.l_flags
== 0)
17166 static const struct
17173 { " EXACT_MATCH", LL_EXACT_MATCH
},
17174 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
17175 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
17176 { " EXPORTS", LL_EXPORTS
},
17177 { " DELAY_LOAD", LL_DELAY_LOAD
},
17178 { " DELTA", LL_DELTA
}
17180 int flags
= liblist
.l_flags
;
17183 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
17184 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
17186 fputs (l_flags_vals
[fcnt
].name
, stdout
);
17187 flags
^= l_flags_vals
[fcnt
].bit
;
17190 printf (" %#x", (unsigned int) flags
);
17202 if (options_offset
!= 0)
17204 Elf_External_Options
* eopt
;
17207 sect
= filedata
->section_headers
;
17209 /* Find the section header so that we get the size. */
17210 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
17211 /* PR 17533 file: 012-277276-0.004. */
17214 error (_("No MIPS_OPTIONS header found\n"));
17218 if (sect
->sh_size
< sizeof (* eopt
))
17220 error (_("The MIPS options section is too small.\n"));
17224 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
17225 sect
->sh_size
, _("options"));
17228 Elf_Internal_Options option
;
17231 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
17233 Elf_External_Options
* eoption
;
17234 unsigned int optsize
;
17236 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
17238 optsize
= BYTE_GET (eoption
->size
);
17240 /* PR 17531: file: ffa0fa3b. */
17241 if (optsize
< sizeof (* eopt
)
17242 || optsize
> sect
->sh_size
- offset
)
17244 error (_("Invalid size (%u) for MIPS option\n"),
17253 printf (ngettext ("\nSection '%s' contains %d entry:\n",
17254 "\nSection '%s' contains %d entries:\n",
17256 printable_section_name (filedata
, sect
), cnt
);
17262 Elf_External_Options
* eoption
;
17264 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
17266 option
.kind
= BYTE_GET (eoption
->kind
);
17267 option
.size
= BYTE_GET (eoption
->size
);
17268 option
.section
= BYTE_GET (eoption
->section
);
17269 option
.info
= BYTE_GET (eoption
->info
);
17271 switch (option
.kind
)
17274 /* This shouldn't happen. */
17275 printf (" NULL %" PRId16
" %" PRIx32
,
17276 option
.section
, option
.info
);
17280 printf (" REGINFO ");
17281 if (filedata
->file_header
.e_machine
== EM_MIPS
)
17283 Elf32_External_RegInfo
* ereg
;
17284 Elf32_RegInfo reginfo
;
17287 if (option
.size
< (sizeof (Elf_External_Options
)
17288 + sizeof (Elf32_External_RegInfo
)))
17290 printf (_("<corrupt>\n"));
17291 error (_("Truncated MIPS REGINFO option\n"));
17296 ereg
= (Elf32_External_RegInfo
*) (eoption
+ 1);
17298 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
17299 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
17300 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
17301 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
17302 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
17303 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
17305 printf ("GPR %08" PRIx32
" GP 0x%" PRIx32
"\n",
17306 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
17308 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
17309 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
17310 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17311 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17316 Elf64_External_RegInfo
* ereg
;
17317 Elf64_Internal_RegInfo reginfo
;
17319 if (option
.size
< (sizeof (Elf_External_Options
)
17320 + sizeof (Elf64_External_RegInfo
)))
17322 printf (_("<corrupt>\n"));
17323 error (_("Truncated MIPS REGINFO option\n"));
17328 ereg
= (Elf64_External_RegInfo
*) (eoption
+ 1);
17329 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
17330 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
17331 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
17332 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
17333 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
17334 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
17336 printf ("GPR %08" PRIx32
" GP 0x%" PRIx64
"\n",
17337 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
17339 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
17340 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
17341 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17342 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17344 offset
+= option
.size
;
17347 case ODK_EXCEPTIONS
:
17348 fputs (" EXCEPTIONS fpe_min(", stdout
);
17349 process_mips_fpe_exception (option
.info
& OEX_FPU_MIN
);
17350 fputs (") fpe_max(", stdout
);
17351 process_mips_fpe_exception ((option
.info
& OEX_FPU_MAX
) >> 8);
17352 fputs (")", stdout
);
17354 if (option
.info
& OEX_PAGE0
)
17355 fputs (" PAGE0", stdout
);
17356 if (option
.info
& OEX_SMM
)
17357 fputs (" SMM", stdout
);
17358 if (option
.info
& OEX_FPDBUG
)
17359 fputs (" FPDBUG", stdout
);
17360 if (option
.info
& OEX_DISMISS
)
17361 fputs (" DISMISS", stdout
);
17365 fputs (" PAD ", stdout
);
17366 if (option
.info
& OPAD_PREFIX
)
17367 fputs (" PREFIX", stdout
);
17368 if (option
.info
& OPAD_POSTFIX
)
17369 fputs (" POSTFIX", stdout
);
17370 if (option
.info
& OPAD_SYMBOL
)
17371 fputs (" SYMBOL", stdout
);
17375 fputs (" HWPATCH ", stdout
);
17376 if (option
.info
& OHW_R4KEOP
)
17377 fputs (" R4KEOP", stdout
);
17378 if (option
.info
& OHW_R8KPFETCH
)
17379 fputs (" R8KPFETCH", stdout
);
17380 if (option
.info
& OHW_R5KEOP
)
17381 fputs (" R5KEOP", stdout
);
17382 if (option
.info
& OHW_R5KCVTL
)
17383 fputs (" R5KCVTL", stdout
);
17387 fputs (" FILL ", stdout
);
17388 /* XXX Print content of info word? */
17392 fputs (" TAGS ", stdout
);
17393 /* XXX Print content of info word? */
17397 fputs (" HWAND ", stdout
);
17398 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
17399 fputs (" R4KEOP_CHECKED", stdout
);
17400 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
17401 fputs (" R4KEOP_CLEAN", stdout
);
17405 fputs (" HWOR ", stdout
);
17406 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
17407 fputs (" R4KEOP_CHECKED", stdout
);
17408 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
17409 fputs (" R4KEOP_CLEAN", stdout
);
17413 printf (" GP_GROUP %#06x self-contained %#06x",
17414 option
.info
& OGP_GROUP
,
17415 (option
.info
& OGP_SELF
) >> 16);
17419 printf (" IDENT %#06x self-contained %#06x",
17420 option
.info
& OGP_GROUP
,
17421 (option
.info
& OGP_SELF
) >> 16);
17425 /* This shouldn't happen. */
17426 printf (" %3d ??? %" PRId16
" %" PRIx32
,
17427 option
.kind
, option
.section
, option
.info
);
17431 len
= sizeof (* eopt
);
17432 while (len
< option
.size
)
17434 unsigned char datum
= *((unsigned char *) eoption
+ len
);
17436 if (ISPRINT (datum
))
17437 printf ("%c", datum
);
17439 printf ("\\%03o", datum
);
17442 fputs ("\n", stdout
);
17444 offset
+= option
.size
;
17452 if (conflicts_offset
!= 0 && conflictsno
!= 0)
17454 Elf32_Conflict
* iconf
;
17457 if (filedata
->dynamic_symbols
== NULL
)
17459 error (_("conflict list found without a dynamic symbol table\n"));
17463 /* PR 21345 - print a slightly more helpful error message
17464 if we are sure that the cmalloc will fail. */
17465 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
17467 error (_("Overlarge number of conflicts detected: %lx\n"),
17468 (long) conflictsno
);
17472 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
17475 error (_("Out of memory allocating space for dynamic conflicts\n"));
17481 Elf32_External_Conflict
* econf32
;
17483 econf32
= (Elf32_External_Conflict
*)
17484 get_data (NULL
, filedata
, conflicts_offset
,
17485 sizeof (*econf32
), conflictsno
, _("conflict"));
17492 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17493 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
17499 Elf64_External_Conflict
* econf64
;
17501 econf64
= (Elf64_External_Conflict
*)
17502 get_data (NULL
, filedata
, conflicts_offset
,
17503 sizeof (*econf64
), conflictsno
, _("conflict"));
17510 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17511 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
17516 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
17517 "\nSection '.conflict' contains %lu entries:\n",
17518 (unsigned long) conflictsno
),
17519 (unsigned long) conflictsno
);
17520 puts (_(" Num: Index Value Name"));
17522 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17524 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
17526 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
17527 printf (_("<corrupt symbol index>"));
17530 Elf_Internal_Sym
* psym
;
17532 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
17533 print_vma (psym
->st_value
, FULL_HEX
);
17535 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17536 print_symbol (25, GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17538 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17546 if (pltgot
!= 0 && local_gotno
!= 0)
17548 bfd_vma ent
, local_end
, global_end
;
17550 unsigned char * data
;
17551 unsigned char * data_end
;
17555 addr_size
= (is_32bit_elf
? 4 : 8);
17556 local_end
= pltgot
+ local_gotno
* addr_size
;
17558 /* PR binutils/17533 file: 012-111227-0.004 */
17559 if (symtabno
< gotsym
)
17561 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17562 (unsigned long) gotsym
, (unsigned long) symtabno
);
17566 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
17567 /* PR 17531: file: 54c91a34. */
17568 if (global_end
< local_end
)
17570 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
17574 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
17575 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
17576 global_end
- pltgot
, 1,
17577 _("Global Offset Table data"));
17578 /* PR 12855: Null data is handled gracefully throughout. */
17579 data_end
= data
+ (global_end
- pltgot
);
17581 printf (_("\nPrimary GOT:\n"));
17582 printf (_(" Canonical gp value: "));
17583 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
17586 printf (_(" Reserved entries:\n"));
17587 printf (_(" %*s %10s %*s Purpose\n"),
17588 addr_size
* 2, _("Address"), _("Access"),
17589 addr_size
* 2, _("Initial"));
17590 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17591 printf (_(" Lazy resolver\n"));
17592 if (ent
== (bfd_vma
) -1)
17593 goto got_print_fail
;
17595 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17596 This entry will be used by some runtime loaders, to store the
17597 module pointer. Otherwise this is an ordinary local entry.
17598 PR 21344: Check for the entry being fully available before
17601 && data
+ ent
- pltgot
+ addr_size
<= data_end
17602 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17603 >> (addr_size
* 8 - 1)) != 0)
17605 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17606 printf (_(" Module pointer (GNU extension)\n"));
17607 if (ent
== (bfd_vma
) -1)
17608 goto got_print_fail
;
17612 if (data
!= NULL
&& ent
< local_end
)
17614 printf (_(" Local entries:\n"));
17615 printf (" %*s %10s %*s\n",
17616 addr_size
* 2, _("Address"), _("Access"),
17617 addr_size
* 2, _("Initial"));
17618 while (ent
< local_end
)
17620 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17622 if (ent
== (bfd_vma
) -1)
17623 goto got_print_fail
;
17628 if (data
!= NULL
&& gotsym
< symtabno
)
17632 printf (_(" Global entries:\n"));
17633 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17634 addr_size
* 2, _("Address"),
17636 addr_size
* 2, _("Initial"),
17637 addr_size
* 2, _("Sym.Val."),
17639 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17640 _("Ndx"), _("Name"));
17642 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
17644 for (i
= gotsym
; i
< symtabno
; i
++)
17646 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17649 if (filedata
->dynamic_symbols
== NULL
)
17650 printf (_("<no dynamic symbols>"));
17651 else if (i
< filedata
->num_dynamic_syms
)
17653 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
17655 print_vma (psym
->st_value
, LONG_HEX
);
17656 printf (" %-7s %3s ",
17657 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17658 get_symbol_index_type (filedata
, psym
->st_shndx
));
17660 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17661 print_symbol (sym_width
,
17662 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17664 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17667 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17668 (unsigned long) i
);
17671 if (ent
== (bfd_vma
) -1)
17681 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
17684 size_t offset
, rel_offset
;
17685 unsigned long count
, i
;
17686 unsigned char * data
;
17687 int addr_size
, sym_width
;
17688 Elf_Internal_Rela
* rels
;
17690 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
17691 if (pltrel
== DT_RELA
)
17693 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17698 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17703 addr_size
= (is_32bit_elf
? 4 : 8);
17704 end
= mips_pltgot
+ (2 + count
) * addr_size
;
17706 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
17707 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
17708 1, _("Procedure Linkage Table data"));
17712 printf ("\nPLT GOT:\n\n");
17713 printf (_(" Reserved entries:\n"));
17714 printf (_(" %*s %*s Purpose\n"),
17715 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
17716 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17717 printf (_(" PLT lazy resolver\n"));
17718 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17719 printf (_(" Module pointer\n"));
17722 printf (_(" Entries:\n"));
17723 printf (" %*s %*s %*s %-7s %3s %s\n",
17724 addr_size
* 2, _("Address"),
17725 addr_size
* 2, _("Initial"),
17726 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17727 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
17728 for (i
= 0; i
< count
; i
++)
17730 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
17732 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17735 if (idx
>= filedata
->num_dynamic_syms
)
17736 printf (_("<corrupt symbol index: %lu>"), idx
);
17739 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
17741 print_vma (psym
->st_value
, LONG_HEX
);
17742 printf (" %-7s %3s ",
17743 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17744 get_symbol_index_type (filedata
, psym
->st_shndx
));
17745 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17746 print_symbol (sym_width
,
17747 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17749 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17763 process_nds32_specific (Filedata
* filedata
)
17765 Elf_Internal_Shdr
*sect
= NULL
;
17767 sect
= find_section (filedata
, ".nds32_e_flags");
17768 if (sect
!= NULL
&& sect
->sh_size
>= 4)
17770 unsigned char *buf
;
17773 printf ("\nNDS32 elf flags section:\n");
17774 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
17775 _("NDS32 elf flags section"));
17780 flag
= byte_get (buf
, 4);
17782 switch (flag
& 0x3)
17785 printf ("(VEC_SIZE):\tNo entry.\n");
17788 printf ("(VEC_SIZE):\t4 bytes\n");
17791 printf ("(VEC_SIZE):\t16 bytes\n");
17794 printf ("(VEC_SIZE):\treserved\n");
17803 process_gnu_liblist (Filedata
* filedata
)
17805 Elf_Internal_Shdr
* section
;
17806 Elf_Internal_Shdr
* string_sec
;
17807 Elf32_External_Lib
* elib
;
17809 size_t strtab_size
;
17811 unsigned long num_liblist
;
17813 bfd_boolean res
= TRUE
;
17818 for (i
= 0, section
= filedata
->section_headers
;
17819 i
< filedata
->file_header
.e_shnum
;
17822 switch (section
->sh_type
)
17824 case SHT_GNU_LIBLIST
:
17825 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
17828 elib
= (Elf32_External_Lib
*)
17829 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
17830 _("liblist section data"));
17838 string_sec
= filedata
->section_headers
+ section
->sh_link
;
17839 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
17840 string_sec
->sh_size
,
17841 _("liblist string table"));
17843 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
17850 strtab_size
= string_sec
->sh_size
;
17852 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
17853 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17854 "\nLibrary list section '%s' contains %lu entries:\n",
17856 printable_section_name (filedata
, section
),
17859 puts (_(" Library Time Stamp Checksum Version Flags"));
17861 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
17869 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17870 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17871 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17872 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17873 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17875 tmp
= gmtime (&atime
);
17876 snprintf (timebuf
, sizeof (timebuf
),
17877 "%04u-%02u-%02uT%02u:%02u:%02u",
17878 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17879 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17881 printf ("%3lu: ", (unsigned long) cnt
);
17883 printf ("%-20s", liblist
.l_name
< strtab_size
17884 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17886 printf ("%-20.20s", liblist
.l_name
< strtab_size
17887 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17888 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
17889 liblist
.l_version
, liblist
.l_flags
);
17900 static const char *
17901 get_note_type (Filedata
* filedata
, unsigned e_type
)
17903 static char buff
[64];
17905 if (filedata
->file_header
.e_type
== ET_CORE
)
17909 return _("NT_AUXV (auxiliary vector)");
17911 return _("NT_PRSTATUS (prstatus structure)");
17913 return _("NT_FPREGSET (floating point registers)");
17915 return _("NT_PRPSINFO (prpsinfo structure)");
17916 case NT_TASKSTRUCT
:
17917 return _("NT_TASKSTRUCT (task structure)");
17919 return _("NT_PRXFPREG (user_xfpregs structure)");
17921 return _("NT_PPC_VMX (ppc Altivec registers)");
17923 return _("NT_PPC_VSX (ppc VSX registers)");
17925 return _("NT_PPC_TAR (ppc TAR register)");
17927 return _("NT_PPC_PPR (ppc PPR register)");
17929 return _("NT_PPC_DSCR (ppc DSCR register)");
17931 return _("NT_PPC_EBB (ppc EBB registers)");
17933 return _("NT_PPC_PMU (ppc PMU registers)");
17934 case NT_PPC_TM_CGPR
:
17935 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17936 case NT_PPC_TM_CFPR
:
17937 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17938 case NT_PPC_TM_CVMX
:
17939 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17940 case NT_PPC_TM_CVSX
:
17941 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17942 case NT_PPC_TM_SPR
:
17943 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17944 case NT_PPC_TM_CTAR
:
17945 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17946 case NT_PPC_TM_CPPR
:
17947 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17948 case NT_PPC_TM_CDSCR
:
17949 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17951 return _("NT_386_TLS (x86 TLS information)");
17952 case NT_386_IOPERM
:
17953 return _("NT_386_IOPERM (x86 I/O permissions)");
17954 case NT_X86_XSTATE
:
17955 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17957 return _("NT_X86_CET (x86 CET state)");
17958 case NT_S390_HIGH_GPRS
:
17959 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17960 case NT_S390_TIMER
:
17961 return _("NT_S390_TIMER (s390 timer register)");
17962 case NT_S390_TODCMP
:
17963 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17964 case NT_S390_TODPREG
:
17965 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17967 return _("NT_S390_CTRS (s390 control registers)");
17968 case NT_S390_PREFIX
:
17969 return _("NT_S390_PREFIX (s390 prefix register)");
17970 case NT_S390_LAST_BREAK
:
17971 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17972 case NT_S390_SYSTEM_CALL
:
17973 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17975 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17976 case NT_S390_VXRS_LOW
:
17977 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17978 case NT_S390_VXRS_HIGH
:
17979 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17980 case NT_S390_GS_CB
:
17981 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17982 case NT_S390_GS_BC
:
17983 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17985 return _("NT_ARM_VFP (arm VFP registers)");
17987 return _("NT_ARM_TLS (AArch TLS registers)");
17988 case NT_ARM_HW_BREAK
:
17989 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17990 case NT_ARM_HW_WATCH
:
17991 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17993 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
17995 return _("NT_PSTATUS (pstatus structure)");
17997 return _("NT_FPREGS (floating point registers)");
17999 return _("NT_PSINFO (psinfo structure)");
18001 return _("NT_LWPSTATUS (lwpstatus_t structure)");
18003 return _("NT_LWPSINFO (lwpsinfo_t structure)");
18004 case NT_WIN32PSTATUS
:
18005 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
18007 return _("NT_SIGINFO (siginfo_t data)");
18009 return _("NT_FILE (mapped files)");
18017 return _("NT_VERSION (version)");
18019 return _("NT_ARCH (architecture)");
18020 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
18022 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
18028 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18033 print_core_note (Elf_Internal_Note
*pnote
)
18035 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
18036 bfd_vma count
, page_size
;
18037 unsigned char *descdata
, *filenames
, *descend
;
18039 if (pnote
->type
!= NT_FILE
)
18049 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
18050 /* Still "successful". */
18055 if (pnote
->descsz
< 2 * addr_size
)
18057 error (_(" Malformed note - too short for header\n"));
18061 descdata
= (unsigned char *) pnote
->descdata
;
18062 descend
= descdata
+ pnote
->descsz
;
18064 if (descdata
[pnote
->descsz
- 1] != '\0')
18066 error (_(" Malformed note - does not end with \\0\n"));
18070 count
= byte_get (descdata
, addr_size
);
18071 descdata
+= addr_size
;
18073 page_size
= byte_get (descdata
, addr_size
);
18074 descdata
+= addr_size
;
18076 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
18077 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
18079 error (_(" Malformed note - too short for supplied file count\n"));
18083 printf (_(" Page size: "));
18084 print_vma (page_size
, DEC
);
18087 printf (_(" %*s%*s%*s\n"),
18088 (int) (2 + 2 * addr_size
), _("Start"),
18089 (int) (4 + 2 * addr_size
), _("End"),
18090 (int) (4 + 2 * addr_size
), _("Page Offset"));
18091 filenames
= descdata
+ count
* 3 * addr_size
;
18092 while (count
-- > 0)
18094 bfd_vma start
, end
, file_ofs
;
18096 if (filenames
== descend
)
18098 error (_(" Malformed note - filenames end too early\n"));
18102 start
= byte_get (descdata
, addr_size
);
18103 descdata
+= addr_size
;
18104 end
= byte_get (descdata
, addr_size
);
18105 descdata
+= addr_size
;
18106 file_ofs
= byte_get (descdata
, addr_size
);
18107 descdata
+= addr_size
;
18110 print_vma (start
, FULL_HEX
);
18112 print_vma (end
, FULL_HEX
);
18114 print_vma (file_ofs
, FULL_HEX
);
18115 printf ("\n %s\n", filenames
);
18117 filenames
+= 1 + strlen ((char *) filenames
);
18123 static const char *
18124 get_gnu_elf_note_type (unsigned e_type
)
18126 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
18129 case NT_GNU_ABI_TAG
:
18130 return _("NT_GNU_ABI_TAG (ABI version tag)");
18132 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
18133 case NT_GNU_BUILD_ID
:
18134 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
18135 case NT_GNU_GOLD_VERSION
:
18136 return _("NT_GNU_GOLD_VERSION (gold version)");
18137 case NT_GNU_PROPERTY_TYPE_0
:
18138 return _("NT_GNU_PROPERTY_TYPE_0");
18139 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
18140 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
18141 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
18142 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
18145 static char buff
[64];
18147 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18154 decode_x86_compat_isa (unsigned int bitmask
)
18158 unsigned int bit
= bitmask
& (- bitmask
);
18163 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
18166 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
18169 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
18172 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
18175 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
18178 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
18181 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
18184 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
18187 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
18190 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
18193 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
18196 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
18197 printf ("AVX512F");
18199 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
18200 printf ("AVX512CD");
18202 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
18203 printf ("AVX512ER");
18205 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
18206 printf ("AVX512PF");
18208 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
18209 printf ("AVX512VL");
18211 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
18212 printf ("AVX512DQ");
18214 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
18215 printf ("AVX512BW");
18218 printf (_("<unknown: %x>"), bit
);
18227 decode_x86_isa (unsigned int bitmask
)
18231 printf (_("<None>"));
18237 unsigned int bit
= bitmask
& (- bitmask
);
18242 case GNU_PROPERTY_X86_ISA_1_CMOV
:
18245 case GNU_PROPERTY_X86_ISA_1_SSE
:
18248 case GNU_PROPERTY_X86_ISA_1_SSE2
:
18251 case GNU_PROPERTY_X86_ISA_1_SSE3
:
18254 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
18257 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
18260 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
18263 case GNU_PROPERTY_X86_ISA_1_AVX
:
18266 case GNU_PROPERTY_X86_ISA_1_AVX2
:
18269 case GNU_PROPERTY_X86_ISA_1_FMA
:
18272 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
18273 printf ("AVX512F");
18275 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
18276 printf ("AVX512CD");
18278 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
18279 printf ("AVX512ER");
18281 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
18282 printf ("AVX512PF");
18284 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
18285 printf ("AVX512VL");
18287 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
18288 printf ("AVX512DQ");
18290 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
18291 printf ("AVX512BW");
18293 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
18294 printf ("AVX512_4FMAPS");
18296 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
18297 printf ("AVX512_4VNNIW");
18299 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
18300 printf ("AVX512_BITALG");
18302 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
18303 printf ("AVX512_IFMA");
18305 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
18306 printf ("AVX512_VBMI");
18308 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
18309 printf ("AVX512_VBMI2");
18311 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
18312 printf ("AVX512_VNNI");
18314 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16
:
18315 printf ("AVX512_BF16");
18318 printf (_("<unknown: %x>"), bit
);
18327 decode_x86_feature_1 (unsigned int bitmask
)
18331 printf (_("<None>"));
18337 unsigned int bit
= bitmask
& (- bitmask
);
18342 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
18345 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
18349 printf (_("<unknown: %x>"), bit
);
18358 decode_x86_feature_2 (unsigned int bitmask
)
18362 printf (_("<None>"));
18368 unsigned int bit
= bitmask
& (- bitmask
);
18373 case GNU_PROPERTY_X86_FEATURE_2_X86
:
18376 case GNU_PROPERTY_X86_FEATURE_2_X87
:
18379 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
18382 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
18385 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
18388 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
18391 case GNU_PROPERTY_X86_FEATURE_2_TMM
:
18394 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
18397 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
18400 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
18401 printf ("XSAVEOPT");
18403 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
18407 printf (_("<unknown: %x>"), bit
);
18416 decode_aarch64_feature_1_and (unsigned int bitmask
)
18420 unsigned int bit
= bitmask
& (- bitmask
);
18425 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
18429 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
18434 printf (_("<unknown: %x>"), bit
);
18443 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
18445 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
18446 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
18447 unsigned int size
= is_32bit_elf
? 4 : 8;
18449 printf (_(" Properties: "));
18451 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
18453 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
18457 while (ptr
< ptr_end
)
18461 unsigned int datasz
;
18463 if ((size_t) (ptr_end
- ptr
) < 8)
18465 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
18469 type
= byte_get (ptr
, 4);
18470 datasz
= byte_get (ptr
+ 4, 4);
18474 if (datasz
> (size_t) (ptr_end
- ptr
))
18476 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
18481 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
18483 if (filedata
->file_header
.e_machine
== EM_X86_64
18484 || filedata
->file_header
.e_machine
== EM_IAMCU
18485 || filedata
->file_header
.e_machine
== EM_386
)
18487 unsigned int bitmask
;
18490 bitmask
= byte_get (ptr
, 4);
18496 case GNU_PROPERTY_X86_ISA_1_USED
:
18498 printf (_("x86 ISA used: <corrupt length: %#x> "),
18502 printf ("x86 ISA used: ");
18503 decode_x86_isa (bitmask
);
18507 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
18509 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18513 printf ("x86 ISA needed: ");
18514 decode_x86_isa (bitmask
);
18518 case GNU_PROPERTY_X86_FEATURE_1_AND
:
18520 printf (_("x86 feature: <corrupt length: %#x> "),
18524 printf ("x86 feature: ");
18525 decode_x86_feature_1 (bitmask
);
18529 case GNU_PROPERTY_X86_FEATURE_2_USED
:
18531 printf (_("x86 feature used: <corrupt length: %#x> "),
18535 printf ("x86 feature used: ");
18536 decode_x86_feature_2 (bitmask
);
18540 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
18542 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
18545 printf ("x86 feature needed: ");
18546 decode_x86_feature_2 (bitmask
);
18550 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
18552 printf (_("x86 ISA used: <corrupt length: %#x> "),
18556 printf ("x86 ISA used: ");
18557 decode_x86_compat_isa (bitmask
);
18561 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
18563 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18567 printf ("x86 ISA needed: ");
18568 decode_x86_compat_isa (bitmask
);
18576 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
18578 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
18580 printf ("AArch64 feature: ");
18582 printf (_("<corrupt length: %#x> "), datasz
);
18584 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
18593 case GNU_PROPERTY_STACK_SIZE
:
18594 printf (_("stack size: "));
18595 if (datasz
!= size
)
18596 printf (_("<corrupt length: %#x> "), datasz
);
18598 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
18601 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
18602 printf ("no copy on protected ");
18604 printf (_("<corrupt length: %#x> "), datasz
);
18612 if (type
< GNU_PROPERTY_LOPROC
)
18613 printf (_("<unknown type %#x data: "), type
);
18614 else if (type
< GNU_PROPERTY_LOUSER
)
18615 printf (_("<procesor-specific type %#x data: "), type
);
18617 printf (_("<application-specific type %#x data: "), type
);
18618 for (j
= 0; j
< datasz
; ++j
)
18619 printf ("%02x ", ptr
[j
] & 0xff);
18623 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
18624 if (ptr
== ptr_end
)
18637 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
18639 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18640 switch (pnote
->type
)
18642 case NT_GNU_BUILD_ID
:
18646 printf (_(" Build ID: "));
18647 for (i
= 0; i
< pnote
->descsz
; ++i
)
18648 printf ("%02x", pnote
->descdata
[i
] & 0xff);
18653 case NT_GNU_ABI_TAG
:
18655 unsigned long os
, major
, minor
, subminor
;
18656 const char *osname
;
18658 /* PR 17531: file: 030-599401-0.004. */
18659 if (pnote
->descsz
< 16)
18661 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18665 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18666 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18667 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
18668 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
18672 case GNU_ABI_TAG_LINUX
:
18675 case GNU_ABI_TAG_HURD
:
18678 case GNU_ABI_TAG_SOLARIS
:
18679 osname
= "Solaris";
18681 case GNU_ABI_TAG_FREEBSD
:
18682 osname
= "FreeBSD";
18684 case GNU_ABI_TAG_NETBSD
:
18687 case GNU_ABI_TAG_SYLLABLE
:
18688 osname
= "Syllable";
18690 case GNU_ABI_TAG_NACL
:
18694 osname
= "Unknown";
18698 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
18699 major
, minor
, subminor
);
18703 case NT_GNU_GOLD_VERSION
:
18707 printf (_(" Version: "));
18708 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
18709 printf ("%c", pnote
->descdata
[i
]);
18716 unsigned long num_entries
, mask
;
18718 /* Hardware capabilities information. Word 0 is the number of entries.
18719 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18720 is a series of entries, where each entry is a single byte followed
18721 by a nul terminated string. The byte gives the bit number to test
18722 if enabled in the bitmask. */
18723 printf (_(" Hardware Capabilities: "));
18724 if (pnote
->descsz
< 8)
18726 error (_("<corrupt GNU_HWCAP>\n"));
18729 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18730 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18731 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
18732 /* FIXME: Add code to display the entries... */
18736 case NT_GNU_PROPERTY_TYPE_0
:
18737 print_gnu_property_note (filedata
, pnote
);
18741 /* Handle unrecognised types. An error message should have already been
18742 created by get_gnu_elf_note_type(), so all that we need to do is to
18743 display the data. */
18747 printf (_(" Description data: "));
18748 for (i
= 0; i
< pnote
->descsz
; ++i
)
18749 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
18758 static const char *
18759 get_v850_elf_note_type (enum v850_notes n_type
)
18761 static char buff
[64];
18765 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
18766 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
18767 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
18768 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
18769 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
18770 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
18772 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
18778 print_v850_note (Elf_Internal_Note
* pnote
)
18782 if (pnote
->descsz
!= 4)
18785 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
18789 printf (_("not set\n"));
18793 switch (pnote
->type
)
18795 case V850_NOTE_ALIGNMENT
:
18798 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
18799 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
18803 case V850_NOTE_DATA_SIZE
:
18806 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
18807 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
18811 case V850_NOTE_FPU_INFO
:
18814 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
18815 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
18819 case V850_NOTE_MMU_INFO
:
18820 case V850_NOTE_CACHE_INFO
:
18821 case V850_NOTE_SIMD_INFO
:
18822 if (val
== EF_RH850_SIMD
)
18824 printf (_("yes\n"));
18830 /* An 'unknown note type' message will already have been displayed. */
18834 printf (_("unknown value: %x\n"), val
);
18839 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
18841 unsigned int version
;
18843 switch (pnote
->type
)
18845 case NT_NETBSD_IDENT
:
18846 if (pnote
->descsz
< 1)
18848 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18849 if ((version
/ 10000) % 100)
18850 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
18851 version
, version
/ 100000000, (version
/ 1000000) % 100,
18852 (version
/ 10000) % 100 > 26 ? "Z" : "",
18853 'A' + (version
/ 10000) % 26);
18855 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
18856 version
, version
/ 100000000, (version
/ 1000000) % 100,
18857 (version
/ 100) % 100);
18860 case NT_NETBSD_MARCH
:
18861 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
18865 #ifdef NT_NETBSD_PAX
18866 case NT_NETBSD_PAX
:
18867 if (pnote
->descsz
< 1)
18869 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18870 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
18871 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
18872 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
18873 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
18874 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
18875 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
18876 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
18881 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
18882 pnote
->descsz
, pnote
->type
);
18886 static const char *
18887 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18891 case NT_FREEBSD_THRMISC
:
18892 return _("NT_THRMISC (thrmisc structure)");
18893 case NT_FREEBSD_PROCSTAT_PROC
:
18894 return _("NT_PROCSTAT_PROC (proc data)");
18895 case NT_FREEBSD_PROCSTAT_FILES
:
18896 return _("NT_PROCSTAT_FILES (files data)");
18897 case NT_FREEBSD_PROCSTAT_VMMAP
:
18898 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18899 case NT_FREEBSD_PROCSTAT_GROUPS
:
18900 return _("NT_PROCSTAT_GROUPS (groups data)");
18901 case NT_FREEBSD_PROCSTAT_UMASK
:
18902 return _("NT_PROCSTAT_UMASK (umask data)");
18903 case NT_FREEBSD_PROCSTAT_RLIMIT
:
18904 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18905 case NT_FREEBSD_PROCSTAT_OSREL
:
18906 return _("NT_PROCSTAT_OSREL (osreldate data)");
18907 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
18908 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18909 case NT_FREEBSD_PROCSTAT_AUXV
:
18910 return _("NT_PROCSTAT_AUXV (auxv data)");
18911 case NT_FREEBSD_PTLWPINFO
:
18912 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18914 return get_note_type (filedata
, e_type
);
18917 static const char *
18918 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18920 static char buff
[64];
18924 case NT_NETBSDCORE_PROCINFO
:
18925 /* NetBSD core "procinfo" structure. */
18926 return _("NetBSD procinfo structure");
18928 #ifdef NT_NETBSDCORE_AUXV
18929 case NT_NETBSDCORE_AUXV
:
18930 return _("NetBSD ELF auxiliary vector data");
18933 #ifdef NT_NETBSDCORE_LWPSTATUS
18934 case NT_NETBSDCORE_LWPSTATUS
:
18935 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
18939 /* As of Jan 2020 there are no other machine-independent notes
18940 defined for NetBSD core files. If the note type is less
18941 than the start of the machine-dependent note types, we don't
18944 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
18946 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18952 switch (filedata
->file_header
.e_machine
)
18954 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18955 and PT_GETFPREGS == mach+2. */
18960 case EM_SPARC32PLUS
:
18964 case NT_NETBSDCORE_FIRSTMACH
+ 0:
18965 return _("PT_GETREGS (reg structure)");
18966 case NT_NETBSDCORE_FIRSTMACH
+ 2:
18967 return _("PT_GETFPREGS (fpreg structure)");
18973 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18974 There's also old PT___GETREGS40 == mach + 1 for old reg
18975 structure which lacks GBR. */
18979 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18980 return _("PT___GETREGS40 (old reg structure)");
18981 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18982 return _("PT_GETREGS (reg structure)");
18983 case NT_NETBSDCORE_FIRSTMACH
+ 5:
18984 return _("PT_GETFPREGS (fpreg structure)");
18990 /* On all other arch's, PT_GETREGS == mach+1 and
18991 PT_GETFPREGS == mach+3. */
18995 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18996 return _("PT_GETREGS (reg structure)");
18997 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18998 return _("PT_GETFPREGS (fpreg structure)");
19004 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
19005 e_type
- NT_NETBSDCORE_FIRSTMACH
);
19009 static const char *
19010 get_stapsdt_note_type (unsigned e_type
)
19012 static char buff
[64];
19017 return _("NT_STAPSDT (SystemTap probe descriptors)");
19023 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19028 print_stapsdt_note (Elf_Internal_Note
*pnote
)
19030 size_t len
, maxlen
;
19031 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
19032 char *data
= pnote
->descdata
;
19033 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
19034 bfd_vma pc
, base_addr
, semaphore
;
19035 char *provider
, *probe
, *arg_fmt
;
19037 if (pnote
->descsz
< (addr_size
* 3))
19038 goto stapdt_note_too_small
;
19040 pc
= byte_get ((unsigned char *) data
, addr_size
);
19043 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
19046 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
19049 if (data
>= data_end
)
19050 goto stapdt_note_too_small
;
19051 maxlen
= data_end
- data
;
19052 len
= strnlen (data
, maxlen
);
19059 goto stapdt_note_too_small
;
19061 if (data
>= data_end
)
19062 goto stapdt_note_too_small
;
19063 maxlen
= data_end
- data
;
19064 len
= strnlen (data
, maxlen
);
19071 goto stapdt_note_too_small
;
19073 if (data
>= data_end
)
19074 goto stapdt_note_too_small
;
19075 maxlen
= data_end
- data
;
19076 len
= strnlen (data
, maxlen
);
19083 goto stapdt_note_too_small
;
19085 printf (_(" Provider: %s\n"), provider
);
19086 printf (_(" Name: %s\n"), probe
);
19087 printf (_(" Location: "));
19088 print_vma (pc
, FULL_HEX
);
19089 printf (_(", Base: "));
19090 print_vma (base_addr
, FULL_HEX
);
19091 printf (_(", Semaphore: "));
19092 print_vma (semaphore
, FULL_HEX
);
19094 printf (_(" Arguments: %s\n"), arg_fmt
);
19096 return data
== data_end
;
19098 stapdt_note_too_small
:
19099 printf (_(" <corrupt - note is too small>\n"));
19100 error (_("corrupt stapdt note - the data size is too small\n"));
19104 static const char *
19105 get_ia64_vms_note_type (unsigned e_type
)
19107 static char buff
[64];
19112 return _("NT_VMS_MHD (module header)");
19114 return _("NT_VMS_LNM (language name)");
19116 return _("NT_VMS_SRC (source files)");
19118 return "NT_VMS_TITLE";
19120 return _("NT_VMS_EIDC (consistency check)");
19121 case NT_VMS_FPMODE
:
19122 return _("NT_VMS_FPMODE (FP mode)");
19123 case NT_VMS_LINKTIME
:
19124 return "NT_VMS_LINKTIME";
19125 case NT_VMS_IMGNAM
:
19126 return _("NT_VMS_IMGNAM (image name)");
19128 return _("NT_VMS_IMGID (image id)");
19129 case NT_VMS_LINKID
:
19130 return _("NT_VMS_LINKID (link id)");
19131 case NT_VMS_IMGBID
:
19132 return _("NT_VMS_IMGBID (build id)");
19133 case NT_VMS_GSTNAM
:
19134 return _("NT_VMS_GSTNAM (sym table name)");
19135 case NT_VMS_ORIG_DYN
:
19136 return "NT_VMS_ORIG_DYN";
19137 case NT_VMS_PATCHTIME
:
19138 return "NT_VMS_PATCHTIME";
19140 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19146 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
19148 int maxlen
= pnote
->descsz
;
19150 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
19151 goto desc_size_fail
;
19153 switch (pnote
->type
)
19157 goto desc_size_fail
;
19159 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
19161 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
19162 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
19163 if (l
+ 34 < maxlen
)
19165 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
19166 if (l
+ 35 < maxlen
)
19167 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
19169 printf (_(" Module version : <missing>\n"));
19173 printf (_(" Module name : <missing>\n"));
19174 printf (_(" Module version : <missing>\n"));
19179 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
19183 case NT_VMS_FPMODE
:
19184 printf (_(" Floating Point mode: "));
19186 goto desc_size_fail
;
19187 /* FIXME: Generate an error if descsz > 8 ? */
19189 printf ("0x%016" BFD_VMA_FMT
"x\n",
19190 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19193 case NT_VMS_LINKTIME
:
19194 printf (_(" Link time: "));
19196 goto desc_size_fail
;
19197 /* FIXME: Generate an error if descsz > 8 ? */
19200 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19204 case NT_VMS_PATCHTIME
:
19205 printf (_(" Patch time: "));
19207 goto desc_size_fail
;
19208 /* FIXME: Generate an error if descsz > 8 ? */
19211 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19215 case NT_VMS_ORIG_DYN
:
19217 goto desc_size_fail
;
19219 printf (_(" Major id: %u, minor id: %u\n"),
19220 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
19221 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
19222 printf (_(" Last modified : "));
19224 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
19225 printf (_("\n Link flags : "));
19226 printf ("0x%016" BFD_VMA_FMT
"x\n",
19227 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
19228 printf (_(" Header flags: 0x%08x\n"),
19229 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
19230 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
19234 case NT_VMS_IMGNAM
:
19235 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
19238 case NT_VMS_GSTNAM
:
19239 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
19243 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
19246 case NT_VMS_LINKID
:
19247 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
19257 printf (_(" <corrupt - data size is too small>\n"));
19258 error (_("corrupt IA64 note: data size is too small\n"));
19262 struct build_attr_cache
{
19263 Filedata
*filedata
;
19265 unsigned long strtablen
;
19266 Elf_Internal_Sym
*symtab
;
19267 unsigned long nsyms
;
19270 /* Find the symbol associated with a build attribute that is attached
19271 to address OFFSET. If PNAME is non-NULL then store the name of
19272 the symbol (if found) in the provided pointer, Returns NULL if a
19273 symbol could not be found. */
19275 static Elf_Internal_Sym
*
19276 get_symbol_for_build_attribute (Filedata
* filedata
,
19277 unsigned long offset
,
19278 bfd_boolean is_open_attr
,
19279 const char ** pname
)
19281 Elf_Internal_Sym
*saved_sym
= NULL
;
19282 Elf_Internal_Sym
*sym
;
19284 if (filedata
->section_headers
!= NULL
19285 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
19287 Elf_Internal_Shdr
* symsec
;
19289 free (ba_cache
.strtab
);
19290 ba_cache
.strtab
= NULL
;
19291 free (ba_cache
.symtab
);
19292 ba_cache
.symtab
= NULL
;
19294 /* Load the symbol and string sections. */
19295 for (symsec
= filedata
->section_headers
;
19296 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
19299 if (symsec
->sh_type
== SHT_SYMTAB
19300 && get_symtab (filedata
, symsec
,
19301 &ba_cache
.symtab
, &ba_cache
.nsyms
,
19302 &ba_cache
.strtab
, &ba_cache
.strtablen
))
19305 ba_cache
.filedata
= filedata
;
19308 if (ba_cache
.symtab
== NULL
)
19311 /* Find a symbol whose value matches offset. */
19312 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
19313 if (sym
->st_value
== offset
)
19315 if (sym
->st_name
>= ba_cache
.strtablen
)
19316 /* Huh ? This should not happen. */
19319 if (ba_cache
.strtab
[sym
->st_name
] == 0)
19322 /* The AArch64 and ARM architectures define mapping symbols
19323 (eg $d, $x, $t) which we want to ignore. */
19324 if (ba_cache
.strtab
[sym
->st_name
] == '$'
19325 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
19326 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
19331 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
19332 and FILE or OBJECT symbols over NOTYPE symbols. We skip
19333 FUNC symbols entirely. */
19334 switch (ELF_ST_TYPE (sym
->st_info
))
19341 /* If the symbol has a size associated
19342 with it then we can stop searching. */
19343 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
19348 /* Ignore function symbols. */
19355 switch (ELF_ST_BIND (sym
->st_info
))
19358 if (saved_sym
== NULL
19359 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
19364 if (saved_sym
== NULL
)
19374 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
19382 if (saved_sym
&& pname
)
19383 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
19388 /* Returns true iff addr1 and addr2 are in the same section. */
19391 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
19393 Elf_Internal_Shdr
* a1
;
19394 Elf_Internal_Shdr
* a2
;
19396 a1
= find_section_by_address (filedata
, addr1
);
19397 a2
= find_section_by_address (filedata
, addr2
);
19399 return a1
== a2
&& a1
!= NULL
;
19403 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
19404 Filedata
* filedata
)
19406 static unsigned long global_offset
= 0;
19407 static unsigned long global_end
= 0;
19408 static unsigned long func_offset
= 0;
19409 static unsigned long func_end
= 0;
19411 Elf_Internal_Sym
* sym
;
19413 unsigned long start
;
19415 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
19417 switch (pnote
->descsz
)
19420 /* A zero-length description means that the range of
19421 the previous note of the same type should be used. */
19424 if (global_end
> global_offset
)
19425 printf (_(" Applies to region from %#lx to %#lx\n"),
19426 global_offset
, global_end
);
19428 printf (_(" Applies to region from %#lx\n"), global_offset
);
19432 if (func_end
> func_offset
)
19433 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
19435 printf (_(" Applies to region from %#lx\n"), func_offset
);
19440 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19447 /* FIXME: We should check that version 3+ notes are being used here... */
19448 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19449 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19453 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19459 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19460 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
19464 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
19465 printf (_(" <invalid descsz>"));
19470 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
19471 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
19472 in order to avoid them being confused with the start address of the
19473 first function in the file... */
19474 if (sym
== NULL
&& is_open_attr
)
19475 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
19478 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
19479 end
= start
+ sym
->st_size
;
19483 /* FIXME: Need to properly allow for section alignment.
19484 16 is just the alignment used on x86_64. */
19486 && start
> BFD_ALIGN (global_end
, 16)
19487 /* Build notes are not guaranteed to be organised in order of
19488 increasing address, but we should find the all of the notes
19489 for one section in the same place. */
19490 && same_section (filedata
, start
, global_end
))
19491 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
19492 global_end
+ 1, start
- 1);
19494 printf (_(" Applies to region from %#lx"), start
);
19495 global_offset
= start
;
19499 printf (_(" to %#lx"), end
);
19505 printf (_(" Applies to region from %#lx"), start
);
19506 func_offset
= start
;
19510 printf (_(" to %#lx"), end
);
19516 printf (_(" (%s)"), name
);
19523 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
19525 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
19526 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
19527 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
19529 char name_attribute
;
19530 const char * expected_types
;
19531 const char * name
= pnote
->namedata
;
19535 if (name
== NULL
|| pnote
->namesz
< 2)
19537 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19538 print_symbol (-20, _(" <corrupt name>"));
19547 /* Version 2 of the spec adds a "GA" prefix to the name field. */
19548 if (name
[0] == 'G' && name
[1] == 'A')
19550 if (pnote
->namesz
< 4)
19552 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19553 print_symbol (-20, _(" <corrupt name>"));
19562 switch ((name_type
= * name
))
19564 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19565 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19566 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19567 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19568 printf ("%c", * name
);
19572 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
19573 print_symbol (-20, _("<unknown name type>"));
19580 switch ((name_attribute
= * name
))
19582 case GNU_BUILD_ATTRIBUTE_VERSION
:
19583 text
= _("<version>");
19584 expected_types
= string_expected
;
19587 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19588 text
= _("<stack prot>");
19589 expected_types
= "!+*";
19592 case GNU_BUILD_ATTRIBUTE_RELRO
:
19593 text
= _("<relro>");
19594 expected_types
= bool_expected
;
19597 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
19598 text
= _("<stack size>");
19599 expected_types
= number_expected
;
19602 case GNU_BUILD_ATTRIBUTE_TOOL
:
19603 text
= _("<tool>");
19604 expected_types
= string_expected
;
19607 case GNU_BUILD_ATTRIBUTE_ABI
:
19609 expected_types
= "$*";
19612 case GNU_BUILD_ATTRIBUTE_PIC
:
19614 expected_types
= number_expected
;
19617 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
19618 text
= _("<short enum>");
19619 expected_types
= bool_expected
;
19623 if (ISPRINT (* name
))
19625 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
19627 if (len
> left
&& ! do_wide
)
19629 printf ("%.*s:", len
, name
);
19635 static char tmpbuf
[128];
19637 error (_("unrecognised byte in name field: %d\n"), * name
);
19638 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
19642 expected_types
= "*$!+";
19647 left
-= printf ("%s", text
);
19649 if (strchr (expected_types
, name_type
) == NULL
)
19650 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
19652 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
19654 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19655 (unsigned long) pnote
->namesz
,
19656 (long) (name
- pnote
->namedata
));
19660 if (left
< 1 && ! do_wide
)
19665 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19667 unsigned int bytes
;
19668 unsigned long long val
= 0;
19669 unsigned int shift
= 0;
19670 char * decoded
= NULL
;
19672 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
19674 /* The -1 is because the name field is always 0 terminated, and we
19675 want to be able to ensure that the shift in the while loop below
19676 will not overflow. */
19679 if (bytes
> sizeof (val
))
19681 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19683 bytes
= sizeof (val
);
19685 /* We do not bother to warn if bytes == 0 as this can
19686 happen with some early versions of the gcc plugin. */
19690 unsigned long long byte
= *name
++ & 0xff;
19692 val
|= byte
<< shift
;
19696 switch (name_attribute
)
19698 case GNU_BUILD_ATTRIBUTE_PIC
:
19701 case 0: decoded
= "static"; break;
19702 case 1: decoded
= "pic"; break;
19703 case 2: decoded
= "PIC"; break;
19704 case 3: decoded
= "pie"; break;
19705 case 4: decoded
= "PIE"; break;
19709 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19712 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19713 case 0: decoded
= "off"; break;
19714 case 1: decoded
= "on"; break;
19715 case 2: decoded
= "all"; break;
19716 case 3: decoded
= "strong"; break;
19717 case 4: decoded
= "explicit"; break;
19725 if (decoded
!= NULL
)
19727 print_symbol (-left
, decoded
);
19738 left
-= printf ("0x%llx", val
);
19740 left
-= printf ("0x%-.*llx", left
, val
);
19744 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19745 left
-= print_symbol (- left
, name
);
19747 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19748 left
-= print_symbol (- left
, "true");
19750 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19751 left
-= print_symbol (- left
, "false");
19755 if (do_wide
&& left
> 0)
19756 printf ("%-*s", left
, " ");
19761 /* Note that by the ELF standard, the name field is already null byte
19762 terminated, and namesz includes the terminating null byte.
19763 I.E. the value of namesz for the name "FSF" is 4.
19765 If the value of namesz is zero, there is no name present. */
19768 process_note (Elf_Internal_Note
* pnote
,
19769 Filedata
* filedata
)
19771 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
19774 if (pnote
->namesz
== 0)
19775 /* If there is no note name, then use the default set of
19776 note type strings. */
19777 nt
= get_note_type (filedata
, pnote
->type
);
19779 else if (const_strneq (pnote
->namedata
, "GNU"))
19780 /* GNU-specific object file notes. */
19781 nt
= get_gnu_elf_note_type (pnote
->type
);
19783 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
19784 /* FreeBSD-specific core file notes. */
19785 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
19787 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
19788 /* NetBSD-specific core file notes. */
19789 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
19791 else if (const_strneq (pnote
->namedata
, "NetBSD"))
19792 /* NetBSD-specific core file notes. */
19793 return process_netbsd_elf_note (pnote
);
19795 else if (const_strneq (pnote
->namedata
, "PaX"))
19796 /* NetBSD-specific core file notes. */
19797 return process_netbsd_elf_note (pnote
);
19799 else if (strneq (pnote
->namedata
, "SPU/", 4))
19801 /* SPU-specific core file notes. */
19802 nt
= pnote
->namedata
+ 4;
19806 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19807 /* VMS/ia64-specific file notes. */
19808 nt
= get_ia64_vms_note_type (pnote
->type
);
19810 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19811 nt
= get_stapsdt_note_type (pnote
->type
);
19814 /* Don't recognize this note name; just use the default set of
19815 note type strings. */
19816 nt
= get_note_type (filedata
, pnote
->type
);
19820 if (((const_strneq (pnote
->namedata
, "GA")
19821 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19822 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19823 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19824 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19825 print_gnu_build_attribute_name (pnote
);
19827 print_symbol (-20, name
);
19830 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
19832 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
19834 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19835 return print_ia64_vms_note (pnote
);
19836 else if (const_strneq (pnote
->namedata
, "GNU"))
19837 return print_gnu_note (filedata
, pnote
);
19838 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19839 return print_stapsdt_note (pnote
);
19840 else if (const_strneq (pnote
->namedata
, "CORE"))
19841 return print_core_note (pnote
);
19842 else if (((const_strneq (pnote
->namedata
, "GA")
19843 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19844 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19845 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19846 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19847 return print_gnu_build_attribute_description (pnote
, filedata
);
19853 printf (_(" description data: "));
19854 for (i
= 0; i
< pnote
->descsz
; i
++)
19855 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19867 process_notes_at (Filedata
* filedata
,
19868 Elf_Internal_Shdr
* section
,
19873 Elf_External_Note
* pnotes
;
19874 Elf_External_Note
* external
;
19876 bfd_boolean res
= TRUE
;
19883 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
19886 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
19894 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19897 if (pnotes
== NULL
)
19903 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
19905 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19906 (unsigned long) offset
, (unsigned long) length
);
19908 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19909 specifies that notes should be aligned to 4 bytes in 32-bit
19910 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19911 we also support 4 byte alignment in 64-bit objects. If section
19912 alignment is less than 4, we treate alignment as 4 bytes. */
19915 else if (align
!= 4 && align
!= 8)
19917 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19923 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19925 end
= (char *) pnotes
+ length
;
19926 while ((char *) external
< end
)
19928 Elf_Internal_Note inote
;
19931 char * temp
= NULL
;
19932 size_t data_remaining
= end
- (char *) external
;
19934 if (!is_ia64_vms (filedata
))
19936 /* PR binutils/15191
19937 Make sure that there is enough data to read. */
19938 min_notesz
= offsetof (Elf_External_Note
, name
);
19939 if (data_remaining
< min_notesz
)
19941 warn (ngettext ("Corrupt note: only %ld byte remains, "
19942 "not enough for a full note\n",
19943 "Corrupt note: only %ld bytes remain, "
19944 "not enough for a full note\n",
19946 (long) data_remaining
);
19949 data_remaining
-= min_notesz
;
19951 inote
.type
= BYTE_GET (external
->type
);
19952 inote
.namesz
= BYTE_GET (external
->namesz
);
19953 inote
.namedata
= external
->name
;
19954 inote
.descsz
= BYTE_GET (external
->descsz
);
19955 inote
.descdata
= ((char *) external
19956 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
19957 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19958 next
= ((char *) external
19959 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
19963 Elf64_External_VMS_Note
*vms_external
;
19965 /* PR binutils/15191
19966 Make sure that there is enough data to read. */
19967 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
19968 if (data_remaining
< min_notesz
)
19970 warn (ngettext ("Corrupt note: only %ld byte remains, "
19971 "not enough for a full note\n",
19972 "Corrupt note: only %ld bytes remain, "
19973 "not enough for a full note\n",
19975 (long) data_remaining
);
19978 data_remaining
-= min_notesz
;
19980 vms_external
= (Elf64_External_VMS_Note
*) external
;
19981 inote
.type
= BYTE_GET (vms_external
->type
);
19982 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
19983 inote
.namedata
= vms_external
->name
;
19984 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
19985 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
19986 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19987 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
19990 /* PR 17531: file: 3443835e. */
19991 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19992 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
19993 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
19994 || (size_t) (next
- inote
.descdata
) < inote
.descsz
19995 || ((size_t) (next
- inote
.descdata
)
19996 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
19998 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19999 (unsigned long) ((char *) external
- (char *) pnotes
));
20000 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
20001 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
20005 external
= (Elf_External_Note
*) next
;
20007 /* Verify that name is null terminated. It appears that at least
20008 one version of Linux (RedHat 6.0) generates corefiles that don't
20009 comply with the ELF spec by failing to include the null byte in
20011 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
20013 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
20015 temp
= (char *) malloc (inote
.namesz
+ 1);
20018 error (_("Out of memory allocating space for inote name\n"));
20023 memcpy (temp
, inote
.namedata
, inote
.namesz
);
20024 inote
.namedata
= temp
;
20026 inote
.namedata
[inote
.namesz
] = 0;
20029 if (! process_note (& inote
, filedata
))
20042 process_corefile_note_segments (Filedata
* filedata
)
20044 Elf_Internal_Phdr
* segment
;
20046 bfd_boolean res
= TRUE
;
20048 if (! get_program_headers (filedata
))
20051 for (i
= 0, segment
= filedata
->program_headers
;
20052 i
< filedata
->file_header
.e_phnum
;
20055 if (segment
->p_type
== PT_NOTE
)
20056 if (! process_notes_at (filedata
, NULL
,
20057 (bfd_vma
) segment
->p_offset
,
20058 (bfd_vma
) segment
->p_filesz
,
20059 (bfd_vma
) segment
->p_align
))
20067 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
20069 Elf_External_Note
* pnotes
;
20070 Elf_External_Note
* external
;
20072 bfd_boolean res
= TRUE
;
20077 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
20079 if (pnotes
== NULL
)
20083 end
= (char*) pnotes
+ length
;
20085 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
20086 (unsigned long) offset
, (unsigned long) length
);
20088 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
20090 Elf_External_Note
* next
;
20091 Elf_Internal_Note inote
;
20093 inote
.type
= BYTE_GET (external
->type
);
20094 inote
.namesz
= BYTE_GET (external
->namesz
);
20095 inote
.namedata
= external
->name
;
20096 inote
.descsz
= BYTE_GET (external
->descsz
);
20097 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
20098 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20100 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
20102 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
20103 inote
.descdata
= inote
.namedata
;
20107 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
20109 if ( ((char *) next
> end
)
20110 || ((char *) next
< (char *) pnotes
))
20112 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
20113 (unsigned long) ((char *) external
- (char *) pnotes
));
20114 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
20115 inote
.type
, inote
.namesz
, inote
.descsz
);
20121 /* Prevent out-of-bounds indexing. */
20122 if ( inote
.namedata
+ inote
.namesz
> end
20123 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
20125 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
20126 (unsigned long) ((char *) external
- (char *) pnotes
));
20127 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
20128 inote
.type
, inote
.namesz
, inote
.descsz
);
20132 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
20134 if (! print_v850_note (& inote
))
20137 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
20138 inote
.namesz
, inote
.descsz
);
20148 process_note_sections (Filedata
* filedata
)
20150 Elf_Internal_Shdr
* section
;
20152 unsigned int n
= 0;
20153 bfd_boolean res
= TRUE
;
20155 for (i
= 0, section
= filedata
->section_headers
;
20156 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
20159 if (section
->sh_type
== SHT_NOTE
)
20161 if (! process_notes_at (filedata
, section
,
20162 (bfd_vma
) section
->sh_offset
,
20163 (bfd_vma
) section
->sh_size
,
20164 (bfd_vma
) section
->sh_addralign
))
20169 if (( filedata
->file_header
.e_machine
== EM_V800
20170 || filedata
->file_header
.e_machine
== EM_V850
20171 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
20172 && section
->sh_type
== SHT_RENESAS_INFO
)
20174 if (! process_v850_notes (filedata
,
20175 (bfd_vma
) section
->sh_offset
,
20176 (bfd_vma
) section
->sh_size
))
20183 /* Try processing NOTE segments instead. */
20184 return process_corefile_note_segments (filedata
);
20190 process_notes (Filedata
* filedata
)
20192 /* If we have not been asked to display the notes then do nothing. */
20196 if (filedata
->file_header
.e_type
!= ET_CORE
)
20197 return process_note_sections (filedata
);
20199 /* No program headers means no NOTE segment. */
20200 if (filedata
->file_header
.e_phnum
> 0)
20201 return process_corefile_note_segments (filedata
);
20203 printf (_("No note segments present in the core file.\n"));
20207 static unsigned char *
20208 display_public_gnu_attributes (unsigned char * start
,
20209 const unsigned char * const end
)
20211 printf (_(" Unknown GNU attribute: %s\n"), start
);
20213 start
+= strnlen ((char *) start
, end
- start
);
20214 display_raw_attribute (start
, end
);
20216 return (unsigned char *) end
;
20219 static unsigned char *
20220 display_generic_attribute (unsigned char * start
,
20222 const unsigned char * const end
)
20225 return (unsigned char *) end
;
20227 return display_tag_value (tag
, start
, end
);
20231 process_arch_specific (Filedata
* filedata
)
20236 switch (filedata
->file_header
.e_machine
)
20239 case EM_ARC_COMPACT
:
20240 case EM_ARC_COMPACT2
:
20241 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
20242 display_arc_attribute
,
20243 display_generic_attribute
);
20245 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
20246 display_arm_attribute
,
20247 display_generic_attribute
);
20250 case EM_MIPS_RS3_LE
:
20251 return process_mips_specific (filedata
);
20254 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
20255 display_msp430_attribute
,
20256 display_msp430_gnu_attribute
);
20259 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
20260 display_riscv_attribute
,
20261 display_generic_attribute
);
20264 return process_nds32_specific (filedata
);
20267 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20268 display_m68k_gnu_attribute
);
20272 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20273 display_power_gnu_attribute
);
20277 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20278 display_s390_gnu_attribute
);
20281 case EM_SPARC32PLUS
:
20283 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20284 display_sparc_gnu_attribute
);
20287 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
20288 display_tic6x_attribute
,
20289 display_generic_attribute
);
20292 return process_attributes (filedata
, "csky", SHT_CSKY_ATTRIBUTES
,
20293 display_csky_attribute
, NULL
);
20296 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
20297 display_public_gnu_attributes
,
20298 display_generic_attribute
);
20303 get_file_header (Filedata
* filedata
)
20305 /* Read in the identity array. */
20306 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
20309 /* Determine how to read the rest of the header. */
20310 switch (filedata
->file_header
.e_ident
[EI_DATA
])
20315 byte_get
= byte_get_little_endian
;
20316 byte_put
= byte_put_little_endian
;
20319 byte_get
= byte_get_big_endian
;
20320 byte_put
= byte_put_big_endian
;
20324 /* For now we only support 32 bit and 64 bit ELF files. */
20325 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
20327 /* Read in the rest of the header. */
20330 Elf32_External_Ehdr ehdr32
;
20332 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20335 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
20336 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
20337 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
20338 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
20339 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
20340 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
20341 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
20342 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
20343 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
20344 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
20345 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
20346 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
20347 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
20351 Elf64_External_Ehdr ehdr64
;
20353 /* If we have been compiled with sizeof (bfd_vma) == 4, then
20354 we will not be able to cope with the 64bit data found in
20355 64 ELF files. Detect this now and abort before we start
20356 overwriting things. */
20357 if (sizeof (bfd_vma
) < 8)
20359 error (_("This instance of readelf has been built without support for a\n\
20360 64 bit data type and so it cannot read 64 bit ELF files.\n"));
20364 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20367 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
20368 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
20369 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
20370 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
20371 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
20372 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
20373 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
20374 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
20375 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
20376 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
20377 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
20378 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
20379 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
20382 if (filedata
->file_header
.e_shoff
)
20384 /* There may be some extensions in the first section header. Don't
20385 bomb if we can't read it. */
20387 get_32bit_section_headers (filedata
, TRUE
);
20389 get_64bit_section_headers (filedata
, TRUE
);
20396 close_file (Filedata
* filedata
)
20400 if (filedata
->handle
)
20401 fclose (filedata
->handle
);
20407 close_debug_file (void * data
)
20409 close_file ((Filedata
*) data
);
20413 open_file (const char * pathname
)
20415 struct stat statbuf
;
20416 Filedata
* filedata
= NULL
;
20418 if (stat (pathname
, & statbuf
) < 0
20419 || ! S_ISREG (statbuf
.st_mode
))
20422 filedata
= calloc (1, sizeof * filedata
);
20423 if (filedata
== NULL
)
20426 filedata
->handle
= fopen (pathname
, "rb");
20427 if (filedata
->handle
== NULL
)
20430 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20431 filedata
->file_name
= pathname
;
20433 if (! get_file_header (filedata
))
20436 if (filedata
->file_header
.e_shoff
)
20440 /* Read the section headers again, this time for real. */
20442 res
= get_32bit_section_headers (filedata
, FALSE
);
20444 res
= get_64bit_section_headers (filedata
, FALSE
);
20455 if (filedata
->handle
)
20456 fclose (filedata
->handle
);
20463 open_debug_file (const char * pathname
)
20465 return open_file (pathname
);
20468 /* Process one ELF object file according to the command line options.
20469 This file may actually be stored in an archive. The file is
20470 positioned at the start of the ELF object. Returns TRUE if no
20471 problems were encountered, FALSE otherwise. */
20474 process_object (Filedata
* filedata
)
20476 bfd_boolean have_separate_files
;
20480 if (! get_file_header (filedata
))
20482 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
20486 /* Initialise per file variables. */
20487 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
20488 filedata
->version_info
[i
] = 0;
20490 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
20491 filedata
->dynamic_info
[i
] = 0;
20492 filedata
->dynamic_info_DT_GNU_HASH
= 0;
20493 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
20495 /* Process the file. */
20497 printf (_("\nFile: %s\n"), filedata
->file_name
);
20499 /* Initialise the dump_sects array from the cmdline_dump_sects array.
20500 Note we do this even if cmdline_dump_sects is empty because we
20501 must make sure that the dump_sets array is zeroed out before each
20502 object file is processed. */
20503 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
20504 memset (filedata
->dump
.dump_sects
, 0,
20505 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20507 if (cmdline
.num_dump_sects
> 0)
20509 if (filedata
->dump
.num_dump_sects
== 0)
20510 /* A sneaky way of allocating the dump_sects array. */
20511 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
20513 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
20514 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
20515 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20518 if (! process_file_header (filedata
))
20521 if (! process_section_headers (filedata
))
20523 /* Without loaded section headers we cannot process lots of things. */
20524 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
20526 if (! do_using_dynamic
)
20527 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
20530 if (! process_section_groups (filedata
))
20531 /* Without loaded section groups we cannot process unwind. */
20534 res
= process_program_headers (filedata
);
20536 res
= process_dynamic_section (filedata
);
20538 if (! process_relocs (filedata
))
20541 if (! process_unwind (filedata
))
20544 if (! process_symbol_table (filedata
))
20547 if (! process_syminfo (filedata
))
20550 if (! process_version_sections (filedata
))
20553 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
20554 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
20556 have_separate_files
= FALSE
;
20558 if (! process_section_contents (filedata
))
20561 if (have_separate_files
)
20565 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
20567 if (! process_section_headers (d
->handle
))
20569 else if (! process_section_contents (d
->handle
))
20573 /* The file handles are closed by the call to free_debug_memory() below. */
20576 if (! process_notes (filedata
))
20579 if (! process_gnu_liblist (filedata
))
20582 if (! process_arch_specific (filedata
))
20585 free (filedata
->program_headers
);
20586 filedata
->program_headers
= NULL
;
20588 free (filedata
->section_headers
);
20589 filedata
->section_headers
= NULL
;
20591 free (filedata
->string_table
);
20592 filedata
->string_table
= NULL
;
20593 filedata
->string_table_length
= 0;
20595 free (filedata
->dump
.dump_sects
);
20596 filedata
->dump
.dump_sects
= NULL
;
20597 filedata
->dump
.num_dump_sects
= 0;
20599 free (filedata
->dynamic_strings
);
20600 filedata
->dynamic_strings
= NULL
;
20601 filedata
->dynamic_strings_length
= 0;
20603 free (filedata
->dynamic_symbols
);
20604 filedata
->dynamic_symbols
= NULL
;
20605 filedata
->num_dynamic_syms
= 0;
20607 free (filedata
->dynamic_syminfo
);
20608 filedata
->dynamic_syminfo
= NULL
;
20610 free (filedata
->dynamic_section
);
20611 filedata
->dynamic_section
= NULL
;
20613 while (filedata
->symtab_shndx_list
!= NULL
)
20615 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
20616 free (filedata
->symtab_shndx_list
);
20617 filedata
->symtab_shndx_list
= next
;
20620 free (filedata
->section_headers_groups
);
20621 filedata
->section_headers_groups
= NULL
;
20623 if (filedata
->section_groups
)
20625 struct group_list
* g
;
20626 struct group_list
* next
;
20628 for (i
= 0; i
< filedata
->group_count
; i
++)
20630 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
20637 free (filedata
->section_groups
);
20638 filedata
->section_groups
= NULL
;
20641 free_debug_memory ();
20646 /* Process an ELF archive.
20647 On entry the file is positioned just after the ARMAG string.
20648 Returns TRUE upon success, FALSE otherwise. */
20651 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
20653 struct archive_info arch
;
20654 struct archive_info nested_arch
;
20656 bfd_boolean ret
= TRUE
;
20660 /* The ARCH structure is used to hold information about this archive. */
20661 arch
.file_name
= NULL
;
20663 arch
.index_array
= NULL
;
20664 arch
.sym_table
= NULL
;
20665 arch
.longnames
= NULL
;
20667 /* The NESTED_ARCH structure is used as a single-item cache of information
20668 about a nested archive (when members of a thin archive reside within
20669 another regular archive file). */
20670 nested_arch
.file_name
= NULL
;
20671 nested_arch
.file
= NULL
;
20672 nested_arch
.index_array
= NULL
;
20673 nested_arch
.sym_table
= NULL
;
20674 nested_arch
.longnames
= NULL
;
20676 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
20677 filedata
->file_size
, is_thin_archive
,
20678 do_archive_index
) != 0)
20684 if (do_archive_index
)
20686 if (arch
.sym_table
== NULL
)
20687 error (_("%s: unable to dump the index as none was found\n"),
20688 filedata
->file_name
);
20691 unsigned long i
, l
;
20692 unsigned long current_pos
;
20694 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
20695 "in the symbol table)\n"),
20696 filedata
->file_name
, (unsigned long) arch
.index_num
,
20699 current_pos
= ftell (filedata
->handle
);
20701 for (i
= l
= 0; i
< arch
.index_num
; i
++)
20704 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
20707 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
20710 if (member_name
!= NULL
)
20712 char * qualified_name
20713 = make_qualified_name (&arch
, &nested_arch
,
20716 if (qualified_name
!= NULL
)
20718 printf (_("Contents of binary %s at offset "),
20720 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
20722 free (qualified_name
);
20724 free (member_name
);
20728 if (l
>= arch
.sym_size
)
20730 error (_("%s: end of the symbol table reached "
20731 "before the end of the index\n"),
20732 filedata
->file_name
);
20736 /* PR 17531: file: 0b6630b2. */
20737 printf ("\t%.*s\n",
20738 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
20739 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
20742 if (arch
.uses_64bit_indices
)
20747 if (l
< arch
.sym_size
)
20749 error (ngettext ("%s: %ld byte remains in the symbol table, "
20750 "but without corresponding entries in "
20751 "the index table\n",
20752 "%s: %ld bytes remain in the symbol table, "
20753 "but without corresponding entries in "
20754 "the index table\n",
20755 arch
.sym_size
- l
),
20756 filedata
->file_name
, arch
.sym_size
- l
);
20760 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
20762 error (_("%s: failed to seek back to start of object files "
20763 "in the archive\n"),
20764 filedata
->file_name
);
20770 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
20771 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
20772 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
20773 && !do_section_groups
&& !do_dyn_syms
)
20775 ret
= TRUE
; /* Archive index only. */
20784 char * qualified_name
;
20786 /* Read the next archive header. */
20787 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
20789 error (_("%s: failed to seek to next archive header\n"),
20794 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
20795 if (got
!= sizeof arch
.arhdr
)
20799 /* PR 24049 - we cannot use filedata->file_name as this will
20800 have already been freed. */
20801 error (_("%s: failed to read archive header\n"), arch
.file_name
);
20806 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
20808 error (_("%s: did not find a valid archive header\n"),
20814 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
20816 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
20817 if (filedata
->archive_file_size
& 01)
20818 ++filedata
->archive_file_size
;
20820 name
= get_archive_member_name (&arch
, &nested_arch
);
20823 error (_("%s: bad archive file name\n"), arch
.file_name
);
20827 namelen
= strlen (name
);
20829 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
20830 if (qualified_name
== NULL
)
20832 error (_("%s: bad archive file name\n"), arch
.file_name
);
20838 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
20840 /* This is a proxy for an external member of a thin archive. */
20841 Filedata
* member_filedata
;
20842 char * member_file_name
= adjust_relative_path
20843 (filedata
->file_name
, name
, namelen
);
20846 if (member_file_name
== NULL
)
20848 free (qualified_name
);
20853 member_filedata
= open_file (member_file_name
);
20854 if (member_filedata
== NULL
)
20856 error (_("Input file '%s' is not readable.\n"), member_file_name
);
20857 free (member_file_name
);
20858 free (qualified_name
);
20863 filedata
->archive_file_offset
= arch
.nested_member_origin
;
20864 member_filedata
->file_name
= qualified_name
;
20866 if (! process_object (member_filedata
))
20869 close_file (member_filedata
);
20870 free (member_file_name
);
20872 else if (is_thin_archive
)
20874 Filedata thin_filedata
;
20876 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
20878 /* PR 15140: Allow for corrupt thin archives. */
20879 if (nested_arch
.file
== NULL
)
20881 error (_("%s: contains corrupt thin archive: %s\n"),
20882 qualified_name
, name
);
20883 free (qualified_name
);
20890 /* This is a proxy for a member of a nested archive. */
20891 filedata
->archive_file_offset
20892 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
20894 /* The nested archive file will have been opened and setup by
20895 get_archive_member_name. */
20896 if (fseek (nested_arch
.file
, filedata
->archive_file_offset
,
20899 error (_("%s: failed to seek to archive member.\n"),
20900 nested_arch
.file_name
);
20901 free (qualified_name
);
20906 thin_filedata
.handle
= nested_arch
.file
;
20907 thin_filedata
.file_name
= qualified_name
;
20909 if (! process_object (& thin_filedata
))
20915 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
20916 filedata
->file_name
= qualified_name
;
20917 if (! process_object (filedata
))
20919 arch
.next_arhdr_offset
+= filedata
->archive_file_size
;
20920 /* Stop looping with "negative" archive_file_size. */
20921 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
20922 arch
.next_arhdr_offset
= -1ul;
20925 free (qualified_name
);
20929 if (nested_arch
.file
!= NULL
)
20930 fclose (nested_arch
.file
);
20931 release_archive (&nested_arch
);
20932 release_archive (&arch
);
20938 process_file (char * file_name
)
20940 Filedata
* filedata
= NULL
;
20941 struct stat statbuf
;
20942 char armag
[SARMAG
];
20943 bfd_boolean ret
= TRUE
;
20945 if (stat (file_name
, &statbuf
) < 0)
20947 if (errno
== ENOENT
)
20948 error (_("'%s': No such file\n"), file_name
);
20950 error (_("Could not locate '%s'. System error message: %s\n"),
20951 file_name
, strerror (errno
));
20955 if (! S_ISREG (statbuf
.st_mode
))
20957 error (_("'%s' is not an ordinary file\n"), file_name
);
20961 filedata
= calloc (1, sizeof * filedata
);
20962 if (filedata
== NULL
)
20964 error (_("Out of memory allocating file data structure\n"));
20968 filedata
->file_name
= file_name
;
20969 filedata
->handle
= fopen (file_name
, "rb");
20970 if (filedata
->handle
== NULL
)
20972 error (_("Input file '%s' is not readable.\n"), file_name
);
20977 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
20979 error (_("%s: Failed to read file's magic number\n"), file_name
);
20980 fclose (filedata
->handle
);
20985 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20987 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
20989 if (! process_archive (filedata
, FALSE
))
20992 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
20994 if ( ! process_archive (filedata
, TRUE
))
20999 if (do_archive_index
&& !check_all
)
21000 error (_("File %s is not an archive so its index cannot be displayed.\n"),
21003 rewind (filedata
->handle
);
21004 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
21006 if (! process_object (filedata
))
21010 fclose (filedata
->handle
);
21011 free (filedata
->section_headers
);
21012 free (filedata
->program_headers
);
21013 free (filedata
->string_table
);
21014 free (filedata
->dump
.dump_sects
);
21017 free (ba_cache
.strtab
);
21018 ba_cache
.strtab
= NULL
;
21019 free (ba_cache
.symtab
);
21020 ba_cache
.symtab
= NULL
;
21021 ba_cache
.filedata
= NULL
;
21026 #ifdef SUPPORT_DISASSEMBLY
21027 /* Needed by the i386 disassembler. For extra credit, someone could
21028 fix this so that we insert symbolic addresses here, esp for GOT/PLT
21032 print_address (unsigned int addr
, FILE * outfile
)
21034 fprintf (outfile
,"0x%8.8x", addr
);
21037 /* Needed by the i386 disassembler. */
21040 db_task_printsym (unsigned int addr
)
21042 print_address (addr
, stderr
);
21047 main (int argc
, char ** argv
)
21051 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
21052 setlocale (LC_MESSAGES
, "");
21054 #if defined (HAVE_SETLOCALE)
21055 setlocale (LC_CTYPE
, "");
21057 bindtextdomain (PACKAGE
, LOCALEDIR
);
21058 textdomain (PACKAGE
);
21060 expandargv (&argc
, &argv
);
21062 parse_args (& cmdline
, argc
, argv
);
21064 if (optind
< (argc
- 1))
21065 /* When displaying information for more than one file,
21066 prefix the information with the file name. */
21068 else if (optind
>= argc
)
21070 /* Ensure that the warning is always displayed. */
21073 warn (_("Nothing to do.\n"));
21078 while (optind
< argc
)
21079 if (! process_file (argv
[optind
++]))
21082 free (cmdline
.dump_sects
);
21084 free (dump_ctf_symtab_name
);
21085 free (dump_ctf_strtab_name
);
21086 free (dump_ctf_parent_name
);
21088 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;