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_msp430x_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_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4320 static char buff
[32];
4321 const char * result
;
4325 case SHT_NULL
: return "NULL";
4326 case SHT_PROGBITS
: return "PROGBITS";
4327 case SHT_SYMTAB
: return "SYMTAB";
4328 case SHT_STRTAB
: return "STRTAB";
4329 case SHT_RELA
: return "RELA";
4330 case SHT_HASH
: return "HASH";
4331 case SHT_DYNAMIC
: return "DYNAMIC";
4332 case SHT_NOTE
: return "NOTE";
4333 case SHT_NOBITS
: return "NOBITS";
4334 case SHT_REL
: return "REL";
4335 case SHT_SHLIB
: return "SHLIB";
4336 case SHT_DYNSYM
: return "DYNSYM";
4337 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4338 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4339 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4340 case SHT_GNU_HASH
: return "GNU_HASH";
4341 case SHT_GROUP
: return "GROUP";
4342 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4343 case SHT_GNU_verdef
: return "VERDEF";
4344 case SHT_GNU_verneed
: return "VERNEED";
4345 case SHT_GNU_versym
: return "VERSYM";
4346 case 0x6ffffff0: return "VERSYM";
4347 case 0x6ffffffc: return "VERDEF";
4348 case 0x7ffffffd: return "AUXILIARY";
4349 case 0x7fffffff: return "FILTER";
4350 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4353 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4355 switch (filedata
->file_header
.e_machine
)
4358 case EM_ARC_COMPACT
:
4359 case EM_ARC_COMPACT2
:
4360 result
= get_arc_section_type_name (sh_type
);
4363 case EM_MIPS_RS3_LE
:
4364 result
= get_mips_section_type_name (sh_type
);
4367 result
= get_parisc_section_type_name (sh_type
);
4370 result
= get_ia64_section_type_name (filedata
, sh_type
);
4375 result
= get_x86_64_section_type_name (sh_type
);
4378 result
= get_aarch64_section_type_name (sh_type
);
4381 result
= get_arm_section_type_name (sh_type
);
4384 result
= get_tic6x_section_type_name (sh_type
);
4387 result
= get_msp430x_section_type_name (sh_type
);
4390 result
= get_nfp_section_type_name (sh_type
);
4394 case EM_CYGNUS_V850
:
4395 result
= get_v850_section_type_name (sh_type
);
4398 result
= get_riscv_section_type_name (sh_type
);
4408 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4410 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4412 switch (filedata
->file_header
.e_machine
)
4415 result
= get_ia64_section_type_name (filedata
, sh_type
);
4418 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4419 result
= get_solaris_section_type (sh_type
);
4424 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4425 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4426 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4427 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4439 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4441 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4443 switch (filedata
->file_header
.e_machine
)
4447 case EM_CYGNUS_V850
:
4448 result
= get_v850_section_type_name (sh_type
);
4458 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4461 /* This message is probably going to be displayed in a 15
4462 character wide field, so put the hex value first. */
4463 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4469 enum long_option_values
4471 OPTION_DEBUG_DUMP
= 512,
4480 OPTION_WITH_SYMBOL_VERSIONS
,
4481 OPTION_RECURSE_LIMIT
,
4482 OPTION_NO_RECURSE_LIMIT
,
4483 OPTION_NO_DEMANGLING
4486 static struct option options
[] =
4488 /* Note - This table is alpha-sorted on the 'val'
4489 field in order to make adding new options easier. */
4490 {"arch-specific", no_argument
, 0, 'A'},
4491 {"all", no_argument
, 0, 'a'},
4492 {"demangle", optional_argument
, 0, 'C'},
4493 {"archive-index", no_argument
, 0, 'c'},
4494 {"use-dynamic", no_argument
, 0, 'D'},
4495 {"dynamic", no_argument
, 0, 'd'},
4496 {"headers", no_argument
, 0, 'e'},
4497 {"section-groups", no_argument
, 0, 'g'},
4498 {"help", no_argument
, 0, 'H'},
4499 {"file-header", no_argument
, 0, 'h'},
4500 {"histogram", no_argument
, 0, 'I'},
4501 {"lint", no_argument
, 0, 'L'},
4502 {"enable-checks", no_argument
, 0, 'L'},
4503 {"program-headers", no_argument
, 0, 'l'},
4504 {"segments", no_argument
, 0, 'l'},
4505 {"full-section-name",no_argument
, 0, 'N'},
4506 {"notes", no_argument
, 0, 'n'},
4507 {"string-dump", required_argument
, 0, 'p'},
4508 {"relocated-dump", required_argument
, 0, 'R'},
4509 {"relocs", no_argument
, 0, 'r'},
4510 {"section-headers", no_argument
, 0, 'S'},
4511 {"sections", no_argument
, 0, 'S'},
4512 {"symbols", no_argument
, 0, 's'},
4513 {"syms", no_argument
, 0, 's'},
4514 {"silent-truncation",no_argument
, 0, 'T'},
4515 {"section-details", no_argument
, 0, 't'},
4516 {"unwind", no_argument
, 0, 'u'},
4517 {"version-info", no_argument
, 0, 'V'},
4518 {"version", no_argument
, 0, 'v'},
4519 {"wide", no_argument
, 0, 'W'},
4520 {"hex-dump", required_argument
, 0, 'x'},
4521 {"decompress", no_argument
, 0, 'z'},
4523 {"no-demangle", no_argument
, 0, OPTION_NO_DEMANGLING
},
4524 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
4525 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
4526 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
4527 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4528 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4529 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4530 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4531 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4532 #ifdef ENABLE_LIBCTF
4533 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
4534 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
4535 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
4536 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
4539 {0, no_argument
, 0, 0}
4543 usage (FILE * stream
)
4545 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4546 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4547 fprintf (stream
, _(" Options are:\n\
4548 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4549 -h --file-header Display the ELF file header\n\
4550 -l --program-headers Display the program headers\n\
4551 --segments An alias for --program-headers\n\
4552 -S --section-headers Display the sections' header\n\
4553 --sections An alias for --section-headers\n\
4554 -g --section-groups Display the section groups\n\
4555 -t --section-details Display the section details\n\
4556 -e --headers Equivalent to: -h -l -S\n\
4557 -s --syms Display the symbol table\n\
4558 --symbols An alias for --syms\n\
4559 --dyn-syms Display the dynamic symbol table\n\
4560 -C --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
4561 The STYLE, if specified, can be `auto' (the default),\n\
4562 `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
4564 --no-demangle Do not demangle low-level symbol names. (This is the default)\n\
4565 --recurse-limit Enable a demangling recursion limit. (This is the default)\n\
4566 --no-recurse-limit Disable a demangling recursion limit\n\
4567 -n --notes Display the core notes (if present)\n\
4568 -r --relocs Display the relocations (if present)\n\
4569 -u --unwind Display the unwind info (if present)\n\
4570 -d --dynamic Display the dynamic section (if present)\n\
4571 -V --version-info Display the version sections (if present)\n\
4572 -A --arch-specific Display architecture specific information (if any)\n\
4573 -c --archive-index Display the symbol/file index in an archive\n\
4574 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4575 -L --lint|--enable-checks Display warning messages for possible problems\n\
4576 -x --hex-dump=<number|name>\n\
4577 Dump the contents of section <number|name> as bytes\n\
4578 -p --string-dump=<number|name>\n\
4579 Dump the contents of section <number|name> as strings\n\
4580 -R --relocated-dump=<number|name>\n\
4581 Dump the contents of section <number|name> as relocated bytes\n\
4582 -z --decompress Decompress section before dumping it\n\
4583 -w[lLiaprmfFsoORtUuTgAckK] or\n\
4584 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4585 =frames-interp,=str,=str-offsets,=loc,=Ranges,=pubtypes,\n\
4586 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4587 =addr,=cu_index,=links,=follow-links]\n\
4588 Display the contents of DWARF debug sections\n"));
4589 fprintf (stream
, _("\
4590 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4591 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4593 #ifdef ENABLE_LIBCTF
4594 fprintf (stream
, _("\
4595 --ctf=<number|name> Display CTF info from section <number|name>\n\
4596 --ctf-parent=<number|name>\n\
4597 Use section <number|name> as the CTF parent\n\n\
4598 --ctf-symbols=<number|name>\n\
4599 Use section <number|name> as the CTF external symtab\n\n\
4600 --ctf-strings=<number|name>\n\
4601 Use section <number|name> as the CTF external strtab\n\n"));
4604 #ifdef SUPPORT_DISASSEMBLY
4605 fprintf (stream
, _("\
4606 -i --instruction-dump=<number|name>\n\
4607 Disassemble the contents of section <number|name>\n"));
4609 fprintf (stream
, _("\
4610 -I --histogram Display histogram of bucket list lengths\n\
4611 -W --wide Allow output width to exceed 80 characters\n\
4612 -T --silent-truncation If a symbol name is truncated, do not add a suffix [...]\n\
4613 @<file> Read options from <file>\n\
4614 -H --help Display this information\n\
4615 -v --version Display the version number of readelf\n"));
4617 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4618 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4620 exit (stream
== stdout
? 0 : 1);
4623 /* Record the fact that the user wants the contents of section number
4624 SECTION to be displayed using the method(s) encoded as flags bits
4625 in TYPE. Note, TYPE can be zero if we are creating the array for
4629 request_dump_bynumber (struct dump_data
*dumpdata
,
4630 unsigned int section
, dump_type type
)
4632 if (section
>= dumpdata
->num_dump_sects
)
4634 dump_type
* new_dump_sects
;
4636 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4637 sizeof (* new_dump_sects
));
4639 if (new_dump_sects
== NULL
)
4640 error (_("Out of memory allocating dump request table.\n"));
4643 if (dumpdata
->dump_sects
)
4645 /* Copy current flag settings. */
4646 memcpy (new_dump_sects
, dumpdata
->dump_sects
,
4647 dumpdata
->num_dump_sects
* sizeof (* new_dump_sects
));
4649 free (dumpdata
->dump_sects
);
4652 dumpdata
->dump_sects
= new_dump_sects
;
4653 dumpdata
->num_dump_sects
= section
+ 1;
4657 if (dumpdata
->dump_sects
)
4658 dumpdata
->dump_sects
[section
] |= type
;
4661 /* Request a dump by section name. */
4664 request_dump_byname (const char * section
, dump_type type
)
4666 struct dump_list_entry
* new_request
;
4668 new_request
= (struct dump_list_entry
*)
4669 malloc (sizeof (struct dump_list_entry
));
4671 error (_("Out of memory allocating dump request table.\n"));
4673 new_request
->name
= strdup (section
);
4674 if (!new_request
->name
)
4675 error (_("Out of memory allocating dump request table.\n"));
4677 new_request
->type
= type
;
4679 new_request
->next
= dump_sects_byname
;
4680 dump_sects_byname
= new_request
;
4684 request_dump (struct dump_data
*dumpdata
, dump_type type
)
4690 section
= strtoul (optarg
, & cp
, 0);
4692 if (! *cp
&& section
>= 0)
4693 request_dump_bynumber (dumpdata
, section
, type
);
4695 request_dump_byname (optarg
, type
);
4699 parse_args (struct dump_data
*dumpdata
, int argc
, char ** argv
)
4706 while ((c
= getopt_long
4707 (argc
, argv
, "ACDHILNR:STVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4725 do_section_groups
= TRUE
;
4728 do_histogram
= TRUE
;
4734 do_section_groups
= TRUE
;
4739 do_section_details
= TRUE
;
4750 do_using_dynamic
= TRUE
;
4774 do_histogram
= TRUE
;
4780 do_archive_index
= TRUE
;
4786 request_dump (dumpdata
, HEX_DUMP
);
4789 request_dump (dumpdata
, STRING_DUMP
);
4792 request_dump (dumpdata
, RELOC_DUMP
);
4795 decompress_dumps
= TRUE
;
4801 do_debugging
= TRUE
;
4802 dwarf_select_sections_all ();
4806 do_debugging
= FALSE
;
4807 dwarf_select_sections_by_letters (optarg
);
4810 case OPTION_DEBUG_DUMP
:
4813 do_debugging
= TRUE
;
4816 do_debugging
= FALSE
;
4817 dwarf_select_sections_by_names (optarg
);
4820 case OPTION_DWARF_DEPTH
:
4824 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4827 case OPTION_DWARF_START
:
4831 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4834 case OPTION_DWARF_CHECK
:
4837 case OPTION_CTF_DUMP
:
4839 request_dump (dumpdata
, CTF_DUMP
);
4841 case OPTION_CTF_SYMBOLS
:
4842 free (dump_ctf_symtab_name
);
4843 dump_ctf_symtab_name
= strdup (optarg
);
4845 case OPTION_CTF_STRINGS
:
4846 free (dump_ctf_strtab_name
);
4847 dump_ctf_strtab_name
= strdup (optarg
);
4849 case OPTION_CTF_PARENT
:
4850 free (dump_ctf_parent_name
);
4851 dump_ctf_parent_name
= strdup (optarg
);
4853 case OPTION_DYN_SYMS
:
4856 #ifdef SUPPORT_DISASSEMBLY
4858 request_dump (dumpdata
, DISASS_DUMP
);
4862 print_version (program_name
);
4871 do_not_show_symbol_truncation
= TRUE
;
4877 enum demangling_styles style
;
4879 style
= cplus_demangle_name_to_style (optarg
);
4880 if (style
== unknown_demangling
)
4881 error (_("unknown demangling style `%s'"), optarg
);
4883 cplus_demangle_set_style (style
);
4886 case OPTION_NO_DEMANGLING
:
4887 do_demangle
= FALSE
;
4889 case OPTION_RECURSE_LIMIT
:
4890 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
4892 case OPTION_NO_RECURSE_LIMIT
:
4893 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
4895 case OPTION_WITH_SYMBOL_VERSIONS
:
4896 /* Ignored for backward compatibility. */
4900 /* xgettext:c-format */
4901 error (_("Invalid option '-%c'\n"), c
);
4908 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4909 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4910 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4911 && !do_section_groups
&& !do_archive_index
4917 do_dynamic
= do_syms
= do_reloc
= do_unwind
= do_sections
= TRUE
;
4918 do_segments
= do_header
= do_dump
= do_version
= TRUE
;
4919 do_histogram
= do_debugging
= do_arch
= do_notes
= TRUE
;
4920 do_section_groups
= do_archive_index
= do_dyn_syms
= TRUE
;
4928 get_elf_class (unsigned int elf_class
)
4930 static char buff
[32];
4934 case ELFCLASSNONE
: return _("none");
4935 case ELFCLASS32
: return "ELF32";
4936 case ELFCLASS64
: return "ELF64";
4938 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4944 get_data_encoding (unsigned int encoding
)
4946 static char buff
[32];
4950 case ELFDATANONE
: return _("none");
4951 case ELFDATA2LSB
: return _("2's complement, little endian");
4952 case ELFDATA2MSB
: return _("2's complement, big endian");
4954 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4959 /* Decode the data held in 'filedata->file_header'. */
4962 process_file_header (Filedata
* filedata
)
4964 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4966 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4967 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4968 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4969 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4972 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4976 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
4982 printf (_("ELF Header:\n"));
4983 printf (_(" Magic: "));
4984 for (i
= 0; i
< EI_NIDENT
; i
++)
4985 printf ("%2.2x ", header
->e_ident
[i
]);
4987 printf (_(" Class: %s\n"),
4988 get_elf_class (header
->e_ident
[EI_CLASS
]));
4989 printf (_(" Data: %s\n"),
4990 get_data_encoding (header
->e_ident
[EI_DATA
]));
4991 printf (_(" Version: %d%s\n"),
4992 header
->e_ident
[EI_VERSION
],
4993 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4995 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4998 printf (_(" OS/ABI: %s\n"),
4999 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
5000 printf (_(" ABI Version: %d\n"),
5001 header
->e_ident
[EI_ABIVERSION
]);
5002 printf (_(" Type: %s\n"),
5003 get_file_type (header
->e_type
));
5004 printf (_(" Machine: %s\n"),
5005 get_machine_name (header
->e_machine
));
5006 printf (_(" Version: 0x%lx\n"),
5009 printf (_(" Entry point address: "));
5010 print_vma (header
->e_entry
, PREFIX_HEX
);
5011 printf (_("\n Start of program headers: "));
5012 print_vma (header
->e_phoff
, DEC
);
5013 printf (_(" (bytes into file)\n Start of section headers: "));
5014 print_vma (header
->e_shoff
, DEC
);
5015 printf (_(" (bytes into file)\n"));
5017 printf (_(" Flags: 0x%lx%s\n"),
5019 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
5020 printf (_(" Size of this header: %u (bytes)\n"),
5022 printf (_(" Size of program headers: %u (bytes)\n"),
5023 header
->e_phentsize
);
5024 printf (_(" Number of program headers: %u"),
5026 if (filedata
->section_headers
!= NULL
5027 && header
->e_phnum
== PN_XNUM
5028 && filedata
->section_headers
[0].sh_info
!= 0)
5030 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
5031 printf (" (%u)", header
->e_phnum
);
5033 putc ('\n', stdout
);
5034 printf (_(" Size of section headers: %u (bytes)\n"),
5035 header
->e_shentsize
);
5036 printf (_(" Number of section headers: %u"),
5038 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
5040 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5041 printf (" (%u)", header
->e_shnum
);
5043 putc ('\n', stdout
);
5044 printf (_(" Section header string table index: %u"),
5045 header
->e_shstrndx
);
5046 if (filedata
->section_headers
!= NULL
5047 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5049 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5050 printf (" (%u)", header
->e_shstrndx
);
5052 if (header
->e_shstrndx
!= SHN_UNDEF
5053 && header
->e_shstrndx
>= header
->e_shnum
)
5055 header
->e_shstrndx
= SHN_UNDEF
;
5056 printf (_(" <corrupt: out of range>"));
5058 putc ('\n', stdout
);
5061 if (filedata
->section_headers
!= NULL
)
5063 if (header
->e_phnum
== PN_XNUM
5064 && filedata
->section_headers
[0].sh_info
!= 0)
5065 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
5066 if (header
->e_shnum
== SHN_UNDEF
)
5067 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5068 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5069 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5070 if (header
->e_shstrndx
>= header
->e_shnum
)
5071 header
->e_shstrndx
= SHN_UNDEF
;
5072 free (filedata
->section_headers
);
5073 filedata
->section_headers
= NULL
;
5079 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5080 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
5083 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5085 Elf32_External_Phdr
* phdrs
;
5086 Elf32_External_Phdr
* external
;
5087 Elf_Internal_Phdr
* internal
;
5089 unsigned int size
= filedata
->file_header
.e_phentsize
;
5090 unsigned int num
= filedata
->file_header
.e_phnum
;
5092 /* PR binutils/17531: Cope with unexpected section header sizes. */
5093 if (size
== 0 || num
== 0)
5095 if (size
< sizeof * phdrs
)
5097 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5100 if (size
> sizeof * phdrs
)
5101 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5103 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5104 size
, num
, _("program headers"));
5108 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5109 i
< filedata
->file_header
.e_phnum
;
5110 i
++, internal
++, external
++)
5112 internal
->p_type
= BYTE_GET (external
->p_type
);
5113 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5114 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5115 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5116 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5117 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5118 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5119 internal
->p_align
= BYTE_GET (external
->p_align
);
5126 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5127 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5130 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5132 Elf64_External_Phdr
* phdrs
;
5133 Elf64_External_Phdr
* external
;
5134 Elf_Internal_Phdr
* internal
;
5136 unsigned int size
= filedata
->file_header
.e_phentsize
;
5137 unsigned int num
= filedata
->file_header
.e_phnum
;
5139 /* PR binutils/17531: Cope with unexpected section header sizes. */
5140 if (size
== 0 || num
== 0)
5142 if (size
< sizeof * phdrs
)
5144 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5147 if (size
> sizeof * phdrs
)
5148 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5150 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5151 size
, num
, _("program headers"));
5155 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5156 i
< filedata
->file_header
.e_phnum
;
5157 i
++, internal
++, external
++)
5159 internal
->p_type
= BYTE_GET (external
->p_type
);
5160 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5161 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5162 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5163 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5164 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5165 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5166 internal
->p_align
= BYTE_GET (external
->p_align
);
5173 /* Returns TRUE if the program headers were read into `program_headers'. */
5176 get_program_headers (Filedata
* filedata
)
5178 Elf_Internal_Phdr
* phdrs
;
5180 /* Check cache of prior read. */
5181 if (filedata
->program_headers
!= NULL
)
5184 /* Be kind to memory checkers by looking for
5185 e_phnum values which we know must be invalid. */
5186 if (filedata
->file_header
.e_phnum
5187 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5188 >= filedata
->file_size
)
5190 error (_("Too many program headers - %#x - the file is not that big\n"),
5191 filedata
->file_header
.e_phnum
);
5195 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5196 sizeof (Elf_Internal_Phdr
));
5199 error (_("Out of memory reading %u program headers\n"),
5200 filedata
->file_header
.e_phnum
);
5205 ? get_32bit_program_headers (filedata
, phdrs
)
5206 : get_64bit_program_headers (filedata
, phdrs
))
5208 filedata
->program_headers
= phdrs
;
5216 /* Returns TRUE if the program headers were loaded. */
5219 process_program_headers (Filedata
* filedata
)
5221 Elf_Internal_Phdr
* segment
;
5223 Elf_Internal_Phdr
* previous_load
= NULL
;
5225 filedata
->dynamic_addr
= 0;
5226 filedata
->dynamic_size
= 0;
5228 if (filedata
->file_header
.e_phnum
== 0)
5230 /* PR binutils/12467. */
5231 if (filedata
->file_header
.e_phoff
!= 0)
5233 warn (_("possibly corrupt ELF header - it has a non-zero program"
5234 " header offset, but no program headers\n"));
5237 else if (do_segments
)
5238 printf (_("\nThere are no program headers in this file.\n"));
5242 if (do_segments
&& !do_header
)
5244 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5245 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5246 printf (ngettext ("There is %d program header, starting at offset %s\n",
5247 "There are %d program headers, starting at offset %s\n",
5248 filedata
->file_header
.e_phnum
),
5249 filedata
->file_header
.e_phnum
,
5250 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5253 if (! get_program_headers (filedata
))
5258 if (filedata
->file_header
.e_phnum
> 1)
5259 printf (_("\nProgram Headers:\n"));
5261 printf (_("\nProgram Headers:\n"));
5265 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5268 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5272 (_(" Type Offset VirtAddr PhysAddr\n"));
5274 (_(" FileSiz MemSiz Flags Align\n"));
5278 for (i
= 0, segment
= filedata
->program_headers
;
5279 i
< filedata
->file_header
.e_phnum
;
5284 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5288 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5289 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5290 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5291 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5292 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5294 (segment
->p_flags
& PF_R
? 'R' : ' '),
5295 (segment
->p_flags
& PF_W
? 'W' : ' '),
5296 (segment
->p_flags
& PF_X
? 'E' : ' '));
5297 printf ("%#lx", (unsigned long) segment
->p_align
);
5301 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5302 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5305 print_vma (segment
->p_offset
, FULL_HEX
);
5309 print_vma (segment
->p_vaddr
, FULL_HEX
);
5311 print_vma (segment
->p_paddr
, FULL_HEX
);
5314 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5315 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5318 print_vma (segment
->p_filesz
, FULL_HEX
);
5322 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5323 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5326 print_vma (segment
->p_memsz
, FULL_HEX
);
5330 (segment
->p_flags
& PF_R
? 'R' : ' '),
5331 (segment
->p_flags
& PF_W
? 'W' : ' '),
5332 (segment
->p_flags
& PF_X
? 'E' : ' '));
5334 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5335 printf ("%#lx", (unsigned long) segment
->p_align
);
5338 print_vma (segment
->p_align
, PREFIX_HEX
);
5343 print_vma (segment
->p_offset
, FULL_HEX
);
5345 print_vma (segment
->p_vaddr
, FULL_HEX
);
5347 print_vma (segment
->p_paddr
, FULL_HEX
);
5349 print_vma (segment
->p_filesz
, FULL_HEX
);
5351 print_vma (segment
->p_memsz
, FULL_HEX
);
5353 (segment
->p_flags
& PF_R
? 'R' : ' '),
5354 (segment
->p_flags
& PF_W
? 'W' : ' '),
5355 (segment
->p_flags
& PF_X
? 'E' : ' '));
5356 print_vma (segment
->p_align
, PREFIX_HEX
);
5359 putc ('\n', stdout
);
5362 switch (segment
->p_type
)
5365 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5366 required by the ELF standard, several programs, including the Linux
5367 kernel, make use of non-ordered segments. */
5369 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5370 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5372 if (segment
->p_memsz
< segment
->p_filesz
)
5373 error (_("the segment's file size is larger than its memory size\n"));
5374 previous_load
= segment
;
5378 /* PR 20815 - Verify that the program header is loaded into memory. */
5379 if (i
> 0 && previous_load
!= NULL
)
5380 error (_("the PHDR segment must occur before any LOAD segment\n"));
5381 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5385 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5387 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
5388 if (load
->p_type
== PT_LOAD
5389 && load
->p_offset
<= segment
->p_offset
5390 && (load
->p_offset
+ load
->p_filesz
5391 >= segment
->p_offset
+ segment
->p_filesz
)
5392 && load
->p_vaddr
<= segment
->p_vaddr
5393 && (load
->p_vaddr
+ load
->p_filesz
5394 >= segment
->p_vaddr
+ segment
->p_filesz
))
5397 if (j
== filedata
->file_header
.e_phnum
)
5398 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5403 if (filedata
->dynamic_addr
)
5404 error (_("more than one dynamic segment\n"));
5406 /* By default, assume that the .dynamic section is the first
5407 section in the DYNAMIC segment. */
5408 filedata
->dynamic_addr
= segment
->p_offset
;
5409 filedata
->dynamic_size
= segment
->p_filesz
;
5411 /* Try to locate the .dynamic section. If there is
5412 a section header table, we can easily locate it. */
5413 if (filedata
->section_headers
!= NULL
)
5415 Elf_Internal_Shdr
* sec
;
5417 sec
= find_section (filedata
, ".dynamic");
5418 if (sec
== NULL
|| sec
->sh_size
== 0)
5420 /* A corresponding .dynamic section is expected, but on
5421 IA-64/OpenVMS it is OK for it to be missing. */
5422 if (!is_ia64_vms (filedata
))
5423 error (_("no .dynamic section in the dynamic segment\n"));
5427 if (sec
->sh_type
== SHT_NOBITS
)
5429 filedata
->dynamic_size
= 0;
5433 filedata
->dynamic_addr
= sec
->sh_offset
;
5434 filedata
->dynamic_size
= sec
->sh_size
;
5436 /* The PT_DYNAMIC segment, which is used by the run-time
5437 loader, should exactly match the .dynamic section. */
5439 && (filedata
->dynamic_addr
!= segment
->p_offset
5440 || filedata
->dynamic_size
!= segment
->p_filesz
))
5442 the .dynamic section is not the same as the dynamic segment\n"));
5445 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5446 segment. Check this after matching against the section headers
5447 so we don't warn on debuginfo file (which have NOBITS .dynamic
5449 if (filedata
->dynamic_addr
> filedata
->file_size
5450 || (filedata
->dynamic_size
5451 > filedata
->file_size
- filedata
->dynamic_addr
))
5453 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5454 filedata
->dynamic_addr
= filedata
->dynamic_size
= 0;
5459 if (fseek (filedata
->handle
,
5460 filedata
->archive_file_offset
+ (long) segment
->p_offset
,
5462 error (_("Unable to find program interpreter name\n"));
5466 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5468 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5469 error (_("Internal error: failed to create format string to display program interpreter\n"));
5471 filedata
->program_interpreter
[0] = 0;
5472 if (fscanf (filedata
->handle
, fmt
,
5473 filedata
->program_interpreter
) <= 0)
5474 error (_("Unable to read program interpreter name\n"));
5477 printf (_(" [Requesting program interpreter: %s]\n"),
5478 filedata
->program_interpreter
);
5485 && filedata
->section_headers
!= NULL
5486 && filedata
->string_table
!= NULL
)
5488 printf (_("\n Section to Segment mapping:\n"));
5489 printf (_(" Segment Sections...\n"));
5491 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5494 Elf_Internal_Shdr
* section
;
5496 segment
= filedata
->program_headers
+ i
;
5497 section
= filedata
->section_headers
+ 1;
5499 printf (" %2.2d ", i
);
5501 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5503 if (!ELF_TBSS_SPECIAL (section
, segment
)
5504 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5505 printf ("%s ", printable_section_name (filedata
, section
));
5516 /* Find the file offset corresponding to VMA by using the program headers. */
5519 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5521 Elf_Internal_Phdr
* seg
;
5523 if (! get_program_headers (filedata
))
5525 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5529 for (seg
= filedata
->program_headers
;
5530 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5533 if (seg
->p_type
!= PT_LOAD
)
5536 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5537 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5538 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5541 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5542 (unsigned long) vma
);
5547 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5548 If PROBE is true, this is just a probe and we do not generate any error
5549 messages if the load fails. */
5552 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5554 Elf32_External_Shdr
* shdrs
;
5555 Elf_Internal_Shdr
* internal
;
5557 unsigned int size
= filedata
->file_header
.e_shentsize
;
5558 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5560 /* PR binutils/17531: Cope with unexpected section header sizes. */
5561 if (size
== 0 || num
== 0)
5563 if (size
< sizeof * shdrs
)
5566 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5569 if (!probe
&& size
> sizeof * shdrs
)
5570 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5572 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5574 probe
? NULL
: _("section headers"));
5578 free (filedata
->section_headers
);
5579 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5580 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5581 if (filedata
->section_headers
== NULL
)
5584 error (_("Out of memory reading %u section headers\n"), num
);
5589 for (i
= 0, internal
= filedata
->section_headers
;
5593 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5594 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5595 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5596 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5597 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5598 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5599 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5600 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5601 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5602 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5603 if (!probe
&& internal
->sh_link
> num
)
5604 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5605 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5606 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5613 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5616 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5618 Elf64_External_Shdr
* shdrs
;
5619 Elf_Internal_Shdr
* internal
;
5621 unsigned int size
= filedata
->file_header
.e_shentsize
;
5622 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5624 /* PR binutils/17531: Cope with unexpected section header sizes. */
5625 if (size
== 0 || num
== 0)
5628 if (size
< sizeof * shdrs
)
5631 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5635 if (! probe
&& size
> sizeof * shdrs
)
5636 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5638 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5639 filedata
->file_header
.e_shoff
,
5641 probe
? NULL
: _("section headers"));
5645 free (filedata
->section_headers
);
5646 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5647 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5648 if (filedata
->section_headers
== NULL
)
5651 error (_("Out of memory reading %u section headers\n"), num
);
5656 for (i
= 0, internal
= filedata
->section_headers
;
5660 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5661 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5662 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5663 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5664 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5665 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5666 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5667 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5668 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5669 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5670 if (!probe
&& internal
->sh_link
> num
)
5671 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5672 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5673 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5680 static Elf_Internal_Sym
*
5681 get_32bit_elf_symbols (Filedata
* filedata
,
5682 Elf_Internal_Shdr
* section
,
5683 unsigned long * num_syms_return
)
5685 unsigned long number
= 0;
5686 Elf32_External_Sym
* esyms
= NULL
;
5687 Elf_External_Sym_Shndx
* shndx
= NULL
;
5688 Elf_Internal_Sym
* isyms
= NULL
;
5689 Elf_Internal_Sym
* psym
;
5691 elf_section_list
* entry
;
5693 if (section
->sh_size
== 0)
5695 if (num_syms_return
!= NULL
)
5696 * num_syms_return
= 0;
5700 /* Run some sanity checks first. */
5701 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5703 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5704 printable_section_name (filedata
, section
),
5705 (unsigned long) section
->sh_entsize
);
5709 if (section
->sh_size
> filedata
->file_size
)
5711 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5712 printable_section_name (filedata
, section
),
5713 (unsigned long) section
->sh_size
);
5717 number
= section
->sh_size
/ section
->sh_entsize
;
5719 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5721 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5722 (unsigned long) section
->sh_size
,
5723 printable_section_name (filedata
, section
),
5724 (unsigned long) section
->sh_entsize
);
5728 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5729 section
->sh_size
, _("symbols"));
5734 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5736 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5741 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5745 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5746 entry
->hdr
->sh_offset
,
5747 1, entry
->hdr
->sh_size
,
5748 _("symbol table section indices"));
5752 /* PR17531: file: heap-buffer-overflow */
5753 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5755 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5756 printable_section_name (filedata
, entry
->hdr
),
5757 (unsigned long) entry
->hdr
->sh_size
,
5758 (unsigned long) section
->sh_size
);
5763 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5767 error (_("Out of memory reading %lu symbols\n"),
5768 (unsigned long) number
);
5772 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5774 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5775 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5776 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5777 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5778 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5780 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5781 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5782 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5783 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5784 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5791 if (num_syms_return
!= NULL
)
5792 * num_syms_return
= isyms
== NULL
? 0 : number
;
5797 static Elf_Internal_Sym
*
5798 get_64bit_elf_symbols (Filedata
* filedata
,
5799 Elf_Internal_Shdr
* section
,
5800 unsigned long * num_syms_return
)
5802 unsigned long number
= 0;
5803 Elf64_External_Sym
* esyms
= NULL
;
5804 Elf_External_Sym_Shndx
* shndx
= NULL
;
5805 Elf_Internal_Sym
* isyms
= NULL
;
5806 Elf_Internal_Sym
* psym
;
5808 elf_section_list
* entry
;
5810 if (section
->sh_size
== 0)
5812 if (num_syms_return
!= NULL
)
5813 * num_syms_return
= 0;
5817 /* Run some sanity checks first. */
5818 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5820 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5821 printable_section_name (filedata
, section
),
5822 (unsigned long) section
->sh_entsize
);
5826 if (section
->sh_size
> filedata
->file_size
)
5828 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5829 printable_section_name (filedata
, section
),
5830 (unsigned long) section
->sh_size
);
5834 number
= section
->sh_size
/ section
->sh_entsize
;
5836 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5838 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5839 (unsigned long) section
->sh_size
,
5840 printable_section_name (filedata
, section
),
5841 (unsigned long) section
->sh_entsize
);
5845 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5846 section
->sh_size
, _("symbols"));
5851 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5853 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5858 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5862 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5863 entry
->hdr
->sh_offset
,
5864 1, entry
->hdr
->sh_size
,
5865 _("symbol table section indices"));
5869 /* PR17531: file: heap-buffer-overflow */
5870 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5872 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5873 printable_section_name (filedata
, entry
->hdr
),
5874 (unsigned long) entry
->hdr
->sh_size
,
5875 (unsigned long) section
->sh_size
);
5880 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5884 error (_("Out of memory reading %lu symbols\n"),
5885 (unsigned long) number
);
5889 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5891 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5892 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5893 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5894 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5896 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5898 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5899 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5900 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5902 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5903 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5910 if (num_syms_return
!= NULL
)
5911 * num_syms_return
= isyms
== NULL
? 0 : number
;
5917 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5919 static char buff
[1024];
5921 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5923 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5924 bfd_vma os_flags
= 0;
5925 bfd_vma proc_flags
= 0;
5926 bfd_vma unknown_flags
= 0;
5934 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5935 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5936 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5937 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5938 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5939 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5940 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5941 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5942 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5943 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5944 /* IA-64 specific. */
5945 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5946 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5947 /* IA-64 OpenVMS specific. */
5948 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5949 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5950 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5951 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5952 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5953 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5955 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5956 /* SPARC specific. */
5957 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5958 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5960 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5961 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5962 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5964 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5966 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5969 if (do_section_details
)
5971 sprintf (buff
, "[%*.*lx]: ",
5972 field_size
, field_size
, (unsigned long) sh_flags
);
5973 p
+= field_size
+ 4;
5980 flag
= sh_flags
& - sh_flags
;
5983 if (do_section_details
)
5987 case SHF_WRITE
: sindex
= 0; break;
5988 case SHF_ALLOC
: sindex
= 1; break;
5989 case SHF_EXECINSTR
: sindex
= 2; break;
5990 case SHF_MERGE
: sindex
= 3; break;
5991 case SHF_STRINGS
: sindex
= 4; break;
5992 case SHF_INFO_LINK
: sindex
= 5; break;
5993 case SHF_LINK_ORDER
: sindex
= 6; break;
5994 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5995 case SHF_GROUP
: sindex
= 8; break;
5996 case SHF_TLS
: sindex
= 9; break;
5997 case SHF_EXCLUDE
: sindex
= 18; break;
5998 case SHF_COMPRESSED
: sindex
= 20; break;
5999 case SHF_GNU_MBIND
: sindex
= 24; break;
6003 switch (filedata
->file_header
.e_machine
)
6006 if (flag
== SHF_IA_64_SHORT
)
6008 else if (flag
== SHF_IA_64_NORECOV
)
6011 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
6014 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
6015 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
6016 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
6017 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
6018 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
6019 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
6030 case EM_OLD_SPARCV9
:
6031 case EM_SPARC32PLUS
:
6034 if (flag
== SHF_ORDERED
)
6041 case SHF_ENTRYSECT
: sindex
= 21; break;
6042 case SHF_ARM_PURECODE
: sindex
= 22; break;
6043 case SHF_COMDEF
: sindex
= 23; break;
6048 if (flag
== SHF_PPC_VLE
)
6059 if (p
!= buff
+ field_size
+ 4)
6061 if (size
< (10 + 2))
6063 warn (_("Internal error: not enough buffer room for section flag info"));
6064 return _("<unknown>");
6071 size
-= flags
[sindex
].len
;
6072 p
= stpcpy (p
, flags
[sindex
].str
);
6074 else if (flag
& SHF_MASKOS
)
6076 else if (flag
& SHF_MASKPROC
)
6079 unknown_flags
|= flag
;
6085 case SHF_WRITE
: *p
= 'W'; break;
6086 case SHF_ALLOC
: *p
= 'A'; break;
6087 case SHF_EXECINSTR
: *p
= 'X'; break;
6088 case SHF_MERGE
: *p
= 'M'; break;
6089 case SHF_STRINGS
: *p
= 'S'; break;
6090 case SHF_INFO_LINK
: *p
= 'I'; break;
6091 case SHF_LINK_ORDER
: *p
= 'L'; break;
6092 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
6093 case SHF_GROUP
: *p
= 'G'; break;
6094 case SHF_TLS
: *p
= 'T'; break;
6095 case SHF_EXCLUDE
: *p
= 'E'; break;
6096 case SHF_COMPRESSED
: *p
= 'C'; break;
6097 case SHF_GNU_MBIND
: *p
= 'D'; break;
6100 if ((filedata
->file_header
.e_machine
== EM_X86_64
6101 || filedata
->file_header
.e_machine
== EM_L1OM
6102 || filedata
->file_header
.e_machine
== EM_K1OM
)
6103 && flag
== SHF_X86_64_LARGE
)
6105 else if (filedata
->file_header
.e_machine
== EM_ARM
6106 && flag
== SHF_ARM_PURECODE
)
6108 else if (filedata
->file_header
.e_machine
== EM_PPC
6109 && flag
== SHF_PPC_VLE
)
6111 else if (flag
& SHF_MASKOS
)
6114 sh_flags
&= ~ SHF_MASKOS
;
6116 else if (flag
& SHF_MASKPROC
)
6119 sh_flags
&= ~ SHF_MASKPROC
;
6129 if (do_section_details
)
6133 size
-= 5 + field_size
;
6134 if (p
!= buff
+ field_size
+ 4)
6138 warn (_("Internal error: not enough buffer room for section flag info"));
6139 return _("<unknown>");
6145 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6146 (unsigned long) os_flags
);
6147 p
+= 5 + field_size
;
6151 size
-= 7 + field_size
;
6152 if (p
!= buff
+ field_size
+ 4)
6156 warn (_("Internal error: not enough buffer room for section flag info"));
6157 return _("<unknown>");
6163 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6164 (unsigned long) proc_flags
);
6165 p
+= 7 + field_size
;
6169 size
-= 10 + field_size
;
6170 if (p
!= buff
+ field_size
+ 4)
6174 warn (_("Internal error: not enough buffer room for section flag info"));
6175 return _("<unknown>");
6181 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6182 (unsigned long) unknown_flags
);
6183 p
+= 10 + field_size
;
6191 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
6192 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6196 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6198 if (size
< sizeof (* echdr
))
6200 error (_("Compressed section is too small even for a compression header\n"));
6204 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6205 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6206 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6207 return sizeof (*echdr
);
6211 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6213 if (size
< sizeof (* echdr
))
6215 error (_("Compressed section is too small even for a compression header\n"));
6219 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6220 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6221 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6222 return sizeof (*echdr
);
6227 process_section_headers (Filedata
* filedata
)
6229 Elf_Internal_Shdr
* section
;
6232 free (filedata
->section_headers
);
6233 filedata
->section_headers
= NULL
;
6234 free (filedata
->dynamic_symbols
);
6235 filedata
->dynamic_symbols
= NULL
;
6236 filedata
->num_dynamic_syms
= 0;
6237 free (filedata
->dynamic_strings
);
6238 filedata
->dynamic_strings
= NULL
;
6239 filedata
->dynamic_strings_length
= 0;
6240 free (filedata
->dynamic_syminfo
);
6241 filedata
->dynamic_syminfo
= NULL
;
6242 while (filedata
->symtab_shndx_list
!= NULL
)
6244 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
6245 free (filedata
->symtab_shndx_list
);
6246 filedata
->symtab_shndx_list
= next
;
6249 if (filedata
->file_header
.e_shnum
== 0)
6251 /* PR binutils/12467. */
6252 if (filedata
->file_header
.e_shoff
!= 0)
6254 warn (_("possibly corrupt ELF file header - it has a non-zero"
6255 " section header offset, but no section headers\n"));
6258 else if (do_sections
)
6259 printf (_("\nThere are no sections in this file.\n"));
6264 if (do_sections
&& !do_header
)
6265 printf (ngettext ("There is %d section header, "
6266 "starting at offset 0x%lx:\n",
6267 "There are %d section headers, "
6268 "starting at offset 0x%lx:\n",
6269 filedata
->file_header
.e_shnum
),
6270 filedata
->file_header
.e_shnum
,
6271 (unsigned long) filedata
->file_header
.e_shoff
);
6275 if (! get_32bit_section_headers (filedata
, FALSE
))
6280 if (! get_64bit_section_headers (filedata
, FALSE
))
6284 /* Read in the string table, so that we have names to display. */
6285 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6286 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6288 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6290 if (section
->sh_size
!= 0)
6292 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6293 1, section
->sh_size
,
6296 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6300 /* Scan the sections for the dynamic symbol table
6301 and dynamic string table and debug sections. */
6302 eh_addr_size
= is_32bit_elf
? 4 : 8;
6303 switch (filedata
->file_header
.e_machine
)
6306 case EM_MIPS_RS3_LE
:
6307 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6308 FDE addresses. However, the ABI also has a semi-official ILP32
6309 variant for which the normal FDE address size rules apply.
6311 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6312 section, where XX is the size of longs in bits. Unfortunately,
6313 earlier compilers provided no way of distinguishing ILP32 objects
6314 from LP64 objects, so if there's any doubt, we should assume that
6315 the official LP64 form is being used. */
6316 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6317 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6323 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6325 case E_H8_MACH_H8300
:
6326 case E_H8_MACH_H8300HN
:
6327 case E_H8_MACH_H8300SN
:
6328 case E_H8_MACH_H8300SXN
:
6331 case E_H8_MACH_H8300H
:
6332 case E_H8_MACH_H8300S
:
6333 case E_H8_MACH_H8300SX
:
6341 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6343 case EF_M32C_CPU_M16C
:
6350 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6353 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6354 if (section->sh_entsize != expected_entsize) \
6357 sprintf_vma (buf, section->sh_entsize); \
6358 /* Note: coded this way so that there is a single string for \
6360 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6361 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6362 (unsigned) expected_entsize); \
6363 section->sh_entsize = expected_entsize; \
6368 #define CHECK_ENTSIZE(section, i, type) \
6369 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6370 sizeof (Elf64_External_##type))
6372 for (i
= 0, section
= filedata
->section_headers
;
6373 i
< filedata
->file_header
.e_shnum
;
6376 char * name
= SECTION_NAME (section
);
6378 /* Run some sanity checks on the headers and
6379 possibly fill in some file data as well. */
6380 switch (section
->sh_type
)
6383 if (filedata
->dynamic_symbols
!= NULL
)
6385 error (_("File contains multiple dynamic symbol tables\n"));
6389 CHECK_ENTSIZE (section
, i
, Sym
);
6390 filedata
->dynamic_symbols
6391 = GET_ELF_SYMBOLS (filedata
, section
, &filedata
->num_dynamic_syms
);
6392 filedata
->dynamic_symtab_section
= section
;
6396 if (streq (name
, ".dynstr"))
6398 if (filedata
->dynamic_strings
!= NULL
)
6400 error (_("File contains multiple dynamic string tables\n"));
6404 filedata
->dynamic_strings
6405 = (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6406 1, section
->sh_size
, _("dynamic strings"));
6407 filedata
->dynamic_strings_length
6408 = filedata
->dynamic_strings
== NULL
? 0 : section
->sh_size
;
6409 filedata
->dynamic_strtab_section
= section
;
6413 case SHT_SYMTAB_SHNDX
:
6415 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6417 entry
->hdr
= section
;
6418 entry
->next
= filedata
->symtab_shndx_list
;
6419 filedata
->symtab_shndx_list
= entry
;
6424 CHECK_ENTSIZE (section
, i
, Sym
);
6428 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6432 CHECK_ENTSIZE (section
, i
, Rel
);
6433 if (do_checks
&& section
->sh_size
== 0)
6434 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6438 CHECK_ENTSIZE (section
, i
, Rela
);
6439 if (do_checks
&& section
->sh_size
== 0)
6440 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6445 /* Having a zero sized section is not illegal according to the
6446 ELF standard, but it might be an indication that something
6447 is wrong. So issue a warning if we are running in lint mode. */
6448 if (do_checks
&& section
->sh_size
== 0)
6449 warn (_("Section '%s': has a size of zero - is this intended ?\n"), name
);
6456 if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6457 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6458 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6459 || do_debug_str
|| do_debug_str_offsets
|| do_debug_loc
|| do_debug_ranges
6460 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6461 && (const_strneq (name
, ".debug_")
6462 || const_strneq (name
, ".zdebug_")))
6465 name
+= sizeof (".zdebug_") - 1;
6467 name
+= sizeof (".debug_") - 1;
6470 || (do_debug_info
&& const_strneq (name
, "info"))
6471 || (do_debug_info
&& const_strneq (name
, "types"))
6472 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6473 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6474 || (do_debug_lines
&& const_strneq (name
, "line."))
6475 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6476 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6477 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6478 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6479 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6480 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6481 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6482 || (do_debug_frames
&& const_strneq (name
, "frame"))
6483 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6484 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6485 || (do_debug_str
&& const_strneq (name
, "str"))
6486 || (do_debug_str_offsets
&& const_strneq (name
, "str_offsets"))
6487 || (do_debug_loc
&& const_strneq (name
, "loc"))
6488 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6489 || (do_debug_addr
&& const_strneq (name
, "addr"))
6490 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6491 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6493 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6495 /* Linkonce section to be combined with .debug_info at link time. */
6496 else if ((do_debugging
|| do_debug_info
)
6497 && const_strneq (name
, ".gnu.linkonce.wi."))
6498 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6499 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6500 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6501 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6502 || streq (name
, ".debug_names")))
6503 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6504 /* Trace sections for Itanium VMS. */
6505 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6506 || do_trace_aranges
)
6507 && const_strneq (name
, ".trace_"))
6509 name
+= sizeof (".trace_") - 1;
6512 || (do_trace_info
&& streq (name
, "info"))
6513 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6514 || (do_trace_aranges
&& streq (name
, "aranges"))
6516 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6518 else if ((do_debugging
|| do_debug_links
)
6519 && (const_strneq (name
, ".gnu_debuglink")
6520 || const_strneq (name
, ".gnu_debugaltlink")))
6521 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6527 if (filedata
->file_header
.e_shnum
> 1)
6528 printf (_("\nSection Headers:\n"));
6530 printf (_("\nSection Header:\n"));
6534 if (do_section_details
)
6536 printf (_(" [Nr] Name\n"));
6537 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6541 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6545 if (do_section_details
)
6547 printf (_(" [Nr] Name\n"));
6548 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6552 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6556 if (do_section_details
)
6558 printf (_(" [Nr] Name\n"));
6559 printf (_(" Type Address Offset Link\n"));
6560 printf (_(" Size EntSize Info Align\n"));
6564 printf (_(" [Nr] Name Type Address Offset\n"));
6565 printf (_(" Size EntSize Flags Link Info Align\n"));
6569 if (do_section_details
)
6570 printf (_(" Flags\n"));
6572 for (i
= 0, section
= filedata
->section_headers
;
6573 i
< filedata
->file_header
.e_shnum
;
6576 /* Run some sanity checks on the section header. */
6578 /* Check the sh_link field. */
6579 switch (section
->sh_type
)
6583 if (section
->sh_link
== 0
6584 && (filedata
->file_header
.e_type
== ET_EXEC
6585 || filedata
->file_header
.e_type
== ET_DYN
))
6586 /* A dynamic relocation section where all entries use a
6587 zero symbol index need not specify a symtab section. */
6590 case SHT_SYMTAB_SHNDX
:
6594 case SHT_GNU_versym
:
6595 if (section
->sh_link
== 0
6596 || section
->sh_link
>= filedata
->file_header
.e_shnum
6597 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6598 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6599 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6600 i
, section
->sh_link
);
6606 case SHT_GNU_verneed
:
6607 case SHT_GNU_verdef
:
6608 case SHT_GNU_LIBLIST
:
6609 if (section
->sh_link
== 0
6610 || section
->sh_link
>= filedata
->file_header
.e_shnum
6611 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6612 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6613 i
, section
->sh_link
);
6616 case SHT_INIT_ARRAY
:
6617 case SHT_FINI_ARRAY
:
6618 case SHT_PREINIT_ARRAY
:
6619 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6620 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6621 i
, section
->sh_link
);
6625 /* FIXME: Add support for target specific section types. */
6626 #if 0 /* Currently we do not check other section types as there are too
6627 many special cases. Stab sections for example have a type
6628 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6630 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6631 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6632 i
, section
->sh_link
);
6637 /* Check the sh_info field. */
6638 switch (section
->sh_type
)
6642 if (section
->sh_info
== 0
6643 && (filedata
->file_header
.e_type
== ET_EXEC
6644 || filedata
->file_header
.e_type
== ET_DYN
))
6645 /* Dynamic relocations apply to segments, so they do not
6646 need to specify the section they relocate. */
6648 if (section
->sh_info
== 0
6649 || section
->sh_info
>= filedata
->file_header
.e_shnum
6650 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6651 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6652 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6653 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6654 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6655 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6656 /* FIXME: Are other section types valid ? */
6657 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6658 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6659 i
, section
->sh_info
);
6664 case SHT_SYMTAB_SHNDX
:
6665 case SHT_INIT_ARRAY
:
6666 case SHT_FINI_ARRAY
:
6667 case SHT_PREINIT_ARRAY
:
6668 if (section
->sh_info
!= 0)
6669 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6670 i
, section
->sh_info
);
6676 /* A symbol index - we assume that it is valid. */
6680 /* FIXME: Add support for target specific section types. */
6681 if (section
->sh_type
== SHT_NOBITS
)
6682 /* NOBITS section headers with non-zero sh_info fields can be
6683 created when a binary is stripped of everything but its debug
6684 information. The stripped sections have their headers
6685 preserved but their types set to SHT_NOBITS. So do not check
6686 this type of section. */
6688 else if (section
->sh_flags
& SHF_INFO_LINK
)
6690 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6691 warn (_("[%2u]: Expected link to another section in info field"), i
);
6693 else if (section
->sh_type
< SHT_LOOS
6694 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6695 && section
->sh_info
!= 0)
6696 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6697 i
, section
->sh_info
);
6701 /* Check the sh_size field. */
6702 if (section
->sh_size
> filedata
->file_size
6703 && section
->sh_type
!= SHT_NOBITS
6704 && section
->sh_type
!= SHT_NULL
6705 && section
->sh_type
< SHT_LOOS
)
6706 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6708 printf (" [%2u] ", i
);
6709 if (do_section_details
)
6710 printf ("%s\n ", printable_section_name (filedata
, section
));
6712 print_symbol (-17, SECTION_NAME (section
));
6714 printf (do_wide
? " %-15s " : " %-15.15s ",
6715 get_section_type_name (filedata
, section
->sh_type
));
6719 const char * link_too_big
= NULL
;
6721 print_vma (section
->sh_addr
, LONG_HEX
);
6723 printf ( " %6.6lx %6.6lx %2.2lx",
6724 (unsigned long) section
->sh_offset
,
6725 (unsigned long) section
->sh_size
,
6726 (unsigned long) section
->sh_entsize
);
6728 if (do_section_details
)
6729 fputs (" ", stdout
);
6731 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6733 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6736 /* The sh_link value is out of range. Normally this indicates
6737 an error but it can have special values in Solaris binaries. */
6738 switch (filedata
->file_header
.e_machine
)
6745 case EM_OLD_SPARCV9
:
6746 case EM_SPARC32PLUS
:
6749 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6750 link_too_big
= "BEFORE";
6751 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6752 link_too_big
= "AFTER";
6759 if (do_section_details
)
6761 if (link_too_big
!= NULL
&& * link_too_big
)
6762 printf ("<%s> ", link_too_big
);
6764 printf ("%2u ", section
->sh_link
);
6765 printf ("%3u %2lu\n", section
->sh_info
,
6766 (unsigned long) section
->sh_addralign
);
6769 printf ("%2u %3u %2lu\n",
6772 (unsigned long) section
->sh_addralign
);
6774 if (link_too_big
&& ! * link_too_big
)
6775 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6776 i
, section
->sh_link
);
6780 print_vma (section
->sh_addr
, LONG_HEX
);
6782 if ((long) section
->sh_offset
== section
->sh_offset
)
6783 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6787 print_vma (section
->sh_offset
, LONG_HEX
);
6790 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6791 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6795 print_vma (section
->sh_size
, LONG_HEX
);
6798 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6799 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6803 print_vma (section
->sh_entsize
, LONG_HEX
);
6806 if (do_section_details
)
6807 fputs (" ", stdout
);
6809 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6811 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6813 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6814 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6817 print_vma (section
->sh_addralign
, DEC
);
6821 else if (do_section_details
)
6824 print_vma (section
->sh_addr
, LONG_HEX
);
6825 if ((long) section
->sh_offset
== section
->sh_offset
)
6826 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6830 print_vma (section
->sh_offset
, LONG_HEX
);
6832 printf (" %u\n ", section
->sh_link
);
6833 print_vma (section
->sh_size
, LONG_HEX
);
6835 print_vma (section
->sh_entsize
, LONG_HEX
);
6837 printf (" %-16u %lu\n",
6839 (unsigned long) section
->sh_addralign
);
6844 print_vma (section
->sh_addr
, LONG_HEX
);
6845 if ((long) section
->sh_offset
== section
->sh_offset
)
6846 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6850 print_vma (section
->sh_offset
, LONG_HEX
);
6853 print_vma (section
->sh_size
, LONG_HEX
);
6855 print_vma (section
->sh_entsize
, LONG_HEX
);
6857 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6859 printf (" %2u %3u %lu\n",
6862 (unsigned long) section
->sh_addralign
);
6865 if (do_section_details
)
6867 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6868 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6870 /* Minimum section size is 12 bytes for 32-bit compression
6871 header + 12 bytes for compressed data header. */
6872 unsigned char buf
[24];
6874 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6875 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6876 sizeof (buf
), _("compression header")))
6878 Elf_Internal_Chdr chdr
;
6880 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
6881 printf (_(" [<corrupt>]\n"));
6884 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6887 printf (_(" [<unknown>: 0x%x], "),
6889 print_vma (chdr
.ch_size
, LONG_HEX
);
6890 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6897 if (!do_section_details
)
6899 /* The ordering of the letters shown here matches the ordering of the
6900 corresponding SHF_xxx values, and hence the order in which these
6901 letters will be displayed to the user. */
6902 printf (_("Key to Flags:\n\
6903 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6904 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6905 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6906 if (filedata
->file_header
.e_machine
== EM_X86_64
6907 || filedata
->file_header
.e_machine
== EM_L1OM
6908 || filedata
->file_header
.e_machine
== EM_K1OM
)
6909 printf (_("l (large), "));
6910 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6911 printf (_("y (purecode), "));
6912 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6913 printf (_("v (VLE), "));
6914 printf ("p (processor specific)\n");
6921 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
6922 Elf_Internal_Sym
**symtab
, unsigned long *nsyms
,
6923 char **strtab
, unsigned long *strtablen
)
6927 *symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, nsyms
);
6929 if (*symtab
== NULL
)
6932 if (symsec
->sh_link
!= 0)
6934 Elf_Internal_Shdr
*strsec
;
6936 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
6938 error (_("Bad sh_link in symbol table section\n"));
6945 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
6947 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
6948 1, strsec
->sh_size
, _("string table"));
6949 if (*strtab
== NULL
)
6956 *strtablen
= strsec
->sh_size
;
6962 get_group_flags (unsigned int flags
)
6964 static char buff
[128];
6968 else if (flags
== GRP_COMDAT
)
6971 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
6973 flags
& GRP_MASKOS
? _("<OS specific>") : "",
6974 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
6975 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
6976 ? _("<unknown>") : ""));
6982 process_section_groups (Filedata
* filedata
)
6984 Elf_Internal_Shdr
* section
;
6986 struct group
* group
;
6987 Elf_Internal_Shdr
* symtab_sec
;
6988 Elf_Internal_Shdr
* strtab_sec
;
6989 Elf_Internal_Sym
* symtab
;
6990 unsigned long num_syms
;
6994 /* Don't process section groups unless needed. */
6995 if (!do_unwind
&& !do_section_groups
)
6998 if (filedata
->file_header
.e_shnum
== 0)
7000 if (do_section_groups
)
7001 printf (_("\nThere are no sections to group in this file.\n"));
7006 if (filedata
->section_headers
== NULL
)
7008 error (_("Section headers are not available!\n"));
7009 /* PR 13622: This can happen with a corrupt ELF header. */
7013 filedata
->section_headers_groups
7014 = (struct group
**) calloc (filedata
->file_header
.e_shnum
,
7015 sizeof (struct group
*));
7017 if (filedata
->section_headers_groups
== NULL
)
7019 error (_("Out of memory reading %u section group headers\n"),
7020 filedata
->file_header
.e_shnum
);
7024 /* Scan the sections for the group section. */
7025 filedata
->group_count
= 0;
7026 for (i
= 0, section
= filedata
->section_headers
;
7027 i
< filedata
->file_header
.e_shnum
;
7029 if (section
->sh_type
== SHT_GROUP
)
7030 filedata
->group_count
++;
7032 if (filedata
->group_count
== 0)
7034 if (do_section_groups
)
7035 printf (_("\nThere are no section groups in this file.\n"));
7040 filedata
->section_groups
= (struct group
*) calloc (filedata
->group_count
,
7041 sizeof (struct group
));
7043 if (filedata
->section_groups
== NULL
)
7045 error (_("Out of memory reading %lu groups\n"),
7046 (unsigned long) filedata
->group_count
);
7056 for (i
= 0, section
= filedata
->section_headers
, group
= filedata
->section_groups
;
7057 i
< filedata
->file_header
.e_shnum
;
7060 if (section
->sh_type
== SHT_GROUP
)
7062 const char * name
= printable_section_name (filedata
, section
);
7063 const char * group_name
;
7064 unsigned char * start
;
7065 unsigned char * indices
;
7066 unsigned int entry
, j
, size
;
7067 Elf_Internal_Shdr
* sec
;
7068 Elf_Internal_Sym
* sym
;
7070 /* Get the symbol table. */
7071 if (section
->sh_link
>= filedata
->file_header
.e_shnum
7072 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
7075 error (_("Bad sh_link in group section `%s'\n"), name
);
7079 if (symtab_sec
!= sec
)
7083 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
7088 error (_("Corrupt header in group section `%s'\n"), name
);
7092 if (section
->sh_info
>= num_syms
)
7094 error (_("Bad sh_info in group section `%s'\n"), name
);
7098 sym
= symtab
+ section
->sh_info
;
7100 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
7102 if (sym
->st_shndx
== 0
7103 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
7105 error (_("Bad sh_info in group section `%s'\n"), name
);
7109 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
7117 /* Get the string table. */
7118 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
7126 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
7131 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
7132 1, strtab_sec
->sh_size
,
7134 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
7136 group_name
= sym
->st_name
< strtab_size
7137 ? strtab
+ sym
->st_name
: _("<corrupt>");
7140 /* PR 17531: file: loop. */
7141 if (section
->sh_entsize
> section
->sh_size
)
7143 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7144 printable_section_name (filedata
, section
),
7145 (unsigned long) section
->sh_entsize
,
7146 (unsigned long) section
->sh_size
);
7150 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
7151 1, section
->sh_size
,
7157 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
7158 entry
= byte_get (indices
, 4);
7161 if (do_section_groups
)
7163 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7164 get_group_flags (entry
), i
, name
, group_name
, size
);
7166 printf (_(" [Index] Name\n"));
7169 group
->group_index
= i
;
7171 for (j
= 0; j
< size
; j
++)
7173 struct group_list
* g
;
7175 entry
= byte_get (indices
, 4);
7178 if (entry
>= filedata
->file_header
.e_shnum
)
7180 static unsigned num_group_errors
= 0;
7182 if (num_group_errors
++ < 10)
7184 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7185 entry
, i
, filedata
->file_header
.e_shnum
- 1);
7186 if (num_group_errors
== 10)
7187 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7192 if (filedata
->section_headers_groups
[entry
] != NULL
)
7196 static unsigned num_errs
= 0;
7198 if (num_errs
++ < 10)
7200 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7202 filedata
->section_headers_groups
[entry
]->group_index
);
7204 warn (_("Further error messages about already contained group sections suppressed\n"));
7210 /* Intel C/C++ compiler may put section 0 in a
7211 section group. We just warn it the first time
7212 and ignore it afterwards. */
7213 static bfd_boolean warned
= FALSE
;
7216 error (_("section 0 in group section [%5u]\n"),
7217 filedata
->section_headers_groups
[entry
]->group_index
);
7223 filedata
->section_headers_groups
[entry
] = group
;
7225 if (do_section_groups
)
7227 sec
= filedata
->section_headers
+ entry
;
7228 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7231 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7232 g
->section_index
= entry
;
7233 g
->next
= group
->root
;
7248 /* Data used to display dynamic fixups. */
7250 struct ia64_vms_dynfixup
7252 bfd_vma needed_ident
; /* Library ident number. */
7253 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7254 bfd_vma fixup_needed
; /* Index of the library. */
7255 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7256 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7259 /* Data used to display dynamic relocations. */
7261 struct ia64_vms_dynimgrela
7263 bfd_vma img_rela_cnt
; /* Number of relocations. */
7264 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7267 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7271 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7272 struct ia64_vms_dynfixup
* fixup
,
7273 const char * strtab
,
7274 unsigned int strtab_sz
)
7276 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7278 const char * lib_name
;
7280 imfs
= get_data (NULL
, filedata
,
7281 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
7282 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
7283 _("dynamic section image fixups"));
7287 if (fixup
->needed
< strtab_sz
)
7288 lib_name
= strtab
+ fixup
->needed
;
7291 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7292 (unsigned long) fixup
->needed
);
7296 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7297 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7299 (_("Seg Offset Type SymVec DataType\n"));
7301 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7306 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7307 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7308 type
= BYTE_GET (imfs
[i
].type
);
7309 rtype
= elf_ia64_reloc_type (type
);
7311 printf (" 0x%08x ", type
);
7313 printf (" %-32s ", rtype
);
7314 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7315 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7322 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7325 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7327 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7330 imrs
= get_data (NULL
, filedata
,
7331 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
7332 sizeof (*imrs
), imgrela
->img_rela_cnt
,
7333 _("dynamic section image relocations"));
7337 printf (_("\nImage relocs\n"));
7339 (_("Seg Offset Type Addend Seg Sym Off\n"));
7341 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7346 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7347 printf ("%08" BFD_VMA_FMT
"x ",
7348 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7349 type
= BYTE_GET (imrs
[i
].type
);
7350 rtype
= elf_ia64_reloc_type (type
);
7352 printf ("0x%08x ", type
);
7354 printf ("%-31s ", rtype
);
7355 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7356 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7357 printf ("%08" BFD_VMA_FMT
"x\n",
7358 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7365 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7368 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7370 struct ia64_vms_dynfixup fixup
;
7371 struct ia64_vms_dynimgrela imgrela
;
7372 Elf_Internal_Dyn
*entry
;
7373 bfd_vma strtab_off
= 0;
7374 bfd_vma strtab_sz
= 0;
7375 char *strtab
= NULL
;
7376 bfd_boolean res
= TRUE
;
7378 memset (&fixup
, 0, sizeof (fixup
));
7379 memset (&imgrela
, 0, sizeof (imgrela
));
7381 /* Note: the order of the entries is specified by the OpenVMS specs. */
7382 for (entry
= filedata
->dynamic_section
;
7383 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
7386 switch (entry
->d_tag
)
7388 case DT_IA_64_VMS_STRTAB_OFFSET
:
7389 strtab_off
= entry
->d_un
.d_val
;
7392 strtab_sz
= entry
->d_un
.d_val
;
7394 strtab
= get_data (NULL
, filedata
,
7395 filedata
->dynamic_addr
+ strtab_off
,
7396 1, strtab_sz
, _("dynamic string section"));
7401 case DT_IA_64_VMS_NEEDED_IDENT
:
7402 fixup
.needed_ident
= entry
->d_un
.d_val
;
7405 fixup
.needed
= entry
->d_un
.d_val
;
7407 case DT_IA_64_VMS_FIXUP_NEEDED
:
7408 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7410 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7411 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7413 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7414 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7415 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7418 case DT_IA_64_VMS_IMG_RELA_CNT
:
7419 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7421 case DT_IA_64_VMS_IMG_RELA_OFF
:
7422 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7423 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7444 dynamic_relocations
[] =
7446 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7447 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7448 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7451 /* Process the reloc section. */
7454 process_relocs (Filedata
* filedata
)
7456 unsigned long rel_size
;
7457 unsigned long rel_offset
;
7462 if (do_using_dynamic
)
7466 bfd_boolean has_dynamic_reloc
;
7469 has_dynamic_reloc
= FALSE
;
7471 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7473 is_rela
= dynamic_relocations
[i
].rela
;
7474 name
= dynamic_relocations
[i
].name
;
7475 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
7476 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
7479 has_dynamic_reloc
= TRUE
;
7481 if (is_rela
== UNKNOWN
)
7483 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7484 switch (filedata
->dynamic_info
[DT_PLTREL
])
7498 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7499 name
, rel_offset
, rel_size
);
7501 dump_relocations (filedata
,
7502 offset_from_vma (filedata
, rel_offset
, rel_size
),
7504 filedata
->dynamic_symbols
,
7505 filedata
->num_dynamic_syms
,
7506 filedata
->dynamic_strings
,
7507 filedata
->dynamic_strings_length
,
7508 is_rela
, TRUE
/* is_dynamic */);
7512 if (is_ia64_vms (filedata
))
7513 if (process_ia64_vms_dynamic_relocs (filedata
))
7514 has_dynamic_reloc
= TRUE
;
7516 if (! has_dynamic_reloc
)
7517 printf (_("\nThere are no dynamic relocations in this file.\n"));
7521 Elf_Internal_Shdr
* section
;
7523 bfd_boolean found
= FALSE
;
7525 for (i
= 0, section
= filedata
->section_headers
;
7526 i
< filedata
->file_header
.e_shnum
;
7529 if ( section
->sh_type
!= SHT_RELA
7530 && section
->sh_type
!= SHT_REL
)
7533 rel_offset
= section
->sh_offset
;
7534 rel_size
= section
->sh_size
;
7539 unsigned long num_rela
;
7541 printf (_("\nRelocation section "));
7543 if (filedata
->string_table
== NULL
)
7544 printf ("%d", section
->sh_name
);
7546 printf ("'%s'", printable_section_name (filedata
, section
));
7548 num_rela
= rel_size
/ section
->sh_entsize
;
7549 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7550 " at offset 0x%lx contains %lu entries:\n",
7552 rel_offset
, num_rela
);
7554 is_rela
= section
->sh_type
== SHT_RELA
;
7556 if (section
->sh_link
!= 0
7557 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7559 Elf_Internal_Shdr
* symsec
;
7560 Elf_Internal_Sym
* symtab
;
7561 unsigned long nsyms
;
7562 unsigned long strtablen
= 0;
7563 char * strtab
= NULL
;
7565 symsec
= filedata
->section_headers
+ section
->sh_link
;
7566 if (symsec
->sh_type
!= SHT_SYMTAB
7567 && symsec
->sh_type
!= SHT_DYNSYM
)
7570 if (!get_symtab (filedata
, symsec
,
7571 &symtab
, &nsyms
, &strtab
, &strtablen
))
7574 dump_relocations (filedata
, rel_offset
, rel_size
,
7575 symtab
, nsyms
, strtab
, strtablen
,
7577 symsec
->sh_type
== SHT_DYNSYM
);
7582 dump_relocations (filedata
, rel_offset
, rel_size
,
7583 NULL
, 0, NULL
, 0, is_rela
,
7584 FALSE
/* is_dynamic */);
7592 /* Users sometimes forget the -D option, so try to be helpful. */
7593 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7595 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
7597 printf (_("\nThere are no static relocations in this file."));
7598 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7603 if (i
== ARRAY_SIZE (dynamic_relocations
))
7604 printf (_("\nThere are no relocations in this file.\n"));
7611 /* An absolute address consists of a section and an offset. If the
7612 section is NULL, the offset itself is the address, otherwise, the
7613 address equals to LOAD_ADDRESS(section) + offset. */
7617 unsigned short section
;
7621 /* Find the nearest symbol at or below ADDR. Returns the symbol
7622 name, if found, and the offset from the symbol to ADDR. */
7625 find_symbol_for_address (Filedata
* filedata
,
7626 Elf_Internal_Sym
* symtab
,
7627 unsigned long nsyms
,
7628 const char * strtab
,
7629 unsigned long strtab_size
,
7630 struct absaddr addr
,
7631 const char ** symname
,
7634 bfd_vma dist
= 0x100000;
7635 Elf_Internal_Sym
* sym
;
7636 Elf_Internal_Sym
* beg
;
7637 Elf_Internal_Sym
* end
;
7638 Elf_Internal_Sym
* best
= NULL
;
7640 REMOVE_ARCH_BITS (addr
.offset
);
7642 end
= symtab
+ nsyms
;
7648 sym
= beg
+ (end
- beg
) / 2;
7650 value
= sym
->st_value
;
7651 REMOVE_ARCH_BITS (value
);
7653 if (sym
->st_name
!= 0
7654 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7655 && addr
.offset
>= value
7656 && addr
.offset
- value
< dist
)
7659 dist
= addr
.offset
- value
;
7664 if (addr
.offset
< value
)
7672 *symname
= (best
->st_name
>= strtab_size
7673 ? _("<corrupt>") : strtab
+ best
->st_name
);
7679 *offset
= addr
.offset
;
7682 static /* signed */ int
7683 symcmp (const void *p
, const void *q
)
7685 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7686 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7688 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7691 /* Process the unwind section. */
7693 #include "unwind-ia64.h"
7695 struct ia64_unw_table_entry
7697 struct absaddr start
;
7699 struct absaddr info
;
7702 struct ia64_unw_aux_info
7704 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7705 unsigned long table_len
; /* Length of unwind table. */
7706 unsigned char * info
; /* Unwind info. */
7707 unsigned long info_size
; /* Size of unwind info. */
7708 bfd_vma info_addr
; /* Starting address of unwind info. */
7709 bfd_vma seg_base
; /* Starting address of segment. */
7710 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7711 unsigned long nsyms
; /* Number of symbols. */
7712 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7713 unsigned long nfuns
; /* Number of entries in funtab. */
7714 char * strtab
; /* The string table. */
7715 unsigned long strtab_size
; /* Size of string table. */
7719 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7721 struct ia64_unw_table_entry
* tp
;
7722 unsigned long j
, nfuns
;
7724 bfd_boolean res
= TRUE
;
7726 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7727 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7728 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7729 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7731 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7733 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7737 const unsigned char * dp
;
7738 const unsigned char * head
;
7739 const unsigned char * end
;
7740 const char * procname
;
7742 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7743 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7745 fputs ("\n<", stdout
);
7749 fputs (procname
, stdout
);
7752 printf ("+%lx", (unsigned long) offset
);
7755 fputs (">: [", stdout
);
7756 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7757 fputc ('-', stdout
);
7758 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7759 printf ("], info at +0x%lx\n",
7760 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7762 /* PR 17531: file: 86232b32. */
7763 if (aux
->info
== NULL
)
7766 offset
= tp
->info
.offset
;
7767 if (tp
->info
.section
)
7769 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
7771 warn (_("Invalid section %u in table entry %ld\n"),
7772 tp
->info
.section
, (long) (tp
- aux
->table
));
7776 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
7778 offset
-= aux
->info_addr
;
7779 /* PR 17531: file: 0997b4d1. */
7780 if (offset
>= aux
->info_size
7781 || aux
->info_size
- offset
< 8)
7783 warn (_("Invalid offset %lx in table entry %ld\n"),
7784 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7789 head
= aux
->info
+ offset
;
7790 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7792 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7793 (unsigned) UNW_VER (stamp
),
7794 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7795 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7796 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7797 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7799 if (UNW_VER (stamp
) != 1)
7801 printf (_("\tUnknown version.\n"));
7806 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7807 /* PR 17531: file: 16ceda89. */
7808 if (end
> aux
->info
+ aux
->info_size
)
7809 end
= aux
->info
+ aux
->info_size
;
7810 for (dp
= head
+ 8; dp
< end
;)
7811 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7820 slurp_ia64_unwind_table (Filedata
* filedata
,
7821 struct ia64_unw_aux_info
* aux
,
7822 Elf_Internal_Shdr
* sec
)
7824 unsigned long size
, nrelas
, i
;
7825 Elf_Internal_Phdr
* seg
;
7826 struct ia64_unw_table_entry
* tep
;
7827 Elf_Internal_Shdr
* relsec
;
7828 Elf_Internal_Rela
* rela
;
7829 Elf_Internal_Rela
* rp
;
7830 unsigned char * table
;
7832 Elf_Internal_Sym
* sym
;
7833 const char * relname
;
7837 /* First, find the starting address of the segment that includes
7840 if (filedata
->file_header
.e_phnum
)
7842 if (! get_program_headers (filedata
))
7845 for (seg
= filedata
->program_headers
;
7846 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7849 if (seg
->p_type
!= PT_LOAD
)
7852 if (sec
->sh_addr
>= seg
->p_vaddr
7853 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7855 aux
->seg_base
= seg
->p_vaddr
;
7861 /* Second, build the unwind table from the contents of the unwind section: */
7862 size
= sec
->sh_size
;
7863 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7868 aux
->table_len
= size
/ (3 * eh_addr_size
);
7869 aux
->table
= (struct ia64_unw_table_entry
*)
7870 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7873 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7875 tep
->start
.section
= SHN_UNDEF
;
7876 tep
->end
.section
= SHN_UNDEF
;
7877 tep
->info
.section
= SHN_UNDEF
;
7878 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7879 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7880 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7881 tep
->start
.offset
+= aux
->seg_base
;
7882 tep
->end
.offset
+= aux
->seg_base
;
7883 tep
->info
.offset
+= aux
->seg_base
;
7887 /* Third, apply any relocations to the unwind table: */
7888 for (relsec
= filedata
->section_headers
;
7889 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7892 if (relsec
->sh_type
!= SHT_RELA
7893 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7894 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7897 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7906 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7908 unsigned int sym_ndx
;
7909 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7910 relname
= elf_ia64_reloc_type (r_type
);
7912 /* PR 17531: file: 9fa67536. */
7913 if (relname
== NULL
)
7915 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
7919 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7921 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7925 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7927 /* PR 17531: file: 5bc8d9bf. */
7928 if (i
>= aux
->table_len
)
7930 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7934 sym_ndx
= get_reloc_symindex (rp
->r_info
);
7935 if (sym_ndx
>= aux
->nsyms
)
7937 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7941 sym
= aux
->symtab
+ sym_ndx
;
7943 switch (rp
->r_offset
/ eh_addr_size
% 3)
7946 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7947 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7950 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7951 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7954 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7955 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7969 ia64_process_unwind (Filedata
* filedata
)
7971 Elf_Internal_Shdr
* sec
;
7972 Elf_Internal_Shdr
* unwsec
= NULL
;
7973 unsigned long i
, unwcount
= 0, unwstart
= 0;
7974 struct ia64_unw_aux_info aux
;
7975 bfd_boolean res
= TRUE
;
7977 memset (& aux
, 0, sizeof (aux
));
7979 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7981 if (sec
->sh_type
== SHT_SYMTAB
)
7985 error (_("Multiple symbol tables encountered\n"));
7991 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
7992 &aux
.strtab
, &aux
.strtab_size
))
7995 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8000 printf (_("\nThere are no unwind sections in this file.\n"));
8002 while (unwcount
-- > 0)
8007 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
8008 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8009 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8014 /* We have already counted the number of SHT_IA64_UNWIND
8015 sections so the loop above should never fail. */
8016 assert (unwsec
!= NULL
);
8019 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
8021 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
8023 /* We need to find which section group it is in. */
8024 struct group_list
* g
;
8026 if (filedata
->section_headers_groups
== NULL
8027 || filedata
->section_headers_groups
[i
] == NULL
)
8028 i
= filedata
->file_header
.e_shnum
;
8031 g
= filedata
->section_headers_groups
[i
]->root
;
8033 for (; g
!= NULL
; g
= g
->next
)
8035 sec
= filedata
->section_headers
+ g
->section_index
;
8037 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
8042 i
= filedata
->file_header
.e_shnum
;
8045 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
8047 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
8048 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
8049 suffix
= SECTION_NAME (unwsec
) + len
;
8050 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
8052 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
8053 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8058 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
8059 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
8060 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
8061 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
8063 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
8064 suffix
= SECTION_NAME (unwsec
) + len
;
8065 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
8067 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
8068 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8072 if (i
== filedata
->file_header
.e_shnum
)
8074 printf (_("\nCould not find unwind info section for "));
8076 if (filedata
->string_table
== NULL
)
8077 printf ("%d", unwsec
->sh_name
);
8079 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8083 aux
.info_addr
= sec
->sh_addr
;
8084 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
8087 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
8089 printf (_("\nUnwind section "));
8091 if (filedata
->string_table
== NULL
)
8092 printf ("%d", unwsec
->sh_name
);
8094 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8096 printf (_(" at offset 0x%lx contains %lu entries:\n"),
8097 (unsigned long) unwsec
->sh_offset
,
8098 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
8100 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
8101 && aux
.table_len
> 0)
8102 dump_ia64_unwind (filedata
, & aux
);
8104 free ((char *) aux
.table
);
8105 free ((char *) aux
.info
);
8112 free ((char *) aux
.strtab
);
8117 struct hppa_unw_table_entry
8119 struct absaddr start
;
8121 unsigned int Cannot_unwind
:1; /* 0 */
8122 unsigned int Millicode
:1; /* 1 */
8123 unsigned int Millicode_save_sr0
:1; /* 2 */
8124 unsigned int Region_description
:2; /* 3..4 */
8125 unsigned int reserved1
:1; /* 5 */
8126 unsigned int Entry_SR
:1; /* 6 */
8127 unsigned int Entry_FR
:4; /* Number saved 7..10 */
8128 unsigned int Entry_GR
:5; /* Number saved 11..15 */
8129 unsigned int Args_stored
:1; /* 16 */
8130 unsigned int Variable_Frame
:1; /* 17 */
8131 unsigned int Separate_Package_Body
:1; /* 18 */
8132 unsigned int Frame_Extension_Millicode
:1; /* 19 */
8133 unsigned int Stack_Overflow_Check
:1; /* 20 */
8134 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
8135 unsigned int Ada_Region
:1; /* 22 */
8136 unsigned int cxx_info
:1; /* 23 */
8137 unsigned int cxx_try_catch
:1; /* 24 */
8138 unsigned int sched_entry_seq
:1; /* 25 */
8139 unsigned int reserved2
:1; /* 26 */
8140 unsigned int Save_SP
:1; /* 27 */
8141 unsigned int Save_RP
:1; /* 28 */
8142 unsigned int Save_MRP_in_frame
:1; /* 29 */
8143 unsigned int extn_ptr_defined
:1; /* 30 */
8144 unsigned int Cleanup_defined
:1; /* 31 */
8146 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
8147 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
8148 unsigned int Large_frame
:1; /* 2 */
8149 unsigned int Pseudo_SP_Set
:1; /* 3 */
8150 unsigned int reserved4
:1; /* 4 */
8151 unsigned int Total_frame_size
:27; /* 5..31 */
8154 struct hppa_unw_aux_info
8156 struct hppa_unw_table_entry
* table
; /* Unwind table. */
8157 unsigned long table_len
; /* Length of unwind table. */
8158 bfd_vma seg_base
; /* Starting address of segment. */
8159 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8160 unsigned long nsyms
; /* Number of symbols. */
8161 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8162 unsigned long nfuns
; /* Number of entries in funtab. */
8163 char * strtab
; /* The string table. */
8164 unsigned long strtab_size
; /* Size of string table. */
8168 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8170 struct hppa_unw_table_entry
* tp
;
8171 unsigned long j
, nfuns
;
8172 bfd_boolean res
= TRUE
;
8174 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8175 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8176 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8177 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8179 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8181 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8184 const char * procname
;
8186 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8187 aux
->strtab_size
, tp
->start
, &procname
,
8190 fputs ("\n<", stdout
);
8194 fputs (procname
, stdout
);
8197 printf ("+%lx", (unsigned long) offset
);
8200 fputs (">: [", stdout
);
8201 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8202 fputc ('-', stdout
);
8203 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8206 #define PF(_m) if (tp->_m) printf (#_m " ");
8207 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8210 PF(Millicode_save_sr0
);
8211 /* PV(Region_description); */
8217 PF(Separate_Package_Body
);
8218 PF(Frame_Extension_Millicode
);
8219 PF(Stack_Overflow_Check
);
8220 PF(Two_Instruction_SP_Increment
);
8224 PF(sched_entry_seq
);
8227 PF(Save_MRP_in_frame
);
8228 PF(extn_ptr_defined
);
8229 PF(Cleanup_defined
);
8230 PF(MPE_XL_interrupt_marker
);
8231 PF(HP_UX_interrupt_marker
);
8234 PV(Total_frame_size
);
8247 slurp_hppa_unwind_table (Filedata
* filedata
,
8248 struct hppa_unw_aux_info
* aux
,
8249 Elf_Internal_Shdr
* sec
)
8251 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8252 Elf_Internal_Phdr
* seg
;
8253 struct hppa_unw_table_entry
* tep
;
8254 Elf_Internal_Shdr
* relsec
;
8255 Elf_Internal_Rela
* rela
;
8256 Elf_Internal_Rela
* rp
;
8257 unsigned char * table
;
8259 Elf_Internal_Sym
* sym
;
8260 const char * relname
;
8262 /* First, find the starting address of the segment that includes
8264 if (filedata
->file_header
.e_phnum
)
8266 if (! get_program_headers (filedata
))
8269 for (seg
= filedata
->program_headers
;
8270 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8273 if (seg
->p_type
!= PT_LOAD
)
8276 if (sec
->sh_addr
>= seg
->p_vaddr
8277 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8279 aux
->seg_base
= seg
->p_vaddr
;
8285 /* Second, build the unwind table from the contents of the unwind
8287 size
= sec
->sh_size
;
8288 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8294 nentries
= size
/ unw_ent_size
;
8295 size
= unw_ent_size
* nentries
;
8297 aux
->table_len
= nentries
;
8298 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8299 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8301 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8303 unsigned int tmp1
, tmp2
;
8305 tep
->start
.section
= SHN_UNDEF
;
8306 tep
->end
.section
= SHN_UNDEF
;
8308 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8309 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8310 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8311 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8313 tep
->start
.offset
+= aux
->seg_base
;
8314 tep
->end
.offset
+= aux
->seg_base
;
8316 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8317 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8318 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8319 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8320 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8321 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8322 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8323 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8324 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8325 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8326 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8327 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8328 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8329 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8330 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8331 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8332 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8333 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8334 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8335 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8336 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8337 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8338 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8339 tep
->Cleanup_defined
= tmp1
& 0x1;
8341 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8342 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8343 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8344 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8345 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8346 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8350 /* Third, apply any relocations to the unwind table. */
8351 for (relsec
= filedata
->section_headers
;
8352 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8355 if (relsec
->sh_type
!= SHT_RELA
8356 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8357 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8360 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8364 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8366 unsigned int sym_ndx
;
8367 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8368 relname
= elf_hppa_reloc_type (r_type
);
8370 if (relname
== NULL
)
8372 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8376 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8377 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8379 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8383 i
= rp
->r_offset
/ unw_ent_size
;
8384 if (i
>= aux
->table_len
)
8386 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8390 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8391 if (sym_ndx
>= aux
->nsyms
)
8393 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8397 sym
= aux
->symtab
+ sym_ndx
;
8399 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8402 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8403 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8406 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8407 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8421 hppa_process_unwind (Filedata
* filedata
)
8423 struct hppa_unw_aux_info aux
;
8424 Elf_Internal_Shdr
* unwsec
= NULL
;
8425 Elf_Internal_Shdr
* sec
;
8427 bfd_boolean res
= TRUE
;
8429 if (filedata
->string_table
== NULL
)
8432 memset (& aux
, 0, sizeof (aux
));
8434 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8436 if (sec
->sh_type
== SHT_SYMTAB
)
8440 error (_("Multiple symbol tables encountered\n"));
8446 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8447 &aux
.strtab
, &aux
.strtab_size
))
8450 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8455 printf (_("\nThere are no unwind sections in this file.\n"));
8457 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8459 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8461 unsigned long num_unwind
= sec
->sh_size
/ 16;
8463 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8464 "contains %lu entry:\n",
8465 "\nUnwind section '%s' at offset 0x%lx "
8466 "contains %lu entries:\n",
8468 printable_section_name (filedata
, sec
),
8469 (unsigned long) sec
->sh_offset
,
8472 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8475 if (res
&& aux
.table_len
> 0)
8477 if (! dump_hppa_unwind (filedata
, &aux
))
8481 free ((char *) aux
.table
);
8487 free ((char *) aux
.strtab
);
8494 unsigned char * data
; /* The unwind data. */
8495 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8496 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8497 unsigned long nrelas
; /* The number of relocations. */
8498 unsigned int rel_type
; /* REL or RELA ? */
8499 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8502 struct arm_unw_aux_info
8504 Filedata
* filedata
; /* The file containing the unwind sections. */
8505 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8506 unsigned long nsyms
; /* Number of symbols. */
8507 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8508 unsigned long nfuns
; /* Number of these symbols. */
8509 char * strtab
; /* The file's string table. */
8510 unsigned long strtab_size
; /* Size of string table. */
8514 arm_print_vma_and_name (Filedata
* filedata
,
8515 struct arm_unw_aux_info
* aux
,
8517 struct absaddr addr
)
8519 const char *procname
;
8522 if (addr
.section
== SHN_UNDEF
)
8525 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8526 aux
->strtab_size
, addr
, &procname
,
8529 print_vma (fn
, PREFIX_HEX
);
8533 fputs (" <", stdout
);
8534 fputs (procname
, stdout
);
8537 printf ("+0x%lx", (unsigned long) sym_offset
);
8538 fputc ('>', stdout
);
8545 arm_free_section (struct arm_section
*arm_sec
)
8547 free (arm_sec
->data
);
8548 free (arm_sec
->rela
);
8551 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8552 cached section and install SEC instead.
8553 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8554 and return its valued in * WORDP, relocating if necessary.
8555 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8556 relocation's offset in ADDR.
8557 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8558 into the string table of the symbol associated with the reloc. If no
8559 reloc was applied store -1 there.
8560 5) Return TRUE upon success, FALSE otherwise. */
8563 get_unwind_section_word (Filedata
* filedata
,
8564 struct arm_unw_aux_info
* aux
,
8565 struct arm_section
* arm_sec
,
8566 Elf_Internal_Shdr
* sec
,
8567 bfd_vma word_offset
,
8568 unsigned int * wordp
,
8569 struct absaddr
* addr
,
8572 Elf_Internal_Rela
*rp
;
8573 Elf_Internal_Sym
*sym
;
8574 const char * relname
;
8576 bfd_boolean wrapped
;
8578 if (sec
== NULL
|| arm_sec
== NULL
)
8581 addr
->section
= SHN_UNDEF
;
8584 if (sym_name
!= NULL
)
8585 *sym_name
= (bfd_vma
) -1;
8587 /* If necessary, update the section cache. */
8588 if (sec
!= arm_sec
->sec
)
8590 Elf_Internal_Shdr
*relsec
;
8592 arm_free_section (arm_sec
);
8595 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8596 sec
->sh_size
, _("unwind data"));
8597 arm_sec
->rela
= NULL
;
8598 arm_sec
->nrelas
= 0;
8600 for (relsec
= filedata
->section_headers
;
8601 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8604 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8605 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8606 /* PR 15745: Check the section type as well. */
8607 || (relsec
->sh_type
!= SHT_REL
8608 && relsec
->sh_type
!= SHT_RELA
))
8611 arm_sec
->rel_type
= relsec
->sh_type
;
8612 if (relsec
->sh_type
== SHT_REL
)
8614 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8616 & arm_sec
->rela
, & arm_sec
->nrelas
))
8619 else /* relsec->sh_type == SHT_RELA */
8621 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8623 & arm_sec
->rela
, & arm_sec
->nrelas
))
8629 arm_sec
->next_rela
= arm_sec
->rela
;
8632 /* If there is no unwind data we can do nothing. */
8633 if (arm_sec
->data
== NULL
)
8636 /* If the offset is invalid then fail. */
8637 if (/* PR 21343 *//* PR 18879 */
8639 || word_offset
> (sec
->sh_size
- 4)
8640 || ((bfd_signed_vma
) word_offset
) < 0)
8643 /* Get the word at the required offset. */
8644 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8646 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8647 if (arm_sec
->rela
== NULL
)
8653 /* Look through the relocs to find the one that applies to the provided offset. */
8655 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8657 bfd_vma prelval
, offset
;
8659 if (rp
->r_offset
> word_offset
&& !wrapped
)
8664 if (rp
->r_offset
> word_offset
)
8667 if (rp
->r_offset
& 3)
8669 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8670 (unsigned long) rp
->r_offset
);
8674 if (rp
->r_offset
< word_offset
)
8677 /* PR 17531: file: 027-161405-0.004 */
8678 if (aux
->symtab
== NULL
)
8681 if (arm_sec
->rel_type
== SHT_REL
)
8683 offset
= word
& 0x7fffffff;
8684 if (offset
& 0x40000000)
8685 offset
|= ~ (bfd_vma
) 0x7fffffff;
8687 else if (arm_sec
->rel_type
== SHT_RELA
)
8688 offset
= rp
->r_addend
;
8691 error (_("Unknown section relocation type %d encountered\n"),
8696 /* PR 17531 file: 027-1241568-0.004. */
8697 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8699 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8700 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8704 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8705 offset
+= sym
->st_value
;
8706 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8708 /* Check that we are processing the expected reloc type. */
8709 if (filedata
->file_header
.e_machine
== EM_ARM
)
8711 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8712 if (relname
== NULL
)
8714 warn (_("Skipping unknown ARM relocation type: %d\n"),
8715 (int) ELF32_R_TYPE (rp
->r_info
));
8719 if (streq (relname
, "R_ARM_NONE"))
8722 if (! streq (relname
, "R_ARM_PREL31"))
8724 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8728 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8730 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8731 if (relname
== NULL
)
8733 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8734 (int) ELF32_R_TYPE (rp
->r_info
));
8738 if (streq (relname
, "R_C6000_NONE"))
8741 if (! streq (relname
, "R_C6000_PREL31"))
8743 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8751 /* This function currently only supports ARM and TI unwinders. */
8752 warn (_("Only TI and ARM unwinders are currently supported\n"));
8756 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8757 addr
->section
= sym
->st_shndx
;
8758 addr
->offset
= offset
;
8761 * sym_name
= sym
->st_name
;
8766 arm_sec
->next_rela
= rp
;
8771 static const char *tic6x_unwind_regnames
[16] =
8773 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8774 "A14", "A13", "A12", "A11", "A10",
8775 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8779 decode_tic6x_unwind_regmask (unsigned int mask
)
8783 for (i
= 12; mask
; mask
>>= 1, i
--)
8787 fputs (tic6x_unwind_regnames
[i
], stdout
);
8789 fputs (", ", stdout
);
8795 if (remaining == 0 && more_words) \
8798 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8799 data_offset, & word, & addr, NULL)) \
8805 #define GET_OP(OP) \
8810 (OP) = word >> 24; \
8815 printf (_("[Truncated opcode]\n")); \
8818 printf ("0x%02x ", OP)
8821 decode_arm_unwind_bytecode (Filedata
* filedata
,
8822 struct arm_unw_aux_info
* aux
,
8824 unsigned int remaining
,
8825 unsigned int more_words
,
8826 bfd_vma data_offset
,
8827 Elf_Internal_Shdr
* data_sec
,
8828 struct arm_section
* data_arm_sec
)
8830 struct absaddr addr
;
8831 bfd_boolean res
= TRUE
;
8833 /* Decode the unwinding instructions. */
8836 unsigned int op
, op2
;
8845 printf (" 0x%02x ", op
);
8847 if ((op
& 0xc0) == 0x00)
8849 int offset
= ((op
& 0x3f) << 2) + 4;
8851 printf (" vsp = vsp + %d", offset
);
8853 else if ((op
& 0xc0) == 0x40)
8855 int offset
= ((op
& 0x3f) << 2) + 4;
8857 printf (" vsp = vsp - %d", offset
);
8859 else if ((op
& 0xf0) == 0x80)
8862 if (op
== 0x80 && op2
== 0)
8863 printf (_("Refuse to unwind"));
8866 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8867 bfd_boolean first
= TRUE
;
8871 for (i
= 0; i
< 12; i
++)
8872 if (mask
& (1 << i
))
8878 printf ("r%d", 4 + i
);
8883 else if ((op
& 0xf0) == 0x90)
8885 if (op
== 0x9d || op
== 0x9f)
8886 printf (_(" [Reserved]"));
8888 printf (" vsp = r%d", op
& 0x0f);
8890 else if ((op
& 0xf0) == 0xa0)
8892 int end
= 4 + (op
& 0x07);
8893 bfd_boolean first
= TRUE
;
8897 for (i
= 4; i
<= end
; i
++)
8913 else if (op
== 0xb0)
8914 printf (_(" finish"));
8915 else if (op
== 0xb1)
8918 if (op2
== 0 || (op2
& 0xf0) != 0)
8919 printf (_("[Spare]"));
8922 unsigned int mask
= op2
& 0x0f;
8923 bfd_boolean first
= TRUE
;
8927 for (i
= 0; i
< 12; i
++)
8928 if (mask
& (1 << i
))
8939 else if (op
== 0xb2)
8941 unsigned char buf
[9];
8942 unsigned int i
, len
;
8943 unsigned long offset
;
8945 for (i
= 0; i
< sizeof (buf
); i
++)
8948 if ((buf
[i
] & 0x80) == 0)
8951 if (i
== sizeof (buf
))
8953 error (_("corrupt change to vsp\n"));
8958 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
8959 assert (len
== i
+ 1);
8960 offset
= offset
* 4 + 0x204;
8961 printf ("vsp = vsp + %ld", offset
);
8964 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8966 unsigned int first
, last
;
8973 printf ("pop {D%d", first
);
8975 printf ("-D%d", first
+ last
);
8978 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8980 unsigned int count
= op
& 0x07;
8984 printf ("-D%d", 8 + count
);
8987 else if (op
>= 0xc0 && op
<= 0xc5)
8989 unsigned int count
= op
& 0x07;
8991 printf (" pop {wR10");
8993 printf ("-wR%d", 10 + count
);
8996 else if (op
== 0xc6)
8998 unsigned int first
, last
;
9003 printf ("pop {wR%d", first
);
9005 printf ("-wR%d", first
+ last
);
9008 else if (op
== 0xc7)
9011 if (op2
== 0 || (op2
& 0xf0) != 0)
9012 printf (_("[Spare]"));
9015 unsigned int mask
= op2
& 0x0f;
9016 bfd_boolean first
= TRUE
;
9020 for (i
= 0; i
< 4; i
++)
9021 if (mask
& (1 << i
))
9027 printf ("wCGR%d", i
);
9034 printf (_(" [unsupported opcode]"));
9045 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
9046 struct arm_unw_aux_info
* aux
,
9048 unsigned int remaining
,
9049 unsigned int more_words
,
9050 bfd_vma data_offset
,
9051 Elf_Internal_Shdr
* data_sec
,
9052 struct arm_section
* data_arm_sec
)
9054 struct absaddr addr
;
9056 /* Decode the unwinding instructions. */
9059 unsigned int op
, op2
;
9068 printf (" 0x%02x ", op
);
9070 if ((op
& 0xc0) == 0x00)
9072 int offset
= ((op
& 0x3f) << 3) + 8;
9073 printf (" sp = sp + %d", offset
);
9075 else if ((op
& 0xc0) == 0x80)
9078 if (op
== 0x80 && op2
== 0)
9079 printf (_("Refuse to unwind"));
9082 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
9084 printf ("pop compact {");
9088 decode_tic6x_unwind_regmask (mask
);
9092 else if ((op
& 0xf0) == 0xc0)
9100 unsigned int offset
;
9104 /* Scan entire instruction first so that GET_OP output is not
9105 interleaved with disassembly. */
9107 for (i
= 0; nregs
< (op
& 0xf); i
++)
9113 regpos
[nregs
].offset
= i
* 2;
9114 regpos
[nregs
].reg
= reg
;
9121 regpos
[nregs
].offset
= i
* 2 + 1;
9122 regpos
[nregs
].reg
= reg
;
9127 printf (_("pop frame {"));
9130 printf (_("*corrupt* - no registers specified"));
9135 for (i
= i
* 2; i
> 0; i
--)
9137 if (regpos
[reg
].offset
== i
- 1)
9139 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
9146 fputs (name
, stdout
);
9154 else if (op
== 0xd0)
9155 printf (" MOV FP, SP");
9156 else if (op
== 0xd1)
9157 printf (" __c6xabi_pop_rts");
9158 else if (op
== 0xd2)
9160 unsigned char buf
[9];
9161 unsigned int i
, len
;
9162 unsigned long offset
;
9164 for (i
= 0; i
< sizeof (buf
); i
++)
9167 if ((buf
[i
] & 0x80) == 0)
9170 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9171 if (i
== sizeof (buf
))
9173 warn (_("Corrupt stack pointer adjustment detected\n"));
9177 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
9178 assert (len
== i
+ 1);
9179 offset
= offset
* 8 + 0x408;
9180 printf (_("sp = sp + %ld"), offset
);
9182 else if ((op
& 0xf0) == 0xe0)
9184 if ((op
& 0x0f) == 7)
9187 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9191 printf (_(" [unsupported opcode]"));
9200 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9204 offset
= word
& 0x7fffffff;
9205 if (offset
& 0x40000000)
9206 offset
|= ~ (bfd_vma
) 0x7fffffff;
9208 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9211 return offset
+ where
;
9215 decode_arm_unwind (Filedata
* filedata
,
9216 struct arm_unw_aux_info
* aux
,
9218 unsigned int remaining
,
9219 bfd_vma data_offset
,
9220 Elf_Internal_Shdr
* data_sec
,
9221 struct arm_section
* data_arm_sec
)
9224 unsigned int more_words
= 0;
9225 struct absaddr addr
;
9226 bfd_vma sym_name
= (bfd_vma
) -1;
9227 bfd_boolean res
= TRUE
;
9231 /* Fetch the first word.
9232 Note - when decoding an object file the address extracted
9233 here will always be 0. So we also pass in the sym_name
9234 parameter so that we can find the symbol associated with
9235 the personality routine. */
9236 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9237 & word
, & addr
, & sym_name
))
9244 addr
.section
= SHN_UNDEF
;
9248 if ((word
& 0x80000000) == 0)
9250 /* Expand prel31 for personality routine. */
9252 const char *procname
;
9254 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9255 printf (_(" Personality routine: "));
9257 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9258 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9260 procname
= aux
->strtab
+ sym_name
;
9261 print_vma (fn
, PREFIX_HEX
);
9264 fputs (" <", stdout
);
9265 fputs (procname
, stdout
);
9266 fputc ('>', stdout
);
9270 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9271 fputc ('\n', stdout
);
9273 /* The GCC personality routines use the standard compact
9274 encoding, starting with one byte giving the number of
9276 if (procname
!= NULL
9277 && (const_strneq (procname
, "__gcc_personality_v0")
9278 || const_strneq (procname
, "__gxx_personality_v0")
9279 || const_strneq (procname
, "__gcj_personality_v0")
9280 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9287 printf (_(" [Truncated data]\n"));
9290 more_words
= word
>> 24;
9300 /* ARM EHABI Section 6.3:
9302 An exception-handling table entry for the compact model looks like:
9306 1 0 index Data for personalityRoutine[index] */
9308 if (filedata
->file_header
.e_machine
== EM_ARM
9309 && (word
& 0x70000000))
9311 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9315 per_index
= (word
>> 24) & 0x7f;
9316 printf (_(" Compact model index: %d\n"), per_index
);
9323 else if (per_index
< 3)
9325 more_words
= (word
>> 16) & 0xff;
9331 switch (filedata
->file_header
.e_machine
)
9336 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9337 data_offset
, data_sec
, data_arm_sec
))
9342 warn (_("Unknown ARM compact model index encountered\n"));
9343 printf (_(" [reserved]\n"));
9351 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9352 data_offset
, data_sec
, data_arm_sec
))
9355 else if (per_index
< 5)
9357 if (((word
>> 17) & 0x7f) == 0x7f)
9358 printf (_(" Restore stack from frame pointer\n"));
9360 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9361 printf (_(" Registers restored: "));
9363 printf (" (compact) ");
9364 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9366 printf (_(" Return register: %s\n"),
9367 tic6x_unwind_regnames
[word
& 0xf]);
9370 printf (_(" [reserved (%d)]\n"), per_index
);
9374 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9375 filedata
->file_header
.e_machine
);
9379 /* Decode the descriptors. Not implemented. */
9385 dump_arm_unwind (Filedata
* filedata
,
9386 struct arm_unw_aux_info
* aux
,
9387 Elf_Internal_Shdr
* exidx_sec
)
9389 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9390 unsigned int i
, exidx_len
;
9391 unsigned long j
, nfuns
;
9392 bfd_boolean res
= TRUE
;
9394 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9395 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9396 exidx_len
= exidx_sec
->sh_size
/ 8;
9398 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9399 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9400 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9401 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9403 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9405 for (i
= 0; i
< exidx_len
; i
++)
9407 unsigned int exidx_fn
, exidx_entry
;
9408 struct absaddr fn_addr
, entry_addr
;
9411 fputc ('\n', stdout
);
9413 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9414 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9415 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9416 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9419 arm_free_section (& exidx_arm_sec
);
9420 arm_free_section (& extab_arm_sec
);
9424 /* ARM EHABI, Section 5:
9425 An index table entry consists of 2 words.
9426 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9427 if (exidx_fn
& 0x80000000)
9429 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9433 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9435 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9436 fputs (": ", stdout
);
9438 if (exidx_entry
== 1)
9440 print_vma (exidx_entry
, PREFIX_HEX
);
9441 fputs (" [cantunwind]\n", stdout
);
9443 else if (exidx_entry
& 0x80000000)
9445 print_vma (exidx_entry
, PREFIX_HEX
);
9446 fputc ('\n', stdout
);
9447 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9451 bfd_vma table
, table_offset
= 0;
9452 Elf_Internal_Shdr
*table_sec
;
9454 fputs ("@", stdout
);
9455 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9456 print_vma (table
, PREFIX_HEX
);
9459 /* Locate the matching .ARM.extab. */
9460 if (entry_addr
.section
!= SHN_UNDEF
9461 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9463 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9464 table_offset
= entry_addr
.offset
;
9466 if (table_offset
> table_sec
->sh_size
9467 || ((bfd_signed_vma
) table_offset
) < 0)
9469 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9470 (unsigned long) table_offset
,
9471 printable_section_name (filedata
, table_sec
));
9478 table_sec
= find_section_by_address (filedata
, table
);
9479 if (table_sec
!= NULL
)
9480 table_offset
= table
- table_sec
->sh_addr
;
9483 if (table_sec
== NULL
)
9485 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9486 (unsigned long) table
);
9491 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9500 arm_free_section (&exidx_arm_sec
);
9501 arm_free_section (&extab_arm_sec
);
9506 /* Used for both ARM and C6X unwinding tables. */
9509 arm_process_unwind (Filedata
* filedata
)
9511 struct arm_unw_aux_info aux
;
9512 Elf_Internal_Shdr
*unwsec
= NULL
;
9513 Elf_Internal_Shdr
*sec
;
9515 unsigned int sec_type
;
9516 bfd_boolean res
= TRUE
;
9518 switch (filedata
->file_header
.e_machine
)
9521 sec_type
= SHT_ARM_EXIDX
;
9525 sec_type
= SHT_C6000_UNWIND
;
9529 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9530 filedata
->file_header
.e_machine
);
9534 if (filedata
->string_table
== NULL
)
9537 memset (& aux
, 0, sizeof (aux
));
9538 aux
.filedata
= filedata
;
9540 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9542 if (sec
->sh_type
== SHT_SYMTAB
)
9546 error (_("Multiple symbol tables encountered\n"));
9552 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9553 &aux
.strtab
, &aux
.strtab_size
))
9556 else if (sec
->sh_type
== sec_type
)
9561 printf (_("\nThere are no unwind sections in this file.\n"));
9563 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9565 if (sec
->sh_type
== sec_type
)
9567 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9568 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9569 "contains %lu entry:\n",
9570 "\nUnwind section '%s' at offset 0x%lx "
9571 "contains %lu entries:\n",
9573 printable_section_name (filedata
, sec
),
9574 (unsigned long) sec
->sh_offset
,
9577 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9583 free ((char *) aux
.strtab
);
9589 process_unwind (Filedata
* filedata
)
9591 struct unwind_handler
9593 unsigned int machtype
;
9594 bfd_boolean (* handler
)(Filedata
*);
9597 { EM_ARM
, arm_process_unwind
},
9598 { EM_IA_64
, ia64_process_unwind
},
9599 { EM_PARISC
, hppa_process_unwind
},
9600 { EM_TI_C6000
, arm_process_unwind
},
9608 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9609 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9610 return handlers
[i
].handler (filedata
);
9612 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9613 get_machine_name (filedata
->file_header
.e_machine
));
9618 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9620 switch (entry
->d_tag
)
9622 case DT_AARCH64_BTI_PLT
:
9623 case DT_AARCH64_PAC_PLT
:
9626 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9633 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
9635 switch (entry
->d_tag
)
9638 if (entry
->d_un
.d_val
== 0)
9642 static const char * opts
[] =
9644 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9645 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9646 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9647 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9651 bfd_boolean first
= TRUE
;
9653 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9654 if (entry
->d_un
.d_val
& (1 << cnt
))
9656 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9662 case DT_MIPS_IVERSION
:
9663 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
9664 printf (_("Interface Version: %s"),
9665 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
9669 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9670 /* Note: coded this way so that there is a single string for translation. */
9671 printf (_("<corrupt: %s>"), buf
);
9675 case DT_MIPS_TIME_STAMP
:
9679 time_t atime
= entry
->d_un
.d_val
;
9681 tmp
= gmtime (&atime
);
9682 /* PR 17531: file: 6accc532. */
9684 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9686 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9687 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9688 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9689 printf (_("Time Stamp: %s"), timebuf
);
9693 case DT_MIPS_RLD_VERSION
:
9694 case DT_MIPS_LOCAL_GOTNO
:
9695 case DT_MIPS_CONFLICTNO
:
9696 case DT_MIPS_LIBLISTNO
:
9697 case DT_MIPS_SYMTABNO
:
9698 case DT_MIPS_UNREFEXTNO
:
9699 case DT_MIPS_HIPAGENO
:
9700 case DT_MIPS_DELTA_CLASS_NO
:
9701 case DT_MIPS_DELTA_INSTANCE_NO
:
9702 case DT_MIPS_DELTA_RELOC_NO
:
9703 case DT_MIPS_DELTA_SYM_NO
:
9704 case DT_MIPS_DELTA_CLASSSYM_NO
:
9705 case DT_MIPS_COMPACT_SIZE
:
9706 print_vma (entry
->d_un
.d_val
, DEC
);
9710 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
9711 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9712 /* Falls through. */
9715 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9721 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9723 switch (entry
->d_tag
)
9725 case DT_HP_DLD_FLAGS
:
9734 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9735 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9736 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9737 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9738 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9739 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9740 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9741 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9742 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9743 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9744 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9745 { DT_HP_GST
, "HP_GST" },
9746 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9747 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9748 { DT_HP_NODELETE
, "HP_NODELETE" },
9749 { DT_HP_GROUP
, "HP_GROUP" },
9750 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9752 bfd_boolean first
= TRUE
;
9754 bfd_vma val
= entry
->d_un
.d_val
;
9756 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9757 if (val
& flags
[cnt
].bit
)
9761 fputs (flags
[cnt
].str
, stdout
);
9763 val
^= flags
[cnt
].bit
;
9766 if (val
!= 0 || first
)
9770 print_vma (val
, HEX
);
9776 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9784 /* VMS vs Unix time offset and factor. */
9786 #define VMS_EPOCH_OFFSET 35067168000000000LL
9787 #define VMS_GRANULARITY_FACTOR 10000000
9789 /* Display a VMS time in a human readable format. */
9792 print_vms_time (bfd_int64_t vmstime
)
9797 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9798 tm
= gmtime (&unxtime
);
9799 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9800 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9801 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9806 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9808 switch (entry
->d_tag
)
9810 case DT_IA_64_PLT_RESERVE
:
9811 /* First 3 slots reserved. */
9812 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9814 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9817 case DT_IA_64_VMS_LINKTIME
:
9819 print_vms_time (entry
->d_un
.d_val
);
9823 case DT_IA_64_VMS_LNKFLAGS
:
9824 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9825 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9826 printf (" CALL_DEBUG");
9827 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9828 printf (" NOP0BUFS");
9829 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9830 printf (" P0IMAGE");
9831 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9832 printf (" MKTHREADS");
9833 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9834 printf (" UPCALLS");
9835 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9837 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9838 printf (" INITIALIZE");
9839 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9841 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9842 printf (" EXE_INIT");
9843 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9844 printf (" TBK_IN_IMG");
9845 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9846 printf (" DBG_IN_IMG");
9847 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9848 printf (" TBK_IN_DSF");
9849 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9850 printf (" DBG_IN_DSF");
9851 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9852 printf (" SIGNATURES");
9853 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9854 printf (" REL_SEG_OFF");
9858 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9865 get_32bit_dynamic_section (Filedata
* filedata
)
9867 Elf32_External_Dyn
* edyn
;
9868 Elf32_External_Dyn
* ext
;
9869 Elf_Internal_Dyn
* entry
;
9871 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
9872 filedata
->dynamic_addr
, 1,
9873 filedata
->dynamic_size
,
9874 _("dynamic section"));
9878 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9879 might not have the luxury of section headers. Look for the DT_NULL
9880 terminator to determine the number of entries. */
9881 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
9882 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
9885 filedata
->dynamic_nent
++;
9886 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9890 filedata
->dynamic_section
9891 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
9892 if (filedata
->dynamic_section
== NULL
)
9894 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9895 (unsigned long) filedata
->dynamic_nent
);
9900 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
9901 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
9904 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9905 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9914 get_64bit_dynamic_section (Filedata
* filedata
)
9916 Elf64_External_Dyn
* edyn
;
9917 Elf64_External_Dyn
* ext
;
9918 Elf_Internal_Dyn
* entry
;
9920 /* Read in the data. */
9921 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
9922 filedata
->dynamic_addr
, 1,
9923 filedata
->dynamic_size
,
9924 _("dynamic section"));
9928 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9929 might not have the luxury of section headers. Look for the DT_NULL
9930 terminator to determine the number of entries. */
9931 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
9932 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9933 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
9936 filedata
->dynamic_nent
++;
9937 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9941 filedata
->dynamic_section
9942 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
9943 if (filedata
->dynamic_section
== NULL
)
9945 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9946 (unsigned long) filedata
->dynamic_nent
);
9951 /* Convert from external to internal formats. */
9952 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
9953 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
9956 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9957 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9966 print_dynamic_flags (bfd_vma flags
)
9968 bfd_boolean first
= TRUE
;
9974 flag
= flags
& - flags
;
9984 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9985 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9986 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9987 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9988 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9989 default: fputs (_("unknown"), stdout
); break;
9996 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
9998 unsigned char * e_data
;
10001 /* If the size_t type is smaller than the bfd_size_type, eg because
10002 you are building a 32-bit tool on a 64-bit host, then make sure
10003 that when (number) is cast to (size_t) no information is lost. */
10004 if (sizeof (size_t) < sizeof (bfd_size_type
)
10005 && (bfd_size_type
) ((size_t) number
) != number
)
10007 error (_("Size truncation prevents reading %s elements of size %u\n"),
10008 bfd_vmatoa ("u", number
), ent_size
);
10012 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
10013 attempting to allocate memory when the read is bound to fail. */
10014 if (ent_size
* number
> filedata
->file_size
)
10016 error (_("Invalid number of dynamic entries: %s\n"),
10017 bfd_vmatoa ("u", number
));
10021 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10022 if (e_data
== NULL
)
10024 error (_("Out of memory reading %s dynamic entries\n"),
10025 bfd_vmatoa ("u", number
));
10029 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
10031 error (_("Unable to read in %s bytes of dynamic data\n"),
10032 bfd_vmatoa ("u", number
* ent_size
));
10037 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10038 if (i_data
== NULL
)
10040 error (_("Out of memory allocating space for %s dynamic entries\n"),
10041 bfd_vmatoa ("u", number
));
10047 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10054 static unsigned long
10055 get_num_dynamic_syms (Filedata
* filedata
)
10057 unsigned long num_of_syms
= 0;
10059 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
10060 return num_of_syms
;
10062 if (filedata
->dynamic_info
[DT_HASH
])
10064 unsigned char nb
[8];
10065 unsigned char nc
[8];
10066 unsigned int hash_ent_size
= 4;
10068 if ((filedata
->file_header
.e_machine
== EM_ALPHA
10069 || filedata
->file_header
.e_machine
== EM_S390
10070 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
10071 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10074 if (fseek (filedata
->handle
,
10075 (filedata
->archive_file_offset
10076 + offset_from_vma (filedata
, filedata
->dynamic_info
[DT_HASH
],
10077 sizeof nb
+ sizeof nc
)),
10080 error (_("Unable to seek to start of dynamic information\n"));
10084 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
10086 error (_("Failed to read in number of buckets\n"));
10090 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
10092 error (_("Failed to read in number of chains\n"));
10096 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
10097 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
10099 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
10101 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
10103 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
10106 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
10107 num_of_syms
= filedata
->nchains
;
10110 if (num_of_syms
== 0)
10112 free (filedata
->buckets
);
10113 filedata
->buckets
= NULL
;
10114 free (filedata
->chains
);
10115 filedata
->chains
= NULL
;
10116 filedata
->nbuckets
= 0;
10120 if (filedata
->dynamic_info_DT_GNU_HASH
)
10122 unsigned char nb
[16];
10123 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10124 bfd_vma buckets_vma
;
10127 if (fseek (filedata
->handle
,
10128 (filedata
->archive_file_offset
10129 + offset_from_vma (filedata
,
10130 filedata
->dynamic_info_DT_GNU_HASH
,
10134 error (_("Unable to seek to start of dynamic information\n"));
10138 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
10140 error (_("Failed to read in number of buckets\n"));
10144 filedata
->ngnubuckets
= byte_get (nb
, 4);
10145 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
10146 bitmaskwords
= byte_get (nb
+ 8, 4);
10147 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
10149 buckets_vma
+= bitmaskwords
* 4;
10151 buckets_vma
+= bitmaskwords
* 8;
10153 if (fseek (filedata
->handle
,
10154 (filedata
->archive_file_offset
10155 + offset_from_vma (filedata
, buckets_vma
, 4)),
10158 error (_("Unable to seek to start of dynamic information\n"));
10162 filedata
->gnubuckets
10163 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
10165 if (filedata
->gnubuckets
== NULL
)
10168 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
10169 if (filedata
->gnubuckets
[i
] != 0)
10171 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
10174 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
10175 maxchain
= filedata
->gnubuckets
[i
];
10178 if (maxchain
== 0xffffffff)
10181 maxchain
-= filedata
->gnusymidx
;
10183 if (fseek (filedata
->handle
,
10184 (filedata
->archive_file_offset
10185 + offset_from_vma (filedata
,
10186 buckets_vma
+ 4 * (filedata
->ngnubuckets
10191 error (_("Unable to seek to start of dynamic information\n"));
10197 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
10199 error (_("Failed to determine last chain length\n"));
10203 if (maxchain
+ 1 == 0)
10208 while ((byte_get (nb
, 4) & 1) == 0);
10210 if (fseek (filedata
->handle
,
10211 (filedata
->archive_file_offset
10212 + offset_from_vma (filedata
, (buckets_vma
10213 + 4 * filedata
->ngnubuckets
),
10217 error (_("Unable to seek to start of dynamic information\n"));
10221 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
10222 filedata
->ngnuchains
= maxchain
;
10224 if (filedata
->gnuchains
== NULL
)
10227 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10229 if (fseek (filedata
->handle
,
10230 (filedata
->archive_file_offset
10231 + offset_from_vma (filedata
, (buckets_vma
10232 + 4 * (filedata
->ngnubuckets
10236 error (_("Unable to seek to start of dynamic information\n"));
10240 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
10241 if (filedata
->mipsxlat
== NULL
)
10245 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
10246 if (filedata
->gnubuckets
[hn
] != 0)
10248 bfd_vma si
= filedata
->gnubuckets
[hn
];
10249 bfd_vma off
= si
- filedata
->gnusymidx
;
10253 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10255 if (off
< filedata
->ngnuchains
10256 && filedata
->mipsxlat
[off
] >= num_of_syms
)
10257 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
10261 if (si
>= num_of_syms
)
10262 num_of_syms
= si
+ 1;
10266 while (off
< filedata
->ngnuchains
10267 && (filedata
->gnuchains
[off
++] & 1) == 0);
10270 if (num_of_syms
== 0)
10273 free (filedata
->mipsxlat
);
10274 filedata
->mipsxlat
= NULL
;
10275 free (filedata
->gnuchains
);
10276 filedata
->gnuchains
= NULL
;
10277 free (filedata
->gnubuckets
);
10278 filedata
->gnubuckets
= NULL
;
10279 filedata
->ngnubuckets
= 0;
10280 filedata
->ngnuchains
= 0;
10284 return num_of_syms
;
10287 /* Parse and display the contents of the dynamic section. */
10290 process_dynamic_section (Filedata
* filedata
)
10292 Elf_Internal_Dyn
* entry
;
10294 if (filedata
->dynamic_size
== 0)
10297 printf (_("\nThere is no dynamic section in this file.\n"));
10304 if (! get_32bit_dynamic_section (filedata
))
10309 if (! get_64bit_dynamic_section (filedata
))
10313 /* Find the appropriate symbol table. */
10314 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
10316 unsigned long num_of_syms
;
10318 for (entry
= filedata
->dynamic_section
;
10319 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10321 if (entry
->d_tag
== DT_SYMTAB
)
10322 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
10323 else if (entry
->d_tag
== DT_SYMENT
)
10324 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
10325 else if (entry
->d_tag
== DT_HASH
)
10326 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
10327 else if (entry
->d_tag
== DT_GNU_HASH
)
10328 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10329 else if ((filedata
->file_header
.e_machine
== EM_MIPS
10330 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
10331 && entry
->d_tag
== DT_MIPS_XHASH
)
10333 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10334 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10337 num_of_syms
= get_num_dynamic_syms (filedata
);
10339 if (num_of_syms
!= 0
10340 && filedata
->dynamic_symbols
== NULL
10341 && filedata
->dynamic_info
[DT_SYMTAB
]
10342 && filedata
->dynamic_info
[DT_SYMENT
])
10344 Elf_Internal_Phdr
*seg
;
10345 bfd_vma vma
= filedata
->dynamic_info
[DT_SYMTAB
];
10347 if (! get_program_headers (filedata
))
10349 error (_("Cannot interpret virtual addresses "
10350 "without program headers.\n"));
10354 for (seg
= filedata
->program_headers
;
10355 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
10358 if (seg
->p_type
!= PT_LOAD
)
10361 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
10363 /* See PR 21379 for a reproducer. */
10364 error (_("Invalid PT_LOAD entry\n"));
10368 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
10369 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
10371 /* Since we do not know how big the symbol table is,
10372 we default to reading in up to the end of PT_LOAD
10373 segment and processing that. This is overkill, I
10374 know, but it should work. */
10375 Elf_Internal_Shdr section
;
10376 section
.sh_offset
= (vma
- seg
->p_vaddr
10378 section
.sh_size
= (num_of_syms
10379 * filedata
->dynamic_info
[DT_SYMENT
]);
10380 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
10383 && filedata
->dynamic_symtab_section
!= NULL
10384 && ((filedata
->dynamic_symtab_section
->sh_offset
10385 != section
.sh_offset
)
10386 || (filedata
->dynamic_symtab_section
->sh_size
10387 != section
.sh_size
)
10388 || (filedata
->dynamic_symtab_section
->sh_entsize
10389 != section
.sh_entsize
)))
10391 the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
10393 section
.sh_name
= filedata
->string_table_length
;
10394 filedata
->dynamic_symbols
10395 = GET_ELF_SYMBOLS (filedata
, §ion
,
10396 &filedata
->num_dynamic_syms
);
10397 if (filedata
->dynamic_symbols
== NULL
10398 || filedata
->num_dynamic_syms
!= num_of_syms
)
10400 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
10409 /* Similarly find a string table. */
10410 if (filedata
->dynamic_strings
== NULL
)
10411 for (entry
= filedata
->dynamic_section
;
10412 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10415 if (entry
->d_tag
== DT_STRTAB
)
10416 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
10418 if (entry
->d_tag
== DT_STRSZ
)
10419 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
10421 if (filedata
->dynamic_info
[DT_STRTAB
]
10422 && filedata
->dynamic_info
[DT_STRSZ
])
10424 unsigned long offset
;
10425 bfd_size_type str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
10427 offset
= offset_from_vma (filedata
,
10428 filedata
->dynamic_info
[DT_STRTAB
],
10431 && filedata
->dynamic_strtab_section
10432 && ((filedata
->dynamic_strtab_section
->sh_offset
10433 != (file_ptr
) offset
)
10434 || (filedata
->dynamic_strtab_section
->sh_size
10437 the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
10439 filedata
->dynamic_strings
10440 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
10441 _("dynamic string table"));
10442 if (filedata
->dynamic_strings
== NULL
)
10444 error (_("Corrupt DT_STRTAB dynamic entry\n"));
10448 filedata
->dynamic_strings_length
= str_tab_len
;
10453 /* And find the syminfo section if available. */
10454 if (filedata
->dynamic_syminfo
== NULL
)
10456 unsigned long syminsz
= 0;
10458 for (entry
= filedata
->dynamic_section
;
10459 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10462 if (entry
->d_tag
== DT_SYMINENT
)
10464 /* Note: these braces are necessary to avoid a syntax
10465 error from the SunOS4 C compiler. */
10466 /* PR binutils/17531: A corrupt file can trigger this test.
10467 So do not use an assert, instead generate an error message. */
10468 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
10469 error (_("Bad value (%d) for SYMINENT entry\n"),
10470 (int) entry
->d_un
.d_val
);
10472 else if (entry
->d_tag
== DT_SYMINSZ
)
10473 syminsz
= entry
->d_un
.d_val
;
10474 else if (entry
->d_tag
== DT_SYMINFO
)
10475 filedata
->dynamic_syminfo_offset
10476 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
10479 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
10481 Elf_External_Syminfo
* extsyminfo
;
10482 Elf_External_Syminfo
* extsym
;
10483 Elf_Internal_Syminfo
* syminfo
;
10485 /* There is a syminfo section. Read the data. */
10486 extsyminfo
= (Elf_External_Syminfo
*)
10487 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
10488 1, syminsz
, _("symbol information"));
10492 if (filedata
->dynamic_syminfo
!= NULL
)
10494 error (_("Multiple dynamic symbol information sections found\n"));
10495 free (filedata
->dynamic_syminfo
);
10497 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10498 if (filedata
->dynamic_syminfo
== NULL
)
10500 error (_("Out of memory allocating %lu bytes "
10501 "for dynamic symbol info\n"),
10502 (unsigned long) syminsz
);
10506 filedata
->dynamic_syminfo_nent
10507 = syminsz
/ sizeof (Elf_External_Syminfo
);
10508 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
10509 syminfo
< (filedata
->dynamic_syminfo
10510 + filedata
->dynamic_syminfo_nent
);
10511 ++syminfo
, ++extsym
)
10513 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10514 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10521 if (do_dynamic
&& filedata
->dynamic_addr
)
10522 printf (ngettext ("\nDynamic section at offset 0x%lx "
10523 "contains %lu entry:\n",
10524 "\nDynamic section at offset 0x%lx "
10525 "contains %lu entries:\n",
10526 filedata
->dynamic_nent
),
10527 filedata
->dynamic_addr
, (unsigned long) filedata
->dynamic_nent
);
10529 printf (_(" Tag Type Name/Value\n"));
10531 for (entry
= filedata
->dynamic_section
;
10532 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10537 const char * dtype
;
10540 print_vma (entry
->d_tag
, FULL_HEX
);
10541 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10542 printf (" (%s)%*s", dtype
,
10543 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10546 switch (entry
->d_tag
)
10550 print_dynamic_flags (entry
->d_un
.d_val
);
10560 switch (entry
->d_tag
)
10563 printf (_("Auxiliary library"));
10567 printf (_("Filter library"));
10571 printf (_("Configuration file"));
10575 printf (_("Dependency audit library"));
10579 printf (_("Audit library"));
10583 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10584 printf (": [%s]\n",
10585 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
10589 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10598 printf (_("Flags:"));
10600 if (entry
->d_un
.d_val
== 0)
10601 printf (_(" None\n"));
10604 unsigned long int val
= entry
->d_un
.d_val
;
10606 if (val
& DTF_1_PARINIT
)
10608 printf (" PARINIT");
10609 val
^= DTF_1_PARINIT
;
10611 if (val
& DTF_1_CONFEXP
)
10613 printf (" CONFEXP");
10614 val
^= DTF_1_CONFEXP
;
10617 printf (" %lx", val
);
10626 printf (_("Flags:"));
10628 if (entry
->d_un
.d_val
== 0)
10629 printf (_(" None\n"));
10632 unsigned long int val
= entry
->d_un
.d_val
;
10634 if (val
& DF_P1_LAZYLOAD
)
10636 printf (" LAZYLOAD");
10637 val
^= DF_P1_LAZYLOAD
;
10639 if (val
& DF_P1_GROUPPERM
)
10641 printf (" GROUPPERM");
10642 val
^= DF_P1_GROUPPERM
;
10645 printf (" %lx", val
);
10654 printf (_("Flags:"));
10655 if (entry
->d_un
.d_val
== 0)
10656 printf (_(" None\n"));
10659 unsigned long int val
= entry
->d_un
.d_val
;
10661 if (val
& DF_1_NOW
)
10666 if (val
& DF_1_GLOBAL
)
10668 printf (" GLOBAL");
10669 val
^= DF_1_GLOBAL
;
10671 if (val
& DF_1_GROUP
)
10676 if (val
& DF_1_NODELETE
)
10678 printf (" NODELETE");
10679 val
^= DF_1_NODELETE
;
10681 if (val
& DF_1_LOADFLTR
)
10683 printf (" LOADFLTR");
10684 val
^= DF_1_LOADFLTR
;
10686 if (val
& DF_1_INITFIRST
)
10688 printf (" INITFIRST");
10689 val
^= DF_1_INITFIRST
;
10691 if (val
& DF_1_NOOPEN
)
10693 printf (" NOOPEN");
10694 val
^= DF_1_NOOPEN
;
10696 if (val
& DF_1_ORIGIN
)
10698 printf (" ORIGIN");
10699 val
^= DF_1_ORIGIN
;
10701 if (val
& DF_1_DIRECT
)
10703 printf (" DIRECT");
10704 val
^= DF_1_DIRECT
;
10706 if (val
& DF_1_TRANS
)
10711 if (val
& DF_1_INTERPOSE
)
10713 printf (" INTERPOSE");
10714 val
^= DF_1_INTERPOSE
;
10716 if (val
& DF_1_NODEFLIB
)
10718 printf (" NODEFLIB");
10719 val
^= DF_1_NODEFLIB
;
10721 if (val
& DF_1_NODUMP
)
10723 printf (" NODUMP");
10724 val
^= DF_1_NODUMP
;
10726 if (val
& DF_1_CONFALT
)
10728 printf (" CONFALT");
10729 val
^= DF_1_CONFALT
;
10731 if (val
& DF_1_ENDFILTEE
)
10733 printf (" ENDFILTEE");
10734 val
^= DF_1_ENDFILTEE
;
10736 if (val
& DF_1_DISPRELDNE
)
10738 printf (" DISPRELDNE");
10739 val
^= DF_1_DISPRELDNE
;
10741 if (val
& DF_1_DISPRELPND
)
10743 printf (" DISPRELPND");
10744 val
^= DF_1_DISPRELPND
;
10746 if (val
& DF_1_NODIRECT
)
10748 printf (" NODIRECT");
10749 val
^= DF_1_NODIRECT
;
10751 if (val
& DF_1_IGNMULDEF
)
10753 printf (" IGNMULDEF");
10754 val
^= DF_1_IGNMULDEF
;
10756 if (val
& DF_1_NOKSYMS
)
10758 printf (" NOKSYMS");
10759 val
^= DF_1_NOKSYMS
;
10761 if (val
& DF_1_NOHDR
)
10766 if (val
& DF_1_EDITED
)
10768 printf (" EDITED");
10769 val
^= DF_1_EDITED
;
10771 if (val
& DF_1_NORELOC
)
10773 printf (" NORELOC");
10774 val
^= DF_1_NORELOC
;
10776 if (val
& DF_1_SYMINTPOSE
)
10778 printf (" SYMINTPOSE");
10779 val
^= DF_1_SYMINTPOSE
;
10781 if (val
& DF_1_GLOBAUDIT
)
10783 printf (" GLOBAUDIT");
10784 val
^= DF_1_GLOBAUDIT
;
10786 if (val
& DF_1_SINGLETON
)
10788 printf (" SINGLETON");
10789 val
^= DF_1_SINGLETON
;
10791 if (val
& DF_1_STUB
)
10796 if (val
& DF_1_PIE
)
10801 if (val
& DF_1_KMOD
)
10806 if (val
& DF_1_WEAKFILTER
)
10808 printf (" WEAKFILTER");
10809 val
^= DF_1_WEAKFILTER
;
10811 if (val
& DF_1_NOCOMMON
)
10813 printf (" NOCOMMON");
10814 val
^= DF_1_NOCOMMON
;
10817 printf (" %lx", val
);
10824 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10826 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10846 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10852 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10853 name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
10859 switch (entry
->d_tag
)
10862 printf (_("Shared library: [%s]"), name
);
10864 if (streq (name
, filedata
->program_interpreter
))
10865 printf (_(" program interpreter"));
10869 printf (_("Library soname: [%s]"), name
);
10873 printf (_("Library rpath: [%s]"), name
);
10877 printf (_("Library runpath: [%s]"), name
);
10881 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10886 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10899 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10900 /* Fall through. */
10904 case DT_INIT_ARRAYSZ
:
10905 case DT_FINI_ARRAYSZ
:
10906 case DT_GNU_CONFLICTSZ
:
10907 case DT_GNU_LIBLISTSZ
:
10910 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10911 printf (_(" (bytes)\n"));
10916 case DT_VERNEEDNUM
:
10921 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10930 case DT_INIT_ARRAY
:
10931 case DT_FINI_ARRAY
:
10934 if (entry
->d_tag
== DT_USED
10935 && VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10937 char * name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
10941 printf (_("Not needed object: [%s]\n"), name
);
10946 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10952 /* The value of this entry is ignored. */
10957 case DT_GNU_PRELINKED
:
10961 time_t atime
= entry
->d_un
.d_val
;
10963 tmp
= gmtime (&atime
);
10964 /* PR 17533 file: 041-1244816-0.004. */
10966 printf (_("<corrupt time val: %lx"),
10967 (unsigned long) atime
);
10969 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10970 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10971 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10977 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10980 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10986 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10987 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
10988 = entry
->d_un
.d_val
;
10992 switch (filedata
->file_header
.e_machine
)
10995 dynamic_section_aarch64_val (entry
);
10998 case EM_MIPS_RS3_LE
:
10999 dynamic_section_mips_val (filedata
, entry
);
11002 dynamic_section_parisc_val (entry
);
11005 dynamic_section_ia64_val (entry
);
11008 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11020 get_ver_flags (unsigned int flags
)
11022 static char buff
[128];
11029 if (flags
& VER_FLG_BASE
)
11030 strcat (buff
, "BASE");
11032 if (flags
& VER_FLG_WEAK
)
11034 if (flags
& VER_FLG_BASE
)
11035 strcat (buff
, " | ");
11037 strcat (buff
, "WEAK");
11040 if (flags
& VER_FLG_INFO
)
11042 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
11043 strcat (buff
, " | ");
11045 strcat (buff
, "INFO");
11048 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11050 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11051 strcat (buff
, " | ");
11053 strcat (buff
, _("<unknown>"));
11059 /* Display the contents of the version sections. */
11062 process_version_sections (Filedata
* filedata
)
11064 Elf_Internal_Shdr
* section
;
11066 bfd_boolean found
= FALSE
;
11071 for (i
= 0, section
= filedata
->section_headers
;
11072 i
< filedata
->file_header
.e_shnum
;
11075 switch (section
->sh_type
)
11077 case SHT_GNU_verdef
:
11079 Elf_External_Verdef
* edefs
;
11086 printf (ngettext ("\nVersion definition section '%s' "
11087 "contains %u entry:\n",
11088 "\nVersion definition section '%s' "
11089 "contains %u entries:\n",
11091 printable_section_name (filedata
, section
),
11094 printf (_(" Addr: 0x"));
11095 printf_vma (section
->sh_addr
);
11096 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11097 (unsigned long) section
->sh_offset
, section
->sh_link
,
11098 printable_section_name_from_index (filedata
, section
->sh_link
));
11100 edefs
= (Elf_External_Verdef
*)
11101 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
11102 _("version definition section"));
11105 endbuf
= (char *) edefs
+ section
->sh_size
;
11107 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11110 Elf_External_Verdef
* edef
;
11111 Elf_Internal_Verdef ent
;
11112 Elf_External_Verdaux
* eaux
;
11113 Elf_Internal_Verdaux aux
;
11114 unsigned long isum
;
11117 vstart
= ((char *) edefs
) + idx
;
11118 if (vstart
+ sizeof (*edef
) > endbuf
)
11121 edef
= (Elf_External_Verdef
*) vstart
;
11123 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
11124 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
11125 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
11126 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
11127 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
11128 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
11129 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
11131 printf (_(" %#06lx: Rev: %d Flags: %s"),
11132 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
11134 printf (_(" Index: %d Cnt: %d "),
11135 ent
.vd_ndx
, ent
.vd_cnt
);
11137 /* Check for overflow. */
11138 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
11141 vstart
+= ent
.vd_aux
;
11143 if (vstart
+ sizeof (*eaux
) > endbuf
)
11145 eaux
= (Elf_External_Verdaux
*) vstart
;
11147 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11148 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11150 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11151 printf (_("Name: %s\n"),
11152 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11154 printf (_("Name index: %ld\n"), aux
.vda_name
);
11156 isum
= idx
+ ent
.vd_aux
;
11158 for (j
= 1; j
< ent
.vd_cnt
; j
++)
11160 if (aux
.vda_next
< sizeof (*eaux
)
11161 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
11163 warn (_("Invalid vda_next field of %lx\n"),
11168 /* Check for overflow. */
11169 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
11172 isum
+= aux
.vda_next
;
11173 vstart
+= aux
.vda_next
;
11175 if (vstart
+ sizeof (*eaux
) > endbuf
)
11177 eaux
= (Elf_External_Verdaux
*) vstart
;
11179 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11180 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11182 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11183 printf (_(" %#06lx: Parent %d: %s\n"),
11185 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11187 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
11188 isum
, j
, aux
.vda_name
);
11191 if (j
< ent
.vd_cnt
)
11192 printf (_(" Version def aux past end of section\n"));
11195 file: id:000001,src:000172+005151,op:splice,rep:2. */
11196 if (ent
.vd_next
< sizeof (*edef
)
11197 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
11199 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
11200 cnt
= section
->sh_info
;
11203 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
11206 idx
+= ent
.vd_next
;
11209 if (cnt
< section
->sh_info
)
11210 printf (_(" Version definition past end of section\n"));
11216 case SHT_GNU_verneed
:
11218 Elf_External_Verneed
* eneed
;
11225 printf (ngettext ("\nVersion needs section '%s' "
11226 "contains %u entry:\n",
11227 "\nVersion needs section '%s' "
11228 "contains %u entries:\n",
11230 printable_section_name (filedata
, section
), section
->sh_info
);
11232 printf (_(" Addr: 0x"));
11233 printf_vma (section
->sh_addr
);
11234 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11235 (unsigned long) section
->sh_offset
, section
->sh_link
,
11236 printable_section_name_from_index (filedata
, section
->sh_link
));
11238 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
11239 section
->sh_offset
, 1,
11241 _("Version Needs section"));
11244 endbuf
= (char *) eneed
+ section
->sh_size
;
11246 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11248 Elf_External_Verneed
* entry
;
11249 Elf_Internal_Verneed ent
;
11250 unsigned long isum
;
11254 vstart
= ((char *) eneed
) + idx
;
11255 if (vstart
+ sizeof (*entry
) > endbuf
)
11258 entry
= (Elf_External_Verneed
*) vstart
;
11260 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
11261 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
11262 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
11263 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
11264 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
11266 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
11268 if (VALID_DYNAMIC_NAME (filedata
, ent
.vn_file
))
11269 printf (_(" File: %s"),
11270 GET_DYNAMIC_NAME (filedata
, ent
.vn_file
));
11272 printf (_(" File: %lx"), ent
.vn_file
);
11274 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
11276 /* Check for overflow. */
11277 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
11279 vstart
+= ent
.vn_aux
;
11281 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
11283 Elf_External_Vernaux
* eaux
;
11284 Elf_Internal_Vernaux aux
;
11286 if (vstart
+ sizeof (*eaux
) > endbuf
)
11288 eaux
= (Elf_External_Vernaux
*) vstart
;
11290 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
11291 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
11292 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
11293 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
11294 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
11296 if (VALID_DYNAMIC_NAME (filedata
, aux
.vna_name
))
11297 printf (_(" %#06lx: Name: %s"),
11298 isum
, GET_DYNAMIC_NAME (filedata
, aux
.vna_name
));
11300 printf (_(" %#06lx: Name index: %lx"),
11301 isum
, aux
.vna_name
);
11303 printf (_(" Flags: %s Version: %d\n"),
11304 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
11306 if (aux
.vna_next
< sizeof (*eaux
)
11307 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
11309 warn (_("Invalid vna_next field of %lx\n"),
11314 /* Check for overflow. */
11315 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
11317 isum
+= aux
.vna_next
;
11318 vstart
+= aux
.vna_next
;
11321 if (j
< ent
.vn_cnt
)
11322 warn (_("Missing Version Needs auxillary information\n"));
11324 if (ent
.vn_next
< sizeof (*entry
)
11325 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
11327 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
11328 cnt
= section
->sh_info
;
11331 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
11333 idx
+= ent
.vn_next
;
11336 if (cnt
< section
->sh_info
)
11337 warn (_("Missing Version Needs information\n"));
11343 case SHT_GNU_versym
:
11345 Elf_Internal_Shdr
* link_section
;
11348 unsigned char * edata
;
11349 unsigned short * data
;
11351 Elf_Internal_Sym
* symbols
;
11352 Elf_Internal_Shdr
* string_sec
;
11353 unsigned long num_syms
;
11356 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
11359 link_section
= filedata
->section_headers
+ section
->sh_link
;
11360 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
11362 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
11367 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
11368 if (symbols
== NULL
)
11371 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
11373 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
11374 string_sec
->sh_size
,
11375 _("version string table"));
11382 printf (ngettext ("\nVersion symbols section '%s' "
11383 "contains %lu entry:\n",
11384 "\nVersion symbols section '%s' "
11385 "contains %lu entries:\n",
11387 printable_section_name (filedata
, section
), (unsigned long) total
);
11389 printf (_(" Addr: 0x"));
11390 printf_vma (section
->sh_addr
);
11391 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11392 (unsigned long) section
->sh_offset
, section
->sh_link
,
11393 printable_section_name (filedata
, link_section
));
11395 off
= offset_from_vma (filedata
,
11396 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11397 total
* sizeof (short));
11398 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
11399 sizeof (short), total
,
11400 _("version symbol data"));
11408 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
11410 for (cnt
= total
; cnt
--;)
11411 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
11416 for (cnt
= 0; cnt
< total
; cnt
+= 4)
11420 char *invalid
= _("*invalid*");
11422 printf (" %03x:", cnt
);
11424 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
11425 switch (data
[cnt
+ j
])
11428 fputs (_(" 0 (*local*) "), stdout
);
11432 fputs (_(" 1 (*global*) "), stdout
);
11436 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
11437 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
11439 /* If this index value is greater than the size of the symbols
11440 array, break to avoid an out-of-bounds read. */
11441 if ((unsigned long)(cnt
+ j
) >= num_syms
)
11443 warn (_("invalid index into symbol array\n"));
11448 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11450 Elf_Internal_Verneed ivn
;
11451 unsigned long offset
;
11453 offset
= offset_from_vma
11455 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11456 sizeof (Elf_External_Verneed
));
11460 Elf_Internal_Vernaux ivna
;
11461 Elf_External_Verneed evn
;
11462 Elf_External_Vernaux evna
;
11463 unsigned long a_off
;
11465 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11466 _("version need")) == NULL
)
11469 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11470 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11472 a_off
= offset
+ ivn
.vn_aux
;
11476 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
11477 1, _("version need aux (2)")) == NULL
)
11480 ivna
.vna_other
= 0;
11484 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11485 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11488 a_off
+= ivna
.vna_next
;
11490 while (ivna
.vna_other
!= data
[cnt
+ j
]
11491 && ivna
.vna_next
!= 0);
11493 if (ivna
.vna_other
== data
[cnt
+ j
])
11495 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11497 if (ivna
.vna_name
>= string_sec
->sh_size
)
11500 name
= strtab
+ ivna
.vna_name
;
11504 offset
+= ivn
.vn_next
;
11506 while (ivn
.vn_next
);
11509 if (data
[cnt
+ j
] != 0x8001
11510 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11512 Elf_Internal_Verdef ivd
;
11513 Elf_External_Verdef evd
;
11514 unsigned long offset
;
11516 offset
= offset_from_vma
11518 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11523 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11524 _("version def")) == NULL
)
11527 /* PR 17531: file: 046-1082287-0.004. */
11528 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11533 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11534 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11537 offset
+= ivd
.vd_next
;
11539 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11540 && ivd
.vd_next
!= 0);
11542 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11544 Elf_External_Verdaux evda
;
11545 Elf_Internal_Verdaux ivda
;
11547 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11549 if (get_data (&evda
, filedata
,
11550 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11552 _("version def aux")) == NULL
)
11555 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11557 if (ivda
.vda_name
>= string_sec
->sh_size
)
11559 else if (name
!= NULL
&& name
!= invalid
)
11560 name
= _("*both*");
11562 name
= strtab
+ ivda
.vda_name
;
11566 nn
+= printf ("(%s%-*s",
11568 12 - (int) strlen (name
),
11572 printf ("%*c", 18 - nn
, ' ');
11590 printf (_("\nNo version information found in this file.\n"));
11595 static const char *
11596 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11598 static char buff
[64];
11602 case STB_LOCAL
: return "LOCAL";
11603 case STB_GLOBAL
: return "GLOBAL";
11604 case STB_WEAK
: return "WEAK";
11606 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11607 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11609 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11611 if (binding
== STB_GNU_UNIQUE
11612 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11614 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11617 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11622 static const char *
11623 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11625 static char buff
[64];
11629 case STT_NOTYPE
: return "NOTYPE";
11630 case STT_OBJECT
: return "OBJECT";
11631 case STT_FUNC
: return "FUNC";
11632 case STT_SECTION
: return "SECTION";
11633 case STT_FILE
: return "FILE";
11634 case STT_COMMON
: return "COMMON";
11635 case STT_TLS
: return "TLS";
11636 case STT_RELC
: return "RELC";
11637 case STT_SRELC
: return "SRELC";
11639 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11641 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11642 return "THUMB_FUNC";
11644 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11647 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11648 return "PARISC_MILLI";
11650 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11652 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11654 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11656 if (type
== STT_HP_OPAQUE
)
11657 return "HP_OPAQUE";
11658 if (type
== STT_HP_STUB
)
11662 if (type
== STT_GNU_IFUNC
11663 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11664 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
11667 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11670 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11675 static const char *
11676 get_symbol_visibility (unsigned int visibility
)
11678 switch (visibility
)
11680 case STV_DEFAULT
: return "DEFAULT";
11681 case STV_INTERNAL
: return "INTERNAL";
11682 case STV_HIDDEN
: return "HIDDEN";
11683 case STV_PROTECTED
: return "PROTECTED";
11685 error (_("Unrecognized visibility value: %u\n"), visibility
);
11686 return _("<unknown>");
11690 static const char *
11691 get_alpha_symbol_other (unsigned int other
)
11695 case STO_ALPHA_NOPV
: return "NOPV";
11696 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
11698 error (_("Unrecognized alpha specific other value: %u\n"), other
);
11699 return _("<unknown>");
11703 static const char *
11704 get_solaris_symbol_visibility (unsigned int visibility
)
11706 switch (visibility
)
11708 case 4: return "EXPORTED";
11709 case 5: return "SINGLETON";
11710 case 6: return "ELIMINATE";
11711 default: return get_symbol_visibility (visibility
);
11715 static const char *
11716 get_aarch64_symbol_other (unsigned int other
)
11718 static char buf
[32];
11720 if (other
& STO_AARCH64_VARIANT_PCS
)
11722 other
&= ~STO_AARCH64_VARIANT_PCS
;
11724 return "VARIANT_PCS";
11725 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
11731 static const char *
11732 get_mips_symbol_other (unsigned int other
)
11736 case STO_OPTIONAL
: return "OPTIONAL";
11737 case STO_MIPS_PLT
: return "MIPS PLT";
11738 case STO_MIPS_PIC
: return "MIPS PIC";
11739 case STO_MICROMIPS
: return "MICROMIPS";
11740 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11741 case STO_MIPS16
: return "MIPS16";
11742 default: return NULL
;
11746 static const char *
11747 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11749 if (is_ia64_vms (filedata
))
11751 static char res
[32];
11755 /* Function types is for images and .STB files only. */
11756 switch (filedata
->file_header
.e_type
)
11760 switch (VMS_ST_FUNC_TYPE (other
))
11762 case VMS_SFT_CODE_ADDR
:
11763 strcat (res
, " CA");
11765 case VMS_SFT_SYMV_IDX
:
11766 strcat (res
, " VEC");
11769 strcat (res
, " FD");
11771 case VMS_SFT_RESERVE
:
11772 strcat (res
, " RSV");
11775 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11776 VMS_ST_FUNC_TYPE (other
));
11777 strcat (res
, " <unknown>");
11784 switch (VMS_ST_LINKAGE (other
))
11786 case VMS_STL_IGNORE
:
11787 strcat (res
, " IGN");
11789 case VMS_STL_RESERVE
:
11790 strcat (res
, " RSV");
11793 strcat (res
, " STD");
11796 strcat (res
, " LNK");
11799 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11800 VMS_ST_LINKAGE (other
));
11801 strcat (res
, " <unknown>");
11813 static const char *
11814 get_ppc64_symbol_other (unsigned int other
)
11816 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11819 other
>>= STO_PPC64_LOCAL_BIT
;
11822 static char buf
[64];
11824 other
= ppc64_decode_local_entry (other
);
11825 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11831 static const char *
11832 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11834 const char * result
= NULL
;
11835 static char buff
[64];
11840 switch (filedata
->file_header
.e_machine
)
11843 result
= get_alpha_symbol_other (other
);
11846 result
= get_aarch64_symbol_other (other
);
11849 result
= get_mips_symbol_other (other
);
11852 result
= get_ia64_symbol_other (filedata
, other
);
11855 result
= get_ppc64_symbol_other (other
);
11865 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11869 static const char *
11870 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11872 static char buff
[32];
11876 case SHN_UNDEF
: return "UND";
11877 case SHN_ABS
: return "ABS";
11878 case SHN_COMMON
: return "COM";
11880 if (type
== SHN_IA_64_ANSI_COMMON
11881 && filedata
->file_header
.e_machine
== EM_IA_64
11882 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11884 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11885 || filedata
->file_header
.e_machine
== EM_L1OM
11886 || filedata
->file_header
.e_machine
== EM_K1OM
)
11887 && type
== SHN_X86_64_LCOMMON
)
11888 return "LARGE_COM";
11889 else if ((type
== SHN_MIPS_SCOMMON
11890 && filedata
->file_header
.e_machine
== EM_MIPS
)
11891 || (type
== SHN_TIC6X_SCOMMON
11892 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11894 else if (type
== SHN_MIPS_SUNDEFINED
11895 && filedata
->file_header
.e_machine
== EM_MIPS
)
11897 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11898 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11899 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11900 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11901 else if (type
>= SHN_LORESERVE
)
11902 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11903 else if (filedata
->file_header
.e_shnum
!= 0
11904 && type
>= filedata
->file_header
.e_shnum
)
11905 sprintf (buff
, _("bad section index[%3d]"), type
);
11907 sprintf (buff
, "%3d", type
);
11914 static const char *
11915 get_symbol_version_string (Filedata
* filedata
,
11916 bfd_boolean is_dynsym
,
11917 const char * strtab
,
11918 unsigned long int strtab_size
,
11920 Elf_Internal_Sym
* psym
,
11921 enum versioned_symbol_info
* sym_info
,
11922 unsigned short * vna_other
)
11924 unsigned char data
[2];
11925 unsigned short vers_data
;
11926 unsigned long offset
;
11927 unsigned short max_vd_ndx
;
11930 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11933 offset
= offset_from_vma (filedata
,
11934 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11935 sizeof data
+ si
* sizeof (vers_data
));
11937 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11938 sizeof (data
), 1, _("version data")) == NULL
)
11941 vers_data
= byte_get (data
, 2);
11943 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11946 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
11949 /* Usually we'd only see verdef for defined symbols, and verneed for
11950 undefined symbols. However, symbols defined by the linker in
11951 .dynbss for variables copied from a shared library in order to
11952 avoid text relocations are defined yet have verneed. We could
11953 use a heuristic to detect the special case, for example, check
11954 for verneed first on symbols defined in SHT_NOBITS sections, but
11955 it is simpler and more reliable to just look for both verdef and
11956 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11958 if (psym
->st_shndx
!= SHN_UNDEF
11959 && vers_data
!= 0x8001
11960 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11962 Elf_Internal_Verdef ivd
;
11963 Elf_Internal_Verdaux ivda
;
11964 Elf_External_Verdaux evda
;
11967 off
= offset_from_vma (filedata
,
11968 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11969 sizeof (Elf_External_Verdef
));
11973 Elf_External_Verdef evd
;
11975 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11976 _("version def")) == NULL
)
11985 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11986 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11987 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11988 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11991 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11992 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11994 off
+= ivd
.vd_next
;
11996 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11998 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
12000 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
12003 off
-= ivd
.vd_next
;
12006 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
12007 _("version def aux")) != NULL
)
12009 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
12011 if (psym
->st_name
!= ivda
.vda_name
)
12012 return (ivda
.vda_name
< strtab_size
12013 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
12018 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
12020 Elf_External_Verneed evn
;
12021 Elf_Internal_Verneed ivn
;
12022 Elf_Internal_Vernaux ivna
;
12024 offset
= offset_from_vma (filedata
,
12025 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
12029 unsigned long vna_off
;
12031 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
12032 _("version need")) == NULL
)
12035 ivna
.vna_other
= 0;
12040 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
12041 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
12043 vna_off
= offset
+ ivn
.vn_aux
;
12047 Elf_External_Vernaux evna
;
12049 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
12050 _("version need aux (3)")) == NULL
)
12053 ivna
.vna_other
= 0;
12058 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
12059 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
12060 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
12063 vna_off
+= ivna
.vna_next
;
12065 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
12067 if (ivna
.vna_other
== vers_data
)
12070 offset
+= ivn
.vn_next
;
12072 while (ivn
.vn_next
!= 0);
12074 if (ivna
.vna_other
== vers_data
)
12076 *sym_info
= symbol_undefined
;
12077 *vna_other
= ivna
.vna_other
;
12078 return (ivna
.vna_name
< strtab_size
12079 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
12081 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
12082 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
12083 return _("<corrupt>");
12089 print_dynamic_symbol (Filedata
*filedata
, unsigned long si
,
12090 Elf_Internal_Sym
*symtab
,
12091 Elf_Internal_Shdr
*section
,
12092 char *strtab
, size_t strtab_size
)
12094 const char *version_string
;
12095 enum versioned_symbol_info sym_info
;
12096 unsigned short vna_other
;
12097 Elf_Internal_Sym
*psym
= symtab
+ si
;
12099 printf ("%6ld: ", si
);
12100 print_vma (psym
->st_value
, LONG_HEX
);
12102 print_vma (psym
->st_size
, DEC_5
);
12103 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12104 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12105 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12106 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12109 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12111 printf (" %-7s", get_symbol_visibility (vis
));
12112 /* Check to see if any other bits in the st_other field are set.
12113 Note - displaying this information disrupts the layout of the
12114 table being generated, but for the moment this case is very rare. */
12115 if (psym
->st_other
^ vis
)
12116 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12118 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12120 bfd_boolean is_valid
= VALID_SYMBOL_NAME (strtab
, strtab_size
,
12122 const char * sstr
= is_valid
? strtab
+ psym
->st_name
: _("<corrupt>");
12125 = get_symbol_version_string (filedata
,
12127 || section
->sh_type
== SHT_DYNSYM
),
12128 strtab
, strtab_size
, si
,
12129 psym
, &sym_info
, &vna_other
);
12131 int len_avail
= 21;
12132 if (! do_wide
&& version_string
!= NULL
)
12136 len_avail
-= 1 + strlen (version_string
);
12138 if (sym_info
== symbol_undefined
)
12139 len_avail
-= sprintf (buffer
," (%d)", vna_other
);
12140 else if (sym_info
!= symbol_hidden
)
12144 print_symbol (len_avail
, sstr
);
12146 if (version_string
)
12148 if (sym_info
== symbol_undefined
)
12149 printf ("@%s (%d)", version_string
, vna_other
);
12151 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12157 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12159 && si
>= section
->sh_info
12160 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12161 && filedata
->file_header
.e_machine
!= EM_MIPS
12162 /* Solaris binaries have been found to violate this requirement as
12163 well. Not sure if this is a bug or an ABI requirement. */
12164 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12165 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12166 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12169 /* Dump the symbol table. */
12171 process_symbol_table (Filedata
* filedata
)
12173 Elf_Internal_Shdr
* section
;
12175 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
12178 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
12180 && do_using_dynamic
12181 && filedata
->dynamic_strings
!= NULL
12182 && filedata
->dynamic_symbols
!= NULL
)
12186 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
12187 "\nSymbol table for image contains %lu entries:\n",
12188 filedata
->num_dynamic_syms
),
12189 filedata
->num_dynamic_syms
);
12191 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12193 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12195 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
12196 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
12197 filedata
->dynamic_strings
,
12198 filedata
->dynamic_strings_length
);
12200 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
12201 && filedata
->section_headers
!= NULL
)
12205 for (i
= 0, section
= filedata
->section_headers
;
12206 i
< filedata
->file_header
.e_shnum
;
12209 char * strtab
= NULL
;
12210 unsigned long int strtab_size
= 0;
12211 Elf_Internal_Sym
* symtab
;
12212 unsigned long si
, num_syms
;
12214 if ((section
->sh_type
!= SHT_SYMTAB
12215 && section
->sh_type
!= SHT_DYNSYM
)
12217 && section
->sh_type
== SHT_SYMTAB
))
12220 if (section
->sh_entsize
== 0)
12222 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12223 printable_section_name (filedata
, section
));
12227 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12228 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12229 "\nSymbol table '%s' contains %lu entries:\n",
12231 printable_section_name (filedata
, section
),
12235 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12237 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12239 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
12240 if (symtab
== NULL
)
12243 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12245 strtab
= filedata
->string_table
;
12246 strtab_size
= filedata
->string_table_length
;
12248 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12250 Elf_Internal_Shdr
* string_sec
;
12252 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12254 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12255 1, string_sec
->sh_size
,
12256 _("string table"));
12257 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12260 for (si
= 0; si
< num_syms
; si
++)
12261 print_dynamic_symbol (filedata
, si
, symtab
, section
,
12262 strtab
, strtab_size
);
12265 if (strtab
!= filedata
->string_table
)
12271 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12273 if (do_histogram
&& filedata
->buckets
!= NULL
)
12275 unsigned long * lengths
;
12276 unsigned long * counts
;
12279 unsigned long maxlength
= 0;
12280 unsigned long nzero_counts
= 0;
12281 unsigned long nsyms
= 0;
12284 printf (ngettext ("\nHistogram for bucket list length "
12285 "(total of %lu bucket):\n",
12286 "\nHistogram for bucket list length "
12287 "(total of %lu buckets):\n",
12288 (unsigned long) filedata
->nbuckets
),
12289 (unsigned long) filedata
->nbuckets
);
12291 lengths
= (unsigned long *) calloc (filedata
->nbuckets
,
12292 sizeof (*lengths
));
12293 if (lengths
== NULL
)
12295 error (_("Out of memory allocating space for histogram buckets\n"));
12298 visited
= xcmalloc (filedata
->nchains
, 1);
12299 memset (visited
, 0, filedata
->nchains
);
12301 printf (_(" Length Number %% of total Coverage\n"));
12302 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12304 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
12307 if (maxlength
< ++lengths
[hn
])
12309 if (si
>= filedata
->nchains
|| visited
[si
])
12311 error (_("histogram chain is corrupt\n"));
12319 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12320 if (counts
== NULL
)
12323 error (_("Out of memory allocating space for histogram counts\n"));
12327 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12328 ++counts
[lengths
[hn
]];
12330 if (filedata
->nbuckets
> 0)
12333 printf (" 0 %-10lu (%5.1f%%)\n",
12334 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
12335 for (i
= 1; i
<= maxlength
; ++i
)
12337 nzero_counts
+= counts
[i
] * i
;
12338 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12339 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
12340 (nzero_counts
* 100.0) / nsyms
);
12348 free (filedata
->buckets
);
12349 filedata
->buckets
= NULL
;
12350 filedata
->nbuckets
= 0;
12351 free (filedata
->chains
);
12352 filedata
->chains
= NULL
;
12354 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
12356 unsigned long * lengths
;
12357 unsigned long * counts
;
12359 unsigned long maxlength
= 0;
12360 unsigned long nzero_counts
= 0;
12361 unsigned long nsyms
= 0;
12363 printf (ngettext ("\nHistogram for `%s' bucket list length "
12364 "(total of %lu bucket):\n",
12365 "\nHistogram for `%s' bucket list length "
12366 "(total of %lu buckets):\n",
12367 (unsigned long) filedata
->ngnubuckets
),
12368 GNU_HASH_SECTION_NAME (filedata
),
12369 (unsigned long) filedata
->ngnubuckets
);
12371 lengths
= (unsigned long *) calloc (filedata
->ngnubuckets
,
12372 sizeof (*lengths
));
12373 if (lengths
== NULL
)
12375 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12379 printf (_(" Length Number %% of total Coverage\n"));
12381 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12382 if (filedata
->gnubuckets
[hn
] != 0)
12384 bfd_vma off
, length
= 1;
12386 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
12387 /* PR 17531 file: 010-77222-0.004. */
12388 off
< filedata
->ngnuchains
12389 && (filedata
->gnuchains
[off
] & 1) == 0;
12392 lengths
[hn
] = length
;
12393 if (length
> maxlength
)
12394 maxlength
= length
;
12398 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12399 if (counts
== NULL
)
12402 error (_("Out of memory allocating space for gnu histogram counts\n"));
12406 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12407 ++counts
[lengths
[hn
]];
12409 if (filedata
->ngnubuckets
> 0)
12412 printf (" 0 %-10lu (%5.1f%%)\n",
12413 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
12414 for (j
= 1; j
<= maxlength
; ++j
)
12416 nzero_counts
+= counts
[j
] * j
;
12417 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12418 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
12419 (nzero_counts
* 100.0) / nsyms
);
12426 free (filedata
->gnubuckets
);
12427 filedata
->gnubuckets
= NULL
;
12428 filedata
->ngnubuckets
= 0;
12429 free (filedata
->gnuchains
);
12430 filedata
->gnuchains
= NULL
;
12431 filedata
->ngnuchains
= 0;
12432 free (filedata
->mipsxlat
);
12433 filedata
->mipsxlat
= NULL
;
12437 free (filedata
->gnubuckets
);
12438 filedata
->gnubuckets
= NULL
;
12439 filedata
->ngnubuckets
= 0;
12440 free (filedata
->gnuchains
);
12441 filedata
->gnuchains
= NULL
;
12442 filedata
->ngnuchains
= 0;
12443 free (filedata
->mipsxlat
);
12444 filedata
->mipsxlat
= NULL
;
12445 free (filedata
->buckets
);
12446 filedata
->buckets
= NULL
;
12447 filedata
->nbuckets
= 0;
12448 free (filedata
->chains
);
12449 filedata
->chains
= NULL
;
12454 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12458 if (filedata
->dynamic_syminfo
== NULL
12460 /* No syminfo, this is ok. */
12463 /* There better should be a dynamic symbol section. */
12464 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
12467 if (filedata
->dynamic_addr
)
12468 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12469 "contains %d entry:\n",
12470 "\nDynamic info segment at offset 0x%lx "
12471 "contains %d entries:\n",
12472 filedata
->dynamic_syminfo_nent
),
12473 filedata
->dynamic_syminfo_offset
, filedata
->dynamic_syminfo_nent
);
12475 printf (_(" Num: Name BoundTo Flags\n"));
12476 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
12478 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
12480 printf ("%4d: ", i
);
12481 if (i
>= filedata
->num_dynamic_syms
)
12482 printf (_("<corrupt index>"));
12483 else if (VALID_DYNAMIC_NAME (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
12484 print_symbol (30, GET_DYNAMIC_NAME (filedata
,
12485 filedata
->dynamic_symbols
[i
].st_name
));
12487 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
12490 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
12492 case SYMINFO_BT_SELF
:
12493 fputs ("SELF ", stdout
);
12495 case SYMINFO_BT_PARENT
:
12496 fputs ("PARENT ", stdout
);
12499 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
12500 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
12501 && VALID_DYNAMIC_NAME (filedata
,
12502 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12504 print_symbol (10, GET_DYNAMIC_NAME (filedata
,
12505 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12509 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
12513 if (flags
& SYMINFO_FLG_DIRECT
)
12514 printf (" DIRECT");
12515 if (flags
& SYMINFO_FLG_PASSTHRU
)
12516 printf (" PASSTHRU");
12517 if (flags
& SYMINFO_FLG_COPY
)
12519 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12520 printf (" LAZYLOAD");
12528 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12529 is contained by the region START .. END. The types of ADDR, START
12530 and END should all be the same. Note both ADDR + NELEM and END
12531 point to just beyond the end of the regions that are being tested. */
12532 #define IN_RANGE(START,END,ADDR,NELEM) \
12533 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12535 /* Check to see if the given reloc needs to be handled in a target specific
12536 manner. If so then process the reloc and return TRUE otherwise return
12539 If called with reloc == NULL, then this is a signal that reloc processing
12540 for the current section has finished, and any saved state should be
12544 target_specific_reloc_handling (Filedata
* filedata
,
12545 Elf_Internal_Rela
* reloc
,
12546 unsigned char * start
,
12547 unsigned char * end
,
12548 Elf_Internal_Sym
* symtab
,
12549 unsigned long num_syms
)
12551 unsigned int reloc_type
= 0;
12552 unsigned long sym_index
= 0;
12556 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12557 sym_index
= get_reloc_symindex (reloc
->r_info
);
12560 switch (filedata
->file_header
.e_machine
)
12563 case EM_MSP430_OLD
:
12565 static Elf_Internal_Sym
* saved_sym
= NULL
;
12573 switch (reloc_type
)
12575 case 10: /* R_MSP430_SYM_DIFF */
12576 if (uses_msp430x_relocs (filedata
))
12578 /* Fall through. */
12579 case 21: /* R_MSP430X_SYM_DIFF */
12581 if (sym_index
>= num_syms
)
12582 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12585 saved_sym
= symtab
+ sym_index
;
12588 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12589 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12590 goto handle_sym_diff
;
12592 case 5: /* R_MSP430_16_BYTE */
12593 case 9: /* R_MSP430_8 */
12594 if (uses_msp430x_relocs (filedata
))
12596 goto handle_sym_diff
;
12598 case 2: /* R_MSP430_ABS16 */
12599 case 15: /* R_MSP430X_ABS16 */
12600 if (! uses_msp430x_relocs (filedata
))
12602 goto handle_sym_diff
;
12605 if (saved_sym
!= NULL
)
12607 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12610 if (sym_index
>= num_syms
)
12611 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12615 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12616 - saved_sym
->st_value
);
12618 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12619 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12622 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12623 (long) reloc
->r_offset
);
12632 if (saved_sym
!= NULL
)
12633 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12640 case EM_CYGNUS_MN10300
:
12642 static Elf_Internal_Sym
* saved_sym
= NULL
;
12650 switch (reloc_type
)
12652 case 34: /* R_MN10300_ALIGN */
12654 case 33: /* R_MN10300_SYM_DIFF */
12655 if (sym_index
>= num_syms
)
12656 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12659 saved_sym
= symtab
+ sym_index
;
12662 case 1: /* R_MN10300_32 */
12663 case 2: /* R_MN10300_16 */
12664 if (saved_sym
!= NULL
)
12666 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12669 if (sym_index
>= num_syms
)
12670 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12674 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12675 - saved_sym
->st_value
);
12677 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12678 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12680 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12681 (long) reloc
->r_offset
);
12689 if (saved_sym
!= NULL
)
12690 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12698 static bfd_vma saved_sym1
= 0;
12699 static bfd_vma saved_sym2
= 0;
12700 static bfd_vma value
;
12704 saved_sym1
= saved_sym2
= 0;
12708 switch (reloc_type
)
12710 case 0x80: /* R_RL78_SYM. */
12711 saved_sym1
= saved_sym2
;
12712 if (sym_index
>= num_syms
)
12713 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12717 saved_sym2
= symtab
[sym_index
].st_value
;
12718 saved_sym2
+= reloc
->r_addend
;
12722 case 0x83: /* R_RL78_OPsub. */
12723 value
= saved_sym1
- saved_sym2
;
12724 saved_sym2
= saved_sym1
= 0;
12728 case 0x41: /* R_RL78_ABS32. */
12729 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12730 byte_put (start
+ reloc
->r_offset
, value
, 4);
12732 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12733 (long) reloc
->r_offset
);
12737 case 0x43: /* R_RL78_ABS16. */
12738 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12739 byte_put (start
+ reloc
->r_offset
, value
, 2);
12741 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12742 (long) reloc
->r_offset
);
12756 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12757 DWARF debug sections. This is a target specific test. Note - we do not
12758 go through the whole including-target-headers-multiple-times route, (as
12759 we have already done with <elf/h8.h>) because this would become very
12760 messy and even then this function would have to contain target specific
12761 information (the names of the relocs instead of their numeric values).
12762 FIXME: This is not the correct way to solve this problem. The proper way
12763 is to have target specific reloc sizing and typing functions created by
12764 the reloc-macros.h header, in the same way that it already creates the
12765 reloc naming functions. */
12768 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12770 /* Please keep this table alpha-sorted for ease of visual lookup. */
12771 switch (filedata
->file_header
.e_machine
)
12775 return reloc_type
== 1; /* R_386_32. */
12777 return reloc_type
== 1; /* R_68K_32. */
12779 return reloc_type
== 1; /* R_860_32. */
12781 return reloc_type
== 2; /* R_960_32. */
12783 return (reloc_type
== 258
12784 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12786 return reloc_type
== 11; /* R_BPF_DATA_32 */
12787 case EM_ADAPTEVA_EPIPHANY
:
12788 return reloc_type
== 3;
12790 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12792 return reloc_type
== 1; /* R_ARC_32. */
12793 case EM_ARC_COMPACT
:
12794 case EM_ARC_COMPACT2
:
12795 return reloc_type
== 4; /* R_ARC_32. */
12797 return reloc_type
== 2; /* R_ARM_ABS32 */
12800 return reloc_type
== 1;
12802 return reloc_type
== 0x12; /* R_byte4_data. */
12804 return reloc_type
== 3; /* R_CRIS_32. */
12806 return reloc_type
== 3; /* R_CR16_NUM32. */
12808 return reloc_type
== 15; /* R_CRX_NUM32. */
12810 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12811 case EM_CYGNUS_FRV
:
12812 return reloc_type
== 1;
12813 case EM_CYGNUS_D10V
:
12815 return reloc_type
== 6; /* R_D10V_32. */
12816 case EM_CYGNUS_D30V
:
12818 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12820 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12821 case EM_CYGNUS_FR30
:
12823 return reloc_type
== 3; /* R_FR30_32. */
12825 return reloc_type
== 1; /* R_FT32_32. */
12829 return reloc_type
== 1; /* R_H8_DIR32. */
12831 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12832 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12833 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12834 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12837 return reloc_type
== 2; /* R_IP2K_32. */
12839 return reloc_type
== 2; /* R_IQ2000_32. */
12840 case EM_LATTICEMICO32
:
12841 return reloc_type
== 3; /* R_LM32_32. */
12844 return reloc_type
== 3; /* R_M32C_32. */
12846 return reloc_type
== 34; /* R_M32R_32_RELA. */
12849 return reloc_type
== 6; /* R_M68HC11_32. */
12851 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12852 reloc_type
== 6; /* R_S12Z_CW32. */
12854 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12855 case EM_CYGNUS_MEP
:
12856 return reloc_type
== 4; /* R_MEP_32. */
12858 return reloc_type
== 2; /* R_METAG_ADDR32. */
12859 case EM_MICROBLAZE
:
12860 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12862 return reloc_type
== 2; /* R_MIPS_32. */
12864 return reloc_type
== 4; /* R_MMIX_32. */
12865 case EM_CYGNUS_MN10200
:
12867 return reloc_type
== 1; /* R_MN10200_32. */
12868 case EM_CYGNUS_MN10300
:
12870 return reloc_type
== 1; /* R_MN10300_32. */
12872 return reloc_type
== 1; /* R_MOXIE_32. */
12873 case EM_MSP430_OLD
:
12875 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12877 return reloc_type
== 2; /* R_MT_32. */
12879 return reloc_type
== 20; /* R_NDS32_RELA. */
12880 case EM_ALTERA_NIOS2
:
12881 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12883 return reloc_type
== 1; /* R_NIOS_32. */
12885 return reloc_type
== 1; /* R_OR1K_32. */
12887 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12888 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12889 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12892 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12894 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12896 return reloc_type
== 1; /* R_PPC_ADDR32. */
12898 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12900 return reloc_type
== 1; /* R_RISCV_32. */
12902 return reloc_type
== 1; /* R_RL78_DIR32. */
12904 return reloc_type
== 1; /* R_RX_DIR32. */
12906 return reloc_type
== 1; /* R_I370_ADDR31. */
12909 return reloc_type
== 4; /* R_S390_32. */
12911 return reloc_type
== 8; /* R_SCORE_ABS32. */
12913 return reloc_type
== 1; /* R_SH_DIR32. */
12914 case EM_SPARC32PLUS
:
12917 return reloc_type
== 3 /* R_SPARC_32. */
12918 || reloc_type
== 23; /* R_SPARC_UA32. */
12920 return reloc_type
== 6; /* R_SPU_ADDR32 */
12922 return reloc_type
== 1; /* R_C6000_ABS32. */
12924 return reloc_type
== 2; /* R_TILEGX_32. */
12926 return reloc_type
== 1; /* R_TILEPRO_32. */
12927 case EM_CYGNUS_V850
:
12929 return reloc_type
== 6; /* R_V850_ABS32. */
12931 return reloc_type
== 0x33; /* R_V810_WORD. */
12933 return reloc_type
== 1; /* R_VAX_32. */
12935 return reloc_type
== 3; /* R_VISIUM_32. */
12936 case EM_WEBASSEMBLY
:
12937 return reloc_type
== 1; /* R_WASM32_32. */
12941 return reloc_type
== 10; /* R_X86_64_32. */
12944 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12946 return reloc_type
== 4; /* R_XGATE_32. */
12948 return reloc_type
== 1; /* R_XSTROMY16_32. */
12949 case EM_XTENSA_OLD
:
12951 return reloc_type
== 1; /* R_XTENSA_32. */
12953 return reloc_type
== 6; /* R_Z80_32. */
12956 static unsigned int prev_warn
= 0;
12958 /* Avoid repeating the same warning multiple times. */
12959 if (prev_warn
!= filedata
->file_header
.e_machine
)
12960 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12961 filedata
->file_header
.e_machine
);
12962 prev_warn
= filedata
->file_header
.e_machine
;
12968 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12969 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12972 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12974 switch (filedata
->file_header
.e_machine
)
12975 /* Please keep this table alpha-sorted for ease of visual lookup. */
12979 return reloc_type
== 2; /* R_386_PC32. */
12981 return reloc_type
== 4; /* R_68K_PC32. */
12983 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12984 case EM_ADAPTEVA_EPIPHANY
:
12985 return reloc_type
== 6;
12987 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12988 case EM_ARC_COMPACT
:
12989 case EM_ARC_COMPACT2
:
12990 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12992 return reloc_type
== 3; /* R_ARM_REL32 */
12995 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12996 case EM_MICROBLAZE
:
12997 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12999 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
13001 return reloc_type
== 9; /* R_PARISC_PCREL32. */
13003 return reloc_type
== 26; /* R_PPC_REL32. */
13005 return reloc_type
== 26; /* R_PPC64_REL32. */
13007 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
13010 return reloc_type
== 5; /* R_390_PC32. */
13012 return reloc_type
== 2; /* R_SH_REL32. */
13013 case EM_SPARC32PLUS
:
13016 return reloc_type
== 6; /* R_SPARC_DISP32. */
13018 return reloc_type
== 13; /* R_SPU_REL32. */
13020 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
13022 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
13024 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
13028 return reloc_type
== 2; /* R_X86_64_PC32. */
13030 return reloc_type
== 4; /* R_VAX_PCREL32. */
13031 case EM_XTENSA_OLD
:
13033 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
13035 /* Do not abort or issue an error message here. Not all targets use
13036 pc-relative 32-bit relocs in their DWARF debug information and we
13037 have already tested for target coverage in is_32bit_abs_reloc. A
13038 more helpful warning message will be generated by apply_relocations
13039 anyway, so just return. */
13044 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13045 a 64-bit absolute RELA relocation used in DWARF debug sections. */
13048 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13050 switch (filedata
->file_header
.e_machine
)
13053 return reloc_type
== 257; /* R_AARCH64_ABS64. */
13055 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
13057 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
13058 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
13060 return reloc_type
== 80; /* R_PARISC_DIR64. */
13062 return reloc_type
== 38; /* R_PPC64_ADDR64. */
13064 return reloc_type
== 2; /* R_RISCV_64. */
13065 case EM_SPARC32PLUS
:
13068 return reloc_type
== 32 /* R_SPARC_64. */
13069 || reloc_type
== 54; /* R_SPARC_UA64. */
13073 return reloc_type
== 1; /* R_X86_64_64. */
13076 return reloc_type
== 22; /* R_S390_64. */
13078 return reloc_type
== 1; /* R_TILEGX_64. */
13080 return reloc_type
== 18; /* R_MIPS_64. */
13086 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
13087 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
13090 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13092 switch (filedata
->file_header
.e_machine
)
13095 return reloc_type
== 260; /* R_AARCH64_PREL64. */
13097 return reloc_type
== 11; /* R_ALPHA_SREL64. */
13099 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
13100 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
13102 return reloc_type
== 72; /* R_PARISC_PCREL64. */
13104 return reloc_type
== 44; /* R_PPC64_REL64. */
13105 case EM_SPARC32PLUS
:
13108 return reloc_type
== 46; /* R_SPARC_DISP64. */
13112 return reloc_type
== 24; /* R_X86_64_PC64. */
13115 return reloc_type
== 23; /* R_S390_PC64. */
13117 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
13123 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13124 a 24-bit absolute RELA relocation used in DWARF debug sections. */
13127 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13129 switch (filedata
->file_header
.e_machine
)
13131 case EM_CYGNUS_MN10200
:
13133 return reloc_type
== 4; /* R_MN10200_24. */
13135 return reloc_type
== 5; /* R_FT32_20. */
13137 return reloc_type
== 5; /* R_Z80_24. */
13143 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13144 a 16-bit absolute RELA relocation used in DWARF debug sections. */
13147 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13149 /* Please keep this table alpha-sorted for ease of visual lookup. */
13150 switch (filedata
->file_header
.e_machine
)
13153 case EM_ARC_COMPACT
:
13154 case EM_ARC_COMPACT2
:
13155 return reloc_type
== 2; /* R_ARC_16. */
13156 case EM_ADAPTEVA_EPIPHANY
:
13157 return reloc_type
== 5;
13160 return reloc_type
== 4; /* R_AVR_16. */
13161 case EM_CYGNUS_D10V
:
13163 return reloc_type
== 3; /* R_D10V_16. */
13165 return reloc_type
== 2; /* R_FT32_16. */
13169 return reloc_type
== R_H8_DIR16
;
13172 return reloc_type
== 1; /* R_IP2K_16. */
13175 return reloc_type
== 1; /* R_M32C_16 */
13176 case EM_CYGNUS_MN10200
:
13178 return reloc_type
== 2; /* R_MN10200_16. */
13179 case EM_CYGNUS_MN10300
:
13181 return reloc_type
== 2; /* R_MN10300_16. */
13183 if (uses_msp430x_relocs (filedata
))
13184 return reloc_type
== 2; /* R_MSP430_ABS16. */
13185 /* Fall through. */
13186 case EM_MSP430_OLD
:
13187 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13189 return reloc_type
== 19; /* R_NDS32_RELA. */
13190 case EM_ALTERA_NIOS2
:
13191 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13193 return reloc_type
== 9; /* R_NIOS_16. */
13195 return reloc_type
== 2; /* R_OR1K_16. */
13197 return reloc_type
== 55; /* R_RISCV_SET16. */
13199 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13201 return reloc_type
== 2; /* R_C6000_ABS16. */
13203 return reloc_type
== 2; /* R_VISIUM_16. */
13206 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13208 return reloc_type
== 3; /* R_XGATE_16. */
13210 return reloc_type
== 4; /* R_Z80_16. */
13216 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13217 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13220 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13222 switch (filedata
->file_header
.e_machine
)
13225 return reloc_type
== 54; /* R_RISCV_SET8. */
13227 return reloc_type
== 1; /* R_Z80_8. */
13233 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13234 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13237 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13239 switch (filedata
->file_header
.e_machine
)
13242 return reloc_type
== 53; /* R_RISCV_SET6. */
13248 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13249 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13252 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13254 /* Please keep this table alpha-sorted for ease of visual lookup. */
13255 switch (filedata
->file_header
.e_machine
)
13258 return reloc_type
== 35; /* R_RISCV_ADD32. */
13264 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13265 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13268 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13270 /* Please keep this table alpha-sorted for ease of visual lookup. */
13271 switch (filedata
->file_header
.e_machine
)
13274 return reloc_type
== 39; /* R_RISCV_SUB32. */
13280 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13281 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13284 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13286 /* Please keep this table alpha-sorted for ease of visual lookup. */
13287 switch (filedata
->file_header
.e_machine
)
13290 return reloc_type
== 36; /* R_RISCV_ADD64. */
13296 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13297 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13300 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13302 /* Please keep this table alpha-sorted for ease of visual lookup. */
13303 switch (filedata
->file_header
.e_machine
)
13306 return reloc_type
== 40; /* R_RISCV_SUB64. */
13312 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13313 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13316 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13318 /* Please keep this table alpha-sorted for ease of visual lookup. */
13319 switch (filedata
->file_header
.e_machine
)
13322 return reloc_type
== 34; /* R_RISCV_ADD16. */
13328 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13329 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13332 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13334 /* Please keep this table alpha-sorted for ease of visual lookup. */
13335 switch (filedata
->file_header
.e_machine
)
13338 return reloc_type
== 38; /* R_RISCV_SUB16. */
13344 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13345 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13348 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13350 /* Please keep this table alpha-sorted for ease of visual lookup. */
13351 switch (filedata
->file_header
.e_machine
)
13354 return reloc_type
== 33; /* R_RISCV_ADD8. */
13360 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13361 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13364 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13366 /* Please keep this table alpha-sorted for ease of visual lookup. */
13367 switch (filedata
->file_header
.e_machine
)
13370 return reloc_type
== 37; /* R_RISCV_SUB8. */
13376 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13377 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13380 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13382 switch (filedata
->file_header
.e_machine
)
13385 return reloc_type
== 52; /* R_RISCV_SUB6. */
13391 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13392 relocation entries (possibly formerly used for SHT_GROUP sections). */
13395 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13397 switch (filedata
->file_header
.e_machine
)
13399 case EM_386
: /* R_386_NONE. */
13400 case EM_68K
: /* R_68K_NONE. */
13401 case EM_ADAPTEVA_EPIPHANY
:
13402 case EM_ALPHA
: /* R_ALPHA_NONE. */
13403 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13404 case EM_ARC
: /* R_ARC_NONE. */
13405 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13406 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13407 case EM_ARM
: /* R_ARM_NONE. */
13408 case EM_C166
: /* R_XC16X_NONE. */
13409 case EM_CRIS
: /* R_CRIS_NONE. */
13410 case EM_FT32
: /* R_FT32_NONE. */
13411 case EM_IA_64
: /* R_IA64_NONE. */
13412 case EM_K1OM
: /* R_X86_64_NONE. */
13413 case EM_L1OM
: /* R_X86_64_NONE. */
13414 case EM_M32R
: /* R_M32R_NONE. */
13415 case EM_MIPS
: /* R_MIPS_NONE. */
13416 case EM_MN10300
: /* R_MN10300_NONE. */
13417 case EM_MOXIE
: /* R_MOXIE_NONE. */
13418 case EM_NIOS32
: /* R_NIOS_NONE. */
13419 case EM_OR1K
: /* R_OR1K_NONE. */
13420 case EM_PARISC
: /* R_PARISC_NONE. */
13421 case EM_PPC64
: /* R_PPC64_NONE. */
13422 case EM_PPC
: /* R_PPC_NONE. */
13423 case EM_RISCV
: /* R_RISCV_NONE. */
13424 case EM_S390
: /* R_390_NONE. */
13426 case EM_SH
: /* R_SH_NONE. */
13427 case EM_SPARC32PLUS
:
13428 case EM_SPARC
: /* R_SPARC_NONE. */
13430 case EM_TILEGX
: /* R_TILEGX_NONE. */
13431 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13432 case EM_TI_C6000
:/* R_C6000_NONE. */
13433 case EM_X86_64
: /* R_X86_64_NONE. */
13435 case EM_Z80
: /* R_Z80_NONE. */
13436 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13437 return reloc_type
== 0;
13440 return reloc_type
== 0 || reloc_type
== 256;
13443 return (reloc_type
== 0 /* R_AVR_NONE. */
13444 || reloc_type
== 30 /* R_AVR_DIFF8. */
13445 || reloc_type
== 31 /* R_AVR_DIFF16. */
13446 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13448 return reloc_type
== 3; /* R_METAG_NONE. */
13450 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13451 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13452 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13453 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13454 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13456 return (reloc_type
== 0 /* R_PRU_NONE. */
13457 || reloc_type
== 65 /* R_PRU_DIFF8. */
13458 || reloc_type
== 66 /* R_PRU_DIFF16. */
13459 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13460 case EM_XTENSA_OLD
:
13462 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13463 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13464 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13465 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
13466 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
13467 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
13468 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
13469 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
13470 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
13471 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
13476 /* Returns TRUE if there is a relocation against
13477 section NAME at OFFSET bytes. */
13480 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13482 Elf_Internal_Rela
* relocs
;
13483 Elf_Internal_Rela
* rp
;
13485 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13488 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13490 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13491 if (rp
->r_offset
== offset
)
13497 /* Apply relocations to a section.
13498 Returns TRUE upon success, FALSE otherwise.
13499 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13500 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13501 will be set to the number of relocs loaded.
13503 Note: So far support has been added only for those relocations
13504 which can be found in debug sections. FIXME: Add support for
13505 more relocations ? */
13508 apply_relocations (Filedata
* filedata
,
13509 const Elf_Internal_Shdr
* section
,
13510 unsigned char * start
,
13511 bfd_size_type size
,
13512 void ** relocs_return
,
13513 unsigned long * num_relocs_return
)
13515 Elf_Internal_Shdr
* relsec
;
13516 unsigned char * end
= start
+ size
;
13518 if (relocs_return
!= NULL
)
13520 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13521 * num_relocs_return
= 0;
13524 if (filedata
->file_header
.e_type
!= ET_REL
)
13525 /* No relocs to apply. */
13528 /* Find the reloc section associated with the section. */
13529 for (relsec
= filedata
->section_headers
;
13530 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13533 bfd_boolean is_rela
;
13534 unsigned long num_relocs
;
13535 Elf_Internal_Rela
* relocs
;
13536 Elf_Internal_Rela
* rp
;
13537 Elf_Internal_Shdr
* symsec
;
13538 Elf_Internal_Sym
* symtab
;
13539 unsigned long num_syms
;
13540 Elf_Internal_Sym
* sym
;
13542 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13543 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13544 || filedata
->section_headers
+ relsec
->sh_info
!= section
13545 || relsec
->sh_size
== 0
13546 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13549 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13550 if (symsec
->sh_type
!= SHT_SYMTAB
13551 && symsec
->sh_type
!= SHT_DYNSYM
)
13554 is_rela
= relsec
->sh_type
== SHT_RELA
;
13558 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13559 relsec
->sh_size
, & relocs
, & num_relocs
))
13564 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13565 relsec
->sh_size
, & relocs
, & num_relocs
))
13569 /* SH uses RELA but uses in place value instead of the addend field. */
13570 if (filedata
->file_header
.e_machine
== EM_SH
)
13573 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13575 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13578 unsigned int reloc_type
;
13579 unsigned int reloc_size
;
13580 bfd_boolean reloc_inplace
= FALSE
;
13581 bfd_boolean reloc_subtract
= FALSE
;
13582 unsigned char * rloc
;
13583 unsigned long sym_index
;
13585 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13587 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13589 else if (is_none_reloc (filedata
, reloc_type
))
13591 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13592 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13594 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13595 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13597 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13599 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13601 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13602 || is_6bit_abs_reloc (filedata
, reloc_type
))
13604 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13606 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13609 reloc_inplace
= TRUE
;
13611 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13613 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13616 reloc_inplace
= TRUE
;
13618 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13620 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13623 reloc_inplace
= TRUE
;
13625 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13627 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13630 reloc_inplace
= TRUE
;
13632 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13636 reloc_inplace
= TRUE
;
13640 static unsigned int prev_reloc
= 0;
13642 if (reloc_type
!= prev_reloc
)
13643 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13644 reloc_type
, printable_section_name (filedata
, section
));
13645 prev_reloc
= reloc_type
;
13649 rloc
= start
+ rp
->r_offset
;
13650 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
13652 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13653 (unsigned long) rp
->r_offset
,
13654 printable_section_name (filedata
, section
));
13658 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13659 if (sym_index
>= num_syms
)
13661 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13662 sym_index
, printable_section_name (filedata
, section
));
13665 sym
= symtab
+ sym_index
;
13667 /* If the reloc has a symbol associated with it,
13668 make sure that it is of an appropriate type.
13670 Relocations against symbols without type can happen.
13671 Gcc -feliminate-dwarf2-dups may generate symbols
13672 without type for debug info.
13674 Icc generates relocations against function symbols
13675 instead of local labels.
13677 Relocations against object symbols can happen, eg when
13678 referencing a global array. For an example of this see
13679 the _clz.o binary in libgcc.a. */
13681 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13682 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13684 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13685 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13686 printable_section_name (filedata
, relsec
),
13687 (long int)(rp
- relocs
));
13693 addend
+= rp
->r_addend
;
13694 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13695 partial_inplace. */
13697 || (filedata
->file_header
.e_machine
== EM_XTENSA
13698 && reloc_type
== 1)
13699 || ((filedata
->file_header
.e_machine
== EM_PJ
13700 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13701 && reloc_type
== 1)
13702 || ((filedata
->file_header
.e_machine
== EM_D30V
13703 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13704 && reloc_type
== 12)
13707 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13708 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13710 addend
+= byte_get (rloc
, reloc_size
);
13713 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13714 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13716 /* On HPPA, all pc-relative relocations are biased by 8. */
13717 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13719 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13722 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13723 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13725 if (reloc_subtract
)
13726 addend
-= sym
->st_value
;
13728 addend
+= sym
->st_value
;
13729 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13730 byte_put (rloc
, addend
, reloc_size
);
13732 else if (reloc_subtract
)
13733 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13735 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13739 /* Let the target specific reloc processing code know that
13740 we have finished with these relocs. */
13741 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13745 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13746 * num_relocs_return
= num_relocs
;
13757 #ifdef SUPPORT_DISASSEMBLY
13759 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13761 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13763 /* FIXME: XXX -- to be done --- XXX */
13769 /* Reads in the contents of SECTION from FILE, returning a pointer
13770 to a malloc'ed buffer or NULL if something went wrong. */
13773 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13775 bfd_size_type num_bytes
= section
->sh_size
;
13777 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13779 printf (_("Section '%s' has no data to dump.\n"),
13780 printable_section_name (filedata
, section
));
13784 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13785 _("section contents"));
13788 /* Uncompresses a section that was compressed using zlib, in place. */
13791 uncompress_section_contents (unsigned char ** buffer
,
13792 dwarf_size_type uncompressed_size
,
13793 dwarf_size_type
* size
)
13795 dwarf_size_type compressed_size
= *size
;
13796 unsigned char * compressed_buffer
= *buffer
;
13797 unsigned char * uncompressed_buffer
;
13801 /* It is possible the section consists of several compressed
13802 buffers concatenated together, so we uncompress in a loop. */
13803 /* PR 18313: The state field in the z_stream structure is supposed
13804 to be invisible to the user (ie us), but some compilers will
13805 still complain about it being used without initialisation. So
13806 we first zero the entire z_stream structure and then set the fields
13808 memset (& strm
, 0, sizeof strm
);
13809 strm
.avail_in
= compressed_size
;
13810 strm
.next_in
= (Bytef
*) compressed_buffer
;
13811 strm
.avail_out
= uncompressed_size
;
13812 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13814 rc
= inflateInit (& strm
);
13815 while (strm
.avail_in
> 0)
13819 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13820 + (uncompressed_size
- strm
.avail_out
));
13821 rc
= inflate (&strm
, Z_FINISH
);
13822 if (rc
!= Z_STREAM_END
)
13824 rc
= inflateReset (& strm
);
13826 rc
= inflateEnd (& strm
);
13828 || strm
.avail_out
!= 0)
13831 *buffer
= uncompressed_buffer
;
13832 *size
= uncompressed_size
;
13836 free (uncompressed_buffer
);
13837 /* Indicate decompression failure. */
13843 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13845 Elf_Internal_Shdr
* relsec
;
13846 bfd_size_type num_bytes
;
13847 unsigned char * data
;
13848 unsigned char * end
;
13849 unsigned char * real_start
;
13850 unsigned char * start
;
13851 bfd_boolean some_strings_shown
;
13853 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13855 /* PR 21820: Do not fail if the section was empty. */
13856 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13858 num_bytes
= section
->sh_size
;
13860 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13862 if (decompress_dumps
)
13864 dwarf_size_type new_size
= num_bytes
;
13865 dwarf_size_type uncompressed_size
= 0;
13867 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13869 Elf_Internal_Chdr chdr
;
13870 unsigned int compression_header_size
13871 = get_compression_header (& chdr
, (unsigned char *) start
,
13873 if (compression_header_size
== 0)
13874 /* An error message will have already been generated
13875 by get_compression_header. */
13878 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13880 warn (_("section '%s' has unsupported compress type: %d\n"),
13881 printable_section_name (filedata
, section
), chdr
.ch_type
);
13884 uncompressed_size
= chdr
.ch_size
;
13885 start
+= compression_header_size
;
13886 new_size
-= compression_header_size
;
13888 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13890 /* Read the zlib header. In this case, it should be "ZLIB"
13891 followed by the uncompressed section size, 8 bytes in
13892 big-endian order. */
13893 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13894 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13895 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13896 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13897 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13898 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13899 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13900 uncompressed_size
+= start
[11];
13905 if (uncompressed_size
)
13907 if (uncompress_section_contents (& start
,
13908 uncompressed_size
, & new_size
))
13909 num_bytes
= new_size
;
13912 error (_("Unable to decompress section %s\n"),
13913 printable_section_name (filedata
, section
));
13918 start
= real_start
;
13921 /* If the section being dumped has relocations against it the user might
13922 be expecting these relocations to have been applied. Check for this
13923 case and issue a warning message in order to avoid confusion.
13924 FIXME: Maybe we ought to have an option that dumps a section with
13925 relocs applied ? */
13926 for (relsec
= filedata
->section_headers
;
13927 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13930 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13931 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13932 || filedata
->section_headers
+ relsec
->sh_info
!= section
13933 || relsec
->sh_size
== 0
13934 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13937 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13942 end
= start
+ num_bytes
;
13943 some_strings_shown
= FALSE
;
13945 #ifdef HAVE_MBSTATE_T
13947 /* Initialise the multibyte conversion state. */
13948 memset (& state
, 0, sizeof (state
));
13951 bfd_boolean continuing
= FALSE
;
13955 while (!ISPRINT (* data
))
13956 if (++ data
>= end
)
13961 size_t maxlen
= end
- data
;
13966 continuing
= FALSE
;
13970 printf (" [%6lx] ", (unsigned long) (data
- start
));
13984 /* PR 25543: Treat new-lines as string-ending characters. */
13993 /* Do not print control characters directly as they can affect terminal
13994 settings. Such characters usually appear in the names generated
13995 by the assembler for local labels. */
13998 printf ("^%c", c
+ 0x40);
14000 else if (ISPRINT (c
))
14007 #ifdef HAVE_MBSTATE_T
14010 /* Let printf do the hard work of displaying multibyte characters. */
14011 printf ("%.1s", data
- 1);
14012 #ifdef HAVE_MBSTATE_T
14013 /* Try to find out how many bytes made up the character that was
14014 just printed. Advance the symbol pointer past the bytes that
14016 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
14020 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
14030 printf (_("<corrupt>\n"));
14033 some_strings_shown
= TRUE
;
14037 if (! some_strings_shown
)
14038 printf (_(" No strings found in this section."));
14051 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
14052 Filedata
* filedata
,
14053 bfd_boolean relocate
)
14055 Elf_Internal_Shdr
* relsec
;
14056 bfd_size_type bytes
;
14057 bfd_size_type section_size
;
14059 unsigned char * data
;
14060 unsigned char * real_start
;
14061 unsigned char * start
;
14063 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
14065 /* PR 21820: Do not fail if the section was empty. */
14066 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
14068 section_size
= section
->sh_size
;
14070 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
14072 if (decompress_dumps
)
14074 dwarf_size_type new_size
= section_size
;
14075 dwarf_size_type uncompressed_size
= 0;
14077 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14079 Elf_Internal_Chdr chdr
;
14080 unsigned int compression_header_size
14081 = get_compression_header (& chdr
, start
, section_size
);
14083 if (compression_header_size
== 0)
14084 /* An error message will have already been generated
14085 by get_compression_header. */
14088 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14090 warn (_("section '%s' has unsupported compress type: %d\n"),
14091 printable_section_name (filedata
, section
), chdr
.ch_type
);
14094 uncompressed_size
= chdr
.ch_size
;
14095 start
+= compression_header_size
;
14096 new_size
-= compression_header_size
;
14098 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14100 /* Read the zlib header. In this case, it should be "ZLIB"
14101 followed by the uncompressed section size, 8 bytes in
14102 big-endian order. */
14103 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14104 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14105 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14106 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14107 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14108 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14109 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14110 uncompressed_size
+= start
[11];
14115 if (uncompressed_size
)
14117 if (uncompress_section_contents (& start
, uncompressed_size
,
14120 section_size
= new_size
;
14124 error (_("Unable to decompress section %s\n"),
14125 printable_section_name (filedata
, section
));
14126 /* FIXME: Print the section anyway ? */
14131 start
= real_start
;
14136 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
14141 /* If the section being dumped has relocations against it the user might
14142 be expecting these relocations to have been applied. Check for this
14143 case and issue a warning message in order to avoid confusion.
14144 FIXME: Maybe we ought to have an option that dumps a section with
14145 relocs applied ? */
14146 for (relsec
= filedata
->section_headers
;
14147 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14150 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14151 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14152 || filedata
->section_headers
+ relsec
->sh_info
!= section
14153 || relsec
->sh_size
== 0
14154 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14157 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14162 addr
= section
->sh_addr
;
14163 bytes
= section_size
;
14172 lbytes
= (bytes
> 16 ? 16 : bytes
);
14174 printf (" 0x%8.8lx ", (unsigned long) addr
);
14176 for (j
= 0; j
< 16; j
++)
14179 printf ("%2.2x", data
[j
]);
14187 for (j
= 0; j
< lbytes
; j
++)
14190 if (k
>= ' ' && k
< 0x7f)
14213 #ifdef ENABLE_LIBCTF
14214 static ctf_sect_t
*
14215 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14217 buf
->cts_name
= SECTION_NAME (shdr
);
14218 buf
->cts_size
= shdr
->sh_size
;
14219 buf
->cts_entsize
= shdr
->sh_entsize
;
14224 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14225 it is passed, or a pointer to newly-allocated storage, in which case
14226 dump_ctf() will free it when it no longer needs it. */
14229 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14230 char *s
, void *arg
)
14232 const char *blanks
= arg
;
14235 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14240 /* Dump CTF errors/warnings. */
14242 dump_ctf_errs (ctf_file_t
*fp
)
14244 ctf_next_t
*it
= NULL
;
14249 /* Dump accumulated errors and warnings. */
14250 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
14252 error (_("%s: `%s'"), is_warning
? _("warning"): _("error"),
14256 if (err
!= ECTF_NEXT_END
)
14257 error (_("CTF error: cannot get CTF errors: `%s'"), ctf_errmsg (err
));
14260 /* Dump one CTF archive member. */
14263 dump_ctf_archive_member (ctf_file_t
*ctf
, const char *name
, void *arg
)
14265 ctf_file_t
*parent
= (ctf_file_t
*) arg
;
14266 const char *things
[] = {"Header", "Labels", "Data objects",
14267 "Function objects", "Variables", "Types", "Strings",
14269 const char **thing
;
14273 /* Only print out the name of non-default-named archive members.
14274 The name .ctf appears everywhere, even for things that aren't
14275 really archives, so printing it out is liable to be confusing.
14277 The parent, if there is one, is the default-owned archive member:
14278 avoid importing it into itself. (This does no harm, but looks
14281 if (strcmp (name
, ".ctf") != 0)
14283 printf (_("\nCTF archive member: %s:\n"), name
);
14284 ctf_import (ctf
, parent
);
14287 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14289 ctf_dump_state_t
*s
= NULL
;
14292 printf ("\n %s:\n", *thing
);
14293 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14294 (void *) " ")) != NULL
)
14296 printf ("%s\n", item
);
14300 if (ctf_errno (ctf
))
14302 error (_("Iteration failed: %s, %s\n"), *thing
,
14303 ctf_errmsg (ctf_errno (ctf
)));
14310 dump_ctf_errs (ctf
);
14315 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14317 Elf_Internal_Shdr
* parent_sec
= NULL
;
14318 Elf_Internal_Shdr
* symtab_sec
= NULL
;
14319 Elf_Internal_Shdr
* strtab_sec
= NULL
;
14320 void * data
= NULL
;
14321 void * symdata
= NULL
;
14322 void * strdata
= NULL
;
14323 void * parentdata
= NULL
;
14324 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
14325 ctf_sect_t
* symsectp
= NULL
;
14326 ctf_sect_t
* strsectp
= NULL
;
14327 ctf_archive_t
* ctfa
= NULL
;
14328 ctf_archive_t
* parenta
= NULL
, *lookparent
;
14329 ctf_file_t
* parent
= NULL
;
14332 bfd_boolean ret
= FALSE
;
14334 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
14335 data
= get_section_contents (section
, filedata
);
14336 ctfsect
.cts_data
= data
;
14338 if (!dump_ctf_symtab_name
)
14339 dump_ctf_symtab_name
= strdup (".symtab");
14341 if (!dump_ctf_strtab_name
)
14342 dump_ctf_strtab_name
= strdup (".strtab");
14344 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
14346 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
14348 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
14351 if ((symdata
= (void *) get_data (NULL
, filedata
,
14352 symtab_sec
->sh_offset
, 1,
14353 symtab_sec
->sh_size
,
14354 _("symbols"))) == NULL
)
14356 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
14357 symsect
.cts_data
= symdata
;
14359 if (dump_ctf_strtab_name
&& dump_ctf_strtab_name
[0] != 0)
14361 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
14363 error (_("No string table section named %s\n"),
14364 dump_ctf_strtab_name
);
14367 if ((strdata
= (void *) get_data (NULL
, filedata
,
14368 strtab_sec
->sh_offset
, 1,
14369 strtab_sec
->sh_size
,
14370 _("strings"))) == NULL
)
14372 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
14373 strsect
.cts_data
= strdata
;
14375 if (dump_ctf_parent_name
)
14377 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
14379 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
14382 if ((parentdata
= (void *) get_data (NULL
, filedata
,
14383 parent_sec
->sh_offset
, 1,
14384 parent_sec
->sh_size
,
14385 _("CTF parent"))) == NULL
)
14387 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
14388 parentsect
.cts_data
= parentdata
;
14391 /* Load the CTF file and dump it. It may be a raw CTF section, or an archive:
14392 libctf papers over the difference, so we can pretend it is always an
14393 archive. Possibly open the parent as well, if one was specified. */
14395 if ((ctfa
= ctf_arc_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14397 dump_ctf_errs (NULL
);
14398 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14404 if ((parenta
= ctf_arc_bufopen (&parentsect
, symsectp
, strsectp
,
14407 dump_ctf_errs (NULL
);
14408 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14411 lookparent
= parenta
;
14416 /* Assume that the applicable parent archive member is the default one.
14417 (This is what all known implementations are expected to do, if they
14418 put CTFs and their parents in archives together.) */
14419 if ((parent
= ctf_arc_open_by_name (lookparent
, NULL
, &err
)) == NULL
)
14421 dump_ctf_errs (NULL
);
14422 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14428 printf (_("\nDump of CTF section '%s':\n"),
14429 printable_section_name (filedata
, section
));
14431 if (ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
) != 0)
14435 ctf_file_close (parent
);
14437 ctf_close (parenta
);
14447 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14448 const Elf_Internal_Shdr
* sec
,
14451 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14453 Filedata
* filedata
= (Filedata
*) data
;
14455 if (section
->start
!= NULL
)
14457 /* If it is already loaded, do nothing. */
14458 if (streq (section
->filename
, filedata
->file_name
))
14460 free (section
->start
);
14463 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14464 section
->address
= sec
->sh_addr
;
14465 section
->user_data
= NULL
;
14466 section
->filename
= filedata
->file_name
;
14467 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14469 sec
->sh_size
, buf
);
14470 if (section
->start
== NULL
)
14474 unsigned char *start
= section
->start
;
14475 dwarf_size_type size
= sec
->sh_size
;
14476 dwarf_size_type uncompressed_size
= 0;
14478 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14480 Elf_Internal_Chdr chdr
;
14481 unsigned int compression_header_size
;
14483 if (size
< (is_32bit_elf
14484 ? sizeof (Elf32_External_Chdr
)
14485 : sizeof (Elf64_External_Chdr
)))
14487 warn (_("compressed section %s is too small to contain a compression header\n"),
14492 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14493 if (compression_header_size
== 0)
14494 /* An error message will have already been generated
14495 by get_compression_header. */
14498 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14500 warn (_("section '%s' has unsupported compress type: %d\n"),
14501 section
->name
, chdr
.ch_type
);
14504 uncompressed_size
= chdr
.ch_size
;
14505 start
+= compression_header_size
;
14506 size
-= compression_header_size
;
14508 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14510 /* Read the zlib header. In this case, it should be "ZLIB"
14511 followed by the uncompressed section size, 8 bytes in
14512 big-endian order. */
14513 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14514 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14515 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14516 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14517 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14518 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14519 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14520 uncompressed_size
+= start
[11];
14525 if (uncompressed_size
)
14527 if (uncompress_section_contents (&start
, uncompressed_size
,
14530 /* Free the compressed buffer, update the section buffer
14531 and the section size if uncompress is successful. */
14532 free (section
->start
);
14533 section
->start
= start
;
14537 error (_("Unable to decompress section %s\n"),
14538 printable_section_name (filedata
, sec
));
14543 section
->size
= size
;
14546 if (section
->start
== NULL
)
14549 if (debug_displays
[debug
].relocate
)
14551 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14552 & section
->reloc_info
, & section
->num_relocs
))
14557 section
->reloc_info
= NULL
;
14558 section
->num_relocs
= 0;
14564 #if HAVE_LIBDEBUGINFOD
14565 /* Return a hex string representation of the build-id. */
14567 get_build_id (void * data
)
14569 Filedata
* filedata
= (Filedata
*)data
;
14570 Elf_Internal_Shdr
* shdr
;
14573 /* Iterate through notes to find note.gnu.build-id.
14574 FIXME: Only the first note in any note section is examined. */
14575 for (i
= 0, shdr
= filedata
->section_headers
;
14576 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
14579 if (shdr
->sh_type
!= SHT_NOTE
)
14584 size_t data_remaining
;
14586 Elf_External_Note
* enote
;
14587 Elf_Internal_Note inote
;
14589 bfd_vma offset
= shdr
->sh_offset
;
14590 bfd_vma align
= shdr
->sh_addralign
;
14591 bfd_vma length
= shdr
->sh_size
;
14593 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
14599 else if (align
!= 4 && align
!= 8)
14605 end
= (char *) enote
+ length
;
14606 data_remaining
= end
- (char *) enote
;
14608 if (!is_ia64_vms (filedata
))
14610 min_notesz
= offsetof (Elf_External_Note
, name
);
14611 if (data_remaining
< min_notesz
)
14614 malformed note encountered in section %s whilst scanning for build-id note\n"),
14615 printable_section_name (filedata
, shdr
));
14619 data_remaining
-= min_notesz
;
14621 inote
.type
= BYTE_GET (enote
->type
);
14622 inote
.namesz
= BYTE_GET (enote
->namesz
);
14623 inote
.namedata
= enote
->name
;
14624 inote
.descsz
= BYTE_GET (enote
->descsz
);
14625 inote
.descdata
= ((char *) enote
14626 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
14627 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14628 next
= ((char *) enote
14629 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
14633 Elf64_External_VMS_Note
*vms_enote
;
14635 /* PR binutils/15191
14636 Make sure that there is enough data to read. */
14637 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14638 if (data_remaining
< min_notesz
)
14641 malformed note encountered in section %s whilst scanning for build-id note\n"),
14642 printable_section_name (filedata
, shdr
));
14646 data_remaining
-= min_notesz
;
14648 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
14649 inote
.type
= BYTE_GET (vms_enote
->type
);
14650 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
14651 inote
.namedata
= vms_enote
->name
;
14652 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
14653 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14654 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14655 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14658 /* Skip malformed notes. */
14659 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
14660 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
14661 || (size_t) (next
- inote
.descdata
) < inote
.descsz
14662 || ((size_t) (next
- inote
.descdata
)
14663 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
14666 malformed note encountered in section %s whilst scanning for build-id note\n"),
14667 printable_section_name (filedata
, shdr
));
14672 /* Check if this is the build-id note. If so then convert the build-id
14673 bytes to a hex string. */
14674 if (inote
.namesz
> 0
14675 && const_strneq (inote
.namedata
, "GNU")
14676 && inote
.type
== NT_GNU_BUILD_ID
)
14681 build_id
= malloc (inote
.descsz
* 2 + 1);
14682 if (build_id
== NULL
)
14688 for (j
= 0; j
< inote
.descsz
; ++j
)
14689 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
14690 build_id
[inote
.descsz
* 2] = '\0';
14693 return (unsigned char *) build_id
;
14700 #endif /* HAVE_LIBDEBUGINFOD */
14702 /* If this is not NULL, load_debug_section will only look for sections
14703 within the list of sections given here. */
14704 static unsigned int * section_subset
= NULL
;
14707 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
14709 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14710 Elf_Internal_Shdr
* sec
;
14711 Filedata
* filedata
= (Filedata
*) data
;
14713 /* Without section headers we cannot find any sections. */
14714 if (filedata
->section_headers
== NULL
)
14717 if (filedata
->string_table
== NULL
14718 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
14719 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
14721 Elf_Internal_Shdr
* strs
;
14723 /* Read in the string table, so that we have section names to scan. */
14724 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
14726 if (strs
!= NULL
&& strs
->sh_size
!= 0)
14728 filedata
->string_table
14729 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
14730 1, strs
->sh_size
, _("string table"));
14732 filedata
->string_table_length
14733 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
14737 /* Locate the debug section. */
14738 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
14740 section
->name
= section
->uncompressed_name
;
14743 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
14745 section
->name
= section
->compressed_name
;
14750 /* If we're loading from a subset of sections, and we've loaded
14751 a section matching this name before, it's likely that it's a
14753 if (section_subset
!= NULL
)
14754 free_debug_section (debug
);
14756 return load_specific_debug_section (debug
, sec
, data
);
14760 free_debug_section (enum dwarf_section_display_enum debug
)
14762 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14764 if (section
->start
== NULL
)
14767 free ((char *) section
->start
);
14768 section
->start
= NULL
;
14769 section
->address
= 0;
14772 free (section
->reloc_info
);
14773 section
->reloc_info
= NULL
;
14774 section
->num_relocs
= 0;
14778 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14780 char * name
= SECTION_NAME (section
);
14781 const char * print_name
= printable_section_name (filedata
, section
);
14782 bfd_size_type length
;
14783 bfd_boolean result
= TRUE
;
14786 length
= section
->sh_size
;
14789 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
14792 if (section
->sh_type
== SHT_NOBITS
)
14794 /* There is no point in dumping the contents of a debugging section
14795 which has the NOBITS type - the bits in the file will be random.
14796 This can happen when a file containing a .eh_frame section is
14797 stripped with the --only-keep-debug command line option. */
14798 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14803 if (const_strneq (name
, ".gnu.linkonce.wi."))
14804 name
= ".debug_info";
14806 /* See if we know how to display the contents of this section. */
14807 for (i
= 0; i
< max
; i
++)
14809 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
14810 struct dwarf_section_display
* display
= debug_displays
+ i
;
14811 struct dwarf_section
* sec
= & display
->section
;
14813 if (streq (sec
->uncompressed_name
, name
)
14814 || (id
== line
&& const_strneq (name
, ".debug_line."))
14815 || streq (sec
->compressed_name
, name
))
14817 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
14820 free_debug_section (id
);
14822 if (i
== line
&& const_strneq (name
, ".debug_line."))
14824 else if (streq (sec
->uncompressed_name
, name
))
14825 sec
->name
= sec
->uncompressed_name
;
14827 sec
->name
= sec
->compressed_name
;
14829 if (load_specific_debug_section (id
, section
, filedata
))
14831 /* If this debug section is part of a CU/TU set in a .dwp file,
14832 restrict load_debug_section to the sections in that set. */
14833 section_subset
= find_cu_tu_set (filedata
, shndx
);
14835 result
&= display
->display (sec
, filedata
);
14837 section_subset
= NULL
;
14839 if (secondary
|| (id
!= info
&& id
!= abbrev
))
14840 free_debug_section (id
);
14848 printf (_("Unrecognized debug section: %s\n"), print_name
);
14855 /* Set DUMP_SECTS for all sections where dumps were requested
14856 based on section name. */
14859 initialise_dumps_byname (Filedata
* filedata
)
14861 struct dump_list_entry
* cur
;
14863 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14866 bfd_boolean any
= FALSE
;
14868 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14869 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14871 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
14876 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14882 process_section_contents (Filedata
* filedata
)
14884 Elf_Internal_Shdr
* section
;
14886 bfd_boolean res
= TRUE
;
14891 initialise_dumps_byname (filedata
);
14893 for (i
= 0, section
= filedata
->section_headers
;
14894 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
14897 dump_type dump
= filedata
->dump
.dump_sects
[i
];
14899 #ifdef SUPPORT_DISASSEMBLY
14900 if (dump
& DISASS_DUMP
)
14902 if (! disassemble_section (section
, filedata
))
14906 if (dump
& HEX_DUMP
)
14908 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14912 if (dump
& RELOC_DUMP
)
14914 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14918 if (dump
& STRING_DUMP
)
14920 if (! dump_section_as_strings (section
, filedata
))
14924 if (dump
& DEBUG_DUMP
)
14926 if (! display_debug_section (i
, section
, filedata
))
14930 #ifdef ENABLE_LIBCTF
14931 if (dump
& CTF_DUMP
)
14933 if (! dump_section_as_ctf (section
, filedata
))
14939 /* Check to see if the user requested a
14940 dump of a section that does not exist. */
14941 while (i
< filedata
->dump
.num_dump_sects
)
14943 if (filedata
->dump
.dump_sects
[i
])
14945 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14955 process_mips_fpe_exception (int mask
)
14959 bfd_boolean first
= TRUE
;
14961 if (mask
& OEX_FPU_INEX
)
14962 fputs ("INEX", stdout
), first
= FALSE
;
14963 if (mask
& OEX_FPU_UFLO
)
14964 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14965 if (mask
& OEX_FPU_OFLO
)
14966 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14967 if (mask
& OEX_FPU_DIV0
)
14968 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14969 if (mask
& OEX_FPU_INVAL
)
14970 printf ("%sINVAL", first
? "" : "|");
14973 fputs ("0", stdout
);
14976 /* Display's the value of TAG at location P. If TAG is
14977 greater than 0 it is assumed to be an unknown tag, and
14978 a message is printed to this effect. Otherwise it is
14979 assumed that a message has already been printed.
14981 If the bottom bit of TAG is set it assumed to have a
14982 string value, otherwise it is assumed to have an integer
14985 Returns an updated P pointing to the first unread byte
14986 beyond the end of TAG's value.
14988 Reads at or beyond END will not be made. */
14990 static unsigned char *
14991 display_tag_value (signed int tag
,
14993 const unsigned char * const end
)
14998 printf (" Tag_unknown_%d: ", tag
);
15002 warn (_("<corrupt tag>\n"));
15006 /* PR 17531 file: 027-19978-0.004. */
15007 size_t maxlen
= (end
- p
) - 1;
15012 print_symbol ((int) maxlen
, (const char *) p
);
15013 p
+= strnlen ((char *) p
, maxlen
) + 1;
15017 printf (_("<corrupt string tag>"));
15018 p
= (unsigned char *) end
;
15024 READ_ULEB (val
, p
, end
);
15025 printf ("%ld (0x%lx)\n", val
, val
);
15032 /* ARC ABI attributes section. */
15034 static unsigned char *
15035 display_arc_attribute (unsigned char * p
,
15036 const unsigned char * const end
)
15041 READ_ULEB (tag
, p
, end
);
15045 case Tag_ARC_PCS_config
:
15046 READ_ULEB (val
, p
, end
);
15047 printf (" Tag_ARC_PCS_config: ");
15051 printf (_("Absent/Non standard\n"));
15054 printf (_("Bare metal/mwdt\n"));
15057 printf (_("Bare metal/newlib\n"));
15060 printf (_("Linux/uclibc\n"));
15063 printf (_("Linux/glibc\n"));
15066 printf (_("Unknown\n"));
15071 case Tag_ARC_CPU_base
:
15072 READ_ULEB (val
, p
, end
);
15073 printf (" Tag_ARC_CPU_base: ");
15078 printf (_("Absent\n"));
15080 case TAG_CPU_ARC6xx
:
15081 printf ("ARC6xx\n");
15083 case TAG_CPU_ARC7xx
:
15084 printf ("ARC7xx\n");
15086 case TAG_CPU_ARCEM
:
15087 printf ("ARCEM\n");
15089 case TAG_CPU_ARCHS
:
15090 printf ("ARCHS\n");
15095 case Tag_ARC_CPU_variation
:
15096 READ_ULEB (val
, p
, end
);
15097 printf (" Tag_ARC_CPU_variation: ");
15101 if (val
> 0 && val
< 16)
15102 printf ("Core%d\n", val
);
15104 printf ("Unknown\n");
15108 printf (_("Absent\n"));
15113 case Tag_ARC_CPU_name
:
15114 printf (" Tag_ARC_CPU_name: ");
15115 p
= display_tag_value (-1, p
, end
);
15118 case Tag_ARC_ABI_rf16
:
15119 READ_ULEB (val
, p
, end
);
15120 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
15123 case Tag_ARC_ABI_osver
:
15124 READ_ULEB (val
, p
, end
);
15125 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
15128 case Tag_ARC_ABI_pic
:
15129 case Tag_ARC_ABI_sda
:
15130 READ_ULEB (val
, p
, end
);
15131 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
15132 : " Tag_ARC_ABI_pic: ");
15136 printf (_("Absent\n"));
15145 printf (_("Unknown\n"));
15150 case Tag_ARC_ABI_tls
:
15151 READ_ULEB (val
, p
, end
);
15152 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
15155 case Tag_ARC_ABI_enumsize
:
15156 READ_ULEB (val
, p
, end
);
15157 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
15161 case Tag_ARC_ABI_exceptions
:
15162 READ_ULEB (val
, p
, end
);
15163 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
15167 case Tag_ARC_ABI_double_size
:
15168 READ_ULEB (val
, p
, end
);
15169 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
15172 case Tag_ARC_ISA_config
:
15173 printf (" Tag_ARC_ISA_config: ");
15174 p
= display_tag_value (-1, p
, end
);
15177 case Tag_ARC_ISA_apex
:
15178 printf (" Tag_ARC_ISA_apex: ");
15179 p
= display_tag_value (-1, p
, end
);
15182 case Tag_ARC_ISA_mpy_option
:
15183 READ_ULEB (val
, p
, end
);
15184 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
15187 case Tag_ARC_ATR_version
:
15188 READ_ULEB (val
, p
, end
);
15189 printf (" Tag_ARC_ATR_version: %d\n", val
);
15193 return display_tag_value (tag
& 1, p
, end
);
15199 /* ARM EABI attributes section. */
15204 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
15206 const char ** table
;
15207 } arm_attr_public_tag
;
15209 static const char * arm_attr_tag_CPU_arch
[] =
15210 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
15211 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
15212 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
15213 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
15214 static const char * arm_attr_tag_THUMB_ISA_use
[] =
15215 {"No", "Thumb-1", "Thumb-2", "Yes"};
15216 static const char * arm_attr_tag_FP_arch
[] =
15217 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
15218 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
15219 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
15220 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
15221 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
15222 "NEON for ARMv8.1"};
15223 static const char * arm_attr_tag_PCS_config
[] =
15224 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
15225 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
15226 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
15227 {"V6", "SB", "TLS", "Unused"};
15228 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
15229 {"Absolute", "PC-relative", "SB-relative", "None"};
15230 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
15231 {"Absolute", "PC-relative", "None"};
15232 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
15233 {"None", "direct", "GOT-indirect"};
15234 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
15235 {"None", "??? 1", "2", "??? 3", "4"};
15236 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
15237 static const char * arm_attr_tag_ABI_FP_denormal
[] =
15238 {"Unused", "Needed", "Sign only"};
15239 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
15240 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
15241 static const char * arm_attr_tag_ABI_FP_number_model
[] =
15242 {"Unused", "Finite", "RTABI", "IEEE 754"};
15243 static const char * arm_attr_tag_ABI_enum_size
[] =
15244 {"Unused", "small", "int", "forced to int"};
15245 static const char * arm_attr_tag_ABI_HardFP_use
[] =
15246 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
15247 static const char * arm_attr_tag_ABI_VFP_args
[] =
15248 {"AAPCS", "VFP registers", "custom", "compatible"};
15249 static const char * arm_attr_tag_ABI_WMMX_args
[] =
15250 {"AAPCS", "WMMX registers", "custom"};
15251 static const char * arm_attr_tag_ABI_optimization_goals
[] =
15252 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15253 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
15254 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
15255 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15256 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
15257 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
15258 static const char * arm_attr_tag_FP_HP_extension
[] =
15259 {"Not Allowed", "Allowed"};
15260 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
15261 {"None", "IEEE 754", "Alternative Format"};
15262 static const char * arm_attr_tag_DSP_extension
[] =
15263 {"Follow architecture", "Allowed"};
15264 static const char * arm_attr_tag_MPextension_use
[] =
15265 {"Not Allowed", "Allowed"};
15266 static const char * arm_attr_tag_DIV_use
[] =
15267 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
15268 "Allowed in v7-A with integer division extension"};
15269 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
15270 static const char * arm_attr_tag_Virtualization_use
[] =
15271 {"Not Allowed", "TrustZone", "Virtualization Extensions",
15272 "TrustZone and Virtualization Extensions"};
15273 static const char * arm_attr_tag_MPextension_use_legacy
[] =
15274 {"Not Allowed", "Allowed"};
15276 static const char * arm_attr_tag_MVE_arch
[] =
15277 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
15279 #define LOOKUP(id, name) \
15280 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
15281 static arm_attr_public_tag arm_attr_public_tags
[] =
15283 {4, "CPU_raw_name", 1, NULL
},
15284 {5, "CPU_name", 1, NULL
},
15285 LOOKUP(6, CPU_arch
),
15286 {7, "CPU_arch_profile", 0, NULL
},
15287 LOOKUP(8, ARM_ISA_use
),
15288 LOOKUP(9, THUMB_ISA_use
),
15289 LOOKUP(10, FP_arch
),
15290 LOOKUP(11, WMMX_arch
),
15291 LOOKUP(12, Advanced_SIMD_arch
),
15292 LOOKUP(13, PCS_config
),
15293 LOOKUP(14, ABI_PCS_R9_use
),
15294 LOOKUP(15, ABI_PCS_RW_data
),
15295 LOOKUP(16, ABI_PCS_RO_data
),
15296 LOOKUP(17, ABI_PCS_GOT_use
),
15297 LOOKUP(18, ABI_PCS_wchar_t
),
15298 LOOKUP(19, ABI_FP_rounding
),
15299 LOOKUP(20, ABI_FP_denormal
),
15300 LOOKUP(21, ABI_FP_exceptions
),
15301 LOOKUP(22, ABI_FP_user_exceptions
),
15302 LOOKUP(23, ABI_FP_number_model
),
15303 {24, "ABI_align_needed", 0, NULL
},
15304 {25, "ABI_align_preserved", 0, NULL
},
15305 LOOKUP(26, ABI_enum_size
),
15306 LOOKUP(27, ABI_HardFP_use
),
15307 LOOKUP(28, ABI_VFP_args
),
15308 LOOKUP(29, ABI_WMMX_args
),
15309 LOOKUP(30, ABI_optimization_goals
),
15310 LOOKUP(31, ABI_FP_optimization_goals
),
15311 {32, "compatibility", 0, NULL
},
15312 LOOKUP(34, CPU_unaligned_access
),
15313 LOOKUP(36, FP_HP_extension
),
15314 LOOKUP(38, ABI_FP_16bit_format
),
15315 LOOKUP(42, MPextension_use
),
15316 LOOKUP(44, DIV_use
),
15317 LOOKUP(46, DSP_extension
),
15318 LOOKUP(48, MVE_arch
),
15319 {64, "nodefaults", 0, NULL
},
15320 {65, "also_compatible_with", 0, NULL
},
15321 LOOKUP(66, T2EE_use
),
15322 {67, "conformance", 1, NULL
},
15323 LOOKUP(68, Virtualization_use
),
15324 LOOKUP(70, MPextension_use_legacy
)
15328 static unsigned char *
15329 display_arm_attribute (unsigned char * p
,
15330 const unsigned char * const end
)
15334 arm_attr_public_tag
* attr
;
15338 READ_ULEB (tag
, p
, end
);
15340 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
15342 if (arm_attr_public_tags
[i
].tag
== tag
)
15344 attr
= &arm_attr_public_tags
[i
];
15351 printf (" Tag_%s: ", attr
->name
);
15352 switch (attr
->type
)
15357 case 7: /* Tag_CPU_arch_profile. */
15358 READ_ULEB (val
, p
, end
);
15361 case 0: printf (_("None\n")); break;
15362 case 'A': printf (_("Application\n")); break;
15363 case 'R': printf (_("Realtime\n")); break;
15364 case 'M': printf (_("Microcontroller\n")); break;
15365 case 'S': printf (_("Application or Realtime\n")); break;
15366 default: printf ("??? (%d)\n", val
); break;
15370 case 24: /* Tag_align_needed. */
15371 READ_ULEB (val
, p
, end
);
15374 case 0: printf (_("None\n")); break;
15375 case 1: printf (_("8-byte\n")); break;
15376 case 2: printf (_("4-byte\n")); break;
15377 case 3: printf ("??? 3\n"); break;
15380 printf (_("8-byte and up to %d-byte extended\n"),
15383 printf ("??? (%d)\n", val
);
15388 case 25: /* Tag_align_preserved. */
15389 READ_ULEB (val
, p
, end
);
15392 case 0: printf (_("None\n")); break;
15393 case 1: printf (_("8-byte, except leaf SP\n")); break;
15394 case 2: printf (_("8-byte\n")); break;
15395 case 3: printf ("??? 3\n"); break;
15398 printf (_("8-byte and up to %d-byte extended\n"),
15401 printf ("??? (%d)\n", val
);
15406 case 32: /* Tag_compatibility. */
15408 READ_ULEB (val
, p
, end
);
15409 printf (_("flag = %d, vendor = "), val
);
15412 size_t maxlen
= (end
- p
) - 1;
15414 print_symbol ((int) maxlen
, (const char *) p
);
15415 p
+= strnlen ((char *) p
, maxlen
) + 1;
15419 printf (_("<corrupt>"));
15420 p
= (unsigned char *) end
;
15426 case 64: /* Tag_nodefaults. */
15427 /* PR 17531: file: 001-505008-0.01. */
15430 printf (_("True\n"));
15433 case 65: /* Tag_also_compatible_with. */
15434 READ_ULEB (val
, p
, end
);
15435 if (val
== 6 /* Tag_CPU_arch. */)
15437 READ_ULEB (val
, p
, end
);
15438 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
15439 printf ("??? (%d)\n", val
);
15441 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
15445 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
15450 printf (_("<unknown: %d>\n"), tag
);
15456 return display_tag_value (-1, p
, end
);
15458 return display_tag_value (0, p
, end
);
15461 assert (attr
->type
& 0x80);
15462 READ_ULEB (val
, p
, end
);
15463 type
= attr
->type
& 0x7f;
15465 printf ("??? (%d)\n", val
);
15467 printf ("%s\n", attr
->table
[val
]);
15472 return display_tag_value (tag
, p
, end
);
15475 static unsigned char *
15476 display_gnu_attribute (unsigned char * p
,
15477 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
15478 const unsigned char * const end
)
15483 READ_ULEB (tag
, p
, end
);
15485 /* Tag_compatibility is the only generic GNU attribute defined at
15489 READ_ULEB (val
, p
, end
);
15491 printf (_("flag = %d, vendor = "), val
);
15494 printf (_("<corrupt>\n"));
15495 warn (_("corrupt vendor attribute\n"));
15501 size_t maxlen
= (end
- p
) - 1;
15503 print_symbol ((int) maxlen
, (const char *) p
);
15504 p
+= strnlen ((char *) p
, maxlen
) + 1;
15508 printf (_("<corrupt>"));
15509 p
= (unsigned char *) end
;
15516 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15517 return display_proc_gnu_attribute (p
, tag
, end
);
15519 return display_tag_value (tag
, p
, end
);
15522 static unsigned char *
15523 display_m68k_gnu_attribute (unsigned char * p
,
15525 const unsigned char * const end
)
15529 if (tag
== Tag_GNU_M68K_ABI_FP
)
15531 printf (" Tag_GNU_M68K_ABI_FP: ");
15534 printf (_("<corrupt>\n"));
15537 READ_ULEB (val
, p
, end
);
15540 printf ("(%#x), ", val
);
15545 printf (_("unspecified hard/soft float\n"));
15548 printf (_("hard float\n"));
15551 printf (_("soft float\n"));
15557 return display_tag_value (tag
& 1, p
, end
);
15560 static unsigned char *
15561 display_power_gnu_attribute (unsigned char * p
,
15563 const unsigned char * const end
)
15567 if (tag
== Tag_GNU_Power_ABI_FP
)
15569 printf (" Tag_GNU_Power_ABI_FP: ");
15572 printf (_("<corrupt>\n"));
15575 READ_ULEB (val
, p
, end
);
15578 printf ("(%#x), ", val
);
15583 printf (_("unspecified hard/soft float, "));
15586 printf (_("hard float, "));
15589 printf (_("soft float, "));
15592 printf (_("single-precision hard float, "));
15599 printf (_("unspecified long double\n"));
15602 printf (_("128-bit IBM long double\n"));
15605 printf (_("64-bit long double\n"));
15608 printf (_("128-bit IEEE long double\n"));
15614 if (tag
== Tag_GNU_Power_ABI_Vector
)
15616 printf (" Tag_GNU_Power_ABI_Vector: ");
15619 printf (_("<corrupt>\n"));
15622 READ_ULEB (val
, p
, end
);
15625 printf ("(%#x), ", val
);
15630 printf (_("unspecified\n"));
15633 printf (_("generic\n"));
15636 printf ("AltiVec\n");
15645 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
15647 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15650 printf (_("<corrupt>\n"));
15653 READ_ULEB (val
, p
, end
);
15656 printf ("(%#x), ", val
);
15661 printf (_("unspecified\n"));
15664 printf ("r3/r4\n");
15667 printf (_("memory\n"));
15676 return display_tag_value (tag
& 1, p
, end
);
15679 static unsigned char *
15680 display_s390_gnu_attribute (unsigned char * p
,
15682 const unsigned char * const end
)
15686 if (tag
== Tag_GNU_S390_ABI_Vector
)
15688 printf (" Tag_GNU_S390_ABI_Vector: ");
15689 READ_ULEB (val
, p
, end
);
15694 printf (_("any\n"));
15697 printf (_("software\n"));
15700 printf (_("hardware\n"));
15703 printf ("??? (%d)\n", val
);
15709 return display_tag_value (tag
& 1, p
, end
);
15713 display_sparc_hwcaps (unsigned int mask
)
15717 bfd_boolean first
= TRUE
;
15719 if (mask
& ELF_SPARC_HWCAP_MUL32
)
15720 fputs ("mul32", stdout
), first
= FALSE
;
15721 if (mask
& ELF_SPARC_HWCAP_DIV32
)
15722 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
15723 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
15724 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
15725 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
15726 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
15727 if (mask
& ELF_SPARC_HWCAP_POPC
)
15728 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
15729 if (mask
& ELF_SPARC_HWCAP_VIS
)
15730 printf ("%svis", first
? "" : "|"), first
= FALSE
;
15731 if (mask
& ELF_SPARC_HWCAP_VIS2
)
15732 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
15733 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
15734 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
15735 if (mask
& ELF_SPARC_HWCAP_FMAF
)
15736 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
15737 if (mask
& ELF_SPARC_HWCAP_VIS3
)
15738 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
15739 if (mask
& ELF_SPARC_HWCAP_HPC
)
15740 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
15741 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
15742 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
15743 if (mask
& ELF_SPARC_HWCAP_TRANS
)
15744 printf ("%strans", first
? "" : "|"), first
= FALSE
;
15745 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
15746 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
15747 if (mask
& ELF_SPARC_HWCAP_IMA
)
15748 printf ("%sima", first
? "" : "|"), first
= FALSE
;
15749 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
15750 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
15753 fputc ('0', stdout
);
15754 fputc ('\n', stdout
);
15758 display_sparc_hwcaps2 (unsigned int mask
)
15762 bfd_boolean first
= TRUE
;
15764 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
15765 fputs ("fjathplus", stdout
), first
= FALSE
;
15766 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
15767 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
15768 if (mask
& ELF_SPARC_HWCAP2_ADP
)
15769 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
15770 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
15771 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
15772 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
15773 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
15774 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
15775 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
15776 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
15777 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
15778 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
15779 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
15780 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
15781 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
15782 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
15783 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
15784 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
15785 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
15788 fputc ('0', stdout
);
15789 fputc ('\n', stdout
);
15792 static unsigned char *
15793 display_sparc_gnu_attribute (unsigned char * p
,
15795 const unsigned char * const end
)
15799 if (tag
== Tag_GNU_Sparc_HWCAPS
)
15801 READ_ULEB (val
, p
, end
);
15802 printf (" Tag_GNU_Sparc_HWCAPS: ");
15803 display_sparc_hwcaps (val
);
15806 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
15808 READ_ULEB (val
, p
, end
);
15809 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15810 display_sparc_hwcaps2 (val
);
15814 return display_tag_value (tag
, p
, end
);
15818 print_mips_fp_abi_value (unsigned int val
)
15822 case Val_GNU_MIPS_ABI_FP_ANY
:
15823 printf (_("Hard or soft float\n"));
15825 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15826 printf (_("Hard float (double precision)\n"));
15828 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15829 printf (_("Hard float (single precision)\n"));
15831 case Val_GNU_MIPS_ABI_FP_SOFT
:
15832 printf (_("Soft float\n"));
15834 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15835 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15837 case Val_GNU_MIPS_ABI_FP_XX
:
15838 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15840 case Val_GNU_MIPS_ABI_FP_64
:
15841 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15843 case Val_GNU_MIPS_ABI_FP_64A
:
15844 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15846 case Val_GNU_MIPS_ABI_FP_NAN2008
:
15847 printf (_("NaN 2008 compatibility\n"));
15850 printf ("??? (%d)\n", val
);
15855 static unsigned char *
15856 display_mips_gnu_attribute (unsigned char * p
,
15858 const unsigned char * const end
)
15860 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15864 printf (" Tag_GNU_MIPS_ABI_FP: ");
15865 READ_ULEB (val
, p
, end
);
15866 print_mips_fp_abi_value (val
);
15870 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15874 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15875 READ_ULEB (val
, p
, end
);
15879 case Val_GNU_MIPS_ABI_MSA_ANY
:
15880 printf (_("Any MSA or not\n"));
15882 case Val_GNU_MIPS_ABI_MSA_128
:
15883 printf (_("128-bit MSA\n"));
15886 printf ("??? (%d)\n", val
);
15892 return display_tag_value (tag
& 1, p
, end
);
15895 static unsigned char *
15896 display_tic6x_attribute (unsigned char * p
,
15897 const unsigned char * const end
)
15902 READ_ULEB (tag
, p
, end
);
15907 printf (" Tag_ISA: ");
15908 READ_ULEB (val
, p
, end
);
15912 case C6XABI_Tag_ISA_none
:
15913 printf (_("None\n"));
15915 case C6XABI_Tag_ISA_C62X
:
15918 case C6XABI_Tag_ISA_C67X
:
15921 case C6XABI_Tag_ISA_C67XP
:
15922 printf ("C67x+\n");
15924 case C6XABI_Tag_ISA_C64X
:
15927 case C6XABI_Tag_ISA_C64XP
:
15928 printf ("C64x+\n");
15930 case C6XABI_Tag_ISA_C674X
:
15931 printf ("C674x\n");
15934 printf ("??? (%d)\n", val
);
15939 case Tag_ABI_wchar_t
:
15940 printf (" Tag_ABI_wchar_t: ");
15941 READ_ULEB (val
, p
, end
);
15945 printf (_("Not used\n"));
15948 printf (_("2 bytes\n"));
15951 printf (_("4 bytes\n"));
15954 printf ("??? (%d)\n", val
);
15959 case Tag_ABI_stack_align_needed
:
15960 printf (" Tag_ABI_stack_align_needed: ");
15961 READ_ULEB (val
, p
, end
);
15965 printf (_("8-byte\n"));
15968 printf (_("16-byte\n"));
15971 printf ("??? (%d)\n", val
);
15976 case Tag_ABI_stack_align_preserved
:
15977 READ_ULEB (val
, p
, end
);
15978 printf (" Tag_ABI_stack_align_preserved: ");
15982 printf (_("8-byte\n"));
15985 printf (_("16-byte\n"));
15988 printf ("??? (%d)\n", val
);
15994 READ_ULEB (val
, p
, end
);
15995 printf (" Tag_ABI_DSBT: ");
15999 printf (_("DSBT addressing not used\n"));
16002 printf (_("DSBT addressing used\n"));
16005 printf ("??? (%d)\n", val
);
16011 READ_ULEB (val
, p
, end
);
16012 printf (" Tag_ABI_PID: ");
16016 printf (_("Data addressing position-dependent\n"));
16019 printf (_("Data addressing position-independent, GOT near DP\n"));
16022 printf (_("Data addressing position-independent, GOT far from DP\n"));
16025 printf ("??? (%d)\n", val
);
16031 READ_ULEB (val
, p
, end
);
16032 printf (" Tag_ABI_PIC: ");
16036 printf (_("Code addressing position-dependent\n"));
16039 printf (_("Code addressing position-independent\n"));
16042 printf ("??? (%d)\n", val
);
16047 case Tag_ABI_array_object_alignment
:
16048 READ_ULEB (val
, p
, end
);
16049 printf (" Tag_ABI_array_object_alignment: ");
16053 printf (_("8-byte\n"));
16056 printf (_("4-byte\n"));
16059 printf (_("16-byte\n"));
16062 printf ("??? (%d)\n", val
);
16067 case Tag_ABI_array_object_align_expected
:
16068 READ_ULEB (val
, p
, end
);
16069 printf (" Tag_ABI_array_object_align_expected: ");
16073 printf (_("8-byte\n"));
16076 printf (_("4-byte\n"));
16079 printf (_("16-byte\n"));
16082 printf ("??? (%d)\n", val
);
16087 case Tag_ABI_compatibility
:
16089 READ_ULEB (val
, p
, end
);
16090 printf (" Tag_ABI_compatibility: ");
16091 printf (_("flag = %d, vendor = "), val
);
16094 size_t maxlen
= (end
- p
) - 1;
16096 print_symbol ((int) maxlen
, (const char *) p
);
16097 p
+= strnlen ((char *) p
, maxlen
) + 1;
16101 printf (_("<corrupt>"));
16102 p
= (unsigned char *) end
;
16108 case Tag_ABI_conformance
:
16110 printf (" Tag_ABI_conformance: \"");
16113 size_t maxlen
= (end
- p
) - 1;
16115 print_symbol ((int) maxlen
, (const char *) p
);
16116 p
+= strnlen ((char *) p
, maxlen
) + 1;
16120 printf (_("<corrupt>"));
16121 p
= (unsigned char *) end
;
16128 return display_tag_value (tag
, p
, end
);
16132 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
16134 unsigned long addr
= 0;
16135 size_t bytes
= end
- p
;
16142 int lbytes
= (bytes
> 16 ? 16 : bytes
);
16144 printf (" 0x%8.8lx ", addr
);
16146 for (j
= 0; j
< 16; j
++)
16149 printf ("%2.2x", p
[j
]);
16157 for (j
= 0; j
< lbytes
; j
++)
16160 if (k
>= ' ' && k
< 0x7f)
16176 static unsigned char *
16177 display_msp430x_attribute (unsigned char * p
,
16178 const unsigned char * const end
)
16183 READ_ULEB (tag
, p
, end
);
16187 case OFBA_MSPABI_Tag_ISA
:
16188 printf (" Tag_ISA: ");
16189 READ_ULEB (val
, p
, end
);
16192 case 0: printf (_("None\n")); break;
16193 case 1: printf (_("MSP430\n")); break;
16194 case 2: printf (_("MSP430X\n")); break;
16195 default: printf ("??? (%d)\n", val
); break;
16199 case OFBA_MSPABI_Tag_Code_Model
:
16200 printf (" Tag_Code_Model: ");
16201 READ_ULEB (val
, p
, end
);
16204 case 0: printf (_("None\n")); break;
16205 case 1: printf (_("Small\n")); break;
16206 case 2: printf (_("Large\n")); break;
16207 default: printf ("??? (%d)\n", val
); break;
16211 case OFBA_MSPABI_Tag_Data_Model
:
16212 printf (" Tag_Data_Model: ");
16213 READ_ULEB (val
, p
, end
);
16216 case 0: printf (_("None\n")); break;
16217 case 1: printf (_("Small\n")); break;
16218 case 2: printf (_("Large\n")); break;
16219 case 3: printf (_("Restricted Large\n")); break;
16220 default: printf ("??? (%d)\n", val
); break;
16225 printf (_(" <unknown tag %d>: "), tag
);
16232 size_t maxlen
= (end
- p
) - 1;
16234 print_symbol ((int) maxlen
, (const char *) p
);
16235 p
+= strnlen ((char *) p
, maxlen
) + 1;
16239 printf (_("<corrupt>"));
16240 p
= (unsigned char *) end
;
16246 READ_ULEB (val
, p
, end
);
16247 printf ("%d (0x%x)\n", val
, val
);
16256 static unsigned char *
16257 display_msp430_gnu_attribute (unsigned char * p
,
16259 const unsigned char * const end
)
16261 if (tag
== Tag_GNU_MSP430_Data_Region
)
16265 printf (" Tag_GNU_MSP430_Data_Region: ");
16266 READ_ULEB (val
, p
, end
);
16270 case Val_GNU_MSP430_Data_Region_Any
:
16271 printf (_("Any Region\n"));
16273 case Val_GNU_MSP430_Data_Region_Lower
:
16274 printf (_("Lower Region Only\n"));
16277 printf ("??? (%u)\n", val
);
16281 return display_tag_value (tag
& 1, p
, end
);
16284 struct riscv_attr_tag_t
{
16289 static struct riscv_attr_tag_t riscv_attr_tag
[] =
16291 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
16294 T(priv_spec_minor
),
16295 T(priv_spec_revision
),
16296 T(unaligned_access
),
16301 static unsigned char *
16302 display_riscv_attribute (unsigned char *p
,
16303 const unsigned char * const end
)
16307 struct riscv_attr_tag_t
*attr
= NULL
;
16310 READ_ULEB (tag
, p
, end
);
16312 /* Find the name of attribute. */
16313 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
16315 if (riscv_attr_tag
[i
].tag
== tag
)
16317 attr
= &riscv_attr_tag
[i
];
16323 printf (" %s: ", attr
->name
);
16325 return display_tag_value (tag
, p
, end
);
16329 case Tag_RISCV_priv_spec
:
16330 case Tag_RISCV_priv_spec_minor
:
16331 case Tag_RISCV_priv_spec_revision
:
16332 READ_ULEB (val
, p
, end
);
16333 printf (_("%u\n"), val
);
16335 case Tag_RISCV_unaligned_access
:
16336 READ_ULEB (val
, p
, end
);
16340 printf (_("No unaligned access\n"));
16343 printf (_("Unaligned access\n"));
16347 case Tag_RISCV_stack_align
:
16348 READ_ULEB (val
, p
, end
);
16349 printf (_("%u-bytes\n"), val
);
16351 case Tag_RISCV_arch
:
16352 p
= display_tag_value (-1, p
, end
);
16355 return display_tag_value (tag
, p
, end
);
16362 process_attributes (Filedata
* filedata
,
16363 const char * public_name
,
16364 unsigned int proc_type
,
16365 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
16366 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
16368 Elf_Internal_Shdr
* sect
;
16370 bfd_boolean res
= TRUE
;
16372 /* Find the section header so that we get the size. */
16373 for (i
= 0, sect
= filedata
->section_headers
;
16374 i
< filedata
->file_header
.e_shnum
;
16377 unsigned char * contents
;
16380 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
16383 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16384 sect
->sh_size
, _("attributes"));
16385 if (contents
== NULL
)
16392 /* The first character is the version of the attributes.
16393 Currently only version 1, (aka 'A') is recognised here. */
16396 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
16401 bfd_vma section_len
;
16403 section_len
= sect
->sh_size
- 1;
16406 while (section_len
> 0)
16409 unsigned int namelen
;
16410 bfd_boolean public_section
;
16411 bfd_boolean gnu_section
;
16413 if (section_len
<= 4)
16415 error (_("Tag section ends prematurely\n"));
16419 attr_len
= byte_get (p
, 4);
16422 if (attr_len
> section_len
)
16424 error (_("Bad attribute length (%u > %u)\n"),
16425 (unsigned) attr_len
, (unsigned) section_len
);
16426 attr_len
= section_len
;
16429 /* PR 17531: file: 001-101425-0.004 */
16430 else if (attr_len
< 5)
16432 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
16437 section_len
-= attr_len
;
16440 namelen
= strnlen ((char *) p
, attr_len
) + 1;
16441 if (namelen
== 0 || namelen
>= attr_len
)
16443 error (_("Corrupt attribute section name\n"));
16448 printf (_("Attribute Section: "));
16449 print_symbol (INT_MAX
, (const char *) p
);
16452 if (public_name
&& streq ((char *) p
, public_name
))
16453 public_section
= TRUE
;
16455 public_section
= FALSE
;
16457 if (streq ((char *) p
, "gnu"))
16458 gnu_section
= TRUE
;
16460 gnu_section
= FALSE
;
16463 attr_len
-= namelen
;
16465 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
16470 unsigned char * end
;
16472 /* PR binutils/17531: Safe handling of corrupt files. */
16475 error (_("Unused bytes at end of section\n"));
16482 size
= byte_get (p
, 4);
16483 if (size
> attr_len
)
16485 error (_("Bad subsection length (%u > %u)\n"),
16486 (unsigned) size
, (unsigned) attr_len
);
16490 /* PR binutils/17531: Safe handling of corrupt files. */
16493 error (_("Bad subsection length (%u < 6)\n"),
16501 end
= p
+ size
- 1;
16502 assert (end
<= contents
+ sect
->sh_size
);
16508 printf (_("File Attributes\n"));
16511 printf (_("Section Attributes:"));
16514 printf (_("Symbol Attributes:"));
16515 /* Fall through. */
16519 READ_ULEB (val
, p
, end
);
16522 printf (" %d", val
);
16527 printf (_("Unknown tag: %d\n"), tag
);
16528 public_section
= FALSE
;
16532 if (public_section
&& display_pub_attribute
!= NULL
)
16535 p
= display_pub_attribute (p
, end
);
16538 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
16541 p
= display_gnu_attribute (p
,
16542 display_proc_gnu_attribute
,
16548 printf (_(" Unknown attribute:\n"));
16549 display_raw_attribute (p
, end
);
16564 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16565 Print the Address, Access and Initial fields of an entry at VMA ADDR
16566 and return the VMA of the next entry, or -1 if there was a problem.
16567 Does not read from DATA_END or beyond. */
16570 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
16571 unsigned char * data_end
)
16574 print_vma (addr
, LONG_HEX
);
16576 if (addr
< pltgot
+ 0xfff0)
16577 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
16579 printf ("%10s", "");
16582 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16586 unsigned char * from
= data
+ addr
- pltgot
;
16588 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
16590 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16591 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
16592 return (bfd_vma
) -1;
16596 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16597 print_vma (entry
, LONG_HEX
);
16600 return addr
+ (is_32bit_elf
? 4 : 8);
16603 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16604 PLTGOT. Print the Address and Initial fields of an entry at VMA
16605 ADDR and return the VMA of the next entry. */
16608 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
16611 print_vma (addr
, LONG_HEX
);
16614 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16619 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16620 print_vma (entry
, LONG_HEX
);
16622 return addr
+ (is_32bit_elf
? 4 : 8);
16626 print_mips_ases (unsigned int mask
)
16628 if (mask
& AFL_ASE_DSP
)
16629 fputs ("\n\tDSP ASE", stdout
);
16630 if (mask
& AFL_ASE_DSPR2
)
16631 fputs ("\n\tDSP R2 ASE", stdout
);
16632 if (mask
& AFL_ASE_DSPR3
)
16633 fputs ("\n\tDSP R3 ASE", stdout
);
16634 if (mask
& AFL_ASE_EVA
)
16635 fputs ("\n\tEnhanced VA Scheme", stdout
);
16636 if (mask
& AFL_ASE_MCU
)
16637 fputs ("\n\tMCU (MicroController) ASE", stdout
);
16638 if (mask
& AFL_ASE_MDMX
)
16639 fputs ("\n\tMDMX ASE", stdout
);
16640 if (mask
& AFL_ASE_MIPS3D
)
16641 fputs ("\n\tMIPS-3D ASE", stdout
);
16642 if (mask
& AFL_ASE_MT
)
16643 fputs ("\n\tMT ASE", stdout
);
16644 if (mask
& AFL_ASE_SMARTMIPS
)
16645 fputs ("\n\tSmartMIPS ASE", stdout
);
16646 if (mask
& AFL_ASE_VIRT
)
16647 fputs ("\n\tVZ ASE", stdout
);
16648 if (mask
& AFL_ASE_MSA
)
16649 fputs ("\n\tMSA ASE", stdout
);
16650 if (mask
& AFL_ASE_MIPS16
)
16651 fputs ("\n\tMIPS16 ASE", stdout
);
16652 if (mask
& AFL_ASE_MICROMIPS
)
16653 fputs ("\n\tMICROMIPS ASE", stdout
);
16654 if (mask
& AFL_ASE_XPA
)
16655 fputs ("\n\tXPA ASE", stdout
);
16656 if (mask
& AFL_ASE_MIPS16E2
)
16657 fputs ("\n\tMIPS16e2 ASE", stdout
);
16658 if (mask
& AFL_ASE_CRC
)
16659 fputs ("\n\tCRC ASE", stdout
);
16660 if (mask
& AFL_ASE_GINV
)
16661 fputs ("\n\tGINV ASE", stdout
);
16662 if (mask
& AFL_ASE_LOONGSON_MMI
)
16663 fputs ("\n\tLoongson MMI ASE", stdout
);
16664 if (mask
& AFL_ASE_LOONGSON_CAM
)
16665 fputs ("\n\tLoongson CAM ASE", stdout
);
16666 if (mask
& AFL_ASE_LOONGSON_EXT
)
16667 fputs ("\n\tLoongson EXT ASE", stdout
);
16668 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16669 fputs ("\n\tLoongson EXT2 ASE", stdout
);
16671 fprintf (stdout
, "\n\t%s", _("None"));
16672 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16673 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16677 print_mips_isa_ext (unsigned int isa_ext
)
16682 fputs (_("None"), stdout
);
16685 fputs ("RMI XLR", stdout
);
16687 case AFL_EXT_OCTEON3
:
16688 fputs ("Cavium Networks Octeon3", stdout
);
16690 case AFL_EXT_OCTEON2
:
16691 fputs ("Cavium Networks Octeon2", stdout
);
16693 case AFL_EXT_OCTEONP
:
16694 fputs ("Cavium Networks OcteonP", stdout
);
16696 case AFL_EXT_OCTEON
:
16697 fputs ("Cavium Networks Octeon", stdout
);
16700 fputs ("Toshiba R5900", stdout
);
16703 fputs ("MIPS R4650", stdout
);
16706 fputs ("LSI R4010", stdout
);
16709 fputs ("NEC VR4100", stdout
);
16712 fputs ("Toshiba R3900", stdout
);
16714 case AFL_EXT_10000
:
16715 fputs ("MIPS R10000", stdout
);
16718 fputs ("Broadcom SB-1", stdout
);
16721 fputs ("NEC VR4111/VR4181", stdout
);
16724 fputs ("NEC VR4120", stdout
);
16727 fputs ("NEC VR5400", stdout
);
16730 fputs ("NEC VR5500", stdout
);
16732 case AFL_EXT_LOONGSON_2E
:
16733 fputs ("ST Microelectronics Loongson 2E", stdout
);
16735 case AFL_EXT_LOONGSON_2F
:
16736 fputs ("ST Microelectronics Loongson 2F", stdout
);
16738 case AFL_EXT_INTERAPTIV_MR2
:
16739 fputs ("Imagination interAptiv MR2", stdout
);
16742 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
16747 get_mips_reg_size (int reg_size
)
16749 return (reg_size
== AFL_REG_NONE
) ? 0
16750 : (reg_size
== AFL_REG_32
) ? 32
16751 : (reg_size
== AFL_REG_64
) ? 64
16752 : (reg_size
== AFL_REG_128
) ? 128
16757 process_mips_specific (Filedata
* filedata
)
16759 Elf_Internal_Dyn
* entry
;
16760 Elf_Internal_Shdr
*sect
= NULL
;
16761 size_t liblist_offset
= 0;
16762 size_t liblistno
= 0;
16763 size_t conflictsno
= 0;
16764 size_t options_offset
= 0;
16765 size_t conflicts_offset
= 0;
16766 size_t pltrelsz
= 0;
16768 bfd_vma pltgot
= 0;
16769 bfd_vma mips_pltgot
= 0;
16770 bfd_vma jmprel
= 0;
16771 bfd_vma local_gotno
= 0;
16772 bfd_vma gotsym
= 0;
16773 bfd_vma symtabno
= 0;
16774 bfd_boolean res
= TRUE
;
16776 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16777 display_mips_gnu_attribute
))
16780 sect
= find_section (filedata
, ".MIPS.abiflags");
16784 Elf_External_ABIFlags_v0
*abiflags_ext
;
16785 Elf_Internal_ABIFlags_v0 abiflags_in
;
16787 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
16789 error (_("Corrupt MIPS ABI Flags section.\n"));
16794 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16795 sect
->sh_size
, _("MIPS ABI Flags section"));
16798 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
16799 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
16800 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
16801 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
16802 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
16803 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
16804 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
16805 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
16806 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
16807 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
16808 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
16810 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
16811 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
16812 if (abiflags_in
.isa_rev
> 1)
16813 printf ("r%d", abiflags_in
.isa_rev
);
16814 printf ("\nGPR size: %d",
16815 get_mips_reg_size (abiflags_in
.gpr_size
));
16816 printf ("\nCPR1 size: %d",
16817 get_mips_reg_size (abiflags_in
.cpr1_size
));
16818 printf ("\nCPR2 size: %d",
16819 get_mips_reg_size (abiflags_in
.cpr2_size
));
16820 fputs ("\nFP ABI: ", stdout
);
16821 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
16822 fputs ("ISA Extension: ", stdout
);
16823 print_mips_isa_ext (abiflags_in
.isa_ext
);
16824 fputs ("\nASEs:", stdout
);
16825 print_mips_ases (abiflags_in
.ases
);
16826 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
16827 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
16828 fputc ('\n', stdout
);
16829 free (abiflags_ext
);
16834 /* We have a lot of special sections. Thanks SGI! */
16835 if (filedata
->dynamic_section
== NULL
)
16837 /* No dynamic information available. See if there is static GOT. */
16838 sect
= find_section (filedata
, ".got");
16841 unsigned char *data_end
;
16842 unsigned char *data
;
16846 pltgot
= sect
->sh_addr
;
16849 addr_size
= (is_32bit_elf
? 4 : 8);
16850 end
= pltgot
+ sect
->sh_size
;
16852 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
16854 _("Global Offset Table data"));
16855 /* PR 12855: Null data is handled gracefully throughout. */
16856 data_end
= data
+ (end
- pltgot
);
16858 printf (_("\nStatic GOT:\n"));
16859 printf (_(" Canonical gp value: "));
16860 print_vma (ent
+ 0x7ff0, LONG_HEX
);
16863 /* In a dynamic binary GOT[0] is reserved for the dynamic
16864 loader to store the lazy resolver pointer, however in
16865 a static binary it may well have been omitted and GOT
16866 reduced to a table of addresses.
16867 PR 21344: Check for the entry being fully available
16868 before fetching it. */
16870 && data
+ ent
- pltgot
+ addr_size
<= data_end
16871 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
16873 printf (_(" Reserved entries:\n"));
16874 printf (_(" %*s %10s %*s\n"),
16875 addr_size
* 2, _("Address"), _("Access"),
16876 addr_size
* 2, _("Value"));
16877 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16879 if (ent
== (bfd_vma
) -1)
16880 goto sgot_print_fail
;
16882 /* Check for the MSB of GOT[1] being set, identifying a
16883 GNU object. This entry will be used by some runtime
16884 loaders, to store the module pointer. Otherwise this
16885 is an ordinary local entry.
16886 PR 21344: Check for the entry being fully available
16887 before fetching it. */
16889 && data
+ ent
- pltgot
+ addr_size
<= data_end
16890 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16891 >> (addr_size
* 8 - 1)) != 0)
16893 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16895 if (ent
== (bfd_vma
) -1)
16896 goto sgot_print_fail
;
16901 if (data
!= NULL
&& ent
< end
)
16903 printf (_(" Local entries:\n"));
16904 printf (" %*s %10s %*s\n",
16905 addr_size
* 2, _("Address"), _("Access"),
16906 addr_size
* 2, _("Value"));
16909 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16911 if (ent
== (bfd_vma
) -1)
16912 goto sgot_print_fail
;
16923 for (entry
= filedata
->dynamic_section
;
16924 /* PR 17531 file: 012-50589-0.004. */
16925 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
16926 && entry
->d_tag
!= DT_NULL
);
16928 switch (entry
->d_tag
)
16930 case DT_MIPS_LIBLIST
:
16932 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16933 liblistno
* sizeof (Elf32_External_Lib
));
16935 case DT_MIPS_LIBLISTNO
:
16936 liblistno
= entry
->d_un
.d_val
;
16938 case DT_MIPS_OPTIONS
:
16939 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
16941 case DT_MIPS_CONFLICT
:
16943 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16944 conflictsno
* sizeof (Elf32_External_Conflict
));
16946 case DT_MIPS_CONFLICTNO
:
16947 conflictsno
= entry
->d_un
.d_val
;
16950 pltgot
= entry
->d_un
.d_ptr
;
16952 case DT_MIPS_LOCAL_GOTNO
:
16953 local_gotno
= entry
->d_un
.d_val
;
16955 case DT_MIPS_GOTSYM
:
16956 gotsym
= entry
->d_un
.d_val
;
16958 case DT_MIPS_SYMTABNO
:
16959 symtabno
= entry
->d_un
.d_val
;
16961 case DT_MIPS_PLTGOT
:
16962 mips_pltgot
= entry
->d_un
.d_ptr
;
16965 pltrel
= entry
->d_un
.d_val
;
16968 pltrelsz
= entry
->d_un
.d_val
;
16971 jmprel
= entry
->d_un
.d_ptr
;
16977 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
16979 Elf32_External_Lib
* elib
;
16982 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
16983 sizeof (Elf32_External_Lib
),
16985 _("liblist section data"));
16988 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16989 "\nSection '.liblist' contains %lu entries:\n",
16990 (unsigned long) liblistno
),
16991 (unsigned long) liblistno
);
16992 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16995 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
17002 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17003 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17004 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17005 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17006 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17008 tmp
= gmtime (&atime
);
17009 snprintf (timebuf
, sizeof (timebuf
),
17010 "%04u-%02u-%02uT%02u:%02u:%02u",
17011 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17012 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17014 printf ("%3lu: ", (unsigned long) cnt
);
17015 if (VALID_DYNAMIC_NAME (filedata
, liblist
.l_name
))
17016 print_symbol (20, GET_DYNAMIC_NAME (filedata
, liblist
.l_name
));
17018 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
17019 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
17020 liblist
.l_version
);
17022 if (liblist
.l_flags
== 0)
17026 static const struct
17033 { " EXACT_MATCH", LL_EXACT_MATCH
},
17034 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
17035 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
17036 { " EXPORTS", LL_EXPORTS
},
17037 { " DELAY_LOAD", LL_DELAY_LOAD
},
17038 { " DELTA", LL_DELTA
}
17040 int flags
= liblist
.l_flags
;
17043 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
17044 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
17046 fputs (l_flags_vals
[fcnt
].name
, stdout
);
17047 flags
^= l_flags_vals
[fcnt
].bit
;
17050 printf (" %#x", (unsigned int) flags
);
17062 if (options_offset
!= 0)
17064 Elf_External_Options
* eopt
;
17067 sect
= filedata
->section_headers
;
17069 /* Find the section header so that we get the size. */
17070 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
17071 /* PR 17533 file: 012-277276-0.004. */
17074 error (_("No MIPS_OPTIONS header found\n"));
17078 if (sect
->sh_size
< sizeof (* eopt
))
17080 error (_("The MIPS options section is too small.\n"));
17084 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
17085 sect
->sh_size
, _("options"));
17088 Elf_Internal_Options option
;
17091 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
17093 Elf_External_Options
* eoption
;
17094 unsigned int optsize
;
17096 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
17098 optsize
= BYTE_GET (eoption
->size
);
17100 /* PR 17531: file: ffa0fa3b. */
17101 if (optsize
< sizeof (* eopt
)
17102 || optsize
> sect
->sh_size
- offset
)
17104 error (_("Invalid size (%u) for MIPS option\n"),
17113 printf (ngettext ("\nSection '%s' contains %d entry:\n",
17114 "\nSection '%s' contains %d entries:\n",
17116 printable_section_name (filedata
, sect
), cnt
);
17122 Elf_External_Options
* eoption
;
17124 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
17126 option
.kind
= BYTE_GET (eoption
->kind
);
17127 option
.size
= BYTE_GET (eoption
->size
);
17128 option
.section
= BYTE_GET (eoption
->section
);
17129 option
.info
= BYTE_GET (eoption
->info
);
17131 switch (option
.kind
)
17134 /* This shouldn't happen. */
17135 printf (" NULL %" PRId16
" %" PRIx32
,
17136 option
.section
, option
.info
);
17140 printf (" REGINFO ");
17141 if (filedata
->file_header
.e_machine
== EM_MIPS
)
17143 Elf32_External_RegInfo
* ereg
;
17144 Elf32_RegInfo reginfo
;
17147 if (option
.size
< (sizeof (Elf_External_Options
)
17148 + sizeof (Elf32_External_RegInfo
)))
17150 printf (_("<corrupt>\n"));
17151 error (_("Truncated MIPS REGINFO option\n"));
17156 ereg
= (Elf32_External_RegInfo
*) (eoption
+ 1);
17158 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
17159 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
17160 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
17161 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
17162 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
17163 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
17165 printf ("GPR %08" PRIx32
" GP 0x%" PRIx32
"\n",
17166 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
17168 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
17169 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
17170 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17171 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17176 Elf64_External_RegInfo
* ereg
;
17177 Elf64_Internal_RegInfo reginfo
;
17179 if (option
.size
< (sizeof (Elf_External_Options
)
17180 + sizeof (Elf64_External_RegInfo
)))
17182 printf (_("<corrupt>\n"));
17183 error (_("Truncated MIPS REGINFO option\n"));
17188 ereg
= (Elf64_External_RegInfo
*) (eoption
+ 1);
17189 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
17190 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
17191 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
17192 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
17193 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
17194 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
17196 printf ("GPR %08" PRIx32
" GP 0x%" PRIx64
"\n",
17197 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
17199 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
17200 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
17201 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17202 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17204 offset
+= option
.size
;
17207 case ODK_EXCEPTIONS
:
17208 fputs (" EXCEPTIONS fpe_min(", stdout
);
17209 process_mips_fpe_exception (option
.info
& OEX_FPU_MIN
);
17210 fputs (") fpe_max(", stdout
);
17211 process_mips_fpe_exception ((option
.info
& OEX_FPU_MAX
) >> 8);
17212 fputs (")", stdout
);
17214 if (option
.info
& OEX_PAGE0
)
17215 fputs (" PAGE0", stdout
);
17216 if (option
.info
& OEX_SMM
)
17217 fputs (" SMM", stdout
);
17218 if (option
.info
& OEX_FPDBUG
)
17219 fputs (" FPDBUG", stdout
);
17220 if (option
.info
& OEX_DISMISS
)
17221 fputs (" DISMISS", stdout
);
17225 fputs (" PAD ", stdout
);
17226 if (option
.info
& OPAD_PREFIX
)
17227 fputs (" PREFIX", stdout
);
17228 if (option
.info
& OPAD_POSTFIX
)
17229 fputs (" POSTFIX", stdout
);
17230 if (option
.info
& OPAD_SYMBOL
)
17231 fputs (" SYMBOL", stdout
);
17235 fputs (" HWPATCH ", stdout
);
17236 if (option
.info
& OHW_R4KEOP
)
17237 fputs (" R4KEOP", stdout
);
17238 if (option
.info
& OHW_R8KPFETCH
)
17239 fputs (" R8KPFETCH", stdout
);
17240 if (option
.info
& OHW_R5KEOP
)
17241 fputs (" R5KEOP", stdout
);
17242 if (option
.info
& OHW_R5KCVTL
)
17243 fputs (" R5KCVTL", stdout
);
17247 fputs (" FILL ", stdout
);
17248 /* XXX Print content of info word? */
17252 fputs (" TAGS ", stdout
);
17253 /* XXX Print content of info word? */
17257 fputs (" HWAND ", stdout
);
17258 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
17259 fputs (" R4KEOP_CHECKED", stdout
);
17260 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
17261 fputs (" R4KEOP_CLEAN", stdout
);
17265 fputs (" HWOR ", stdout
);
17266 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
17267 fputs (" R4KEOP_CHECKED", stdout
);
17268 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
17269 fputs (" R4KEOP_CLEAN", stdout
);
17273 printf (" GP_GROUP %#06x self-contained %#06x",
17274 option
.info
& OGP_GROUP
,
17275 (option
.info
& OGP_SELF
) >> 16);
17279 printf (" IDENT %#06x self-contained %#06x",
17280 option
.info
& OGP_GROUP
,
17281 (option
.info
& OGP_SELF
) >> 16);
17285 /* This shouldn't happen. */
17286 printf (" %3d ??? %" PRId16
" %" PRIx32
,
17287 option
.kind
, option
.section
, option
.info
);
17291 len
= sizeof (* eopt
);
17292 while (len
< option
.size
)
17294 unsigned char datum
= *((unsigned char *) eoption
+ len
);
17296 if (ISPRINT (datum
))
17297 printf ("%c", datum
);
17299 printf ("\\%03o", datum
);
17302 fputs ("\n", stdout
);
17304 offset
+= option
.size
;
17312 if (conflicts_offset
!= 0 && conflictsno
!= 0)
17314 Elf32_Conflict
* iconf
;
17317 if (filedata
->dynamic_symbols
== NULL
)
17319 error (_("conflict list found without a dynamic symbol table\n"));
17323 /* PR 21345 - print a slightly more helpful error message
17324 if we are sure that the cmalloc will fail. */
17325 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
17327 error (_("Overlarge number of conflicts detected: %lx\n"),
17328 (long) conflictsno
);
17332 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
17335 error (_("Out of memory allocating space for dynamic conflicts\n"));
17341 Elf32_External_Conflict
* econf32
;
17343 econf32
= (Elf32_External_Conflict
*)
17344 get_data (NULL
, filedata
, conflicts_offset
,
17345 sizeof (*econf32
), conflictsno
, _("conflict"));
17352 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17353 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
17359 Elf64_External_Conflict
* econf64
;
17361 econf64
= (Elf64_External_Conflict
*)
17362 get_data (NULL
, filedata
, conflicts_offset
,
17363 sizeof (*econf64
), conflictsno
, _("conflict"));
17370 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17371 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
17376 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
17377 "\nSection '.conflict' contains %lu entries:\n",
17378 (unsigned long) conflictsno
),
17379 (unsigned long) conflictsno
);
17380 puts (_(" Num: Index Value Name"));
17382 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17384 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
17386 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
17387 printf (_("<corrupt symbol index>"));
17390 Elf_Internal_Sym
* psym
;
17392 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
17393 print_vma (psym
->st_value
, FULL_HEX
);
17395 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17396 print_symbol (25, GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17398 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17406 if (pltgot
!= 0 && local_gotno
!= 0)
17408 bfd_vma ent
, local_end
, global_end
;
17410 unsigned char * data
;
17411 unsigned char * data_end
;
17415 addr_size
= (is_32bit_elf
? 4 : 8);
17416 local_end
= pltgot
+ local_gotno
* addr_size
;
17418 /* PR binutils/17533 file: 012-111227-0.004 */
17419 if (symtabno
< gotsym
)
17421 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17422 (unsigned long) gotsym
, (unsigned long) symtabno
);
17426 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
17427 /* PR 17531: file: 54c91a34. */
17428 if (global_end
< local_end
)
17430 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
17434 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
17435 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
17436 global_end
- pltgot
, 1,
17437 _("Global Offset Table data"));
17438 /* PR 12855: Null data is handled gracefully throughout. */
17439 data_end
= data
+ (global_end
- pltgot
);
17441 printf (_("\nPrimary GOT:\n"));
17442 printf (_(" Canonical gp value: "));
17443 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
17446 printf (_(" Reserved entries:\n"));
17447 printf (_(" %*s %10s %*s Purpose\n"),
17448 addr_size
* 2, _("Address"), _("Access"),
17449 addr_size
* 2, _("Initial"));
17450 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17451 printf (_(" Lazy resolver\n"));
17452 if (ent
== (bfd_vma
) -1)
17453 goto got_print_fail
;
17455 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17456 This entry will be used by some runtime loaders, to store the
17457 module pointer. Otherwise this is an ordinary local entry.
17458 PR 21344: Check for the entry being fully available before
17461 && data
+ ent
- pltgot
+ addr_size
<= data_end
17462 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17463 >> (addr_size
* 8 - 1)) != 0)
17465 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17466 printf (_(" Module pointer (GNU extension)\n"));
17467 if (ent
== (bfd_vma
) -1)
17468 goto got_print_fail
;
17472 if (data
!= NULL
&& ent
< local_end
)
17474 printf (_(" Local entries:\n"));
17475 printf (" %*s %10s %*s\n",
17476 addr_size
* 2, _("Address"), _("Access"),
17477 addr_size
* 2, _("Initial"));
17478 while (ent
< local_end
)
17480 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17482 if (ent
== (bfd_vma
) -1)
17483 goto got_print_fail
;
17488 if (data
!= NULL
&& gotsym
< symtabno
)
17492 printf (_(" Global entries:\n"));
17493 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17494 addr_size
* 2, _("Address"),
17496 addr_size
* 2, _("Initial"),
17497 addr_size
* 2, _("Sym.Val."),
17499 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17500 _("Ndx"), _("Name"));
17502 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
17504 for (i
= gotsym
; i
< symtabno
; i
++)
17506 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17509 if (filedata
->dynamic_symbols
== NULL
)
17510 printf (_("<no dynamic symbols>"));
17511 else if (i
< filedata
->num_dynamic_syms
)
17513 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
17515 print_vma (psym
->st_value
, LONG_HEX
);
17516 printf (" %-7s %3s ",
17517 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17518 get_symbol_index_type (filedata
, psym
->st_shndx
));
17520 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17521 print_symbol (sym_width
,
17522 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17524 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17527 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17528 (unsigned long) i
);
17531 if (ent
== (bfd_vma
) -1)
17541 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
17544 size_t offset
, rel_offset
;
17545 unsigned long count
, i
;
17546 unsigned char * data
;
17547 int addr_size
, sym_width
;
17548 Elf_Internal_Rela
* rels
;
17550 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
17551 if (pltrel
== DT_RELA
)
17553 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17558 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17563 addr_size
= (is_32bit_elf
? 4 : 8);
17564 end
= mips_pltgot
+ (2 + count
) * addr_size
;
17566 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
17567 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
17568 1, _("Procedure Linkage Table data"));
17572 printf ("\nPLT GOT:\n\n");
17573 printf (_(" Reserved entries:\n"));
17574 printf (_(" %*s %*s Purpose\n"),
17575 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
17576 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17577 printf (_(" PLT lazy resolver\n"));
17578 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17579 printf (_(" Module pointer\n"));
17582 printf (_(" Entries:\n"));
17583 printf (" %*s %*s %*s %-7s %3s %s\n",
17584 addr_size
* 2, _("Address"),
17585 addr_size
* 2, _("Initial"),
17586 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17587 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
17588 for (i
= 0; i
< count
; i
++)
17590 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
17592 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17595 if (idx
>= filedata
->num_dynamic_syms
)
17596 printf (_("<corrupt symbol index: %lu>"), idx
);
17599 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
17601 print_vma (psym
->st_value
, LONG_HEX
);
17602 printf (" %-7s %3s ",
17603 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17604 get_symbol_index_type (filedata
, psym
->st_shndx
));
17605 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17606 print_symbol (sym_width
,
17607 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17609 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17623 process_nds32_specific (Filedata
* filedata
)
17625 Elf_Internal_Shdr
*sect
= NULL
;
17627 sect
= find_section (filedata
, ".nds32_e_flags");
17628 if (sect
!= NULL
&& sect
->sh_size
>= 4)
17630 unsigned char *buf
;
17633 printf ("\nNDS32 elf flags section:\n");
17634 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
17635 _("NDS32 elf flags section"));
17640 flag
= byte_get (buf
, 4);
17642 switch (flag
& 0x3)
17645 printf ("(VEC_SIZE):\tNo entry.\n");
17648 printf ("(VEC_SIZE):\t4 bytes\n");
17651 printf ("(VEC_SIZE):\t16 bytes\n");
17654 printf ("(VEC_SIZE):\treserved\n");
17663 process_gnu_liblist (Filedata
* filedata
)
17665 Elf_Internal_Shdr
* section
;
17666 Elf_Internal_Shdr
* string_sec
;
17667 Elf32_External_Lib
* elib
;
17669 size_t strtab_size
;
17671 unsigned long num_liblist
;
17673 bfd_boolean res
= TRUE
;
17678 for (i
= 0, section
= filedata
->section_headers
;
17679 i
< filedata
->file_header
.e_shnum
;
17682 switch (section
->sh_type
)
17684 case SHT_GNU_LIBLIST
:
17685 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
17688 elib
= (Elf32_External_Lib
*)
17689 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
17690 _("liblist section data"));
17698 string_sec
= filedata
->section_headers
+ section
->sh_link
;
17699 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
17700 string_sec
->sh_size
,
17701 _("liblist string table"));
17703 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
17710 strtab_size
= string_sec
->sh_size
;
17712 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
17713 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17714 "\nLibrary list section '%s' contains %lu entries:\n",
17716 printable_section_name (filedata
, section
),
17719 puts (_(" Library Time Stamp Checksum Version Flags"));
17721 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
17729 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17730 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17731 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17732 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17733 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17735 tmp
= gmtime (&atime
);
17736 snprintf (timebuf
, sizeof (timebuf
),
17737 "%04u-%02u-%02uT%02u:%02u:%02u",
17738 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17739 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17741 printf ("%3lu: ", (unsigned long) cnt
);
17743 printf ("%-20s", liblist
.l_name
< strtab_size
17744 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17746 printf ("%-20.20s", liblist
.l_name
< strtab_size
17747 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17748 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
17749 liblist
.l_version
, liblist
.l_flags
);
17760 static const char *
17761 get_note_type (Filedata
* filedata
, unsigned e_type
)
17763 static char buff
[64];
17765 if (filedata
->file_header
.e_type
== ET_CORE
)
17769 return _("NT_AUXV (auxiliary vector)");
17771 return _("NT_PRSTATUS (prstatus structure)");
17773 return _("NT_FPREGSET (floating point registers)");
17775 return _("NT_PRPSINFO (prpsinfo structure)");
17776 case NT_TASKSTRUCT
:
17777 return _("NT_TASKSTRUCT (task structure)");
17779 return _("NT_PRXFPREG (user_xfpregs structure)");
17781 return _("NT_PPC_VMX (ppc Altivec registers)");
17783 return _("NT_PPC_VSX (ppc VSX registers)");
17785 return _("NT_PPC_TAR (ppc TAR register)");
17787 return _("NT_PPC_PPR (ppc PPR register)");
17789 return _("NT_PPC_DSCR (ppc DSCR register)");
17791 return _("NT_PPC_EBB (ppc EBB registers)");
17793 return _("NT_PPC_PMU (ppc PMU registers)");
17794 case NT_PPC_TM_CGPR
:
17795 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17796 case NT_PPC_TM_CFPR
:
17797 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17798 case NT_PPC_TM_CVMX
:
17799 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17800 case NT_PPC_TM_CVSX
:
17801 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17802 case NT_PPC_TM_SPR
:
17803 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17804 case NT_PPC_TM_CTAR
:
17805 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17806 case NT_PPC_TM_CPPR
:
17807 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17808 case NT_PPC_TM_CDSCR
:
17809 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17811 return _("NT_386_TLS (x86 TLS information)");
17812 case NT_386_IOPERM
:
17813 return _("NT_386_IOPERM (x86 I/O permissions)");
17814 case NT_X86_XSTATE
:
17815 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17816 case NT_S390_HIGH_GPRS
:
17817 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17818 case NT_S390_TIMER
:
17819 return _("NT_S390_TIMER (s390 timer register)");
17820 case NT_S390_TODCMP
:
17821 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17822 case NT_S390_TODPREG
:
17823 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17825 return _("NT_S390_CTRS (s390 control registers)");
17826 case NT_S390_PREFIX
:
17827 return _("NT_S390_PREFIX (s390 prefix register)");
17828 case NT_S390_LAST_BREAK
:
17829 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17830 case NT_S390_SYSTEM_CALL
:
17831 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17833 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17834 case NT_S390_VXRS_LOW
:
17835 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17836 case NT_S390_VXRS_HIGH
:
17837 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17838 case NT_S390_GS_CB
:
17839 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17840 case NT_S390_GS_BC
:
17841 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17843 return _("NT_ARM_VFP (arm VFP registers)");
17845 return _("NT_ARM_TLS (AArch TLS registers)");
17846 case NT_ARM_HW_BREAK
:
17847 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17848 case NT_ARM_HW_WATCH
:
17849 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17851 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
17853 return _("NT_PSTATUS (pstatus structure)");
17855 return _("NT_FPREGS (floating point registers)");
17857 return _("NT_PSINFO (psinfo structure)");
17859 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17861 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17862 case NT_WIN32PSTATUS
:
17863 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17865 return _("NT_SIGINFO (siginfo_t data)");
17867 return _("NT_FILE (mapped files)");
17875 return _("NT_VERSION (version)");
17877 return _("NT_ARCH (architecture)");
17878 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17880 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17886 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17891 print_core_note (Elf_Internal_Note
*pnote
)
17893 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
17894 bfd_vma count
, page_size
;
17895 unsigned char *descdata
, *filenames
, *descend
;
17897 if (pnote
->type
!= NT_FILE
)
17907 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17908 /* Still "successful". */
17913 if (pnote
->descsz
< 2 * addr_size
)
17915 error (_(" Malformed note - too short for header\n"));
17919 descdata
= (unsigned char *) pnote
->descdata
;
17920 descend
= descdata
+ pnote
->descsz
;
17922 if (descdata
[pnote
->descsz
- 1] != '\0')
17924 error (_(" Malformed note - does not end with \\0\n"));
17928 count
= byte_get (descdata
, addr_size
);
17929 descdata
+= addr_size
;
17931 page_size
= byte_get (descdata
, addr_size
);
17932 descdata
+= addr_size
;
17934 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
17935 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
17937 error (_(" Malformed note - too short for supplied file count\n"));
17941 printf (_(" Page size: "));
17942 print_vma (page_size
, DEC
);
17945 printf (_(" %*s%*s%*s\n"),
17946 (int) (2 + 2 * addr_size
), _("Start"),
17947 (int) (4 + 2 * addr_size
), _("End"),
17948 (int) (4 + 2 * addr_size
), _("Page Offset"));
17949 filenames
= descdata
+ count
* 3 * addr_size
;
17950 while (count
-- > 0)
17952 bfd_vma start
, end
, file_ofs
;
17954 if (filenames
== descend
)
17956 error (_(" Malformed note - filenames end too early\n"));
17960 start
= byte_get (descdata
, addr_size
);
17961 descdata
+= addr_size
;
17962 end
= byte_get (descdata
, addr_size
);
17963 descdata
+= addr_size
;
17964 file_ofs
= byte_get (descdata
, addr_size
);
17965 descdata
+= addr_size
;
17968 print_vma (start
, FULL_HEX
);
17970 print_vma (end
, FULL_HEX
);
17972 print_vma (file_ofs
, FULL_HEX
);
17973 printf ("\n %s\n", filenames
);
17975 filenames
+= 1 + strlen ((char *) filenames
);
17981 static const char *
17982 get_gnu_elf_note_type (unsigned e_type
)
17984 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17987 case NT_GNU_ABI_TAG
:
17988 return _("NT_GNU_ABI_TAG (ABI version tag)");
17990 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17991 case NT_GNU_BUILD_ID
:
17992 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17993 case NT_GNU_GOLD_VERSION
:
17994 return _("NT_GNU_GOLD_VERSION (gold version)");
17995 case NT_GNU_PROPERTY_TYPE_0
:
17996 return _("NT_GNU_PROPERTY_TYPE_0");
17997 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17998 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17999 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
18000 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
18003 static char buff
[64];
18005 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18012 decode_x86_compat_isa (unsigned int bitmask
)
18016 unsigned int bit
= bitmask
& (- bitmask
);
18021 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
18024 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
18027 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
18030 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
18033 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
18036 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
18039 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
18042 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
18045 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
18048 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
18051 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
18054 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
18055 printf ("AVX512F");
18057 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
18058 printf ("AVX512CD");
18060 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
18061 printf ("AVX512ER");
18063 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
18064 printf ("AVX512PF");
18066 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
18067 printf ("AVX512VL");
18069 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
18070 printf ("AVX512DQ");
18072 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
18073 printf ("AVX512BW");
18076 printf (_("<unknown: %x>"), bit
);
18085 decode_x86_isa (unsigned int bitmask
)
18089 printf (_("<None>"));
18095 unsigned int bit
= bitmask
& (- bitmask
);
18100 case GNU_PROPERTY_X86_ISA_1_CMOV
:
18103 case GNU_PROPERTY_X86_ISA_1_SSE
:
18106 case GNU_PROPERTY_X86_ISA_1_SSE2
:
18109 case GNU_PROPERTY_X86_ISA_1_SSE3
:
18112 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
18115 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
18118 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
18121 case GNU_PROPERTY_X86_ISA_1_AVX
:
18124 case GNU_PROPERTY_X86_ISA_1_AVX2
:
18127 case GNU_PROPERTY_X86_ISA_1_FMA
:
18130 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
18131 printf ("AVX512F");
18133 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
18134 printf ("AVX512CD");
18136 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
18137 printf ("AVX512ER");
18139 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
18140 printf ("AVX512PF");
18142 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
18143 printf ("AVX512VL");
18145 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
18146 printf ("AVX512DQ");
18148 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
18149 printf ("AVX512BW");
18151 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
18152 printf ("AVX512_4FMAPS");
18154 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
18155 printf ("AVX512_4VNNIW");
18157 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
18158 printf ("AVX512_BITALG");
18160 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
18161 printf ("AVX512_IFMA");
18163 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
18164 printf ("AVX512_VBMI");
18166 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
18167 printf ("AVX512_VBMI2");
18169 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
18170 printf ("AVX512_VNNI");
18172 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16
:
18173 printf ("AVX512_BF16");
18176 printf (_("<unknown: %x>"), bit
);
18185 decode_x86_feature_1 (unsigned int bitmask
)
18189 printf (_("<None>"));
18195 unsigned int bit
= bitmask
& (- bitmask
);
18200 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
18203 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
18207 printf (_("<unknown: %x>"), bit
);
18216 decode_x86_feature_2 (unsigned int bitmask
)
18220 printf (_("<None>"));
18226 unsigned int bit
= bitmask
& (- bitmask
);
18231 case GNU_PROPERTY_X86_FEATURE_2_X86
:
18234 case GNU_PROPERTY_X86_FEATURE_2_X87
:
18237 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
18240 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
18243 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
18246 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
18249 case GNU_PROPERTY_X86_FEATURE_2_TMM
:
18252 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
18255 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
18258 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
18259 printf ("XSAVEOPT");
18261 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
18265 printf (_("<unknown: %x>"), bit
);
18274 decode_aarch64_feature_1_and (unsigned int bitmask
)
18278 unsigned int bit
= bitmask
& (- bitmask
);
18283 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
18287 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
18292 printf (_("<unknown: %x>"), bit
);
18301 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
18303 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
18304 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
18305 unsigned int size
= is_32bit_elf
? 4 : 8;
18307 printf (_(" Properties: "));
18309 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
18311 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
18315 while (ptr
< ptr_end
)
18319 unsigned int datasz
;
18321 if ((size_t) (ptr_end
- ptr
) < 8)
18323 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
18327 type
= byte_get (ptr
, 4);
18328 datasz
= byte_get (ptr
+ 4, 4);
18332 if (datasz
> (size_t) (ptr_end
- ptr
))
18334 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
18339 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
18341 if (filedata
->file_header
.e_machine
== EM_X86_64
18342 || filedata
->file_header
.e_machine
== EM_IAMCU
18343 || filedata
->file_header
.e_machine
== EM_386
)
18345 unsigned int bitmask
;
18348 bitmask
= byte_get (ptr
, 4);
18354 case GNU_PROPERTY_X86_ISA_1_USED
:
18356 printf (_("x86 ISA used: <corrupt length: %#x> "),
18360 printf ("x86 ISA used: ");
18361 decode_x86_isa (bitmask
);
18365 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
18367 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18371 printf ("x86 ISA needed: ");
18372 decode_x86_isa (bitmask
);
18376 case GNU_PROPERTY_X86_FEATURE_1_AND
:
18378 printf (_("x86 feature: <corrupt length: %#x> "),
18382 printf ("x86 feature: ");
18383 decode_x86_feature_1 (bitmask
);
18387 case GNU_PROPERTY_X86_FEATURE_2_USED
:
18389 printf (_("x86 feature used: <corrupt length: %#x> "),
18393 printf ("x86 feature used: ");
18394 decode_x86_feature_2 (bitmask
);
18398 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
18400 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
18403 printf ("x86 feature needed: ");
18404 decode_x86_feature_2 (bitmask
);
18408 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
18410 printf (_("x86 ISA used: <corrupt length: %#x> "),
18414 printf ("x86 ISA used: ");
18415 decode_x86_compat_isa (bitmask
);
18419 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
18421 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18425 printf ("x86 ISA needed: ");
18426 decode_x86_compat_isa (bitmask
);
18434 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
18436 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
18438 printf ("AArch64 feature: ");
18440 printf (_("<corrupt length: %#x> "), datasz
);
18442 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
18451 case GNU_PROPERTY_STACK_SIZE
:
18452 printf (_("stack size: "));
18453 if (datasz
!= size
)
18454 printf (_("<corrupt length: %#x> "), datasz
);
18456 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
18459 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
18460 printf ("no copy on protected ");
18462 printf (_("<corrupt length: %#x> "), datasz
);
18470 if (type
< GNU_PROPERTY_LOPROC
)
18471 printf (_("<unknown type %#x data: "), type
);
18472 else if (type
< GNU_PROPERTY_LOUSER
)
18473 printf (_("<procesor-specific type %#x data: "), type
);
18475 printf (_("<application-specific type %#x data: "), type
);
18476 for (j
= 0; j
< datasz
; ++j
)
18477 printf ("%02x ", ptr
[j
] & 0xff);
18481 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
18482 if (ptr
== ptr_end
)
18495 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
18497 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18498 switch (pnote
->type
)
18500 case NT_GNU_BUILD_ID
:
18504 printf (_(" Build ID: "));
18505 for (i
= 0; i
< pnote
->descsz
; ++i
)
18506 printf ("%02x", pnote
->descdata
[i
] & 0xff);
18511 case NT_GNU_ABI_TAG
:
18513 unsigned long os
, major
, minor
, subminor
;
18514 const char *osname
;
18516 /* PR 17531: file: 030-599401-0.004. */
18517 if (pnote
->descsz
< 16)
18519 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18523 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18524 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18525 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
18526 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
18530 case GNU_ABI_TAG_LINUX
:
18533 case GNU_ABI_TAG_HURD
:
18536 case GNU_ABI_TAG_SOLARIS
:
18537 osname
= "Solaris";
18539 case GNU_ABI_TAG_FREEBSD
:
18540 osname
= "FreeBSD";
18542 case GNU_ABI_TAG_NETBSD
:
18545 case GNU_ABI_TAG_SYLLABLE
:
18546 osname
= "Syllable";
18548 case GNU_ABI_TAG_NACL
:
18552 osname
= "Unknown";
18556 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
18557 major
, minor
, subminor
);
18561 case NT_GNU_GOLD_VERSION
:
18565 printf (_(" Version: "));
18566 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
18567 printf ("%c", pnote
->descdata
[i
]);
18574 unsigned long num_entries
, mask
;
18576 /* Hardware capabilities information. Word 0 is the number of entries.
18577 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18578 is a series of entries, where each entry is a single byte followed
18579 by a nul terminated string. The byte gives the bit number to test
18580 if enabled in the bitmask. */
18581 printf (_(" Hardware Capabilities: "));
18582 if (pnote
->descsz
< 8)
18584 error (_("<corrupt GNU_HWCAP>\n"));
18587 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18588 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18589 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
18590 /* FIXME: Add code to display the entries... */
18594 case NT_GNU_PROPERTY_TYPE_0
:
18595 print_gnu_property_note (filedata
, pnote
);
18599 /* Handle unrecognised types. An error message should have already been
18600 created by get_gnu_elf_note_type(), so all that we need to do is to
18601 display the data. */
18605 printf (_(" Description data: "));
18606 for (i
= 0; i
< pnote
->descsz
; ++i
)
18607 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
18616 static const char *
18617 get_v850_elf_note_type (enum v850_notes n_type
)
18619 static char buff
[64];
18623 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
18624 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
18625 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
18626 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
18627 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
18628 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
18630 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
18636 print_v850_note (Elf_Internal_Note
* pnote
)
18640 if (pnote
->descsz
!= 4)
18643 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
18647 printf (_("not set\n"));
18651 switch (pnote
->type
)
18653 case V850_NOTE_ALIGNMENT
:
18656 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
18657 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
18661 case V850_NOTE_DATA_SIZE
:
18664 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
18665 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
18669 case V850_NOTE_FPU_INFO
:
18672 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
18673 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
18677 case V850_NOTE_MMU_INFO
:
18678 case V850_NOTE_CACHE_INFO
:
18679 case V850_NOTE_SIMD_INFO
:
18680 if (val
== EF_RH850_SIMD
)
18682 printf (_("yes\n"));
18688 /* An 'unknown note type' message will already have been displayed. */
18692 printf (_("unknown value: %x\n"), val
);
18697 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
18699 unsigned int version
;
18701 switch (pnote
->type
)
18703 case NT_NETBSD_IDENT
:
18704 if (pnote
->descsz
< 1)
18706 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18707 if ((version
/ 10000) % 100)
18708 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
18709 version
, version
/ 100000000, (version
/ 1000000) % 100,
18710 (version
/ 10000) % 100 > 26 ? "Z" : "",
18711 'A' + (version
/ 10000) % 26);
18713 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
18714 version
, version
/ 100000000, (version
/ 1000000) % 100,
18715 (version
/ 100) % 100);
18718 case NT_NETBSD_MARCH
:
18719 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
18723 #ifdef NT_NETBSD_PAX
18724 case NT_NETBSD_PAX
:
18725 if (pnote
->descsz
< 1)
18727 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18728 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
18729 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
18730 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
18731 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
18732 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
18733 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
18734 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
18739 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
18740 pnote
->descsz
, pnote
->type
);
18744 static const char *
18745 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18749 case NT_FREEBSD_THRMISC
:
18750 return _("NT_THRMISC (thrmisc structure)");
18751 case NT_FREEBSD_PROCSTAT_PROC
:
18752 return _("NT_PROCSTAT_PROC (proc data)");
18753 case NT_FREEBSD_PROCSTAT_FILES
:
18754 return _("NT_PROCSTAT_FILES (files data)");
18755 case NT_FREEBSD_PROCSTAT_VMMAP
:
18756 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18757 case NT_FREEBSD_PROCSTAT_GROUPS
:
18758 return _("NT_PROCSTAT_GROUPS (groups data)");
18759 case NT_FREEBSD_PROCSTAT_UMASK
:
18760 return _("NT_PROCSTAT_UMASK (umask data)");
18761 case NT_FREEBSD_PROCSTAT_RLIMIT
:
18762 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18763 case NT_FREEBSD_PROCSTAT_OSREL
:
18764 return _("NT_PROCSTAT_OSREL (osreldate data)");
18765 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
18766 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18767 case NT_FREEBSD_PROCSTAT_AUXV
:
18768 return _("NT_PROCSTAT_AUXV (auxv data)");
18769 case NT_FREEBSD_PTLWPINFO
:
18770 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18772 return get_note_type (filedata
, e_type
);
18775 static const char *
18776 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18778 static char buff
[64];
18782 case NT_NETBSDCORE_PROCINFO
:
18783 /* NetBSD core "procinfo" structure. */
18784 return _("NetBSD procinfo structure");
18786 #ifdef NT_NETBSDCORE_AUXV
18787 case NT_NETBSDCORE_AUXV
:
18788 return _("NetBSD ELF auxiliary vector data");
18791 #ifdef NT_NETBSDCORE_LWPSTATUS
18792 case NT_NETBSDCORE_LWPSTATUS
:
18793 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
18797 /* As of Jan 2020 there are no other machine-independent notes
18798 defined for NetBSD core files. If the note type is less
18799 than the start of the machine-dependent note types, we don't
18802 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
18804 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18810 switch (filedata
->file_header
.e_machine
)
18812 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18813 and PT_GETFPREGS == mach+2. */
18818 case EM_SPARC32PLUS
:
18822 case NT_NETBSDCORE_FIRSTMACH
+ 0:
18823 return _("PT_GETREGS (reg structure)");
18824 case NT_NETBSDCORE_FIRSTMACH
+ 2:
18825 return _("PT_GETFPREGS (fpreg structure)");
18831 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18832 There's also old PT___GETREGS40 == mach + 1 for old reg
18833 structure which lacks GBR. */
18837 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18838 return _("PT___GETREGS40 (old reg structure)");
18839 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18840 return _("PT_GETREGS (reg structure)");
18841 case NT_NETBSDCORE_FIRSTMACH
+ 5:
18842 return _("PT_GETFPREGS (fpreg structure)");
18848 /* On all other arch's, PT_GETREGS == mach+1 and
18849 PT_GETFPREGS == mach+3. */
18853 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18854 return _("PT_GETREGS (reg structure)");
18855 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18856 return _("PT_GETFPREGS (fpreg structure)");
18862 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
18863 e_type
- NT_NETBSDCORE_FIRSTMACH
);
18867 static const char *
18868 get_stapsdt_note_type (unsigned e_type
)
18870 static char buff
[64];
18875 return _("NT_STAPSDT (SystemTap probe descriptors)");
18881 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18886 print_stapsdt_note (Elf_Internal_Note
*pnote
)
18888 size_t len
, maxlen
;
18889 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
18890 char *data
= pnote
->descdata
;
18891 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
18892 bfd_vma pc
, base_addr
, semaphore
;
18893 char *provider
, *probe
, *arg_fmt
;
18895 if (pnote
->descsz
< (addr_size
* 3))
18896 goto stapdt_note_too_small
;
18898 pc
= byte_get ((unsigned char *) data
, addr_size
);
18901 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
18904 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
18907 if (data
>= data_end
)
18908 goto stapdt_note_too_small
;
18909 maxlen
= data_end
- data
;
18910 len
= strnlen (data
, maxlen
);
18917 goto stapdt_note_too_small
;
18919 if (data
>= data_end
)
18920 goto stapdt_note_too_small
;
18921 maxlen
= data_end
- data
;
18922 len
= strnlen (data
, maxlen
);
18929 goto stapdt_note_too_small
;
18931 if (data
>= data_end
)
18932 goto stapdt_note_too_small
;
18933 maxlen
= data_end
- data
;
18934 len
= strnlen (data
, maxlen
);
18941 goto stapdt_note_too_small
;
18943 printf (_(" Provider: %s\n"), provider
);
18944 printf (_(" Name: %s\n"), probe
);
18945 printf (_(" Location: "));
18946 print_vma (pc
, FULL_HEX
);
18947 printf (_(", Base: "));
18948 print_vma (base_addr
, FULL_HEX
);
18949 printf (_(", Semaphore: "));
18950 print_vma (semaphore
, FULL_HEX
);
18952 printf (_(" Arguments: %s\n"), arg_fmt
);
18954 return data
== data_end
;
18956 stapdt_note_too_small
:
18957 printf (_(" <corrupt - note is too small>\n"));
18958 error (_("corrupt stapdt note - the data size is too small\n"));
18962 static const char *
18963 get_ia64_vms_note_type (unsigned e_type
)
18965 static char buff
[64];
18970 return _("NT_VMS_MHD (module header)");
18972 return _("NT_VMS_LNM (language name)");
18974 return _("NT_VMS_SRC (source files)");
18976 return "NT_VMS_TITLE";
18978 return _("NT_VMS_EIDC (consistency check)");
18979 case NT_VMS_FPMODE
:
18980 return _("NT_VMS_FPMODE (FP mode)");
18981 case NT_VMS_LINKTIME
:
18982 return "NT_VMS_LINKTIME";
18983 case NT_VMS_IMGNAM
:
18984 return _("NT_VMS_IMGNAM (image name)");
18986 return _("NT_VMS_IMGID (image id)");
18987 case NT_VMS_LINKID
:
18988 return _("NT_VMS_LINKID (link id)");
18989 case NT_VMS_IMGBID
:
18990 return _("NT_VMS_IMGBID (build id)");
18991 case NT_VMS_GSTNAM
:
18992 return _("NT_VMS_GSTNAM (sym table name)");
18993 case NT_VMS_ORIG_DYN
:
18994 return "NT_VMS_ORIG_DYN";
18995 case NT_VMS_PATCHTIME
:
18996 return "NT_VMS_PATCHTIME";
18998 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19004 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
19006 int maxlen
= pnote
->descsz
;
19008 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
19009 goto desc_size_fail
;
19011 switch (pnote
->type
)
19015 goto desc_size_fail
;
19017 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
19019 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
19020 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
19021 if (l
+ 34 < maxlen
)
19023 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
19024 if (l
+ 35 < maxlen
)
19025 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
19027 printf (_(" Module version : <missing>\n"));
19031 printf (_(" Module name : <missing>\n"));
19032 printf (_(" Module version : <missing>\n"));
19037 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
19041 case NT_VMS_FPMODE
:
19042 printf (_(" Floating Point mode: "));
19044 goto desc_size_fail
;
19045 /* FIXME: Generate an error if descsz > 8 ? */
19047 printf ("0x%016" BFD_VMA_FMT
"x\n",
19048 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19051 case NT_VMS_LINKTIME
:
19052 printf (_(" Link time: "));
19054 goto desc_size_fail
;
19055 /* FIXME: Generate an error if descsz > 8 ? */
19058 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19062 case NT_VMS_PATCHTIME
:
19063 printf (_(" Patch time: "));
19065 goto desc_size_fail
;
19066 /* FIXME: Generate an error if descsz > 8 ? */
19069 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19073 case NT_VMS_ORIG_DYN
:
19075 goto desc_size_fail
;
19077 printf (_(" Major id: %u, minor id: %u\n"),
19078 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
19079 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
19080 printf (_(" Last modified : "));
19082 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
19083 printf (_("\n Link flags : "));
19084 printf ("0x%016" BFD_VMA_FMT
"x\n",
19085 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
19086 printf (_(" Header flags: 0x%08x\n"),
19087 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
19088 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
19092 case NT_VMS_IMGNAM
:
19093 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
19096 case NT_VMS_GSTNAM
:
19097 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
19101 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
19104 case NT_VMS_LINKID
:
19105 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
19115 printf (_(" <corrupt - data size is too small>\n"));
19116 error (_("corrupt IA64 note: data size is too small\n"));
19120 struct build_attr_cache
{
19121 Filedata
*filedata
;
19123 unsigned long strtablen
;
19124 Elf_Internal_Sym
*symtab
;
19125 unsigned long nsyms
;
19128 /* Find the symbol associated with a build attribute that is attached
19129 to address OFFSET. If PNAME is non-NULL then store the name of
19130 the symbol (if found) in the provided pointer, Returns NULL if a
19131 symbol could not be found. */
19133 static Elf_Internal_Sym
*
19134 get_symbol_for_build_attribute (Filedata
* filedata
,
19135 unsigned long offset
,
19136 bfd_boolean is_open_attr
,
19137 const char ** pname
)
19139 Elf_Internal_Sym
*saved_sym
= NULL
;
19140 Elf_Internal_Sym
*sym
;
19142 if (filedata
->section_headers
!= NULL
19143 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
19145 Elf_Internal_Shdr
* symsec
;
19147 free (ba_cache
.strtab
);
19148 ba_cache
.strtab
= NULL
;
19149 free (ba_cache
.symtab
);
19150 ba_cache
.symtab
= NULL
;
19152 /* Load the symbol and string sections. */
19153 for (symsec
= filedata
->section_headers
;
19154 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
19157 if (symsec
->sh_type
== SHT_SYMTAB
19158 && get_symtab (filedata
, symsec
,
19159 &ba_cache
.symtab
, &ba_cache
.nsyms
,
19160 &ba_cache
.strtab
, &ba_cache
.strtablen
))
19163 ba_cache
.filedata
= filedata
;
19166 if (ba_cache
.symtab
== NULL
)
19169 /* Find a symbol whose value matches offset. */
19170 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
19171 if (sym
->st_value
== offset
)
19173 if (sym
->st_name
>= ba_cache
.strtablen
)
19174 /* Huh ? This should not happen. */
19177 if (ba_cache
.strtab
[sym
->st_name
] == 0)
19180 /* The AArch64 and ARM architectures define mapping symbols
19181 (eg $d, $x, $t) which we want to ignore. */
19182 if (ba_cache
.strtab
[sym
->st_name
] == '$'
19183 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
19184 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
19189 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
19190 and FILE or OBJECT symbols over NOTYPE symbols. We skip
19191 FUNC symbols entirely. */
19192 switch (ELF_ST_TYPE (sym
->st_info
))
19199 /* If the symbol has a size associated
19200 with it then we can stop searching. */
19201 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
19206 /* Ignore function symbols. */
19213 switch (ELF_ST_BIND (sym
->st_info
))
19216 if (saved_sym
== NULL
19217 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
19222 if (saved_sym
== NULL
)
19232 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
19240 if (saved_sym
&& pname
)
19241 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
19246 /* Returns true iff addr1 and addr2 are in the same section. */
19249 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
19251 Elf_Internal_Shdr
* a1
;
19252 Elf_Internal_Shdr
* a2
;
19254 a1
= find_section_by_address (filedata
, addr1
);
19255 a2
= find_section_by_address (filedata
, addr2
);
19257 return a1
== a2
&& a1
!= NULL
;
19261 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
19262 Filedata
* filedata
)
19264 static unsigned long global_offset
= 0;
19265 static unsigned long global_end
= 0;
19266 static unsigned long func_offset
= 0;
19267 static unsigned long func_end
= 0;
19269 Elf_Internal_Sym
* sym
;
19271 unsigned long start
;
19273 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
19275 switch (pnote
->descsz
)
19278 /* A zero-length description means that the range of
19279 the previous note of the same type should be used. */
19282 if (global_end
> global_offset
)
19283 printf (_(" Applies to region from %#lx to %#lx\n"),
19284 global_offset
, global_end
);
19286 printf (_(" Applies to region from %#lx\n"), global_offset
);
19290 if (func_end
> func_offset
)
19291 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
19293 printf (_(" Applies to region from %#lx\n"), func_offset
);
19298 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19305 /* FIXME: We should check that version 3+ notes are being used here... */
19306 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19307 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19311 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19317 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19318 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
19322 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
19323 printf (_(" <invalid descsz>"));
19328 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
19329 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
19330 in order to avoid them being confused with the start address of the
19331 first function in the file... */
19332 if (sym
== NULL
&& is_open_attr
)
19333 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
19336 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
19337 end
= start
+ sym
->st_size
;
19341 /* FIXME: Need to properly allow for section alignment.
19342 16 is just the alignment used on x86_64. */
19344 && start
> BFD_ALIGN (global_end
, 16)
19345 /* Build notes are not guaranteed to be organised in order of
19346 increasing address, but we should find the all of the notes
19347 for one section in the same place. */
19348 && same_section (filedata
, start
, global_end
))
19349 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
19350 global_end
+ 1, start
- 1);
19352 printf (_(" Applies to region from %#lx"), start
);
19353 global_offset
= start
;
19357 printf (_(" to %#lx"), end
);
19363 printf (_(" Applies to region from %#lx"), start
);
19364 func_offset
= start
;
19368 printf (_(" to %#lx"), end
);
19374 printf (_(" (%s)"), name
);
19381 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
19383 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
19384 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
19385 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
19387 char name_attribute
;
19388 const char * expected_types
;
19389 const char * name
= pnote
->namedata
;
19393 if (name
== NULL
|| pnote
->namesz
< 2)
19395 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19396 print_symbol (-20, _(" <corrupt name>"));
19405 /* Version 2 of the spec adds a "GA" prefix to the name field. */
19406 if (name
[0] == 'G' && name
[1] == 'A')
19408 if (pnote
->namesz
< 4)
19410 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19411 print_symbol (-20, _(" <corrupt name>"));
19420 switch ((name_type
= * name
))
19422 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19423 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19424 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19425 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19426 printf ("%c", * name
);
19430 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
19431 print_symbol (-20, _("<unknown name type>"));
19438 switch ((name_attribute
= * name
))
19440 case GNU_BUILD_ATTRIBUTE_VERSION
:
19441 text
= _("<version>");
19442 expected_types
= string_expected
;
19445 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19446 text
= _("<stack prot>");
19447 expected_types
= "!+*";
19450 case GNU_BUILD_ATTRIBUTE_RELRO
:
19451 text
= _("<relro>");
19452 expected_types
= bool_expected
;
19455 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
19456 text
= _("<stack size>");
19457 expected_types
= number_expected
;
19460 case GNU_BUILD_ATTRIBUTE_TOOL
:
19461 text
= _("<tool>");
19462 expected_types
= string_expected
;
19465 case GNU_BUILD_ATTRIBUTE_ABI
:
19467 expected_types
= "$*";
19470 case GNU_BUILD_ATTRIBUTE_PIC
:
19472 expected_types
= number_expected
;
19475 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
19476 text
= _("<short enum>");
19477 expected_types
= bool_expected
;
19481 if (ISPRINT (* name
))
19483 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
19485 if (len
> left
&& ! do_wide
)
19487 printf ("%.*s:", len
, name
);
19493 static char tmpbuf
[128];
19495 error (_("unrecognised byte in name field: %d\n"), * name
);
19496 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
19500 expected_types
= "*$!+";
19505 left
-= printf ("%s", text
);
19507 if (strchr (expected_types
, name_type
) == NULL
)
19508 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
19510 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
19512 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19513 (unsigned long) pnote
->namesz
,
19514 (long) (name
- pnote
->namedata
));
19518 if (left
< 1 && ! do_wide
)
19523 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19525 unsigned int bytes
;
19526 unsigned long long val
= 0;
19527 unsigned int shift
= 0;
19528 char * decoded
= NULL
;
19530 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
19532 /* The -1 is because the name field is always 0 terminated, and we
19533 want to be able to ensure that the shift in the while loop below
19534 will not overflow. */
19537 if (bytes
> sizeof (val
))
19539 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19541 bytes
= sizeof (val
);
19543 /* We do not bother to warn if bytes == 0 as this can
19544 happen with some early versions of the gcc plugin. */
19548 unsigned long byte
= (* name
++) & 0xff;
19550 val
|= byte
<< shift
;
19554 switch (name_attribute
)
19556 case GNU_BUILD_ATTRIBUTE_PIC
:
19559 case 0: decoded
= "static"; break;
19560 case 1: decoded
= "pic"; break;
19561 case 2: decoded
= "PIC"; break;
19562 case 3: decoded
= "pie"; break;
19563 case 4: decoded
= "PIE"; break;
19567 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19570 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19571 case 0: decoded
= "off"; break;
19572 case 1: decoded
= "on"; break;
19573 case 2: decoded
= "all"; break;
19574 case 3: decoded
= "strong"; break;
19575 case 4: decoded
= "explicit"; break;
19583 if (decoded
!= NULL
)
19585 print_symbol (-left
, decoded
);
19596 left
-= printf ("0x%llx", val
);
19598 left
-= printf ("0x%-.*llx", left
, val
);
19602 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19603 left
-= print_symbol (- left
, name
);
19605 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19606 left
-= print_symbol (- left
, "true");
19608 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19609 left
-= print_symbol (- left
, "false");
19613 if (do_wide
&& left
> 0)
19614 printf ("%-*s", left
, " ");
19619 /* Note that by the ELF standard, the name field is already null byte
19620 terminated, and namesz includes the terminating null byte.
19621 I.E. the value of namesz for the name "FSF" is 4.
19623 If the value of namesz is zero, there is no name present. */
19626 process_note (Elf_Internal_Note
* pnote
,
19627 Filedata
* filedata
)
19629 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
19632 if (pnote
->namesz
== 0)
19633 /* If there is no note name, then use the default set of
19634 note type strings. */
19635 nt
= get_note_type (filedata
, pnote
->type
);
19637 else if (const_strneq (pnote
->namedata
, "GNU"))
19638 /* GNU-specific object file notes. */
19639 nt
= get_gnu_elf_note_type (pnote
->type
);
19641 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
19642 /* FreeBSD-specific core file notes. */
19643 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
19645 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
19646 /* NetBSD-specific core file notes. */
19647 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
19649 else if (const_strneq (pnote
->namedata
, "NetBSD"))
19650 /* NetBSD-specific core file notes. */
19651 return process_netbsd_elf_note (pnote
);
19653 else if (const_strneq (pnote
->namedata
, "PaX"))
19654 /* NetBSD-specific core file notes. */
19655 return process_netbsd_elf_note (pnote
);
19657 else if (strneq (pnote
->namedata
, "SPU/", 4))
19659 /* SPU-specific core file notes. */
19660 nt
= pnote
->namedata
+ 4;
19664 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19665 /* VMS/ia64-specific file notes. */
19666 nt
= get_ia64_vms_note_type (pnote
->type
);
19668 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19669 nt
= get_stapsdt_note_type (pnote
->type
);
19672 /* Don't recognize this note name; just use the default set of
19673 note type strings. */
19674 nt
= get_note_type (filedata
, pnote
->type
);
19678 if (((const_strneq (pnote
->namedata
, "GA")
19679 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19680 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19681 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19682 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19683 print_gnu_build_attribute_name (pnote
);
19685 print_symbol (-20, name
);
19688 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
19690 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
19692 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19693 return print_ia64_vms_note (pnote
);
19694 else if (const_strneq (pnote
->namedata
, "GNU"))
19695 return print_gnu_note (filedata
, pnote
);
19696 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19697 return print_stapsdt_note (pnote
);
19698 else if (const_strneq (pnote
->namedata
, "CORE"))
19699 return print_core_note (pnote
);
19700 else if (((const_strneq (pnote
->namedata
, "GA")
19701 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19702 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19703 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19704 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19705 return print_gnu_build_attribute_description (pnote
, filedata
);
19711 printf (_(" description data: "));
19712 for (i
= 0; i
< pnote
->descsz
; i
++)
19713 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19725 process_notes_at (Filedata
* filedata
,
19726 Elf_Internal_Shdr
* section
,
19731 Elf_External_Note
* pnotes
;
19732 Elf_External_Note
* external
;
19734 bfd_boolean res
= TRUE
;
19741 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
19744 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
19752 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19755 if (pnotes
== NULL
)
19761 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
19763 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19764 (unsigned long) offset
, (unsigned long) length
);
19766 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19767 specifies that notes should be aligned to 4 bytes in 32-bit
19768 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19769 we also support 4 byte alignment in 64-bit objects. If section
19770 alignment is less than 4, we treate alignment as 4 bytes. */
19773 else if (align
!= 4 && align
!= 8)
19775 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19781 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19783 end
= (char *) pnotes
+ length
;
19784 while ((char *) external
< end
)
19786 Elf_Internal_Note inote
;
19789 char * temp
= NULL
;
19790 size_t data_remaining
= end
- (char *) external
;
19792 if (!is_ia64_vms (filedata
))
19794 /* PR binutils/15191
19795 Make sure that there is enough data to read. */
19796 min_notesz
= offsetof (Elf_External_Note
, name
);
19797 if (data_remaining
< min_notesz
)
19799 warn (ngettext ("Corrupt note: only %ld byte remains, "
19800 "not enough for a full note\n",
19801 "Corrupt note: only %ld bytes remain, "
19802 "not enough for a full note\n",
19804 (long) data_remaining
);
19807 data_remaining
-= min_notesz
;
19809 inote
.type
= BYTE_GET (external
->type
);
19810 inote
.namesz
= BYTE_GET (external
->namesz
);
19811 inote
.namedata
= external
->name
;
19812 inote
.descsz
= BYTE_GET (external
->descsz
);
19813 inote
.descdata
= ((char *) external
19814 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
19815 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19816 next
= ((char *) external
19817 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
19821 Elf64_External_VMS_Note
*vms_external
;
19823 /* PR binutils/15191
19824 Make sure that there is enough data to read. */
19825 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
19826 if (data_remaining
< min_notesz
)
19828 warn (ngettext ("Corrupt note: only %ld byte remains, "
19829 "not enough for a full note\n",
19830 "Corrupt note: only %ld bytes remain, "
19831 "not enough for a full note\n",
19833 (long) data_remaining
);
19836 data_remaining
-= min_notesz
;
19838 vms_external
= (Elf64_External_VMS_Note
*) external
;
19839 inote
.type
= BYTE_GET (vms_external
->type
);
19840 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
19841 inote
.namedata
= vms_external
->name
;
19842 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
19843 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
19844 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19845 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
19848 /* PR 17531: file: 3443835e. */
19849 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19850 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
19851 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
19852 || (size_t) (next
- inote
.descdata
) < inote
.descsz
19853 || ((size_t) (next
- inote
.descdata
)
19854 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
19856 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19857 (unsigned long) ((char *) external
- (char *) pnotes
));
19858 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19859 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
19863 external
= (Elf_External_Note
*) next
;
19865 /* Verify that name is null terminated. It appears that at least
19866 one version of Linux (RedHat 6.0) generates corefiles that don't
19867 comply with the ELF spec by failing to include the null byte in
19869 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
19871 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
19873 temp
= (char *) malloc (inote
.namesz
+ 1);
19876 error (_("Out of memory allocating space for inote name\n"));
19881 memcpy (temp
, inote
.namedata
, inote
.namesz
);
19882 inote
.namedata
= temp
;
19884 inote
.namedata
[inote
.namesz
] = 0;
19887 if (! process_note (& inote
, filedata
))
19900 process_corefile_note_segments (Filedata
* filedata
)
19902 Elf_Internal_Phdr
* segment
;
19904 bfd_boolean res
= TRUE
;
19906 if (! get_program_headers (filedata
))
19909 for (i
= 0, segment
= filedata
->program_headers
;
19910 i
< filedata
->file_header
.e_phnum
;
19913 if (segment
->p_type
== PT_NOTE
)
19914 if (! process_notes_at (filedata
, NULL
,
19915 (bfd_vma
) segment
->p_offset
,
19916 (bfd_vma
) segment
->p_filesz
,
19917 (bfd_vma
) segment
->p_align
))
19925 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
19927 Elf_External_Note
* pnotes
;
19928 Elf_External_Note
* external
;
19930 bfd_boolean res
= TRUE
;
19935 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19937 if (pnotes
== NULL
)
19941 end
= (char*) pnotes
+ length
;
19943 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19944 (unsigned long) offset
, (unsigned long) length
);
19946 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
19948 Elf_External_Note
* next
;
19949 Elf_Internal_Note inote
;
19951 inote
.type
= BYTE_GET (external
->type
);
19952 inote
.namesz
= BYTE_GET (external
->namesz
);
19953 inote
.namedata
= external
->name
;
19954 inote
.descsz
= BYTE_GET (external
->descsz
);
19955 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
19956 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19958 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
19960 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
19961 inote
.descdata
= inote
.namedata
;
19965 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
19967 if ( ((char *) next
> end
)
19968 || ((char *) next
< (char *) pnotes
))
19970 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19971 (unsigned long) ((char *) external
- (char *) pnotes
));
19972 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19973 inote
.type
, inote
.namesz
, inote
.descsz
);
19979 /* Prevent out-of-bounds indexing. */
19980 if ( inote
.namedata
+ inote
.namesz
> end
19981 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
19983 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19984 (unsigned long) ((char *) external
- (char *) pnotes
));
19985 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19986 inote
.type
, inote
.namesz
, inote
.descsz
);
19990 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
19992 if (! print_v850_note (& inote
))
19995 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19996 inote
.namesz
, inote
.descsz
);
20006 process_note_sections (Filedata
* filedata
)
20008 Elf_Internal_Shdr
* section
;
20010 unsigned int n
= 0;
20011 bfd_boolean res
= TRUE
;
20013 for (i
= 0, section
= filedata
->section_headers
;
20014 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
20017 if (section
->sh_type
== SHT_NOTE
)
20019 if (! process_notes_at (filedata
, section
,
20020 (bfd_vma
) section
->sh_offset
,
20021 (bfd_vma
) section
->sh_size
,
20022 (bfd_vma
) section
->sh_addralign
))
20027 if (( filedata
->file_header
.e_machine
== EM_V800
20028 || filedata
->file_header
.e_machine
== EM_V850
20029 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
20030 && section
->sh_type
== SHT_RENESAS_INFO
)
20032 if (! process_v850_notes (filedata
,
20033 (bfd_vma
) section
->sh_offset
,
20034 (bfd_vma
) section
->sh_size
))
20041 /* Try processing NOTE segments instead. */
20042 return process_corefile_note_segments (filedata
);
20048 process_notes (Filedata
* filedata
)
20050 /* If we have not been asked to display the notes then do nothing. */
20054 if (filedata
->file_header
.e_type
!= ET_CORE
)
20055 return process_note_sections (filedata
);
20057 /* No program headers means no NOTE segment. */
20058 if (filedata
->file_header
.e_phnum
> 0)
20059 return process_corefile_note_segments (filedata
);
20061 printf (_("No note segments present in the core file.\n"));
20065 static unsigned char *
20066 display_public_gnu_attributes (unsigned char * start
,
20067 const unsigned char * const end
)
20069 printf (_(" Unknown GNU attribute: %s\n"), start
);
20071 start
+= strnlen ((char *) start
, end
- start
);
20072 display_raw_attribute (start
, end
);
20074 return (unsigned char *) end
;
20077 static unsigned char *
20078 display_generic_attribute (unsigned char * start
,
20080 const unsigned char * const end
)
20083 return (unsigned char *) end
;
20085 return display_tag_value (tag
, start
, end
);
20089 process_arch_specific (Filedata
* filedata
)
20094 switch (filedata
->file_header
.e_machine
)
20097 case EM_ARC_COMPACT
:
20098 case EM_ARC_COMPACT2
:
20099 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
20100 display_arc_attribute
,
20101 display_generic_attribute
);
20103 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
20104 display_arm_attribute
,
20105 display_generic_attribute
);
20108 case EM_MIPS_RS3_LE
:
20109 return process_mips_specific (filedata
);
20112 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
20113 display_msp430x_attribute
,
20114 display_msp430_gnu_attribute
);
20117 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
20118 display_riscv_attribute
,
20119 display_generic_attribute
);
20122 return process_nds32_specific (filedata
);
20125 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20126 display_m68k_gnu_attribute
);
20130 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20131 display_power_gnu_attribute
);
20135 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20136 display_s390_gnu_attribute
);
20139 case EM_SPARC32PLUS
:
20141 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20142 display_sparc_gnu_attribute
);
20145 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
20146 display_tic6x_attribute
,
20147 display_generic_attribute
);
20150 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
20151 display_public_gnu_attributes
,
20152 display_generic_attribute
);
20157 get_file_header (Filedata
* filedata
)
20159 /* Read in the identity array. */
20160 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
20163 /* Determine how to read the rest of the header. */
20164 switch (filedata
->file_header
.e_ident
[EI_DATA
])
20169 byte_get
= byte_get_little_endian
;
20170 byte_put
= byte_put_little_endian
;
20173 byte_get
= byte_get_big_endian
;
20174 byte_put
= byte_put_big_endian
;
20178 /* For now we only support 32 bit and 64 bit ELF files. */
20179 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
20181 /* Read in the rest of the header. */
20184 Elf32_External_Ehdr ehdr32
;
20186 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20189 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
20190 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
20191 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
20192 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
20193 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
20194 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
20195 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
20196 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
20197 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
20198 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
20199 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
20200 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
20201 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
20205 Elf64_External_Ehdr ehdr64
;
20207 /* If we have been compiled with sizeof (bfd_vma) == 4, then
20208 we will not be able to cope with the 64bit data found in
20209 64 ELF files. Detect this now and abort before we start
20210 overwriting things. */
20211 if (sizeof (bfd_vma
) < 8)
20213 error (_("This instance of readelf has been built without support for a\n\
20214 64 bit data type and so it cannot read 64 bit ELF files.\n"));
20218 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20221 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
20222 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
20223 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
20224 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
20225 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
20226 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
20227 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
20228 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
20229 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
20230 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
20231 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
20232 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
20233 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
20236 if (filedata
->file_header
.e_shoff
)
20238 /* There may be some extensions in the first section header. Don't
20239 bomb if we can't read it. */
20241 get_32bit_section_headers (filedata
, TRUE
);
20243 get_64bit_section_headers (filedata
, TRUE
);
20250 close_file (Filedata
* filedata
)
20254 if (filedata
->handle
)
20255 fclose (filedata
->handle
);
20261 close_debug_file (void * data
)
20263 close_file ((Filedata
*) data
);
20267 open_file (const char * pathname
)
20269 struct stat statbuf
;
20270 Filedata
* filedata
= NULL
;
20272 if (stat (pathname
, & statbuf
) < 0
20273 || ! S_ISREG (statbuf
.st_mode
))
20276 filedata
= calloc (1, sizeof * filedata
);
20277 if (filedata
== NULL
)
20280 filedata
->handle
= fopen (pathname
, "rb");
20281 if (filedata
->handle
== NULL
)
20284 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20285 filedata
->file_name
= pathname
;
20287 if (! get_file_header (filedata
))
20290 if (filedata
->file_header
.e_shoff
)
20294 /* Read the section headers again, this time for real. */
20296 res
= get_32bit_section_headers (filedata
, FALSE
);
20298 res
= get_64bit_section_headers (filedata
, FALSE
);
20309 if (filedata
->handle
)
20310 fclose (filedata
->handle
);
20317 open_debug_file (const char * pathname
)
20319 return open_file (pathname
);
20322 /* Process one ELF object file according to the command line options.
20323 This file may actually be stored in an archive. The file is
20324 positioned at the start of the ELF object. Returns TRUE if no
20325 problems were encountered, FALSE otherwise. */
20328 process_object (Filedata
* filedata
)
20330 bfd_boolean have_separate_files
;
20334 if (! get_file_header (filedata
))
20336 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
20340 /* Initialise per file variables. */
20341 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
20342 filedata
->version_info
[i
] = 0;
20344 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
20345 filedata
->dynamic_info
[i
] = 0;
20346 filedata
->dynamic_info_DT_GNU_HASH
= 0;
20347 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
20349 /* Process the file. */
20351 printf (_("\nFile: %s\n"), filedata
->file_name
);
20353 /* Initialise the dump_sects array from the cmdline_dump_sects array.
20354 Note we do this even if cmdline_dump_sects is empty because we
20355 must make sure that the dump_sets array is zeroed out before each
20356 object file is processed. */
20357 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
20358 memset (filedata
->dump
.dump_sects
, 0,
20359 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20361 if (cmdline
.num_dump_sects
> 0)
20363 if (filedata
->dump
.num_dump_sects
== 0)
20364 /* A sneaky way of allocating the dump_sects array. */
20365 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
20367 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
20368 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
20369 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20372 if (! process_file_header (filedata
))
20375 if (! process_section_headers (filedata
))
20377 /* Without loaded section headers we cannot process lots of things. */
20378 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
20380 if (! do_using_dynamic
)
20381 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
20384 if (! process_section_groups (filedata
))
20385 /* Without loaded section groups we cannot process unwind. */
20388 res
= process_program_headers (filedata
);
20390 res
= process_dynamic_section (filedata
);
20392 if (! process_relocs (filedata
))
20395 if (! process_unwind (filedata
))
20398 if (! process_symbol_table (filedata
))
20401 if (! process_syminfo (filedata
))
20404 if (! process_version_sections (filedata
))
20407 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
20408 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
20410 have_separate_files
= FALSE
;
20412 if (! process_section_contents (filedata
))
20415 if (have_separate_files
)
20419 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
20421 if (! process_section_headers (d
->handle
))
20423 else if (! process_section_contents (d
->handle
))
20427 /* The file handles are closed by the call to free_debug_memory() below. */
20430 if (! process_notes (filedata
))
20433 if (! process_gnu_liblist (filedata
))
20436 if (! process_arch_specific (filedata
))
20439 free (filedata
->program_headers
);
20440 filedata
->program_headers
= NULL
;
20442 free (filedata
->section_headers
);
20443 filedata
->section_headers
= NULL
;
20445 free (filedata
->string_table
);
20446 filedata
->string_table
= NULL
;
20447 filedata
->string_table_length
= 0;
20449 free (filedata
->dump
.dump_sects
);
20450 filedata
->dump
.dump_sects
= NULL
;
20451 filedata
->dump
.num_dump_sects
= 0;
20453 free (filedata
->dynamic_strings
);
20454 filedata
->dynamic_strings
= NULL
;
20455 filedata
->dynamic_strings_length
= 0;
20457 free (filedata
->dynamic_symbols
);
20458 filedata
->dynamic_symbols
= NULL
;
20459 filedata
->num_dynamic_syms
= 0;
20461 free (filedata
->dynamic_syminfo
);
20462 filedata
->dynamic_syminfo
= NULL
;
20464 free (filedata
->dynamic_section
);
20465 filedata
->dynamic_section
= NULL
;
20467 while (filedata
->symtab_shndx_list
!= NULL
)
20469 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
20470 free (filedata
->symtab_shndx_list
);
20471 filedata
->symtab_shndx_list
= next
;
20474 free (filedata
->section_headers_groups
);
20475 filedata
->section_headers_groups
= NULL
;
20477 if (filedata
->section_groups
)
20479 struct group_list
* g
;
20480 struct group_list
* next
;
20482 for (i
= 0; i
< filedata
->group_count
; i
++)
20484 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
20491 free (filedata
->section_groups
);
20492 filedata
->section_groups
= NULL
;
20495 free_debug_memory ();
20500 /* Process an ELF archive.
20501 On entry the file is positioned just after the ARMAG string.
20502 Returns TRUE upon success, FALSE otherwise. */
20505 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
20507 struct archive_info arch
;
20508 struct archive_info nested_arch
;
20510 bfd_boolean ret
= TRUE
;
20514 /* The ARCH structure is used to hold information about this archive. */
20515 arch
.file_name
= NULL
;
20517 arch
.index_array
= NULL
;
20518 arch
.sym_table
= NULL
;
20519 arch
.longnames
= NULL
;
20521 /* The NESTED_ARCH structure is used as a single-item cache of information
20522 about a nested archive (when members of a thin archive reside within
20523 another regular archive file). */
20524 nested_arch
.file_name
= NULL
;
20525 nested_arch
.file
= NULL
;
20526 nested_arch
.index_array
= NULL
;
20527 nested_arch
.sym_table
= NULL
;
20528 nested_arch
.longnames
= NULL
;
20530 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
20531 filedata
->file_size
, is_thin_archive
,
20532 do_archive_index
) != 0)
20538 if (do_archive_index
)
20540 if (arch
.sym_table
== NULL
)
20541 error (_("%s: unable to dump the index as none was found\n"),
20542 filedata
->file_name
);
20545 unsigned long i
, l
;
20546 unsigned long current_pos
;
20548 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
20549 "in the symbol table)\n"),
20550 filedata
->file_name
, (unsigned long) arch
.index_num
,
20553 current_pos
= ftell (filedata
->handle
);
20555 for (i
= l
= 0; i
< arch
.index_num
; i
++)
20558 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
20561 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
20564 if (member_name
!= NULL
)
20566 char * qualified_name
20567 = make_qualified_name (&arch
, &nested_arch
,
20570 if (qualified_name
!= NULL
)
20572 printf (_("Contents of binary %s at offset "),
20574 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
20576 free (qualified_name
);
20578 free (member_name
);
20582 if (l
>= arch
.sym_size
)
20584 error (_("%s: end of the symbol table reached "
20585 "before the end of the index\n"),
20586 filedata
->file_name
);
20590 /* PR 17531: file: 0b6630b2. */
20591 printf ("\t%.*s\n",
20592 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
20593 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
20596 if (arch
.uses_64bit_indices
)
20601 if (l
< arch
.sym_size
)
20603 error (ngettext ("%s: %ld byte remains in the symbol table, "
20604 "but without corresponding entries in "
20605 "the index table\n",
20606 "%s: %ld bytes remain in the symbol table, "
20607 "but without corresponding entries in "
20608 "the index table\n",
20609 arch
.sym_size
- l
),
20610 filedata
->file_name
, arch
.sym_size
- l
);
20614 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
20616 error (_("%s: failed to seek back to start of object files "
20617 "in the archive\n"),
20618 filedata
->file_name
);
20624 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
20625 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
20626 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
20627 && !do_section_groups
&& !do_dyn_syms
)
20629 ret
= TRUE
; /* Archive index only. */
20638 char * qualified_name
;
20640 /* Read the next archive header. */
20641 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
20643 error (_("%s: failed to seek to next archive header\n"),
20648 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
20649 if (got
!= sizeof arch
.arhdr
)
20653 /* PR 24049 - we cannot use filedata->file_name as this will
20654 have already been freed. */
20655 error (_("%s: failed to read archive header\n"), arch
.file_name
);
20660 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
20662 error (_("%s: did not find a valid archive header\n"),
20668 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
20670 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
20671 if (filedata
->archive_file_size
& 01)
20672 ++filedata
->archive_file_size
;
20674 name
= get_archive_member_name (&arch
, &nested_arch
);
20677 error (_("%s: bad archive file name\n"), arch
.file_name
);
20681 namelen
= strlen (name
);
20683 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
20684 if (qualified_name
== NULL
)
20686 error (_("%s: bad archive file name\n"), arch
.file_name
);
20692 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
20694 /* This is a proxy for an external member of a thin archive. */
20695 Filedata
* member_filedata
;
20696 char * member_file_name
= adjust_relative_path
20697 (filedata
->file_name
, name
, namelen
);
20700 if (member_file_name
== NULL
)
20702 free (qualified_name
);
20707 member_filedata
= open_file (member_file_name
);
20708 if (member_filedata
== NULL
)
20710 error (_("Input file '%s' is not readable.\n"), member_file_name
);
20711 free (member_file_name
);
20712 free (qualified_name
);
20717 filedata
->archive_file_offset
= arch
.nested_member_origin
;
20718 member_filedata
->file_name
= qualified_name
;
20720 if (! process_object (member_filedata
))
20723 close_file (member_filedata
);
20724 free (member_file_name
);
20726 else if (is_thin_archive
)
20728 Filedata thin_filedata
;
20730 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
20732 /* PR 15140: Allow for corrupt thin archives. */
20733 if (nested_arch
.file
== NULL
)
20735 error (_("%s: contains corrupt thin archive: %s\n"),
20736 qualified_name
, name
);
20737 free (qualified_name
);
20744 /* This is a proxy for a member of a nested archive. */
20745 filedata
->archive_file_offset
20746 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
20748 /* The nested archive file will have been opened and setup by
20749 get_archive_member_name. */
20750 if (fseek (nested_arch
.file
, filedata
->archive_file_offset
,
20753 error (_("%s: failed to seek to archive member.\n"),
20754 nested_arch
.file_name
);
20755 free (qualified_name
);
20760 thin_filedata
.handle
= nested_arch
.file
;
20761 thin_filedata
.file_name
= qualified_name
;
20763 if (! process_object (& thin_filedata
))
20769 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
20770 filedata
->file_name
= qualified_name
;
20771 if (! process_object (filedata
))
20773 arch
.next_arhdr_offset
+= filedata
->archive_file_size
;
20774 /* Stop looping with "negative" archive_file_size. */
20775 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
20776 arch
.next_arhdr_offset
= -1ul;
20779 free (qualified_name
);
20783 if (nested_arch
.file
!= NULL
)
20784 fclose (nested_arch
.file
);
20785 release_archive (&nested_arch
);
20786 release_archive (&arch
);
20792 process_file (char * file_name
)
20794 Filedata
* filedata
= NULL
;
20795 struct stat statbuf
;
20796 char armag
[SARMAG
];
20797 bfd_boolean ret
= TRUE
;
20799 if (stat (file_name
, &statbuf
) < 0)
20801 if (errno
== ENOENT
)
20802 error (_("'%s': No such file\n"), file_name
);
20804 error (_("Could not locate '%s'. System error message: %s\n"),
20805 file_name
, strerror (errno
));
20809 if (! S_ISREG (statbuf
.st_mode
))
20811 error (_("'%s' is not an ordinary file\n"), file_name
);
20815 filedata
= calloc (1, sizeof * filedata
);
20816 if (filedata
== NULL
)
20818 error (_("Out of memory allocating file data structure\n"));
20822 filedata
->file_name
= file_name
;
20823 filedata
->handle
= fopen (file_name
, "rb");
20824 if (filedata
->handle
== NULL
)
20826 error (_("Input file '%s' is not readable.\n"), file_name
);
20831 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
20833 error (_("%s: Failed to read file's magic number\n"), file_name
);
20834 fclose (filedata
->handle
);
20839 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20841 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
20843 if (! process_archive (filedata
, FALSE
))
20846 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
20848 if ( ! process_archive (filedata
, TRUE
))
20853 if (do_archive_index
&& !check_all
)
20854 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20857 rewind (filedata
->handle
);
20858 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
20860 if (! process_object (filedata
))
20864 fclose (filedata
->handle
);
20865 free (filedata
->section_headers
);
20866 free (filedata
->program_headers
);
20867 free (filedata
->string_table
);
20868 free (filedata
->dump
.dump_sects
);
20871 free (ba_cache
.strtab
);
20872 ba_cache
.strtab
= NULL
;
20873 free (ba_cache
.symtab
);
20874 ba_cache
.symtab
= NULL
;
20875 ba_cache
.filedata
= NULL
;
20880 #ifdef SUPPORT_DISASSEMBLY
20881 /* Needed by the i386 disassembler. For extra credit, someone could
20882 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20886 print_address (unsigned int addr
, FILE * outfile
)
20888 fprintf (outfile
,"0x%8.8x", addr
);
20891 /* Needed by the i386 disassembler. */
20894 db_task_printsym (unsigned int addr
)
20896 print_address (addr
, stderr
);
20901 main (int argc
, char ** argv
)
20905 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20906 setlocale (LC_MESSAGES
, "");
20908 #if defined (HAVE_SETLOCALE)
20909 setlocale (LC_CTYPE
, "");
20911 bindtextdomain (PACKAGE
, LOCALEDIR
);
20912 textdomain (PACKAGE
);
20914 expandargv (&argc
, &argv
);
20916 parse_args (& cmdline
, argc
, argv
);
20918 if (optind
< (argc
- 1))
20919 /* When displaying information for more than one file,
20920 prefix the information with the file name. */
20922 else if (optind
>= argc
)
20924 /* Ensure that the warning is always displayed. */
20927 warn (_("Nothing to do.\n"));
20932 while (optind
< argc
)
20933 if (! process_file (argv
[optind
++]))
20936 free (cmdline
.dump_sects
);
20938 free (dump_ctf_symtab_name
);
20939 free (dump_ctf_strtab_name
);
20940 free (dump_ctf_parent_name
);
20942 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;