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
= 0;
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 if (reloc
->r_offset
< (size_t) (end
- start
))
12635 read_leb128 (start
+ reloc
->r_offset
, end
, FALSE
,
12636 &reloc_size
, &leb_ret
);
12643 if (leb_ret
!= 0 || reloc_size
== 0 || reloc_size
> 8)
12644 error (_("MSP430 ULEB128 field at 0x%lx contains invalid "
12645 "ULEB128 value\n"),
12646 (long) reloc
->r_offset
);
12647 else if (sym_index
>= num_syms
)
12648 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12652 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12653 - saved_sym
->st_value
);
12655 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12656 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12659 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12660 (long) reloc
->r_offset
);
12669 if (saved_sym
!= NULL
)
12670 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12677 case EM_CYGNUS_MN10300
:
12679 static Elf_Internal_Sym
* saved_sym
= NULL
;
12687 switch (reloc_type
)
12689 case 34: /* R_MN10300_ALIGN */
12691 case 33: /* R_MN10300_SYM_DIFF */
12692 if (sym_index
>= num_syms
)
12693 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12696 saved_sym
= symtab
+ sym_index
;
12699 case 1: /* R_MN10300_32 */
12700 case 2: /* R_MN10300_16 */
12701 if (saved_sym
!= NULL
)
12703 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12706 if (sym_index
>= num_syms
)
12707 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12711 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12712 - saved_sym
->st_value
);
12714 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12715 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12717 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12718 (long) reloc
->r_offset
);
12726 if (saved_sym
!= NULL
)
12727 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12735 static bfd_vma saved_sym1
= 0;
12736 static bfd_vma saved_sym2
= 0;
12737 static bfd_vma value
;
12741 saved_sym1
= saved_sym2
= 0;
12745 switch (reloc_type
)
12747 case 0x80: /* R_RL78_SYM. */
12748 saved_sym1
= saved_sym2
;
12749 if (sym_index
>= num_syms
)
12750 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12754 saved_sym2
= symtab
[sym_index
].st_value
;
12755 saved_sym2
+= reloc
->r_addend
;
12759 case 0x83: /* R_RL78_OPsub. */
12760 value
= saved_sym1
- saved_sym2
;
12761 saved_sym2
= saved_sym1
= 0;
12765 case 0x41: /* R_RL78_ABS32. */
12766 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12767 byte_put (start
+ reloc
->r_offset
, value
, 4);
12769 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12770 (long) reloc
->r_offset
);
12774 case 0x43: /* R_RL78_ABS16. */
12775 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12776 byte_put (start
+ reloc
->r_offset
, value
, 2);
12778 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12779 (long) reloc
->r_offset
);
12793 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12794 DWARF debug sections. This is a target specific test. Note - we do not
12795 go through the whole including-target-headers-multiple-times route, (as
12796 we have already done with <elf/h8.h>) because this would become very
12797 messy and even then this function would have to contain target specific
12798 information (the names of the relocs instead of their numeric values).
12799 FIXME: This is not the correct way to solve this problem. The proper way
12800 is to have target specific reloc sizing and typing functions created by
12801 the reloc-macros.h header, in the same way that it already creates the
12802 reloc naming functions. */
12805 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12807 /* Please keep this table alpha-sorted for ease of visual lookup. */
12808 switch (filedata
->file_header
.e_machine
)
12812 return reloc_type
== 1; /* R_386_32. */
12814 return reloc_type
== 1; /* R_68K_32. */
12816 return reloc_type
== 1; /* R_860_32. */
12818 return reloc_type
== 2; /* R_960_32. */
12820 return (reloc_type
== 258
12821 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12823 return reloc_type
== 11; /* R_BPF_DATA_32 */
12824 case EM_ADAPTEVA_EPIPHANY
:
12825 return reloc_type
== 3;
12827 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12829 return reloc_type
== 1; /* R_ARC_32. */
12830 case EM_ARC_COMPACT
:
12831 case EM_ARC_COMPACT2
:
12832 return reloc_type
== 4; /* R_ARC_32. */
12834 return reloc_type
== 2; /* R_ARM_ABS32 */
12837 return reloc_type
== 1;
12839 return reloc_type
== 0x12; /* R_byte4_data. */
12841 return reloc_type
== 3; /* R_CRIS_32. */
12843 return reloc_type
== 3; /* R_CR16_NUM32. */
12845 return reloc_type
== 15; /* R_CRX_NUM32. */
12847 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12848 case EM_CYGNUS_FRV
:
12849 return reloc_type
== 1;
12850 case EM_CYGNUS_D10V
:
12852 return reloc_type
== 6; /* R_D10V_32. */
12853 case EM_CYGNUS_D30V
:
12855 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12857 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12858 case EM_CYGNUS_FR30
:
12860 return reloc_type
== 3; /* R_FR30_32. */
12862 return reloc_type
== 1; /* R_FT32_32. */
12866 return reloc_type
== 1; /* R_H8_DIR32. */
12868 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12869 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12870 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12871 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12874 return reloc_type
== 2; /* R_IP2K_32. */
12876 return reloc_type
== 2; /* R_IQ2000_32. */
12877 case EM_LATTICEMICO32
:
12878 return reloc_type
== 3; /* R_LM32_32. */
12881 return reloc_type
== 3; /* R_M32C_32. */
12883 return reloc_type
== 34; /* R_M32R_32_RELA. */
12886 return reloc_type
== 6; /* R_M68HC11_32. */
12888 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12889 reloc_type
== 6; /* R_S12Z_CW32. */
12891 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12892 case EM_CYGNUS_MEP
:
12893 return reloc_type
== 4; /* R_MEP_32. */
12895 return reloc_type
== 2; /* R_METAG_ADDR32. */
12896 case EM_MICROBLAZE
:
12897 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12899 return reloc_type
== 2; /* R_MIPS_32. */
12901 return reloc_type
== 4; /* R_MMIX_32. */
12902 case EM_CYGNUS_MN10200
:
12904 return reloc_type
== 1; /* R_MN10200_32. */
12905 case EM_CYGNUS_MN10300
:
12907 return reloc_type
== 1; /* R_MN10300_32. */
12909 return reloc_type
== 1; /* R_MOXIE_32. */
12910 case EM_MSP430_OLD
:
12912 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12914 return reloc_type
== 2; /* R_MT_32. */
12916 return reloc_type
== 20; /* R_NDS32_RELA. */
12917 case EM_ALTERA_NIOS2
:
12918 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12920 return reloc_type
== 1; /* R_NIOS_32. */
12922 return reloc_type
== 1; /* R_OR1K_32. */
12924 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12925 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12926 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12929 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12931 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12933 return reloc_type
== 1; /* R_PPC_ADDR32. */
12935 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12937 return reloc_type
== 1; /* R_RISCV_32. */
12939 return reloc_type
== 1; /* R_RL78_DIR32. */
12941 return reloc_type
== 1; /* R_RX_DIR32. */
12943 return reloc_type
== 1; /* R_I370_ADDR31. */
12946 return reloc_type
== 4; /* R_S390_32. */
12948 return reloc_type
== 8; /* R_SCORE_ABS32. */
12950 return reloc_type
== 1; /* R_SH_DIR32. */
12951 case EM_SPARC32PLUS
:
12954 return reloc_type
== 3 /* R_SPARC_32. */
12955 || reloc_type
== 23; /* R_SPARC_UA32. */
12957 return reloc_type
== 6; /* R_SPU_ADDR32 */
12959 return reloc_type
== 1; /* R_C6000_ABS32. */
12961 return reloc_type
== 2; /* R_TILEGX_32. */
12963 return reloc_type
== 1; /* R_TILEPRO_32. */
12964 case EM_CYGNUS_V850
:
12966 return reloc_type
== 6; /* R_V850_ABS32. */
12968 return reloc_type
== 0x33; /* R_V810_WORD. */
12970 return reloc_type
== 1; /* R_VAX_32. */
12972 return reloc_type
== 3; /* R_VISIUM_32. */
12973 case EM_WEBASSEMBLY
:
12974 return reloc_type
== 1; /* R_WASM32_32. */
12978 return reloc_type
== 10; /* R_X86_64_32. */
12981 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12983 return reloc_type
== 4; /* R_XGATE_32. */
12985 return reloc_type
== 1; /* R_XSTROMY16_32. */
12986 case EM_XTENSA_OLD
:
12988 return reloc_type
== 1; /* R_XTENSA_32. */
12990 return reloc_type
== 6; /* R_Z80_32. */
12993 static unsigned int prev_warn
= 0;
12995 /* Avoid repeating the same warning multiple times. */
12996 if (prev_warn
!= filedata
->file_header
.e_machine
)
12997 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12998 filedata
->file_header
.e_machine
);
12999 prev_warn
= filedata
->file_header
.e_machine
;
13005 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13006 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
13009 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13011 switch (filedata
->file_header
.e_machine
)
13012 /* Please keep this table alpha-sorted for ease of visual lookup. */
13016 return reloc_type
== 2; /* R_386_PC32. */
13018 return reloc_type
== 4; /* R_68K_PC32. */
13020 return reloc_type
== 261; /* R_AARCH64_PREL32 */
13021 case EM_ADAPTEVA_EPIPHANY
:
13022 return reloc_type
== 6;
13024 return reloc_type
== 10; /* R_ALPHA_SREL32. */
13025 case EM_ARC_COMPACT
:
13026 case EM_ARC_COMPACT2
:
13027 return reloc_type
== 49; /* R_ARC_32_PCREL. */
13029 return reloc_type
== 3; /* R_ARM_REL32 */
13032 return reloc_type
== 36; /* R_AVR_32_PCREL. */
13033 case EM_MICROBLAZE
:
13034 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
13036 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
13038 return reloc_type
== 9; /* R_PARISC_PCREL32. */
13040 return reloc_type
== 26; /* R_PPC_REL32. */
13042 return reloc_type
== 26; /* R_PPC64_REL32. */
13044 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
13047 return reloc_type
== 5; /* R_390_PC32. */
13049 return reloc_type
== 2; /* R_SH_REL32. */
13050 case EM_SPARC32PLUS
:
13053 return reloc_type
== 6; /* R_SPARC_DISP32. */
13055 return reloc_type
== 13; /* R_SPU_REL32. */
13057 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
13059 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
13061 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
13065 return reloc_type
== 2; /* R_X86_64_PC32. */
13067 return reloc_type
== 4; /* R_VAX_PCREL32. */
13068 case EM_XTENSA_OLD
:
13070 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
13072 /* Do not abort or issue an error message here. Not all targets use
13073 pc-relative 32-bit relocs in their DWARF debug information and we
13074 have already tested for target coverage in is_32bit_abs_reloc. A
13075 more helpful warning message will be generated by apply_relocations
13076 anyway, so just return. */
13081 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13082 a 64-bit absolute RELA relocation used in DWARF debug sections. */
13085 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13087 switch (filedata
->file_header
.e_machine
)
13090 return reloc_type
== 257; /* R_AARCH64_ABS64. */
13092 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
13094 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
13095 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
13097 return reloc_type
== 80; /* R_PARISC_DIR64. */
13099 return reloc_type
== 38; /* R_PPC64_ADDR64. */
13101 return reloc_type
== 2; /* R_RISCV_64. */
13102 case EM_SPARC32PLUS
:
13105 return reloc_type
== 32 /* R_SPARC_64. */
13106 || reloc_type
== 54; /* R_SPARC_UA64. */
13110 return reloc_type
== 1; /* R_X86_64_64. */
13113 return reloc_type
== 22; /* R_S390_64. */
13115 return reloc_type
== 1; /* R_TILEGX_64. */
13117 return reloc_type
== 18; /* R_MIPS_64. */
13123 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
13124 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
13127 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13129 switch (filedata
->file_header
.e_machine
)
13132 return reloc_type
== 260; /* R_AARCH64_PREL64. */
13134 return reloc_type
== 11; /* R_ALPHA_SREL64. */
13136 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
13137 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
13139 return reloc_type
== 72; /* R_PARISC_PCREL64. */
13141 return reloc_type
== 44; /* R_PPC64_REL64. */
13142 case EM_SPARC32PLUS
:
13145 return reloc_type
== 46; /* R_SPARC_DISP64. */
13149 return reloc_type
== 24; /* R_X86_64_PC64. */
13152 return reloc_type
== 23; /* R_S390_PC64. */
13154 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
13160 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13161 a 24-bit absolute RELA relocation used in DWARF debug sections. */
13164 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13166 switch (filedata
->file_header
.e_machine
)
13168 case EM_CYGNUS_MN10200
:
13170 return reloc_type
== 4; /* R_MN10200_24. */
13172 return reloc_type
== 5; /* R_FT32_20. */
13174 return reloc_type
== 5; /* R_Z80_24. */
13180 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13181 a 16-bit absolute RELA relocation used in DWARF debug sections. */
13184 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13186 /* Please keep this table alpha-sorted for ease of visual lookup. */
13187 switch (filedata
->file_header
.e_machine
)
13190 case EM_ARC_COMPACT
:
13191 case EM_ARC_COMPACT2
:
13192 return reloc_type
== 2; /* R_ARC_16. */
13193 case EM_ADAPTEVA_EPIPHANY
:
13194 return reloc_type
== 5;
13197 return reloc_type
== 4; /* R_AVR_16. */
13198 case EM_CYGNUS_D10V
:
13200 return reloc_type
== 3; /* R_D10V_16. */
13202 return reloc_type
== 2; /* R_FT32_16. */
13206 return reloc_type
== R_H8_DIR16
;
13209 return reloc_type
== 1; /* R_IP2K_16. */
13212 return reloc_type
== 1; /* R_M32C_16 */
13213 case EM_CYGNUS_MN10200
:
13215 return reloc_type
== 2; /* R_MN10200_16. */
13216 case EM_CYGNUS_MN10300
:
13218 return reloc_type
== 2; /* R_MN10300_16. */
13220 if (uses_msp430x_relocs (filedata
))
13221 return reloc_type
== 2; /* R_MSP430_ABS16. */
13222 /* Fall through. */
13223 case EM_MSP430_OLD
:
13224 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13226 return reloc_type
== 19; /* R_NDS32_RELA. */
13227 case EM_ALTERA_NIOS2
:
13228 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13230 return reloc_type
== 9; /* R_NIOS_16. */
13232 return reloc_type
== 2; /* R_OR1K_16. */
13234 return reloc_type
== 55; /* R_RISCV_SET16. */
13236 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13238 return reloc_type
== 2; /* R_C6000_ABS16. */
13240 return reloc_type
== 2; /* R_VISIUM_16. */
13243 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13245 return reloc_type
== 3; /* R_XGATE_16. */
13247 return reloc_type
== 4; /* R_Z80_16. */
13253 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13254 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13257 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13259 switch (filedata
->file_header
.e_machine
)
13262 return reloc_type
== 54; /* R_RISCV_SET8. */
13264 return reloc_type
== 1; /* R_Z80_8. */
13270 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13271 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13274 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13276 switch (filedata
->file_header
.e_machine
)
13279 return reloc_type
== 53; /* R_RISCV_SET6. */
13285 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13286 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13289 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13291 /* Please keep this table alpha-sorted for ease of visual lookup. */
13292 switch (filedata
->file_header
.e_machine
)
13295 return reloc_type
== 35; /* R_RISCV_ADD32. */
13301 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13302 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13305 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13307 /* Please keep this table alpha-sorted for ease of visual lookup. */
13308 switch (filedata
->file_header
.e_machine
)
13311 return reloc_type
== 39; /* R_RISCV_SUB32. */
13317 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13318 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13321 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13323 /* Please keep this table alpha-sorted for ease of visual lookup. */
13324 switch (filedata
->file_header
.e_machine
)
13327 return reloc_type
== 36; /* R_RISCV_ADD64. */
13333 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13334 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13337 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13339 /* Please keep this table alpha-sorted for ease of visual lookup. */
13340 switch (filedata
->file_header
.e_machine
)
13343 return reloc_type
== 40; /* R_RISCV_SUB64. */
13349 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13350 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13353 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13355 /* Please keep this table alpha-sorted for ease of visual lookup. */
13356 switch (filedata
->file_header
.e_machine
)
13359 return reloc_type
== 34; /* R_RISCV_ADD16. */
13365 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13366 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13369 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13371 /* Please keep this table alpha-sorted for ease of visual lookup. */
13372 switch (filedata
->file_header
.e_machine
)
13375 return reloc_type
== 38; /* R_RISCV_SUB16. */
13381 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13382 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13385 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13387 /* Please keep this table alpha-sorted for ease of visual lookup. */
13388 switch (filedata
->file_header
.e_machine
)
13391 return reloc_type
== 33; /* R_RISCV_ADD8. */
13397 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13398 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13401 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13403 /* Please keep this table alpha-sorted for ease of visual lookup. */
13404 switch (filedata
->file_header
.e_machine
)
13407 return reloc_type
== 37; /* R_RISCV_SUB8. */
13413 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13414 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13417 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13419 switch (filedata
->file_header
.e_machine
)
13422 return reloc_type
== 52; /* R_RISCV_SUB6. */
13428 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13429 relocation entries (possibly formerly used for SHT_GROUP sections). */
13432 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13434 switch (filedata
->file_header
.e_machine
)
13436 case EM_386
: /* R_386_NONE. */
13437 case EM_68K
: /* R_68K_NONE. */
13438 case EM_ADAPTEVA_EPIPHANY
:
13439 case EM_ALPHA
: /* R_ALPHA_NONE. */
13440 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13441 case EM_ARC
: /* R_ARC_NONE. */
13442 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13443 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13444 case EM_ARM
: /* R_ARM_NONE. */
13445 case EM_C166
: /* R_XC16X_NONE. */
13446 case EM_CRIS
: /* R_CRIS_NONE. */
13447 case EM_FT32
: /* R_FT32_NONE. */
13448 case EM_IA_64
: /* R_IA64_NONE. */
13449 case EM_K1OM
: /* R_X86_64_NONE. */
13450 case EM_L1OM
: /* R_X86_64_NONE. */
13451 case EM_M32R
: /* R_M32R_NONE. */
13452 case EM_MIPS
: /* R_MIPS_NONE. */
13453 case EM_MN10300
: /* R_MN10300_NONE. */
13454 case EM_MOXIE
: /* R_MOXIE_NONE. */
13455 case EM_NIOS32
: /* R_NIOS_NONE. */
13456 case EM_OR1K
: /* R_OR1K_NONE. */
13457 case EM_PARISC
: /* R_PARISC_NONE. */
13458 case EM_PPC64
: /* R_PPC64_NONE. */
13459 case EM_PPC
: /* R_PPC_NONE. */
13460 case EM_RISCV
: /* R_RISCV_NONE. */
13461 case EM_S390
: /* R_390_NONE. */
13463 case EM_SH
: /* R_SH_NONE. */
13464 case EM_SPARC32PLUS
:
13465 case EM_SPARC
: /* R_SPARC_NONE. */
13467 case EM_TILEGX
: /* R_TILEGX_NONE. */
13468 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13469 case EM_TI_C6000
:/* R_C6000_NONE. */
13470 case EM_X86_64
: /* R_X86_64_NONE. */
13472 case EM_Z80
: /* R_Z80_NONE. */
13473 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13474 return reloc_type
== 0;
13477 return reloc_type
== 0 || reloc_type
== 256;
13480 return (reloc_type
== 0 /* R_AVR_NONE. */
13481 || reloc_type
== 30 /* R_AVR_DIFF8. */
13482 || reloc_type
== 31 /* R_AVR_DIFF16. */
13483 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13485 return reloc_type
== 3; /* R_METAG_NONE. */
13487 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13488 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13489 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13490 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13491 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13493 return (reloc_type
== 0 /* R_PRU_NONE. */
13494 || reloc_type
== 65 /* R_PRU_DIFF8. */
13495 || reloc_type
== 66 /* R_PRU_DIFF16. */
13496 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13497 case EM_XTENSA_OLD
:
13499 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13500 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13501 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13502 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
13503 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
13504 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
13505 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
13506 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
13507 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
13508 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
13513 /* Returns TRUE if there is a relocation against
13514 section NAME at OFFSET bytes. */
13517 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13519 Elf_Internal_Rela
* relocs
;
13520 Elf_Internal_Rela
* rp
;
13522 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13525 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13527 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13528 if (rp
->r_offset
== offset
)
13534 /* Apply relocations to a section.
13535 Returns TRUE upon success, FALSE otherwise.
13536 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13537 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13538 will be set to the number of relocs loaded.
13540 Note: So far support has been added only for those relocations
13541 which can be found in debug sections. FIXME: Add support for
13542 more relocations ? */
13545 apply_relocations (Filedata
* filedata
,
13546 const Elf_Internal_Shdr
* section
,
13547 unsigned char * start
,
13548 bfd_size_type size
,
13549 void ** relocs_return
,
13550 unsigned long * num_relocs_return
)
13552 Elf_Internal_Shdr
* relsec
;
13553 unsigned char * end
= start
+ size
;
13555 if (relocs_return
!= NULL
)
13557 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13558 * num_relocs_return
= 0;
13561 if (filedata
->file_header
.e_type
!= ET_REL
)
13562 /* No relocs to apply. */
13565 /* Find the reloc section associated with the section. */
13566 for (relsec
= filedata
->section_headers
;
13567 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13570 bfd_boolean is_rela
;
13571 unsigned long num_relocs
;
13572 Elf_Internal_Rela
* relocs
;
13573 Elf_Internal_Rela
* rp
;
13574 Elf_Internal_Shdr
* symsec
;
13575 Elf_Internal_Sym
* symtab
;
13576 unsigned long num_syms
;
13577 Elf_Internal_Sym
* sym
;
13579 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13580 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13581 || filedata
->section_headers
+ relsec
->sh_info
!= section
13582 || relsec
->sh_size
== 0
13583 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13586 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13587 if (symsec
->sh_type
!= SHT_SYMTAB
13588 && symsec
->sh_type
!= SHT_DYNSYM
)
13591 is_rela
= relsec
->sh_type
== SHT_RELA
;
13595 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13596 relsec
->sh_size
, & relocs
, & num_relocs
))
13601 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13602 relsec
->sh_size
, & relocs
, & num_relocs
))
13606 /* SH uses RELA but uses in place value instead of the addend field. */
13607 if (filedata
->file_header
.e_machine
== EM_SH
)
13610 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13612 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13615 unsigned int reloc_type
;
13616 unsigned int reloc_size
;
13617 bfd_boolean reloc_inplace
= FALSE
;
13618 bfd_boolean reloc_subtract
= FALSE
;
13619 unsigned char * rloc
;
13620 unsigned long sym_index
;
13622 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13624 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13626 else if (is_none_reloc (filedata
, reloc_type
))
13628 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13629 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13631 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13632 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13634 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13636 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13638 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13639 || is_6bit_abs_reloc (filedata
, reloc_type
))
13641 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13643 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13646 reloc_inplace
= TRUE
;
13648 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13650 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13653 reloc_inplace
= TRUE
;
13655 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13657 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13660 reloc_inplace
= TRUE
;
13662 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13664 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13667 reloc_inplace
= TRUE
;
13669 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13673 reloc_inplace
= TRUE
;
13677 static unsigned int prev_reloc
= 0;
13679 if (reloc_type
!= prev_reloc
)
13680 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13681 reloc_type
, printable_section_name (filedata
, section
));
13682 prev_reloc
= reloc_type
;
13686 rloc
= start
+ rp
->r_offset
;
13687 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
13689 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13690 (unsigned long) rp
->r_offset
,
13691 printable_section_name (filedata
, section
));
13695 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13696 if (sym_index
>= num_syms
)
13698 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13699 sym_index
, printable_section_name (filedata
, section
));
13702 sym
= symtab
+ sym_index
;
13704 /* If the reloc has a symbol associated with it,
13705 make sure that it is of an appropriate type.
13707 Relocations against symbols without type can happen.
13708 Gcc -feliminate-dwarf2-dups may generate symbols
13709 without type for debug info.
13711 Icc generates relocations against function symbols
13712 instead of local labels.
13714 Relocations against object symbols can happen, eg when
13715 referencing a global array. For an example of this see
13716 the _clz.o binary in libgcc.a. */
13718 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13719 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13721 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13722 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13723 printable_section_name (filedata
, relsec
),
13724 (long int)(rp
- relocs
));
13730 addend
+= rp
->r_addend
;
13731 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13732 partial_inplace. */
13734 || (filedata
->file_header
.e_machine
== EM_XTENSA
13735 && reloc_type
== 1)
13736 || ((filedata
->file_header
.e_machine
== EM_PJ
13737 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13738 && reloc_type
== 1)
13739 || ((filedata
->file_header
.e_machine
== EM_D30V
13740 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13741 && reloc_type
== 12)
13744 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13745 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13747 addend
+= byte_get (rloc
, reloc_size
);
13750 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13751 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13753 /* On HPPA, all pc-relative relocations are biased by 8. */
13754 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13756 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13759 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13760 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13762 if (reloc_subtract
)
13763 addend
-= sym
->st_value
;
13765 addend
+= sym
->st_value
;
13766 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13767 byte_put (rloc
, addend
, reloc_size
);
13769 else if (reloc_subtract
)
13770 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13772 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13776 /* Let the target specific reloc processing code know that
13777 we have finished with these relocs. */
13778 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13782 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13783 * num_relocs_return
= num_relocs
;
13794 #ifdef SUPPORT_DISASSEMBLY
13796 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13798 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13800 /* FIXME: XXX -- to be done --- XXX */
13806 /* Reads in the contents of SECTION from FILE, returning a pointer
13807 to a malloc'ed buffer or NULL if something went wrong. */
13810 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13812 bfd_size_type num_bytes
= section
->sh_size
;
13814 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13816 printf (_("Section '%s' has no data to dump.\n"),
13817 printable_section_name (filedata
, section
));
13821 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13822 _("section contents"));
13825 /* Uncompresses a section that was compressed using zlib, in place. */
13828 uncompress_section_contents (unsigned char ** buffer
,
13829 dwarf_size_type uncompressed_size
,
13830 dwarf_size_type
* size
)
13832 dwarf_size_type compressed_size
= *size
;
13833 unsigned char * compressed_buffer
= *buffer
;
13834 unsigned char * uncompressed_buffer
;
13838 /* It is possible the section consists of several compressed
13839 buffers concatenated together, so we uncompress in a loop. */
13840 /* PR 18313: The state field in the z_stream structure is supposed
13841 to be invisible to the user (ie us), but some compilers will
13842 still complain about it being used without initialisation. So
13843 we first zero the entire z_stream structure and then set the fields
13845 memset (& strm
, 0, sizeof strm
);
13846 strm
.avail_in
= compressed_size
;
13847 strm
.next_in
= (Bytef
*) compressed_buffer
;
13848 strm
.avail_out
= uncompressed_size
;
13849 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13851 rc
= inflateInit (& strm
);
13852 while (strm
.avail_in
> 0)
13856 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13857 + (uncompressed_size
- strm
.avail_out
));
13858 rc
= inflate (&strm
, Z_FINISH
);
13859 if (rc
!= Z_STREAM_END
)
13861 rc
= inflateReset (& strm
);
13863 rc
= inflateEnd (& strm
);
13865 || strm
.avail_out
!= 0)
13868 *buffer
= uncompressed_buffer
;
13869 *size
= uncompressed_size
;
13873 free (uncompressed_buffer
);
13874 /* Indicate decompression failure. */
13880 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13882 Elf_Internal_Shdr
* relsec
;
13883 bfd_size_type num_bytes
;
13884 unsigned char * data
;
13885 unsigned char * end
;
13886 unsigned char * real_start
;
13887 unsigned char * start
;
13888 bfd_boolean some_strings_shown
;
13890 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13892 /* PR 21820: Do not fail if the section was empty. */
13893 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13895 num_bytes
= section
->sh_size
;
13897 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13899 if (decompress_dumps
)
13901 dwarf_size_type new_size
= num_bytes
;
13902 dwarf_size_type uncompressed_size
= 0;
13904 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13906 Elf_Internal_Chdr chdr
;
13907 unsigned int compression_header_size
13908 = get_compression_header (& chdr
, (unsigned char *) start
,
13910 if (compression_header_size
== 0)
13911 /* An error message will have already been generated
13912 by get_compression_header. */
13915 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13917 warn (_("section '%s' has unsupported compress type: %d\n"),
13918 printable_section_name (filedata
, section
), chdr
.ch_type
);
13921 uncompressed_size
= chdr
.ch_size
;
13922 start
+= compression_header_size
;
13923 new_size
-= compression_header_size
;
13925 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13927 /* Read the zlib header. In this case, it should be "ZLIB"
13928 followed by the uncompressed section size, 8 bytes in
13929 big-endian order. */
13930 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13931 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13932 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13933 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13934 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13935 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13936 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13937 uncompressed_size
+= start
[11];
13942 if (uncompressed_size
)
13944 if (uncompress_section_contents (& start
,
13945 uncompressed_size
, & new_size
))
13946 num_bytes
= new_size
;
13949 error (_("Unable to decompress section %s\n"),
13950 printable_section_name (filedata
, section
));
13955 start
= real_start
;
13958 /* If the section being dumped has relocations against it the user might
13959 be expecting these relocations to have been applied. Check for this
13960 case and issue a warning message in order to avoid confusion.
13961 FIXME: Maybe we ought to have an option that dumps a section with
13962 relocs applied ? */
13963 for (relsec
= filedata
->section_headers
;
13964 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13967 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13968 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13969 || filedata
->section_headers
+ relsec
->sh_info
!= section
13970 || relsec
->sh_size
== 0
13971 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13974 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13979 end
= start
+ num_bytes
;
13980 some_strings_shown
= FALSE
;
13982 #ifdef HAVE_MBSTATE_T
13984 /* Initialise the multibyte conversion state. */
13985 memset (& state
, 0, sizeof (state
));
13988 bfd_boolean continuing
= FALSE
;
13992 while (!ISPRINT (* data
))
13993 if (++ data
>= end
)
13998 size_t maxlen
= end
- data
;
14003 continuing
= FALSE
;
14007 printf (" [%6lx] ", (unsigned long) (data
- start
));
14021 /* PR 25543: Treat new-lines as string-ending characters. */
14030 /* Do not print control characters directly as they can affect terminal
14031 settings. Such characters usually appear in the names generated
14032 by the assembler for local labels. */
14035 printf ("^%c", c
+ 0x40);
14037 else if (ISPRINT (c
))
14044 #ifdef HAVE_MBSTATE_T
14047 /* Let printf do the hard work of displaying multibyte characters. */
14048 printf ("%.1s", data
- 1);
14049 #ifdef HAVE_MBSTATE_T
14050 /* Try to find out how many bytes made up the character that was
14051 just printed. Advance the symbol pointer past the bytes that
14053 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
14057 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
14067 printf (_("<corrupt>\n"));
14070 some_strings_shown
= TRUE
;
14074 if (! some_strings_shown
)
14075 printf (_(" No strings found in this section."));
14088 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
14089 Filedata
* filedata
,
14090 bfd_boolean relocate
)
14092 Elf_Internal_Shdr
* relsec
;
14093 bfd_size_type bytes
;
14094 bfd_size_type section_size
;
14096 unsigned char * data
;
14097 unsigned char * real_start
;
14098 unsigned char * start
;
14100 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
14102 /* PR 21820: Do not fail if the section was empty. */
14103 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
14105 section_size
= section
->sh_size
;
14107 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
14109 if (decompress_dumps
)
14111 dwarf_size_type new_size
= section_size
;
14112 dwarf_size_type uncompressed_size
= 0;
14114 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14116 Elf_Internal_Chdr chdr
;
14117 unsigned int compression_header_size
14118 = get_compression_header (& chdr
, start
, section_size
);
14120 if (compression_header_size
== 0)
14121 /* An error message will have already been generated
14122 by get_compression_header. */
14125 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14127 warn (_("section '%s' has unsupported compress type: %d\n"),
14128 printable_section_name (filedata
, section
), chdr
.ch_type
);
14131 uncompressed_size
= chdr
.ch_size
;
14132 start
+= compression_header_size
;
14133 new_size
-= compression_header_size
;
14135 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14137 /* Read the zlib header. In this case, it should be "ZLIB"
14138 followed by the uncompressed section size, 8 bytes in
14139 big-endian order. */
14140 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14141 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14142 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14143 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14144 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14145 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14146 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14147 uncompressed_size
+= start
[11];
14152 if (uncompressed_size
)
14154 if (uncompress_section_contents (& start
, uncompressed_size
,
14157 section_size
= new_size
;
14161 error (_("Unable to decompress section %s\n"),
14162 printable_section_name (filedata
, section
));
14163 /* FIXME: Print the section anyway ? */
14168 start
= real_start
;
14173 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
14178 /* If the section being dumped has relocations against it the user might
14179 be expecting these relocations to have been applied. Check for this
14180 case and issue a warning message in order to avoid confusion.
14181 FIXME: Maybe we ought to have an option that dumps a section with
14182 relocs applied ? */
14183 for (relsec
= filedata
->section_headers
;
14184 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14187 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14188 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14189 || filedata
->section_headers
+ relsec
->sh_info
!= section
14190 || relsec
->sh_size
== 0
14191 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14194 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14199 addr
= section
->sh_addr
;
14200 bytes
= section_size
;
14209 lbytes
= (bytes
> 16 ? 16 : bytes
);
14211 printf (" 0x%8.8lx ", (unsigned long) addr
);
14213 for (j
= 0; j
< 16; j
++)
14216 printf ("%2.2x", data
[j
]);
14224 for (j
= 0; j
< lbytes
; j
++)
14227 if (k
>= ' ' && k
< 0x7f)
14250 #ifdef ENABLE_LIBCTF
14251 static ctf_sect_t
*
14252 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14254 buf
->cts_name
= SECTION_NAME (shdr
);
14255 buf
->cts_size
= shdr
->sh_size
;
14256 buf
->cts_entsize
= shdr
->sh_entsize
;
14261 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14262 it is passed, or a pointer to newly-allocated storage, in which case
14263 dump_ctf() will free it when it no longer needs it. */
14266 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14267 char *s
, void *arg
)
14269 const char *blanks
= arg
;
14272 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14277 /* Dump CTF errors/warnings. */
14279 dump_ctf_errs (ctf_file_t
*fp
)
14281 ctf_next_t
*it
= NULL
;
14286 /* Dump accumulated errors and warnings. */
14287 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
14289 error (_("%s: %s"), is_warning
? _("warning"): _("error"),
14293 if (err
!= ECTF_NEXT_END
)
14294 error (_("CTF error: cannot get CTF errors: `%s'"), ctf_errmsg (err
));
14297 /* Dump one CTF archive member. */
14300 dump_ctf_archive_member (ctf_file_t
*ctf
, const char *name
, void *arg
)
14302 ctf_file_t
*parent
= (ctf_file_t
*) arg
;
14303 const char *things
[] = {"Header", "Labels", "Data objects",
14304 "Function objects", "Variables", "Types", "Strings",
14306 const char **thing
;
14310 /* Only print out the name of non-default-named archive members.
14311 The name .ctf appears everywhere, even for things that aren't
14312 really archives, so printing it out is liable to be confusing.
14314 The parent, if there is one, is the default-owned archive member:
14315 avoid importing it into itself. (This does no harm, but looks
14318 if (strcmp (name
, ".ctf") != 0)
14320 printf (_("\nCTF archive member: %s:\n"), name
);
14321 ctf_import (ctf
, parent
);
14324 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14326 ctf_dump_state_t
*s
= NULL
;
14329 printf ("\n %s:\n", *thing
);
14330 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14331 (void *) " ")) != NULL
)
14333 printf ("%s\n", item
);
14337 if (ctf_errno (ctf
))
14339 error (_("Iteration failed: %s, %s\n"), *thing
,
14340 ctf_errmsg (ctf_errno (ctf
)));
14347 dump_ctf_errs (ctf
);
14352 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14354 Elf_Internal_Shdr
* parent_sec
= NULL
;
14355 Elf_Internal_Shdr
* symtab_sec
= NULL
;
14356 Elf_Internal_Shdr
* strtab_sec
= NULL
;
14357 void * data
= NULL
;
14358 void * symdata
= NULL
;
14359 void * strdata
= NULL
;
14360 void * parentdata
= NULL
;
14361 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
14362 ctf_sect_t
* symsectp
= NULL
;
14363 ctf_sect_t
* strsectp
= NULL
;
14364 ctf_archive_t
* ctfa
= NULL
;
14365 ctf_archive_t
* parenta
= NULL
, *lookparent
;
14366 ctf_file_t
* parent
= NULL
;
14369 bfd_boolean ret
= FALSE
;
14371 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
14372 data
= get_section_contents (section
, filedata
);
14373 ctfsect
.cts_data
= data
;
14375 if (!dump_ctf_symtab_name
)
14376 dump_ctf_symtab_name
= strdup (".symtab");
14378 if (!dump_ctf_strtab_name
)
14379 dump_ctf_strtab_name
= strdup (".strtab");
14381 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
14383 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
14385 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
14388 if ((symdata
= (void *) get_data (NULL
, filedata
,
14389 symtab_sec
->sh_offset
, 1,
14390 symtab_sec
->sh_size
,
14391 _("symbols"))) == NULL
)
14393 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
14394 symsect
.cts_data
= symdata
;
14396 if (dump_ctf_strtab_name
&& dump_ctf_strtab_name
[0] != 0)
14398 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
14400 error (_("No string table section named %s\n"),
14401 dump_ctf_strtab_name
);
14404 if ((strdata
= (void *) get_data (NULL
, filedata
,
14405 strtab_sec
->sh_offset
, 1,
14406 strtab_sec
->sh_size
,
14407 _("strings"))) == NULL
)
14409 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
14410 strsect
.cts_data
= strdata
;
14412 if (dump_ctf_parent_name
)
14414 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
14416 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
14419 if ((parentdata
= (void *) get_data (NULL
, filedata
,
14420 parent_sec
->sh_offset
, 1,
14421 parent_sec
->sh_size
,
14422 _("CTF parent"))) == NULL
)
14424 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
14425 parentsect
.cts_data
= parentdata
;
14428 /* Load the CTF file and dump it. It may be a raw CTF section, or an archive:
14429 libctf papers over the difference, so we can pretend it is always an
14430 archive. Possibly open the parent as well, if one was specified. */
14432 if ((ctfa
= ctf_arc_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14434 dump_ctf_errs (NULL
);
14435 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14441 if ((parenta
= ctf_arc_bufopen (&parentsect
, symsectp
, strsectp
,
14444 dump_ctf_errs (NULL
);
14445 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14448 lookparent
= parenta
;
14453 /* Assume that the applicable parent archive member is the default one.
14454 (This is what all known implementations are expected to do, if they
14455 put CTFs and their parents in archives together.) */
14456 if ((parent
= ctf_arc_open_by_name (lookparent
, NULL
, &err
)) == NULL
)
14458 dump_ctf_errs (NULL
);
14459 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14465 printf (_("\nDump of CTF section '%s':\n"),
14466 printable_section_name (filedata
, section
));
14468 if (ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
) != 0)
14472 ctf_file_close (parent
);
14474 ctf_close (parenta
);
14484 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14485 const Elf_Internal_Shdr
* sec
,
14488 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14490 Filedata
* filedata
= (Filedata
*) data
;
14492 if (section
->start
!= NULL
)
14494 /* If it is already loaded, do nothing. */
14495 if (streq (section
->filename
, filedata
->file_name
))
14497 free (section
->start
);
14500 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14501 section
->address
= sec
->sh_addr
;
14502 section
->user_data
= NULL
;
14503 section
->filename
= filedata
->file_name
;
14504 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14506 sec
->sh_size
, buf
);
14507 if (section
->start
== NULL
)
14511 unsigned char *start
= section
->start
;
14512 dwarf_size_type size
= sec
->sh_size
;
14513 dwarf_size_type uncompressed_size
= 0;
14515 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14517 Elf_Internal_Chdr chdr
;
14518 unsigned int compression_header_size
;
14520 if (size
< (is_32bit_elf
14521 ? sizeof (Elf32_External_Chdr
)
14522 : sizeof (Elf64_External_Chdr
)))
14524 warn (_("compressed section %s is too small to contain a compression header\n"),
14529 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14530 if (compression_header_size
== 0)
14531 /* An error message will have already been generated
14532 by get_compression_header. */
14535 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14537 warn (_("section '%s' has unsupported compress type: %d\n"),
14538 section
->name
, chdr
.ch_type
);
14541 uncompressed_size
= chdr
.ch_size
;
14542 start
+= compression_header_size
;
14543 size
-= compression_header_size
;
14545 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14547 /* Read the zlib header. In this case, it should be "ZLIB"
14548 followed by the uncompressed section size, 8 bytes in
14549 big-endian order. */
14550 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14551 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14552 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14553 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14554 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14555 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14556 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14557 uncompressed_size
+= start
[11];
14562 if (uncompressed_size
)
14564 if (uncompress_section_contents (&start
, uncompressed_size
,
14567 /* Free the compressed buffer, update the section buffer
14568 and the section size if uncompress is successful. */
14569 free (section
->start
);
14570 section
->start
= start
;
14574 error (_("Unable to decompress section %s\n"),
14575 printable_section_name (filedata
, sec
));
14580 section
->size
= size
;
14583 if (section
->start
== NULL
)
14586 if (debug_displays
[debug
].relocate
)
14588 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14589 & section
->reloc_info
, & section
->num_relocs
))
14594 section
->reloc_info
= NULL
;
14595 section
->num_relocs
= 0;
14601 #if HAVE_LIBDEBUGINFOD
14602 /* Return a hex string representation of the build-id. */
14604 get_build_id (void * data
)
14606 Filedata
* filedata
= (Filedata
*)data
;
14607 Elf_Internal_Shdr
* shdr
;
14610 /* Iterate through notes to find note.gnu.build-id.
14611 FIXME: Only the first note in any note section is examined. */
14612 for (i
= 0, shdr
= filedata
->section_headers
;
14613 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
14616 if (shdr
->sh_type
!= SHT_NOTE
)
14621 size_t data_remaining
;
14623 Elf_External_Note
* enote
;
14624 Elf_Internal_Note inote
;
14626 bfd_vma offset
= shdr
->sh_offset
;
14627 bfd_vma align
= shdr
->sh_addralign
;
14628 bfd_vma length
= shdr
->sh_size
;
14630 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
14636 else if (align
!= 4 && align
!= 8)
14642 end
= (char *) enote
+ length
;
14643 data_remaining
= end
- (char *) enote
;
14645 if (!is_ia64_vms (filedata
))
14647 min_notesz
= offsetof (Elf_External_Note
, name
);
14648 if (data_remaining
< min_notesz
)
14651 malformed note encountered in section %s whilst scanning for build-id note\n"),
14652 printable_section_name (filedata
, shdr
));
14656 data_remaining
-= min_notesz
;
14658 inote
.type
= BYTE_GET (enote
->type
);
14659 inote
.namesz
= BYTE_GET (enote
->namesz
);
14660 inote
.namedata
= enote
->name
;
14661 inote
.descsz
= BYTE_GET (enote
->descsz
);
14662 inote
.descdata
= ((char *) enote
14663 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
14664 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14665 next
= ((char *) enote
14666 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
14670 Elf64_External_VMS_Note
*vms_enote
;
14672 /* PR binutils/15191
14673 Make sure that there is enough data to read. */
14674 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14675 if (data_remaining
< min_notesz
)
14678 malformed note encountered in section %s whilst scanning for build-id note\n"),
14679 printable_section_name (filedata
, shdr
));
14683 data_remaining
-= min_notesz
;
14685 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
14686 inote
.type
= BYTE_GET (vms_enote
->type
);
14687 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
14688 inote
.namedata
= vms_enote
->name
;
14689 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
14690 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14691 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14692 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14695 /* Skip malformed notes. */
14696 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
14697 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
14698 || (size_t) (next
- inote
.descdata
) < inote
.descsz
14699 || ((size_t) (next
- inote
.descdata
)
14700 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
14703 malformed note encountered in section %s whilst scanning for build-id note\n"),
14704 printable_section_name (filedata
, shdr
));
14709 /* Check if this is the build-id note. If so then convert the build-id
14710 bytes to a hex string. */
14711 if (inote
.namesz
> 0
14712 && const_strneq (inote
.namedata
, "GNU")
14713 && inote
.type
== NT_GNU_BUILD_ID
)
14718 build_id
= malloc (inote
.descsz
* 2 + 1);
14719 if (build_id
== NULL
)
14725 for (j
= 0; j
< inote
.descsz
; ++j
)
14726 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
14727 build_id
[inote
.descsz
* 2] = '\0';
14730 return (unsigned char *) build_id
;
14737 #endif /* HAVE_LIBDEBUGINFOD */
14739 /* If this is not NULL, load_debug_section will only look for sections
14740 within the list of sections given here. */
14741 static unsigned int * section_subset
= NULL
;
14744 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
14746 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14747 Elf_Internal_Shdr
* sec
;
14748 Filedata
* filedata
= (Filedata
*) data
;
14750 /* Without section headers we cannot find any sections. */
14751 if (filedata
->section_headers
== NULL
)
14754 if (filedata
->string_table
== NULL
14755 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
14756 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
14758 Elf_Internal_Shdr
* strs
;
14760 /* Read in the string table, so that we have section names to scan. */
14761 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
14763 if (strs
!= NULL
&& strs
->sh_size
!= 0)
14765 filedata
->string_table
14766 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
14767 1, strs
->sh_size
, _("string table"));
14769 filedata
->string_table_length
14770 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
14774 /* Locate the debug section. */
14775 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
14777 section
->name
= section
->uncompressed_name
;
14780 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
14782 section
->name
= section
->compressed_name
;
14787 /* If we're loading from a subset of sections, and we've loaded
14788 a section matching this name before, it's likely that it's a
14790 if (section_subset
!= NULL
)
14791 free_debug_section (debug
);
14793 return load_specific_debug_section (debug
, sec
, data
);
14797 free_debug_section (enum dwarf_section_display_enum debug
)
14799 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14801 if (section
->start
== NULL
)
14804 free ((char *) section
->start
);
14805 section
->start
= NULL
;
14806 section
->address
= 0;
14809 free (section
->reloc_info
);
14810 section
->reloc_info
= NULL
;
14811 section
->num_relocs
= 0;
14815 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14817 char * name
= SECTION_NAME (section
);
14818 const char * print_name
= printable_section_name (filedata
, section
);
14819 bfd_size_type length
;
14820 bfd_boolean result
= TRUE
;
14823 length
= section
->sh_size
;
14826 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
14829 if (section
->sh_type
== SHT_NOBITS
)
14831 /* There is no point in dumping the contents of a debugging section
14832 which has the NOBITS type - the bits in the file will be random.
14833 This can happen when a file containing a .eh_frame section is
14834 stripped with the --only-keep-debug command line option. */
14835 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14840 if (const_strneq (name
, ".gnu.linkonce.wi."))
14841 name
= ".debug_info";
14843 /* See if we know how to display the contents of this section. */
14844 for (i
= 0; i
< max
; i
++)
14846 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
14847 struct dwarf_section_display
* display
= debug_displays
+ i
;
14848 struct dwarf_section
* sec
= & display
->section
;
14850 if (streq (sec
->uncompressed_name
, name
)
14851 || (id
== line
&& const_strneq (name
, ".debug_line."))
14852 || streq (sec
->compressed_name
, name
))
14854 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
14857 free_debug_section (id
);
14859 if (i
== line
&& const_strneq (name
, ".debug_line."))
14861 else if (streq (sec
->uncompressed_name
, name
))
14862 sec
->name
= sec
->uncompressed_name
;
14864 sec
->name
= sec
->compressed_name
;
14866 if (load_specific_debug_section (id
, section
, filedata
))
14868 /* If this debug section is part of a CU/TU set in a .dwp file,
14869 restrict load_debug_section to the sections in that set. */
14870 section_subset
= find_cu_tu_set (filedata
, shndx
);
14872 result
&= display
->display (sec
, filedata
);
14874 section_subset
= NULL
;
14876 if (secondary
|| (id
!= info
&& id
!= abbrev
))
14877 free_debug_section (id
);
14885 printf (_("Unrecognized debug section: %s\n"), print_name
);
14892 /* Set DUMP_SECTS for all sections where dumps were requested
14893 based on section name. */
14896 initialise_dumps_byname (Filedata
* filedata
)
14898 struct dump_list_entry
* cur
;
14900 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14903 bfd_boolean any
= FALSE
;
14905 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14906 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14908 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
14913 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14919 process_section_contents (Filedata
* filedata
)
14921 Elf_Internal_Shdr
* section
;
14923 bfd_boolean res
= TRUE
;
14928 initialise_dumps_byname (filedata
);
14930 for (i
= 0, section
= filedata
->section_headers
;
14931 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
14934 dump_type dump
= filedata
->dump
.dump_sects
[i
];
14936 #ifdef SUPPORT_DISASSEMBLY
14937 if (dump
& DISASS_DUMP
)
14939 if (! disassemble_section (section
, filedata
))
14943 if (dump
& HEX_DUMP
)
14945 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14949 if (dump
& RELOC_DUMP
)
14951 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14955 if (dump
& STRING_DUMP
)
14957 if (! dump_section_as_strings (section
, filedata
))
14961 if (dump
& DEBUG_DUMP
)
14963 if (! display_debug_section (i
, section
, filedata
))
14967 #ifdef ENABLE_LIBCTF
14968 if (dump
& CTF_DUMP
)
14970 if (! dump_section_as_ctf (section
, filedata
))
14976 /* Check to see if the user requested a
14977 dump of a section that does not exist. */
14978 while (i
< filedata
->dump
.num_dump_sects
)
14980 if (filedata
->dump
.dump_sects
[i
])
14982 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14992 process_mips_fpe_exception (int mask
)
14996 bfd_boolean first
= TRUE
;
14998 if (mask
& OEX_FPU_INEX
)
14999 fputs ("INEX", stdout
), first
= FALSE
;
15000 if (mask
& OEX_FPU_UFLO
)
15001 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
15002 if (mask
& OEX_FPU_OFLO
)
15003 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
15004 if (mask
& OEX_FPU_DIV0
)
15005 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
15006 if (mask
& OEX_FPU_INVAL
)
15007 printf ("%sINVAL", first
? "" : "|");
15010 fputs ("0", stdout
);
15013 /* Display's the value of TAG at location P. If TAG is
15014 greater than 0 it is assumed to be an unknown tag, and
15015 a message is printed to this effect. Otherwise it is
15016 assumed that a message has already been printed.
15018 If the bottom bit of TAG is set it assumed to have a
15019 string value, otherwise it is assumed to have an integer
15022 Returns an updated P pointing to the first unread byte
15023 beyond the end of TAG's value.
15025 Reads at or beyond END will not be made. */
15027 static unsigned char *
15028 display_tag_value (signed int tag
,
15030 const unsigned char * const end
)
15035 printf (" Tag_unknown_%d: ", tag
);
15039 warn (_("<corrupt tag>\n"));
15043 /* PR 17531 file: 027-19978-0.004. */
15044 size_t maxlen
= (end
- p
) - 1;
15049 print_symbol ((int) maxlen
, (const char *) p
);
15050 p
+= strnlen ((char *) p
, maxlen
) + 1;
15054 printf (_("<corrupt string tag>"));
15055 p
= (unsigned char *) end
;
15061 READ_ULEB (val
, p
, end
);
15062 printf ("%ld (0x%lx)\n", val
, val
);
15069 /* ARC ABI attributes section. */
15071 static unsigned char *
15072 display_arc_attribute (unsigned char * p
,
15073 const unsigned char * const end
)
15078 READ_ULEB (tag
, p
, end
);
15082 case Tag_ARC_PCS_config
:
15083 READ_ULEB (val
, p
, end
);
15084 printf (" Tag_ARC_PCS_config: ");
15088 printf (_("Absent/Non standard\n"));
15091 printf (_("Bare metal/mwdt\n"));
15094 printf (_("Bare metal/newlib\n"));
15097 printf (_("Linux/uclibc\n"));
15100 printf (_("Linux/glibc\n"));
15103 printf (_("Unknown\n"));
15108 case Tag_ARC_CPU_base
:
15109 READ_ULEB (val
, p
, end
);
15110 printf (" Tag_ARC_CPU_base: ");
15115 printf (_("Absent\n"));
15117 case TAG_CPU_ARC6xx
:
15118 printf ("ARC6xx\n");
15120 case TAG_CPU_ARC7xx
:
15121 printf ("ARC7xx\n");
15123 case TAG_CPU_ARCEM
:
15124 printf ("ARCEM\n");
15126 case TAG_CPU_ARCHS
:
15127 printf ("ARCHS\n");
15132 case Tag_ARC_CPU_variation
:
15133 READ_ULEB (val
, p
, end
);
15134 printf (" Tag_ARC_CPU_variation: ");
15138 if (val
> 0 && val
< 16)
15139 printf ("Core%d\n", val
);
15141 printf ("Unknown\n");
15145 printf (_("Absent\n"));
15150 case Tag_ARC_CPU_name
:
15151 printf (" Tag_ARC_CPU_name: ");
15152 p
= display_tag_value (-1, p
, end
);
15155 case Tag_ARC_ABI_rf16
:
15156 READ_ULEB (val
, p
, end
);
15157 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
15160 case Tag_ARC_ABI_osver
:
15161 READ_ULEB (val
, p
, end
);
15162 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
15165 case Tag_ARC_ABI_pic
:
15166 case Tag_ARC_ABI_sda
:
15167 READ_ULEB (val
, p
, end
);
15168 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
15169 : " Tag_ARC_ABI_pic: ");
15173 printf (_("Absent\n"));
15182 printf (_("Unknown\n"));
15187 case Tag_ARC_ABI_tls
:
15188 READ_ULEB (val
, p
, end
);
15189 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
15192 case Tag_ARC_ABI_enumsize
:
15193 READ_ULEB (val
, p
, end
);
15194 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
15198 case Tag_ARC_ABI_exceptions
:
15199 READ_ULEB (val
, p
, end
);
15200 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
15204 case Tag_ARC_ABI_double_size
:
15205 READ_ULEB (val
, p
, end
);
15206 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
15209 case Tag_ARC_ISA_config
:
15210 printf (" Tag_ARC_ISA_config: ");
15211 p
= display_tag_value (-1, p
, end
);
15214 case Tag_ARC_ISA_apex
:
15215 printf (" Tag_ARC_ISA_apex: ");
15216 p
= display_tag_value (-1, p
, end
);
15219 case Tag_ARC_ISA_mpy_option
:
15220 READ_ULEB (val
, p
, end
);
15221 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
15224 case Tag_ARC_ATR_version
:
15225 READ_ULEB (val
, p
, end
);
15226 printf (" Tag_ARC_ATR_version: %d\n", val
);
15230 return display_tag_value (tag
& 1, p
, end
);
15236 /* ARM EABI attributes section. */
15241 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
15243 const char ** table
;
15244 } arm_attr_public_tag
;
15246 static const char * arm_attr_tag_CPU_arch
[] =
15247 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
15248 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
15249 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
15250 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
15251 static const char * arm_attr_tag_THUMB_ISA_use
[] =
15252 {"No", "Thumb-1", "Thumb-2", "Yes"};
15253 static const char * arm_attr_tag_FP_arch
[] =
15254 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
15255 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
15256 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
15257 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
15258 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
15259 "NEON for ARMv8.1"};
15260 static const char * arm_attr_tag_PCS_config
[] =
15261 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
15262 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
15263 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
15264 {"V6", "SB", "TLS", "Unused"};
15265 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
15266 {"Absolute", "PC-relative", "SB-relative", "None"};
15267 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
15268 {"Absolute", "PC-relative", "None"};
15269 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
15270 {"None", "direct", "GOT-indirect"};
15271 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
15272 {"None", "??? 1", "2", "??? 3", "4"};
15273 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
15274 static const char * arm_attr_tag_ABI_FP_denormal
[] =
15275 {"Unused", "Needed", "Sign only"};
15276 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
15277 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
15278 static const char * arm_attr_tag_ABI_FP_number_model
[] =
15279 {"Unused", "Finite", "RTABI", "IEEE 754"};
15280 static const char * arm_attr_tag_ABI_enum_size
[] =
15281 {"Unused", "small", "int", "forced to int"};
15282 static const char * arm_attr_tag_ABI_HardFP_use
[] =
15283 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
15284 static const char * arm_attr_tag_ABI_VFP_args
[] =
15285 {"AAPCS", "VFP registers", "custom", "compatible"};
15286 static const char * arm_attr_tag_ABI_WMMX_args
[] =
15287 {"AAPCS", "WMMX registers", "custom"};
15288 static const char * arm_attr_tag_ABI_optimization_goals
[] =
15289 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15290 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
15291 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
15292 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15293 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
15294 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
15295 static const char * arm_attr_tag_FP_HP_extension
[] =
15296 {"Not Allowed", "Allowed"};
15297 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
15298 {"None", "IEEE 754", "Alternative Format"};
15299 static const char * arm_attr_tag_DSP_extension
[] =
15300 {"Follow architecture", "Allowed"};
15301 static const char * arm_attr_tag_MPextension_use
[] =
15302 {"Not Allowed", "Allowed"};
15303 static const char * arm_attr_tag_DIV_use
[] =
15304 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
15305 "Allowed in v7-A with integer division extension"};
15306 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
15307 static const char * arm_attr_tag_Virtualization_use
[] =
15308 {"Not Allowed", "TrustZone", "Virtualization Extensions",
15309 "TrustZone and Virtualization Extensions"};
15310 static const char * arm_attr_tag_MPextension_use_legacy
[] =
15311 {"Not Allowed", "Allowed"};
15313 static const char * arm_attr_tag_MVE_arch
[] =
15314 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
15316 #define LOOKUP(id, name) \
15317 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
15318 static arm_attr_public_tag arm_attr_public_tags
[] =
15320 {4, "CPU_raw_name", 1, NULL
},
15321 {5, "CPU_name", 1, NULL
},
15322 LOOKUP(6, CPU_arch
),
15323 {7, "CPU_arch_profile", 0, NULL
},
15324 LOOKUP(8, ARM_ISA_use
),
15325 LOOKUP(9, THUMB_ISA_use
),
15326 LOOKUP(10, FP_arch
),
15327 LOOKUP(11, WMMX_arch
),
15328 LOOKUP(12, Advanced_SIMD_arch
),
15329 LOOKUP(13, PCS_config
),
15330 LOOKUP(14, ABI_PCS_R9_use
),
15331 LOOKUP(15, ABI_PCS_RW_data
),
15332 LOOKUP(16, ABI_PCS_RO_data
),
15333 LOOKUP(17, ABI_PCS_GOT_use
),
15334 LOOKUP(18, ABI_PCS_wchar_t
),
15335 LOOKUP(19, ABI_FP_rounding
),
15336 LOOKUP(20, ABI_FP_denormal
),
15337 LOOKUP(21, ABI_FP_exceptions
),
15338 LOOKUP(22, ABI_FP_user_exceptions
),
15339 LOOKUP(23, ABI_FP_number_model
),
15340 {24, "ABI_align_needed", 0, NULL
},
15341 {25, "ABI_align_preserved", 0, NULL
},
15342 LOOKUP(26, ABI_enum_size
),
15343 LOOKUP(27, ABI_HardFP_use
),
15344 LOOKUP(28, ABI_VFP_args
),
15345 LOOKUP(29, ABI_WMMX_args
),
15346 LOOKUP(30, ABI_optimization_goals
),
15347 LOOKUP(31, ABI_FP_optimization_goals
),
15348 {32, "compatibility", 0, NULL
},
15349 LOOKUP(34, CPU_unaligned_access
),
15350 LOOKUP(36, FP_HP_extension
),
15351 LOOKUP(38, ABI_FP_16bit_format
),
15352 LOOKUP(42, MPextension_use
),
15353 LOOKUP(44, DIV_use
),
15354 LOOKUP(46, DSP_extension
),
15355 LOOKUP(48, MVE_arch
),
15356 {64, "nodefaults", 0, NULL
},
15357 {65, "also_compatible_with", 0, NULL
},
15358 LOOKUP(66, T2EE_use
),
15359 {67, "conformance", 1, NULL
},
15360 LOOKUP(68, Virtualization_use
),
15361 LOOKUP(70, MPextension_use_legacy
)
15365 static unsigned char *
15366 display_arm_attribute (unsigned char * p
,
15367 const unsigned char * const end
)
15371 arm_attr_public_tag
* attr
;
15375 READ_ULEB (tag
, p
, end
);
15377 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
15379 if (arm_attr_public_tags
[i
].tag
== tag
)
15381 attr
= &arm_attr_public_tags
[i
];
15388 printf (" Tag_%s: ", attr
->name
);
15389 switch (attr
->type
)
15394 case 7: /* Tag_CPU_arch_profile. */
15395 READ_ULEB (val
, p
, end
);
15398 case 0: printf (_("None\n")); break;
15399 case 'A': printf (_("Application\n")); break;
15400 case 'R': printf (_("Realtime\n")); break;
15401 case 'M': printf (_("Microcontroller\n")); break;
15402 case 'S': printf (_("Application or Realtime\n")); break;
15403 default: printf ("??? (%d)\n", val
); break;
15407 case 24: /* Tag_align_needed. */
15408 READ_ULEB (val
, p
, end
);
15411 case 0: printf (_("None\n")); break;
15412 case 1: printf (_("8-byte\n")); break;
15413 case 2: printf (_("4-byte\n")); break;
15414 case 3: printf ("??? 3\n"); break;
15417 printf (_("8-byte and up to %d-byte extended\n"),
15420 printf ("??? (%d)\n", val
);
15425 case 25: /* Tag_align_preserved. */
15426 READ_ULEB (val
, p
, end
);
15429 case 0: printf (_("None\n")); break;
15430 case 1: printf (_("8-byte, except leaf SP\n")); break;
15431 case 2: printf (_("8-byte\n")); break;
15432 case 3: printf ("??? 3\n"); break;
15435 printf (_("8-byte and up to %d-byte extended\n"),
15438 printf ("??? (%d)\n", val
);
15443 case 32: /* Tag_compatibility. */
15445 READ_ULEB (val
, p
, end
);
15446 printf (_("flag = %d, vendor = "), val
);
15449 size_t maxlen
= (end
- p
) - 1;
15451 print_symbol ((int) maxlen
, (const char *) p
);
15452 p
+= strnlen ((char *) p
, maxlen
) + 1;
15456 printf (_("<corrupt>"));
15457 p
= (unsigned char *) end
;
15463 case 64: /* Tag_nodefaults. */
15464 /* PR 17531: file: 001-505008-0.01. */
15467 printf (_("True\n"));
15470 case 65: /* Tag_also_compatible_with. */
15471 READ_ULEB (val
, p
, end
);
15472 if (val
== 6 /* Tag_CPU_arch. */)
15474 READ_ULEB (val
, p
, end
);
15475 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
15476 printf ("??? (%d)\n", val
);
15478 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
15482 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
15487 printf (_("<unknown: %d>\n"), tag
);
15493 return display_tag_value (-1, p
, end
);
15495 return display_tag_value (0, p
, end
);
15498 assert (attr
->type
& 0x80);
15499 READ_ULEB (val
, p
, end
);
15500 type
= attr
->type
& 0x7f;
15502 printf ("??? (%d)\n", val
);
15504 printf ("%s\n", attr
->table
[val
]);
15509 return display_tag_value (tag
, p
, end
);
15512 static unsigned char *
15513 display_gnu_attribute (unsigned char * p
,
15514 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
15515 const unsigned char * const end
)
15520 READ_ULEB (tag
, p
, end
);
15522 /* Tag_compatibility is the only generic GNU attribute defined at
15526 READ_ULEB (val
, p
, end
);
15528 printf (_("flag = %d, vendor = "), val
);
15531 printf (_("<corrupt>\n"));
15532 warn (_("corrupt vendor attribute\n"));
15538 size_t maxlen
= (end
- p
) - 1;
15540 print_symbol ((int) maxlen
, (const char *) p
);
15541 p
+= strnlen ((char *) p
, maxlen
) + 1;
15545 printf (_("<corrupt>"));
15546 p
= (unsigned char *) end
;
15553 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15554 return display_proc_gnu_attribute (p
, tag
, end
);
15556 return display_tag_value (tag
, p
, end
);
15559 static unsigned char *
15560 display_m68k_gnu_attribute (unsigned char * p
,
15562 const unsigned char * const end
)
15566 if (tag
== Tag_GNU_M68K_ABI_FP
)
15568 printf (" Tag_GNU_M68K_ABI_FP: ");
15571 printf (_("<corrupt>\n"));
15574 READ_ULEB (val
, p
, end
);
15577 printf ("(%#x), ", val
);
15582 printf (_("unspecified hard/soft float\n"));
15585 printf (_("hard float\n"));
15588 printf (_("soft float\n"));
15594 return display_tag_value (tag
& 1, p
, end
);
15597 static unsigned char *
15598 display_power_gnu_attribute (unsigned char * p
,
15600 const unsigned char * const end
)
15604 if (tag
== Tag_GNU_Power_ABI_FP
)
15606 printf (" Tag_GNU_Power_ABI_FP: ");
15609 printf (_("<corrupt>\n"));
15612 READ_ULEB (val
, p
, end
);
15615 printf ("(%#x), ", val
);
15620 printf (_("unspecified hard/soft float, "));
15623 printf (_("hard float, "));
15626 printf (_("soft float, "));
15629 printf (_("single-precision hard float, "));
15636 printf (_("unspecified long double\n"));
15639 printf (_("128-bit IBM long double\n"));
15642 printf (_("64-bit long double\n"));
15645 printf (_("128-bit IEEE long double\n"));
15651 if (tag
== Tag_GNU_Power_ABI_Vector
)
15653 printf (" Tag_GNU_Power_ABI_Vector: ");
15656 printf (_("<corrupt>\n"));
15659 READ_ULEB (val
, p
, end
);
15662 printf ("(%#x), ", val
);
15667 printf (_("unspecified\n"));
15670 printf (_("generic\n"));
15673 printf ("AltiVec\n");
15682 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
15684 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15687 printf (_("<corrupt>\n"));
15690 READ_ULEB (val
, p
, end
);
15693 printf ("(%#x), ", val
);
15698 printf (_("unspecified\n"));
15701 printf ("r3/r4\n");
15704 printf (_("memory\n"));
15713 return display_tag_value (tag
& 1, p
, end
);
15716 static unsigned char *
15717 display_s390_gnu_attribute (unsigned char * p
,
15719 const unsigned char * const end
)
15723 if (tag
== Tag_GNU_S390_ABI_Vector
)
15725 printf (" Tag_GNU_S390_ABI_Vector: ");
15726 READ_ULEB (val
, p
, end
);
15731 printf (_("any\n"));
15734 printf (_("software\n"));
15737 printf (_("hardware\n"));
15740 printf ("??? (%d)\n", val
);
15746 return display_tag_value (tag
& 1, p
, end
);
15750 display_sparc_hwcaps (unsigned int mask
)
15754 bfd_boolean first
= TRUE
;
15756 if (mask
& ELF_SPARC_HWCAP_MUL32
)
15757 fputs ("mul32", stdout
), first
= FALSE
;
15758 if (mask
& ELF_SPARC_HWCAP_DIV32
)
15759 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
15760 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
15761 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
15762 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
15763 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
15764 if (mask
& ELF_SPARC_HWCAP_POPC
)
15765 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
15766 if (mask
& ELF_SPARC_HWCAP_VIS
)
15767 printf ("%svis", first
? "" : "|"), first
= FALSE
;
15768 if (mask
& ELF_SPARC_HWCAP_VIS2
)
15769 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
15770 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
15771 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
15772 if (mask
& ELF_SPARC_HWCAP_FMAF
)
15773 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
15774 if (mask
& ELF_SPARC_HWCAP_VIS3
)
15775 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
15776 if (mask
& ELF_SPARC_HWCAP_HPC
)
15777 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
15778 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
15779 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
15780 if (mask
& ELF_SPARC_HWCAP_TRANS
)
15781 printf ("%strans", first
? "" : "|"), first
= FALSE
;
15782 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
15783 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
15784 if (mask
& ELF_SPARC_HWCAP_IMA
)
15785 printf ("%sima", first
? "" : "|"), first
= FALSE
;
15786 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
15787 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
15790 fputc ('0', stdout
);
15791 fputc ('\n', stdout
);
15795 display_sparc_hwcaps2 (unsigned int mask
)
15799 bfd_boolean first
= TRUE
;
15801 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
15802 fputs ("fjathplus", stdout
), first
= FALSE
;
15803 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
15804 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
15805 if (mask
& ELF_SPARC_HWCAP2_ADP
)
15806 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
15807 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
15808 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
15809 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
15810 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
15811 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
15812 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
15813 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
15814 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
15815 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
15816 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
15817 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
15818 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
15819 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
15820 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
15821 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
15822 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
15825 fputc ('0', stdout
);
15826 fputc ('\n', stdout
);
15829 static unsigned char *
15830 display_sparc_gnu_attribute (unsigned char * p
,
15832 const unsigned char * const end
)
15836 if (tag
== Tag_GNU_Sparc_HWCAPS
)
15838 READ_ULEB (val
, p
, end
);
15839 printf (" Tag_GNU_Sparc_HWCAPS: ");
15840 display_sparc_hwcaps (val
);
15843 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
15845 READ_ULEB (val
, p
, end
);
15846 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15847 display_sparc_hwcaps2 (val
);
15851 return display_tag_value (tag
, p
, end
);
15855 print_mips_fp_abi_value (unsigned int val
)
15859 case Val_GNU_MIPS_ABI_FP_ANY
:
15860 printf (_("Hard or soft float\n"));
15862 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15863 printf (_("Hard float (double precision)\n"));
15865 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15866 printf (_("Hard float (single precision)\n"));
15868 case Val_GNU_MIPS_ABI_FP_SOFT
:
15869 printf (_("Soft float\n"));
15871 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15872 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15874 case Val_GNU_MIPS_ABI_FP_XX
:
15875 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15877 case Val_GNU_MIPS_ABI_FP_64
:
15878 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15880 case Val_GNU_MIPS_ABI_FP_64A
:
15881 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15883 case Val_GNU_MIPS_ABI_FP_NAN2008
:
15884 printf (_("NaN 2008 compatibility\n"));
15887 printf ("??? (%d)\n", val
);
15892 static unsigned char *
15893 display_mips_gnu_attribute (unsigned char * p
,
15895 const unsigned char * const end
)
15897 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15901 printf (" Tag_GNU_MIPS_ABI_FP: ");
15902 READ_ULEB (val
, p
, end
);
15903 print_mips_fp_abi_value (val
);
15907 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15911 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15912 READ_ULEB (val
, p
, end
);
15916 case Val_GNU_MIPS_ABI_MSA_ANY
:
15917 printf (_("Any MSA or not\n"));
15919 case Val_GNU_MIPS_ABI_MSA_128
:
15920 printf (_("128-bit MSA\n"));
15923 printf ("??? (%d)\n", val
);
15929 return display_tag_value (tag
& 1, p
, end
);
15932 static unsigned char *
15933 display_tic6x_attribute (unsigned char * p
,
15934 const unsigned char * const end
)
15939 READ_ULEB (tag
, p
, end
);
15944 printf (" Tag_ISA: ");
15945 READ_ULEB (val
, p
, end
);
15949 case C6XABI_Tag_ISA_none
:
15950 printf (_("None\n"));
15952 case C6XABI_Tag_ISA_C62X
:
15955 case C6XABI_Tag_ISA_C67X
:
15958 case C6XABI_Tag_ISA_C67XP
:
15959 printf ("C67x+\n");
15961 case C6XABI_Tag_ISA_C64X
:
15964 case C6XABI_Tag_ISA_C64XP
:
15965 printf ("C64x+\n");
15967 case C6XABI_Tag_ISA_C674X
:
15968 printf ("C674x\n");
15971 printf ("??? (%d)\n", val
);
15976 case Tag_ABI_wchar_t
:
15977 printf (" Tag_ABI_wchar_t: ");
15978 READ_ULEB (val
, p
, end
);
15982 printf (_("Not used\n"));
15985 printf (_("2 bytes\n"));
15988 printf (_("4 bytes\n"));
15991 printf ("??? (%d)\n", val
);
15996 case Tag_ABI_stack_align_needed
:
15997 printf (" Tag_ABI_stack_align_needed: ");
15998 READ_ULEB (val
, p
, end
);
16002 printf (_("8-byte\n"));
16005 printf (_("16-byte\n"));
16008 printf ("??? (%d)\n", val
);
16013 case Tag_ABI_stack_align_preserved
:
16014 READ_ULEB (val
, p
, end
);
16015 printf (" Tag_ABI_stack_align_preserved: ");
16019 printf (_("8-byte\n"));
16022 printf (_("16-byte\n"));
16025 printf ("??? (%d)\n", val
);
16031 READ_ULEB (val
, p
, end
);
16032 printf (" Tag_ABI_DSBT: ");
16036 printf (_("DSBT addressing not used\n"));
16039 printf (_("DSBT addressing used\n"));
16042 printf ("??? (%d)\n", val
);
16048 READ_ULEB (val
, p
, end
);
16049 printf (" Tag_ABI_PID: ");
16053 printf (_("Data addressing position-dependent\n"));
16056 printf (_("Data addressing position-independent, GOT near DP\n"));
16059 printf (_("Data addressing position-independent, GOT far from DP\n"));
16062 printf ("??? (%d)\n", val
);
16068 READ_ULEB (val
, p
, end
);
16069 printf (" Tag_ABI_PIC: ");
16073 printf (_("Code addressing position-dependent\n"));
16076 printf (_("Code addressing position-independent\n"));
16079 printf ("??? (%d)\n", val
);
16084 case Tag_ABI_array_object_alignment
:
16085 READ_ULEB (val
, p
, end
);
16086 printf (" Tag_ABI_array_object_alignment: ");
16090 printf (_("8-byte\n"));
16093 printf (_("4-byte\n"));
16096 printf (_("16-byte\n"));
16099 printf ("??? (%d)\n", val
);
16104 case Tag_ABI_array_object_align_expected
:
16105 READ_ULEB (val
, p
, end
);
16106 printf (" Tag_ABI_array_object_align_expected: ");
16110 printf (_("8-byte\n"));
16113 printf (_("4-byte\n"));
16116 printf (_("16-byte\n"));
16119 printf ("??? (%d)\n", val
);
16124 case Tag_ABI_compatibility
:
16126 READ_ULEB (val
, p
, end
);
16127 printf (" Tag_ABI_compatibility: ");
16128 printf (_("flag = %d, vendor = "), val
);
16131 size_t maxlen
= (end
- p
) - 1;
16133 print_symbol ((int) maxlen
, (const char *) p
);
16134 p
+= strnlen ((char *) p
, maxlen
) + 1;
16138 printf (_("<corrupt>"));
16139 p
= (unsigned char *) end
;
16145 case Tag_ABI_conformance
:
16147 printf (" Tag_ABI_conformance: \"");
16150 size_t maxlen
= (end
- p
) - 1;
16152 print_symbol ((int) maxlen
, (const char *) p
);
16153 p
+= strnlen ((char *) p
, maxlen
) + 1;
16157 printf (_("<corrupt>"));
16158 p
= (unsigned char *) end
;
16165 return display_tag_value (tag
, p
, end
);
16169 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
16171 unsigned long addr
= 0;
16172 size_t bytes
= end
- p
;
16179 int lbytes
= (bytes
> 16 ? 16 : bytes
);
16181 printf (" 0x%8.8lx ", addr
);
16183 for (j
= 0; j
< 16; j
++)
16186 printf ("%2.2x", p
[j
]);
16194 for (j
= 0; j
< lbytes
; j
++)
16197 if (k
>= ' ' && k
< 0x7f)
16213 static unsigned char *
16214 display_msp430_attribute (unsigned char * p
,
16215 const unsigned char * const end
)
16220 READ_ULEB (tag
, p
, end
);
16224 case OFBA_MSPABI_Tag_ISA
:
16225 printf (" Tag_ISA: ");
16226 READ_ULEB (val
, p
, end
);
16229 case 0: printf (_("None\n")); break;
16230 case 1: printf (_("MSP430\n")); break;
16231 case 2: printf (_("MSP430X\n")); break;
16232 default: printf ("??? (%d)\n", val
); break;
16236 case OFBA_MSPABI_Tag_Code_Model
:
16237 printf (" Tag_Code_Model: ");
16238 READ_ULEB (val
, p
, end
);
16241 case 0: printf (_("None\n")); break;
16242 case 1: printf (_("Small\n")); break;
16243 case 2: printf (_("Large\n")); break;
16244 default: printf ("??? (%d)\n", val
); break;
16248 case OFBA_MSPABI_Tag_Data_Model
:
16249 printf (" Tag_Data_Model: ");
16250 READ_ULEB (val
, p
, end
);
16253 case 0: printf (_("None\n")); break;
16254 case 1: printf (_("Small\n")); break;
16255 case 2: printf (_("Large\n")); break;
16256 case 3: printf (_("Restricted Large\n")); break;
16257 default: printf ("??? (%d)\n", val
); break;
16262 printf (_(" <unknown tag %d>: "), tag
);
16269 size_t maxlen
= (end
- p
) - 1;
16271 print_symbol ((int) maxlen
, (const char *) p
);
16272 p
+= strnlen ((char *) p
, maxlen
) + 1;
16276 printf (_("<corrupt>"));
16277 p
= (unsigned char *) end
;
16283 READ_ULEB (val
, p
, end
);
16284 printf ("%d (0x%x)\n", val
, val
);
16293 static unsigned char *
16294 display_msp430_gnu_attribute (unsigned char * p
,
16296 const unsigned char * const end
)
16298 if (tag
== Tag_GNU_MSP430_Data_Region
)
16302 printf (" Tag_GNU_MSP430_Data_Region: ");
16303 READ_ULEB (val
, p
, end
);
16307 case Val_GNU_MSP430_Data_Region_Any
:
16308 printf (_("Any Region\n"));
16310 case Val_GNU_MSP430_Data_Region_Lower
:
16311 printf (_("Lower Region Only\n"));
16314 printf ("??? (%u)\n", val
);
16318 return display_tag_value (tag
& 1, p
, end
);
16321 struct riscv_attr_tag_t
{
16326 static struct riscv_attr_tag_t riscv_attr_tag
[] =
16328 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
16331 T(priv_spec_minor
),
16332 T(priv_spec_revision
),
16333 T(unaligned_access
),
16338 static unsigned char *
16339 display_riscv_attribute (unsigned char *p
,
16340 const unsigned char * const end
)
16344 struct riscv_attr_tag_t
*attr
= NULL
;
16347 READ_ULEB (tag
, p
, end
);
16349 /* Find the name of attribute. */
16350 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
16352 if (riscv_attr_tag
[i
].tag
== tag
)
16354 attr
= &riscv_attr_tag
[i
];
16360 printf (" %s: ", attr
->name
);
16362 return display_tag_value (tag
, p
, end
);
16366 case Tag_RISCV_priv_spec
:
16367 case Tag_RISCV_priv_spec_minor
:
16368 case Tag_RISCV_priv_spec_revision
:
16369 READ_ULEB (val
, p
, end
);
16370 printf (_("%u\n"), val
);
16372 case Tag_RISCV_unaligned_access
:
16373 READ_ULEB (val
, p
, end
);
16377 printf (_("No unaligned access\n"));
16380 printf (_("Unaligned access\n"));
16384 case Tag_RISCV_stack_align
:
16385 READ_ULEB (val
, p
, end
);
16386 printf (_("%u-bytes\n"), val
);
16388 case Tag_RISCV_arch
:
16389 p
= display_tag_value (-1, p
, end
);
16392 return display_tag_value (tag
, p
, end
);
16398 static unsigned char *
16399 display_csky_attribute (unsigned char * p
,
16400 const unsigned char * const end
)
16404 READ_ULEB (tag
, p
, end
);
16406 if (tag
>= Tag_CSKY_MAX
)
16408 return display_tag_value (-1, p
, end
);
16413 case Tag_CSKY_ARCH_NAME
:
16414 printf (" Tag_CSKY_ARCH_NAME:\t\t");
16415 return display_tag_value (-1, p
, end
);
16416 case Tag_CSKY_CPU_NAME
:
16417 printf (" Tag_CSKY_CPU_NAME:\t\t");
16418 return display_tag_value (-1, p
, end
);
16420 case Tag_CSKY_ISA_FLAGS
:
16421 printf (" Tag_CSKY_ISA_FLAGS:\t\t");
16422 return display_tag_value (0, p
, end
);
16423 case Tag_CSKY_ISA_EXT_FLAGS
:
16424 printf (" Tag_CSKY_ISA_EXT_FLAGS:\t");
16425 return display_tag_value (0, p
, end
);
16427 case Tag_CSKY_DSP_VERSION
:
16428 printf (" Tag_CSKY_DSP_VERSION:\t\t");
16429 READ_ULEB (val
, p
, end
);
16430 if (val
== VAL_CSKY_DSP_VERSION_EXTENSION
)
16431 printf ("DSP Extension\n");
16432 else if (val
== VAL_CSKY_DSP_VERSION_2
)
16433 printf ("DSP 2.0\n");
16436 case Tag_CSKY_VDSP_VERSION
:
16437 printf (" Tag_CSKY_VDSP_VERSION:\t");
16438 READ_ULEB (val
, p
, end
);
16439 printf ("VDSP Version %d\n", val
);
16442 case Tag_CSKY_FPU_VERSION
:
16443 printf (" Tag_CSKY_FPU_VERSION:\t\t");
16444 READ_ULEB (val
, p
, end
);
16445 if (val
== VAL_CSKY_FPU_VERSION_1
)
16446 printf ("ABIV1 FPU Version 1\n");
16447 else if (val
== VAL_CSKY_FPU_VERSION_2
)
16448 printf ("FPU Version 2\n");
16451 case Tag_CSKY_FPU_ABI
:
16452 printf (" Tag_CSKY_FPU_ABI:\t\t");
16453 READ_ULEB (val
, p
, end
);
16454 if (val
== VAL_CSKY_FPU_ABI_HARD
)
16456 else if (val
== VAL_CSKY_FPU_ABI_SOFTFP
)
16457 printf ("SoftFP\n");
16458 else if (val
== VAL_CSKY_FPU_ABI_SOFT
)
16461 case Tag_CSKY_FPU_ROUNDING
:
16462 READ_ULEB (val
, p
, end
);
16464 printf (" Tag_CSKY_FPU_ROUNDING:\t");
16465 printf ("Needed\n");
16468 case Tag_CSKY_FPU_DENORMAL
:
16469 READ_ULEB (val
, p
, end
);
16471 printf (" Tag_CSKY_FPU_DENORMAL:\t");
16472 printf ("Needed\n");
16475 case Tag_CSKY_FPU_Exception
:
16476 READ_ULEB (val
, p
, end
);
16478 printf (" Tag_CSKY_FPU_Exception:\t");
16479 printf ("Needed\n");
16482 case Tag_CSKY_FPU_NUMBER_MODULE
:
16483 printf (" Tag_CSKY_FPU_NUMBER_MODULE:\t");
16484 return display_tag_value (-1, p
, end
);
16485 case Tag_CSKY_FPU_HARDFP
:
16486 printf (" Tag_CSKY_FPU_HARDFP:\t\t");
16487 READ_ULEB (val
, p
, end
);
16488 if (val
& VAL_CSKY_FPU_HARDFP_HALF
)
16490 if (val
& VAL_CSKY_FPU_HARDFP_SINGLE
)
16491 printf (" Single");
16492 if (val
& VAL_CSKY_FPU_HARDFP_DOUBLE
)
16493 printf (" Double");
16497 return display_tag_value (tag
, p
, end
);
16503 process_attributes (Filedata
* filedata
,
16504 const char * public_name
,
16505 unsigned int proc_type
,
16506 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
16507 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
16509 Elf_Internal_Shdr
* sect
;
16511 bfd_boolean res
= TRUE
;
16513 /* Find the section header so that we get the size. */
16514 for (i
= 0, sect
= filedata
->section_headers
;
16515 i
< filedata
->file_header
.e_shnum
;
16518 unsigned char * contents
;
16521 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
16524 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16525 sect
->sh_size
, _("attributes"));
16526 if (contents
== NULL
)
16533 /* The first character is the version of the attributes.
16534 Currently only version 1, (aka 'A') is recognised here. */
16537 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
16542 bfd_vma section_len
;
16544 section_len
= sect
->sh_size
- 1;
16547 while (section_len
> 0)
16550 unsigned int namelen
;
16551 bfd_boolean public_section
;
16552 bfd_boolean gnu_section
;
16554 if (section_len
<= 4)
16556 error (_("Tag section ends prematurely\n"));
16560 attr_len
= byte_get (p
, 4);
16563 if (attr_len
> section_len
)
16565 error (_("Bad attribute length (%u > %u)\n"),
16566 (unsigned) attr_len
, (unsigned) section_len
);
16567 attr_len
= section_len
;
16570 /* PR 17531: file: 001-101425-0.004 */
16571 else if (attr_len
< 5)
16573 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
16578 section_len
-= attr_len
;
16581 namelen
= strnlen ((char *) p
, attr_len
) + 1;
16582 if (namelen
== 0 || namelen
>= attr_len
)
16584 error (_("Corrupt attribute section name\n"));
16589 printf (_("Attribute Section: "));
16590 print_symbol (INT_MAX
, (const char *) p
);
16593 if (public_name
&& streq ((char *) p
, public_name
))
16594 public_section
= TRUE
;
16596 public_section
= FALSE
;
16598 if (streq ((char *) p
, "gnu"))
16599 gnu_section
= TRUE
;
16601 gnu_section
= FALSE
;
16604 attr_len
-= namelen
;
16606 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
16611 unsigned char * end
;
16613 /* PR binutils/17531: Safe handling of corrupt files. */
16616 error (_("Unused bytes at end of section\n"));
16623 size
= byte_get (p
, 4);
16624 if (size
> attr_len
)
16626 error (_("Bad subsection length (%u > %u)\n"),
16627 (unsigned) size
, (unsigned) attr_len
);
16631 /* PR binutils/17531: Safe handling of corrupt files. */
16634 error (_("Bad subsection length (%u < 6)\n"),
16642 end
= p
+ size
- 1;
16643 assert (end
<= contents
+ sect
->sh_size
);
16649 printf (_("File Attributes\n"));
16652 printf (_("Section Attributes:"));
16655 printf (_("Symbol Attributes:"));
16656 /* Fall through. */
16660 READ_ULEB (val
, p
, end
);
16663 printf (" %d", val
);
16668 printf (_("Unknown tag: %d\n"), tag
);
16669 public_section
= FALSE
;
16673 if (public_section
&& display_pub_attribute
!= NULL
)
16676 p
= display_pub_attribute (p
, end
);
16679 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
16682 p
= display_gnu_attribute (p
,
16683 display_proc_gnu_attribute
,
16689 printf (_(" Unknown attribute:\n"));
16690 display_raw_attribute (p
, end
);
16705 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16706 Print the Address, Access and Initial fields of an entry at VMA ADDR
16707 and return the VMA of the next entry, or -1 if there was a problem.
16708 Does not read from DATA_END or beyond. */
16711 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
16712 unsigned char * data_end
)
16715 print_vma (addr
, LONG_HEX
);
16717 if (addr
< pltgot
+ 0xfff0)
16718 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
16720 printf ("%10s", "");
16723 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16727 unsigned char * from
= data
+ addr
- pltgot
;
16729 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
16731 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16732 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
16733 return (bfd_vma
) -1;
16737 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16738 print_vma (entry
, LONG_HEX
);
16741 return addr
+ (is_32bit_elf
? 4 : 8);
16744 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16745 PLTGOT. Print the Address and Initial fields of an entry at VMA
16746 ADDR and return the VMA of the next entry. */
16749 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
16752 print_vma (addr
, LONG_HEX
);
16755 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16760 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16761 print_vma (entry
, LONG_HEX
);
16763 return addr
+ (is_32bit_elf
? 4 : 8);
16767 print_mips_ases (unsigned int mask
)
16769 if (mask
& AFL_ASE_DSP
)
16770 fputs ("\n\tDSP ASE", stdout
);
16771 if (mask
& AFL_ASE_DSPR2
)
16772 fputs ("\n\tDSP R2 ASE", stdout
);
16773 if (mask
& AFL_ASE_DSPR3
)
16774 fputs ("\n\tDSP R3 ASE", stdout
);
16775 if (mask
& AFL_ASE_EVA
)
16776 fputs ("\n\tEnhanced VA Scheme", stdout
);
16777 if (mask
& AFL_ASE_MCU
)
16778 fputs ("\n\tMCU (MicroController) ASE", stdout
);
16779 if (mask
& AFL_ASE_MDMX
)
16780 fputs ("\n\tMDMX ASE", stdout
);
16781 if (mask
& AFL_ASE_MIPS3D
)
16782 fputs ("\n\tMIPS-3D ASE", stdout
);
16783 if (mask
& AFL_ASE_MT
)
16784 fputs ("\n\tMT ASE", stdout
);
16785 if (mask
& AFL_ASE_SMARTMIPS
)
16786 fputs ("\n\tSmartMIPS ASE", stdout
);
16787 if (mask
& AFL_ASE_VIRT
)
16788 fputs ("\n\tVZ ASE", stdout
);
16789 if (mask
& AFL_ASE_MSA
)
16790 fputs ("\n\tMSA ASE", stdout
);
16791 if (mask
& AFL_ASE_MIPS16
)
16792 fputs ("\n\tMIPS16 ASE", stdout
);
16793 if (mask
& AFL_ASE_MICROMIPS
)
16794 fputs ("\n\tMICROMIPS ASE", stdout
);
16795 if (mask
& AFL_ASE_XPA
)
16796 fputs ("\n\tXPA ASE", stdout
);
16797 if (mask
& AFL_ASE_MIPS16E2
)
16798 fputs ("\n\tMIPS16e2 ASE", stdout
);
16799 if (mask
& AFL_ASE_CRC
)
16800 fputs ("\n\tCRC ASE", stdout
);
16801 if (mask
& AFL_ASE_GINV
)
16802 fputs ("\n\tGINV ASE", stdout
);
16803 if (mask
& AFL_ASE_LOONGSON_MMI
)
16804 fputs ("\n\tLoongson MMI ASE", stdout
);
16805 if (mask
& AFL_ASE_LOONGSON_CAM
)
16806 fputs ("\n\tLoongson CAM ASE", stdout
);
16807 if (mask
& AFL_ASE_LOONGSON_EXT
)
16808 fputs ("\n\tLoongson EXT ASE", stdout
);
16809 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16810 fputs ("\n\tLoongson EXT2 ASE", stdout
);
16812 fprintf (stdout
, "\n\t%s", _("None"));
16813 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16814 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16818 print_mips_isa_ext (unsigned int isa_ext
)
16823 fputs (_("None"), stdout
);
16826 fputs ("RMI XLR", stdout
);
16828 case AFL_EXT_OCTEON3
:
16829 fputs ("Cavium Networks Octeon3", stdout
);
16831 case AFL_EXT_OCTEON2
:
16832 fputs ("Cavium Networks Octeon2", stdout
);
16834 case AFL_EXT_OCTEONP
:
16835 fputs ("Cavium Networks OcteonP", stdout
);
16837 case AFL_EXT_OCTEON
:
16838 fputs ("Cavium Networks Octeon", stdout
);
16841 fputs ("Toshiba R5900", stdout
);
16844 fputs ("MIPS R4650", stdout
);
16847 fputs ("LSI R4010", stdout
);
16850 fputs ("NEC VR4100", stdout
);
16853 fputs ("Toshiba R3900", stdout
);
16855 case AFL_EXT_10000
:
16856 fputs ("MIPS R10000", stdout
);
16859 fputs ("Broadcom SB-1", stdout
);
16862 fputs ("NEC VR4111/VR4181", stdout
);
16865 fputs ("NEC VR4120", stdout
);
16868 fputs ("NEC VR5400", stdout
);
16871 fputs ("NEC VR5500", stdout
);
16873 case AFL_EXT_LOONGSON_2E
:
16874 fputs ("ST Microelectronics Loongson 2E", stdout
);
16876 case AFL_EXT_LOONGSON_2F
:
16877 fputs ("ST Microelectronics Loongson 2F", stdout
);
16879 case AFL_EXT_INTERAPTIV_MR2
:
16880 fputs ("Imagination interAptiv MR2", stdout
);
16883 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
16888 get_mips_reg_size (int reg_size
)
16890 return (reg_size
== AFL_REG_NONE
) ? 0
16891 : (reg_size
== AFL_REG_32
) ? 32
16892 : (reg_size
== AFL_REG_64
) ? 64
16893 : (reg_size
== AFL_REG_128
) ? 128
16898 process_mips_specific (Filedata
* filedata
)
16900 Elf_Internal_Dyn
* entry
;
16901 Elf_Internal_Shdr
*sect
= NULL
;
16902 size_t liblist_offset
= 0;
16903 size_t liblistno
= 0;
16904 size_t conflictsno
= 0;
16905 size_t options_offset
= 0;
16906 size_t conflicts_offset
= 0;
16907 size_t pltrelsz
= 0;
16909 bfd_vma pltgot
= 0;
16910 bfd_vma mips_pltgot
= 0;
16911 bfd_vma jmprel
= 0;
16912 bfd_vma local_gotno
= 0;
16913 bfd_vma gotsym
= 0;
16914 bfd_vma symtabno
= 0;
16915 bfd_boolean res
= TRUE
;
16917 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16918 display_mips_gnu_attribute
))
16921 sect
= find_section (filedata
, ".MIPS.abiflags");
16925 Elf_External_ABIFlags_v0
*abiflags_ext
;
16926 Elf_Internal_ABIFlags_v0 abiflags_in
;
16928 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
16930 error (_("Corrupt MIPS ABI Flags section.\n"));
16935 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16936 sect
->sh_size
, _("MIPS ABI Flags section"));
16939 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
16940 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
16941 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
16942 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
16943 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
16944 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
16945 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
16946 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
16947 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
16948 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
16949 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
16951 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
16952 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
16953 if (abiflags_in
.isa_rev
> 1)
16954 printf ("r%d", abiflags_in
.isa_rev
);
16955 printf ("\nGPR size: %d",
16956 get_mips_reg_size (abiflags_in
.gpr_size
));
16957 printf ("\nCPR1 size: %d",
16958 get_mips_reg_size (abiflags_in
.cpr1_size
));
16959 printf ("\nCPR2 size: %d",
16960 get_mips_reg_size (abiflags_in
.cpr2_size
));
16961 fputs ("\nFP ABI: ", stdout
);
16962 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
16963 fputs ("ISA Extension: ", stdout
);
16964 print_mips_isa_ext (abiflags_in
.isa_ext
);
16965 fputs ("\nASEs:", stdout
);
16966 print_mips_ases (abiflags_in
.ases
);
16967 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
16968 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
16969 fputc ('\n', stdout
);
16970 free (abiflags_ext
);
16975 /* We have a lot of special sections. Thanks SGI! */
16976 if (filedata
->dynamic_section
== NULL
)
16978 /* No dynamic information available. See if there is static GOT. */
16979 sect
= find_section (filedata
, ".got");
16982 unsigned char *data_end
;
16983 unsigned char *data
;
16987 pltgot
= sect
->sh_addr
;
16990 addr_size
= (is_32bit_elf
? 4 : 8);
16991 end
= pltgot
+ sect
->sh_size
;
16993 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
16995 _("Global Offset Table data"));
16996 /* PR 12855: Null data is handled gracefully throughout. */
16997 data_end
= data
+ (end
- pltgot
);
16999 printf (_("\nStatic GOT:\n"));
17000 printf (_(" Canonical gp value: "));
17001 print_vma (ent
+ 0x7ff0, LONG_HEX
);
17004 /* In a dynamic binary GOT[0] is reserved for the dynamic
17005 loader to store the lazy resolver pointer, however in
17006 a static binary it may well have been omitted and GOT
17007 reduced to a table of addresses.
17008 PR 21344: Check for the entry being fully available
17009 before fetching it. */
17011 && data
+ ent
- pltgot
+ addr_size
<= data_end
17012 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
17014 printf (_(" Reserved entries:\n"));
17015 printf (_(" %*s %10s %*s\n"),
17016 addr_size
* 2, _("Address"), _("Access"),
17017 addr_size
* 2, _("Value"));
17018 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17020 if (ent
== (bfd_vma
) -1)
17021 goto sgot_print_fail
;
17023 /* Check for the MSB of GOT[1] being set, identifying a
17024 GNU object. This entry will be used by some runtime
17025 loaders, to store the module pointer. Otherwise this
17026 is an ordinary local entry.
17027 PR 21344: Check for the entry being fully available
17028 before fetching it. */
17030 && data
+ ent
- pltgot
+ addr_size
<= data_end
17031 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17032 >> (addr_size
* 8 - 1)) != 0)
17034 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17036 if (ent
== (bfd_vma
) -1)
17037 goto sgot_print_fail
;
17042 if (data
!= NULL
&& ent
< end
)
17044 printf (_(" Local entries:\n"));
17045 printf (" %*s %10s %*s\n",
17046 addr_size
* 2, _("Address"), _("Access"),
17047 addr_size
* 2, _("Value"));
17050 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17052 if (ent
== (bfd_vma
) -1)
17053 goto sgot_print_fail
;
17064 for (entry
= filedata
->dynamic_section
;
17065 /* PR 17531 file: 012-50589-0.004. */
17066 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
17067 && entry
->d_tag
!= DT_NULL
);
17069 switch (entry
->d_tag
)
17071 case DT_MIPS_LIBLIST
:
17073 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
17074 liblistno
* sizeof (Elf32_External_Lib
));
17076 case DT_MIPS_LIBLISTNO
:
17077 liblistno
= entry
->d_un
.d_val
;
17079 case DT_MIPS_OPTIONS
:
17080 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
17082 case DT_MIPS_CONFLICT
:
17084 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
17085 conflictsno
* sizeof (Elf32_External_Conflict
));
17087 case DT_MIPS_CONFLICTNO
:
17088 conflictsno
= entry
->d_un
.d_val
;
17091 pltgot
= entry
->d_un
.d_ptr
;
17093 case DT_MIPS_LOCAL_GOTNO
:
17094 local_gotno
= entry
->d_un
.d_val
;
17096 case DT_MIPS_GOTSYM
:
17097 gotsym
= entry
->d_un
.d_val
;
17099 case DT_MIPS_SYMTABNO
:
17100 symtabno
= entry
->d_un
.d_val
;
17102 case DT_MIPS_PLTGOT
:
17103 mips_pltgot
= entry
->d_un
.d_ptr
;
17106 pltrel
= entry
->d_un
.d_val
;
17109 pltrelsz
= entry
->d_un
.d_val
;
17112 jmprel
= entry
->d_un
.d_ptr
;
17118 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
17120 Elf32_External_Lib
* elib
;
17123 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
17124 sizeof (Elf32_External_Lib
),
17126 _("liblist section data"));
17129 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
17130 "\nSection '.liblist' contains %lu entries:\n",
17131 (unsigned long) liblistno
),
17132 (unsigned long) liblistno
);
17133 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
17136 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
17143 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17144 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17145 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17146 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17147 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17149 tmp
= gmtime (&atime
);
17150 snprintf (timebuf
, sizeof (timebuf
),
17151 "%04u-%02u-%02uT%02u:%02u:%02u",
17152 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17153 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17155 printf ("%3lu: ", (unsigned long) cnt
);
17156 if (VALID_DYNAMIC_NAME (filedata
, liblist
.l_name
))
17157 print_symbol (20, GET_DYNAMIC_NAME (filedata
, liblist
.l_name
));
17159 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
17160 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
17161 liblist
.l_version
);
17163 if (liblist
.l_flags
== 0)
17167 static const struct
17174 { " EXACT_MATCH", LL_EXACT_MATCH
},
17175 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
17176 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
17177 { " EXPORTS", LL_EXPORTS
},
17178 { " DELAY_LOAD", LL_DELAY_LOAD
},
17179 { " DELTA", LL_DELTA
}
17181 int flags
= liblist
.l_flags
;
17184 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
17185 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
17187 fputs (l_flags_vals
[fcnt
].name
, stdout
);
17188 flags
^= l_flags_vals
[fcnt
].bit
;
17191 printf (" %#x", (unsigned int) flags
);
17203 if (options_offset
!= 0)
17205 Elf_External_Options
* eopt
;
17208 sect
= filedata
->section_headers
;
17210 /* Find the section header so that we get the size. */
17211 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
17212 /* PR 17533 file: 012-277276-0.004. */
17215 error (_("No MIPS_OPTIONS header found\n"));
17219 if (sect
->sh_size
< sizeof (* eopt
))
17221 error (_("The MIPS options section is too small.\n"));
17225 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
17226 sect
->sh_size
, _("options"));
17229 Elf_Internal_Options option
;
17232 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
17234 Elf_External_Options
* eoption
;
17235 unsigned int optsize
;
17237 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
17239 optsize
= BYTE_GET (eoption
->size
);
17241 /* PR 17531: file: ffa0fa3b. */
17242 if (optsize
< sizeof (* eopt
)
17243 || optsize
> sect
->sh_size
- offset
)
17245 error (_("Invalid size (%u) for MIPS option\n"),
17254 printf (ngettext ("\nSection '%s' contains %d entry:\n",
17255 "\nSection '%s' contains %d entries:\n",
17257 printable_section_name (filedata
, sect
), cnt
);
17263 Elf_External_Options
* eoption
;
17265 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
17267 option
.kind
= BYTE_GET (eoption
->kind
);
17268 option
.size
= BYTE_GET (eoption
->size
);
17269 option
.section
= BYTE_GET (eoption
->section
);
17270 option
.info
= BYTE_GET (eoption
->info
);
17272 switch (option
.kind
)
17275 /* This shouldn't happen. */
17276 printf (" NULL %" PRId16
" %" PRIx32
,
17277 option
.section
, option
.info
);
17281 printf (" REGINFO ");
17282 if (filedata
->file_header
.e_machine
== EM_MIPS
)
17284 Elf32_External_RegInfo
* ereg
;
17285 Elf32_RegInfo reginfo
;
17288 if (option
.size
< (sizeof (Elf_External_Options
)
17289 + sizeof (Elf32_External_RegInfo
)))
17291 printf (_("<corrupt>\n"));
17292 error (_("Truncated MIPS REGINFO option\n"));
17297 ereg
= (Elf32_External_RegInfo
*) (eoption
+ 1);
17299 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
17300 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
17301 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
17302 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
17303 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
17304 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
17306 printf ("GPR %08" PRIx32
" GP 0x%" PRIx32
"\n",
17307 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
17309 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
17310 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
17311 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17312 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17317 Elf64_External_RegInfo
* ereg
;
17318 Elf64_Internal_RegInfo reginfo
;
17320 if (option
.size
< (sizeof (Elf_External_Options
)
17321 + sizeof (Elf64_External_RegInfo
)))
17323 printf (_("<corrupt>\n"));
17324 error (_("Truncated MIPS REGINFO option\n"));
17329 ereg
= (Elf64_External_RegInfo
*) (eoption
+ 1);
17330 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
17331 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
17332 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
17333 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
17334 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
17335 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
17337 printf ("GPR %08" PRIx32
" GP 0x%" PRIx64
"\n",
17338 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
17340 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
17341 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
17342 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17343 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17345 offset
+= option
.size
;
17348 case ODK_EXCEPTIONS
:
17349 fputs (" EXCEPTIONS fpe_min(", stdout
);
17350 process_mips_fpe_exception (option
.info
& OEX_FPU_MIN
);
17351 fputs (") fpe_max(", stdout
);
17352 process_mips_fpe_exception ((option
.info
& OEX_FPU_MAX
) >> 8);
17353 fputs (")", stdout
);
17355 if (option
.info
& OEX_PAGE0
)
17356 fputs (" PAGE0", stdout
);
17357 if (option
.info
& OEX_SMM
)
17358 fputs (" SMM", stdout
);
17359 if (option
.info
& OEX_FPDBUG
)
17360 fputs (" FPDBUG", stdout
);
17361 if (option
.info
& OEX_DISMISS
)
17362 fputs (" DISMISS", stdout
);
17366 fputs (" PAD ", stdout
);
17367 if (option
.info
& OPAD_PREFIX
)
17368 fputs (" PREFIX", stdout
);
17369 if (option
.info
& OPAD_POSTFIX
)
17370 fputs (" POSTFIX", stdout
);
17371 if (option
.info
& OPAD_SYMBOL
)
17372 fputs (" SYMBOL", stdout
);
17376 fputs (" HWPATCH ", stdout
);
17377 if (option
.info
& OHW_R4KEOP
)
17378 fputs (" R4KEOP", stdout
);
17379 if (option
.info
& OHW_R8KPFETCH
)
17380 fputs (" R8KPFETCH", stdout
);
17381 if (option
.info
& OHW_R5KEOP
)
17382 fputs (" R5KEOP", stdout
);
17383 if (option
.info
& OHW_R5KCVTL
)
17384 fputs (" R5KCVTL", stdout
);
17388 fputs (" FILL ", stdout
);
17389 /* XXX Print content of info word? */
17393 fputs (" TAGS ", stdout
);
17394 /* XXX Print content of info word? */
17398 fputs (" HWAND ", stdout
);
17399 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
17400 fputs (" R4KEOP_CHECKED", stdout
);
17401 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
17402 fputs (" R4KEOP_CLEAN", stdout
);
17406 fputs (" HWOR ", stdout
);
17407 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
17408 fputs (" R4KEOP_CHECKED", stdout
);
17409 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
17410 fputs (" R4KEOP_CLEAN", stdout
);
17414 printf (" GP_GROUP %#06x self-contained %#06x",
17415 option
.info
& OGP_GROUP
,
17416 (option
.info
& OGP_SELF
) >> 16);
17420 printf (" IDENT %#06x self-contained %#06x",
17421 option
.info
& OGP_GROUP
,
17422 (option
.info
& OGP_SELF
) >> 16);
17426 /* This shouldn't happen. */
17427 printf (" %3d ??? %" PRId16
" %" PRIx32
,
17428 option
.kind
, option
.section
, option
.info
);
17432 len
= sizeof (* eopt
);
17433 while (len
< option
.size
)
17435 unsigned char datum
= *((unsigned char *) eoption
+ len
);
17437 if (ISPRINT (datum
))
17438 printf ("%c", datum
);
17440 printf ("\\%03o", datum
);
17443 fputs ("\n", stdout
);
17445 offset
+= option
.size
;
17453 if (conflicts_offset
!= 0 && conflictsno
!= 0)
17455 Elf32_Conflict
* iconf
;
17458 if (filedata
->dynamic_symbols
== NULL
)
17460 error (_("conflict list found without a dynamic symbol table\n"));
17464 /* PR 21345 - print a slightly more helpful error message
17465 if we are sure that the cmalloc will fail. */
17466 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
17468 error (_("Overlarge number of conflicts detected: %lx\n"),
17469 (long) conflictsno
);
17473 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
17476 error (_("Out of memory allocating space for dynamic conflicts\n"));
17482 Elf32_External_Conflict
* econf32
;
17484 econf32
= (Elf32_External_Conflict
*)
17485 get_data (NULL
, filedata
, conflicts_offset
,
17486 sizeof (*econf32
), conflictsno
, _("conflict"));
17493 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17494 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
17500 Elf64_External_Conflict
* econf64
;
17502 econf64
= (Elf64_External_Conflict
*)
17503 get_data (NULL
, filedata
, conflicts_offset
,
17504 sizeof (*econf64
), conflictsno
, _("conflict"));
17511 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17512 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
17517 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
17518 "\nSection '.conflict' contains %lu entries:\n",
17519 (unsigned long) conflictsno
),
17520 (unsigned long) conflictsno
);
17521 puts (_(" Num: Index Value Name"));
17523 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17525 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
17527 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
17528 printf (_("<corrupt symbol index>"));
17531 Elf_Internal_Sym
* psym
;
17533 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
17534 print_vma (psym
->st_value
, FULL_HEX
);
17536 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17537 print_symbol (25, GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17539 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17547 if (pltgot
!= 0 && local_gotno
!= 0)
17549 bfd_vma ent
, local_end
, global_end
;
17551 unsigned char * data
;
17552 unsigned char * data_end
;
17556 addr_size
= (is_32bit_elf
? 4 : 8);
17557 local_end
= pltgot
+ local_gotno
* addr_size
;
17559 /* PR binutils/17533 file: 012-111227-0.004 */
17560 if (symtabno
< gotsym
)
17562 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17563 (unsigned long) gotsym
, (unsigned long) symtabno
);
17567 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
17568 /* PR 17531: file: 54c91a34. */
17569 if (global_end
< local_end
)
17571 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
17575 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
17576 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
17577 global_end
- pltgot
, 1,
17578 _("Global Offset Table data"));
17579 /* PR 12855: Null data is handled gracefully throughout. */
17580 data_end
= data
+ (global_end
- pltgot
);
17582 printf (_("\nPrimary GOT:\n"));
17583 printf (_(" Canonical gp value: "));
17584 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
17587 printf (_(" Reserved entries:\n"));
17588 printf (_(" %*s %10s %*s Purpose\n"),
17589 addr_size
* 2, _("Address"), _("Access"),
17590 addr_size
* 2, _("Initial"));
17591 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17592 printf (_(" Lazy resolver\n"));
17593 if (ent
== (bfd_vma
) -1)
17594 goto got_print_fail
;
17596 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17597 This entry will be used by some runtime loaders, to store the
17598 module pointer. Otherwise this is an ordinary local entry.
17599 PR 21344: Check for the entry being fully available before
17602 && data
+ ent
- pltgot
+ addr_size
<= data_end
17603 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17604 >> (addr_size
* 8 - 1)) != 0)
17606 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17607 printf (_(" Module pointer (GNU extension)\n"));
17608 if (ent
== (bfd_vma
) -1)
17609 goto got_print_fail
;
17613 if (data
!= NULL
&& ent
< local_end
)
17615 printf (_(" Local entries:\n"));
17616 printf (" %*s %10s %*s\n",
17617 addr_size
* 2, _("Address"), _("Access"),
17618 addr_size
* 2, _("Initial"));
17619 while (ent
< local_end
)
17621 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17623 if (ent
== (bfd_vma
) -1)
17624 goto got_print_fail
;
17629 if (data
!= NULL
&& gotsym
< symtabno
)
17633 printf (_(" Global entries:\n"));
17634 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17635 addr_size
* 2, _("Address"),
17637 addr_size
* 2, _("Initial"),
17638 addr_size
* 2, _("Sym.Val."),
17640 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17641 _("Ndx"), _("Name"));
17643 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
17645 for (i
= gotsym
; i
< symtabno
; i
++)
17647 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17650 if (filedata
->dynamic_symbols
== NULL
)
17651 printf (_("<no dynamic symbols>"));
17652 else if (i
< filedata
->num_dynamic_syms
)
17654 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
17656 print_vma (psym
->st_value
, LONG_HEX
);
17657 printf (" %-7s %3s ",
17658 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17659 get_symbol_index_type (filedata
, psym
->st_shndx
));
17661 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17662 print_symbol (sym_width
,
17663 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17665 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17668 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17669 (unsigned long) i
);
17672 if (ent
== (bfd_vma
) -1)
17682 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
17685 size_t offset
, rel_offset
;
17686 unsigned long count
, i
;
17687 unsigned char * data
;
17688 int addr_size
, sym_width
;
17689 Elf_Internal_Rela
* rels
;
17691 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
17692 if (pltrel
== DT_RELA
)
17694 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17699 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17704 addr_size
= (is_32bit_elf
? 4 : 8);
17705 end
= mips_pltgot
+ (2 + count
) * addr_size
;
17707 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
17708 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
17709 1, _("Procedure Linkage Table data"));
17713 printf ("\nPLT GOT:\n\n");
17714 printf (_(" Reserved entries:\n"));
17715 printf (_(" %*s %*s Purpose\n"),
17716 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
17717 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17718 printf (_(" PLT lazy resolver\n"));
17719 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17720 printf (_(" Module pointer\n"));
17723 printf (_(" Entries:\n"));
17724 printf (" %*s %*s %*s %-7s %3s %s\n",
17725 addr_size
* 2, _("Address"),
17726 addr_size
* 2, _("Initial"),
17727 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17728 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
17729 for (i
= 0; i
< count
; i
++)
17731 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
17733 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17736 if (idx
>= filedata
->num_dynamic_syms
)
17737 printf (_("<corrupt symbol index: %lu>"), idx
);
17740 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
17742 print_vma (psym
->st_value
, LONG_HEX
);
17743 printf (" %-7s %3s ",
17744 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17745 get_symbol_index_type (filedata
, psym
->st_shndx
));
17746 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17747 print_symbol (sym_width
,
17748 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17750 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17764 process_nds32_specific (Filedata
* filedata
)
17766 Elf_Internal_Shdr
*sect
= NULL
;
17768 sect
= find_section (filedata
, ".nds32_e_flags");
17769 if (sect
!= NULL
&& sect
->sh_size
>= 4)
17771 unsigned char *buf
;
17774 printf ("\nNDS32 elf flags section:\n");
17775 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
17776 _("NDS32 elf flags section"));
17781 flag
= byte_get (buf
, 4);
17783 switch (flag
& 0x3)
17786 printf ("(VEC_SIZE):\tNo entry.\n");
17789 printf ("(VEC_SIZE):\t4 bytes\n");
17792 printf ("(VEC_SIZE):\t16 bytes\n");
17795 printf ("(VEC_SIZE):\treserved\n");
17804 process_gnu_liblist (Filedata
* filedata
)
17806 Elf_Internal_Shdr
* section
;
17807 Elf_Internal_Shdr
* string_sec
;
17808 Elf32_External_Lib
* elib
;
17810 size_t strtab_size
;
17812 unsigned long num_liblist
;
17814 bfd_boolean res
= TRUE
;
17819 for (i
= 0, section
= filedata
->section_headers
;
17820 i
< filedata
->file_header
.e_shnum
;
17823 switch (section
->sh_type
)
17825 case SHT_GNU_LIBLIST
:
17826 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
17829 elib
= (Elf32_External_Lib
*)
17830 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
17831 _("liblist section data"));
17839 string_sec
= filedata
->section_headers
+ section
->sh_link
;
17840 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
17841 string_sec
->sh_size
,
17842 _("liblist string table"));
17844 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
17851 strtab_size
= string_sec
->sh_size
;
17853 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
17854 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17855 "\nLibrary list section '%s' contains %lu entries:\n",
17857 printable_section_name (filedata
, section
),
17860 puts (_(" Library Time Stamp Checksum Version Flags"));
17862 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
17870 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17871 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17872 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17873 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17874 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17876 tmp
= gmtime (&atime
);
17877 snprintf (timebuf
, sizeof (timebuf
),
17878 "%04u-%02u-%02uT%02u:%02u:%02u",
17879 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17880 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17882 printf ("%3lu: ", (unsigned long) cnt
);
17884 printf ("%-20s", liblist
.l_name
< strtab_size
17885 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17887 printf ("%-20.20s", liblist
.l_name
< strtab_size
17888 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17889 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
17890 liblist
.l_version
, liblist
.l_flags
);
17901 static const char *
17902 get_note_type (Filedata
* filedata
, unsigned e_type
)
17904 static char buff
[64];
17906 if (filedata
->file_header
.e_type
== ET_CORE
)
17910 return _("NT_AUXV (auxiliary vector)");
17912 return _("NT_PRSTATUS (prstatus structure)");
17914 return _("NT_FPREGSET (floating point registers)");
17916 return _("NT_PRPSINFO (prpsinfo structure)");
17917 case NT_TASKSTRUCT
:
17918 return _("NT_TASKSTRUCT (task structure)");
17920 return _("NT_PRXFPREG (user_xfpregs structure)");
17922 return _("NT_PPC_VMX (ppc Altivec registers)");
17924 return _("NT_PPC_VSX (ppc VSX registers)");
17926 return _("NT_PPC_TAR (ppc TAR register)");
17928 return _("NT_PPC_PPR (ppc PPR register)");
17930 return _("NT_PPC_DSCR (ppc DSCR register)");
17932 return _("NT_PPC_EBB (ppc EBB registers)");
17934 return _("NT_PPC_PMU (ppc PMU registers)");
17935 case NT_PPC_TM_CGPR
:
17936 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17937 case NT_PPC_TM_CFPR
:
17938 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17939 case NT_PPC_TM_CVMX
:
17940 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17941 case NT_PPC_TM_CVSX
:
17942 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17943 case NT_PPC_TM_SPR
:
17944 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17945 case NT_PPC_TM_CTAR
:
17946 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17947 case NT_PPC_TM_CPPR
:
17948 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17949 case NT_PPC_TM_CDSCR
:
17950 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17952 return _("NT_386_TLS (x86 TLS information)");
17953 case NT_386_IOPERM
:
17954 return _("NT_386_IOPERM (x86 I/O permissions)");
17955 case NT_X86_XSTATE
:
17956 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17958 return _("NT_X86_CET (x86 CET state)");
17959 case NT_S390_HIGH_GPRS
:
17960 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17961 case NT_S390_TIMER
:
17962 return _("NT_S390_TIMER (s390 timer register)");
17963 case NT_S390_TODCMP
:
17964 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17965 case NT_S390_TODPREG
:
17966 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17968 return _("NT_S390_CTRS (s390 control registers)");
17969 case NT_S390_PREFIX
:
17970 return _("NT_S390_PREFIX (s390 prefix register)");
17971 case NT_S390_LAST_BREAK
:
17972 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17973 case NT_S390_SYSTEM_CALL
:
17974 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17976 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17977 case NT_S390_VXRS_LOW
:
17978 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17979 case NT_S390_VXRS_HIGH
:
17980 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17981 case NT_S390_GS_CB
:
17982 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17983 case NT_S390_GS_BC
:
17984 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17986 return _("NT_ARM_VFP (arm VFP registers)");
17988 return _("NT_ARM_TLS (AArch TLS registers)");
17989 case NT_ARM_HW_BREAK
:
17990 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17991 case NT_ARM_HW_WATCH
:
17992 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17994 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
17996 return _("NT_PSTATUS (pstatus structure)");
17998 return _("NT_FPREGS (floating point registers)");
18000 return _("NT_PSINFO (psinfo structure)");
18002 return _("NT_LWPSTATUS (lwpstatus_t structure)");
18004 return _("NT_LWPSINFO (lwpsinfo_t structure)");
18005 case NT_WIN32PSTATUS
:
18006 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
18008 return _("NT_SIGINFO (siginfo_t data)");
18010 return _("NT_FILE (mapped files)");
18018 return _("NT_VERSION (version)");
18020 return _("NT_ARCH (architecture)");
18021 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
18023 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
18029 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18034 print_core_note (Elf_Internal_Note
*pnote
)
18036 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
18037 bfd_vma count
, page_size
;
18038 unsigned char *descdata
, *filenames
, *descend
;
18040 if (pnote
->type
!= NT_FILE
)
18050 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
18051 /* Still "successful". */
18056 if (pnote
->descsz
< 2 * addr_size
)
18058 error (_(" Malformed note - too short for header\n"));
18062 descdata
= (unsigned char *) pnote
->descdata
;
18063 descend
= descdata
+ pnote
->descsz
;
18065 if (descdata
[pnote
->descsz
- 1] != '\0')
18067 error (_(" Malformed note - does not end with \\0\n"));
18071 count
= byte_get (descdata
, addr_size
);
18072 descdata
+= addr_size
;
18074 page_size
= byte_get (descdata
, addr_size
);
18075 descdata
+= addr_size
;
18077 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
18078 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
18080 error (_(" Malformed note - too short for supplied file count\n"));
18084 printf (_(" Page size: "));
18085 print_vma (page_size
, DEC
);
18088 printf (_(" %*s%*s%*s\n"),
18089 (int) (2 + 2 * addr_size
), _("Start"),
18090 (int) (4 + 2 * addr_size
), _("End"),
18091 (int) (4 + 2 * addr_size
), _("Page Offset"));
18092 filenames
= descdata
+ count
* 3 * addr_size
;
18093 while (count
-- > 0)
18095 bfd_vma start
, end
, file_ofs
;
18097 if (filenames
== descend
)
18099 error (_(" Malformed note - filenames end too early\n"));
18103 start
= byte_get (descdata
, addr_size
);
18104 descdata
+= addr_size
;
18105 end
= byte_get (descdata
, addr_size
);
18106 descdata
+= addr_size
;
18107 file_ofs
= byte_get (descdata
, addr_size
);
18108 descdata
+= addr_size
;
18111 print_vma (start
, FULL_HEX
);
18113 print_vma (end
, FULL_HEX
);
18115 print_vma (file_ofs
, FULL_HEX
);
18116 printf ("\n %s\n", filenames
);
18118 filenames
+= 1 + strlen ((char *) filenames
);
18124 static const char *
18125 get_gnu_elf_note_type (unsigned e_type
)
18127 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
18130 case NT_GNU_ABI_TAG
:
18131 return _("NT_GNU_ABI_TAG (ABI version tag)");
18133 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
18134 case NT_GNU_BUILD_ID
:
18135 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
18136 case NT_GNU_GOLD_VERSION
:
18137 return _("NT_GNU_GOLD_VERSION (gold version)");
18138 case NT_GNU_PROPERTY_TYPE_0
:
18139 return _("NT_GNU_PROPERTY_TYPE_0");
18140 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
18141 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
18142 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
18143 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
18146 static char buff
[64];
18148 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18155 decode_x86_compat_isa (unsigned int bitmask
)
18159 unsigned int bit
= bitmask
& (- bitmask
);
18164 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
18167 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
18170 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
18173 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
18176 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
18179 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
18182 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
18185 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
18188 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
18191 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
18194 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
18197 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
18198 printf ("AVX512F");
18200 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
18201 printf ("AVX512CD");
18203 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
18204 printf ("AVX512ER");
18206 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
18207 printf ("AVX512PF");
18209 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
18210 printf ("AVX512VL");
18212 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
18213 printf ("AVX512DQ");
18215 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
18216 printf ("AVX512BW");
18219 printf (_("<unknown: %x>"), bit
);
18228 decode_x86_isa (unsigned int bitmask
)
18232 printf (_("<None>"));
18238 unsigned int bit
= bitmask
& (- bitmask
);
18243 case GNU_PROPERTY_X86_ISA_1_CMOV
:
18246 case GNU_PROPERTY_X86_ISA_1_SSE
:
18249 case GNU_PROPERTY_X86_ISA_1_SSE2
:
18252 case GNU_PROPERTY_X86_ISA_1_SSE3
:
18255 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
18258 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
18261 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
18264 case GNU_PROPERTY_X86_ISA_1_AVX
:
18267 case GNU_PROPERTY_X86_ISA_1_AVX2
:
18270 case GNU_PROPERTY_X86_ISA_1_FMA
:
18273 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
18274 printf ("AVX512F");
18276 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
18277 printf ("AVX512CD");
18279 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
18280 printf ("AVX512ER");
18282 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
18283 printf ("AVX512PF");
18285 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
18286 printf ("AVX512VL");
18288 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
18289 printf ("AVX512DQ");
18291 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
18292 printf ("AVX512BW");
18294 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
18295 printf ("AVX512_4FMAPS");
18297 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
18298 printf ("AVX512_4VNNIW");
18300 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
18301 printf ("AVX512_BITALG");
18303 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
18304 printf ("AVX512_IFMA");
18306 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
18307 printf ("AVX512_VBMI");
18309 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
18310 printf ("AVX512_VBMI2");
18312 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
18313 printf ("AVX512_VNNI");
18315 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16
:
18316 printf ("AVX512_BF16");
18319 printf (_("<unknown: %x>"), bit
);
18328 decode_x86_feature_1 (unsigned int bitmask
)
18332 printf (_("<None>"));
18338 unsigned int bit
= bitmask
& (- bitmask
);
18343 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
18346 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
18350 printf (_("<unknown: %x>"), bit
);
18359 decode_x86_feature_2 (unsigned int bitmask
)
18363 printf (_("<None>"));
18369 unsigned int bit
= bitmask
& (- bitmask
);
18374 case GNU_PROPERTY_X86_FEATURE_2_X86
:
18377 case GNU_PROPERTY_X86_FEATURE_2_X87
:
18380 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
18383 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
18386 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
18389 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
18392 case GNU_PROPERTY_X86_FEATURE_2_TMM
:
18395 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
18398 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
18401 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
18402 printf ("XSAVEOPT");
18404 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
18408 printf (_("<unknown: %x>"), bit
);
18417 decode_aarch64_feature_1_and (unsigned int bitmask
)
18421 unsigned int bit
= bitmask
& (- bitmask
);
18426 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
18430 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
18435 printf (_("<unknown: %x>"), bit
);
18444 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
18446 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
18447 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
18448 unsigned int size
= is_32bit_elf
? 4 : 8;
18450 printf (_(" Properties: "));
18452 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
18454 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
18458 while (ptr
< ptr_end
)
18462 unsigned int datasz
;
18464 if ((size_t) (ptr_end
- ptr
) < 8)
18466 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
18470 type
= byte_get (ptr
, 4);
18471 datasz
= byte_get (ptr
+ 4, 4);
18475 if (datasz
> (size_t) (ptr_end
- ptr
))
18477 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
18482 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
18484 if (filedata
->file_header
.e_machine
== EM_X86_64
18485 || filedata
->file_header
.e_machine
== EM_IAMCU
18486 || filedata
->file_header
.e_machine
== EM_386
)
18488 unsigned int bitmask
;
18491 bitmask
= byte_get (ptr
, 4);
18497 case GNU_PROPERTY_X86_ISA_1_USED
:
18499 printf (_("x86 ISA used: <corrupt length: %#x> "),
18503 printf ("x86 ISA used: ");
18504 decode_x86_isa (bitmask
);
18508 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
18510 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18514 printf ("x86 ISA needed: ");
18515 decode_x86_isa (bitmask
);
18519 case GNU_PROPERTY_X86_FEATURE_1_AND
:
18521 printf (_("x86 feature: <corrupt length: %#x> "),
18525 printf ("x86 feature: ");
18526 decode_x86_feature_1 (bitmask
);
18530 case GNU_PROPERTY_X86_FEATURE_2_USED
:
18532 printf (_("x86 feature used: <corrupt length: %#x> "),
18536 printf ("x86 feature used: ");
18537 decode_x86_feature_2 (bitmask
);
18541 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
18543 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
18546 printf ("x86 feature needed: ");
18547 decode_x86_feature_2 (bitmask
);
18551 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
18553 printf (_("x86 ISA used: <corrupt length: %#x> "),
18557 printf ("x86 ISA used: ");
18558 decode_x86_compat_isa (bitmask
);
18562 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
18564 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18568 printf ("x86 ISA needed: ");
18569 decode_x86_compat_isa (bitmask
);
18577 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
18579 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
18581 printf ("AArch64 feature: ");
18583 printf (_("<corrupt length: %#x> "), datasz
);
18585 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
18594 case GNU_PROPERTY_STACK_SIZE
:
18595 printf (_("stack size: "));
18596 if (datasz
!= size
)
18597 printf (_("<corrupt length: %#x> "), datasz
);
18599 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
18602 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
18603 printf ("no copy on protected ");
18605 printf (_("<corrupt length: %#x> "), datasz
);
18613 if (type
< GNU_PROPERTY_LOPROC
)
18614 printf (_("<unknown type %#x data: "), type
);
18615 else if (type
< GNU_PROPERTY_LOUSER
)
18616 printf (_("<procesor-specific type %#x data: "), type
);
18618 printf (_("<application-specific type %#x data: "), type
);
18619 for (j
= 0; j
< datasz
; ++j
)
18620 printf ("%02x ", ptr
[j
] & 0xff);
18624 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
18625 if (ptr
== ptr_end
)
18638 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
18640 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18641 switch (pnote
->type
)
18643 case NT_GNU_BUILD_ID
:
18647 printf (_(" Build ID: "));
18648 for (i
= 0; i
< pnote
->descsz
; ++i
)
18649 printf ("%02x", pnote
->descdata
[i
] & 0xff);
18654 case NT_GNU_ABI_TAG
:
18656 unsigned long os
, major
, minor
, subminor
;
18657 const char *osname
;
18659 /* PR 17531: file: 030-599401-0.004. */
18660 if (pnote
->descsz
< 16)
18662 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18666 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18667 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18668 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
18669 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
18673 case GNU_ABI_TAG_LINUX
:
18676 case GNU_ABI_TAG_HURD
:
18679 case GNU_ABI_TAG_SOLARIS
:
18680 osname
= "Solaris";
18682 case GNU_ABI_TAG_FREEBSD
:
18683 osname
= "FreeBSD";
18685 case GNU_ABI_TAG_NETBSD
:
18688 case GNU_ABI_TAG_SYLLABLE
:
18689 osname
= "Syllable";
18691 case GNU_ABI_TAG_NACL
:
18695 osname
= "Unknown";
18699 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
18700 major
, minor
, subminor
);
18704 case NT_GNU_GOLD_VERSION
:
18708 printf (_(" Version: "));
18709 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
18710 printf ("%c", pnote
->descdata
[i
]);
18717 unsigned long num_entries
, mask
;
18719 /* Hardware capabilities information. Word 0 is the number of entries.
18720 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18721 is a series of entries, where each entry is a single byte followed
18722 by a nul terminated string. The byte gives the bit number to test
18723 if enabled in the bitmask. */
18724 printf (_(" Hardware Capabilities: "));
18725 if (pnote
->descsz
< 8)
18727 error (_("<corrupt GNU_HWCAP>\n"));
18730 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18731 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18732 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
18733 /* FIXME: Add code to display the entries... */
18737 case NT_GNU_PROPERTY_TYPE_0
:
18738 print_gnu_property_note (filedata
, pnote
);
18742 /* Handle unrecognised types. An error message should have already been
18743 created by get_gnu_elf_note_type(), so all that we need to do is to
18744 display the data. */
18748 printf (_(" Description data: "));
18749 for (i
= 0; i
< pnote
->descsz
; ++i
)
18750 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
18759 static const char *
18760 get_v850_elf_note_type (enum v850_notes n_type
)
18762 static char buff
[64];
18766 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
18767 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
18768 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
18769 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
18770 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
18771 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
18773 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
18779 print_v850_note (Elf_Internal_Note
* pnote
)
18783 if (pnote
->descsz
!= 4)
18786 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
18790 printf (_("not set\n"));
18794 switch (pnote
->type
)
18796 case V850_NOTE_ALIGNMENT
:
18799 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
18800 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
18804 case V850_NOTE_DATA_SIZE
:
18807 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
18808 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
18812 case V850_NOTE_FPU_INFO
:
18815 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
18816 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
18820 case V850_NOTE_MMU_INFO
:
18821 case V850_NOTE_CACHE_INFO
:
18822 case V850_NOTE_SIMD_INFO
:
18823 if (val
== EF_RH850_SIMD
)
18825 printf (_("yes\n"));
18831 /* An 'unknown note type' message will already have been displayed. */
18835 printf (_("unknown value: %x\n"), val
);
18840 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
18842 unsigned int version
;
18844 switch (pnote
->type
)
18846 case NT_NETBSD_IDENT
:
18847 if (pnote
->descsz
< 1)
18849 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18850 if ((version
/ 10000) % 100)
18851 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
18852 version
, version
/ 100000000, (version
/ 1000000) % 100,
18853 (version
/ 10000) % 100 > 26 ? "Z" : "",
18854 'A' + (version
/ 10000) % 26);
18856 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
18857 version
, version
/ 100000000, (version
/ 1000000) % 100,
18858 (version
/ 100) % 100);
18861 case NT_NETBSD_MARCH
:
18862 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
18866 #ifdef NT_NETBSD_PAX
18867 case NT_NETBSD_PAX
:
18868 if (pnote
->descsz
< 1)
18870 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18871 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
18872 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
18873 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
18874 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
18875 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
18876 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
18877 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
18882 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
18883 pnote
->descsz
, pnote
->type
);
18887 static const char *
18888 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18892 case NT_FREEBSD_THRMISC
:
18893 return _("NT_THRMISC (thrmisc structure)");
18894 case NT_FREEBSD_PROCSTAT_PROC
:
18895 return _("NT_PROCSTAT_PROC (proc data)");
18896 case NT_FREEBSD_PROCSTAT_FILES
:
18897 return _("NT_PROCSTAT_FILES (files data)");
18898 case NT_FREEBSD_PROCSTAT_VMMAP
:
18899 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18900 case NT_FREEBSD_PROCSTAT_GROUPS
:
18901 return _("NT_PROCSTAT_GROUPS (groups data)");
18902 case NT_FREEBSD_PROCSTAT_UMASK
:
18903 return _("NT_PROCSTAT_UMASK (umask data)");
18904 case NT_FREEBSD_PROCSTAT_RLIMIT
:
18905 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18906 case NT_FREEBSD_PROCSTAT_OSREL
:
18907 return _("NT_PROCSTAT_OSREL (osreldate data)");
18908 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
18909 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18910 case NT_FREEBSD_PROCSTAT_AUXV
:
18911 return _("NT_PROCSTAT_AUXV (auxv data)");
18912 case NT_FREEBSD_PTLWPINFO
:
18913 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18915 return get_note_type (filedata
, e_type
);
18918 static const char *
18919 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18921 static char buff
[64];
18925 case NT_NETBSDCORE_PROCINFO
:
18926 /* NetBSD core "procinfo" structure. */
18927 return _("NetBSD procinfo structure");
18929 #ifdef NT_NETBSDCORE_AUXV
18930 case NT_NETBSDCORE_AUXV
:
18931 return _("NetBSD ELF auxiliary vector data");
18934 #ifdef NT_NETBSDCORE_LWPSTATUS
18935 case NT_NETBSDCORE_LWPSTATUS
:
18936 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
18940 /* As of Jan 2020 there are no other machine-independent notes
18941 defined for NetBSD core files. If the note type is less
18942 than the start of the machine-dependent note types, we don't
18945 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
18947 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18953 switch (filedata
->file_header
.e_machine
)
18955 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18956 and PT_GETFPREGS == mach+2. */
18961 case EM_SPARC32PLUS
:
18965 case NT_NETBSDCORE_FIRSTMACH
+ 0:
18966 return _("PT_GETREGS (reg structure)");
18967 case NT_NETBSDCORE_FIRSTMACH
+ 2:
18968 return _("PT_GETFPREGS (fpreg structure)");
18974 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18975 There's also old PT___GETREGS40 == mach + 1 for old reg
18976 structure which lacks GBR. */
18980 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18981 return _("PT___GETREGS40 (old reg structure)");
18982 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18983 return _("PT_GETREGS (reg structure)");
18984 case NT_NETBSDCORE_FIRSTMACH
+ 5:
18985 return _("PT_GETFPREGS (fpreg structure)");
18991 /* On all other arch's, PT_GETREGS == mach+1 and
18992 PT_GETFPREGS == mach+3. */
18996 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18997 return _("PT_GETREGS (reg structure)");
18998 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18999 return _("PT_GETFPREGS (fpreg structure)");
19005 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
19006 e_type
- NT_NETBSDCORE_FIRSTMACH
);
19010 static const char *
19011 get_stapsdt_note_type (unsigned e_type
)
19013 static char buff
[64];
19018 return _("NT_STAPSDT (SystemTap probe descriptors)");
19024 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19029 print_stapsdt_note (Elf_Internal_Note
*pnote
)
19031 size_t len
, maxlen
;
19032 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
19033 char *data
= pnote
->descdata
;
19034 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
19035 bfd_vma pc
, base_addr
, semaphore
;
19036 char *provider
, *probe
, *arg_fmt
;
19038 if (pnote
->descsz
< (addr_size
* 3))
19039 goto stapdt_note_too_small
;
19041 pc
= byte_get ((unsigned char *) data
, addr_size
);
19044 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
19047 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
19050 if (data
>= data_end
)
19051 goto stapdt_note_too_small
;
19052 maxlen
= data_end
- data
;
19053 len
= strnlen (data
, maxlen
);
19060 goto stapdt_note_too_small
;
19062 if (data
>= data_end
)
19063 goto stapdt_note_too_small
;
19064 maxlen
= data_end
- data
;
19065 len
= strnlen (data
, maxlen
);
19072 goto stapdt_note_too_small
;
19074 if (data
>= data_end
)
19075 goto stapdt_note_too_small
;
19076 maxlen
= data_end
- data
;
19077 len
= strnlen (data
, maxlen
);
19084 goto stapdt_note_too_small
;
19086 printf (_(" Provider: %s\n"), provider
);
19087 printf (_(" Name: %s\n"), probe
);
19088 printf (_(" Location: "));
19089 print_vma (pc
, FULL_HEX
);
19090 printf (_(", Base: "));
19091 print_vma (base_addr
, FULL_HEX
);
19092 printf (_(", Semaphore: "));
19093 print_vma (semaphore
, FULL_HEX
);
19095 printf (_(" Arguments: %s\n"), arg_fmt
);
19097 return data
== data_end
;
19099 stapdt_note_too_small
:
19100 printf (_(" <corrupt - note is too small>\n"));
19101 error (_("corrupt stapdt note - the data size is too small\n"));
19105 static const char *
19106 get_ia64_vms_note_type (unsigned e_type
)
19108 static char buff
[64];
19113 return _("NT_VMS_MHD (module header)");
19115 return _("NT_VMS_LNM (language name)");
19117 return _("NT_VMS_SRC (source files)");
19119 return "NT_VMS_TITLE";
19121 return _("NT_VMS_EIDC (consistency check)");
19122 case NT_VMS_FPMODE
:
19123 return _("NT_VMS_FPMODE (FP mode)");
19124 case NT_VMS_LINKTIME
:
19125 return "NT_VMS_LINKTIME";
19126 case NT_VMS_IMGNAM
:
19127 return _("NT_VMS_IMGNAM (image name)");
19129 return _("NT_VMS_IMGID (image id)");
19130 case NT_VMS_LINKID
:
19131 return _("NT_VMS_LINKID (link id)");
19132 case NT_VMS_IMGBID
:
19133 return _("NT_VMS_IMGBID (build id)");
19134 case NT_VMS_GSTNAM
:
19135 return _("NT_VMS_GSTNAM (sym table name)");
19136 case NT_VMS_ORIG_DYN
:
19137 return "NT_VMS_ORIG_DYN";
19138 case NT_VMS_PATCHTIME
:
19139 return "NT_VMS_PATCHTIME";
19141 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19147 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
19149 int maxlen
= pnote
->descsz
;
19151 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
19152 goto desc_size_fail
;
19154 switch (pnote
->type
)
19158 goto desc_size_fail
;
19160 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
19162 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
19163 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
19164 if (l
+ 34 < maxlen
)
19166 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
19167 if (l
+ 35 < maxlen
)
19168 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
19170 printf (_(" Module version : <missing>\n"));
19174 printf (_(" Module name : <missing>\n"));
19175 printf (_(" Module version : <missing>\n"));
19180 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
19184 case NT_VMS_FPMODE
:
19185 printf (_(" Floating Point mode: "));
19187 goto desc_size_fail
;
19188 /* FIXME: Generate an error if descsz > 8 ? */
19190 printf ("0x%016" BFD_VMA_FMT
"x\n",
19191 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19194 case NT_VMS_LINKTIME
:
19195 printf (_(" Link time: "));
19197 goto desc_size_fail
;
19198 /* FIXME: Generate an error if descsz > 8 ? */
19201 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19205 case NT_VMS_PATCHTIME
:
19206 printf (_(" Patch time: "));
19208 goto desc_size_fail
;
19209 /* FIXME: Generate an error if descsz > 8 ? */
19212 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19216 case NT_VMS_ORIG_DYN
:
19218 goto desc_size_fail
;
19220 printf (_(" Major id: %u, minor id: %u\n"),
19221 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
19222 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
19223 printf (_(" Last modified : "));
19225 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
19226 printf (_("\n Link flags : "));
19227 printf ("0x%016" BFD_VMA_FMT
"x\n",
19228 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
19229 printf (_(" Header flags: 0x%08x\n"),
19230 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
19231 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
19235 case NT_VMS_IMGNAM
:
19236 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
19239 case NT_VMS_GSTNAM
:
19240 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
19244 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
19247 case NT_VMS_LINKID
:
19248 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
19258 printf (_(" <corrupt - data size is too small>\n"));
19259 error (_("corrupt IA64 note: data size is too small\n"));
19263 struct build_attr_cache
{
19264 Filedata
*filedata
;
19266 unsigned long strtablen
;
19267 Elf_Internal_Sym
*symtab
;
19268 unsigned long nsyms
;
19271 /* Find the symbol associated with a build attribute that is attached
19272 to address OFFSET. If PNAME is non-NULL then store the name of
19273 the symbol (if found) in the provided pointer, Returns NULL if a
19274 symbol could not be found. */
19276 static Elf_Internal_Sym
*
19277 get_symbol_for_build_attribute (Filedata
* filedata
,
19278 unsigned long offset
,
19279 bfd_boolean is_open_attr
,
19280 const char ** pname
)
19282 Elf_Internal_Sym
*saved_sym
= NULL
;
19283 Elf_Internal_Sym
*sym
;
19285 if (filedata
->section_headers
!= NULL
19286 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
19288 Elf_Internal_Shdr
* symsec
;
19290 free (ba_cache
.strtab
);
19291 ba_cache
.strtab
= NULL
;
19292 free (ba_cache
.symtab
);
19293 ba_cache
.symtab
= NULL
;
19295 /* Load the symbol and string sections. */
19296 for (symsec
= filedata
->section_headers
;
19297 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
19300 if (symsec
->sh_type
== SHT_SYMTAB
19301 && get_symtab (filedata
, symsec
,
19302 &ba_cache
.symtab
, &ba_cache
.nsyms
,
19303 &ba_cache
.strtab
, &ba_cache
.strtablen
))
19306 ba_cache
.filedata
= filedata
;
19309 if (ba_cache
.symtab
== NULL
)
19312 /* Find a symbol whose value matches offset. */
19313 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
19314 if (sym
->st_value
== offset
)
19316 if (sym
->st_name
>= ba_cache
.strtablen
)
19317 /* Huh ? This should not happen. */
19320 if (ba_cache
.strtab
[sym
->st_name
] == 0)
19323 /* The AArch64 and ARM architectures define mapping symbols
19324 (eg $d, $x, $t) which we want to ignore. */
19325 if (ba_cache
.strtab
[sym
->st_name
] == '$'
19326 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
19327 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
19332 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
19333 and FILE or OBJECT symbols over NOTYPE symbols. We skip
19334 FUNC symbols entirely. */
19335 switch (ELF_ST_TYPE (sym
->st_info
))
19342 /* If the symbol has a size associated
19343 with it then we can stop searching. */
19344 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
19349 /* Ignore function symbols. */
19356 switch (ELF_ST_BIND (sym
->st_info
))
19359 if (saved_sym
== NULL
19360 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
19365 if (saved_sym
== NULL
)
19375 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
19383 if (saved_sym
&& pname
)
19384 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
19389 /* Returns true iff addr1 and addr2 are in the same section. */
19392 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
19394 Elf_Internal_Shdr
* a1
;
19395 Elf_Internal_Shdr
* a2
;
19397 a1
= find_section_by_address (filedata
, addr1
);
19398 a2
= find_section_by_address (filedata
, addr2
);
19400 return a1
== a2
&& a1
!= NULL
;
19404 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
19405 Filedata
* filedata
)
19407 static unsigned long global_offset
= 0;
19408 static unsigned long global_end
= 0;
19409 static unsigned long func_offset
= 0;
19410 static unsigned long func_end
= 0;
19412 Elf_Internal_Sym
* sym
;
19414 unsigned long start
;
19416 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
19418 switch (pnote
->descsz
)
19421 /* A zero-length description means that the range of
19422 the previous note of the same type should be used. */
19425 if (global_end
> global_offset
)
19426 printf (_(" Applies to region from %#lx to %#lx\n"),
19427 global_offset
, global_end
);
19429 printf (_(" Applies to region from %#lx\n"), global_offset
);
19433 if (func_end
> func_offset
)
19434 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
19436 printf (_(" Applies to region from %#lx\n"), func_offset
);
19441 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19448 /* FIXME: We should check that version 3+ notes are being used here... */
19449 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19450 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19454 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19460 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19461 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
19465 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
19466 printf (_(" <invalid descsz>"));
19471 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
19472 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
19473 in order to avoid them being confused with the start address of the
19474 first function in the file... */
19475 if (sym
== NULL
&& is_open_attr
)
19476 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
19479 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
19480 end
= start
+ sym
->st_size
;
19484 /* FIXME: Need to properly allow for section alignment.
19485 16 is just the alignment used on x86_64. */
19487 && start
> BFD_ALIGN (global_end
, 16)
19488 /* Build notes are not guaranteed to be organised in order of
19489 increasing address, but we should find the all of the notes
19490 for one section in the same place. */
19491 && same_section (filedata
, start
, global_end
))
19492 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
19493 global_end
+ 1, start
- 1);
19495 printf (_(" Applies to region from %#lx"), start
);
19496 global_offset
= start
;
19500 printf (_(" to %#lx"), end
);
19506 printf (_(" Applies to region from %#lx"), start
);
19507 func_offset
= start
;
19511 printf (_(" to %#lx"), end
);
19517 printf (_(" (%s)"), name
);
19524 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
19526 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
19527 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
19528 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
19530 char name_attribute
;
19531 const char * expected_types
;
19532 const char * name
= pnote
->namedata
;
19536 if (name
== NULL
|| pnote
->namesz
< 2)
19538 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19539 print_symbol (-20, _(" <corrupt name>"));
19548 /* Version 2 of the spec adds a "GA" prefix to the name field. */
19549 if (name
[0] == 'G' && name
[1] == 'A')
19551 if (pnote
->namesz
< 4)
19553 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19554 print_symbol (-20, _(" <corrupt name>"));
19563 switch ((name_type
= * name
))
19565 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19566 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19567 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19568 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19569 printf ("%c", * name
);
19573 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
19574 print_symbol (-20, _("<unknown name type>"));
19581 switch ((name_attribute
= * name
))
19583 case GNU_BUILD_ATTRIBUTE_VERSION
:
19584 text
= _("<version>");
19585 expected_types
= string_expected
;
19588 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19589 text
= _("<stack prot>");
19590 expected_types
= "!+*";
19593 case GNU_BUILD_ATTRIBUTE_RELRO
:
19594 text
= _("<relro>");
19595 expected_types
= bool_expected
;
19598 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
19599 text
= _("<stack size>");
19600 expected_types
= number_expected
;
19603 case GNU_BUILD_ATTRIBUTE_TOOL
:
19604 text
= _("<tool>");
19605 expected_types
= string_expected
;
19608 case GNU_BUILD_ATTRIBUTE_ABI
:
19610 expected_types
= "$*";
19613 case GNU_BUILD_ATTRIBUTE_PIC
:
19615 expected_types
= number_expected
;
19618 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
19619 text
= _("<short enum>");
19620 expected_types
= bool_expected
;
19624 if (ISPRINT (* name
))
19626 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
19628 if (len
> left
&& ! do_wide
)
19630 printf ("%.*s:", len
, name
);
19636 static char tmpbuf
[128];
19638 error (_("unrecognised byte in name field: %d\n"), * name
);
19639 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
19643 expected_types
= "*$!+";
19648 left
-= printf ("%s", text
);
19650 if (strchr (expected_types
, name_type
) == NULL
)
19651 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
19653 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
19655 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19656 (unsigned long) pnote
->namesz
,
19657 (long) (name
- pnote
->namedata
));
19661 if (left
< 1 && ! do_wide
)
19666 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19668 unsigned int bytes
;
19669 unsigned long long val
= 0;
19670 unsigned int shift
= 0;
19671 char * decoded
= NULL
;
19673 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
19675 /* The -1 is because the name field is always 0 terminated, and we
19676 want to be able to ensure that the shift in the while loop below
19677 will not overflow. */
19680 if (bytes
> sizeof (val
))
19682 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19684 bytes
= sizeof (val
);
19686 /* We do not bother to warn if bytes == 0 as this can
19687 happen with some early versions of the gcc plugin. */
19691 unsigned long long byte
= *name
++ & 0xff;
19693 val
|= byte
<< shift
;
19697 switch (name_attribute
)
19699 case GNU_BUILD_ATTRIBUTE_PIC
:
19702 case 0: decoded
= "static"; break;
19703 case 1: decoded
= "pic"; break;
19704 case 2: decoded
= "PIC"; break;
19705 case 3: decoded
= "pie"; break;
19706 case 4: decoded
= "PIE"; break;
19710 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19713 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19714 case 0: decoded
= "off"; break;
19715 case 1: decoded
= "on"; break;
19716 case 2: decoded
= "all"; break;
19717 case 3: decoded
= "strong"; break;
19718 case 4: decoded
= "explicit"; break;
19726 if (decoded
!= NULL
)
19728 print_symbol (-left
, decoded
);
19739 left
-= printf ("0x%llx", val
);
19741 left
-= printf ("0x%-.*llx", left
, val
);
19745 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19746 left
-= print_symbol (- left
, name
);
19748 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19749 left
-= print_symbol (- left
, "true");
19751 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19752 left
-= print_symbol (- left
, "false");
19756 if (do_wide
&& left
> 0)
19757 printf ("%-*s", left
, " ");
19762 /* Note that by the ELF standard, the name field is already null byte
19763 terminated, and namesz includes the terminating null byte.
19764 I.E. the value of namesz for the name "FSF" is 4.
19766 If the value of namesz is zero, there is no name present. */
19769 process_note (Elf_Internal_Note
* pnote
,
19770 Filedata
* filedata
)
19772 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
19775 if (pnote
->namesz
== 0)
19776 /* If there is no note name, then use the default set of
19777 note type strings. */
19778 nt
= get_note_type (filedata
, pnote
->type
);
19780 else if (const_strneq (pnote
->namedata
, "GNU"))
19781 /* GNU-specific object file notes. */
19782 nt
= get_gnu_elf_note_type (pnote
->type
);
19784 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
19785 /* FreeBSD-specific core file notes. */
19786 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
19788 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
19789 /* NetBSD-specific core file notes. */
19790 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
19792 else if (const_strneq (pnote
->namedata
, "NetBSD"))
19793 /* NetBSD-specific core file notes. */
19794 return process_netbsd_elf_note (pnote
);
19796 else if (const_strneq (pnote
->namedata
, "PaX"))
19797 /* NetBSD-specific core file notes. */
19798 return process_netbsd_elf_note (pnote
);
19800 else if (strneq (pnote
->namedata
, "SPU/", 4))
19802 /* SPU-specific core file notes. */
19803 nt
= pnote
->namedata
+ 4;
19807 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19808 /* VMS/ia64-specific file notes. */
19809 nt
= get_ia64_vms_note_type (pnote
->type
);
19811 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19812 nt
= get_stapsdt_note_type (pnote
->type
);
19815 /* Don't recognize this note name; just use the default set of
19816 note type strings. */
19817 nt
= get_note_type (filedata
, pnote
->type
);
19821 if (((const_strneq (pnote
->namedata
, "GA")
19822 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19823 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19824 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19825 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19826 print_gnu_build_attribute_name (pnote
);
19828 print_symbol (-20, name
);
19831 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
19833 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
19835 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19836 return print_ia64_vms_note (pnote
);
19837 else if (const_strneq (pnote
->namedata
, "GNU"))
19838 return print_gnu_note (filedata
, pnote
);
19839 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19840 return print_stapsdt_note (pnote
);
19841 else if (const_strneq (pnote
->namedata
, "CORE"))
19842 return print_core_note (pnote
);
19843 else if (((const_strneq (pnote
->namedata
, "GA")
19844 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19845 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19846 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19847 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19848 return print_gnu_build_attribute_description (pnote
, filedata
);
19854 printf (_(" description data: "));
19855 for (i
= 0; i
< pnote
->descsz
; i
++)
19856 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19868 process_notes_at (Filedata
* filedata
,
19869 Elf_Internal_Shdr
* section
,
19874 Elf_External_Note
* pnotes
;
19875 Elf_External_Note
* external
;
19877 bfd_boolean res
= TRUE
;
19884 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
19887 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
19895 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19898 if (pnotes
== NULL
)
19904 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
19906 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19907 (unsigned long) offset
, (unsigned long) length
);
19909 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19910 specifies that notes should be aligned to 4 bytes in 32-bit
19911 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19912 we also support 4 byte alignment in 64-bit objects. If section
19913 alignment is less than 4, we treate alignment as 4 bytes. */
19916 else if (align
!= 4 && align
!= 8)
19918 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19924 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19926 end
= (char *) pnotes
+ length
;
19927 while ((char *) external
< end
)
19929 Elf_Internal_Note inote
;
19932 char * temp
= NULL
;
19933 size_t data_remaining
= end
- (char *) external
;
19935 if (!is_ia64_vms (filedata
))
19937 /* PR binutils/15191
19938 Make sure that there is enough data to read. */
19939 min_notesz
= offsetof (Elf_External_Note
, name
);
19940 if (data_remaining
< min_notesz
)
19942 warn (ngettext ("Corrupt note: only %ld byte remains, "
19943 "not enough for a full note\n",
19944 "Corrupt note: only %ld bytes remain, "
19945 "not enough for a full note\n",
19947 (long) data_remaining
);
19950 data_remaining
-= min_notesz
;
19952 inote
.type
= BYTE_GET (external
->type
);
19953 inote
.namesz
= BYTE_GET (external
->namesz
);
19954 inote
.namedata
= external
->name
;
19955 inote
.descsz
= BYTE_GET (external
->descsz
);
19956 inote
.descdata
= ((char *) external
19957 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
19958 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19959 next
= ((char *) external
19960 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
19964 Elf64_External_VMS_Note
*vms_external
;
19966 /* PR binutils/15191
19967 Make sure that there is enough data to read. */
19968 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
19969 if (data_remaining
< min_notesz
)
19971 warn (ngettext ("Corrupt note: only %ld byte remains, "
19972 "not enough for a full note\n",
19973 "Corrupt note: only %ld bytes remain, "
19974 "not enough for a full note\n",
19976 (long) data_remaining
);
19979 data_remaining
-= min_notesz
;
19981 vms_external
= (Elf64_External_VMS_Note
*) external
;
19982 inote
.type
= BYTE_GET (vms_external
->type
);
19983 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
19984 inote
.namedata
= vms_external
->name
;
19985 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
19986 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
19987 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19988 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
19991 /* PR 17531: file: 3443835e. */
19992 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19993 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
19994 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
19995 || (size_t) (next
- inote
.descdata
) < inote
.descsz
19996 || ((size_t) (next
- inote
.descdata
)
19997 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
19999 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
20000 (unsigned long) ((char *) external
- (char *) pnotes
));
20001 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
20002 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
20006 external
= (Elf_External_Note
*) next
;
20008 /* Verify that name is null terminated. It appears that at least
20009 one version of Linux (RedHat 6.0) generates corefiles that don't
20010 comply with the ELF spec by failing to include the null byte in
20012 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
20014 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
20016 temp
= (char *) malloc (inote
.namesz
+ 1);
20019 error (_("Out of memory allocating space for inote name\n"));
20024 memcpy (temp
, inote
.namedata
, inote
.namesz
);
20025 inote
.namedata
= temp
;
20027 inote
.namedata
[inote
.namesz
] = 0;
20030 if (! process_note (& inote
, filedata
))
20043 process_corefile_note_segments (Filedata
* filedata
)
20045 Elf_Internal_Phdr
* segment
;
20047 bfd_boolean res
= TRUE
;
20049 if (! get_program_headers (filedata
))
20052 for (i
= 0, segment
= filedata
->program_headers
;
20053 i
< filedata
->file_header
.e_phnum
;
20056 if (segment
->p_type
== PT_NOTE
)
20057 if (! process_notes_at (filedata
, NULL
,
20058 (bfd_vma
) segment
->p_offset
,
20059 (bfd_vma
) segment
->p_filesz
,
20060 (bfd_vma
) segment
->p_align
))
20068 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
20070 Elf_External_Note
* pnotes
;
20071 Elf_External_Note
* external
;
20073 bfd_boolean res
= TRUE
;
20078 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
20080 if (pnotes
== NULL
)
20084 end
= (char*) pnotes
+ length
;
20086 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
20087 (unsigned long) offset
, (unsigned long) length
);
20089 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
20091 Elf_External_Note
* next
;
20092 Elf_Internal_Note inote
;
20094 inote
.type
= BYTE_GET (external
->type
);
20095 inote
.namesz
= BYTE_GET (external
->namesz
);
20096 inote
.namedata
= external
->name
;
20097 inote
.descsz
= BYTE_GET (external
->descsz
);
20098 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
20099 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20101 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
20103 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
20104 inote
.descdata
= inote
.namedata
;
20108 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
20110 if ( ((char *) next
> end
)
20111 || ((char *) next
< (char *) pnotes
))
20113 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
20114 (unsigned long) ((char *) external
- (char *) pnotes
));
20115 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
20116 inote
.type
, inote
.namesz
, inote
.descsz
);
20122 /* Prevent out-of-bounds indexing. */
20123 if ( inote
.namedata
+ inote
.namesz
> end
20124 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
20126 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
20127 (unsigned long) ((char *) external
- (char *) pnotes
));
20128 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
20129 inote
.type
, inote
.namesz
, inote
.descsz
);
20133 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
20135 if (! print_v850_note (& inote
))
20138 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
20139 inote
.namesz
, inote
.descsz
);
20149 process_note_sections (Filedata
* filedata
)
20151 Elf_Internal_Shdr
* section
;
20153 unsigned int n
= 0;
20154 bfd_boolean res
= TRUE
;
20156 for (i
= 0, section
= filedata
->section_headers
;
20157 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
20160 if (section
->sh_type
== SHT_NOTE
)
20162 if (! process_notes_at (filedata
, section
,
20163 (bfd_vma
) section
->sh_offset
,
20164 (bfd_vma
) section
->sh_size
,
20165 (bfd_vma
) section
->sh_addralign
))
20170 if (( filedata
->file_header
.e_machine
== EM_V800
20171 || filedata
->file_header
.e_machine
== EM_V850
20172 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
20173 && section
->sh_type
== SHT_RENESAS_INFO
)
20175 if (! process_v850_notes (filedata
,
20176 (bfd_vma
) section
->sh_offset
,
20177 (bfd_vma
) section
->sh_size
))
20184 /* Try processing NOTE segments instead. */
20185 return process_corefile_note_segments (filedata
);
20191 process_notes (Filedata
* filedata
)
20193 /* If we have not been asked to display the notes then do nothing. */
20197 if (filedata
->file_header
.e_type
!= ET_CORE
)
20198 return process_note_sections (filedata
);
20200 /* No program headers means no NOTE segment. */
20201 if (filedata
->file_header
.e_phnum
> 0)
20202 return process_corefile_note_segments (filedata
);
20204 printf (_("No note segments present in the core file.\n"));
20208 static unsigned char *
20209 display_public_gnu_attributes (unsigned char * start
,
20210 const unsigned char * const end
)
20212 printf (_(" Unknown GNU attribute: %s\n"), start
);
20214 start
+= strnlen ((char *) start
, end
- start
);
20215 display_raw_attribute (start
, end
);
20217 return (unsigned char *) end
;
20220 static unsigned char *
20221 display_generic_attribute (unsigned char * start
,
20223 const unsigned char * const end
)
20226 return (unsigned char *) end
;
20228 return display_tag_value (tag
, start
, end
);
20232 process_arch_specific (Filedata
* filedata
)
20237 switch (filedata
->file_header
.e_machine
)
20240 case EM_ARC_COMPACT
:
20241 case EM_ARC_COMPACT2
:
20242 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
20243 display_arc_attribute
,
20244 display_generic_attribute
);
20246 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
20247 display_arm_attribute
,
20248 display_generic_attribute
);
20251 case EM_MIPS_RS3_LE
:
20252 return process_mips_specific (filedata
);
20255 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
20256 display_msp430_attribute
,
20257 display_msp430_gnu_attribute
);
20260 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
20261 display_riscv_attribute
,
20262 display_generic_attribute
);
20265 return process_nds32_specific (filedata
);
20268 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20269 display_m68k_gnu_attribute
);
20273 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20274 display_power_gnu_attribute
);
20278 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20279 display_s390_gnu_attribute
);
20282 case EM_SPARC32PLUS
:
20284 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20285 display_sparc_gnu_attribute
);
20288 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
20289 display_tic6x_attribute
,
20290 display_generic_attribute
);
20293 return process_attributes (filedata
, "csky", SHT_CSKY_ATTRIBUTES
,
20294 display_csky_attribute
, NULL
);
20297 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
20298 display_public_gnu_attributes
,
20299 display_generic_attribute
);
20304 get_file_header (Filedata
* filedata
)
20306 /* Read in the identity array. */
20307 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
20310 /* Determine how to read the rest of the header. */
20311 switch (filedata
->file_header
.e_ident
[EI_DATA
])
20316 byte_get
= byte_get_little_endian
;
20317 byte_put
= byte_put_little_endian
;
20320 byte_get
= byte_get_big_endian
;
20321 byte_put
= byte_put_big_endian
;
20325 /* For now we only support 32 bit and 64 bit ELF files. */
20326 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
20328 /* Read in the rest of the header. */
20331 Elf32_External_Ehdr ehdr32
;
20333 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20336 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
20337 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
20338 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
20339 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
20340 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
20341 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
20342 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
20343 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
20344 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
20345 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
20346 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
20347 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
20348 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
20352 Elf64_External_Ehdr ehdr64
;
20354 /* If we have been compiled with sizeof (bfd_vma) == 4, then
20355 we will not be able to cope with the 64bit data found in
20356 64 ELF files. Detect this now and abort before we start
20357 overwriting things. */
20358 if (sizeof (bfd_vma
) < 8)
20360 error (_("This instance of readelf has been built without support for a\n\
20361 64 bit data type and so it cannot read 64 bit ELF files.\n"));
20365 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20368 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
20369 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
20370 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
20371 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
20372 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
20373 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
20374 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
20375 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
20376 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
20377 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
20378 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
20379 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
20380 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
20383 if (filedata
->file_header
.e_shoff
)
20385 /* There may be some extensions in the first section header. Don't
20386 bomb if we can't read it. */
20388 get_32bit_section_headers (filedata
, TRUE
);
20390 get_64bit_section_headers (filedata
, TRUE
);
20397 close_file (Filedata
* filedata
)
20401 if (filedata
->handle
)
20402 fclose (filedata
->handle
);
20408 close_debug_file (void * data
)
20410 close_file ((Filedata
*) data
);
20414 open_file (const char * pathname
)
20416 struct stat statbuf
;
20417 Filedata
* filedata
= NULL
;
20419 if (stat (pathname
, & statbuf
) < 0
20420 || ! S_ISREG (statbuf
.st_mode
))
20423 filedata
= calloc (1, sizeof * filedata
);
20424 if (filedata
== NULL
)
20427 filedata
->handle
= fopen (pathname
, "rb");
20428 if (filedata
->handle
== NULL
)
20431 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20432 filedata
->file_name
= pathname
;
20434 if (! get_file_header (filedata
))
20437 if (filedata
->file_header
.e_shoff
)
20441 /* Read the section headers again, this time for real. */
20443 res
= get_32bit_section_headers (filedata
, FALSE
);
20445 res
= get_64bit_section_headers (filedata
, FALSE
);
20456 if (filedata
->handle
)
20457 fclose (filedata
->handle
);
20464 open_debug_file (const char * pathname
)
20466 return open_file (pathname
);
20469 /* Process one ELF object file according to the command line options.
20470 This file may actually be stored in an archive. The file is
20471 positioned at the start of the ELF object. Returns TRUE if no
20472 problems were encountered, FALSE otherwise. */
20475 process_object (Filedata
* filedata
)
20477 bfd_boolean have_separate_files
;
20481 if (! get_file_header (filedata
))
20483 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
20487 /* Initialise per file variables. */
20488 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
20489 filedata
->version_info
[i
] = 0;
20491 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
20492 filedata
->dynamic_info
[i
] = 0;
20493 filedata
->dynamic_info_DT_GNU_HASH
= 0;
20494 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
20496 /* Process the file. */
20498 printf (_("\nFile: %s\n"), filedata
->file_name
);
20500 /* Initialise the dump_sects array from the cmdline_dump_sects array.
20501 Note we do this even if cmdline_dump_sects is empty because we
20502 must make sure that the dump_sets array is zeroed out before each
20503 object file is processed. */
20504 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
20505 memset (filedata
->dump
.dump_sects
, 0,
20506 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20508 if (cmdline
.num_dump_sects
> 0)
20510 if (filedata
->dump
.num_dump_sects
== 0)
20511 /* A sneaky way of allocating the dump_sects array. */
20512 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
20514 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
20515 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
20516 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20519 if (! process_file_header (filedata
))
20522 if (! process_section_headers (filedata
))
20524 /* Without loaded section headers we cannot process lots of things. */
20525 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
20527 if (! do_using_dynamic
)
20528 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
20531 if (! process_section_groups (filedata
))
20532 /* Without loaded section groups we cannot process unwind. */
20535 res
= process_program_headers (filedata
);
20537 res
= process_dynamic_section (filedata
);
20539 if (! process_relocs (filedata
))
20542 if (! process_unwind (filedata
))
20545 if (! process_symbol_table (filedata
))
20548 if (! process_syminfo (filedata
))
20551 if (! process_version_sections (filedata
))
20554 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
20555 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
20557 have_separate_files
= FALSE
;
20559 if (! process_section_contents (filedata
))
20562 if (have_separate_files
)
20566 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
20568 if (! process_section_headers (d
->handle
))
20570 else if (! process_section_contents (d
->handle
))
20574 /* The file handles are closed by the call to free_debug_memory() below. */
20577 if (! process_notes (filedata
))
20580 if (! process_gnu_liblist (filedata
))
20583 if (! process_arch_specific (filedata
))
20586 free (filedata
->program_headers
);
20587 filedata
->program_headers
= NULL
;
20589 free (filedata
->section_headers
);
20590 filedata
->section_headers
= NULL
;
20592 free (filedata
->string_table
);
20593 filedata
->string_table
= NULL
;
20594 filedata
->string_table_length
= 0;
20596 free (filedata
->dump
.dump_sects
);
20597 filedata
->dump
.dump_sects
= NULL
;
20598 filedata
->dump
.num_dump_sects
= 0;
20600 free (filedata
->dynamic_strings
);
20601 filedata
->dynamic_strings
= NULL
;
20602 filedata
->dynamic_strings_length
= 0;
20604 free (filedata
->dynamic_symbols
);
20605 filedata
->dynamic_symbols
= NULL
;
20606 filedata
->num_dynamic_syms
= 0;
20608 free (filedata
->dynamic_syminfo
);
20609 filedata
->dynamic_syminfo
= NULL
;
20611 free (filedata
->dynamic_section
);
20612 filedata
->dynamic_section
= NULL
;
20614 while (filedata
->symtab_shndx_list
!= NULL
)
20616 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
20617 free (filedata
->symtab_shndx_list
);
20618 filedata
->symtab_shndx_list
= next
;
20621 free (filedata
->section_headers_groups
);
20622 filedata
->section_headers_groups
= NULL
;
20624 if (filedata
->section_groups
)
20626 struct group_list
* g
;
20627 struct group_list
* next
;
20629 for (i
= 0; i
< filedata
->group_count
; i
++)
20631 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
20638 free (filedata
->section_groups
);
20639 filedata
->section_groups
= NULL
;
20642 free_debug_memory ();
20647 /* Process an ELF archive.
20648 On entry the file is positioned just after the ARMAG string.
20649 Returns TRUE upon success, FALSE otherwise. */
20652 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
20654 struct archive_info arch
;
20655 struct archive_info nested_arch
;
20657 bfd_boolean ret
= TRUE
;
20661 /* The ARCH structure is used to hold information about this archive. */
20662 arch
.file_name
= NULL
;
20664 arch
.index_array
= NULL
;
20665 arch
.sym_table
= NULL
;
20666 arch
.longnames
= NULL
;
20668 /* The NESTED_ARCH structure is used as a single-item cache of information
20669 about a nested archive (when members of a thin archive reside within
20670 another regular archive file). */
20671 nested_arch
.file_name
= NULL
;
20672 nested_arch
.file
= NULL
;
20673 nested_arch
.index_array
= NULL
;
20674 nested_arch
.sym_table
= NULL
;
20675 nested_arch
.longnames
= NULL
;
20677 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
20678 filedata
->file_size
, is_thin_archive
,
20679 do_archive_index
) != 0)
20685 if (do_archive_index
)
20687 if (arch
.sym_table
== NULL
)
20688 error (_("%s: unable to dump the index as none was found\n"),
20689 filedata
->file_name
);
20692 unsigned long i
, l
;
20693 unsigned long current_pos
;
20695 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
20696 "in the symbol table)\n"),
20697 filedata
->file_name
, (unsigned long) arch
.index_num
,
20700 current_pos
= ftell (filedata
->handle
);
20702 for (i
= l
= 0; i
< arch
.index_num
; i
++)
20705 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
20708 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
20711 if (member_name
!= NULL
)
20713 char * qualified_name
20714 = make_qualified_name (&arch
, &nested_arch
,
20717 if (qualified_name
!= NULL
)
20719 printf (_("Contents of binary %s at offset "),
20721 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
20723 free (qualified_name
);
20725 free (member_name
);
20729 if (l
>= arch
.sym_size
)
20731 error (_("%s: end of the symbol table reached "
20732 "before the end of the index\n"),
20733 filedata
->file_name
);
20737 /* PR 17531: file: 0b6630b2. */
20738 printf ("\t%.*s\n",
20739 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
20740 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
20743 if (arch
.uses_64bit_indices
)
20748 if (l
< arch
.sym_size
)
20750 error (ngettext ("%s: %ld byte remains in the symbol table, "
20751 "but without corresponding entries in "
20752 "the index table\n",
20753 "%s: %ld bytes remain in the symbol table, "
20754 "but without corresponding entries in "
20755 "the index table\n",
20756 arch
.sym_size
- l
),
20757 filedata
->file_name
, arch
.sym_size
- l
);
20761 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
20763 error (_("%s: failed to seek back to start of object files "
20764 "in the archive\n"),
20765 filedata
->file_name
);
20771 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
20772 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
20773 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
20774 && !do_section_groups
&& !do_dyn_syms
)
20776 ret
= TRUE
; /* Archive index only. */
20785 char * qualified_name
;
20787 /* Read the next archive header. */
20788 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
20790 error (_("%s: failed to seek to next archive header\n"),
20795 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
20796 if (got
!= sizeof arch
.arhdr
)
20800 /* PR 24049 - we cannot use filedata->file_name as this will
20801 have already been freed. */
20802 error (_("%s: failed to read archive header\n"), arch
.file_name
);
20807 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
20809 error (_("%s: did not find a valid archive header\n"),
20815 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
20817 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
20818 if (filedata
->archive_file_size
& 01)
20819 ++filedata
->archive_file_size
;
20821 name
= get_archive_member_name (&arch
, &nested_arch
);
20824 error (_("%s: bad archive file name\n"), arch
.file_name
);
20828 namelen
= strlen (name
);
20830 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
20831 if (qualified_name
== NULL
)
20833 error (_("%s: bad archive file name\n"), arch
.file_name
);
20839 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
20841 /* This is a proxy for an external member of a thin archive. */
20842 Filedata
* member_filedata
;
20843 char * member_file_name
= adjust_relative_path
20844 (filedata
->file_name
, name
, namelen
);
20847 if (member_file_name
== NULL
)
20849 free (qualified_name
);
20854 member_filedata
= open_file (member_file_name
);
20855 if (member_filedata
== NULL
)
20857 error (_("Input file '%s' is not readable.\n"), member_file_name
);
20858 free (member_file_name
);
20859 free (qualified_name
);
20864 filedata
->archive_file_offset
= arch
.nested_member_origin
;
20865 member_filedata
->file_name
= qualified_name
;
20867 if (! process_object (member_filedata
))
20870 close_file (member_filedata
);
20871 free (member_file_name
);
20873 else if (is_thin_archive
)
20875 Filedata thin_filedata
;
20877 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
20879 /* PR 15140: Allow for corrupt thin archives. */
20880 if (nested_arch
.file
== NULL
)
20882 error (_("%s: contains corrupt thin archive: %s\n"),
20883 qualified_name
, name
);
20884 free (qualified_name
);
20891 /* This is a proxy for a member of a nested archive. */
20892 filedata
->archive_file_offset
20893 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
20895 /* The nested archive file will have been opened and setup by
20896 get_archive_member_name. */
20897 if (fseek (nested_arch
.file
, filedata
->archive_file_offset
,
20900 error (_("%s: failed to seek to archive member.\n"),
20901 nested_arch
.file_name
);
20902 free (qualified_name
);
20907 thin_filedata
.handle
= nested_arch
.file
;
20908 thin_filedata
.file_name
= qualified_name
;
20910 if (! process_object (& thin_filedata
))
20916 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
20917 filedata
->file_name
= qualified_name
;
20918 if (! process_object (filedata
))
20920 arch
.next_arhdr_offset
+= filedata
->archive_file_size
;
20921 /* Stop looping with "negative" archive_file_size. */
20922 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
20923 arch
.next_arhdr_offset
= -1ul;
20926 free (qualified_name
);
20930 if (nested_arch
.file
!= NULL
)
20931 fclose (nested_arch
.file
);
20932 release_archive (&nested_arch
);
20933 release_archive (&arch
);
20939 process_file (char * file_name
)
20941 Filedata
* filedata
= NULL
;
20942 struct stat statbuf
;
20943 char armag
[SARMAG
];
20944 bfd_boolean ret
= TRUE
;
20946 if (stat (file_name
, &statbuf
) < 0)
20948 if (errno
== ENOENT
)
20949 error (_("'%s': No such file\n"), file_name
);
20951 error (_("Could not locate '%s'. System error message: %s\n"),
20952 file_name
, strerror (errno
));
20956 if (! S_ISREG (statbuf
.st_mode
))
20958 error (_("'%s' is not an ordinary file\n"), file_name
);
20962 filedata
= calloc (1, sizeof * filedata
);
20963 if (filedata
== NULL
)
20965 error (_("Out of memory allocating file data structure\n"));
20969 filedata
->file_name
= file_name
;
20970 filedata
->handle
= fopen (file_name
, "rb");
20971 if (filedata
->handle
== NULL
)
20973 error (_("Input file '%s' is not readable.\n"), file_name
);
20978 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
20980 error (_("%s: Failed to read file's magic number\n"), file_name
);
20981 fclose (filedata
->handle
);
20986 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20988 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
20990 if (! process_archive (filedata
, FALSE
))
20993 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
20995 if ( ! process_archive (filedata
, TRUE
))
21000 if (do_archive_index
&& !check_all
)
21001 error (_("File %s is not an archive so its index cannot be displayed.\n"),
21004 rewind (filedata
->handle
);
21005 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
21007 if (! process_object (filedata
))
21011 fclose (filedata
->handle
);
21012 free (filedata
->section_headers
);
21013 free (filedata
->program_headers
);
21014 free (filedata
->string_table
);
21015 free (filedata
->dump
.dump_sects
);
21018 free (ba_cache
.strtab
);
21019 ba_cache
.strtab
= NULL
;
21020 free (ba_cache
.symtab
);
21021 ba_cache
.symtab
= NULL
;
21022 ba_cache
.filedata
= NULL
;
21027 #ifdef SUPPORT_DISASSEMBLY
21028 /* Needed by the i386 disassembler. For extra credit, someone could
21029 fix this so that we insert symbolic addresses here, esp for GOT/PLT
21033 print_address (unsigned int addr
, FILE * outfile
)
21035 fprintf (outfile
,"0x%8.8x", addr
);
21038 /* Needed by the i386 disassembler. */
21041 db_task_printsym (unsigned int addr
)
21043 print_address (addr
, stderr
);
21048 main (int argc
, char ** argv
)
21052 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
21053 setlocale (LC_MESSAGES
, "");
21055 #if defined (HAVE_SETLOCALE)
21056 setlocale (LC_CTYPE
, "");
21058 bindtextdomain (PACKAGE
, LOCALEDIR
);
21059 textdomain (PACKAGE
);
21061 expandargv (&argc
, &argv
);
21063 parse_args (& cmdline
, argc
, argv
);
21065 if (optind
< (argc
- 1))
21066 /* When displaying information for more than one file,
21067 prefix the information with the file name. */
21069 else if (optind
>= argc
)
21071 /* Ensure that the warning is always displayed. */
21074 warn (_("Nothing to do.\n"));
21079 while (optind
< argc
)
21080 if (! process_file (argv
[optind
++]))
21083 free (cmdline
.dump_sects
);
21085 free (dump_ctf_symtab_name
);
21086 free (dump_ctf_strtab_name
);
21087 free (dump_ctf_parent_name
);
21089 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;