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 if (uses_msp430x_relocs (filedata
))
12591 /* Fall through. */
12592 case 21: /* R_MSP430X_SYM_DIFF */
12594 if (sym_index
>= num_syms
)
12595 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12598 saved_sym
= symtab
+ sym_index
;
12601 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12602 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12603 goto handle_sym_diff
;
12605 case 5: /* R_MSP430_16_BYTE */
12606 case 9: /* R_MSP430_8 */
12607 if (uses_msp430x_relocs (filedata
))
12609 goto handle_sym_diff
;
12611 case 2: /* R_MSP430_ABS16 */
12612 case 15: /* R_MSP430X_ABS16 */
12613 if (! uses_msp430x_relocs (filedata
))
12615 goto handle_sym_diff
;
12618 if (saved_sym
!= NULL
)
12620 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12623 if (sym_index
>= num_syms
)
12624 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12628 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12629 - saved_sym
->st_value
);
12631 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12632 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12635 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12636 (long) reloc
->r_offset
);
12645 if (saved_sym
!= NULL
)
12646 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12653 case EM_CYGNUS_MN10300
:
12655 static Elf_Internal_Sym
* saved_sym
= NULL
;
12663 switch (reloc_type
)
12665 case 34: /* R_MN10300_ALIGN */
12667 case 33: /* R_MN10300_SYM_DIFF */
12668 if (sym_index
>= num_syms
)
12669 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12672 saved_sym
= symtab
+ sym_index
;
12675 case 1: /* R_MN10300_32 */
12676 case 2: /* R_MN10300_16 */
12677 if (saved_sym
!= NULL
)
12679 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12682 if (sym_index
>= num_syms
)
12683 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12687 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12688 - saved_sym
->st_value
);
12690 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12691 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12693 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12694 (long) reloc
->r_offset
);
12702 if (saved_sym
!= NULL
)
12703 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12711 static bfd_vma saved_sym1
= 0;
12712 static bfd_vma saved_sym2
= 0;
12713 static bfd_vma value
;
12717 saved_sym1
= saved_sym2
= 0;
12721 switch (reloc_type
)
12723 case 0x80: /* R_RL78_SYM. */
12724 saved_sym1
= saved_sym2
;
12725 if (sym_index
>= num_syms
)
12726 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12730 saved_sym2
= symtab
[sym_index
].st_value
;
12731 saved_sym2
+= reloc
->r_addend
;
12735 case 0x83: /* R_RL78_OPsub. */
12736 value
= saved_sym1
- saved_sym2
;
12737 saved_sym2
= saved_sym1
= 0;
12741 case 0x41: /* R_RL78_ABS32. */
12742 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12743 byte_put (start
+ reloc
->r_offset
, value
, 4);
12745 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12746 (long) reloc
->r_offset
);
12750 case 0x43: /* R_RL78_ABS16. */
12751 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12752 byte_put (start
+ reloc
->r_offset
, value
, 2);
12754 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12755 (long) reloc
->r_offset
);
12769 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12770 DWARF debug sections. This is a target specific test. Note - we do not
12771 go through the whole including-target-headers-multiple-times route, (as
12772 we have already done with <elf/h8.h>) because this would become very
12773 messy and even then this function would have to contain target specific
12774 information (the names of the relocs instead of their numeric values).
12775 FIXME: This is not the correct way to solve this problem. The proper way
12776 is to have target specific reloc sizing and typing functions created by
12777 the reloc-macros.h header, in the same way that it already creates the
12778 reloc naming functions. */
12781 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12783 /* Please keep this table alpha-sorted for ease of visual lookup. */
12784 switch (filedata
->file_header
.e_machine
)
12788 return reloc_type
== 1; /* R_386_32. */
12790 return reloc_type
== 1; /* R_68K_32. */
12792 return reloc_type
== 1; /* R_860_32. */
12794 return reloc_type
== 2; /* R_960_32. */
12796 return (reloc_type
== 258
12797 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12799 return reloc_type
== 11; /* R_BPF_DATA_32 */
12800 case EM_ADAPTEVA_EPIPHANY
:
12801 return reloc_type
== 3;
12803 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12805 return reloc_type
== 1; /* R_ARC_32. */
12806 case EM_ARC_COMPACT
:
12807 case EM_ARC_COMPACT2
:
12808 return reloc_type
== 4; /* R_ARC_32. */
12810 return reloc_type
== 2; /* R_ARM_ABS32 */
12813 return reloc_type
== 1;
12815 return reloc_type
== 0x12; /* R_byte4_data. */
12817 return reloc_type
== 3; /* R_CRIS_32. */
12819 return reloc_type
== 3; /* R_CR16_NUM32. */
12821 return reloc_type
== 15; /* R_CRX_NUM32. */
12823 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12824 case EM_CYGNUS_FRV
:
12825 return reloc_type
== 1;
12826 case EM_CYGNUS_D10V
:
12828 return reloc_type
== 6; /* R_D10V_32. */
12829 case EM_CYGNUS_D30V
:
12831 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12833 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12834 case EM_CYGNUS_FR30
:
12836 return reloc_type
== 3; /* R_FR30_32. */
12838 return reloc_type
== 1; /* R_FT32_32. */
12842 return reloc_type
== 1; /* R_H8_DIR32. */
12844 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12845 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12846 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12847 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12850 return reloc_type
== 2; /* R_IP2K_32. */
12852 return reloc_type
== 2; /* R_IQ2000_32. */
12853 case EM_LATTICEMICO32
:
12854 return reloc_type
== 3; /* R_LM32_32. */
12857 return reloc_type
== 3; /* R_M32C_32. */
12859 return reloc_type
== 34; /* R_M32R_32_RELA. */
12862 return reloc_type
== 6; /* R_M68HC11_32. */
12864 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12865 reloc_type
== 6; /* R_S12Z_CW32. */
12867 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12868 case EM_CYGNUS_MEP
:
12869 return reloc_type
== 4; /* R_MEP_32. */
12871 return reloc_type
== 2; /* R_METAG_ADDR32. */
12872 case EM_MICROBLAZE
:
12873 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12875 return reloc_type
== 2; /* R_MIPS_32. */
12877 return reloc_type
== 4; /* R_MMIX_32. */
12878 case EM_CYGNUS_MN10200
:
12880 return reloc_type
== 1; /* R_MN10200_32. */
12881 case EM_CYGNUS_MN10300
:
12883 return reloc_type
== 1; /* R_MN10300_32. */
12885 return reloc_type
== 1; /* R_MOXIE_32. */
12886 case EM_MSP430_OLD
:
12888 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12890 return reloc_type
== 2; /* R_MT_32. */
12892 return reloc_type
== 20; /* R_NDS32_RELA. */
12893 case EM_ALTERA_NIOS2
:
12894 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12896 return reloc_type
== 1; /* R_NIOS_32. */
12898 return reloc_type
== 1; /* R_OR1K_32. */
12900 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12901 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12902 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12905 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12907 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12909 return reloc_type
== 1; /* R_PPC_ADDR32. */
12911 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12913 return reloc_type
== 1; /* R_RISCV_32. */
12915 return reloc_type
== 1; /* R_RL78_DIR32. */
12917 return reloc_type
== 1; /* R_RX_DIR32. */
12919 return reloc_type
== 1; /* R_I370_ADDR31. */
12922 return reloc_type
== 4; /* R_S390_32. */
12924 return reloc_type
== 8; /* R_SCORE_ABS32. */
12926 return reloc_type
== 1; /* R_SH_DIR32. */
12927 case EM_SPARC32PLUS
:
12930 return reloc_type
== 3 /* R_SPARC_32. */
12931 || reloc_type
== 23; /* R_SPARC_UA32. */
12933 return reloc_type
== 6; /* R_SPU_ADDR32 */
12935 return reloc_type
== 1; /* R_C6000_ABS32. */
12937 return reloc_type
== 2; /* R_TILEGX_32. */
12939 return reloc_type
== 1; /* R_TILEPRO_32. */
12940 case EM_CYGNUS_V850
:
12942 return reloc_type
== 6; /* R_V850_ABS32. */
12944 return reloc_type
== 0x33; /* R_V810_WORD. */
12946 return reloc_type
== 1; /* R_VAX_32. */
12948 return reloc_type
== 3; /* R_VISIUM_32. */
12949 case EM_WEBASSEMBLY
:
12950 return reloc_type
== 1; /* R_WASM32_32. */
12954 return reloc_type
== 10; /* R_X86_64_32. */
12957 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12959 return reloc_type
== 4; /* R_XGATE_32. */
12961 return reloc_type
== 1; /* R_XSTROMY16_32. */
12962 case EM_XTENSA_OLD
:
12964 return reloc_type
== 1; /* R_XTENSA_32. */
12966 return reloc_type
== 6; /* R_Z80_32. */
12969 static unsigned int prev_warn
= 0;
12971 /* Avoid repeating the same warning multiple times. */
12972 if (prev_warn
!= filedata
->file_header
.e_machine
)
12973 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12974 filedata
->file_header
.e_machine
);
12975 prev_warn
= filedata
->file_header
.e_machine
;
12981 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12982 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12985 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12987 switch (filedata
->file_header
.e_machine
)
12988 /* Please keep this table alpha-sorted for ease of visual lookup. */
12992 return reloc_type
== 2; /* R_386_PC32. */
12994 return reloc_type
== 4; /* R_68K_PC32. */
12996 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12997 case EM_ADAPTEVA_EPIPHANY
:
12998 return reloc_type
== 6;
13000 return reloc_type
== 10; /* R_ALPHA_SREL32. */
13001 case EM_ARC_COMPACT
:
13002 case EM_ARC_COMPACT2
:
13003 return reloc_type
== 49; /* R_ARC_32_PCREL. */
13005 return reloc_type
== 3; /* R_ARM_REL32 */
13008 return reloc_type
== 36; /* R_AVR_32_PCREL. */
13009 case EM_MICROBLAZE
:
13010 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
13012 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
13014 return reloc_type
== 9; /* R_PARISC_PCREL32. */
13016 return reloc_type
== 26; /* R_PPC_REL32. */
13018 return reloc_type
== 26; /* R_PPC64_REL32. */
13020 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
13023 return reloc_type
== 5; /* R_390_PC32. */
13025 return reloc_type
== 2; /* R_SH_REL32. */
13026 case EM_SPARC32PLUS
:
13029 return reloc_type
== 6; /* R_SPARC_DISP32. */
13031 return reloc_type
== 13; /* R_SPU_REL32. */
13033 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
13035 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
13037 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
13041 return reloc_type
== 2; /* R_X86_64_PC32. */
13043 return reloc_type
== 4; /* R_VAX_PCREL32. */
13044 case EM_XTENSA_OLD
:
13046 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
13048 /* Do not abort or issue an error message here. Not all targets use
13049 pc-relative 32-bit relocs in their DWARF debug information and we
13050 have already tested for target coverage in is_32bit_abs_reloc. A
13051 more helpful warning message will be generated by apply_relocations
13052 anyway, so just return. */
13057 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13058 a 64-bit absolute RELA relocation used in DWARF debug sections. */
13061 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13063 switch (filedata
->file_header
.e_machine
)
13066 return reloc_type
== 257; /* R_AARCH64_ABS64. */
13068 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
13070 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
13071 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
13073 return reloc_type
== 80; /* R_PARISC_DIR64. */
13075 return reloc_type
== 38; /* R_PPC64_ADDR64. */
13077 return reloc_type
== 2; /* R_RISCV_64. */
13078 case EM_SPARC32PLUS
:
13081 return reloc_type
== 32 /* R_SPARC_64. */
13082 || reloc_type
== 54; /* R_SPARC_UA64. */
13086 return reloc_type
== 1; /* R_X86_64_64. */
13089 return reloc_type
== 22; /* R_S390_64. */
13091 return reloc_type
== 1; /* R_TILEGX_64. */
13093 return reloc_type
== 18; /* R_MIPS_64. */
13099 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
13100 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
13103 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13105 switch (filedata
->file_header
.e_machine
)
13108 return reloc_type
== 260; /* R_AARCH64_PREL64. */
13110 return reloc_type
== 11; /* R_ALPHA_SREL64. */
13112 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
13113 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
13115 return reloc_type
== 72; /* R_PARISC_PCREL64. */
13117 return reloc_type
== 44; /* R_PPC64_REL64. */
13118 case EM_SPARC32PLUS
:
13121 return reloc_type
== 46; /* R_SPARC_DISP64. */
13125 return reloc_type
== 24; /* R_X86_64_PC64. */
13128 return reloc_type
== 23; /* R_S390_PC64. */
13130 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
13136 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13137 a 24-bit absolute RELA relocation used in DWARF debug sections. */
13140 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13142 switch (filedata
->file_header
.e_machine
)
13144 case EM_CYGNUS_MN10200
:
13146 return reloc_type
== 4; /* R_MN10200_24. */
13148 return reloc_type
== 5; /* R_FT32_20. */
13150 return reloc_type
== 5; /* R_Z80_24. */
13156 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13157 a 16-bit absolute RELA relocation used in DWARF debug sections. */
13160 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13162 /* Please keep this table alpha-sorted for ease of visual lookup. */
13163 switch (filedata
->file_header
.e_machine
)
13166 case EM_ARC_COMPACT
:
13167 case EM_ARC_COMPACT2
:
13168 return reloc_type
== 2; /* R_ARC_16. */
13169 case EM_ADAPTEVA_EPIPHANY
:
13170 return reloc_type
== 5;
13173 return reloc_type
== 4; /* R_AVR_16. */
13174 case EM_CYGNUS_D10V
:
13176 return reloc_type
== 3; /* R_D10V_16. */
13178 return reloc_type
== 2; /* R_FT32_16. */
13182 return reloc_type
== R_H8_DIR16
;
13185 return reloc_type
== 1; /* R_IP2K_16. */
13188 return reloc_type
== 1; /* R_M32C_16 */
13189 case EM_CYGNUS_MN10200
:
13191 return reloc_type
== 2; /* R_MN10200_16. */
13192 case EM_CYGNUS_MN10300
:
13194 return reloc_type
== 2; /* R_MN10300_16. */
13196 if (uses_msp430x_relocs (filedata
))
13197 return reloc_type
== 2; /* R_MSP430_ABS16. */
13198 /* Fall through. */
13199 case EM_MSP430_OLD
:
13200 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13202 return reloc_type
== 19; /* R_NDS32_RELA. */
13203 case EM_ALTERA_NIOS2
:
13204 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13206 return reloc_type
== 9; /* R_NIOS_16. */
13208 return reloc_type
== 2; /* R_OR1K_16. */
13210 return reloc_type
== 55; /* R_RISCV_SET16. */
13212 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13214 return reloc_type
== 2; /* R_C6000_ABS16. */
13216 return reloc_type
== 2; /* R_VISIUM_16. */
13219 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13221 return reloc_type
== 3; /* R_XGATE_16. */
13223 return reloc_type
== 4; /* R_Z80_16. */
13229 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13230 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13233 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13235 switch (filedata
->file_header
.e_machine
)
13238 return reloc_type
== 54; /* R_RISCV_SET8. */
13240 return reloc_type
== 1; /* R_Z80_8. */
13246 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13247 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13250 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13252 switch (filedata
->file_header
.e_machine
)
13255 return reloc_type
== 53; /* R_RISCV_SET6. */
13261 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13262 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13265 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13267 /* Please keep this table alpha-sorted for ease of visual lookup. */
13268 switch (filedata
->file_header
.e_machine
)
13271 return reloc_type
== 35; /* R_RISCV_ADD32. */
13277 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13278 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13281 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13283 /* Please keep this table alpha-sorted for ease of visual lookup. */
13284 switch (filedata
->file_header
.e_machine
)
13287 return reloc_type
== 39; /* R_RISCV_SUB32. */
13293 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13294 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13297 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13299 /* Please keep this table alpha-sorted for ease of visual lookup. */
13300 switch (filedata
->file_header
.e_machine
)
13303 return reloc_type
== 36; /* R_RISCV_ADD64. */
13309 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13310 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13313 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13315 /* Please keep this table alpha-sorted for ease of visual lookup. */
13316 switch (filedata
->file_header
.e_machine
)
13319 return reloc_type
== 40; /* R_RISCV_SUB64. */
13325 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13326 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13329 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13331 /* Please keep this table alpha-sorted for ease of visual lookup. */
13332 switch (filedata
->file_header
.e_machine
)
13335 return reloc_type
== 34; /* R_RISCV_ADD16. */
13341 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13342 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13345 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13347 /* Please keep this table alpha-sorted for ease of visual lookup. */
13348 switch (filedata
->file_header
.e_machine
)
13351 return reloc_type
== 38; /* R_RISCV_SUB16. */
13357 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13358 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13361 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13363 /* Please keep this table alpha-sorted for ease of visual lookup. */
13364 switch (filedata
->file_header
.e_machine
)
13367 return reloc_type
== 33; /* R_RISCV_ADD8. */
13373 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13374 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13377 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13379 /* Please keep this table alpha-sorted for ease of visual lookup. */
13380 switch (filedata
->file_header
.e_machine
)
13383 return reloc_type
== 37; /* R_RISCV_SUB8. */
13389 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13390 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13393 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13395 switch (filedata
->file_header
.e_machine
)
13398 return reloc_type
== 52; /* R_RISCV_SUB6. */
13404 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13405 relocation entries (possibly formerly used for SHT_GROUP sections). */
13408 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13410 switch (filedata
->file_header
.e_machine
)
13412 case EM_386
: /* R_386_NONE. */
13413 case EM_68K
: /* R_68K_NONE. */
13414 case EM_ADAPTEVA_EPIPHANY
:
13415 case EM_ALPHA
: /* R_ALPHA_NONE. */
13416 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13417 case EM_ARC
: /* R_ARC_NONE. */
13418 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13419 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13420 case EM_ARM
: /* R_ARM_NONE. */
13421 case EM_C166
: /* R_XC16X_NONE. */
13422 case EM_CRIS
: /* R_CRIS_NONE. */
13423 case EM_FT32
: /* R_FT32_NONE. */
13424 case EM_IA_64
: /* R_IA64_NONE. */
13425 case EM_K1OM
: /* R_X86_64_NONE. */
13426 case EM_L1OM
: /* R_X86_64_NONE. */
13427 case EM_M32R
: /* R_M32R_NONE. */
13428 case EM_MIPS
: /* R_MIPS_NONE. */
13429 case EM_MN10300
: /* R_MN10300_NONE. */
13430 case EM_MOXIE
: /* R_MOXIE_NONE. */
13431 case EM_NIOS32
: /* R_NIOS_NONE. */
13432 case EM_OR1K
: /* R_OR1K_NONE. */
13433 case EM_PARISC
: /* R_PARISC_NONE. */
13434 case EM_PPC64
: /* R_PPC64_NONE. */
13435 case EM_PPC
: /* R_PPC_NONE. */
13436 case EM_RISCV
: /* R_RISCV_NONE. */
13437 case EM_S390
: /* R_390_NONE. */
13439 case EM_SH
: /* R_SH_NONE. */
13440 case EM_SPARC32PLUS
:
13441 case EM_SPARC
: /* R_SPARC_NONE. */
13443 case EM_TILEGX
: /* R_TILEGX_NONE. */
13444 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13445 case EM_TI_C6000
:/* R_C6000_NONE. */
13446 case EM_X86_64
: /* R_X86_64_NONE. */
13448 case EM_Z80
: /* R_Z80_NONE. */
13449 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13450 return reloc_type
== 0;
13453 return reloc_type
== 0 || reloc_type
== 256;
13456 return (reloc_type
== 0 /* R_AVR_NONE. */
13457 || reloc_type
== 30 /* R_AVR_DIFF8. */
13458 || reloc_type
== 31 /* R_AVR_DIFF16. */
13459 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13461 return reloc_type
== 3; /* R_METAG_NONE. */
13463 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13464 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13465 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13466 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13467 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13469 return (reloc_type
== 0 /* R_PRU_NONE. */
13470 || reloc_type
== 65 /* R_PRU_DIFF8. */
13471 || reloc_type
== 66 /* R_PRU_DIFF16. */
13472 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13473 case EM_XTENSA_OLD
:
13475 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13476 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13477 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13478 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
13479 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
13480 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
13481 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
13482 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
13483 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
13484 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
13489 /* Returns TRUE if there is a relocation against
13490 section NAME at OFFSET bytes. */
13493 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13495 Elf_Internal_Rela
* relocs
;
13496 Elf_Internal_Rela
* rp
;
13498 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13501 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13503 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13504 if (rp
->r_offset
== offset
)
13510 /* Apply relocations to a section.
13511 Returns TRUE upon success, FALSE otherwise.
13512 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13513 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13514 will be set to the number of relocs loaded.
13516 Note: So far support has been added only for those relocations
13517 which can be found in debug sections. FIXME: Add support for
13518 more relocations ? */
13521 apply_relocations (Filedata
* filedata
,
13522 const Elf_Internal_Shdr
* section
,
13523 unsigned char * start
,
13524 bfd_size_type size
,
13525 void ** relocs_return
,
13526 unsigned long * num_relocs_return
)
13528 Elf_Internal_Shdr
* relsec
;
13529 unsigned char * end
= start
+ size
;
13531 if (relocs_return
!= NULL
)
13533 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13534 * num_relocs_return
= 0;
13537 if (filedata
->file_header
.e_type
!= ET_REL
)
13538 /* No relocs to apply. */
13541 /* Find the reloc section associated with the section. */
13542 for (relsec
= filedata
->section_headers
;
13543 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13546 bfd_boolean is_rela
;
13547 unsigned long num_relocs
;
13548 Elf_Internal_Rela
* relocs
;
13549 Elf_Internal_Rela
* rp
;
13550 Elf_Internal_Shdr
* symsec
;
13551 Elf_Internal_Sym
* symtab
;
13552 unsigned long num_syms
;
13553 Elf_Internal_Sym
* sym
;
13555 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13556 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13557 || filedata
->section_headers
+ relsec
->sh_info
!= section
13558 || relsec
->sh_size
== 0
13559 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13562 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13563 if (symsec
->sh_type
!= SHT_SYMTAB
13564 && symsec
->sh_type
!= SHT_DYNSYM
)
13567 is_rela
= relsec
->sh_type
== SHT_RELA
;
13571 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13572 relsec
->sh_size
, & relocs
, & num_relocs
))
13577 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13578 relsec
->sh_size
, & relocs
, & num_relocs
))
13582 /* SH uses RELA but uses in place value instead of the addend field. */
13583 if (filedata
->file_header
.e_machine
== EM_SH
)
13586 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13588 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13591 unsigned int reloc_type
;
13592 unsigned int reloc_size
;
13593 bfd_boolean reloc_inplace
= FALSE
;
13594 bfd_boolean reloc_subtract
= FALSE
;
13595 unsigned char * rloc
;
13596 unsigned long sym_index
;
13598 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13600 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13602 else if (is_none_reloc (filedata
, reloc_type
))
13604 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13605 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13607 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13608 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13610 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13612 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13614 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13615 || is_6bit_abs_reloc (filedata
, reloc_type
))
13617 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13619 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13622 reloc_inplace
= TRUE
;
13624 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13626 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13629 reloc_inplace
= TRUE
;
13631 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13633 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13636 reloc_inplace
= TRUE
;
13638 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13640 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13643 reloc_inplace
= TRUE
;
13645 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13649 reloc_inplace
= TRUE
;
13653 static unsigned int prev_reloc
= 0;
13655 if (reloc_type
!= prev_reloc
)
13656 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13657 reloc_type
, printable_section_name (filedata
, section
));
13658 prev_reloc
= reloc_type
;
13662 rloc
= start
+ rp
->r_offset
;
13663 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
13665 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13666 (unsigned long) rp
->r_offset
,
13667 printable_section_name (filedata
, section
));
13671 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13672 if (sym_index
>= num_syms
)
13674 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13675 sym_index
, printable_section_name (filedata
, section
));
13678 sym
= symtab
+ sym_index
;
13680 /* If the reloc has a symbol associated with it,
13681 make sure that it is of an appropriate type.
13683 Relocations against symbols without type can happen.
13684 Gcc -feliminate-dwarf2-dups may generate symbols
13685 without type for debug info.
13687 Icc generates relocations against function symbols
13688 instead of local labels.
13690 Relocations against object symbols can happen, eg when
13691 referencing a global array. For an example of this see
13692 the _clz.o binary in libgcc.a. */
13694 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13695 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13697 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13698 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13699 printable_section_name (filedata
, relsec
),
13700 (long int)(rp
- relocs
));
13706 addend
+= rp
->r_addend
;
13707 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13708 partial_inplace. */
13710 || (filedata
->file_header
.e_machine
== EM_XTENSA
13711 && reloc_type
== 1)
13712 || ((filedata
->file_header
.e_machine
== EM_PJ
13713 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13714 && reloc_type
== 1)
13715 || ((filedata
->file_header
.e_machine
== EM_D30V
13716 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13717 && reloc_type
== 12)
13720 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13721 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13723 addend
+= byte_get (rloc
, reloc_size
);
13726 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13727 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13729 /* On HPPA, all pc-relative relocations are biased by 8. */
13730 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13732 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13735 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13736 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13738 if (reloc_subtract
)
13739 addend
-= sym
->st_value
;
13741 addend
+= sym
->st_value
;
13742 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13743 byte_put (rloc
, addend
, reloc_size
);
13745 else if (reloc_subtract
)
13746 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13748 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13752 /* Let the target specific reloc processing code know that
13753 we have finished with these relocs. */
13754 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13758 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13759 * num_relocs_return
= num_relocs
;
13770 #ifdef SUPPORT_DISASSEMBLY
13772 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13774 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13776 /* FIXME: XXX -- to be done --- XXX */
13782 /* Reads in the contents of SECTION from FILE, returning a pointer
13783 to a malloc'ed buffer or NULL if something went wrong. */
13786 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13788 bfd_size_type num_bytes
= section
->sh_size
;
13790 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13792 printf (_("Section '%s' has no data to dump.\n"),
13793 printable_section_name (filedata
, section
));
13797 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13798 _("section contents"));
13801 /* Uncompresses a section that was compressed using zlib, in place. */
13804 uncompress_section_contents (unsigned char ** buffer
,
13805 dwarf_size_type uncompressed_size
,
13806 dwarf_size_type
* size
)
13808 dwarf_size_type compressed_size
= *size
;
13809 unsigned char * compressed_buffer
= *buffer
;
13810 unsigned char * uncompressed_buffer
;
13814 /* It is possible the section consists of several compressed
13815 buffers concatenated together, so we uncompress in a loop. */
13816 /* PR 18313: The state field in the z_stream structure is supposed
13817 to be invisible to the user (ie us), but some compilers will
13818 still complain about it being used without initialisation. So
13819 we first zero the entire z_stream structure and then set the fields
13821 memset (& strm
, 0, sizeof strm
);
13822 strm
.avail_in
= compressed_size
;
13823 strm
.next_in
= (Bytef
*) compressed_buffer
;
13824 strm
.avail_out
= uncompressed_size
;
13825 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13827 rc
= inflateInit (& strm
);
13828 while (strm
.avail_in
> 0)
13832 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13833 + (uncompressed_size
- strm
.avail_out
));
13834 rc
= inflate (&strm
, Z_FINISH
);
13835 if (rc
!= Z_STREAM_END
)
13837 rc
= inflateReset (& strm
);
13839 rc
= inflateEnd (& strm
);
13841 || strm
.avail_out
!= 0)
13844 *buffer
= uncompressed_buffer
;
13845 *size
= uncompressed_size
;
13849 free (uncompressed_buffer
);
13850 /* Indicate decompression failure. */
13856 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13858 Elf_Internal_Shdr
* relsec
;
13859 bfd_size_type num_bytes
;
13860 unsigned char * data
;
13861 unsigned char * end
;
13862 unsigned char * real_start
;
13863 unsigned char * start
;
13864 bfd_boolean some_strings_shown
;
13866 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13868 /* PR 21820: Do not fail if the section was empty. */
13869 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13871 num_bytes
= section
->sh_size
;
13873 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13875 if (decompress_dumps
)
13877 dwarf_size_type new_size
= num_bytes
;
13878 dwarf_size_type uncompressed_size
= 0;
13880 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13882 Elf_Internal_Chdr chdr
;
13883 unsigned int compression_header_size
13884 = get_compression_header (& chdr
, (unsigned char *) start
,
13886 if (compression_header_size
== 0)
13887 /* An error message will have already been generated
13888 by get_compression_header. */
13891 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13893 warn (_("section '%s' has unsupported compress type: %d\n"),
13894 printable_section_name (filedata
, section
), chdr
.ch_type
);
13897 uncompressed_size
= chdr
.ch_size
;
13898 start
+= compression_header_size
;
13899 new_size
-= compression_header_size
;
13901 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13903 /* Read the zlib header. In this case, it should be "ZLIB"
13904 followed by the uncompressed section size, 8 bytes in
13905 big-endian order. */
13906 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13907 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13908 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13909 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13910 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13911 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13912 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13913 uncompressed_size
+= start
[11];
13918 if (uncompressed_size
)
13920 if (uncompress_section_contents (& start
,
13921 uncompressed_size
, & new_size
))
13922 num_bytes
= new_size
;
13925 error (_("Unable to decompress section %s\n"),
13926 printable_section_name (filedata
, section
));
13931 start
= real_start
;
13934 /* If the section being dumped has relocations against it the user might
13935 be expecting these relocations to have been applied. Check for this
13936 case and issue a warning message in order to avoid confusion.
13937 FIXME: Maybe we ought to have an option that dumps a section with
13938 relocs applied ? */
13939 for (relsec
= filedata
->section_headers
;
13940 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13943 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13944 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13945 || filedata
->section_headers
+ relsec
->sh_info
!= section
13946 || relsec
->sh_size
== 0
13947 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13950 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13955 end
= start
+ num_bytes
;
13956 some_strings_shown
= FALSE
;
13958 #ifdef HAVE_MBSTATE_T
13960 /* Initialise the multibyte conversion state. */
13961 memset (& state
, 0, sizeof (state
));
13964 bfd_boolean continuing
= FALSE
;
13968 while (!ISPRINT (* data
))
13969 if (++ data
>= end
)
13974 size_t maxlen
= end
- data
;
13979 continuing
= FALSE
;
13983 printf (" [%6lx] ", (unsigned long) (data
- start
));
13997 /* PR 25543: Treat new-lines as string-ending characters. */
14006 /* Do not print control characters directly as they can affect terminal
14007 settings. Such characters usually appear in the names generated
14008 by the assembler for local labels. */
14011 printf ("^%c", c
+ 0x40);
14013 else if (ISPRINT (c
))
14020 #ifdef HAVE_MBSTATE_T
14023 /* Let printf do the hard work of displaying multibyte characters. */
14024 printf ("%.1s", data
- 1);
14025 #ifdef HAVE_MBSTATE_T
14026 /* Try to find out how many bytes made up the character that was
14027 just printed. Advance the symbol pointer past the bytes that
14029 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
14033 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
14043 printf (_("<corrupt>\n"));
14046 some_strings_shown
= TRUE
;
14050 if (! some_strings_shown
)
14051 printf (_(" No strings found in this section."));
14064 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
14065 Filedata
* filedata
,
14066 bfd_boolean relocate
)
14068 Elf_Internal_Shdr
* relsec
;
14069 bfd_size_type bytes
;
14070 bfd_size_type section_size
;
14072 unsigned char * data
;
14073 unsigned char * real_start
;
14074 unsigned char * start
;
14076 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
14078 /* PR 21820: Do not fail if the section was empty. */
14079 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
14081 section_size
= section
->sh_size
;
14083 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
14085 if (decompress_dumps
)
14087 dwarf_size_type new_size
= section_size
;
14088 dwarf_size_type uncompressed_size
= 0;
14090 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14092 Elf_Internal_Chdr chdr
;
14093 unsigned int compression_header_size
14094 = get_compression_header (& chdr
, start
, section_size
);
14096 if (compression_header_size
== 0)
14097 /* An error message will have already been generated
14098 by get_compression_header. */
14101 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14103 warn (_("section '%s' has unsupported compress type: %d\n"),
14104 printable_section_name (filedata
, section
), chdr
.ch_type
);
14107 uncompressed_size
= chdr
.ch_size
;
14108 start
+= compression_header_size
;
14109 new_size
-= compression_header_size
;
14111 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14113 /* Read the zlib header. In this case, it should be "ZLIB"
14114 followed by the uncompressed section size, 8 bytes in
14115 big-endian order. */
14116 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14117 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14118 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14119 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14120 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14121 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14122 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14123 uncompressed_size
+= start
[11];
14128 if (uncompressed_size
)
14130 if (uncompress_section_contents (& start
, uncompressed_size
,
14133 section_size
= new_size
;
14137 error (_("Unable to decompress section %s\n"),
14138 printable_section_name (filedata
, section
));
14139 /* FIXME: Print the section anyway ? */
14144 start
= real_start
;
14149 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
14154 /* If the section being dumped has relocations against it the user might
14155 be expecting these relocations to have been applied. Check for this
14156 case and issue a warning message in order to avoid confusion.
14157 FIXME: Maybe we ought to have an option that dumps a section with
14158 relocs applied ? */
14159 for (relsec
= filedata
->section_headers
;
14160 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14163 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14164 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14165 || filedata
->section_headers
+ relsec
->sh_info
!= section
14166 || relsec
->sh_size
== 0
14167 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14170 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14175 addr
= section
->sh_addr
;
14176 bytes
= section_size
;
14185 lbytes
= (bytes
> 16 ? 16 : bytes
);
14187 printf (" 0x%8.8lx ", (unsigned long) addr
);
14189 for (j
= 0; j
< 16; j
++)
14192 printf ("%2.2x", data
[j
]);
14200 for (j
= 0; j
< lbytes
; j
++)
14203 if (k
>= ' ' && k
< 0x7f)
14226 #ifdef ENABLE_LIBCTF
14227 static ctf_sect_t
*
14228 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14230 buf
->cts_name
= SECTION_NAME (shdr
);
14231 buf
->cts_size
= shdr
->sh_size
;
14232 buf
->cts_entsize
= shdr
->sh_entsize
;
14237 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14238 it is passed, or a pointer to newly-allocated storage, in which case
14239 dump_ctf() will free it when it no longer needs it. */
14242 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14243 char *s
, void *arg
)
14245 const char *blanks
= arg
;
14248 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14253 /* Dump CTF errors/warnings. */
14255 dump_ctf_errs (ctf_file_t
*fp
)
14257 ctf_next_t
*it
= NULL
;
14262 /* Dump accumulated errors and warnings. */
14263 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
14265 error (_("%s: %s"), is_warning
? _("warning"): _("error"),
14269 if (err
!= ECTF_NEXT_END
)
14270 error (_("CTF error: cannot get CTF errors: `%s'"), ctf_errmsg (err
));
14273 /* Dump one CTF archive member. */
14276 dump_ctf_archive_member (ctf_file_t
*ctf
, const char *name
, void *arg
)
14278 ctf_file_t
*parent
= (ctf_file_t
*) arg
;
14279 const char *things
[] = {"Header", "Labels", "Data objects",
14280 "Function objects", "Variables", "Types", "Strings",
14282 const char **thing
;
14286 /* Only print out the name of non-default-named archive members.
14287 The name .ctf appears everywhere, even for things that aren't
14288 really archives, so printing it out is liable to be confusing.
14290 The parent, if there is one, is the default-owned archive member:
14291 avoid importing it into itself. (This does no harm, but looks
14294 if (strcmp (name
, ".ctf") != 0)
14296 printf (_("\nCTF archive member: %s:\n"), name
);
14297 ctf_import (ctf
, parent
);
14300 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14302 ctf_dump_state_t
*s
= NULL
;
14305 printf ("\n %s:\n", *thing
);
14306 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14307 (void *) " ")) != NULL
)
14309 printf ("%s\n", item
);
14313 if (ctf_errno (ctf
))
14315 error (_("Iteration failed: %s, %s\n"), *thing
,
14316 ctf_errmsg (ctf_errno (ctf
)));
14323 dump_ctf_errs (ctf
);
14328 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14330 Elf_Internal_Shdr
* parent_sec
= NULL
;
14331 Elf_Internal_Shdr
* symtab_sec
= NULL
;
14332 Elf_Internal_Shdr
* strtab_sec
= NULL
;
14333 void * data
= NULL
;
14334 void * symdata
= NULL
;
14335 void * strdata
= NULL
;
14336 void * parentdata
= NULL
;
14337 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
14338 ctf_sect_t
* symsectp
= NULL
;
14339 ctf_sect_t
* strsectp
= NULL
;
14340 ctf_archive_t
* ctfa
= NULL
;
14341 ctf_archive_t
* parenta
= NULL
, *lookparent
;
14342 ctf_file_t
* parent
= NULL
;
14345 bfd_boolean ret
= FALSE
;
14347 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
14348 data
= get_section_contents (section
, filedata
);
14349 ctfsect
.cts_data
= data
;
14351 if (!dump_ctf_symtab_name
)
14352 dump_ctf_symtab_name
= strdup (".symtab");
14354 if (!dump_ctf_strtab_name
)
14355 dump_ctf_strtab_name
= strdup (".strtab");
14357 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
14359 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
14361 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
14364 if ((symdata
= (void *) get_data (NULL
, filedata
,
14365 symtab_sec
->sh_offset
, 1,
14366 symtab_sec
->sh_size
,
14367 _("symbols"))) == NULL
)
14369 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
14370 symsect
.cts_data
= symdata
;
14372 if (dump_ctf_strtab_name
&& dump_ctf_strtab_name
[0] != 0)
14374 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
14376 error (_("No string table section named %s\n"),
14377 dump_ctf_strtab_name
);
14380 if ((strdata
= (void *) get_data (NULL
, filedata
,
14381 strtab_sec
->sh_offset
, 1,
14382 strtab_sec
->sh_size
,
14383 _("strings"))) == NULL
)
14385 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
14386 strsect
.cts_data
= strdata
;
14388 if (dump_ctf_parent_name
)
14390 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
14392 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
14395 if ((parentdata
= (void *) get_data (NULL
, filedata
,
14396 parent_sec
->sh_offset
, 1,
14397 parent_sec
->sh_size
,
14398 _("CTF parent"))) == NULL
)
14400 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
14401 parentsect
.cts_data
= parentdata
;
14404 /* Load the CTF file and dump it. It may be a raw CTF section, or an archive:
14405 libctf papers over the difference, so we can pretend it is always an
14406 archive. Possibly open the parent as well, if one was specified. */
14408 if ((ctfa
= ctf_arc_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14410 dump_ctf_errs (NULL
);
14411 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14417 if ((parenta
= ctf_arc_bufopen (&parentsect
, symsectp
, strsectp
,
14420 dump_ctf_errs (NULL
);
14421 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14424 lookparent
= parenta
;
14429 /* Assume that the applicable parent archive member is the default one.
14430 (This is what all known implementations are expected to do, if they
14431 put CTFs and their parents in archives together.) */
14432 if ((parent
= ctf_arc_open_by_name (lookparent
, NULL
, &err
)) == NULL
)
14434 dump_ctf_errs (NULL
);
14435 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14441 printf (_("\nDump of CTF section '%s':\n"),
14442 printable_section_name (filedata
, section
));
14444 if (ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
) != 0)
14448 ctf_file_close (parent
);
14450 ctf_close (parenta
);
14460 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14461 const Elf_Internal_Shdr
* sec
,
14464 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14466 Filedata
* filedata
= (Filedata
*) data
;
14468 if (section
->start
!= NULL
)
14470 /* If it is already loaded, do nothing. */
14471 if (streq (section
->filename
, filedata
->file_name
))
14473 free (section
->start
);
14476 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14477 section
->address
= sec
->sh_addr
;
14478 section
->user_data
= NULL
;
14479 section
->filename
= filedata
->file_name
;
14480 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14482 sec
->sh_size
, buf
);
14483 if (section
->start
== NULL
)
14487 unsigned char *start
= section
->start
;
14488 dwarf_size_type size
= sec
->sh_size
;
14489 dwarf_size_type uncompressed_size
= 0;
14491 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14493 Elf_Internal_Chdr chdr
;
14494 unsigned int compression_header_size
;
14496 if (size
< (is_32bit_elf
14497 ? sizeof (Elf32_External_Chdr
)
14498 : sizeof (Elf64_External_Chdr
)))
14500 warn (_("compressed section %s is too small to contain a compression header\n"),
14505 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14506 if (compression_header_size
== 0)
14507 /* An error message will have already been generated
14508 by get_compression_header. */
14511 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14513 warn (_("section '%s' has unsupported compress type: %d\n"),
14514 section
->name
, chdr
.ch_type
);
14517 uncompressed_size
= chdr
.ch_size
;
14518 start
+= compression_header_size
;
14519 size
-= compression_header_size
;
14521 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14523 /* Read the zlib header. In this case, it should be "ZLIB"
14524 followed by the uncompressed section size, 8 bytes in
14525 big-endian order. */
14526 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14527 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14528 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14529 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14530 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14531 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14532 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14533 uncompressed_size
+= start
[11];
14538 if (uncompressed_size
)
14540 if (uncompress_section_contents (&start
, uncompressed_size
,
14543 /* Free the compressed buffer, update the section buffer
14544 and the section size if uncompress is successful. */
14545 free (section
->start
);
14546 section
->start
= start
;
14550 error (_("Unable to decompress section %s\n"),
14551 printable_section_name (filedata
, sec
));
14556 section
->size
= size
;
14559 if (section
->start
== NULL
)
14562 if (debug_displays
[debug
].relocate
)
14564 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14565 & section
->reloc_info
, & section
->num_relocs
))
14570 section
->reloc_info
= NULL
;
14571 section
->num_relocs
= 0;
14577 #if HAVE_LIBDEBUGINFOD
14578 /* Return a hex string representation of the build-id. */
14580 get_build_id (void * data
)
14582 Filedata
* filedata
= (Filedata
*)data
;
14583 Elf_Internal_Shdr
* shdr
;
14586 /* Iterate through notes to find note.gnu.build-id.
14587 FIXME: Only the first note in any note section is examined. */
14588 for (i
= 0, shdr
= filedata
->section_headers
;
14589 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
14592 if (shdr
->sh_type
!= SHT_NOTE
)
14597 size_t data_remaining
;
14599 Elf_External_Note
* enote
;
14600 Elf_Internal_Note inote
;
14602 bfd_vma offset
= shdr
->sh_offset
;
14603 bfd_vma align
= shdr
->sh_addralign
;
14604 bfd_vma length
= shdr
->sh_size
;
14606 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
14612 else if (align
!= 4 && align
!= 8)
14618 end
= (char *) enote
+ length
;
14619 data_remaining
= end
- (char *) enote
;
14621 if (!is_ia64_vms (filedata
))
14623 min_notesz
= offsetof (Elf_External_Note
, name
);
14624 if (data_remaining
< min_notesz
)
14627 malformed note encountered in section %s whilst scanning for build-id note\n"),
14628 printable_section_name (filedata
, shdr
));
14632 data_remaining
-= min_notesz
;
14634 inote
.type
= BYTE_GET (enote
->type
);
14635 inote
.namesz
= BYTE_GET (enote
->namesz
);
14636 inote
.namedata
= enote
->name
;
14637 inote
.descsz
= BYTE_GET (enote
->descsz
);
14638 inote
.descdata
= ((char *) enote
14639 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
14640 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14641 next
= ((char *) enote
14642 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
14646 Elf64_External_VMS_Note
*vms_enote
;
14648 /* PR binutils/15191
14649 Make sure that there is enough data to read. */
14650 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14651 if (data_remaining
< min_notesz
)
14654 malformed note encountered in section %s whilst scanning for build-id note\n"),
14655 printable_section_name (filedata
, shdr
));
14659 data_remaining
-= min_notesz
;
14661 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
14662 inote
.type
= BYTE_GET (vms_enote
->type
);
14663 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
14664 inote
.namedata
= vms_enote
->name
;
14665 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
14666 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14667 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14668 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14671 /* Skip malformed notes. */
14672 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
14673 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
14674 || (size_t) (next
- inote
.descdata
) < inote
.descsz
14675 || ((size_t) (next
- inote
.descdata
)
14676 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
14679 malformed note encountered in section %s whilst scanning for build-id note\n"),
14680 printable_section_name (filedata
, shdr
));
14685 /* Check if this is the build-id note. If so then convert the build-id
14686 bytes to a hex string. */
14687 if (inote
.namesz
> 0
14688 && const_strneq (inote
.namedata
, "GNU")
14689 && inote
.type
== NT_GNU_BUILD_ID
)
14694 build_id
= malloc (inote
.descsz
* 2 + 1);
14695 if (build_id
== NULL
)
14701 for (j
= 0; j
< inote
.descsz
; ++j
)
14702 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
14703 build_id
[inote
.descsz
* 2] = '\0';
14706 return (unsigned char *) build_id
;
14713 #endif /* HAVE_LIBDEBUGINFOD */
14715 /* If this is not NULL, load_debug_section will only look for sections
14716 within the list of sections given here. */
14717 static unsigned int * section_subset
= NULL
;
14720 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
14722 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14723 Elf_Internal_Shdr
* sec
;
14724 Filedata
* filedata
= (Filedata
*) data
;
14726 /* Without section headers we cannot find any sections. */
14727 if (filedata
->section_headers
== NULL
)
14730 if (filedata
->string_table
== NULL
14731 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
14732 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
14734 Elf_Internal_Shdr
* strs
;
14736 /* Read in the string table, so that we have section names to scan. */
14737 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
14739 if (strs
!= NULL
&& strs
->sh_size
!= 0)
14741 filedata
->string_table
14742 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
14743 1, strs
->sh_size
, _("string table"));
14745 filedata
->string_table_length
14746 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
14750 /* Locate the debug section. */
14751 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
14753 section
->name
= section
->uncompressed_name
;
14756 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
14758 section
->name
= section
->compressed_name
;
14763 /* If we're loading from a subset of sections, and we've loaded
14764 a section matching this name before, it's likely that it's a
14766 if (section_subset
!= NULL
)
14767 free_debug_section (debug
);
14769 return load_specific_debug_section (debug
, sec
, data
);
14773 free_debug_section (enum dwarf_section_display_enum debug
)
14775 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14777 if (section
->start
== NULL
)
14780 free ((char *) section
->start
);
14781 section
->start
= NULL
;
14782 section
->address
= 0;
14785 free (section
->reloc_info
);
14786 section
->reloc_info
= NULL
;
14787 section
->num_relocs
= 0;
14791 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14793 char * name
= SECTION_NAME (section
);
14794 const char * print_name
= printable_section_name (filedata
, section
);
14795 bfd_size_type length
;
14796 bfd_boolean result
= TRUE
;
14799 length
= section
->sh_size
;
14802 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
14805 if (section
->sh_type
== SHT_NOBITS
)
14807 /* There is no point in dumping the contents of a debugging section
14808 which has the NOBITS type - the bits in the file will be random.
14809 This can happen when a file containing a .eh_frame section is
14810 stripped with the --only-keep-debug command line option. */
14811 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14816 if (const_strneq (name
, ".gnu.linkonce.wi."))
14817 name
= ".debug_info";
14819 /* See if we know how to display the contents of this section. */
14820 for (i
= 0; i
< max
; i
++)
14822 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
14823 struct dwarf_section_display
* display
= debug_displays
+ i
;
14824 struct dwarf_section
* sec
= & display
->section
;
14826 if (streq (sec
->uncompressed_name
, name
)
14827 || (id
== line
&& const_strneq (name
, ".debug_line."))
14828 || streq (sec
->compressed_name
, name
))
14830 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
14833 free_debug_section (id
);
14835 if (i
== line
&& const_strneq (name
, ".debug_line."))
14837 else if (streq (sec
->uncompressed_name
, name
))
14838 sec
->name
= sec
->uncompressed_name
;
14840 sec
->name
= sec
->compressed_name
;
14842 if (load_specific_debug_section (id
, section
, filedata
))
14844 /* If this debug section is part of a CU/TU set in a .dwp file,
14845 restrict load_debug_section to the sections in that set. */
14846 section_subset
= find_cu_tu_set (filedata
, shndx
);
14848 result
&= display
->display (sec
, filedata
);
14850 section_subset
= NULL
;
14852 if (secondary
|| (id
!= info
&& id
!= abbrev
))
14853 free_debug_section (id
);
14861 printf (_("Unrecognized debug section: %s\n"), print_name
);
14868 /* Set DUMP_SECTS for all sections where dumps were requested
14869 based on section name. */
14872 initialise_dumps_byname (Filedata
* filedata
)
14874 struct dump_list_entry
* cur
;
14876 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14879 bfd_boolean any
= FALSE
;
14881 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14882 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14884 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
14889 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14895 process_section_contents (Filedata
* filedata
)
14897 Elf_Internal_Shdr
* section
;
14899 bfd_boolean res
= TRUE
;
14904 initialise_dumps_byname (filedata
);
14906 for (i
= 0, section
= filedata
->section_headers
;
14907 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
14910 dump_type dump
= filedata
->dump
.dump_sects
[i
];
14912 #ifdef SUPPORT_DISASSEMBLY
14913 if (dump
& DISASS_DUMP
)
14915 if (! disassemble_section (section
, filedata
))
14919 if (dump
& HEX_DUMP
)
14921 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14925 if (dump
& RELOC_DUMP
)
14927 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14931 if (dump
& STRING_DUMP
)
14933 if (! dump_section_as_strings (section
, filedata
))
14937 if (dump
& DEBUG_DUMP
)
14939 if (! display_debug_section (i
, section
, filedata
))
14943 #ifdef ENABLE_LIBCTF
14944 if (dump
& CTF_DUMP
)
14946 if (! dump_section_as_ctf (section
, filedata
))
14952 /* Check to see if the user requested a
14953 dump of a section that does not exist. */
14954 while (i
< filedata
->dump
.num_dump_sects
)
14956 if (filedata
->dump
.dump_sects
[i
])
14958 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14968 process_mips_fpe_exception (int mask
)
14972 bfd_boolean first
= TRUE
;
14974 if (mask
& OEX_FPU_INEX
)
14975 fputs ("INEX", stdout
), first
= FALSE
;
14976 if (mask
& OEX_FPU_UFLO
)
14977 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14978 if (mask
& OEX_FPU_OFLO
)
14979 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14980 if (mask
& OEX_FPU_DIV0
)
14981 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14982 if (mask
& OEX_FPU_INVAL
)
14983 printf ("%sINVAL", first
? "" : "|");
14986 fputs ("0", stdout
);
14989 /* Display's the value of TAG at location P. If TAG is
14990 greater than 0 it is assumed to be an unknown tag, and
14991 a message is printed to this effect. Otherwise it is
14992 assumed that a message has already been printed.
14994 If the bottom bit of TAG is set it assumed to have a
14995 string value, otherwise it is assumed to have an integer
14998 Returns an updated P pointing to the first unread byte
14999 beyond the end of TAG's value.
15001 Reads at or beyond END will not be made. */
15003 static unsigned char *
15004 display_tag_value (signed int tag
,
15006 const unsigned char * const end
)
15011 printf (" Tag_unknown_%d: ", tag
);
15015 warn (_("<corrupt tag>\n"));
15019 /* PR 17531 file: 027-19978-0.004. */
15020 size_t maxlen
= (end
- p
) - 1;
15025 print_symbol ((int) maxlen
, (const char *) p
);
15026 p
+= strnlen ((char *) p
, maxlen
) + 1;
15030 printf (_("<corrupt string tag>"));
15031 p
= (unsigned char *) end
;
15037 READ_ULEB (val
, p
, end
);
15038 printf ("%ld (0x%lx)\n", val
, val
);
15045 /* ARC ABI attributes section. */
15047 static unsigned char *
15048 display_arc_attribute (unsigned char * p
,
15049 const unsigned char * const end
)
15054 READ_ULEB (tag
, p
, end
);
15058 case Tag_ARC_PCS_config
:
15059 READ_ULEB (val
, p
, end
);
15060 printf (" Tag_ARC_PCS_config: ");
15064 printf (_("Absent/Non standard\n"));
15067 printf (_("Bare metal/mwdt\n"));
15070 printf (_("Bare metal/newlib\n"));
15073 printf (_("Linux/uclibc\n"));
15076 printf (_("Linux/glibc\n"));
15079 printf (_("Unknown\n"));
15084 case Tag_ARC_CPU_base
:
15085 READ_ULEB (val
, p
, end
);
15086 printf (" Tag_ARC_CPU_base: ");
15091 printf (_("Absent\n"));
15093 case TAG_CPU_ARC6xx
:
15094 printf ("ARC6xx\n");
15096 case TAG_CPU_ARC7xx
:
15097 printf ("ARC7xx\n");
15099 case TAG_CPU_ARCEM
:
15100 printf ("ARCEM\n");
15102 case TAG_CPU_ARCHS
:
15103 printf ("ARCHS\n");
15108 case Tag_ARC_CPU_variation
:
15109 READ_ULEB (val
, p
, end
);
15110 printf (" Tag_ARC_CPU_variation: ");
15114 if (val
> 0 && val
< 16)
15115 printf ("Core%d\n", val
);
15117 printf ("Unknown\n");
15121 printf (_("Absent\n"));
15126 case Tag_ARC_CPU_name
:
15127 printf (" Tag_ARC_CPU_name: ");
15128 p
= display_tag_value (-1, p
, end
);
15131 case Tag_ARC_ABI_rf16
:
15132 READ_ULEB (val
, p
, end
);
15133 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
15136 case Tag_ARC_ABI_osver
:
15137 READ_ULEB (val
, p
, end
);
15138 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
15141 case Tag_ARC_ABI_pic
:
15142 case Tag_ARC_ABI_sda
:
15143 READ_ULEB (val
, p
, end
);
15144 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
15145 : " Tag_ARC_ABI_pic: ");
15149 printf (_("Absent\n"));
15158 printf (_("Unknown\n"));
15163 case Tag_ARC_ABI_tls
:
15164 READ_ULEB (val
, p
, end
);
15165 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
15168 case Tag_ARC_ABI_enumsize
:
15169 READ_ULEB (val
, p
, end
);
15170 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
15174 case Tag_ARC_ABI_exceptions
:
15175 READ_ULEB (val
, p
, end
);
15176 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
15180 case Tag_ARC_ABI_double_size
:
15181 READ_ULEB (val
, p
, end
);
15182 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
15185 case Tag_ARC_ISA_config
:
15186 printf (" Tag_ARC_ISA_config: ");
15187 p
= display_tag_value (-1, p
, end
);
15190 case Tag_ARC_ISA_apex
:
15191 printf (" Tag_ARC_ISA_apex: ");
15192 p
= display_tag_value (-1, p
, end
);
15195 case Tag_ARC_ISA_mpy_option
:
15196 READ_ULEB (val
, p
, end
);
15197 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
15200 case Tag_ARC_ATR_version
:
15201 READ_ULEB (val
, p
, end
);
15202 printf (" Tag_ARC_ATR_version: %d\n", val
);
15206 return display_tag_value (tag
& 1, p
, end
);
15212 /* ARM EABI attributes section. */
15217 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
15219 const char ** table
;
15220 } arm_attr_public_tag
;
15222 static const char * arm_attr_tag_CPU_arch
[] =
15223 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
15224 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
15225 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
15226 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
15227 static const char * arm_attr_tag_THUMB_ISA_use
[] =
15228 {"No", "Thumb-1", "Thumb-2", "Yes"};
15229 static const char * arm_attr_tag_FP_arch
[] =
15230 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
15231 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
15232 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
15233 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
15234 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
15235 "NEON for ARMv8.1"};
15236 static const char * arm_attr_tag_PCS_config
[] =
15237 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
15238 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
15239 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
15240 {"V6", "SB", "TLS", "Unused"};
15241 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
15242 {"Absolute", "PC-relative", "SB-relative", "None"};
15243 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
15244 {"Absolute", "PC-relative", "None"};
15245 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
15246 {"None", "direct", "GOT-indirect"};
15247 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
15248 {"None", "??? 1", "2", "??? 3", "4"};
15249 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
15250 static const char * arm_attr_tag_ABI_FP_denormal
[] =
15251 {"Unused", "Needed", "Sign only"};
15252 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
15253 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
15254 static const char * arm_attr_tag_ABI_FP_number_model
[] =
15255 {"Unused", "Finite", "RTABI", "IEEE 754"};
15256 static const char * arm_attr_tag_ABI_enum_size
[] =
15257 {"Unused", "small", "int", "forced to int"};
15258 static const char * arm_attr_tag_ABI_HardFP_use
[] =
15259 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
15260 static const char * arm_attr_tag_ABI_VFP_args
[] =
15261 {"AAPCS", "VFP registers", "custom", "compatible"};
15262 static const char * arm_attr_tag_ABI_WMMX_args
[] =
15263 {"AAPCS", "WMMX registers", "custom"};
15264 static const char * arm_attr_tag_ABI_optimization_goals
[] =
15265 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15266 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
15267 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
15268 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15269 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
15270 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
15271 static const char * arm_attr_tag_FP_HP_extension
[] =
15272 {"Not Allowed", "Allowed"};
15273 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
15274 {"None", "IEEE 754", "Alternative Format"};
15275 static const char * arm_attr_tag_DSP_extension
[] =
15276 {"Follow architecture", "Allowed"};
15277 static const char * arm_attr_tag_MPextension_use
[] =
15278 {"Not Allowed", "Allowed"};
15279 static const char * arm_attr_tag_DIV_use
[] =
15280 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
15281 "Allowed in v7-A with integer division extension"};
15282 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
15283 static const char * arm_attr_tag_Virtualization_use
[] =
15284 {"Not Allowed", "TrustZone", "Virtualization Extensions",
15285 "TrustZone and Virtualization Extensions"};
15286 static const char * arm_attr_tag_MPextension_use_legacy
[] =
15287 {"Not Allowed", "Allowed"};
15289 static const char * arm_attr_tag_MVE_arch
[] =
15290 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
15292 #define LOOKUP(id, name) \
15293 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
15294 static arm_attr_public_tag arm_attr_public_tags
[] =
15296 {4, "CPU_raw_name", 1, NULL
},
15297 {5, "CPU_name", 1, NULL
},
15298 LOOKUP(6, CPU_arch
),
15299 {7, "CPU_arch_profile", 0, NULL
},
15300 LOOKUP(8, ARM_ISA_use
),
15301 LOOKUP(9, THUMB_ISA_use
),
15302 LOOKUP(10, FP_arch
),
15303 LOOKUP(11, WMMX_arch
),
15304 LOOKUP(12, Advanced_SIMD_arch
),
15305 LOOKUP(13, PCS_config
),
15306 LOOKUP(14, ABI_PCS_R9_use
),
15307 LOOKUP(15, ABI_PCS_RW_data
),
15308 LOOKUP(16, ABI_PCS_RO_data
),
15309 LOOKUP(17, ABI_PCS_GOT_use
),
15310 LOOKUP(18, ABI_PCS_wchar_t
),
15311 LOOKUP(19, ABI_FP_rounding
),
15312 LOOKUP(20, ABI_FP_denormal
),
15313 LOOKUP(21, ABI_FP_exceptions
),
15314 LOOKUP(22, ABI_FP_user_exceptions
),
15315 LOOKUP(23, ABI_FP_number_model
),
15316 {24, "ABI_align_needed", 0, NULL
},
15317 {25, "ABI_align_preserved", 0, NULL
},
15318 LOOKUP(26, ABI_enum_size
),
15319 LOOKUP(27, ABI_HardFP_use
),
15320 LOOKUP(28, ABI_VFP_args
),
15321 LOOKUP(29, ABI_WMMX_args
),
15322 LOOKUP(30, ABI_optimization_goals
),
15323 LOOKUP(31, ABI_FP_optimization_goals
),
15324 {32, "compatibility", 0, NULL
},
15325 LOOKUP(34, CPU_unaligned_access
),
15326 LOOKUP(36, FP_HP_extension
),
15327 LOOKUP(38, ABI_FP_16bit_format
),
15328 LOOKUP(42, MPextension_use
),
15329 LOOKUP(44, DIV_use
),
15330 LOOKUP(46, DSP_extension
),
15331 LOOKUP(48, MVE_arch
),
15332 {64, "nodefaults", 0, NULL
},
15333 {65, "also_compatible_with", 0, NULL
},
15334 LOOKUP(66, T2EE_use
),
15335 {67, "conformance", 1, NULL
},
15336 LOOKUP(68, Virtualization_use
),
15337 LOOKUP(70, MPextension_use_legacy
)
15341 static unsigned char *
15342 display_arm_attribute (unsigned char * p
,
15343 const unsigned char * const end
)
15347 arm_attr_public_tag
* attr
;
15351 READ_ULEB (tag
, p
, end
);
15353 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
15355 if (arm_attr_public_tags
[i
].tag
== tag
)
15357 attr
= &arm_attr_public_tags
[i
];
15364 printf (" Tag_%s: ", attr
->name
);
15365 switch (attr
->type
)
15370 case 7: /* Tag_CPU_arch_profile. */
15371 READ_ULEB (val
, p
, end
);
15374 case 0: printf (_("None\n")); break;
15375 case 'A': printf (_("Application\n")); break;
15376 case 'R': printf (_("Realtime\n")); break;
15377 case 'M': printf (_("Microcontroller\n")); break;
15378 case 'S': printf (_("Application or Realtime\n")); break;
15379 default: printf ("??? (%d)\n", val
); break;
15383 case 24: /* Tag_align_needed. */
15384 READ_ULEB (val
, p
, end
);
15387 case 0: printf (_("None\n")); break;
15388 case 1: printf (_("8-byte\n")); break;
15389 case 2: printf (_("4-byte\n")); break;
15390 case 3: printf ("??? 3\n"); break;
15393 printf (_("8-byte and up to %d-byte extended\n"),
15396 printf ("??? (%d)\n", val
);
15401 case 25: /* Tag_align_preserved. */
15402 READ_ULEB (val
, p
, end
);
15405 case 0: printf (_("None\n")); break;
15406 case 1: printf (_("8-byte, except leaf SP\n")); break;
15407 case 2: printf (_("8-byte\n")); break;
15408 case 3: printf ("??? 3\n"); break;
15411 printf (_("8-byte and up to %d-byte extended\n"),
15414 printf ("??? (%d)\n", val
);
15419 case 32: /* Tag_compatibility. */
15421 READ_ULEB (val
, p
, end
);
15422 printf (_("flag = %d, vendor = "), val
);
15425 size_t maxlen
= (end
- p
) - 1;
15427 print_symbol ((int) maxlen
, (const char *) p
);
15428 p
+= strnlen ((char *) p
, maxlen
) + 1;
15432 printf (_("<corrupt>"));
15433 p
= (unsigned char *) end
;
15439 case 64: /* Tag_nodefaults. */
15440 /* PR 17531: file: 001-505008-0.01. */
15443 printf (_("True\n"));
15446 case 65: /* Tag_also_compatible_with. */
15447 READ_ULEB (val
, p
, end
);
15448 if (val
== 6 /* Tag_CPU_arch. */)
15450 READ_ULEB (val
, p
, end
);
15451 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
15452 printf ("??? (%d)\n", val
);
15454 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
15458 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
15463 printf (_("<unknown: %d>\n"), tag
);
15469 return display_tag_value (-1, p
, end
);
15471 return display_tag_value (0, p
, end
);
15474 assert (attr
->type
& 0x80);
15475 READ_ULEB (val
, p
, end
);
15476 type
= attr
->type
& 0x7f;
15478 printf ("??? (%d)\n", val
);
15480 printf ("%s\n", attr
->table
[val
]);
15485 return display_tag_value (tag
, p
, end
);
15488 static unsigned char *
15489 display_gnu_attribute (unsigned char * p
,
15490 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
15491 const unsigned char * const end
)
15496 READ_ULEB (tag
, p
, end
);
15498 /* Tag_compatibility is the only generic GNU attribute defined at
15502 READ_ULEB (val
, p
, end
);
15504 printf (_("flag = %d, vendor = "), val
);
15507 printf (_("<corrupt>\n"));
15508 warn (_("corrupt vendor attribute\n"));
15514 size_t maxlen
= (end
- p
) - 1;
15516 print_symbol ((int) maxlen
, (const char *) p
);
15517 p
+= strnlen ((char *) p
, maxlen
) + 1;
15521 printf (_("<corrupt>"));
15522 p
= (unsigned char *) end
;
15529 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15530 return display_proc_gnu_attribute (p
, tag
, end
);
15532 return display_tag_value (tag
, p
, end
);
15535 static unsigned char *
15536 display_m68k_gnu_attribute (unsigned char * p
,
15538 const unsigned char * const end
)
15542 if (tag
== Tag_GNU_M68K_ABI_FP
)
15544 printf (" Tag_GNU_M68K_ABI_FP: ");
15547 printf (_("<corrupt>\n"));
15550 READ_ULEB (val
, p
, end
);
15553 printf ("(%#x), ", val
);
15558 printf (_("unspecified hard/soft float\n"));
15561 printf (_("hard float\n"));
15564 printf (_("soft float\n"));
15570 return display_tag_value (tag
& 1, p
, end
);
15573 static unsigned char *
15574 display_power_gnu_attribute (unsigned char * p
,
15576 const unsigned char * const end
)
15580 if (tag
== Tag_GNU_Power_ABI_FP
)
15582 printf (" Tag_GNU_Power_ABI_FP: ");
15585 printf (_("<corrupt>\n"));
15588 READ_ULEB (val
, p
, end
);
15591 printf ("(%#x), ", val
);
15596 printf (_("unspecified hard/soft float, "));
15599 printf (_("hard float, "));
15602 printf (_("soft float, "));
15605 printf (_("single-precision hard float, "));
15612 printf (_("unspecified long double\n"));
15615 printf (_("128-bit IBM long double\n"));
15618 printf (_("64-bit long double\n"));
15621 printf (_("128-bit IEEE long double\n"));
15627 if (tag
== Tag_GNU_Power_ABI_Vector
)
15629 printf (" Tag_GNU_Power_ABI_Vector: ");
15632 printf (_("<corrupt>\n"));
15635 READ_ULEB (val
, p
, end
);
15638 printf ("(%#x), ", val
);
15643 printf (_("unspecified\n"));
15646 printf (_("generic\n"));
15649 printf ("AltiVec\n");
15658 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
15660 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15663 printf (_("<corrupt>\n"));
15666 READ_ULEB (val
, p
, end
);
15669 printf ("(%#x), ", val
);
15674 printf (_("unspecified\n"));
15677 printf ("r3/r4\n");
15680 printf (_("memory\n"));
15689 return display_tag_value (tag
& 1, p
, end
);
15692 static unsigned char *
15693 display_s390_gnu_attribute (unsigned char * p
,
15695 const unsigned char * const end
)
15699 if (tag
== Tag_GNU_S390_ABI_Vector
)
15701 printf (" Tag_GNU_S390_ABI_Vector: ");
15702 READ_ULEB (val
, p
, end
);
15707 printf (_("any\n"));
15710 printf (_("software\n"));
15713 printf (_("hardware\n"));
15716 printf ("??? (%d)\n", val
);
15722 return display_tag_value (tag
& 1, p
, end
);
15726 display_sparc_hwcaps (unsigned int mask
)
15730 bfd_boolean first
= TRUE
;
15732 if (mask
& ELF_SPARC_HWCAP_MUL32
)
15733 fputs ("mul32", stdout
), first
= FALSE
;
15734 if (mask
& ELF_SPARC_HWCAP_DIV32
)
15735 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
15736 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
15737 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
15738 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
15739 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
15740 if (mask
& ELF_SPARC_HWCAP_POPC
)
15741 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
15742 if (mask
& ELF_SPARC_HWCAP_VIS
)
15743 printf ("%svis", first
? "" : "|"), first
= FALSE
;
15744 if (mask
& ELF_SPARC_HWCAP_VIS2
)
15745 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
15746 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
15747 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
15748 if (mask
& ELF_SPARC_HWCAP_FMAF
)
15749 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
15750 if (mask
& ELF_SPARC_HWCAP_VIS3
)
15751 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
15752 if (mask
& ELF_SPARC_HWCAP_HPC
)
15753 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
15754 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
15755 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
15756 if (mask
& ELF_SPARC_HWCAP_TRANS
)
15757 printf ("%strans", first
? "" : "|"), first
= FALSE
;
15758 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
15759 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
15760 if (mask
& ELF_SPARC_HWCAP_IMA
)
15761 printf ("%sima", first
? "" : "|"), first
= FALSE
;
15762 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
15763 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
15766 fputc ('0', stdout
);
15767 fputc ('\n', stdout
);
15771 display_sparc_hwcaps2 (unsigned int mask
)
15775 bfd_boolean first
= TRUE
;
15777 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
15778 fputs ("fjathplus", stdout
), first
= FALSE
;
15779 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
15780 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
15781 if (mask
& ELF_SPARC_HWCAP2_ADP
)
15782 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
15783 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
15784 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
15785 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
15786 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
15787 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
15788 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
15789 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
15790 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
15791 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
15792 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
15793 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
15794 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
15795 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
15796 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
15797 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
15798 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
15801 fputc ('0', stdout
);
15802 fputc ('\n', stdout
);
15805 static unsigned char *
15806 display_sparc_gnu_attribute (unsigned char * p
,
15808 const unsigned char * const end
)
15812 if (tag
== Tag_GNU_Sparc_HWCAPS
)
15814 READ_ULEB (val
, p
, end
);
15815 printf (" Tag_GNU_Sparc_HWCAPS: ");
15816 display_sparc_hwcaps (val
);
15819 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
15821 READ_ULEB (val
, p
, end
);
15822 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15823 display_sparc_hwcaps2 (val
);
15827 return display_tag_value (tag
, p
, end
);
15831 print_mips_fp_abi_value (unsigned int val
)
15835 case Val_GNU_MIPS_ABI_FP_ANY
:
15836 printf (_("Hard or soft float\n"));
15838 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15839 printf (_("Hard float (double precision)\n"));
15841 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15842 printf (_("Hard float (single precision)\n"));
15844 case Val_GNU_MIPS_ABI_FP_SOFT
:
15845 printf (_("Soft float\n"));
15847 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15848 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15850 case Val_GNU_MIPS_ABI_FP_XX
:
15851 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15853 case Val_GNU_MIPS_ABI_FP_64
:
15854 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15856 case Val_GNU_MIPS_ABI_FP_64A
:
15857 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15859 case Val_GNU_MIPS_ABI_FP_NAN2008
:
15860 printf (_("NaN 2008 compatibility\n"));
15863 printf ("??? (%d)\n", val
);
15868 static unsigned char *
15869 display_mips_gnu_attribute (unsigned char * p
,
15871 const unsigned char * const end
)
15873 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15877 printf (" Tag_GNU_MIPS_ABI_FP: ");
15878 READ_ULEB (val
, p
, end
);
15879 print_mips_fp_abi_value (val
);
15883 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15887 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15888 READ_ULEB (val
, p
, end
);
15892 case Val_GNU_MIPS_ABI_MSA_ANY
:
15893 printf (_("Any MSA or not\n"));
15895 case Val_GNU_MIPS_ABI_MSA_128
:
15896 printf (_("128-bit MSA\n"));
15899 printf ("??? (%d)\n", val
);
15905 return display_tag_value (tag
& 1, p
, end
);
15908 static unsigned char *
15909 display_tic6x_attribute (unsigned char * p
,
15910 const unsigned char * const end
)
15915 READ_ULEB (tag
, p
, end
);
15920 printf (" Tag_ISA: ");
15921 READ_ULEB (val
, p
, end
);
15925 case C6XABI_Tag_ISA_none
:
15926 printf (_("None\n"));
15928 case C6XABI_Tag_ISA_C62X
:
15931 case C6XABI_Tag_ISA_C67X
:
15934 case C6XABI_Tag_ISA_C67XP
:
15935 printf ("C67x+\n");
15937 case C6XABI_Tag_ISA_C64X
:
15940 case C6XABI_Tag_ISA_C64XP
:
15941 printf ("C64x+\n");
15943 case C6XABI_Tag_ISA_C674X
:
15944 printf ("C674x\n");
15947 printf ("??? (%d)\n", val
);
15952 case Tag_ABI_wchar_t
:
15953 printf (" Tag_ABI_wchar_t: ");
15954 READ_ULEB (val
, p
, end
);
15958 printf (_("Not used\n"));
15961 printf (_("2 bytes\n"));
15964 printf (_("4 bytes\n"));
15967 printf ("??? (%d)\n", val
);
15972 case Tag_ABI_stack_align_needed
:
15973 printf (" Tag_ABI_stack_align_needed: ");
15974 READ_ULEB (val
, p
, end
);
15978 printf (_("8-byte\n"));
15981 printf (_("16-byte\n"));
15984 printf ("??? (%d)\n", val
);
15989 case Tag_ABI_stack_align_preserved
:
15990 READ_ULEB (val
, p
, end
);
15991 printf (" Tag_ABI_stack_align_preserved: ");
15995 printf (_("8-byte\n"));
15998 printf (_("16-byte\n"));
16001 printf ("??? (%d)\n", val
);
16007 READ_ULEB (val
, p
, end
);
16008 printf (" Tag_ABI_DSBT: ");
16012 printf (_("DSBT addressing not used\n"));
16015 printf (_("DSBT addressing used\n"));
16018 printf ("??? (%d)\n", val
);
16024 READ_ULEB (val
, p
, end
);
16025 printf (" Tag_ABI_PID: ");
16029 printf (_("Data addressing position-dependent\n"));
16032 printf (_("Data addressing position-independent, GOT near DP\n"));
16035 printf (_("Data addressing position-independent, GOT far from DP\n"));
16038 printf ("??? (%d)\n", val
);
16044 READ_ULEB (val
, p
, end
);
16045 printf (" Tag_ABI_PIC: ");
16049 printf (_("Code addressing position-dependent\n"));
16052 printf (_("Code addressing position-independent\n"));
16055 printf ("??? (%d)\n", val
);
16060 case Tag_ABI_array_object_alignment
:
16061 READ_ULEB (val
, p
, end
);
16062 printf (" Tag_ABI_array_object_alignment: ");
16066 printf (_("8-byte\n"));
16069 printf (_("4-byte\n"));
16072 printf (_("16-byte\n"));
16075 printf ("??? (%d)\n", val
);
16080 case Tag_ABI_array_object_align_expected
:
16081 READ_ULEB (val
, p
, end
);
16082 printf (" Tag_ABI_array_object_align_expected: ");
16086 printf (_("8-byte\n"));
16089 printf (_("4-byte\n"));
16092 printf (_("16-byte\n"));
16095 printf ("??? (%d)\n", val
);
16100 case Tag_ABI_compatibility
:
16102 READ_ULEB (val
, p
, end
);
16103 printf (" Tag_ABI_compatibility: ");
16104 printf (_("flag = %d, vendor = "), val
);
16107 size_t maxlen
= (end
- p
) - 1;
16109 print_symbol ((int) maxlen
, (const char *) p
);
16110 p
+= strnlen ((char *) p
, maxlen
) + 1;
16114 printf (_("<corrupt>"));
16115 p
= (unsigned char *) end
;
16121 case Tag_ABI_conformance
:
16123 printf (" Tag_ABI_conformance: \"");
16126 size_t maxlen
= (end
- p
) - 1;
16128 print_symbol ((int) maxlen
, (const char *) p
);
16129 p
+= strnlen ((char *) p
, maxlen
) + 1;
16133 printf (_("<corrupt>"));
16134 p
= (unsigned char *) end
;
16141 return display_tag_value (tag
, p
, end
);
16145 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
16147 unsigned long addr
= 0;
16148 size_t bytes
= end
- p
;
16155 int lbytes
= (bytes
> 16 ? 16 : bytes
);
16157 printf (" 0x%8.8lx ", addr
);
16159 for (j
= 0; j
< 16; j
++)
16162 printf ("%2.2x", p
[j
]);
16170 for (j
= 0; j
< lbytes
; j
++)
16173 if (k
>= ' ' && k
< 0x7f)
16189 static unsigned char *
16190 display_msp430_attribute (unsigned char * p
,
16191 const unsigned char * const end
)
16196 READ_ULEB (tag
, p
, end
);
16200 case OFBA_MSPABI_Tag_ISA
:
16201 printf (" Tag_ISA: ");
16202 READ_ULEB (val
, p
, end
);
16205 case 0: printf (_("None\n")); break;
16206 case 1: printf (_("MSP430\n")); break;
16207 case 2: printf (_("MSP430X\n")); break;
16208 default: printf ("??? (%d)\n", val
); break;
16212 case OFBA_MSPABI_Tag_Code_Model
:
16213 printf (" Tag_Code_Model: ");
16214 READ_ULEB (val
, p
, end
);
16217 case 0: printf (_("None\n")); break;
16218 case 1: printf (_("Small\n")); break;
16219 case 2: printf (_("Large\n")); break;
16220 default: printf ("??? (%d)\n", val
); break;
16224 case OFBA_MSPABI_Tag_Data_Model
:
16225 printf (" Tag_Data_Model: ");
16226 READ_ULEB (val
, p
, end
);
16229 case 0: printf (_("None\n")); break;
16230 case 1: printf (_("Small\n")); break;
16231 case 2: printf (_("Large\n")); break;
16232 case 3: printf (_("Restricted Large\n")); break;
16233 default: printf ("??? (%d)\n", val
); break;
16238 printf (_(" <unknown tag %d>: "), tag
);
16245 size_t maxlen
= (end
- p
) - 1;
16247 print_symbol ((int) maxlen
, (const char *) p
);
16248 p
+= strnlen ((char *) p
, maxlen
) + 1;
16252 printf (_("<corrupt>"));
16253 p
= (unsigned char *) end
;
16259 READ_ULEB (val
, p
, end
);
16260 printf ("%d (0x%x)\n", val
, val
);
16269 static unsigned char *
16270 display_msp430_gnu_attribute (unsigned char * p
,
16272 const unsigned char * const end
)
16274 if (tag
== Tag_GNU_MSP430_Data_Region
)
16278 printf (" Tag_GNU_MSP430_Data_Region: ");
16279 READ_ULEB (val
, p
, end
);
16283 case Val_GNU_MSP430_Data_Region_Any
:
16284 printf (_("Any Region\n"));
16286 case Val_GNU_MSP430_Data_Region_Lower
:
16287 printf (_("Lower Region Only\n"));
16290 printf ("??? (%u)\n", val
);
16294 return display_tag_value (tag
& 1, p
, end
);
16297 struct riscv_attr_tag_t
{
16302 static struct riscv_attr_tag_t riscv_attr_tag
[] =
16304 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
16307 T(priv_spec_minor
),
16308 T(priv_spec_revision
),
16309 T(unaligned_access
),
16314 static unsigned char *
16315 display_riscv_attribute (unsigned char *p
,
16316 const unsigned char * const end
)
16320 struct riscv_attr_tag_t
*attr
= NULL
;
16323 READ_ULEB (tag
, p
, end
);
16325 /* Find the name of attribute. */
16326 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
16328 if (riscv_attr_tag
[i
].tag
== tag
)
16330 attr
= &riscv_attr_tag
[i
];
16336 printf (" %s: ", attr
->name
);
16338 return display_tag_value (tag
, p
, end
);
16342 case Tag_RISCV_priv_spec
:
16343 case Tag_RISCV_priv_spec_minor
:
16344 case Tag_RISCV_priv_spec_revision
:
16345 READ_ULEB (val
, p
, end
);
16346 printf (_("%u\n"), val
);
16348 case Tag_RISCV_unaligned_access
:
16349 READ_ULEB (val
, p
, end
);
16353 printf (_("No unaligned access\n"));
16356 printf (_("Unaligned access\n"));
16360 case Tag_RISCV_stack_align
:
16361 READ_ULEB (val
, p
, end
);
16362 printf (_("%u-bytes\n"), val
);
16364 case Tag_RISCV_arch
:
16365 p
= display_tag_value (-1, p
, end
);
16368 return display_tag_value (tag
, p
, end
);
16374 static unsigned char *
16375 display_csky_attribute (unsigned char * p
,
16376 const unsigned char * const end
)
16380 READ_ULEB (tag
, p
, end
);
16382 if (tag
>= Tag_CSKY_MAX
)
16384 return display_tag_value (-1, p
, end
);
16389 case Tag_CSKY_ARCH_NAME
:
16390 printf (" Tag_CSKY_ARCH_NAME:\t\t");
16391 return display_tag_value (-1, p
, end
);
16392 case Tag_CSKY_CPU_NAME
:
16393 printf (" Tag_CSKY_CPU_NAME:\t\t");
16394 return display_tag_value (-1, p
, end
);
16396 case Tag_CSKY_ISA_FLAGS
:
16397 printf (" Tag_CSKY_ISA_FLAGS:\t\t");
16398 return display_tag_value (0, p
, end
);
16399 case Tag_CSKY_ISA_EXT_FLAGS
:
16400 printf (" Tag_CSKY_ISA_EXT_FLAGS:\t");
16401 return display_tag_value (0, p
, end
);
16403 case Tag_CSKY_DSP_VERSION
:
16404 printf (" Tag_CSKY_DSP_VERSION:\t\t");
16405 READ_ULEB (val
, p
, end
);
16406 if (val
== VAL_CSKY_DSP_VERSION_EXTENSION
)
16407 printf ("DSP Extension\n");
16408 else if (val
== VAL_CSKY_DSP_VERSION_2
)
16409 printf ("DSP 2.0\n");
16412 case Tag_CSKY_VDSP_VERSION
:
16413 printf (" Tag_CSKY_VDSP_VERSION:\t");
16414 READ_ULEB (val
, p
, end
);
16415 printf ("VDSP Version %d\n", val
);
16418 case Tag_CSKY_FPU_VERSION
:
16419 printf (" Tag_CSKY_FPU_VERSION:\t\t");
16420 READ_ULEB (val
, p
, end
);
16421 if (val
== VAL_CSKY_FPU_VERSION_1
)
16422 printf ("ABIV1 FPU Version 1\n");
16423 else if (val
== VAL_CSKY_FPU_VERSION_2
)
16424 printf ("FPU Version 2\n");
16427 case Tag_CSKY_FPU_ABI
:
16428 printf (" Tag_CSKY_FPU_ABI:\t\t");
16429 READ_ULEB (val
, p
, end
);
16430 if (val
== VAL_CSKY_FPU_ABI_HARD
)
16432 else if (val
== VAL_CSKY_FPU_ABI_SOFTFP
)
16433 printf ("SoftFP\n");
16434 else if (val
== VAL_CSKY_FPU_ABI_SOFT
)
16437 case Tag_CSKY_FPU_ROUNDING
:
16438 READ_ULEB (val
, p
, end
);
16440 printf (" Tag_CSKY_FPU_ROUNDING:\t");
16441 printf ("Needed\n");
16444 case Tag_CSKY_FPU_DENORMAL
:
16445 READ_ULEB (val
, p
, end
);
16447 printf (" Tag_CSKY_FPU_DENORMAL:\t");
16448 printf ("Needed\n");
16451 case Tag_CSKY_FPU_Exception
:
16452 READ_ULEB (val
, p
, end
);
16454 printf (" Tag_CSKY_FPU_Exception:\t");
16455 printf ("Needed\n");
16458 case Tag_CSKY_FPU_NUMBER_MODULE
:
16459 printf (" Tag_CSKY_FPU_NUMBER_MODULE:\t");
16460 return display_tag_value (-1, p
, end
);
16461 case Tag_CSKY_FPU_HARDFP
:
16462 printf (" Tag_CSKY_FPU_HARDFP:\t\t");
16463 READ_ULEB (val
, p
, end
);
16464 if (val
& VAL_CSKY_FPU_HARDFP_HALF
)
16466 if (val
& VAL_CSKY_FPU_HARDFP_SINGLE
)
16467 printf (" Single");
16468 if (val
& VAL_CSKY_FPU_HARDFP_DOUBLE
)
16469 printf (" Double");
16473 return display_tag_value (tag
, p
, end
);
16479 process_attributes (Filedata
* filedata
,
16480 const char * public_name
,
16481 unsigned int proc_type
,
16482 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
16483 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
16485 Elf_Internal_Shdr
* sect
;
16487 bfd_boolean res
= TRUE
;
16489 /* Find the section header so that we get the size. */
16490 for (i
= 0, sect
= filedata
->section_headers
;
16491 i
< filedata
->file_header
.e_shnum
;
16494 unsigned char * contents
;
16497 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
16500 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16501 sect
->sh_size
, _("attributes"));
16502 if (contents
== NULL
)
16509 /* The first character is the version of the attributes.
16510 Currently only version 1, (aka 'A') is recognised here. */
16513 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
16518 bfd_vma section_len
;
16520 section_len
= sect
->sh_size
- 1;
16523 while (section_len
> 0)
16526 unsigned int namelen
;
16527 bfd_boolean public_section
;
16528 bfd_boolean gnu_section
;
16530 if (section_len
<= 4)
16532 error (_("Tag section ends prematurely\n"));
16536 attr_len
= byte_get (p
, 4);
16539 if (attr_len
> section_len
)
16541 error (_("Bad attribute length (%u > %u)\n"),
16542 (unsigned) attr_len
, (unsigned) section_len
);
16543 attr_len
= section_len
;
16546 /* PR 17531: file: 001-101425-0.004 */
16547 else if (attr_len
< 5)
16549 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
16554 section_len
-= attr_len
;
16557 namelen
= strnlen ((char *) p
, attr_len
) + 1;
16558 if (namelen
== 0 || namelen
>= attr_len
)
16560 error (_("Corrupt attribute section name\n"));
16565 printf (_("Attribute Section: "));
16566 print_symbol (INT_MAX
, (const char *) p
);
16569 if (public_name
&& streq ((char *) p
, public_name
))
16570 public_section
= TRUE
;
16572 public_section
= FALSE
;
16574 if (streq ((char *) p
, "gnu"))
16575 gnu_section
= TRUE
;
16577 gnu_section
= FALSE
;
16580 attr_len
-= namelen
;
16582 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
16587 unsigned char * end
;
16589 /* PR binutils/17531: Safe handling of corrupt files. */
16592 error (_("Unused bytes at end of section\n"));
16599 size
= byte_get (p
, 4);
16600 if (size
> attr_len
)
16602 error (_("Bad subsection length (%u > %u)\n"),
16603 (unsigned) size
, (unsigned) attr_len
);
16607 /* PR binutils/17531: Safe handling of corrupt files. */
16610 error (_("Bad subsection length (%u < 6)\n"),
16618 end
= p
+ size
- 1;
16619 assert (end
<= contents
+ sect
->sh_size
);
16625 printf (_("File Attributes\n"));
16628 printf (_("Section Attributes:"));
16631 printf (_("Symbol Attributes:"));
16632 /* Fall through. */
16636 READ_ULEB (val
, p
, end
);
16639 printf (" %d", val
);
16644 printf (_("Unknown tag: %d\n"), tag
);
16645 public_section
= FALSE
;
16649 if (public_section
&& display_pub_attribute
!= NULL
)
16652 p
= display_pub_attribute (p
, end
);
16655 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
16658 p
= display_gnu_attribute (p
,
16659 display_proc_gnu_attribute
,
16665 printf (_(" Unknown attribute:\n"));
16666 display_raw_attribute (p
, end
);
16681 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16682 Print the Address, Access and Initial fields of an entry at VMA ADDR
16683 and return the VMA of the next entry, or -1 if there was a problem.
16684 Does not read from DATA_END or beyond. */
16687 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
16688 unsigned char * data_end
)
16691 print_vma (addr
, LONG_HEX
);
16693 if (addr
< pltgot
+ 0xfff0)
16694 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
16696 printf ("%10s", "");
16699 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16703 unsigned char * from
= data
+ addr
- pltgot
;
16705 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
16707 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16708 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
16709 return (bfd_vma
) -1;
16713 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16714 print_vma (entry
, LONG_HEX
);
16717 return addr
+ (is_32bit_elf
? 4 : 8);
16720 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16721 PLTGOT. Print the Address and Initial fields of an entry at VMA
16722 ADDR and return the VMA of the next entry. */
16725 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
16728 print_vma (addr
, LONG_HEX
);
16731 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16736 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16737 print_vma (entry
, LONG_HEX
);
16739 return addr
+ (is_32bit_elf
? 4 : 8);
16743 print_mips_ases (unsigned int mask
)
16745 if (mask
& AFL_ASE_DSP
)
16746 fputs ("\n\tDSP ASE", stdout
);
16747 if (mask
& AFL_ASE_DSPR2
)
16748 fputs ("\n\tDSP R2 ASE", stdout
);
16749 if (mask
& AFL_ASE_DSPR3
)
16750 fputs ("\n\tDSP R3 ASE", stdout
);
16751 if (mask
& AFL_ASE_EVA
)
16752 fputs ("\n\tEnhanced VA Scheme", stdout
);
16753 if (mask
& AFL_ASE_MCU
)
16754 fputs ("\n\tMCU (MicroController) ASE", stdout
);
16755 if (mask
& AFL_ASE_MDMX
)
16756 fputs ("\n\tMDMX ASE", stdout
);
16757 if (mask
& AFL_ASE_MIPS3D
)
16758 fputs ("\n\tMIPS-3D ASE", stdout
);
16759 if (mask
& AFL_ASE_MT
)
16760 fputs ("\n\tMT ASE", stdout
);
16761 if (mask
& AFL_ASE_SMARTMIPS
)
16762 fputs ("\n\tSmartMIPS ASE", stdout
);
16763 if (mask
& AFL_ASE_VIRT
)
16764 fputs ("\n\tVZ ASE", stdout
);
16765 if (mask
& AFL_ASE_MSA
)
16766 fputs ("\n\tMSA ASE", stdout
);
16767 if (mask
& AFL_ASE_MIPS16
)
16768 fputs ("\n\tMIPS16 ASE", stdout
);
16769 if (mask
& AFL_ASE_MICROMIPS
)
16770 fputs ("\n\tMICROMIPS ASE", stdout
);
16771 if (mask
& AFL_ASE_XPA
)
16772 fputs ("\n\tXPA ASE", stdout
);
16773 if (mask
& AFL_ASE_MIPS16E2
)
16774 fputs ("\n\tMIPS16e2 ASE", stdout
);
16775 if (mask
& AFL_ASE_CRC
)
16776 fputs ("\n\tCRC ASE", stdout
);
16777 if (mask
& AFL_ASE_GINV
)
16778 fputs ("\n\tGINV ASE", stdout
);
16779 if (mask
& AFL_ASE_LOONGSON_MMI
)
16780 fputs ("\n\tLoongson MMI ASE", stdout
);
16781 if (mask
& AFL_ASE_LOONGSON_CAM
)
16782 fputs ("\n\tLoongson CAM ASE", stdout
);
16783 if (mask
& AFL_ASE_LOONGSON_EXT
)
16784 fputs ("\n\tLoongson EXT ASE", stdout
);
16785 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16786 fputs ("\n\tLoongson EXT2 ASE", stdout
);
16788 fprintf (stdout
, "\n\t%s", _("None"));
16789 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16790 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16794 print_mips_isa_ext (unsigned int isa_ext
)
16799 fputs (_("None"), stdout
);
16802 fputs ("RMI XLR", stdout
);
16804 case AFL_EXT_OCTEON3
:
16805 fputs ("Cavium Networks Octeon3", stdout
);
16807 case AFL_EXT_OCTEON2
:
16808 fputs ("Cavium Networks Octeon2", stdout
);
16810 case AFL_EXT_OCTEONP
:
16811 fputs ("Cavium Networks OcteonP", stdout
);
16813 case AFL_EXT_OCTEON
:
16814 fputs ("Cavium Networks Octeon", stdout
);
16817 fputs ("Toshiba R5900", stdout
);
16820 fputs ("MIPS R4650", stdout
);
16823 fputs ("LSI R4010", stdout
);
16826 fputs ("NEC VR4100", stdout
);
16829 fputs ("Toshiba R3900", stdout
);
16831 case AFL_EXT_10000
:
16832 fputs ("MIPS R10000", stdout
);
16835 fputs ("Broadcom SB-1", stdout
);
16838 fputs ("NEC VR4111/VR4181", stdout
);
16841 fputs ("NEC VR4120", stdout
);
16844 fputs ("NEC VR5400", stdout
);
16847 fputs ("NEC VR5500", stdout
);
16849 case AFL_EXT_LOONGSON_2E
:
16850 fputs ("ST Microelectronics Loongson 2E", stdout
);
16852 case AFL_EXT_LOONGSON_2F
:
16853 fputs ("ST Microelectronics Loongson 2F", stdout
);
16855 case AFL_EXT_INTERAPTIV_MR2
:
16856 fputs ("Imagination interAptiv MR2", stdout
);
16859 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
16864 get_mips_reg_size (int reg_size
)
16866 return (reg_size
== AFL_REG_NONE
) ? 0
16867 : (reg_size
== AFL_REG_32
) ? 32
16868 : (reg_size
== AFL_REG_64
) ? 64
16869 : (reg_size
== AFL_REG_128
) ? 128
16874 process_mips_specific (Filedata
* filedata
)
16876 Elf_Internal_Dyn
* entry
;
16877 Elf_Internal_Shdr
*sect
= NULL
;
16878 size_t liblist_offset
= 0;
16879 size_t liblistno
= 0;
16880 size_t conflictsno
= 0;
16881 size_t options_offset
= 0;
16882 size_t conflicts_offset
= 0;
16883 size_t pltrelsz
= 0;
16885 bfd_vma pltgot
= 0;
16886 bfd_vma mips_pltgot
= 0;
16887 bfd_vma jmprel
= 0;
16888 bfd_vma local_gotno
= 0;
16889 bfd_vma gotsym
= 0;
16890 bfd_vma symtabno
= 0;
16891 bfd_boolean res
= TRUE
;
16893 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16894 display_mips_gnu_attribute
))
16897 sect
= find_section (filedata
, ".MIPS.abiflags");
16901 Elf_External_ABIFlags_v0
*abiflags_ext
;
16902 Elf_Internal_ABIFlags_v0 abiflags_in
;
16904 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
16906 error (_("Corrupt MIPS ABI Flags section.\n"));
16911 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16912 sect
->sh_size
, _("MIPS ABI Flags section"));
16915 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
16916 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
16917 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
16918 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
16919 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
16920 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
16921 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
16922 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
16923 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
16924 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
16925 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
16927 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
16928 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
16929 if (abiflags_in
.isa_rev
> 1)
16930 printf ("r%d", abiflags_in
.isa_rev
);
16931 printf ("\nGPR size: %d",
16932 get_mips_reg_size (abiflags_in
.gpr_size
));
16933 printf ("\nCPR1 size: %d",
16934 get_mips_reg_size (abiflags_in
.cpr1_size
));
16935 printf ("\nCPR2 size: %d",
16936 get_mips_reg_size (abiflags_in
.cpr2_size
));
16937 fputs ("\nFP ABI: ", stdout
);
16938 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
16939 fputs ("ISA Extension: ", stdout
);
16940 print_mips_isa_ext (abiflags_in
.isa_ext
);
16941 fputs ("\nASEs:", stdout
);
16942 print_mips_ases (abiflags_in
.ases
);
16943 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
16944 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
16945 fputc ('\n', stdout
);
16946 free (abiflags_ext
);
16951 /* We have a lot of special sections. Thanks SGI! */
16952 if (filedata
->dynamic_section
== NULL
)
16954 /* No dynamic information available. See if there is static GOT. */
16955 sect
= find_section (filedata
, ".got");
16958 unsigned char *data_end
;
16959 unsigned char *data
;
16963 pltgot
= sect
->sh_addr
;
16966 addr_size
= (is_32bit_elf
? 4 : 8);
16967 end
= pltgot
+ sect
->sh_size
;
16969 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
16971 _("Global Offset Table data"));
16972 /* PR 12855: Null data is handled gracefully throughout. */
16973 data_end
= data
+ (end
- pltgot
);
16975 printf (_("\nStatic GOT:\n"));
16976 printf (_(" Canonical gp value: "));
16977 print_vma (ent
+ 0x7ff0, LONG_HEX
);
16980 /* In a dynamic binary GOT[0] is reserved for the dynamic
16981 loader to store the lazy resolver pointer, however in
16982 a static binary it may well have been omitted and GOT
16983 reduced to a table of addresses.
16984 PR 21344: Check for the entry being fully available
16985 before fetching it. */
16987 && data
+ ent
- pltgot
+ addr_size
<= data_end
16988 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
16990 printf (_(" Reserved entries:\n"));
16991 printf (_(" %*s %10s %*s\n"),
16992 addr_size
* 2, _("Address"), _("Access"),
16993 addr_size
* 2, _("Value"));
16994 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16996 if (ent
== (bfd_vma
) -1)
16997 goto sgot_print_fail
;
16999 /* Check for the MSB of GOT[1] being set, identifying a
17000 GNU object. This entry will be used by some runtime
17001 loaders, to store the module pointer. Otherwise this
17002 is an ordinary local entry.
17003 PR 21344: Check for the entry being fully available
17004 before fetching it. */
17006 && data
+ ent
- pltgot
+ addr_size
<= data_end
17007 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17008 >> (addr_size
* 8 - 1)) != 0)
17010 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17012 if (ent
== (bfd_vma
) -1)
17013 goto sgot_print_fail
;
17018 if (data
!= NULL
&& ent
< end
)
17020 printf (_(" Local entries:\n"));
17021 printf (" %*s %10s %*s\n",
17022 addr_size
* 2, _("Address"), _("Access"),
17023 addr_size
* 2, _("Value"));
17026 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17028 if (ent
== (bfd_vma
) -1)
17029 goto sgot_print_fail
;
17040 for (entry
= filedata
->dynamic_section
;
17041 /* PR 17531 file: 012-50589-0.004. */
17042 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
17043 && entry
->d_tag
!= DT_NULL
);
17045 switch (entry
->d_tag
)
17047 case DT_MIPS_LIBLIST
:
17049 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
17050 liblistno
* sizeof (Elf32_External_Lib
));
17052 case DT_MIPS_LIBLISTNO
:
17053 liblistno
= entry
->d_un
.d_val
;
17055 case DT_MIPS_OPTIONS
:
17056 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
17058 case DT_MIPS_CONFLICT
:
17060 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
17061 conflictsno
* sizeof (Elf32_External_Conflict
));
17063 case DT_MIPS_CONFLICTNO
:
17064 conflictsno
= entry
->d_un
.d_val
;
17067 pltgot
= entry
->d_un
.d_ptr
;
17069 case DT_MIPS_LOCAL_GOTNO
:
17070 local_gotno
= entry
->d_un
.d_val
;
17072 case DT_MIPS_GOTSYM
:
17073 gotsym
= entry
->d_un
.d_val
;
17075 case DT_MIPS_SYMTABNO
:
17076 symtabno
= entry
->d_un
.d_val
;
17078 case DT_MIPS_PLTGOT
:
17079 mips_pltgot
= entry
->d_un
.d_ptr
;
17082 pltrel
= entry
->d_un
.d_val
;
17085 pltrelsz
= entry
->d_un
.d_val
;
17088 jmprel
= entry
->d_un
.d_ptr
;
17094 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
17096 Elf32_External_Lib
* elib
;
17099 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
17100 sizeof (Elf32_External_Lib
),
17102 _("liblist section data"));
17105 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
17106 "\nSection '.liblist' contains %lu entries:\n",
17107 (unsigned long) liblistno
),
17108 (unsigned long) liblistno
);
17109 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
17112 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
17119 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17120 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17121 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17122 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17123 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17125 tmp
= gmtime (&atime
);
17126 snprintf (timebuf
, sizeof (timebuf
),
17127 "%04u-%02u-%02uT%02u:%02u:%02u",
17128 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17129 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17131 printf ("%3lu: ", (unsigned long) cnt
);
17132 if (VALID_DYNAMIC_NAME (filedata
, liblist
.l_name
))
17133 print_symbol (20, GET_DYNAMIC_NAME (filedata
, liblist
.l_name
));
17135 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
17136 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
17137 liblist
.l_version
);
17139 if (liblist
.l_flags
== 0)
17143 static const struct
17150 { " EXACT_MATCH", LL_EXACT_MATCH
},
17151 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
17152 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
17153 { " EXPORTS", LL_EXPORTS
},
17154 { " DELAY_LOAD", LL_DELAY_LOAD
},
17155 { " DELTA", LL_DELTA
}
17157 int flags
= liblist
.l_flags
;
17160 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
17161 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
17163 fputs (l_flags_vals
[fcnt
].name
, stdout
);
17164 flags
^= l_flags_vals
[fcnt
].bit
;
17167 printf (" %#x", (unsigned int) flags
);
17179 if (options_offset
!= 0)
17181 Elf_External_Options
* eopt
;
17184 sect
= filedata
->section_headers
;
17186 /* Find the section header so that we get the size. */
17187 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
17188 /* PR 17533 file: 012-277276-0.004. */
17191 error (_("No MIPS_OPTIONS header found\n"));
17195 if (sect
->sh_size
< sizeof (* eopt
))
17197 error (_("The MIPS options section is too small.\n"));
17201 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
17202 sect
->sh_size
, _("options"));
17205 Elf_Internal_Options option
;
17208 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
17210 Elf_External_Options
* eoption
;
17211 unsigned int optsize
;
17213 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
17215 optsize
= BYTE_GET (eoption
->size
);
17217 /* PR 17531: file: ffa0fa3b. */
17218 if (optsize
< sizeof (* eopt
)
17219 || optsize
> sect
->sh_size
- offset
)
17221 error (_("Invalid size (%u) for MIPS option\n"),
17230 printf (ngettext ("\nSection '%s' contains %d entry:\n",
17231 "\nSection '%s' contains %d entries:\n",
17233 printable_section_name (filedata
, sect
), cnt
);
17239 Elf_External_Options
* eoption
;
17241 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
17243 option
.kind
= BYTE_GET (eoption
->kind
);
17244 option
.size
= BYTE_GET (eoption
->size
);
17245 option
.section
= BYTE_GET (eoption
->section
);
17246 option
.info
= BYTE_GET (eoption
->info
);
17248 switch (option
.kind
)
17251 /* This shouldn't happen. */
17252 printf (" NULL %" PRId16
" %" PRIx32
,
17253 option
.section
, option
.info
);
17257 printf (" REGINFO ");
17258 if (filedata
->file_header
.e_machine
== EM_MIPS
)
17260 Elf32_External_RegInfo
* ereg
;
17261 Elf32_RegInfo reginfo
;
17264 if (option
.size
< (sizeof (Elf_External_Options
)
17265 + sizeof (Elf32_External_RegInfo
)))
17267 printf (_("<corrupt>\n"));
17268 error (_("Truncated MIPS REGINFO option\n"));
17273 ereg
= (Elf32_External_RegInfo
*) (eoption
+ 1);
17275 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
17276 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
17277 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
17278 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
17279 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
17280 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
17282 printf ("GPR %08" PRIx32
" GP 0x%" PRIx32
"\n",
17283 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
17285 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
17286 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
17287 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17288 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17293 Elf64_External_RegInfo
* ereg
;
17294 Elf64_Internal_RegInfo reginfo
;
17296 if (option
.size
< (sizeof (Elf_External_Options
)
17297 + sizeof (Elf64_External_RegInfo
)))
17299 printf (_("<corrupt>\n"));
17300 error (_("Truncated MIPS REGINFO option\n"));
17305 ereg
= (Elf64_External_RegInfo
*) (eoption
+ 1);
17306 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
17307 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
17308 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
17309 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
17310 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
17311 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
17313 printf ("GPR %08" PRIx32
" GP 0x%" PRIx64
"\n",
17314 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
17316 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
17317 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
17318 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17319 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17321 offset
+= option
.size
;
17324 case ODK_EXCEPTIONS
:
17325 fputs (" EXCEPTIONS fpe_min(", stdout
);
17326 process_mips_fpe_exception (option
.info
& OEX_FPU_MIN
);
17327 fputs (") fpe_max(", stdout
);
17328 process_mips_fpe_exception ((option
.info
& OEX_FPU_MAX
) >> 8);
17329 fputs (")", stdout
);
17331 if (option
.info
& OEX_PAGE0
)
17332 fputs (" PAGE0", stdout
);
17333 if (option
.info
& OEX_SMM
)
17334 fputs (" SMM", stdout
);
17335 if (option
.info
& OEX_FPDBUG
)
17336 fputs (" FPDBUG", stdout
);
17337 if (option
.info
& OEX_DISMISS
)
17338 fputs (" DISMISS", stdout
);
17342 fputs (" PAD ", stdout
);
17343 if (option
.info
& OPAD_PREFIX
)
17344 fputs (" PREFIX", stdout
);
17345 if (option
.info
& OPAD_POSTFIX
)
17346 fputs (" POSTFIX", stdout
);
17347 if (option
.info
& OPAD_SYMBOL
)
17348 fputs (" SYMBOL", stdout
);
17352 fputs (" HWPATCH ", stdout
);
17353 if (option
.info
& OHW_R4KEOP
)
17354 fputs (" R4KEOP", stdout
);
17355 if (option
.info
& OHW_R8KPFETCH
)
17356 fputs (" R8KPFETCH", stdout
);
17357 if (option
.info
& OHW_R5KEOP
)
17358 fputs (" R5KEOP", stdout
);
17359 if (option
.info
& OHW_R5KCVTL
)
17360 fputs (" R5KCVTL", stdout
);
17364 fputs (" FILL ", stdout
);
17365 /* XXX Print content of info word? */
17369 fputs (" TAGS ", stdout
);
17370 /* XXX Print content of info word? */
17374 fputs (" HWAND ", stdout
);
17375 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
17376 fputs (" R4KEOP_CHECKED", stdout
);
17377 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
17378 fputs (" R4KEOP_CLEAN", stdout
);
17382 fputs (" HWOR ", stdout
);
17383 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
17384 fputs (" R4KEOP_CHECKED", stdout
);
17385 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
17386 fputs (" R4KEOP_CLEAN", stdout
);
17390 printf (" GP_GROUP %#06x self-contained %#06x",
17391 option
.info
& OGP_GROUP
,
17392 (option
.info
& OGP_SELF
) >> 16);
17396 printf (" IDENT %#06x self-contained %#06x",
17397 option
.info
& OGP_GROUP
,
17398 (option
.info
& OGP_SELF
) >> 16);
17402 /* This shouldn't happen. */
17403 printf (" %3d ??? %" PRId16
" %" PRIx32
,
17404 option
.kind
, option
.section
, option
.info
);
17408 len
= sizeof (* eopt
);
17409 while (len
< option
.size
)
17411 unsigned char datum
= *((unsigned char *) eoption
+ len
);
17413 if (ISPRINT (datum
))
17414 printf ("%c", datum
);
17416 printf ("\\%03o", datum
);
17419 fputs ("\n", stdout
);
17421 offset
+= option
.size
;
17429 if (conflicts_offset
!= 0 && conflictsno
!= 0)
17431 Elf32_Conflict
* iconf
;
17434 if (filedata
->dynamic_symbols
== NULL
)
17436 error (_("conflict list found without a dynamic symbol table\n"));
17440 /* PR 21345 - print a slightly more helpful error message
17441 if we are sure that the cmalloc will fail. */
17442 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
17444 error (_("Overlarge number of conflicts detected: %lx\n"),
17445 (long) conflictsno
);
17449 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
17452 error (_("Out of memory allocating space for dynamic conflicts\n"));
17458 Elf32_External_Conflict
* econf32
;
17460 econf32
= (Elf32_External_Conflict
*)
17461 get_data (NULL
, filedata
, conflicts_offset
,
17462 sizeof (*econf32
), conflictsno
, _("conflict"));
17469 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17470 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
17476 Elf64_External_Conflict
* econf64
;
17478 econf64
= (Elf64_External_Conflict
*)
17479 get_data (NULL
, filedata
, conflicts_offset
,
17480 sizeof (*econf64
), conflictsno
, _("conflict"));
17487 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17488 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
17493 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
17494 "\nSection '.conflict' contains %lu entries:\n",
17495 (unsigned long) conflictsno
),
17496 (unsigned long) conflictsno
);
17497 puts (_(" Num: Index Value Name"));
17499 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17501 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
17503 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
17504 printf (_("<corrupt symbol index>"));
17507 Elf_Internal_Sym
* psym
;
17509 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
17510 print_vma (psym
->st_value
, FULL_HEX
);
17512 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17513 print_symbol (25, GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17515 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17523 if (pltgot
!= 0 && local_gotno
!= 0)
17525 bfd_vma ent
, local_end
, global_end
;
17527 unsigned char * data
;
17528 unsigned char * data_end
;
17532 addr_size
= (is_32bit_elf
? 4 : 8);
17533 local_end
= pltgot
+ local_gotno
* addr_size
;
17535 /* PR binutils/17533 file: 012-111227-0.004 */
17536 if (symtabno
< gotsym
)
17538 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17539 (unsigned long) gotsym
, (unsigned long) symtabno
);
17543 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
17544 /* PR 17531: file: 54c91a34. */
17545 if (global_end
< local_end
)
17547 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
17551 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
17552 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
17553 global_end
- pltgot
, 1,
17554 _("Global Offset Table data"));
17555 /* PR 12855: Null data is handled gracefully throughout. */
17556 data_end
= data
+ (global_end
- pltgot
);
17558 printf (_("\nPrimary GOT:\n"));
17559 printf (_(" Canonical gp value: "));
17560 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
17563 printf (_(" Reserved entries:\n"));
17564 printf (_(" %*s %10s %*s Purpose\n"),
17565 addr_size
* 2, _("Address"), _("Access"),
17566 addr_size
* 2, _("Initial"));
17567 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17568 printf (_(" Lazy resolver\n"));
17569 if (ent
== (bfd_vma
) -1)
17570 goto got_print_fail
;
17572 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17573 This entry will be used by some runtime loaders, to store the
17574 module pointer. Otherwise this is an ordinary local entry.
17575 PR 21344: Check for the entry being fully available before
17578 && data
+ ent
- pltgot
+ addr_size
<= data_end
17579 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17580 >> (addr_size
* 8 - 1)) != 0)
17582 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17583 printf (_(" Module pointer (GNU extension)\n"));
17584 if (ent
== (bfd_vma
) -1)
17585 goto got_print_fail
;
17589 if (data
!= NULL
&& ent
< local_end
)
17591 printf (_(" Local entries:\n"));
17592 printf (" %*s %10s %*s\n",
17593 addr_size
* 2, _("Address"), _("Access"),
17594 addr_size
* 2, _("Initial"));
17595 while (ent
< local_end
)
17597 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17599 if (ent
== (bfd_vma
) -1)
17600 goto got_print_fail
;
17605 if (data
!= NULL
&& gotsym
< symtabno
)
17609 printf (_(" Global entries:\n"));
17610 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17611 addr_size
* 2, _("Address"),
17613 addr_size
* 2, _("Initial"),
17614 addr_size
* 2, _("Sym.Val."),
17616 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17617 _("Ndx"), _("Name"));
17619 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
17621 for (i
= gotsym
; i
< symtabno
; i
++)
17623 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17626 if (filedata
->dynamic_symbols
== NULL
)
17627 printf (_("<no dynamic symbols>"));
17628 else if (i
< filedata
->num_dynamic_syms
)
17630 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
17632 print_vma (psym
->st_value
, LONG_HEX
);
17633 printf (" %-7s %3s ",
17634 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17635 get_symbol_index_type (filedata
, psym
->st_shndx
));
17637 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17638 print_symbol (sym_width
,
17639 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17641 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17644 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17645 (unsigned long) i
);
17648 if (ent
== (bfd_vma
) -1)
17658 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
17661 size_t offset
, rel_offset
;
17662 unsigned long count
, i
;
17663 unsigned char * data
;
17664 int addr_size
, sym_width
;
17665 Elf_Internal_Rela
* rels
;
17667 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
17668 if (pltrel
== DT_RELA
)
17670 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17675 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17680 addr_size
= (is_32bit_elf
? 4 : 8);
17681 end
= mips_pltgot
+ (2 + count
) * addr_size
;
17683 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
17684 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
17685 1, _("Procedure Linkage Table data"));
17689 printf ("\nPLT GOT:\n\n");
17690 printf (_(" Reserved entries:\n"));
17691 printf (_(" %*s %*s Purpose\n"),
17692 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
17693 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17694 printf (_(" PLT lazy resolver\n"));
17695 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17696 printf (_(" Module pointer\n"));
17699 printf (_(" Entries:\n"));
17700 printf (" %*s %*s %*s %-7s %3s %s\n",
17701 addr_size
* 2, _("Address"),
17702 addr_size
* 2, _("Initial"),
17703 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17704 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
17705 for (i
= 0; i
< count
; i
++)
17707 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
17709 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17712 if (idx
>= filedata
->num_dynamic_syms
)
17713 printf (_("<corrupt symbol index: %lu>"), idx
);
17716 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
17718 print_vma (psym
->st_value
, LONG_HEX
);
17719 printf (" %-7s %3s ",
17720 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17721 get_symbol_index_type (filedata
, psym
->st_shndx
));
17722 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17723 print_symbol (sym_width
,
17724 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17726 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17740 process_nds32_specific (Filedata
* filedata
)
17742 Elf_Internal_Shdr
*sect
= NULL
;
17744 sect
= find_section (filedata
, ".nds32_e_flags");
17745 if (sect
!= NULL
&& sect
->sh_size
>= 4)
17747 unsigned char *buf
;
17750 printf ("\nNDS32 elf flags section:\n");
17751 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
17752 _("NDS32 elf flags section"));
17757 flag
= byte_get (buf
, 4);
17759 switch (flag
& 0x3)
17762 printf ("(VEC_SIZE):\tNo entry.\n");
17765 printf ("(VEC_SIZE):\t4 bytes\n");
17768 printf ("(VEC_SIZE):\t16 bytes\n");
17771 printf ("(VEC_SIZE):\treserved\n");
17780 process_gnu_liblist (Filedata
* filedata
)
17782 Elf_Internal_Shdr
* section
;
17783 Elf_Internal_Shdr
* string_sec
;
17784 Elf32_External_Lib
* elib
;
17786 size_t strtab_size
;
17788 unsigned long num_liblist
;
17790 bfd_boolean res
= TRUE
;
17795 for (i
= 0, section
= filedata
->section_headers
;
17796 i
< filedata
->file_header
.e_shnum
;
17799 switch (section
->sh_type
)
17801 case SHT_GNU_LIBLIST
:
17802 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
17805 elib
= (Elf32_External_Lib
*)
17806 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
17807 _("liblist section data"));
17815 string_sec
= filedata
->section_headers
+ section
->sh_link
;
17816 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
17817 string_sec
->sh_size
,
17818 _("liblist string table"));
17820 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
17827 strtab_size
= string_sec
->sh_size
;
17829 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
17830 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17831 "\nLibrary list section '%s' contains %lu entries:\n",
17833 printable_section_name (filedata
, section
),
17836 puts (_(" Library Time Stamp Checksum Version Flags"));
17838 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
17846 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17847 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17848 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17849 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17850 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17852 tmp
= gmtime (&atime
);
17853 snprintf (timebuf
, sizeof (timebuf
),
17854 "%04u-%02u-%02uT%02u:%02u:%02u",
17855 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17856 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17858 printf ("%3lu: ", (unsigned long) cnt
);
17860 printf ("%-20s", liblist
.l_name
< strtab_size
17861 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17863 printf ("%-20.20s", liblist
.l_name
< strtab_size
17864 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17865 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
17866 liblist
.l_version
, liblist
.l_flags
);
17877 static const char *
17878 get_note_type (Filedata
* filedata
, unsigned e_type
)
17880 static char buff
[64];
17882 if (filedata
->file_header
.e_type
== ET_CORE
)
17886 return _("NT_AUXV (auxiliary vector)");
17888 return _("NT_PRSTATUS (prstatus structure)");
17890 return _("NT_FPREGSET (floating point registers)");
17892 return _("NT_PRPSINFO (prpsinfo structure)");
17893 case NT_TASKSTRUCT
:
17894 return _("NT_TASKSTRUCT (task structure)");
17896 return _("NT_PRXFPREG (user_xfpregs structure)");
17898 return _("NT_PPC_VMX (ppc Altivec registers)");
17900 return _("NT_PPC_VSX (ppc VSX registers)");
17902 return _("NT_PPC_TAR (ppc TAR register)");
17904 return _("NT_PPC_PPR (ppc PPR register)");
17906 return _("NT_PPC_DSCR (ppc DSCR register)");
17908 return _("NT_PPC_EBB (ppc EBB registers)");
17910 return _("NT_PPC_PMU (ppc PMU registers)");
17911 case NT_PPC_TM_CGPR
:
17912 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17913 case NT_PPC_TM_CFPR
:
17914 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17915 case NT_PPC_TM_CVMX
:
17916 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17917 case NT_PPC_TM_CVSX
:
17918 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17919 case NT_PPC_TM_SPR
:
17920 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17921 case NT_PPC_TM_CTAR
:
17922 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17923 case NT_PPC_TM_CPPR
:
17924 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17925 case NT_PPC_TM_CDSCR
:
17926 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17928 return _("NT_386_TLS (x86 TLS information)");
17929 case NT_386_IOPERM
:
17930 return _("NT_386_IOPERM (x86 I/O permissions)");
17931 case NT_X86_XSTATE
:
17932 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17933 case NT_S390_HIGH_GPRS
:
17934 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17935 case NT_S390_TIMER
:
17936 return _("NT_S390_TIMER (s390 timer register)");
17937 case NT_S390_TODCMP
:
17938 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17939 case NT_S390_TODPREG
:
17940 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17942 return _("NT_S390_CTRS (s390 control registers)");
17943 case NT_S390_PREFIX
:
17944 return _("NT_S390_PREFIX (s390 prefix register)");
17945 case NT_S390_LAST_BREAK
:
17946 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17947 case NT_S390_SYSTEM_CALL
:
17948 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17950 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17951 case NT_S390_VXRS_LOW
:
17952 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17953 case NT_S390_VXRS_HIGH
:
17954 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17955 case NT_S390_GS_CB
:
17956 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17957 case NT_S390_GS_BC
:
17958 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17960 return _("NT_ARM_VFP (arm VFP registers)");
17962 return _("NT_ARM_TLS (AArch TLS registers)");
17963 case NT_ARM_HW_BREAK
:
17964 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17965 case NT_ARM_HW_WATCH
:
17966 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17968 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
17970 return _("NT_PSTATUS (pstatus structure)");
17972 return _("NT_FPREGS (floating point registers)");
17974 return _("NT_PSINFO (psinfo structure)");
17976 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17978 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17979 case NT_WIN32PSTATUS
:
17980 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17982 return _("NT_SIGINFO (siginfo_t data)");
17984 return _("NT_FILE (mapped files)");
17992 return _("NT_VERSION (version)");
17994 return _("NT_ARCH (architecture)");
17995 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17997 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
18003 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18008 print_core_note (Elf_Internal_Note
*pnote
)
18010 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
18011 bfd_vma count
, page_size
;
18012 unsigned char *descdata
, *filenames
, *descend
;
18014 if (pnote
->type
!= NT_FILE
)
18024 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
18025 /* Still "successful". */
18030 if (pnote
->descsz
< 2 * addr_size
)
18032 error (_(" Malformed note - too short for header\n"));
18036 descdata
= (unsigned char *) pnote
->descdata
;
18037 descend
= descdata
+ pnote
->descsz
;
18039 if (descdata
[pnote
->descsz
- 1] != '\0')
18041 error (_(" Malformed note - does not end with \\0\n"));
18045 count
= byte_get (descdata
, addr_size
);
18046 descdata
+= addr_size
;
18048 page_size
= byte_get (descdata
, addr_size
);
18049 descdata
+= addr_size
;
18051 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
18052 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
18054 error (_(" Malformed note - too short for supplied file count\n"));
18058 printf (_(" Page size: "));
18059 print_vma (page_size
, DEC
);
18062 printf (_(" %*s%*s%*s\n"),
18063 (int) (2 + 2 * addr_size
), _("Start"),
18064 (int) (4 + 2 * addr_size
), _("End"),
18065 (int) (4 + 2 * addr_size
), _("Page Offset"));
18066 filenames
= descdata
+ count
* 3 * addr_size
;
18067 while (count
-- > 0)
18069 bfd_vma start
, end
, file_ofs
;
18071 if (filenames
== descend
)
18073 error (_(" Malformed note - filenames end too early\n"));
18077 start
= byte_get (descdata
, addr_size
);
18078 descdata
+= addr_size
;
18079 end
= byte_get (descdata
, addr_size
);
18080 descdata
+= addr_size
;
18081 file_ofs
= byte_get (descdata
, addr_size
);
18082 descdata
+= addr_size
;
18085 print_vma (start
, FULL_HEX
);
18087 print_vma (end
, FULL_HEX
);
18089 print_vma (file_ofs
, FULL_HEX
);
18090 printf ("\n %s\n", filenames
);
18092 filenames
+= 1 + strlen ((char *) filenames
);
18098 static const char *
18099 get_gnu_elf_note_type (unsigned e_type
)
18101 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
18104 case NT_GNU_ABI_TAG
:
18105 return _("NT_GNU_ABI_TAG (ABI version tag)");
18107 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
18108 case NT_GNU_BUILD_ID
:
18109 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
18110 case NT_GNU_GOLD_VERSION
:
18111 return _("NT_GNU_GOLD_VERSION (gold version)");
18112 case NT_GNU_PROPERTY_TYPE_0
:
18113 return _("NT_GNU_PROPERTY_TYPE_0");
18114 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
18115 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
18116 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
18117 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
18120 static char buff
[64];
18122 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18129 decode_x86_compat_isa (unsigned int bitmask
)
18133 unsigned int bit
= bitmask
& (- bitmask
);
18138 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
18141 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
18144 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
18147 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
18150 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
18153 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
18156 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
18159 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
18162 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
18165 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
18168 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
18171 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
18172 printf ("AVX512F");
18174 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
18175 printf ("AVX512CD");
18177 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
18178 printf ("AVX512ER");
18180 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
18181 printf ("AVX512PF");
18183 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
18184 printf ("AVX512VL");
18186 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
18187 printf ("AVX512DQ");
18189 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
18190 printf ("AVX512BW");
18193 printf (_("<unknown: %x>"), bit
);
18202 decode_x86_isa (unsigned int bitmask
)
18206 printf (_("<None>"));
18212 unsigned int bit
= bitmask
& (- bitmask
);
18217 case GNU_PROPERTY_X86_ISA_1_CMOV
:
18220 case GNU_PROPERTY_X86_ISA_1_SSE
:
18223 case GNU_PROPERTY_X86_ISA_1_SSE2
:
18226 case GNU_PROPERTY_X86_ISA_1_SSE3
:
18229 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
18232 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
18235 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
18238 case GNU_PROPERTY_X86_ISA_1_AVX
:
18241 case GNU_PROPERTY_X86_ISA_1_AVX2
:
18244 case GNU_PROPERTY_X86_ISA_1_FMA
:
18247 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
18248 printf ("AVX512F");
18250 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
18251 printf ("AVX512CD");
18253 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
18254 printf ("AVX512ER");
18256 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
18257 printf ("AVX512PF");
18259 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
18260 printf ("AVX512VL");
18262 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
18263 printf ("AVX512DQ");
18265 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
18266 printf ("AVX512BW");
18268 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
18269 printf ("AVX512_4FMAPS");
18271 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
18272 printf ("AVX512_4VNNIW");
18274 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
18275 printf ("AVX512_BITALG");
18277 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
18278 printf ("AVX512_IFMA");
18280 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
18281 printf ("AVX512_VBMI");
18283 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
18284 printf ("AVX512_VBMI2");
18286 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
18287 printf ("AVX512_VNNI");
18289 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16
:
18290 printf ("AVX512_BF16");
18293 printf (_("<unknown: %x>"), bit
);
18302 decode_x86_feature_1 (unsigned int bitmask
)
18306 printf (_("<None>"));
18312 unsigned int bit
= bitmask
& (- bitmask
);
18317 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
18320 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
18324 printf (_("<unknown: %x>"), bit
);
18333 decode_x86_feature_2 (unsigned int bitmask
)
18337 printf (_("<None>"));
18343 unsigned int bit
= bitmask
& (- bitmask
);
18348 case GNU_PROPERTY_X86_FEATURE_2_X86
:
18351 case GNU_PROPERTY_X86_FEATURE_2_X87
:
18354 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
18357 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
18360 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
18363 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
18366 case GNU_PROPERTY_X86_FEATURE_2_TMM
:
18369 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
18372 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
18375 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
18376 printf ("XSAVEOPT");
18378 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
18382 printf (_("<unknown: %x>"), bit
);
18391 decode_aarch64_feature_1_and (unsigned int bitmask
)
18395 unsigned int bit
= bitmask
& (- bitmask
);
18400 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
18404 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
18409 printf (_("<unknown: %x>"), bit
);
18418 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
18420 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
18421 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
18422 unsigned int size
= is_32bit_elf
? 4 : 8;
18424 printf (_(" Properties: "));
18426 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
18428 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
18432 while (ptr
< ptr_end
)
18436 unsigned int datasz
;
18438 if ((size_t) (ptr_end
- ptr
) < 8)
18440 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
18444 type
= byte_get (ptr
, 4);
18445 datasz
= byte_get (ptr
+ 4, 4);
18449 if (datasz
> (size_t) (ptr_end
- ptr
))
18451 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
18456 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
18458 if (filedata
->file_header
.e_machine
== EM_X86_64
18459 || filedata
->file_header
.e_machine
== EM_IAMCU
18460 || filedata
->file_header
.e_machine
== EM_386
)
18462 unsigned int bitmask
;
18465 bitmask
= byte_get (ptr
, 4);
18471 case GNU_PROPERTY_X86_ISA_1_USED
:
18473 printf (_("x86 ISA used: <corrupt length: %#x> "),
18477 printf ("x86 ISA used: ");
18478 decode_x86_isa (bitmask
);
18482 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
18484 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18488 printf ("x86 ISA needed: ");
18489 decode_x86_isa (bitmask
);
18493 case GNU_PROPERTY_X86_FEATURE_1_AND
:
18495 printf (_("x86 feature: <corrupt length: %#x> "),
18499 printf ("x86 feature: ");
18500 decode_x86_feature_1 (bitmask
);
18504 case GNU_PROPERTY_X86_FEATURE_2_USED
:
18506 printf (_("x86 feature used: <corrupt length: %#x> "),
18510 printf ("x86 feature used: ");
18511 decode_x86_feature_2 (bitmask
);
18515 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
18517 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
18520 printf ("x86 feature needed: ");
18521 decode_x86_feature_2 (bitmask
);
18525 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
18527 printf (_("x86 ISA used: <corrupt length: %#x> "),
18531 printf ("x86 ISA used: ");
18532 decode_x86_compat_isa (bitmask
);
18536 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
18538 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18542 printf ("x86 ISA needed: ");
18543 decode_x86_compat_isa (bitmask
);
18551 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
18553 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
18555 printf ("AArch64 feature: ");
18557 printf (_("<corrupt length: %#x> "), datasz
);
18559 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
18568 case GNU_PROPERTY_STACK_SIZE
:
18569 printf (_("stack size: "));
18570 if (datasz
!= size
)
18571 printf (_("<corrupt length: %#x> "), datasz
);
18573 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
18576 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
18577 printf ("no copy on protected ");
18579 printf (_("<corrupt length: %#x> "), datasz
);
18587 if (type
< GNU_PROPERTY_LOPROC
)
18588 printf (_("<unknown type %#x data: "), type
);
18589 else if (type
< GNU_PROPERTY_LOUSER
)
18590 printf (_("<procesor-specific type %#x data: "), type
);
18592 printf (_("<application-specific type %#x data: "), type
);
18593 for (j
= 0; j
< datasz
; ++j
)
18594 printf ("%02x ", ptr
[j
] & 0xff);
18598 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
18599 if (ptr
== ptr_end
)
18612 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
18614 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18615 switch (pnote
->type
)
18617 case NT_GNU_BUILD_ID
:
18621 printf (_(" Build ID: "));
18622 for (i
= 0; i
< pnote
->descsz
; ++i
)
18623 printf ("%02x", pnote
->descdata
[i
] & 0xff);
18628 case NT_GNU_ABI_TAG
:
18630 unsigned long os
, major
, minor
, subminor
;
18631 const char *osname
;
18633 /* PR 17531: file: 030-599401-0.004. */
18634 if (pnote
->descsz
< 16)
18636 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18640 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18641 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18642 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
18643 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
18647 case GNU_ABI_TAG_LINUX
:
18650 case GNU_ABI_TAG_HURD
:
18653 case GNU_ABI_TAG_SOLARIS
:
18654 osname
= "Solaris";
18656 case GNU_ABI_TAG_FREEBSD
:
18657 osname
= "FreeBSD";
18659 case GNU_ABI_TAG_NETBSD
:
18662 case GNU_ABI_TAG_SYLLABLE
:
18663 osname
= "Syllable";
18665 case GNU_ABI_TAG_NACL
:
18669 osname
= "Unknown";
18673 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
18674 major
, minor
, subminor
);
18678 case NT_GNU_GOLD_VERSION
:
18682 printf (_(" Version: "));
18683 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
18684 printf ("%c", pnote
->descdata
[i
]);
18691 unsigned long num_entries
, mask
;
18693 /* Hardware capabilities information. Word 0 is the number of entries.
18694 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18695 is a series of entries, where each entry is a single byte followed
18696 by a nul terminated string. The byte gives the bit number to test
18697 if enabled in the bitmask. */
18698 printf (_(" Hardware Capabilities: "));
18699 if (pnote
->descsz
< 8)
18701 error (_("<corrupt GNU_HWCAP>\n"));
18704 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18705 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18706 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
18707 /* FIXME: Add code to display the entries... */
18711 case NT_GNU_PROPERTY_TYPE_0
:
18712 print_gnu_property_note (filedata
, pnote
);
18716 /* Handle unrecognised types. An error message should have already been
18717 created by get_gnu_elf_note_type(), so all that we need to do is to
18718 display the data. */
18722 printf (_(" Description data: "));
18723 for (i
= 0; i
< pnote
->descsz
; ++i
)
18724 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
18733 static const char *
18734 get_v850_elf_note_type (enum v850_notes n_type
)
18736 static char buff
[64];
18740 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
18741 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
18742 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
18743 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
18744 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
18745 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
18747 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
18753 print_v850_note (Elf_Internal_Note
* pnote
)
18757 if (pnote
->descsz
!= 4)
18760 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
18764 printf (_("not set\n"));
18768 switch (pnote
->type
)
18770 case V850_NOTE_ALIGNMENT
:
18773 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
18774 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
18778 case V850_NOTE_DATA_SIZE
:
18781 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
18782 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
18786 case V850_NOTE_FPU_INFO
:
18789 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
18790 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
18794 case V850_NOTE_MMU_INFO
:
18795 case V850_NOTE_CACHE_INFO
:
18796 case V850_NOTE_SIMD_INFO
:
18797 if (val
== EF_RH850_SIMD
)
18799 printf (_("yes\n"));
18805 /* An 'unknown note type' message will already have been displayed. */
18809 printf (_("unknown value: %x\n"), val
);
18814 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
18816 unsigned int version
;
18818 switch (pnote
->type
)
18820 case NT_NETBSD_IDENT
:
18821 if (pnote
->descsz
< 1)
18823 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18824 if ((version
/ 10000) % 100)
18825 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
18826 version
, version
/ 100000000, (version
/ 1000000) % 100,
18827 (version
/ 10000) % 100 > 26 ? "Z" : "",
18828 'A' + (version
/ 10000) % 26);
18830 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
18831 version
, version
/ 100000000, (version
/ 1000000) % 100,
18832 (version
/ 100) % 100);
18835 case NT_NETBSD_MARCH
:
18836 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
18840 #ifdef NT_NETBSD_PAX
18841 case NT_NETBSD_PAX
:
18842 if (pnote
->descsz
< 1)
18844 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18845 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
18846 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
18847 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
18848 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
18849 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
18850 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
18851 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
18856 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
18857 pnote
->descsz
, pnote
->type
);
18861 static const char *
18862 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18866 case NT_FREEBSD_THRMISC
:
18867 return _("NT_THRMISC (thrmisc structure)");
18868 case NT_FREEBSD_PROCSTAT_PROC
:
18869 return _("NT_PROCSTAT_PROC (proc data)");
18870 case NT_FREEBSD_PROCSTAT_FILES
:
18871 return _("NT_PROCSTAT_FILES (files data)");
18872 case NT_FREEBSD_PROCSTAT_VMMAP
:
18873 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18874 case NT_FREEBSD_PROCSTAT_GROUPS
:
18875 return _("NT_PROCSTAT_GROUPS (groups data)");
18876 case NT_FREEBSD_PROCSTAT_UMASK
:
18877 return _("NT_PROCSTAT_UMASK (umask data)");
18878 case NT_FREEBSD_PROCSTAT_RLIMIT
:
18879 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18880 case NT_FREEBSD_PROCSTAT_OSREL
:
18881 return _("NT_PROCSTAT_OSREL (osreldate data)");
18882 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
18883 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18884 case NT_FREEBSD_PROCSTAT_AUXV
:
18885 return _("NT_PROCSTAT_AUXV (auxv data)");
18886 case NT_FREEBSD_PTLWPINFO
:
18887 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18889 return get_note_type (filedata
, e_type
);
18892 static const char *
18893 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18895 static char buff
[64];
18899 case NT_NETBSDCORE_PROCINFO
:
18900 /* NetBSD core "procinfo" structure. */
18901 return _("NetBSD procinfo structure");
18903 #ifdef NT_NETBSDCORE_AUXV
18904 case NT_NETBSDCORE_AUXV
:
18905 return _("NetBSD ELF auxiliary vector data");
18908 #ifdef NT_NETBSDCORE_LWPSTATUS
18909 case NT_NETBSDCORE_LWPSTATUS
:
18910 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
18914 /* As of Jan 2020 there are no other machine-independent notes
18915 defined for NetBSD core files. If the note type is less
18916 than the start of the machine-dependent note types, we don't
18919 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
18921 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18927 switch (filedata
->file_header
.e_machine
)
18929 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18930 and PT_GETFPREGS == mach+2. */
18935 case EM_SPARC32PLUS
:
18939 case NT_NETBSDCORE_FIRSTMACH
+ 0:
18940 return _("PT_GETREGS (reg structure)");
18941 case NT_NETBSDCORE_FIRSTMACH
+ 2:
18942 return _("PT_GETFPREGS (fpreg structure)");
18948 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18949 There's also old PT___GETREGS40 == mach + 1 for old reg
18950 structure which lacks GBR. */
18954 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18955 return _("PT___GETREGS40 (old reg structure)");
18956 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18957 return _("PT_GETREGS (reg structure)");
18958 case NT_NETBSDCORE_FIRSTMACH
+ 5:
18959 return _("PT_GETFPREGS (fpreg structure)");
18965 /* On all other arch's, PT_GETREGS == mach+1 and
18966 PT_GETFPREGS == mach+3. */
18970 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18971 return _("PT_GETREGS (reg structure)");
18972 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18973 return _("PT_GETFPREGS (fpreg structure)");
18979 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
18980 e_type
- NT_NETBSDCORE_FIRSTMACH
);
18984 static const char *
18985 get_stapsdt_note_type (unsigned e_type
)
18987 static char buff
[64];
18992 return _("NT_STAPSDT (SystemTap probe descriptors)");
18998 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19003 print_stapsdt_note (Elf_Internal_Note
*pnote
)
19005 size_t len
, maxlen
;
19006 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
19007 char *data
= pnote
->descdata
;
19008 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
19009 bfd_vma pc
, base_addr
, semaphore
;
19010 char *provider
, *probe
, *arg_fmt
;
19012 if (pnote
->descsz
< (addr_size
* 3))
19013 goto stapdt_note_too_small
;
19015 pc
= byte_get ((unsigned char *) data
, addr_size
);
19018 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
19021 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
19024 if (data
>= data_end
)
19025 goto stapdt_note_too_small
;
19026 maxlen
= data_end
- data
;
19027 len
= strnlen (data
, maxlen
);
19034 goto stapdt_note_too_small
;
19036 if (data
>= data_end
)
19037 goto stapdt_note_too_small
;
19038 maxlen
= data_end
- data
;
19039 len
= strnlen (data
, maxlen
);
19046 goto stapdt_note_too_small
;
19048 if (data
>= data_end
)
19049 goto stapdt_note_too_small
;
19050 maxlen
= data_end
- data
;
19051 len
= strnlen (data
, maxlen
);
19058 goto stapdt_note_too_small
;
19060 printf (_(" Provider: %s\n"), provider
);
19061 printf (_(" Name: %s\n"), probe
);
19062 printf (_(" Location: "));
19063 print_vma (pc
, FULL_HEX
);
19064 printf (_(", Base: "));
19065 print_vma (base_addr
, FULL_HEX
);
19066 printf (_(", Semaphore: "));
19067 print_vma (semaphore
, FULL_HEX
);
19069 printf (_(" Arguments: %s\n"), arg_fmt
);
19071 return data
== data_end
;
19073 stapdt_note_too_small
:
19074 printf (_(" <corrupt - note is too small>\n"));
19075 error (_("corrupt stapdt note - the data size is too small\n"));
19079 static const char *
19080 get_ia64_vms_note_type (unsigned e_type
)
19082 static char buff
[64];
19087 return _("NT_VMS_MHD (module header)");
19089 return _("NT_VMS_LNM (language name)");
19091 return _("NT_VMS_SRC (source files)");
19093 return "NT_VMS_TITLE";
19095 return _("NT_VMS_EIDC (consistency check)");
19096 case NT_VMS_FPMODE
:
19097 return _("NT_VMS_FPMODE (FP mode)");
19098 case NT_VMS_LINKTIME
:
19099 return "NT_VMS_LINKTIME";
19100 case NT_VMS_IMGNAM
:
19101 return _("NT_VMS_IMGNAM (image name)");
19103 return _("NT_VMS_IMGID (image id)");
19104 case NT_VMS_LINKID
:
19105 return _("NT_VMS_LINKID (link id)");
19106 case NT_VMS_IMGBID
:
19107 return _("NT_VMS_IMGBID (build id)");
19108 case NT_VMS_GSTNAM
:
19109 return _("NT_VMS_GSTNAM (sym table name)");
19110 case NT_VMS_ORIG_DYN
:
19111 return "NT_VMS_ORIG_DYN";
19112 case NT_VMS_PATCHTIME
:
19113 return "NT_VMS_PATCHTIME";
19115 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19121 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
19123 int maxlen
= pnote
->descsz
;
19125 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
19126 goto desc_size_fail
;
19128 switch (pnote
->type
)
19132 goto desc_size_fail
;
19134 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
19136 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
19137 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
19138 if (l
+ 34 < maxlen
)
19140 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
19141 if (l
+ 35 < maxlen
)
19142 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
19144 printf (_(" Module version : <missing>\n"));
19148 printf (_(" Module name : <missing>\n"));
19149 printf (_(" Module version : <missing>\n"));
19154 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
19158 case NT_VMS_FPMODE
:
19159 printf (_(" Floating Point mode: "));
19161 goto desc_size_fail
;
19162 /* FIXME: Generate an error if descsz > 8 ? */
19164 printf ("0x%016" BFD_VMA_FMT
"x\n",
19165 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19168 case NT_VMS_LINKTIME
:
19169 printf (_(" Link time: "));
19171 goto desc_size_fail
;
19172 /* FIXME: Generate an error if descsz > 8 ? */
19175 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19179 case NT_VMS_PATCHTIME
:
19180 printf (_(" Patch time: "));
19182 goto desc_size_fail
;
19183 /* FIXME: Generate an error if descsz > 8 ? */
19186 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19190 case NT_VMS_ORIG_DYN
:
19192 goto desc_size_fail
;
19194 printf (_(" Major id: %u, minor id: %u\n"),
19195 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
19196 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
19197 printf (_(" Last modified : "));
19199 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
19200 printf (_("\n Link flags : "));
19201 printf ("0x%016" BFD_VMA_FMT
"x\n",
19202 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
19203 printf (_(" Header flags: 0x%08x\n"),
19204 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
19205 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
19209 case NT_VMS_IMGNAM
:
19210 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
19213 case NT_VMS_GSTNAM
:
19214 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
19218 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
19221 case NT_VMS_LINKID
:
19222 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
19232 printf (_(" <corrupt - data size is too small>\n"));
19233 error (_("corrupt IA64 note: data size is too small\n"));
19237 struct build_attr_cache
{
19238 Filedata
*filedata
;
19240 unsigned long strtablen
;
19241 Elf_Internal_Sym
*symtab
;
19242 unsigned long nsyms
;
19245 /* Find the symbol associated with a build attribute that is attached
19246 to address OFFSET. If PNAME is non-NULL then store the name of
19247 the symbol (if found) in the provided pointer, Returns NULL if a
19248 symbol could not be found. */
19250 static Elf_Internal_Sym
*
19251 get_symbol_for_build_attribute (Filedata
* filedata
,
19252 unsigned long offset
,
19253 bfd_boolean is_open_attr
,
19254 const char ** pname
)
19256 Elf_Internal_Sym
*saved_sym
= NULL
;
19257 Elf_Internal_Sym
*sym
;
19259 if (filedata
->section_headers
!= NULL
19260 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
19262 Elf_Internal_Shdr
* symsec
;
19264 free (ba_cache
.strtab
);
19265 ba_cache
.strtab
= NULL
;
19266 free (ba_cache
.symtab
);
19267 ba_cache
.symtab
= NULL
;
19269 /* Load the symbol and string sections. */
19270 for (symsec
= filedata
->section_headers
;
19271 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
19274 if (symsec
->sh_type
== SHT_SYMTAB
19275 && get_symtab (filedata
, symsec
,
19276 &ba_cache
.symtab
, &ba_cache
.nsyms
,
19277 &ba_cache
.strtab
, &ba_cache
.strtablen
))
19280 ba_cache
.filedata
= filedata
;
19283 if (ba_cache
.symtab
== NULL
)
19286 /* Find a symbol whose value matches offset. */
19287 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
19288 if (sym
->st_value
== offset
)
19290 if (sym
->st_name
>= ba_cache
.strtablen
)
19291 /* Huh ? This should not happen. */
19294 if (ba_cache
.strtab
[sym
->st_name
] == 0)
19297 /* The AArch64 and ARM architectures define mapping symbols
19298 (eg $d, $x, $t) which we want to ignore. */
19299 if (ba_cache
.strtab
[sym
->st_name
] == '$'
19300 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
19301 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
19306 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
19307 and FILE or OBJECT symbols over NOTYPE symbols. We skip
19308 FUNC symbols entirely. */
19309 switch (ELF_ST_TYPE (sym
->st_info
))
19316 /* If the symbol has a size associated
19317 with it then we can stop searching. */
19318 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
19323 /* Ignore function symbols. */
19330 switch (ELF_ST_BIND (sym
->st_info
))
19333 if (saved_sym
== NULL
19334 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
19339 if (saved_sym
== NULL
)
19349 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
19357 if (saved_sym
&& pname
)
19358 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
19363 /* Returns true iff addr1 and addr2 are in the same section. */
19366 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
19368 Elf_Internal_Shdr
* a1
;
19369 Elf_Internal_Shdr
* a2
;
19371 a1
= find_section_by_address (filedata
, addr1
);
19372 a2
= find_section_by_address (filedata
, addr2
);
19374 return a1
== a2
&& a1
!= NULL
;
19378 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
19379 Filedata
* filedata
)
19381 static unsigned long global_offset
= 0;
19382 static unsigned long global_end
= 0;
19383 static unsigned long func_offset
= 0;
19384 static unsigned long func_end
= 0;
19386 Elf_Internal_Sym
* sym
;
19388 unsigned long start
;
19390 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
19392 switch (pnote
->descsz
)
19395 /* A zero-length description means that the range of
19396 the previous note of the same type should be used. */
19399 if (global_end
> global_offset
)
19400 printf (_(" Applies to region from %#lx to %#lx\n"),
19401 global_offset
, global_end
);
19403 printf (_(" Applies to region from %#lx\n"), global_offset
);
19407 if (func_end
> func_offset
)
19408 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
19410 printf (_(" Applies to region from %#lx\n"), func_offset
);
19415 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19422 /* FIXME: We should check that version 3+ notes are being used here... */
19423 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19424 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19428 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19434 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19435 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
19439 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
19440 printf (_(" <invalid descsz>"));
19445 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
19446 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
19447 in order to avoid them being confused with the start address of the
19448 first function in the file... */
19449 if (sym
== NULL
&& is_open_attr
)
19450 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
19453 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
19454 end
= start
+ sym
->st_size
;
19458 /* FIXME: Need to properly allow for section alignment.
19459 16 is just the alignment used on x86_64. */
19461 && start
> BFD_ALIGN (global_end
, 16)
19462 /* Build notes are not guaranteed to be organised in order of
19463 increasing address, but we should find the all of the notes
19464 for one section in the same place. */
19465 && same_section (filedata
, start
, global_end
))
19466 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
19467 global_end
+ 1, start
- 1);
19469 printf (_(" Applies to region from %#lx"), start
);
19470 global_offset
= start
;
19474 printf (_(" to %#lx"), end
);
19480 printf (_(" Applies to region from %#lx"), start
);
19481 func_offset
= start
;
19485 printf (_(" to %#lx"), end
);
19491 printf (_(" (%s)"), name
);
19498 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
19500 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
19501 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
19502 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
19504 char name_attribute
;
19505 const char * expected_types
;
19506 const char * name
= pnote
->namedata
;
19510 if (name
== NULL
|| pnote
->namesz
< 2)
19512 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19513 print_symbol (-20, _(" <corrupt name>"));
19522 /* Version 2 of the spec adds a "GA" prefix to the name field. */
19523 if (name
[0] == 'G' && name
[1] == 'A')
19525 if (pnote
->namesz
< 4)
19527 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19528 print_symbol (-20, _(" <corrupt name>"));
19537 switch ((name_type
= * name
))
19539 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19540 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19541 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19542 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19543 printf ("%c", * name
);
19547 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
19548 print_symbol (-20, _("<unknown name type>"));
19555 switch ((name_attribute
= * name
))
19557 case GNU_BUILD_ATTRIBUTE_VERSION
:
19558 text
= _("<version>");
19559 expected_types
= string_expected
;
19562 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19563 text
= _("<stack prot>");
19564 expected_types
= "!+*";
19567 case GNU_BUILD_ATTRIBUTE_RELRO
:
19568 text
= _("<relro>");
19569 expected_types
= bool_expected
;
19572 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
19573 text
= _("<stack size>");
19574 expected_types
= number_expected
;
19577 case GNU_BUILD_ATTRIBUTE_TOOL
:
19578 text
= _("<tool>");
19579 expected_types
= string_expected
;
19582 case GNU_BUILD_ATTRIBUTE_ABI
:
19584 expected_types
= "$*";
19587 case GNU_BUILD_ATTRIBUTE_PIC
:
19589 expected_types
= number_expected
;
19592 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
19593 text
= _("<short enum>");
19594 expected_types
= bool_expected
;
19598 if (ISPRINT (* name
))
19600 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
19602 if (len
> left
&& ! do_wide
)
19604 printf ("%.*s:", len
, name
);
19610 static char tmpbuf
[128];
19612 error (_("unrecognised byte in name field: %d\n"), * name
);
19613 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
19617 expected_types
= "*$!+";
19622 left
-= printf ("%s", text
);
19624 if (strchr (expected_types
, name_type
) == NULL
)
19625 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
19627 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
19629 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19630 (unsigned long) pnote
->namesz
,
19631 (long) (name
- pnote
->namedata
));
19635 if (left
< 1 && ! do_wide
)
19640 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19642 unsigned int bytes
;
19643 unsigned long long val
= 0;
19644 unsigned int shift
= 0;
19645 char * decoded
= NULL
;
19647 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
19649 /* The -1 is because the name field is always 0 terminated, and we
19650 want to be able to ensure that the shift in the while loop below
19651 will not overflow. */
19654 if (bytes
> sizeof (val
))
19656 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19658 bytes
= sizeof (val
);
19660 /* We do not bother to warn if bytes == 0 as this can
19661 happen with some early versions of the gcc plugin. */
19665 unsigned long byte
= (* name
++) & 0xff;
19667 val
|= byte
<< shift
;
19671 switch (name_attribute
)
19673 case GNU_BUILD_ATTRIBUTE_PIC
:
19676 case 0: decoded
= "static"; break;
19677 case 1: decoded
= "pic"; break;
19678 case 2: decoded
= "PIC"; break;
19679 case 3: decoded
= "pie"; break;
19680 case 4: decoded
= "PIE"; break;
19684 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19687 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19688 case 0: decoded
= "off"; break;
19689 case 1: decoded
= "on"; break;
19690 case 2: decoded
= "all"; break;
19691 case 3: decoded
= "strong"; break;
19692 case 4: decoded
= "explicit"; break;
19700 if (decoded
!= NULL
)
19702 print_symbol (-left
, decoded
);
19713 left
-= printf ("0x%llx", val
);
19715 left
-= printf ("0x%-.*llx", left
, val
);
19719 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19720 left
-= print_symbol (- left
, name
);
19722 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19723 left
-= print_symbol (- left
, "true");
19725 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19726 left
-= print_symbol (- left
, "false");
19730 if (do_wide
&& left
> 0)
19731 printf ("%-*s", left
, " ");
19736 /* Note that by the ELF standard, the name field is already null byte
19737 terminated, and namesz includes the terminating null byte.
19738 I.E. the value of namesz for the name "FSF" is 4.
19740 If the value of namesz is zero, there is no name present. */
19743 process_note (Elf_Internal_Note
* pnote
,
19744 Filedata
* filedata
)
19746 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
19749 if (pnote
->namesz
== 0)
19750 /* If there is no note name, then use the default set of
19751 note type strings. */
19752 nt
= get_note_type (filedata
, pnote
->type
);
19754 else if (const_strneq (pnote
->namedata
, "GNU"))
19755 /* GNU-specific object file notes. */
19756 nt
= get_gnu_elf_note_type (pnote
->type
);
19758 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
19759 /* FreeBSD-specific core file notes. */
19760 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
19762 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
19763 /* NetBSD-specific core file notes. */
19764 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
19766 else if (const_strneq (pnote
->namedata
, "NetBSD"))
19767 /* NetBSD-specific core file notes. */
19768 return process_netbsd_elf_note (pnote
);
19770 else if (const_strneq (pnote
->namedata
, "PaX"))
19771 /* NetBSD-specific core file notes. */
19772 return process_netbsd_elf_note (pnote
);
19774 else if (strneq (pnote
->namedata
, "SPU/", 4))
19776 /* SPU-specific core file notes. */
19777 nt
= pnote
->namedata
+ 4;
19781 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19782 /* VMS/ia64-specific file notes. */
19783 nt
= get_ia64_vms_note_type (pnote
->type
);
19785 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19786 nt
= get_stapsdt_note_type (pnote
->type
);
19789 /* Don't recognize this note name; just use the default set of
19790 note type strings. */
19791 nt
= get_note_type (filedata
, pnote
->type
);
19795 if (((const_strneq (pnote
->namedata
, "GA")
19796 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19797 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19798 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19799 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19800 print_gnu_build_attribute_name (pnote
);
19802 print_symbol (-20, name
);
19805 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
19807 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
19809 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19810 return print_ia64_vms_note (pnote
);
19811 else if (const_strneq (pnote
->namedata
, "GNU"))
19812 return print_gnu_note (filedata
, pnote
);
19813 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19814 return print_stapsdt_note (pnote
);
19815 else if (const_strneq (pnote
->namedata
, "CORE"))
19816 return print_core_note (pnote
);
19817 else if (((const_strneq (pnote
->namedata
, "GA")
19818 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19819 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19820 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19821 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19822 return print_gnu_build_attribute_description (pnote
, filedata
);
19828 printf (_(" description data: "));
19829 for (i
= 0; i
< pnote
->descsz
; i
++)
19830 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19842 process_notes_at (Filedata
* filedata
,
19843 Elf_Internal_Shdr
* section
,
19848 Elf_External_Note
* pnotes
;
19849 Elf_External_Note
* external
;
19851 bfd_boolean res
= TRUE
;
19858 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
19861 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
19869 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19872 if (pnotes
== NULL
)
19878 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
19880 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19881 (unsigned long) offset
, (unsigned long) length
);
19883 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19884 specifies that notes should be aligned to 4 bytes in 32-bit
19885 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19886 we also support 4 byte alignment in 64-bit objects. If section
19887 alignment is less than 4, we treate alignment as 4 bytes. */
19890 else if (align
!= 4 && align
!= 8)
19892 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19898 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19900 end
= (char *) pnotes
+ length
;
19901 while ((char *) external
< end
)
19903 Elf_Internal_Note inote
;
19906 char * temp
= NULL
;
19907 size_t data_remaining
= end
- (char *) external
;
19909 if (!is_ia64_vms (filedata
))
19911 /* PR binutils/15191
19912 Make sure that there is enough data to read. */
19913 min_notesz
= offsetof (Elf_External_Note
, name
);
19914 if (data_remaining
< min_notesz
)
19916 warn (ngettext ("Corrupt note: only %ld byte remains, "
19917 "not enough for a full note\n",
19918 "Corrupt note: only %ld bytes remain, "
19919 "not enough for a full note\n",
19921 (long) data_remaining
);
19924 data_remaining
-= min_notesz
;
19926 inote
.type
= BYTE_GET (external
->type
);
19927 inote
.namesz
= BYTE_GET (external
->namesz
);
19928 inote
.namedata
= external
->name
;
19929 inote
.descsz
= BYTE_GET (external
->descsz
);
19930 inote
.descdata
= ((char *) external
19931 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
19932 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19933 next
= ((char *) external
19934 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
19938 Elf64_External_VMS_Note
*vms_external
;
19940 /* PR binutils/15191
19941 Make sure that there is enough data to read. */
19942 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
19943 if (data_remaining
< min_notesz
)
19945 warn (ngettext ("Corrupt note: only %ld byte remains, "
19946 "not enough for a full note\n",
19947 "Corrupt note: only %ld bytes remain, "
19948 "not enough for a full note\n",
19950 (long) data_remaining
);
19953 data_remaining
-= min_notesz
;
19955 vms_external
= (Elf64_External_VMS_Note
*) external
;
19956 inote
.type
= BYTE_GET (vms_external
->type
);
19957 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
19958 inote
.namedata
= vms_external
->name
;
19959 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
19960 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
19961 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19962 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
19965 /* PR 17531: file: 3443835e. */
19966 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19967 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
19968 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
19969 || (size_t) (next
- inote
.descdata
) < inote
.descsz
19970 || ((size_t) (next
- inote
.descdata
)
19971 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
19973 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19974 (unsigned long) ((char *) external
- (char *) pnotes
));
19975 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19976 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
19980 external
= (Elf_External_Note
*) next
;
19982 /* Verify that name is null terminated. It appears that at least
19983 one version of Linux (RedHat 6.0) generates corefiles that don't
19984 comply with the ELF spec by failing to include the null byte in
19986 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
19988 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
19990 temp
= (char *) malloc (inote
.namesz
+ 1);
19993 error (_("Out of memory allocating space for inote name\n"));
19998 memcpy (temp
, inote
.namedata
, inote
.namesz
);
19999 inote
.namedata
= temp
;
20001 inote
.namedata
[inote
.namesz
] = 0;
20004 if (! process_note (& inote
, filedata
))
20017 process_corefile_note_segments (Filedata
* filedata
)
20019 Elf_Internal_Phdr
* segment
;
20021 bfd_boolean res
= TRUE
;
20023 if (! get_program_headers (filedata
))
20026 for (i
= 0, segment
= filedata
->program_headers
;
20027 i
< filedata
->file_header
.e_phnum
;
20030 if (segment
->p_type
== PT_NOTE
)
20031 if (! process_notes_at (filedata
, NULL
,
20032 (bfd_vma
) segment
->p_offset
,
20033 (bfd_vma
) segment
->p_filesz
,
20034 (bfd_vma
) segment
->p_align
))
20042 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
20044 Elf_External_Note
* pnotes
;
20045 Elf_External_Note
* external
;
20047 bfd_boolean res
= TRUE
;
20052 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
20054 if (pnotes
== NULL
)
20058 end
= (char*) pnotes
+ length
;
20060 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
20061 (unsigned long) offset
, (unsigned long) length
);
20063 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
20065 Elf_External_Note
* next
;
20066 Elf_Internal_Note inote
;
20068 inote
.type
= BYTE_GET (external
->type
);
20069 inote
.namesz
= BYTE_GET (external
->namesz
);
20070 inote
.namedata
= external
->name
;
20071 inote
.descsz
= BYTE_GET (external
->descsz
);
20072 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
20073 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20075 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
20077 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
20078 inote
.descdata
= inote
.namedata
;
20082 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
20084 if ( ((char *) next
> end
)
20085 || ((char *) next
< (char *) pnotes
))
20087 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
20088 (unsigned long) ((char *) external
- (char *) pnotes
));
20089 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
20090 inote
.type
, inote
.namesz
, inote
.descsz
);
20096 /* Prevent out-of-bounds indexing. */
20097 if ( inote
.namedata
+ inote
.namesz
> end
20098 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
20100 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
20101 (unsigned long) ((char *) external
- (char *) pnotes
));
20102 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
20103 inote
.type
, inote
.namesz
, inote
.descsz
);
20107 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
20109 if (! print_v850_note (& inote
))
20112 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
20113 inote
.namesz
, inote
.descsz
);
20123 process_note_sections (Filedata
* filedata
)
20125 Elf_Internal_Shdr
* section
;
20127 unsigned int n
= 0;
20128 bfd_boolean res
= TRUE
;
20130 for (i
= 0, section
= filedata
->section_headers
;
20131 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
20134 if (section
->sh_type
== SHT_NOTE
)
20136 if (! process_notes_at (filedata
, section
,
20137 (bfd_vma
) section
->sh_offset
,
20138 (bfd_vma
) section
->sh_size
,
20139 (bfd_vma
) section
->sh_addralign
))
20144 if (( filedata
->file_header
.e_machine
== EM_V800
20145 || filedata
->file_header
.e_machine
== EM_V850
20146 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
20147 && section
->sh_type
== SHT_RENESAS_INFO
)
20149 if (! process_v850_notes (filedata
,
20150 (bfd_vma
) section
->sh_offset
,
20151 (bfd_vma
) section
->sh_size
))
20158 /* Try processing NOTE segments instead. */
20159 return process_corefile_note_segments (filedata
);
20165 process_notes (Filedata
* filedata
)
20167 /* If we have not been asked to display the notes then do nothing. */
20171 if (filedata
->file_header
.e_type
!= ET_CORE
)
20172 return process_note_sections (filedata
);
20174 /* No program headers means no NOTE segment. */
20175 if (filedata
->file_header
.e_phnum
> 0)
20176 return process_corefile_note_segments (filedata
);
20178 printf (_("No note segments present in the core file.\n"));
20182 static unsigned char *
20183 display_public_gnu_attributes (unsigned char * start
,
20184 const unsigned char * const end
)
20186 printf (_(" Unknown GNU attribute: %s\n"), start
);
20188 start
+= strnlen ((char *) start
, end
- start
);
20189 display_raw_attribute (start
, end
);
20191 return (unsigned char *) end
;
20194 static unsigned char *
20195 display_generic_attribute (unsigned char * start
,
20197 const unsigned char * const end
)
20200 return (unsigned char *) end
;
20202 return display_tag_value (tag
, start
, end
);
20206 process_arch_specific (Filedata
* filedata
)
20211 switch (filedata
->file_header
.e_machine
)
20214 case EM_ARC_COMPACT
:
20215 case EM_ARC_COMPACT2
:
20216 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
20217 display_arc_attribute
,
20218 display_generic_attribute
);
20220 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
20221 display_arm_attribute
,
20222 display_generic_attribute
);
20225 case EM_MIPS_RS3_LE
:
20226 return process_mips_specific (filedata
);
20229 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
20230 display_msp430_attribute
,
20231 display_msp430_gnu_attribute
);
20234 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
20235 display_riscv_attribute
,
20236 display_generic_attribute
);
20239 return process_nds32_specific (filedata
);
20242 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20243 display_m68k_gnu_attribute
);
20247 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20248 display_power_gnu_attribute
);
20252 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20253 display_s390_gnu_attribute
);
20256 case EM_SPARC32PLUS
:
20258 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20259 display_sparc_gnu_attribute
);
20262 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
20263 display_tic6x_attribute
,
20264 display_generic_attribute
);
20267 return process_attributes (filedata
, "csky", SHT_CSKY_ATTRIBUTES
,
20268 display_csky_attribute
, NULL
);
20271 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
20272 display_public_gnu_attributes
,
20273 display_generic_attribute
);
20278 get_file_header (Filedata
* filedata
)
20280 /* Read in the identity array. */
20281 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
20284 /* Determine how to read the rest of the header. */
20285 switch (filedata
->file_header
.e_ident
[EI_DATA
])
20290 byte_get
= byte_get_little_endian
;
20291 byte_put
= byte_put_little_endian
;
20294 byte_get
= byte_get_big_endian
;
20295 byte_put
= byte_put_big_endian
;
20299 /* For now we only support 32 bit and 64 bit ELF files. */
20300 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
20302 /* Read in the rest of the header. */
20305 Elf32_External_Ehdr ehdr32
;
20307 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20310 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
20311 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
20312 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
20313 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
20314 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
20315 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
20316 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
20317 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
20318 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
20319 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
20320 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
20321 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
20322 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
20326 Elf64_External_Ehdr ehdr64
;
20328 /* If we have been compiled with sizeof (bfd_vma) == 4, then
20329 we will not be able to cope with the 64bit data found in
20330 64 ELF files. Detect this now and abort before we start
20331 overwriting things. */
20332 if (sizeof (bfd_vma
) < 8)
20334 error (_("This instance of readelf has been built without support for a\n\
20335 64 bit data type and so it cannot read 64 bit ELF files.\n"));
20339 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20342 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
20343 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
20344 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
20345 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
20346 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
20347 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
20348 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
20349 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
20350 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
20351 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
20352 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
20353 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
20354 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
20357 if (filedata
->file_header
.e_shoff
)
20359 /* There may be some extensions in the first section header. Don't
20360 bomb if we can't read it. */
20362 get_32bit_section_headers (filedata
, TRUE
);
20364 get_64bit_section_headers (filedata
, TRUE
);
20371 close_file (Filedata
* filedata
)
20375 if (filedata
->handle
)
20376 fclose (filedata
->handle
);
20382 close_debug_file (void * data
)
20384 close_file ((Filedata
*) data
);
20388 open_file (const char * pathname
)
20390 struct stat statbuf
;
20391 Filedata
* filedata
= NULL
;
20393 if (stat (pathname
, & statbuf
) < 0
20394 || ! S_ISREG (statbuf
.st_mode
))
20397 filedata
= calloc (1, sizeof * filedata
);
20398 if (filedata
== NULL
)
20401 filedata
->handle
= fopen (pathname
, "rb");
20402 if (filedata
->handle
== NULL
)
20405 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20406 filedata
->file_name
= pathname
;
20408 if (! get_file_header (filedata
))
20411 if (filedata
->file_header
.e_shoff
)
20415 /* Read the section headers again, this time for real. */
20417 res
= get_32bit_section_headers (filedata
, FALSE
);
20419 res
= get_64bit_section_headers (filedata
, FALSE
);
20430 if (filedata
->handle
)
20431 fclose (filedata
->handle
);
20438 open_debug_file (const char * pathname
)
20440 return open_file (pathname
);
20443 /* Process one ELF object file according to the command line options.
20444 This file may actually be stored in an archive. The file is
20445 positioned at the start of the ELF object. Returns TRUE if no
20446 problems were encountered, FALSE otherwise. */
20449 process_object (Filedata
* filedata
)
20451 bfd_boolean have_separate_files
;
20455 if (! get_file_header (filedata
))
20457 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
20461 /* Initialise per file variables. */
20462 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
20463 filedata
->version_info
[i
] = 0;
20465 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
20466 filedata
->dynamic_info
[i
] = 0;
20467 filedata
->dynamic_info_DT_GNU_HASH
= 0;
20468 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
20470 /* Process the file. */
20472 printf (_("\nFile: %s\n"), filedata
->file_name
);
20474 /* Initialise the dump_sects array from the cmdline_dump_sects array.
20475 Note we do this even if cmdline_dump_sects is empty because we
20476 must make sure that the dump_sets array is zeroed out before each
20477 object file is processed. */
20478 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
20479 memset (filedata
->dump
.dump_sects
, 0,
20480 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20482 if (cmdline
.num_dump_sects
> 0)
20484 if (filedata
->dump
.num_dump_sects
== 0)
20485 /* A sneaky way of allocating the dump_sects array. */
20486 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
20488 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
20489 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
20490 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20493 if (! process_file_header (filedata
))
20496 if (! process_section_headers (filedata
))
20498 /* Without loaded section headers we cannot process lots of things. */
20499 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
20501 if (! do_using_dynamic
)
20502 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
20505 if (! process_section_groups (filedata
))
20506 /* Without loaded section groups we cannot process unwind. */
20509 res
= process_program_headers (filedata
);
20511 res
= process_dynamic_section (filedata
);
20513 if (! process_relocs (filedata
))
20516 if (! process_unwind (filedata
))
20519 if (! process_symbol_table (filedata
))
20522 if (! process_syminfo (filedata
))
20525 if (! process_version_sections (filedata
))
20528 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
20529 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
20531 have_separate_files
= FALSE
;
20533 if (! process_section_contents (filedata
))
20536 if (have_separate_files
)
20540 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
20542 if (! process_section_headers (d
->handle
))
20544 else if (! process_section_contents (d
->handle
))
20548 /* The file handles are closed by the call to free_debug_memory() below. */
20551 if (! process_notes (filedata
))
20554 if (! process_gnu_liblist (filedata
))
20557 if (! process_arch_specific (filedata
))
20560 free (filedata
->program_headers
);
20561 filedata
->program_headers
= NULL
;
20563 free (filedata
->section_headers
);
20564 filedata
->section_headers
= NULL
;
20566 free (filedata
->string_table
);
20567 filedata
->string_table
= NULL
;
20568 filedata
->string_table_length
= 0;
20570 free (filedata
->dump
.dump_sects
);
20571 filedata
->dump
.dump_sects
= NULL
;
20572 filedata
->dump
.num_dump_sects
= 0;
20574 free (filedata
->dynamic_strings
);
20575 filedata
->dynamic_strings
= NULL
;
20576 filedata
->dynamic_strings_length
= 0;
20578 free (filedata
->dynamic_symbols
);
20579 filedata
->dynamic_symbols
= NULL
;
20580 filedata
->num_dynamic_syms
= 0;
20582 free (filedata
->dynamic_syminfo
);
20583 filedata
->dynamic_syminfo
= NULL
;
20585 free (filedata
->dynamic_section
);
20586 filedata
->dynamic_section
= NULL
;
20588 while (filedata
->symtab_shndx_list
!= NULL
)
20590 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
20591 free (filedata
->symtab_shndx_list
);
20592 filedata
->symtab_shndx_list
= next
;
20595 free (filedata
->section_headers_groups
);
20596 filedata
->section_headers_groups
= NULL
;
20598 if (filedata
->section_groups
)
20600 struct group_list
* g
;
20601 struct group_list
* next
;
20603 for (i
= 0; i
< filedata
->group_count
; i
++)
20605 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
20612 free (filedata
->section_groups
);
20613 filedata
->section_groups
= NULL
;
20616 free_debug_memory ();
20621 /* Process an ELF archive.
20622 On entry the file is positioned just after the ARMAG string.
20623 Returns TRUE upon success, FALSE otherwise. */
20626 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
20628 struct archive_info arch
;
20629 struct archive_info nested_arch
;
20631 bfd_boolean ret
= TRUE
;
20635 /* The ARCH structure is used to hold information about this archive. */
20636 arch
.file_name
= NULL
;
20638 arch
.index_array
= NULL
;
20639 arch
.sym_table
= NULL
;
20640 arch
.longnames
= NULL
;
20642 /* The NESTED_ARCH structure is used as a single-item cache of information
20643 about a nested archive (when members of a thin archive reside within
20644 another regular archive file). */
20645 nested_arch
.file_name
= NULL
;
20646 nested_arch
.file
= NULL
;
20647 nested_arch
.index_array
= NULL
;
20648 nested_arch
.sym_table
= NULL
;
20649 nested_arch
.longnames
= NULL
;
20651 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
20652 filedata
->file_size
, is_thin_archive
,
20653 do_archive_index
) != 0)
20659 if (do_archive_index
)
20661 if (arch
.sym_table
== NULL
)
20662 error (_("%s: unable to dump the index as none was found\n"),
20663 filedata
->file_name
);
20666 unsigned long i
, l
;
20667 unsigned long current_pos
;
20669 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
20670 "in the symbol table)\n"),
20671 filedata
->file_name
, (unsigned long) arch
.index_num
,
20674 current_pos
= ftell (filedata
->handle
);
20676 for (i
= l
= 0; i
< arch
.index_num
; i
++)
20679 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
20682 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
20685 if (member_name
!= NULL
)
20687 char * qualified_name
20688 = make_qualified_name (&arch
, &nested_arch
,
20691 if (qualified_name
!= NULL
)
20693 printf (_("Contents of binary %s at offset "),
20695 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
20697 free (qualified_name
);
20699 free (member_name
);
20703 if (l
>= arch
.sym_size
)
20705 error (_("%s: end of the symbol table reached "
20706 "before the end of the index\n"),
20707 filedata
->file_name
);
20711 /* PR 17531: file: 0b6630b2. */
20712 printf ("\t%.*s\n",
20713 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
20714 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
20717 if (arch
.uses_64bit_indices
)
20722 if (l
< arch
.sym_size
)
20724 error (ngettext ("%s: %ld byte remains in the symbol table, "
20725 "but without corresponding entries in "
20726 "the index table\n",
20727 "%s: %ld bytes remain in the symbol table, "
20728 "but without corresponding entries in "
20729 "the index table\n",
20730 arch
.sym_size
- l
),
20731 filedata
->file_name
, arch
.sym_size
- l
);
20735 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
20737 error (_("%s: failed to seek back to start of object files "
20738 "in the archive\n"),
20739 filedata
->file_name
);
20745 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
20746 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
20747 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
20748 && !do_section_groups
&& !do_dyn_syms
)
20750 ret
= TRUE
; /* Archive index only. */
20759 char * qualified_name
;
20761 /* Read the next archive header. */
20762 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
20764 error (_("%s: failed to seek to next archive header\n"),
20769 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
20770 if (got
!= sizeof arch
.arhdr
)
20774 /* PR 24049 - we cannot use filedata->file_name as this will
20775 have already been freed. */
20776 error (_("%s: failed to read archive header\n"), arch
.file_name
);
20781 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
20783 error (_("%s: did not find a valid archive header\n"),
20789 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
20791 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
20792 if (filedata
->archive_file_size
& 01)
20793 ++filedata
->archive_file_size
;
20795 name
= get_archive_member_name (&arch
, &nested_arch
);
20798 error (_("%s: bad archive file name\n"), arch
.file_name
);
20802 namelen
= strlen (name
);
20804 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
20805 if (qualified_name
== NULL
)
20807 error (_("%s: bad archive file name\n"), arch
.file_name
);
20813 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
20815 /* This is a proxy for an external member of a thin archive. */
20816 Filedata
* member_filedata
;
20817 char * member_file_name
= adjust_relative_path
20818 (filedata
->file_name
, name
, namelen
);
20821 if (member_file_name
== NULL
)
20823 free (qualified_name
);
20828 member_filedata
= open_file (member_file_name
);
20829 if (member_filedata
== NULL
)
20831 error (_("Input file '%s' is not readable.\n"), member_file_name
);
20832 free (member_file_name
);
20833 free (qualified_name
);
20838 filedata
->archive_file_offset
= arch
.nested_member_origin
;
20839 member_filedata
->file_name
= qualified_name
;
20841 if (! process_object (member_filedata
))
20844 close_file (member_filedata
);
20845 free (member_file_name
);
20847 else if (is_thin_archive
)
20849 Filedata thin_filedata
;
20851 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
20853 /* PR 15140: Allow for corrupt thin archives. */
20854 if (nested_arch
.file
== NULL
)
20856 error (_("%s: contains corrupt thin archive: %s\n"),
20857 qualified_name
, name
);
20858 free (qualified_name
);
20865 /* This is a proxy for a member of a nested archive. */
20866 filedata
->archive_file_offset
20867 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
20869 /* The nested archive file will have been opened and setup by
20870 get_archive_member_name. */
20871 if (fseek (nested_arch
.file
, filedata
->archive_file_offset
,
20874 error (_("%s: failed to seek to archive member.\n"),
20875 nested_arch
.file_name
);
20876 free (qualified_name
);
20881 thin_filedata
.handle
= nested_arch
.file
;
20882 thin_filedata
.file_name
= qualified_name
;
20884 if (! process_object (& thin_filedata
))
20890 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
20891 filedata
->file_name
= qualified_name
;
20892 if (! process_object (filedata
))
20894 arch
.next_arhdr_offset
+= filedata
->archive_file_size
;
20895 /* Stop looping with "negative" archive_file_size. */
20896 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
20897 arch
.next_arhdr_offset
= -1ul;
20900 free (qualified_name
);
20904 if (nested_arch
.file
!= NULL
)
20905 fclose (nested_arch
.file
);
20906 release_archive (&nested_arch
);
20907 release_archive (&arch
);
20913 process_file (char * file_name
)
20915 Filedata
* filedata
= NULL
;
20916 struct stat statbuf
;
20917 char armag
[SARMAG
];
20918 bfd_boolean ret
= TRUE
;
20920 if (stat (file_name
, &statbuf
) < 0)
20922 if (errno
== ENOENT
)
20923 error (_("'%s': No such file\n"), file_name
);
20925 error (_("Could not locate '%s'. System error message: %s\n"),
20926 file_name
, strerror (errno
));
20930 if (! S_ISREG (statbuf
.st_mode
))
20932 error (_("'%s' is not an ordinary file\n"), file_name
);
20936 filedata
= calloc (1, sizeof * filedata
);
20937 if (filedata
== NULL
)
20939 error (_("Out of memory allocating file data structure\n"));
20943 filedata
->file_name
= file_name
;
20944 filedata
->handle
= fopen (file_name
, "rb");
20945 if (filedata
->handle
== NULL
)
20947 error (_("Input file '%s' is not readable.\n"), file_name
);
20952 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
20954 error (_("%s: Failed to read file's magic number\n"), file_name
);
20955 fclose (filedata
->handle
);
20960 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20962 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
20964 if (! process_archive (filedata
, FALSE
))
20967 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
20969 if ( ! process_archive (filedata
, TRUE
))
20974 if (do_archive_index
&& !check_all
)
20975 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20978 rewind (filedata
->handle
);
20979 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
20981 if (! process_object (filedata
))
20985 fclose (filedata
->handle
);
20986 free (filedata
->section_headers
);
20987 free (filedata
->program_headers
);
20988 free (filedata
->string_table
);
20989 free (filedata
->dump
.dump_sects
);
20992 free (ba_cache
.strtab
);
20993 ba_cache
.strtab
= NULL
;
20994 free (ba_cache
.symtab
);
20995 ba_cache
.symtab
= NULL
;
20996 ba_cache
.filedata
= NULL
;
21001 #ifdef SUPPORT_DISASSEMBLY
21002 /* Needed by the i386 disassembler. For extra credit, someone could
21003 fix this so that we insert symbolic addresses here, esp for GOT/PLT
21007 print_address (unsigned int addr
, FILE * outfile
)
21009 fprintf (outfile
,"0x%8.8x", addr
);
21012 /* Needed by the i386 disassembler. */
21015 db_task_printsym (unsigned int addr
)
21017 print_address (addr
, stderr
);
21022 main (int argc
, char ** argv
)
21026 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
21027 setlocale (LC_MESSAGES
, "");
21029 #if defined (HAVE_SETLOCALE)
21030 setlocale (LC_CTYPE
, "");
21032 bindtextdomain (PACKAGE
, LOCALEDIR
);
21033 textdomain (PACKAGE
);
21035 expandargv (&argc
, &argv
);
21037 parse_args (& cmdline
, argc
, argv
);
21039 if (optind
< (argc
- 1))
21040 /* When displaying information for more than one file,
21041 prefix the information with the file name. */
21043 else if (optind
>= argc
)
21045 /* Ensure that the warning is always displayed. */
21048 warn (_("Nothing to do.\n"));
21053 while (optind
< argc
)
21054 if (! process_file (argv
[optind
++]))
21057 free (cmdline
.dump_sects
);
21059 free (dump_ctf_symtab_name
);
21060 free (dump_ctf_strtab_name
);
21061 free (dump_ctf_parent_name
);
21063 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;